def preprocess_project(stage, name):
try:
user = stage.user.name
index = stage.index
except AttributeError:
user, index = stage.name.split('/')
if not is_project_cached(stage, name):
return dict(name=name, user=user, index=index)
setuptools_metadata = frozenset((
'author', 'author_email', 'classifiers', 'description', 'download_url',
'home_page', 'keywords', 'license', 'platform', 'summary'))
versions = get_sorted_versions(stage.list_versions_perstage(name))
result = dict(name=name)
for i, version in enumerate(versions):
verdata = stage.get_versiondata(name, version)
if not i:
result.update(verdata)
links = stage.get_linkstore_perstage(name, version).get_links(rel="doczip")
if links:
# we assume it has been unpacked
result['doc_version'] = version
result['+doczip'] = iter_doc_contents(stage, name, version)
break
else:
assert '+doczip' not in result
result[u'user'] = user
result[u'index'] = index
for key in setuptools_metadata:
if key in result:
value = result[key]
if value == 'UNKNOWN' or not value:
del result[key]
return result
def stable_versions(self):
versions = self.stage.list_versions(self.project)
if not versions:
raise HTTPNotFound("The project %s does not exist." % self.project)
versions = get_sorted_versions(versions, stable=True)
if not versions:
raise HTTPNotFound("The project %s has no stable release." % self.project)
return versions
def get_matching_versioninfo(self, pkgname, indexname):
req = next(pkg_resources.parse_requirements(pkgname))
projurl = self.current.get_project_url(
req.project_name, indexname=indexname).url
r = self.hub.http_api("get", projurl)
for version in get_sorted_versions(r.result):
if version not in req:
continue
return ViewLinkStore(projurl, r.result[version])
def preprocess_project(project):
stage = project.stage
pm = get_pluginmanager(stage.xom.config)
name = normalize_name(project.name)
try:
user = stage.user.name
index = stage.index
except AttributeError:
user, index = stage.name.split('/')
user = ensure_unicode(user)
index = ensure_unicode(index)
if not is_project_cached(stage, name):
result = dict(name=name, user=user, index=index)
pm.hook.devpiweb_modify_preprocess_project_result(project=project,
result=result)
return result
stage.offline = True
if not stage.has_project_perstage(name):
# project doesn't exist anymore
return
setuptools_metadata = frozenset(getattr(stage, 'metadata_keys', ()))
versions = get_sorted_versions(stage.list_versions_perstage(name))
result = dict(name=name)
for i, version in enumerate(versions):
if i == 0:
verdata = stage.get_versiondata_perstage(name, version)
result.update(verdata)
links = stage.get_linkstore_perstage(name,
version).get_links(rel="doczip")
if links:
docs = Docs(stage, name, version)
if docs.exists():
result['doc_version'] = version
result['+doczip'] = docs
break
else:
assert '+doczip' not in result
result[u'user'] = user
result[u'index'] = index
for key in setuptools_metadata:
if key in result:
value = result[key]
if value == 'UNKNOWN' or not value:
del result[key]
pm.hook.devpiweb_modify_preprocess_project_result(project=project,
result=result)
return result
def out_project(hub, reply, req):
data = reply.result
index = hub.current.index[len(hub.current.rooturl):]
num = 0
maxshow = 2
for version in get_sorted_versions(data):
if version not in req:
continue
if num > maxshow and not hub.args.all:
num += 1
continue
verdata = data[version]
if out_project_version_files(hub, reply.url, verdata, version, index):
num += 1
shadowing = data[version].get("+shadowing", [])
for verdata in shadowing:
if out_project_version_files(hub, reply.url, verdata, version, None):
num += 1
if not hub.args.all and num > (maxshow+1):
hub.info("%s older versions not shown, use --all to see" %
(num-maxshow-1))
def versions(self):
versions = self.stage.list_versions(self.project)
if not versions:
raise HTTPNotFound("The project %s does not exist." % self.project)
return get_sorted_versions(versions)
def project_get(context, request):
context = ContextWrapper(context)
try:
releaselinks = context.stage.get_releaselinks(context.verified_project)
stage_versions = context.stage.list_versions_perstage(context.verified_project)
except context.stage.UpstreamError as e:
log.error(e.msg)
raise HTTPBadGateway(e.msg)
version_info = {}
seen = set()
for release in releaselinks:
user, index = release.entrypath.split("/", 2)[:2]
name, version = release.project, release.version
if not version or version == 'XXX':
continue
seen_key = (user, index, name, version)
if seen_key in seen:
continue
version_info[version] = dict(
index_title="%s/%s" % (user, index),
index_url=request.stage_url(user, index),
title=version,
url=request.route_url(
"/{user}/{index}/{project}/{version}",
user=user, index=index, project=name, version=version),
docs=None,
_release=release)
seen.add(seen_key)
user = context.username
index = context.stage.index
index_title = "%s/%s" % (user, index)
name = context.verified_project
index_url = request.stage_url(user, index)
for version in stage_versions:
linkstore = context.stage.get_linkstore_perstage(name, version)
docs = get_docs_info(request, context.stage, linkstore)
if not docs:
continue
if version not in version_info:
version_info[version] = dict(
index_title=index_title,
index_url=index_url,
title=version,
url=request.route_url(
"/{user}/{index}/{project}/{version}",
user=user, index=index, project=name, version=version),
docs=docs,
_release=None)
else:
version_info[version]['docs'] = docs
versions = []
for version in get_sorted_versions(version_info):
versions.append(version_info[version])
if hasattr(context.stage, 'get_mirror_whitelist_info'):
whitelist_info = context.stage.get_mirror_whitelist_info(context.project)
else:
whitelist_info = dict(
has_mirror_base=context.stage.has_mirror_base(context.project),
blocked_by_mirror_whitelist=None)
return dict(
title="%s/: %s versions" % (context.stage.name, context.project),
blocked_by_mirror_whitelist=whitelist_info['blocked_by_mirror_whitelist'],
versions=versions)
def _stable_versions(self):
return get_sorted_versions(self._versions, stable=True)
def _versions(self):
return get_sorted_versions(self.stage.list_versions_perstage(
self.project),
stable=False)
def versions(self):
versions = self.stage.list_versions(self.name)
if not versions:
raise HTTPNotFound("The project %s does not exist." % self.name)
return get_sorted_versions(versions)
