def main(input_args):
"""Parse input and run the program"""
short_opts = "hai"
long_opts = ('help', 'all', 'ignore-l10n')
try:
module_opts, queries = gnu_getopt(input_args, short_opts, long_opts)
except GetoptError as err:
sys.stderr.write(pp.error("Module %s" % err))
print()
print_help(with_description=False)
sys.exit(2)
parse_module_options(module_opts)
if not queries:
print_help()
sys.exit(2)
#
# Output
#
first_run = True
legend_printed = False
for query in (Query(x) for x in queries):
if not first_run:
print()
if QUERY_OPTS["all_versions"]:
matches = query.find(include_masked=True)
else:
matches = [query.find_best()]
if not any(matches):
raise errors.GentoolkitNoMatches(query)
matches.sort()
global_usedesc = get_global_useflags()
for pkg in matches:
output = get_output_descriptions(pkg, global_usedesc)
if output:
if CONFIG['verbose']:
if not legend_printed:
print_legend()
legend_printed = True
print((" * Found these USE flags for %s:" %
pp.cpv(str(pkg.cpv))))
print(pp.emph(" U I"))
display_useflags(output)
else:
if CONFIG['verbose']:
sys.stderr.write(
pp.warn("No USE flags found for %s" % pp.cpv(pkg.cpv))
)
first_run = False
def _format_values(self, key, values):
"""Format entry values ie. USE flags, keywords,...
@type key: str
@param key: a pre-formatted cpv
@type values: list of pre-formatted strings
@param values: ['flag1', 'flag2',...]
@rtype: str
@return: formatted options string
"""
result = []
if self.cpv_width > 1:
_cpv = pp.cpv(key + "." * (self.cpv_width - len(key)))
if not len(values):
return _cpv
self.twrap.initial_indent = _cpv
self.twrap.subsequent_indent = " " * (self.cpv_width + 1)
else:
_cpv = pp.cpv(key + " ")
if not len(values):
return _cpv
self.twrap.initial_indent = _cpv
self.twrap.subsequent_indent = " " * (len(key) + 1)
result.append(self.twrap.fill(values))
return "\n".join(result)
def main(input_args):
"""Parse input and run the program"""
short_opts = "hai"
long_opts = ('help', 'all', 'ignore-linguas')
try:
module_opts, queries = gnu_getopt(input_args, short_opts, long_opts)
except GetoptError as err:
sys.stderr.write(pp.error("Module %s" % err))
print()
print_help(with_description=False)
sys.exit(2)
parse_module_options(module_opts)
if not queries:
print_help()
sys.exit(2)
#
# Output
#
first_run = True
legend_printed = False
for query in (Query(x) for x in queries):
if not first_run:
print()
if QUERY_OPTS["all_versions"]:
matches = query.find(include_masked=True)
else:
matches = [query.find_best()]
if not any(matches):
raise errors.GentoolkitNoMatches(query)
matches.sort()
global_usedesc = get_global_useflags()
for pkg in matches:
output = get_output_descriptions(pkg, global_usedesc)
if output:
if CONFIG['verbose']:
if not legend_printed:
print_legend()
legend_printed = True
print((" * Found these USE flags for %s:" %
pp.cpv(str(pkg.cpv))))
print(pp.emph(" U I"))
display_useflags(output)
else:
if CONFIG['verbose']:
sys.stderr.write(
pp.warn("No USE flags found for %s" % pp.cpv(pkg.cpv))
)
first_run = False
def make_depgraph(pkg, printer_fn):
"""Create and display depgraph for each package."""
print()
if CONFIG["verbose"]:
pp.uprint(" * " + pp.subsection("dependency graph for ") + pp.cpv(str(pkg.cpv)))
else:
pp.uprint("%s:" % pkg.cpv)
# Print out the first package
printer_fn(0, pkg, None, initial_pkg=True)
deps = pkg.deps.graph_depends(
max_depth=QUERY_OPTS["depth"],
printer_fn=printer_fn,
# Use this to set this pkg as the graph's root; better way?
result=[(0, pkg)],
)
if CONFIG["verbose"]:
pkgname = pp.cpv(str(pkg.cpv))
n_packages = pp.number(str(len(deps)))
max_seen = pp.number(str(max(x[0] for x in deps)))
info = "[ %s stats: packages (%s), max depth (%s) ]"
pp.uprint(info % (pkgname, n_packages, max_seen))
def result(self, cp, version, urls, handler, confidence):
from euscan.version import get_version_type
cpv = '%s-%s' % (cp, version)
urls = ' '.join(
transform_url(self.config, cpv, url) for url in urls.split()
)
if self.config['format'] in ['json', 'dict']:
_curr = self.queries[self.current_query]
_curr["result"].append(
{
"version": version,
"urls": urls.split(),
"handler": handler,
"confidence": confidence,
"type": get_version_type(version)
}
)
else:
if not self.config['quiet']:
print "Upstream Version:", pp.number("%s" % version),
print pp.path(" %s" % urls)
else:
print pp.cpv("%s-%s" % (cp, version)) + ":", pp.path(urls)
def _format_values(self, key, values): """Format entry values ie. USE flags, keywords,... @type key: str @param key: a pre-formatted cpv @type values: list of pre-formatted strings @param values: ['flag1', 'flag2',...] @rtype: str @return: formatted options string """ result = [] if self.cpv_width > 1: _cpv = pp.cpv(key+'.'*(self.cpv_width-len(key))) if not len(values): return _cpv self.twrap.initial_indent = _cpv self.twrap.subsequent_indent = " " * (self.cpv_width+1) else: _cpv = pp.cpv(key+' ') if not len(values): return _cpv self.twrap.initial_indent = _cpv self.twrap.subsequent_indent = " " * (len(key)+1) result.append(self.twrap.fill(values)) return '\n'.join(result)
def make_depgraph(pkg, printer_fn):
"""Create and display depgraph for each package."""
print()
if CONFIG['verbose']:
pp.uprint(" * " + pp.subsection("dependency graph for ") +
pp.cpv(str(pkg.cpv)))
else:
pp.uprint("%s:" % pkg.cpv)
# Print out the first package
printer_fn(0, pkg, None, initial_pkg=True)
deps = pkg.deps.graph_depends(
max_depth=QUERY_OPTS['depth'],
printer_fn=printer_fn,
# Use this to set this pkg as the graph's root; better way?
result=[(0, pkg)])
if CONFIG['verbose']:
pkgname = pp.cpv(str(pkg.cpv))
n_packages = pp.number(str(len(deps)))
max_seen = pp.number(str(max(x[0] for x in deps)))
info = "[ %s stats: packages (%s), max depth (%s) ]"
pp.uprint(info % (pkgname, n_packages, max_seen))
def print_keyword_verbose(key, stability, default, count, pkgs):
"""Verbosely prints a set of keywords info. including the pkgs
using them.
"""
_pkgs = pkgs[:]
_key = pp.keyword((stability + key), stable=(stability == " "), hard_masked=stability == "-")
cpv = _pkgs.pop(0)
print(_key, "." * (20 - len(key)), default, pp.number(count), pp.cpv(cpv))
while _pkgs:
cpv = _pkgs.pop(0)
print(" " * 37 + pp.cpv(cpv))
def print_keyword_verbose(self, key, stability, default, count, pkgs):
"""Verbosely prints a set of keywords info. including the pkgs
using them.
"""
_pkgs = pkgs[:]
_key = (pp.keyword((stability+key),stable=(stability==" "),
hard_masked=stability=="-"))
cpv = _pkgs.pop(0)
print(self.prepend + _key,'.'*(20-len(key)), default, pp.number(count),
pp.cpv(cpv))
while _pkgs:
cpv = _pkgs.pop(0)
print(' '*37 + pp.cpv(cpv))
def print_use_verbose(key, active, default, count, pkgs):
"""Verbosely prints a set of use flag info. including the pkgs
using them.
"""
_pkgs = pkgs[:]
if active in ["+", "-"]:
_key = pp.useflag((active + key), active == "+")
else:
_key = " " + key
cpv = _pkgs.pop(0)
print(_key, "." * (35 - len(key)), default, pp.number(count), pp.cpv(cpv))
while _pkgs:
cpv = _pkgs.pop(0)
print(" " * 52 + pp.cpv(cpv))
def print_use_verbose(key, active, default, count, pkgs):
"""Verbosely prints a set of use flag info. including the pkgs
using them.
"""
_pkgs = pkgs[:]
if active in ["+", "-"]:
_key = pp.useflag((active + key), active == "+")
else:
_key = (" " + key)
cpv = _pkgs.pop(0)
print(_key, '.' * (35 - len(key)), default, pp.number(count),
pp.cpv(cpv))
while _pkgs:
cpv = _pkgs.pop(0)
print(' ' * 52 + pp.cpv(cpv))
def result(self, cp, version, url, handler, confidence):
from euscan.helpers import get_version_type
if self.config['format']:
_curr = self.queries[self.current_query]
_curr["result"].append(
{"version": version, "urls": [url], "handler": handler,
"confidence": confidence, "type": get_version_type(version)}
)
else:
if not self.config['quiet']:
print "Upstream Version:", pp.number("%s" % version),
print pp.path(" %s" % url)
else:
print pp.cpv("%s-%s" % (cp, version)) + ":", pp.path(url)
def display_size(match_set):
"""Display the total size of all accessible files owned by packages.
@type match_set: list
@param match_set: package cat/pkg-ver strings
"""
for pkg in match_set:
size, files, uncounted = pkg.size()
if CONFIG['verbose']:
pp.uprint(" * %s" % pp.cpv(str(pkg.cpv)))
print("Total files : %s".rjust(25) % pp.number(str(files)))
if uncounted:
print(("Inaccessible files : %s".rjust(25) %
pp.number(str(uncounted))))
if QUERY_OPTS["size_in_bytes"]:
size_str = pp.number(str(size))
else:
size_str = "%s %s" % format_bytes(size)
print("Total size : %s".rjust(25) % size_str)
else:
info = "%s: total(%d), inaccessible(%d), size(%s)"
pp.uprint(info % (str(pkg.cpv), files, uncounted, size))
def result(self, cp, version, urls, handler, confidence):
from euscan.version import get_version_type
cpv = '%s-%s' % (cp, version)
urls = ' '.join(
transform_url(self.config, cpv, url) for url in urls.split()
)
if self.config['format'] in ['json', 'dict']:
_curr = self.queries[self.current_query]
_curr["result"].append(
{
"version": version,
"urls": urls.split(),
"handler": handler,
"confidence": confidence,
"type": get_version_type(version)
}
)
else:
if not self.config['quiet']:
print("Upstream Version:", pp.number("%s" % version), end=' ')
print(pp.path(" %s" % urls))
else:
print(pp.cpv("%s-%s" % (cp, version)) + ":", pp.path(urls))
def display_useflags(output):
"""Print USE flag descriptions and statuses.
@type output: list
@param output: [(inuse, inused, flag, desc, restrict), ...]
inuse (int) = 0 or 1; if 1, flag is set in make.conf
inused (int) = 0 or 1; if 1, package is installed with flag enabled
flag (str) = the name of the USE flag
desc (str) = the flag's description
restrict (str) = corresponds to the text of restrict in metadata
"""
maxflag_len = len(max([t[2] for t in output], key=len))
twrap = TextWrapper()
twrap.width = CONFIG['termWidth']
twrap.subsequent_indent = " " * (maxflag_len + 8)
markers = ("-", "+")
color = (partial(pp.useflag,
enabled=False), partial(pp.useflag, enabled=True))
for in_makeconf, in_installed, flag, desc, restrict in output:
if CONFIG['verbose']:
flag_name = ""
if in_makeconf != in_installed:
flag_name += pp.emph(
" %s %s" % (markers[in_makeconf], markers[in_installed]))
else:
flag_name += (" %s %s" %
(markers[in_makeconf], markers[in_installed]))
flag_name += " " + color[in_makeconf](flag.ljust(maxflag_len))
flag_name += " : "
# Strip initial whitespace at the start of the description
# Bug 432530
if desc:
desc = desc.lstrip()
# print description
if restrict:
restrict = "(%s %s)" % (pp.emph("Restricted to"),
pp.cpv(restrict))
twrap.initial_indent = flag_name
pp.uprint(twrap.fill(restrict))
if desc:
twrap.initial_indent = twrap.subsequent_indent
pp.uprint(twrap.fill(desc))
else:
print(" : <unknown>")
else:
if desc:
twrap.initial_indent = flag_name
desc = twrap.fill(desc)
pp.uprint(desc)
else:
twrap.initial_indent = flag_name
print(twrap.fill("<unknown>"))
else:
pp.uprint(markers[in_makeconf] + flag)
def display_size(match_set):
"""Display the total size of all accessible files owned by packages.
@type match_set: list
@param match_set: package cat/pkg-ver strings
"""
for pkg in match_set:
size, files, uncounted = pkg.size()
if CONFIG['verbose']:
pp.uprint(" * %s" % pp.cpv(str(pkg.cpv)))
print("Total files : %s".rjust(25) % pp.number(str(files)))
if uncounted:
print(("Inaccessible files : %s".rjust(25) %
pp.number(str(uncounted))))
if QUERY_OPTS["size_in_bytes"]:
size_str = pp.number(str(size))
else:
size_str = "%s %s" % format_bytes(size)
print("Total size : %s".rjust(25) % size_str)
else:
info = "%s: total(%d), inaccessible(%d), size(%s)"
pp.uprint(info % (str(pkg.cpv), files, uncounted, size))
def print_verbose(self, pkg, cfile):
"Format for full output."
file_str = pp.path(format_filetype(cfile, pkg.parsed_contents()[cfile]))
if self.name_only:
name = pkg.cp
else:
name = str(pkg.cpv)
pp.uprint(pp.cpv(name), "(" + file_str + ")")
def print_verbose(self, pkg, cfile):
"Format for full output."
file_str = pp.path(format_filetype(cfile, pkg.parsed_contents()[cfile]))
if self.name_only:
name = pkg.cp
else:
name = str(pkg.cpv)
pp.uprint(pp.cpv(name), "(" + file_str + ")")
def depgraph_printer(depth,
pkg,
dep,
no_use=False,
no_atom=False,
no_indent=False,
initial_pkg=False,
no_mask=False):
"""Display L{gentoolkit.dependencies.Dependencies.graph_depends} results.
@type depth: int
@param depth: depth of indirection, used to calculate indent
@type pkg: L{gentoolkit.package.Package}
@param pkg: "best match" package matched by B{dep}
@type dep: L{gentoolkit.atom.Atom}
@param dep: dependency that matched B{pkg}
@type no_use: bool
@param no_use: don't output USE flags
@type no_atom: bool
@param no_atom: don't output dep atom
@type no_indent: bool
@param no_indent: don't output indent based on B{depth}
@type initial_pkg: bool
@param initial_pkg: somewhat of a hack used to print the root package of
the graph with absolutely no indent
"""
indent = '' if no_indent or initial_pkg else ' ' + (' ' * depth)
decorator = '[%3d] ' % depth if no_indent else '`-- '
use = ''
atom = ''
mask = ''
try:
if not no_atom:
if dep.operator == '=*':
atom += ' (=%s*)' % dep.cpv
else:
atom += ' (%s%s)' % (dep.operator, dep.cpv)
if not no_use and dep is not None and dep.use:
use = ' [%s]' % ' '.join(
pp.useflag(x, enabled=True) for x in dep.use.tokens)
except AttributeError:
# 'NoneType' object has no attribute 'atom'
pass
if pkg and not no_mask:
mask = pkg.mask_status()
if not mask:
mask = [
determine_keyword(portage.settings["ARCH"],
portage.settings["ACCEPT_KEYWORDS"],
pkg.environment('KEYWORDS'))
]
mask = pp.masking(mask)
try:
pp.uprint(' '.join(
(indent, decorator, pp.cpv(str(pkg.cpv)), atom, mask, use)))
except AttributeError:
# 'NoneType' object has no attribute 'cpv'
pp.uprint(''.join((indent, decorator, "(no match for %r)" % dep.atom)))
def format_cpv(self, attr=None): if attr is None: value = self.pkg.cpv else: value = getattr(self.pkg, attr) if self._do_format: return pp.cpv(value) else: return value
def scan_upstream(query):
matches = Query(query).find(
include_masked=True,
in_installed=False
)
if not matches:
sys.stderr.write(pp.warn("No package matching '%s'" % pp.pkgquery(query)))
return []
matches = sorted(matches)
pkg = matches.pop()
while '9999' in pkg.version and len(matches):
pkg = matches.pop()
if not pkg:
sys.stderr.write(pp.warn("Package '%s' only have a dev version (9999)"
% pp.pkgquery(pkg.cp)))
return []
if pkg.cp in BLACKLIST_PACKAGES:
sys.stderr.write(pp.warn("Package '%s' is blacklisted" % pp.pkgquery(pkg.cp)))
return []
if not CONFIG['quiet']:
pp.uprint(" * %s [%s]" % (pp.cpv(pkg.cpv), pp.section(pkg.repo_name())))
pp.uprint()
ebuild_path = pkg.ebuild_path()
if ebuild_path:
pp.uprint('Ebuild: ' + pp.path(os.path.normpath(ebuild_path)))
pp.uprint('Repository: ' + pkg.repo_name())
pp.uprint('Homepage: ' + pkg.environment("HOMEPAGE"))
pp.uprint('Description: ' + pkg.environment("DESCRIPTION"))
cpv = pkg.cpv
metadata = {
"EAPI" : port_settings["EAPI"],
"SRC_URI" : pkg.environment("SRC_URI", False),
}
use = frozenset(port_settings["PORTAGE_USE"].split())
try:
alist = porttree._parse_uri_map(cpv, metadata, use=use)
aalist = porttree._parse_uri_map(cpv, metadata)
except Exception as e:
sys.stderr.write(pp.warn("%s\n" % str(e)))
sys.stderr.write(pp.warn("Invalid SRC_URI for '%s'" % pp.pkgquery(cpv)))
return []
if "mirror" in portage.settings.features:
urls = aalist
else:
urls = alist
return scan_upstream_urls(pkg.cpv, urls)
def format_cpv(self, attr=None):
if attr is None:
value = self.pkg.cpv
else:
value = getattr(self.pkg, attr)
if self._do_format:
return pp.cpv(value)
else:
return value
def main(input_args):
"""Parse input and run the program"""
# -e, --exact-name is legacy option. djanderson '09
short_opts = "hemstf:"
long_opts = ('help', 'exact-name', 'md5sum', 'timestamp', 'type', 'tree',
'filter=')
try:
module_opts, queries = gnu_getopt(input_args, short_opts, long_opts)
except GetoptError as err:
sys.stderr.write(pp.error("Module %s" % err))
print()
print_help(with_description=False)
sys.exit(2)
parse_module_options(module_opts)
if not queries:
print_help()
sys.exit(2)
# Turn off filtering for tree output
if QUERY_OPTS["output_tree"]:
QUERY_OPTS["type_filter"] = None
#
# Output files
#
first_run = True
for query in queries:
if not first_run:
print()
matches = Query(query).smart_find(**QUERY_OPTS)
if not matches:
sys.stderr.write(
pp.error("No matching packages found for %s" % query)
)
matches.sort()
for pkg in matches:
if CONFIG['verbose']:
pp.uprint(" * Contents of %s:" % pp.cpv(str(pkg.cpv)))
contents = pkg.parsed_contents()
display_files(filter_contents(contents))
first_run = False
def main(input_args):
"""Parse input and run the program"""
# -e, --exact-name is legacy option. djanderson '09
short_opts = "hemstf:"
long_opts = ('help', 'exact-name', 'md5sum', 'timestamp', 'type', 'tree',
'filter=')
try:
module_opts, queries = gnu_getopt(input_args, short_opts, long_opts)
except GetoptError as err:
sys.stderr.write(pp.error("Module %s" % err))
print()
print_help(with_description=False)
sys.exit(2)
parse_module_options(module_opts)
if not queries:
print_help()
sys.exit(2)
# Turn off filtering for tree output
if QUERY_OPTS["output_tree"]:
QUERY_OPTS["type_filter"] = None
#
# Output files
#
first_run = True
for query in queries:
if not first_run:
print()
matches = Query(query).smart_find(**QUERY_OPTS)
if not matches:
sys.stderr.write(
pp.error("No matching packages found for %s" % query))
matches.sort()
for pkg in matches:
if CONFIG['verbose']:
pp.uprint(" * Contents of %s:" % pp.cpv(str(pkg.cpv)))
contents = pkg.parsed_contents()
display_files(filter_contents(contents))
first_run = False
def depgraph_printer(depth, pkg, dep, no_use=False, no_atom=False, no_indent=False, initial_pkg=False, no_mask=False):
"""Display L{gentoolkit.dependencies.Dependencies.graph_depends} results.
@type depth: int
@param depth: depth of indirection, used to calculate indent
@type pkg: L{gentoolkit.package.Package}
@param pkg: "best match" package matched by B{dep}
@type dep: L{gentoolkit.atom.Atom}
@param dep: dependency that matched B{pkg}
@type no_use: bool
@param no_use: don't output USE flags
@type no_atom: bool
@param no_atom: don't output dep atom
@type no_indent: bool
@param no_indent: don't output indent based on B{depth}
@type initial_pkg: bool
@param initial_pkg: somewhat of a hack used to print the root package of
the graph with absolutely no indent
"""
indent = "" if no_indent or initial_pkg else " " + (" " * depth)
decorator = "[%3d] " % depth if no_indent else "`-- "
use = ""
atom = ""
mask = ""
try:
if not no_atom:
if dep.operator == "=*":
atom += " (=%s*)" % dep.cpv
else:
atom += " (%s%s)" % (dep.operator, dep.cpv)
if not no_use and dep is not None and dep.use:
use = " [%s]" % " ".join(pp.useflag(x, enabled=True) for x in dep.use.tokens)
except AttributeError:
# 'NoneType' object has no attribute 'atom'
pass
if pkg and not no_mask:
mask = pkg.mask_status()
if not mask:
mask = [
determine_keyword(
portage.settings["ARCH"], portage.settings["ACCEPT_KEYWORDS"], pkg.environment("KEYWORDS")
)
]
mask = pp.masking(mask)
try:
pp.uprint(" ".join((indent, decorator, pp.cpv(str(pkg.cpv)), atom, mask, use)))
except AttributeError:
# 'NoneType' object has no attribute 'cpv'
pp.uprint("".join((indent, decorator, "(no match for %r)" % dep.atom)))
def display_useflags(output):
"""Print USE flag descriptions and statuses.
@type output: list
@param output: [(inuse, inused, flag, desc, restrict), ...]
inuse (int) = 0 or 1; if 1, flag is set in make.conf
inused (int) = 0 or 1; if 1, package is installed with flag enabled
flag (str) = the name of the USE flag
desc (str) = the flag's description
restrict (str) = corresponds to the text of restrict in metadata
"""
maxflag_len = len(max([t[2] for t in output], key=len))
twrap = TextWrapper()
twrap.width = CONFIG['termWidth']
twrap.subsequent_indent = " " * (maxflag_len + 8)
markers = ("-", "+")
color = (
partial(pp.useflag, enabled=False), partial(pp.useflag, enabled=True)
)
for in_makeconf, in_installed, flag, desc, restrict in output:
if CONFIG['verbose']:
flag_name = ""
if in_makeconf != in_installed:
flag_name += pp.emph(" %s %s" %
(markers[in_makeconf], markers[in_installed]))
else:
flag_name += (" %s %s" %
(markers[in_makeconf], markers[in_installed]))
flag_name += " " + color[in_makeconf](flag.ljust(maxflag_len))
flag_name += " : "
# Strip initial whitespace at the start of the description
# Bug 432530
if desc:
desc = desc.lstrip()
# print description
if restrict:
restrict = "(%s %s)" % (pp.emph("Restricted to"),
pp.cpv(restrict))
twrap.initial_indent = flag_name
pp.uprint(twrap.fill(restrict))
if desc:
twrap.initial_indent = twrap.subsequent_indent
pp.uprint(twrap.fill(desc))
else:
print(" : <unknown>")
else:
if desc:
twrap.initial_indent = flag_name
desc = twrap.fill(desc)
pp.uprint(desc)
else:
twrap.initial_indent = flag_name
print(twrap.fill("<unknown>"))
else:
pp.uprint(markers[in_makeconf] + flag)
def call_format_functions(best_match, matches):
"""Call information gathering functions and display the results."""
if CONFIG['verbose']:
repo = best_match.repo_name()
pp.uprint(" * %s [%s]" % (pp.cpv(best_match.cp), pp.section(repo)))
got_opts = False
if any(QUERY_OPTS.values()):
# Specific information requested, less formatting
got_opts = True
if QUERY_OPTS["herd"] or not got_opts:
herds = best_match.metadata.herds(include_email=True)
if any(not h[0] for h in herds):
print(pp.warn("The packages metadata.xml has an empty <herd> tag"),
file=sys.stderr)
herds = [x for x in herds if x[0]]
herds = format_herds(herds)
if QUERY_OPTS["herd"]:
print_sequence(format_list(herds))
else:
for herd in herds:
pp.uprint(format_line(herd, "Herd: ", " " * 13))
if QUERY_OPTS["maintainer"] or not got_opts:
maints = format_maintainers(best_match.metadata.maintainers())
if QUERY_OPTS["maintainer"]:
print_sequence(format_list(maints))
else:
if not maints:
pp.uprint(format_line([], "Maintainer: ", " " * 13))
else:
for maint in maints:
pp.uprint(format_line(maint, "Maintainer: ", " " * 13))
if QUERY_OPTS["upstream"] or not got_opts:
upstream = format_upstream(best_match.metadata.upstream())
homepage = format_homepage(best_match.environment("HOMEPAGE"))
if QUERY_OPTS["upstream"]:
upstream = format_list(upstream)
else:
upstream = format_list(upstream, "Upstream: ", " " * 13)
print_sequence(upstream)
print_sequence(homepage)
if not got_opts:
pkg_loc = best_match.package_path()
pp.uprint(format_line(pkg_loc, "Location: ", " " * 13))
if QUERY_OPTS["keywords"] or not got_opts:
# Get {<Package 'dev-libs/glib-2.20.5'>: [u'ia64', u'm68k', ...], ...}
keyword_map = filter_keywords(matches)
for match in matches:
slot = match.environment('SLOT')
verstr_len = len(match.fullversion) + len(slot)
fmtd_keywords = format_keywords(keyword_map[match])
keywords_line = format_keywords_line(match, fmtd_keywords, slot,
verstr_len)
if QUERY_OPTS["keywords"]:
pp.uprint(keywords_line)
else:
indent = " " * (16 + verstr_len)
pp.uprint(format_line(keywords_line, "Keywords: ", indent))
if QUERY_OPTS["description"]:
desc = best_match.metadata.descriptions()
print_sequence(format_list(desc))
if QUERY_OPTS["useflags"]:
useflags = format_useflags(best_match.metadata.use())
print_sequence(format_list(useflags))
if QUERY_OPTS["license"] or not got_opts:
_license = best_match.environment(["LICENSE"])
if QUERY_OPTS["license"]:
_license = format_list(_license)
else:
_license = format_list(_license, "License: ", " " * 13)
print_sequence(_license)
if QUERY_OPTS["stablereq"]:
# Get {<Package 'dev-libs/glib-2.20.5'>: [u'ia64', u'm68k', ...], ...}
stablereq_map = stablereq(matches)
for match in matches:
slot = match.environment('SLOT')
verstr_len = len(match.fullversion) + len(slot)
fmtd_ccs = ','.join(sorted(stablereq_map[match]))
stablereq_line = format_stablereq_line(match, fmtd_ccs, slot)
#print("STABLEREQ:", )
pp.uprint(stablereq_line)
if QUERY_OPTS["xml"]:
print_file(os.path.join(best_match.package_path(), 'metadata.xml'))
def call_format_functions(best_match, matches):
"""Call information gathering functions and display the results."""
if CONFIG['verbose']:
repo = best_match.repo_name()
pp.uprint(" * %s [%s]" % (pp.cpv(best_match.cp), pp.section(repo)))
got_opts = False
if any(QUERY_OPTS.values()):
# Specific information requested, less formatting
got_opts = True
if QUERY_OPTS["herd"] or not got_opts:
herds = best_match.metadata.herds(include_email=True)
if any(not h[0] for h in herds):
print(pp.warn("The packages metadata.xml has an empty <herd> tag"),
file = sys.stderr)
herds = [x for x in herds if x[0]]
herds = format_herds(herds)
if QUERY_OPTS["herd"]:
print_sequence(format_list(herds))
else:
for herd in herds:
pp.uprint(format_line(herd, "Herd: ", " " * 13))
if QUERY_OPTS["maintainer"] or not got_opts:
maints = format_maintainers(best_match.metadata.maintainers())
if QUERY_OPTS["maintainer"]:
print_sequence(format_list(maints))
else:
if not maints:
pp.uprint(format_line([], "Maintainer: ", " " * 13))
else:
for maint in maints:
pp.uprint(format_line(maint, "Maintainer: ", " " * 13))
if QUERY_OPTS["upstream"] or not got_opts:
upstream = format_upstream(best_match.metadata.upstream())
homepage = format_homepage(best_match.environment("HOMEPAGE"))
if QUERY_OPTS["upstream"]:
upstream = format_list(upstream)
else:
upstream = format_list(upstream, "Upstream: ", " " * 13)
print_sequence(upstream)
print_sequence(homepage)
if not got_opts:
pkg_loc = best_match.package_path()
pp.uprint(format_line(pkg_loc, "Location: ", " " * 13))
if QUERY_OPTS["keywords"] or not got_opts:
# Get {<Package 'dev-libs/glib-2.20.5'>: [u'ia64', u'm68k', ...], ...}
keyword_map = filter_keywords(matches)
for match in matches:
slot = match.environment('SLOT')
verstr_len = len(match.fullversion) + len(slot)
fmtd_keywords = format_keywords(keyword_map[match])
keywords_line = format_keywords_line(
match, fmtd_keywords, slot, verstr_len
)
if QUERY_OPTS["keywords"]:
pp.uprint(keywords_line)
else:
indent = " " * (16 + verstr_len)
pp.uprint(format_line(keywords_line, "Keywords: ", indent))
if QUERY_OPTS["description"]:
desc = best_match.metadata.descriptions()
print_sequence(format_list(desc))
if QUERY_OPTS["useflags"]:
useflags = format_useflags(best_match.metadata.use())
print_sequence(format_list(useflags))
if QUERY_OPTS["stablereq"]:
# Get {<Package 'dev-libs/glib-2.20.5'>: [u'ia64', u'm68k', ...], ...}
stablereq_map = stablereq(matches)
for match in matches:
slot = match.environment('SLOT')
verstr_len = len(match.fullversion) + len(slot)
fmtd_ccs = ','.join(sorted(stablereq_map[match]))
stablereq_line = format_stablereq_line(
match, fmtd_ccs, slot
)
#print("STABLEREQ:", )
pp.uprint(stablereq_line)
if QUERY_OPTS["xml"]:
print_file(os.path.join(best_match.package_path(), 'metadata.xml'))
def analyse_keywords(self, keywords=None):
"""This will scan the installed packages db and analyze the
keywords used for installation and produce a report on them.
"""
print()
system_keywords = portage.settings["ACCEPT_KEYWORDS"]
arch = portage.settings["ARCH"]
if self.options["prefix"]:
# build a new keyword for testing
system_keywords = "~" + arch + "-linux"
if self.options["verbose"] or self.options["prefix"]:
print("Current system ARCH =", arch)
print("Current system ACCEPT_KEYWORDS =", system_keywords)
system_keywords = system_keywords.split()
self.printer = AnalysisPrinter("keywords", self.options["verbose"], system_keywords)
self.analyser = KeywordAnalyser(arch, system_keywords, portage.db[portage.root]["vartree"].dbapi)
# self.analyser.set_order(portage.settings["USE"].split())
# only for testing
test_use = portage.settings["USE"].split()
if self.options["prefix"] and "prefix" not in test_use:
print("ANALYSE_KEYWORDS() 'prefix' flag not found in system", "USE flags!!! appending for testing")
print()
test_use.append("prefix")
self.analyser.set_order(test_use)
# /end testing
if self.options["verbose"]:
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
# print "Total number of installed ebuilds =", len(cpvs)
keyword_users = gather_keywords_info(
cpvs=cpvs,
system_keywords=system_keywords,
use_portage=self.options["portage"],
keywords=keywords,
analyser=self.analyser,
)
blankline = nl
else:
keyword_users = gather_keywords_info(
system_keywords=system_keywords,
use_portage=self.options["portage"],
keywords=keywords,
analyser=self.analyser,
)
blankline = lambda: None
# print keyword_users
keyword_keys = sorted(keyword_users)
if self.options["verbose"]:
print(" Keyword System #pkgs cat/pkg-ver")
elif not self.options["quiet"]:
print(" Keyword System #pkgs")
for keyword in keyword_keys:
kwd_stable = keyword_users[keyword]["stable"]
if len(kwd_stable):
self.printer(keyword, " ", kwd_stable)
blankline()
kwd_testing = keyword_users[keyword]["testing"]
if len(kwd_testing):
self.printer(keyword, "~", kwd_testing)
blankline()
kwd_missing = keyword_users[keyword]["missing"]
if len(kwd_missing):
self.printer(keyword, "-", kwd_missing)
blankline
if not self.options["quiet"]:
if self.analyser.mismatched:
print("_________________________________________________")
print(
(
"The following packages were found to have a \n"
+ "different recorded ARCH than the current system ARCH"
)
)
for cpv in self.analyser.mismatched:
print("\t", pp.cpv(cpv))
print("===================================================")
print("Total number of keywords in report =", pp.output.red(str(len(keyword_keys))))
if self.options["verbose"]:
print("Total number of installed ebuilds =", pp.output.red(str(len(cpvs))))
print()
def rebuild_keywords(self):
#print("Module action not yet available")
#print()
"""This will scan the installed packages db and analyze the
keywords used for installation and produce a report on them.
"""
system_keywords = portage.settings["ACCEPT_KEYWORDS"].split()
output = RebuildPrinter(
"keywords", self.options["pretend"], self.options["exact"],
self.options['slot'])
arch = portage.settings["ARCH"]
if self.options["prefix"]:
# build a new keyword for testing
system_keywords = "~" + arch + "-linux"
if self.options["verbose"] or self.options["prefix"]:
print("Current system ARCH =", arch)
print("Current system ACCEPT_KEYWORDS =", system_keywords)
self.analyser = KeywordAnalyser( arch, system_keywords, portage.db[portage.root]["vartree"].dbapi)
#self.analyser.set_order(portage.settings["USE"].split())
# only for testing
test_use = portage.settings["USE"].split()
if self.options['prefix'] and 'prefix' not in test_use:
print("REBUILD_KEYWORDS() 'prefix' flag not found in system",
"USE flags!!! appending for testing")
print()
test_use.append('prefix')
self.analyser.set_order(test_use)
# /end testing
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
#print "Total number of installed ebuilds =", len(cpvs)
pkgs, cp_counts = cpv_all_diff_keywords(
cpvs=cpvs,
system_keywords=system_keywords,
use_portage=self.options['portage'],
analyser = self.analyser
)
#print([pkgs[p][0].cpv for p in pkgs])
pkg_keys = []
if pkgs:
pkg_keys = sorted(pkgs)
#print(len(pkgs))
if self.options["pretend"] and not self.options["quiet"]:
print()
print(pp.globaloption(
" -- These are the installed packages & keywords " +
"that were detected"))
print(pp.globaloption(" to need keyword settings other " +
"than the defaults."))
print()
elif not self.options["quiet"]:
print(" -- preparing pkgs for file entries")
for pkg in pkg_keys:
output(pkg, pkgs[pkg], cp_counts[pkg])
if not self.options['quiet']:
if self.analyser.mismatched:
print("_________________________________________________")
print(("The following packages were found to have a \n" +
"different recorded ARCH than the current system ARCH"))
for cpv in self.analyser.mismatched:
print("\t", pp.cpv(cpv))
print("===================================================")
print("Total number of entries in report =",
pp.output.red(str(len(pkg_keys))))
if self.options["verbose"]:
print("Total number of installed ebuilds =",
pp.output.red(str(len(cpvs))))
print()
if not self.options["pretend"]:
filepath = os.path.expanduser('~/package.keywords.test')
self.save_file(filepath, output.lines)
def rebuild_keywords(self):
# print("Module action not yet available")
# print()
"""This will scan the installed packages db and analyze the
keywords used for installation and produce a report on them.
"""
system_keywords = portage.settings["ACCEPT_KEYWORDS"].split()
output = RebuildPrinter(
"keywords",
self.options["pretend"],
self.options["exact"],
self.options["slot"],
)
arch = portage.settings["ARCH"]
if self.options["prefix"]:
# build a new keyword for testing
system_keywords = "~" + arch + "-linux"
if self.options["verbose"] or self.options["prefix"]:
print("Current system ARCH =", arch)
print("Current system ACCEPT_KEYWORDS =", system_keywords)
self.analyser = KeywordAnalyser(
arch, system_keywords, portage.db[portage.root]["vartree"].dbapi
)
# self.analyser.set_order(portage.settings["USE"].split())
# only for testing
test_use = portage.settings["USE"].split()
if self.options["prefix"] and "prefix" not in test_use:
print(
"REBUILD_KEYWORDS() 'prefix' flag not found in system",
"USE flags!!! appending for testing",
)
print()
test_use.append("prefix")
self.analyser.set_order(test_use)
# /end testing
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
# print "Total number of installed ebuilds =", len(cpvs)
pkgs, cp_counts = cpv_all_diff_keywords(
cpvs=cpvs,
system_keywords=system_keywords,
use_portage=self.options["portage"],
analyser=self.analyser,
)
# print([pkgs[p][0].cpv for p in pkgs])
pkg_keys = []
if pkgs:
pkg_keys = sorted(pkgs)
# print(len(pkgs))
if self.options["pretend"] and not self.options["quiet"]:
print()
print(
pp.globaloption(
" -- These are the installed packages & keywords "
+ "that were detected"
)
)
print(
pp.globaloption(
" to need keyword settings other " + "than the defaults."
)
)
print()
elif not self.options["quiet"]:
print(" -- preparing pkgs for file entries")
for pkg in pkg_keys:
output(pkg, pkgs[pkg], cp_counts[pkg])
if not self.options["quiet"]:
if self.analyser.mismatched:
print("_________________________________________________")
print(
(
"The following packages were found to have a \n"
+ "different recorded ARCH than the current system ARCH"
)
)
for cpv in self.analyser.mismatched:
print("\t", pp.cpv(cpv))
print("===================================================")
print(
"Total number of entries in report =", pp.output.red(str(len(pkg_keys)))
)
if self.options["verbose"]:
print(
"Total number of installed ebuilds =", pp.output.red(str(len(cpvs)))
)
print()
if not self.options["pretend"]:
filepath = os.path.expanduser("~/package.keywords.test")
self.save_file(filepath, output.lines)
def analyse_keywords(self, keywords=None):
"""This will scan the installed packages db and analyze the
keywords used for installation and produce a report on them.
"""
print()
system_keywords = portage.settings["ACCEPT_KEYWORDS"]
arch = portage.settings["ARCH"]
if self.options["prefix"]:
# build a new keyword for testing
system_keywords = "~" + arch + "-linux"
if self.options["verbose"] or self.options["prefix"]:
print("Current system ARCH =", arch)
print("Current system ACCEPT_KEYWORDS =", system_keywords)
system_keywords = system_keywords.split()
self.printer = AnalysisPrinter(
"keywords",
self.options["verbose"],
system_keywords,
width=self.options["width"],
prepend=self.options["prepend"])
self.analyser = KeywordAnalyser( arch, system_keywords, portage.db[portage.root]["vartree"].dbapi)
#self.analyser.set_order(portage.settings["USE"].split())
# only for testing
test_use = portage.settings["USE"].split()
if self.options['prefix'] and 'prefix' not in test_use:
print("ANALYSE_KEYWORDS() 'prefix' flag not found in system",
"USE flags!!! appending for testing")
print()
test_use.append('prefix')
self.analyser.set_order(test_use)
# /end testing
if self.options["verbose"]:
cpvs = portage.db[portage.root]["vartree"].dbapi.cpv_all()
#print "Total number of installed ebuilds =", len(cpvs)
keyword_users = gather_keywords_info(
cpvs=cpvs,
system_keywords=system_keywords,
use_portage=self.options['portage'],
keywords=keywords, analyser = self.analyser
)
blankline = nl
else:
keyword_users = gather_keywords_info(
system_keywords=system_keywords,
use_portage=self.options['portage'],
keywords=keywords,
analyser = self.analyser
)
blankline = lambda: None
#print keyword_users
keyword_keys = sorted(keyword_users)
if self.options["verbose"]:
print(" Keyword System #pkgs cat/pkg-ver")
elif not self.options['quiet']:
print(" Keyword System #pkgs")
for keyword in keyword_keys:
kwd_stable = keyword_users[keyword]["stable"]
if len(kwd_stable):
self.printer(keyword, " ", kwd_stable)
blankline()
kwd_testing = keyword_users[keyword]["testing"]
if len(kwd_testing):
self.printer(keyword, "~", kwd_testing)
blankline()
kwd_missing = keyword_users[keyword]["missing"]
if len(kwd_missing):
self.printer(keyword, "-", kwd_missing)
blankline
if not self.options['quiet']:
if self.analyser.mismatched:
print("_________________________________________________")
print(("The following packages were found to have a \n" +
"different recorded ARCH than the current system ARCH"))
for cpv in self.analyser.mismatched:
print("\t", pp.cpv(cpv))
print("===================================================")
print("Total number of keywords in report =",
pp.output.red(str(len(keyword_keys))))
if self.options["verbose"]:
print("Total number of installed ebuilds =",
pp.output.red(str(len(cpvs))))
print()
def scan_upstream(query, on_progress=None):
"""
Scans the upstream searching new versions for the given query
"""
maxval = 3
curval = 0
matches = []
if query.endswith(".ebuild"):
cpv = package_from_ebuild(query)
if cpv:
reload_gentoolkit()
matches = [Package(cpv)]
else:
matches = Query(query).find(
include_masked=True,
in_installed=False
)
if not matches:
output.ewarn(
pp.warn("No package matching '%s'" % pp.pkgquery(query))
)
return None
matches = sorted(matches)
pkg = matches.pop()
while '9999' in pkg.version and len(matches):
pkg = matches.pop()
if not pkg:
output.ewarn(
pp.warn("Package '%s' only have a dev version (9999)"
% pp.pkgquery(pkg.cp))
)
return None
# useful data only for formatted output
start_time = datetime.now()
output.metadata("datetime", start_time.isoformat(), show=False)
output.metadata("cp", pkg.cp, show=False)
output.metadata("cpv", pkg.cpv, show=False)
curval += 1
if on_progress:
on_progress(maxval, curval)
if pkg.cp in BLACKLIST_PACKAGES:
output.ewarn(
pp.warn("Package '%s' is blacklisted" % pp.pkgquery(pkg.cp))
)
return None
if not CONFIG['quiet']:
if not CONFIG['format']:
pp.uprint(
" * %s [%s]" % (pp.cpv(pkg.cpv), pp.section(pkg.repo_name()))
)
pp.uprint()
else:
output.metadata("overlay", pp.section(pkg.repo_name()))
ebuild_path = pkg.ebuild_path()
if ebuild_path:
output.metadata(
"ebuild", pp.path(os.path.normpath(ebuild_path))
)
output.metadata("repository", pkg.repo_name())
output.metadata("homepage", pkg.environment("HOMEPAGE"))
output.metadata("description", pkg.environment("DESCRIPTION"))
cpv = pkg.cpv
metadata = {
"EAPI": portage.settings["EAPI"],
"SRC_URI": pkg.environment("SRC_URI", False),
}
use = frozenset(portage.settings["PORTAGE_USE"].split())
try:
alist = porttree._parse_uri_map(cpv, metadata, use=use)
aalist = porttree._parse_uri_map(cpv, metadata)
except Exception as e:
output.ewarn(pp.warn("%s\n" % str(e)))
output.ewarn(
pp.warn("Invalid SRC_URI for '%s'" % pp.pkgquery(cpv))
)
return None
if "mirror" in portage.settings.features:
urls = aalist
else:
urls = alist
# output scan time for formatted output
scan_time = (datetime.now() - start_time).total_seconds()
output.metadata("scan_time", scan_time, show=False)
curval += 1
if on_progress:
on_progress(maxval, curval)
result = scan_upstream_urls(pkg.cpv, urls, on_progress)
curval += 1
if on_progress:
on_progress(maxval, curval)
return result
def scan_upstream(query, on_progress=None):
"""
Scans the upstream searching new versions for the given query
"""
matches = []
if query.endswith(".ebuild"):
cpv = package_from_ebuild(query)
reload_gentoolkit()
if cpv:
matches = [Package(cpv)]
else:
matches = Query(query).find(
include_masked=True,
in_installed=False,
)
if not matches:
output.ewarn(
pp.warn("No package matching '%s'" % pp.pkgquery(query))
)
return None
matches = sorted(matches)
pkg = matches.pop()
while '9999' in pkg.version and len(matches):
pkg = matches.pop()
if not pkg:
output.ewarn(
pp.warn("Package '%s' only have a dev version (9999)"
% pp.pkgquery(pkg.cp))
)
return None
# useful data only for formatted output
start_time = datetime.now()
output.metadata("datetime", start_time.isoformat(), show=False)
output.metadata("cp", pkg.cp, show=False)
output.metadata("cpv", pkg.cpv, show=False)
if on_progress:
on_progress(increment=10)
if pkg.cp in BLACKLIST_PACKAGES:
output.ewarn(
pp.warn("Package '%s' is blacklisted" % pp.pkgquery(pkg.cp))
)
return None
if not CONFIG['quiet']:
if not CONFIG['format']:
pp.uprint(
" * %s [%s]" % (pp.cpv(pkg.cpv), pp.section(pkg.repo_name()))
)
pp.uprint()
else:
output.metadata("overlay", pp.section(pkg.repo_name()))
ebuild_path = pkg.ebuild_path()
if ebuild_path:
output.metadata(
"ebuild", pp.path(os.path.normpath(ebuild_path))
)
uris, homepage, description = pkg.environment(
('SRC_URI', 'HOMEPAGE', 'DESCRIPTION')
)
output.metadata("repository", pkg.repo_name())
output.metadata("homepage", homepage)
output.metadata("description", description)
else:
uris = pkg.environment('SRC_URI')
cpv = pkg.cpv
uris = parse_src_uri(uris)
uris_expanded = [
from_mirror(uri) if 'mirror://' in uri else uri for uri in uris
]
pkg._uris = uris
pkg._uris_expanded = uris_expanded
versions = handlers.scan(pkg, uris, on_progress)
cp, ver, rev = portage.pkgsplit(pkg.cpv)
result = filter_versions(cp, versions)
if on_progress:
on_progress(increment=10)
# output scan time for formatted output
scan_time = (datetime.now() - start_time).total_seconds()
output.metadata("scan_time", scan_time, show=False)
is_current_version_stable = is_version_stable(ver)
if len(result) > 0:
if not (CONFIG['format'] or CONFIG['quiet']):
print("")
for cp, url, version, handler, confidence in result:
if CONFIG["ignore-pre-release"]:
if not is_version_stable(version):
continue
if CONFIG["ignore-pre-release-if-stable"]:
if is_current_version_stable and \
not is_version_stable(version):
continue
if CONFIG['progress']:
print("", file=sys.stderr)
output.result(cp, version, url, handler, confidence)
return result
def scan_upstream(query, on_progress=None):
"""
Scans the upstream searching new versions for the given query
"""
matches = []
if query.endswith(".ebuild"):
cpv = package_from_ebuild(query)
reload_gentoolkit()
if cpv:
matches = [Package(cpv)]
else:
matches = Query(query).find(
include_masked=True,
in_installed=False,
)
if not matches:
output.ewarn(pp.warn("No package matching '%s'" % pp.pkgquery(query)))
return None
matches = sorted(matches)
pkg = matches.pop()
while '9999' in pkg.version and len(matches):
pkg = matches.pop()
if not pkg:
output.ewarn(
pp.warn("Package '%s' only have a dev version (9999)" %
pp.pkgquery(pkg.cp)))
return None
# useful data only for formatted output
start_time = datetime.now()
output.metadata("datetime", start_time.isoformat(), show=False)
output.metadata("cp", pkg.cp, show=False)
output.metadata("cpv", pkg.cpv, show=False)
if on_progress:
on_progress(increment=10)
if pkg.cp in BLACKLIST_PACKAGES:
output.ewarn(
pp.warn("Package '%s' is blacklisted" % pp.pkgquery(pkg.cp)))
return None
if not CONFIG['quiet']:
if not CONFIG['format']:
pp.uprint(" * %s [%s]" %
(pp.cpv(pkg.cpv), pp.section(pkg.repo_name())))
pp.uprint()
else:
output.metadata("overlay", pp.section(pkg.repo_name()))
ebuild_path = pkg.ebuild_path()
if ebuild_path:
output.metadata("ebuild", pp.path(os.path.normpath(ebuild_path)))
uris, homepage, description = pkg.environment(
('SRC_URI', 'HOMEPAGE', 'DESCRIPTION'))
output.metadata("repository", pkg.repo_name())
output.metadata("homepage", homepage)
output.metadata("description", description)
else:
uris = pkg.environment('SRC_URI')
cpv = pkg.cpv
uris = parse_src_uri(uris)
uris_expanded = [
from_mirror(uri) if 'mirror://' in uri else uri for uri in uris
]
pkg._uris = uris
pkg._uris_expanded = uris_expanded
versions = handlers.scan(pkg, uris, on_progress)
cp, ver, rev = portage.pkgsplit(pkg.cpv)
result = filter_versions(cp, versions)
if on_progress:
on_progress(increment=10)
# output scan time for formatted output
scan_time = (datetime.now() - start_time).total_seconds()
output.metadata("scan_time", scan_time, show=False)
is_current_version_stable = is_version_stable(ver)
if len(result) > 0:
if not (CONFIG['format'] or CONFIG['quiet']):
print("")
for cp, url, version, handler, confidence in result:
if CONFIG["ignore-pre-release"]:
if not is_version_stable(version):
continue
if CONFIG["ignore-pre-release-if-stable"]:
if is_current_version_stable and \
not is_version_stable(version):
continue
if CONFIG['progress']:
print("", file=sys.stderr)
output.result(cp, version, url, handler, confidence)
return result
def pmsg(package, msg):
print(pp.cpv(str(package)) + ": " + msg)
def print_verbose(indent, cpv, use_conditional, depatom):
"""Verbosely prints a set of dep strings."""
sep = ' ? ' if (depatom and use_conditional) else ''
pp.uprint(indent + pp.cpv(cpv),
"(" + use_conditional + sep + depatom + ")")
def print_verbose(indent, cpv, use_conditional, depatom):
"""Verbosely prints a set of dep strings."""
sep = ' ? ' if (depatom and use_conditional) else ''
pp.uprint(indent + pp.cpv(cpv), "(" + use_conditional +
sep + depatom + ")")
