def _collect(self):
self._non_private_cp_to_atoms = defaultdict(list)
self._private_cp_to_atoms = defaultdict(list)
self._total_count = 0
self._private_count = 0
for location in self._locations():
for x in portage.grabfile_package(os.path.join(
location, self._section),
recursive=1):
self._total_count = self._total_count + 1
if x.startswith('-'):
print ' no proper support for "-cat/pkg" style entry "%s" yet, sorry.' % x.strip(
)
continue
cp = get_cp(x)
if self._privacy_filter and is_private_package_atom(cp):
self._private_count = self._private_count + 1
dict_ref = self._private_cp_to_atoms
else:
dict_ref = self._non_private_cp_to_atoms
merge_with = set([x])
if cp in dict_ref:
dict_ref[cp] = dict_ref[cp].union(merge_with)
else:
dict_ref[cp] = merge_with
def _collect(self):
config_root = portage.settings["PORTAGE_CONFIGROOT"]
world_file = os.path.join(config_root, WORLD_FILE)
file = open(world_file, 'r')
self._all_cps = [line.rstrip("\r\n") for line in file]
self._total_count = len(self._all_cps)
self._known_cps = set([e for e in self._all_cps if \
not is_private_package_atom(e)])
self._private_count = self._total_count - len(self._known_cps)
file.close()
def _collect(self):
config_root = portage.settings["PORTAGE_CONFIGROOT"]
world_file = os.path.join(config_root, WORLD_FILE)
file = open(world_file, 'r')
self._all_cps = [line.rstrip("\r\n") for line in file]
self._total_count = len(self._all_cps)
self._known_cps = set([e for e in self._all_cps if \
not is_private_package_atom(e)])
self._private_count = self._total_count - len(self._known_cps)
file.close()
def _collect(self):
self._non_private_cp_to_atoms = defaultdict(list)
self._private_cp_to_atoms = defaultdict(list)
self._total_count = 0
self._private_count = 0
for location in self._locations():
for x in portage.grabfile_package(
os.path.join(location, self._section), recursive = 1):
self._total_count = self._total_count + 1
if x.startswith('-'):
print ' no proper support for "-cat/pkg" style entry "%s" yet, sorry.' % x.strip()
continue
cp = get_cp(x)
if self._privacy_filter and is_private_package_atom(cp):
self._private_count = self._private_count + 1
dict_ref = self._private_cp_to_atoms
else:
dict_ref = self._non_private_cp_to_atoms
merge_with = set([x])
if cp in dict_ref:
dict_ref[cp] = dict_ref[cp].union(merge_with)
else:
dict_ref[cp] = merge_with
def _process(self, var_tree, cpv, debug=False):
cat, pkg, ver, rev = catpkgsplit(cpv)
package_name = "%s/%s" % (cat, pkg)
if rev == 'r0':
version_revision = ver
else:
version_revision = "%s-%s" % (ver, rev)
SLOT, KEYWORDS, repo, IUSE, USE = \
var_tree.dbapi.aux_get(cpv, ['SLOT', 'KEYWORDS', 'repository',
'IUSE', 'USE'])
# Perform privacy check and filtering
installed_from = [repo, ]
if is_private_package_atom('=' + cpv, installed_from=installed_from,
debug=debug):
return None
repo = installed_from[0]
ACCEPT_KEYWORDS = portage.settings['ACCEPT_KEYWORDS']
ARCH = portage.settings['ARCH']
keyword_status = self._keyword_status(ARCH, ACCEPT_KEYWORDS, KEYWORDS)
unmasked = PackageUnmask().hits(cpv)
# A package that is (1) installed and (2) not unmasked
# cannot be masked so we skip the next line's checks
masked = unmasked and (PackageMask().hits(cpv) or \
ProfilePackageMask().hits(cpv))
# World set test
if SLOT != '0':
world_set_test = '%s/%s:%s' % (cat, pkg, SLOT)
else:
world_set_test = '%s/%s' % (cat, pkg)
is_in_world = world_set_test in WorldSet().get()
# Use flags
if self._publish_installed_packages_use_flags:
iuse_list = tuple(x.lstrip("+-") for x in IUSE.split())
count_all = len(set(iuse_list))
package_use_set = set(filter(self.is_known_use_flag, USE.split()))
package_iuse_set = set(filter(self.is_known_use_flag, iuse_list))
enabled_flags = package_use_set & package_iuse_set
disabled_flags = package_iuse_set - package_use_set
package_flags = sorted(enabled_flags) + ['-' + e for e in sorted(disabled_flags)]
count_non_private = len(package_flags)
count_private = count_all - count_non_private
self._private_use_flags = self._private_use_flags + count_private
self._non_private_use_flags = self._non_private_use_flags + count_non_private
else:
package_flags = tuple()
if not self._publish_repos:
repo = 'WITHHELD'
entry = [package_name, version_revision, SLOT, keyword_status,
masked, unmasked, is_in_world, repo, package_flags]
return entry
