Python models.Package类代码示例

def user_packages(request, user):
    """
    Retrieve a list of [role_name, package_name] for a given username.
    Role is either 'Maintainer' or 'Owner'.
    """
    session = DBSession()
    owned = Package.by_owner(session, user)
    maintained = Package.by_maintainer(session, user)
    owned = [('Owner', p.name) for p in owned]
    maintained = [('Maintainer', p.name) for p in maintained]
    return owned + maintained

    def test_by_name(self):
        from pyshop.models import Package
        pkg = Package.by_name(self.session, u'mirrored_package1')
        self.assertIsInstance(pkg, Package)
        self.assertEqual(pkg.id, 1)
        self.assertEqual(pkg.name, u'mirrored_package1')

        # Test case insensitivity
        pkg = Package.by_name(self.session, u'MirRored_pAckaGe1')
        self.assertIsInstance(pkg, Package)
        self.assertEqual(pkg.id, 1)
        self.assertEqual(pkg.name, u'mirrored_package1')

    def render(self):
        req = self.request
        page_no = 1
        page_size = 20
        if 'page_no' in req.matchdict:
            page_no = int(req.matchdict['page_no'])

        opts = {}
        if 'form.submitted' in req.params:
            opts['local_only'] = req.params.get('local_only', '0') == '1'
        else:
            opts['local_only'] = True

        opts['names'] = []
        opts['classifiers'] = []

        if 'form.submitted' in req.params or \
                req.params.get('classifier.added'):
            classifiers = [Classifier.by_id(self.session, id)
                           for id in set(req.params.getall('classifiers'))]
            names = req.params.getall('names')

            if req.params.get('classifier.added'):
                classifier = Classifier.by_name(self.session,
                                                req.params['classifier.added'])
                if classifier:
                    classifiers.append(classifier)
                else:
                    names.append(req.params['classifier.added'])
            opts['classifiers'] = classifiers
            opts['names'] = names

        package_count = Package.by_filter(self.session, opts, count='*')

        return {u'has_page': package_count > page_size,
                u'paging': {u'route': u'list_package_page',
                            u'qs': self.request.query_string,
                            u'kwargs': {},
                            u'max': int(
                                math.ceil(float(package_count) / page_size)),
                            u'no': page_no},
                u'package_count': package_count,
                u'packages': Package.by_filter(
                    self.session, opts,
                    limit=page_size, offset=page_size * (page_no - 1),
                    order_by=func.lower(Package.name)
                    ),
                u'filter': opts,
                u'classifiers': Classifier.all(self.session,
                                               order_by=Classifier.name)
                }

    def render(self):
        req = self.request
        page_no = 1
        page_size = 20
        if "page_no" in req.matchdict:
            page_no = int(req.matchdict["page_no"])

        opts = {}
        if "form.submitted" in req.params:
            opts["local_only"] = req.params.get("local_only", "0") == "1"
        else:
            opts["local_only"] = True

        opts["names"] = []
        opts["classifiers"] = []  # TODO: set defaults in settings

        if "form.submitted" in req.params or req.params.get("classifier.added"):
            classifiers = [Classifier.by_id(self.session, id) for id in set(req.params.getall("classifiers"))]
            names = req.params.getall("names")

            if req.params.get("classifier.added"):
                classifier = Classifier.by_name(self.session, req.params["classifier.added"])
                if classifier:
                    log.info("!" * 80)
                    log.info(classifier.__dict__)
                    classifiers.append(classifier)
                else:
                    names.append(req.params["classifier.added"])
            opts["classifiers"] = classifiers
            opts["names"] = names

        package_count = Package.by_filter(self.session, opts, count="*")

        return {
            u"has_page": package_count > page_size,
            u"paging": {
                u"route": u"list_package_page",
                u"qs": self.request.query_string,
                u"kwargs": {},
                u"max": int(math.ceil(float(package_count) / page_size)),
                u"no": page_no,
            },
            u"package_count": package_count,
            u"packages": Package.by_filter(
                self.session, opts, limit=page_size, offset=page_size * (page_no - 1), order_by=func.lower(Package.name)
            ),
            u"filter": opts,
            u"classifiers": Classifier.all(self.session, order_by=Classifier.name),
        }

def package_releases(request, package_name, show_hidden=False):
    """
    Retrieve a list of the releases registered for the given package_name.
    Returns a list with all version strings if show_hidden is True or
    only the non-hidden ones otherwise."""
    session = DBSession()
    package = Package.by_name(session, package_name)
    return [rel.version for rel in package.sorted_releases]

def list_packages(request):
    """
    Retrieve a list of the package names registered with the package index.
    Returns a list of name strings.
    """
    session = DBSession()
    names = [p.name for p in Package.all(session, order_by=Package.name)]
    return names

 def package_roles(self, package_name):
     """
     Retrieve a list of users and their attributes roles for a given
     package_name. Role is either 'Maintainer' or 'Owner'. 
     """
     session = DBSession()
     package = Package.by_name(session, package_name)
     owners = [('Owner', o.name) for o in package.owners]
     maintainers  = [('Maintainer', o.name) for o in package.maintainers]
     return owners + maintainers

    def render(self):

        package = Package.by_name(self.session, self.request.matchdict["package_name"])
        if not package:
            raise HTTPNotFound()

        if "release_version" in self.request.matchdict:
            release = Release.by_version(self.session, package.name, self.request.matchdict["release_version"])
        else:
            release = package.sorted_releases[0]

        return {u"package": package, u"release": release}

    def render(self):

        package = Package.by_name(self.session,
                                  self.request.matchdict['package_name'])
        if not package:
            raise HTTPNotFound()

        if 'release_version' in self.request.matchdict:
            release = Release.by_version(self.session, package.name,
                self.request.matchdict['release_version'])
        else:
            release = package.sorted_releases[0]

        return {u'package': package,
                u'release': release,
                }

    def render(self):

        package = Package.by_name(self.session,
                                  self.request.matchdict['package_name'])
        if not package:
            raise HTTPNotFound()

        if 'form.refresh_package' in self.request.params:
            package.update_at = None
            self.session.add(package)

        if 'release_version' in self.request.matchdict:
            release = Release.by_version(self.session, package.name,
                self.request.matchdict['release_version'])
        else:
            release = package.sorted_releases[0]

        return {u'package': package,
                u'release': release,
                }

 def test_get_mirrored(self):
     from pyshop.models import Package
     pkges = Package.get_mirrored(self.session)
     self.assertIsInstance(pkges, list)
     pkges = [pkg.name for pkg in pkges]
     self.assertEqual(pkges, [u'mirrored_package1', u'mirrored_package2'])

 def test_get_locals(self):
     from pyshop.models import Package
     pkges = Package.get_locals(self.session)
     self.assertIsInstance(pkges, list)
     pkges = [pkg.name for pkg in pkges]
     self.assertEqual(pkges, [u'local_package1'])

    def render(self):
        settings = self.request.registry.settings
        username = authenticated_userid(self.request)
        if not username:
             raise exc.HTTPForbidden()

        remote_user = User.by_login(self.session, username)
        if not remote_user:
            raise exc.HTTPForbidden()


        params = self.request.params

        if (asbool(settings['pyshop.upload.satanize'])
            and not re.match(settings['pyshop.upload.satanize.regex'],
                            params['version']
                            )):
            raise exc.HTTPForbidden()

        pkg = Package.by_name(self.session, params['name'])
        if pkg:
            auth = [user for user in pkg.owners + pkg.maintainers
                    if user == remote_user]
            if not auth:
                raise exc.HTTPForbidden()
        else:
            pkg = Package(name=params['name'], local=True)
            pkg.owners.append(remote_user)

        content = self.request.POST['content']
        input_file = content.file
        # rewrite the filename, do not use the posted one for security
        filename = u'%s-%s.%s' % (params['name'], params['version'],
                                  {u'sdist': u'tar.gz',
                                   u'bdist_egg': u'egg',
                                   u'bdist_msi': u'msi',
                                   u'bdist_dmg': u'zip', # XXX or gztar ?
                                   u'bdist_rpm': u'rpm',
                                   u'bdist_dumb': u'msi',
                                   u'bdist_wininst': u'exe',
                                   }[params['filetype']])
        dir_ = os.path.join(settings['pyshop.repository'],
                            filename[0].lower())

        if not os.path.exists(dir_):
            os.mkdir(dir_, 0750)

        filepath = os.path.join(dir_, filename)
        while os.path.exists(filepath):
            log.warn('File %s exists but new upload self.request, deleting'
                     % filepath)
            os.unlink(filepath)

        size = 0
        with open(filepath, 'wb') as output_file:
            input_file.seek(0)
            while True:
                data = input_file.read(2<<16)
                if not data:
                    break
                size += len(data)
                output_file.write(data)


        release = Release.by_version(self.session, pkg.name,
                                     params['version'])
        if not release:
            release = Release(package=pkg,
                              version=params['version'],
                              summary=params.get('summary'),
                              author=remote_user,
                              home_page=params.get('home_page'),
                              license=params.get('license'),
                              description=params.get('description'),
                              keywords=params.get('keywords'),
                              platform=params.get('platform'),
                              download_url=params.get('download_url'),
                              docs_url=params.get('docs_url'),
                              )

        classifiers = params.getall('classifiers')
        for name in classifiers:
            classifier = Classifier.by_name(self.session, name)
            while classifier:
                if classifier not in release.classifiers:
                    release.classifiers.append(classifier)
                if classifier not in pkg.classifiers:
                    pkg.classifiers.append(classifier)
                classifier = classifier.parent

        rfile = ReleaseFile.by_filename(self.session, release, filename)
        if not rfile:
            rfile = ReleaseFile(release=release,
                                filename=filename,
                                size=size,
                                md5_digest=params.get('md5_digest'),
                                package_type=params['filetype'],
                                python_version=params.get('pyversion'),
                                comment_text=params.get('comment'),
                                )
#.........这里部分代码省略.........

 def test_by_maintainer(self):
     from pyshop.models import Package
     pkges = Package.by_maintainer(self.session, u'janedoe')
     self.assertIsInstance(pkges, list)
     pkges = [pkg.name for pkg in pkges]
     self.assertEqual(pkges, [u'mirrored_package2'])

    def render(self):
        settings = self.request.registry.settings
        if not self.user:
            raise exc.HTTPForbidden()

        params = self.request.params

        if (asbool(settings['pyshop.upload.sanitize'])
            and not re.match(settings['pyshop.upload.sanitize.regex'],
                             params['version']
                             )):
            raise exc.HTTPForbidden()

        pkg = Package.by_name(self.session, params['name'])
        if pkg and pkg.local:
            auth = [user for user in pkg.owners + pkg.maintainers
                    if user == self.user]
            if not auth:
                raise exc.HTTPForbidden()
        elif not pkg:
            pkg = Package(name=params['name'], local=True)
            pkg.owners.append(self.user)

        content = self.request.POST['content']
        input_file = content.file

        if asbool(settings.get('pyshop.upload.rewrite_filename', '1')):
            # rewrite the filename, do not use the posted one for security
            filename = self._guess_filename(params, content.filename)
        else:
            filename = content.filename

        dir_ = os.path.join(settings['pyshop.repository'],
                            filename[0].lower())

        if not os.path.exists(dir_):
            os.makedirs(dir_, 0o750)

        filepath = os.path.join(dir_, filename)
        while os.path.exists(filepath):
            log.warning('File %s exists but new upload self.request, deleting'
                        % filepath)
            os.unlink(filepath)

        size = 0
        with open(filepath, 'wb') as output_file:
            input_file.seek(0)
            while True:
                data = input_file.read(2 << 16)
                if not data:
                    break
                size += len(data)
                output_file.write(data)

        release = Release.by_version(self.session, pkg.name,
                                     params['version'])
        if not release:
            release = Release(package=pkg,
                              version=params['version'],
                              summary=params.get('summary'),
                              author=self.user,
                              home_page=params.get('home_page'),
                              license=params.get('license'),
                              description=params.get('description'),
                              keywords=params.get('keywords'),
                              platform=params.get('platform'),
                              download_url=params.get('download_url'),
                              docs_url=params.get('docs_url'),
                              )

        classifiers = params.getall('classifiers')
        for name in classifiers:
            classifier = Classifier.by_name(self.session, name)
            while classifier:
                if classifier not in release.classifiers:
                    release.classifiers.append(classifier)
                if classifier not in pkg.classifiers:
                    pkg.classifiers.append(classifier)
                classifier = classifier.parent

        rfile = ReleaseFile.by_filename(self.session, release, filename)
        if not rfile:
            rfile = ReleaseFile(release=release,
                                filename=filename,
                                size=size,
                                md5_digest=params.get('md5_digest'),
                                package_type=params['filetype'],
                                python_version=params.get('pyversion'),
                                comment_text=params.get('comment'),
                                )

        self.session.add(rfile)
        self.session.add(release)
        pkg.update_at = func.now()
        self.session.add(pkg)
        return {'release_file': rfile}