| # Copyright 1999-2021 Gentoo Authors |
| # Distributed under the terms of the GNU General Public License v2 |
| |
| from itertools import chain |
| import warnings |
| |
| import portage |
| from portage.cache.mappings import slot_dict_class |
| from portage.const import EBUILD_PHASES |
| from portage.dep import ( |
| Atom, |
| check_required_use, |
| use_reduce, |
| paren_enclose, |
| _slot_separator, |
| _repo_separator, |
| ) |
| from portage.dep.soname.parse import parse_soname_deps |
| from portage.versions import _pkg_str, _unknown_repo |
| from portage.eapi import _get_eapi_attrs, eapi_has_use_aliases |
| from portage.exception import InvalidData, InvalidDependString |
| from portage.localization import _ |
| from _emerge.Task import Task |
| |
| |
| class Package(Task): |
| |
| __hash__ = Task.__hash__ |
| __slots__ = ( |
| "built", |
| "cpv", |
| "depth", |
| "installed", |
| "onlydeps", |
| "operation", |
| "root_config", |
| "type_name", |
| "category", |
| "counter", |
| "cp", |
| "cpv_split", |
| "inherited", |
| "iuse", |
| "mtime", |
| "pf", |
| "root", |
| "slot", |
| "sub_slot", |
| "slot_atom", |
| "version", |
| ) + ( |
| "_invalid", |
| "_masks", |
| "_metadata", |
| "_provided_cps", |
| "_raw_metadata", |
| "_provides", |
| "_requires", |
| "_use", |
| "_validated_atoms", |
| "_visible", |
| ) |
| |
| metadata_keys = [ |
| "BDEPEND", |
| "BUILD_ID", |
| "BUILD_TIME", |
| "CHOST", |
| "COUNTER", |
| "DEFINED_PHASES", |
| "DEPEND", |
| "EAPI", |
| "IDEPEND", |
| "INHERITED", |
| "IUSE", |
| "KEYWORDS", |
| "LICENSE", |
| "MD5", |
| "PDEPEND", |
| "PROVIDES", |
| "RDEPEND", |
| "repository", |
| "REQUIRED_USE", |
| "PROPERTIES", |
| "REQUIRES", |
| "RESTRICT", |
| "SIZE", |
| "SLOT", |
| "USE", |
| "_mtime_", |
| ] |
| |
| _dep_keys = ("BDEPEND", "DEPEND", "IDEPEND", "PDEPEND", "RDEPEND") |
| _buildtime_keys = ("BDEPEND", "DEPEND") |
| _runtime_keys = ("IDEPEND", "PDEPEND", "RDEPEND") |
| _use_conditional_misc_keys = ("LICENSE", "PROPERTIES", "RESTRICT") |
| UNKNOWN_REPO = _unknown_repo |
| |
| def __init__(self, **kwargs): |
| metadata = _PackageMetadataWrapperBase(kwargs.pop("metadata")) |
| Task.__init__(self, **kwargs) |
| # the SlotObject constructor assigns self.root_config from keyword args |
| # and is an instance of a '_emerge.RootConfig.RootConfig class |
| self.root = self.root_config.root |
| self._raw_metadata = metadata |
| self._metadata = _PackageMetadataWrapper(self, metadata) |
| if not self.built: |
| self._metadata["CHOST"] = self.root_config.settings.get("CHOST", "") |
| eapi_attrs = _get_eapi_attrs(self.eapi) |
| |
| try: |
| db = self.cpv._db |
| except AttributeError: |
| if self.built: |
| # For independence from the source ebuild repository and |
| # profile implicit IUSE state, require the _db attribute |
| # for built packages. |
| raise |
| db = self.root_config.trees["porttree"].dbapi |
| |
| self.cpv = _pkg_str( |
| self.cpv, metadata=self._metadata, settings=self.root_config.settings, db=db |
| ) |
| if hasattr(self.cpv, "slot_invalid"): |
| self._invalid_metadata( |
| "SLOT.invalid", "SLOT: invalid value: '%s'" % self._metadata["SLOT"] |
| ) |
| self.cpv_split = self.cpv.cpv_split |
| self.category, self.pf = portage.catsplit(self.cpv) |
| self.cp = self.cpv.cp |
| self.version = self.cpv.version |
| self.slot = self.cpv.slot |
| self.sub_slot = self.cpv.sub_slot |
| self.slot_atom = Atom("%s%s%s" % (self.cp, _slot_separator, self.slot)) |
| # sync metadata with validated repo (may be UNKNOWN_REPO) |
| self._metadata["repository"] = self.cpv.repo |
| |
| if self.root_config.settings.local_config: |
| implicit_match = db._iuse_implicit_cnstr(self.cpv, self._metadata) |
| else: |
| implicit_match = db._repoman_iuse_implicit_cnstr(self.cpv, self._metadata) |
| usealiases = self.root_config.settings._use_manager.getUseAliases(self) |
| self.iuse = self._iuse( |
| self, self._metadata["IUSE"].split(), implicit_match, usealiases, self.eapi |
| ) |
| |
| if (self.iuse.enabled or self.iuse.disabled) and not eapi_attrs.iuse_defaults: |
| if not self.installed: |
| self._invalid_metadata( |
| "EAPI.incompatible", |
| "IUSE contains defaults, but EAPI doesn't allow them", |
| ) |
| if self.inherited is None: |
| self.inherited = frozenset() |
| |
| if self.operation is None: |
| if self.onlydeps or self.installed: |
| self.operation = "nomerge" |
| else: |
| self.operation = "merge" |
| |
| self._hash_key = Package._gen_hash_key( |
| cpv=self.cpv, |
| installed=self.installed, |
| onlydeps=self.onlydeps, |
| operation=self.operation, |
| repo_name=self.cpv.repo, |
| root_config=self.root_config, |
| type_name=self.type_name, |
| ) |
| self._hash_value = hash(self._hash_key) |
| |
| @property |
| def eapi(self): |
| return self._metadata["EAPI"] |
| |
| @property |
| def build_id(self): |
| return self.cpv.build_id |
| |
| @property |
| def build_time(self): |
| if not self.built: |
| raise AttributeError("build_time") |
| return self.cpv.build_time |
| |
| @property |
| def defined_phases(self): |
| return self._metadata.defined_phases |
| |
| @property |
| def properties(self): |
| return self._metadata.properties |
| |
| @property |
| def provided_cps(self): |
| return (self.cp,) |
| |
| @property |
| def restrict(self): |
| return self._metadata.restrict |
| |
| @property |
| def metadata(self): |
| warnings.warn( |
| "_emerge.Package.Package.metadata is deprecated", |
| DeprecationWarning, |
| stacklevel=3, |
| ) |
| return self._metadata |
| |
| # These are calculated on-demand, so that they are calculated |
| # after FakeVartree applies its metadata tweaks. |
| @property |
| def invalid(self): |
| if self._invalid is None: |
| self._validate_deps() |
| if self._invalid is None: |
| self._invalid = False |
| return self._invalid |
| |
| @property |
| def masks(self): |
| if self._masks is None: |
| self._masks = self._eval_masks() |
| return self._masks |
| |
| @property |
| def visible(self): |
| if self._visible is None: |
| self._visible = self._eval_visiblity(self.masks) |
| return self._visible |
| |
| @property |
| def validated_atoms(self): |
| """ |
| Returns *all* validated atoms from the deps, regardless |
| of USE conditionals, with USE conditionals inside |
| atoms left unevaluated. |
| """ |
| if self._validated_atoms is None: |
| self._validate_deps() |
| return self._validated_atoms |
| |
| @property |
| def stable(self): |
| return self.cpv.stable |
| |
| @property |
| def provides(self): |
| self.invalid |
| return self._provides |
| |
| @property |
| def requires(self): |
| self.invalid |
| return self._requires |
| |
| @classmethod |
| def _gen_hash_key( |
| cls, |
| cpv=None, |
| installed=None, |
| onlydeps=None, |
| operation=None, |
| repo_name=None, |
| root_config=None, |
| type_name=None, |
| **kwargs |
| ): |
| |
| if operation is None: |
| if installed or onlydeps: |
| operation = "nomerge" |
| else: |
| operation = "merge" |
| |
| root = None |
| if root_config is not None: |
| root = root_config.root |
| else: |
| raise TypeError("root_config argument is required") |
| |
| elements = [type_name, root, str(cpv), operation] |
| |
| # For installed (and binary) packages we don't care for the repo |
| # when it comes to hashing, because there can only be one cpv. |
| # So overwrite the repo_key with type_name. |
| if type_name is None: |
| raise TypeError("type_name argument is required") |
| elif type_name == "ebuild": |
| if repo_name is None: |
| raise AssertionError( |
| "Package._gen_hash_key() " + "called without 'repo_name' argument" |
| ) |
| elements.append(repo_name) |
| elif type_name == "binary": |
| # Including a variety of fingerprints in the hash makes |
| # it possible to simultaneously consider multiple similar |
| # packages. Note that digests are not included here, since |
| # they are relatively expensive to compute, and they may |
| # not necessarily be available. |
| elements.extend([cpv.build_id, cpv.file_size, cpv.build_time, cpv.mtime]) |
| else: |
| # For installed (and binary) packages we don't care for the repo |
| # when it comes to hashing, because there can only be one cpv. |
| # So overwrite the repo_key with type_name. |
| elements.append(type_name) |
| |
| return tuple(elements) |
| |
| def _validate_deps(self): |
| """ |
| Validate deps. This does not trigger USE calculation since that |
| is expensive for ebuilds and therefore we want to avoid doing |
| it unnecessarily (like for masked packages). |
| """ |
| eapi = self.eapi |
| dep_eapi = eapi |
| dep_valid_flag = self.iuse.is_valid_flag |
| if self.installed: |
| # Ignore EAPI.incompatible and conditionals missing |
| # from IUSE for installed packages since these issues |
| # aren't relevant now (re-evaluate when new EAPIs are |
| # deployed). |
| dep_eapi = None |
| dep_valid_flag = None |
| |
| validated_atoms = [] |
| for k in self._dep_keys: |
| v = self._metadata.get(k) |
| if not v: |
| continue |
| try: |
| atoms = use_reduce( |
| v, |
| eapi=dep_eapi, |
| matchall=True, |
| is_valid_flag=dep_valid_flag, |
| token_class=Atom, |
| flat=True, |
| ) |
| except InvalidDependString as e: |
| self._metadata_exception(k, e) |
| else: |
| validated_atoms.extend(atoms) |
| if not self.built: |
| for atom in atoms: |
| if not isinstance(atom, Atom): |
| continue |
| if atom.slot_operator_built: |
| e = InvalidDependString( |
| _( |
| "Improper context for slot-operator " |
| '"built" atom syntax: %s' |
| ) |
| % (atom.unevaluated_atom,) |
| ) |
| self._metadata_exception(k, e) |
| |
| self._validated_atoms = tuple( |
| set(atom for atom in validated_atoms if isinstance(atom, Atom)) |
| ) |
| |
| for k in self._use_conditional_misc_keys: |
| v = self._metadata.get(k) |
| if not v: |
| continue |
| try: |
| use_reduce( |
| v, eapi=dep_eapi, matchall=True, is_valid_flag=dep_valid_flag |
| ) |
| except InvalidDependString as e: |
| self._metadata_exception(k, e) |
| |
| k = "REQUIRED_USE" |
| v = self._metadata.get(k) |
| if v and not self.built: |
| if not _get_eapi_attrs(eapi).required_use: |
| self._invalid_metadata( |
| "EAPI.incompatible", |
| "REQUIRED_USE set, but EAPI='%s' doesn't allow it" % eapi, |
| ) |
| else: |
| try: |
| check_required_use(v, (), self.iuse.is_valid_flag, eapi=eapi) |
| except InvalidDependString as e: |
| self._invalid_metadata(k + ".syntax", "%s: %s" % (k, e)) |
| |
| k = "SRC_URI" |
| v = self._metadata.get(k) |
| if v: |
| try: |
| use_reduce( |
| v, |
| is_src_uri=True, |
| eapi=eapi, |
| matchall=True, |
| is_valid_flag=self.iuse.is_valid_flag, |
| ) |
| except InvalidDependString as e: |
| if not self.installed: |
| self._metadata_exception(k, e) |
| |
| if self.built: |
| k = "PROVIDES" |
| try: |
| self._provides = frozenset(parse_soname_deps(self._metadata[k])) |
| except InvalidData as e: |
| self._invalid_metadata(k + ".syntax", "%s: %s" % (k, e)) |
| |
| k = "REQUIRES" |
| try: |
| self._requires = frozenset(parse_soname_deps(self._metadata[k])) |
| except InvalidData as e: |
| self._invalid_metadata(k + ".syntax", "%s: %s" % (k, e)) |
| |
| def copy(self): |
| return Package( |
| built=self.built, |
| cpv=self.cpv, |
| depth=self.depth, |
| installed=self.installed, |
| metadata=self._raw_metadata, |
| onlydeps=self.onlydeps, |
| operation=self.operation, |
| root_config=self.root_config, |
| type_name=self.type_name, |
| ) |
| |
| def _eval_masks(self): |
| masks = {} |
| settings = self.root_config.settings |
| |
| if self.invalid is not False: |
| masks["invalid"] = self.invalid |
| |
| if not settings._accept_chost(self.cpv, self._metadata): |
| masks["CHOST"] = self._metadata["CHOST"] |
| |
| eapi = self.eapi |
| if not portage.eapi_is_supported(eapi): |
| masks["EAPI.unsupported"] = eapi |
| if portage._eapi_is_deprecated(eapi): |
| masks["EAPI.deprecated"] = eapi |
| |
| missing_keywords = settings._getMissingKeywords(self.cpv, self._metadata) |
| if missing_keywords: |
| masks["KEYWORDS"] = missing_keywords |
| |
| try: |
| missing_properties = settings._getMissingProperties( |
| self.cpv, self._metadata |
| ) |
| if missing_properties: |
| masks["PROPERTIES"] = missing_properties |
| except InvalidDependString: |
| # already recorded as 'invalid' |
| pass |
| |
| try: |
| missing_restricts = settings._getMissingRestrict(self.cpv, self._metadata) |
| if missing_restricts: |
| masks["RESTRICT"] = missing_restricts |
| except InvalidDependString: |
| # already recorded as 'invalid' |
| pass |
| |
| mask_atom = settings._getMaskAtom(self.cpv, self._metadata) |
| if mask_atom is not None: |
| masks["package.mask"] = mask_atom |
| |
| try: |
| missing_licenses = settings._getMissingLicenses(self.cpv, self._metadata) |
| if missing_licenses: |
| masks["LICENSE"] = missing_licenses |
| except InvalidDependString: |
| # already recorded as 'invalid' |
| pass |
| |
| if not masks: |
| masks = False |
| |
| return masks |
| |
| def _eval_visiblity(self, masks): |
| |
| if masks is not False: |
| |
| if "EAPI.unsupported" in masks: |
| return False |
| |
| if "invalid" in masks: |
| return False |
| |
| if not self.installed and ( |
| "CHOST" in masks |
| or "EAPI.deprecated" in masks |
| or "KEYWORDS" in masks |
| or "PROPERTIES" in masks |
| or "RESTRICT" in masks |
| ): |
| return False |
| |
| if "package.mask" in masks or "LICENSE" in masks: |
| return False |
| |
| return True |
| |
| def get_keyword_mask(self): |
| """returns None, 'missing', or 'unstable'.""" |
| |
| missing = self.root_config.settings._getRawMissingKeywords( |
| self.cpv, self._metadata |
| ) |
| |
| if not missing: |
| return None |
| |
| if "**" in missing: |
| return "missing" |
| |
| global_accept_keywords = frozenset( |
| self.root_config.settings.get("ACCEPT_KEYWORDS", "").split() |
| ) |
| |
| for keyword in missing: |
| if keyword.lstrip("~") in global_accept_keywords: |
| return "unstable" |
| |
| return "missing" |
| |
| def isHardMasked(self): |
| """returns a bool if the cpv is in the list of |
| expanded pmaskdict[cp] available ebuilds""" |
| pmask = self.root_config.settings._getRawMaskAtom(self.cpv, self._metadata) |
| return pmask is not None |
| |
| def _metadata_exception(self, k, e): |
| |
| if k.endswith("DEPEND"): |
| qacat = "dependency.syntax" |
| else: |
| qacat = k + ".syntax" |
| |
| if not self.installed: |
| categorized_error = False |
| if e.errors: |
| for error in e.errors: |
| if getattr(error, "category", None) is None: |
| continue |
| categorized_error = True |
| self._invalid_metadata(error.category, "%s: %s" % (k, error)) |
| |
| if not categorized_error: |
| self._invalid_metadata(qacat, "%s: %s" % (k, e)) |
| else: |
| # For installed packages, show the path of the file |
| # containing the invalid metadata, since the user may |
| # want to fix the deps by hand. |
| vardb = self.root_config.trees["vartree"].dbapi |
| path = vardb.getpath(self.cpv, filename=k) |
| self._invalid_metadata(qacat, "%s: %s in '%s'" % (k, e, path)) |
| |
| def _invalid_metadata(self, msg_type, msg): |
| if self._invalid is None: |
| self._invalid = {} |
| msgs = self._invalid.get(msg_type) |
| if msgs is None: |
| msgs = [] |
| self._invalid[msg_type] = msgs |
| msgs.append(msg) |
| |
| def __str__(self): |
| if self.operation == "merge": |
| if self.type_name == "binary": |
| cpv_color = "PKG_BINARY_MERGE" |
| else: |
| cpv_color = "PKG_MERGE" |
| elif self.operation == "uninstall": |
| cpv_color = "PKG_UNINSTALL" |
| else: |
| cpv_color = "PKG_NOMERGE" |
| |
| build_id_str = "" |
| if isinstance(self.cpv.build_id, int) and self.cpv.build_id > 0: |
| build_id_str = "-%s" % self.cpv.build_id |
| |
| s = "(%s, %s" % ( |
| portage.output.colorize( |
| cpv_color, |
| self.cpv |
| + build_id_str |
| + _slot_separator |
| + self.slot |
| + "/" |
| + self.sub_slot |
| + _repo_separator |
| + self.repo, |
| ), |
| self.type_name, |
| ) |
| |
| if self.type_name == "installed": |
| if self.root_config.settings["ROOT"] != "/": |
| s += " in '%s'" % self.root_config.settings["ROOT"] |
| if self.operation == "uninstall": |
| s += " scheduled for uninstall" |
| else: |
| if self.operation == "merge": |
| s += " scheduled for merge" |
| if self.root_config.settings["ROOT"] != "/": |
| s += " to '%s'" % self.root_config.settings["ROOT"] |
| s += ")" |
| return s |
| |
| class _use_class: |
| |
| __slots__ = ("enabled", "_expand", "_expand_hidden", "_force", "_pkg", "_mask") |
| |
| # Share identical frozenset instances when available. |
| _frozensets = {} |
| |
| def __init__(self, pkg, enabled_flags): |
| self._pkg = pkg |
| self._expand = None |
| self._expand_hidden = None |
| self._force = None |
| self._mask = None |
| if eapi_has_use_aliases(pkg.eapi): |
| for enabled_flag in enabled_flags: |
| enabled_flags.extend(pkg.iuse.alias_mapping.get(enabled_flag, [])) |
| self.enabled = frozenset(enabled_flags) |
| if pkg.built: |
| # Use IUSE to validate USE settings for built packages, |
| # in case the package manager that built this package |
| # failed to do that for some reason (or in case of |
| # data corruption). |
| missing_iuse = pkg.iuse.get_missing_iuse(self.enabled) |
| if missing_iuse: |
| self.enabled = self.enabled.difference(missing_iuse) |
| |
| def _init_force_mask(self): |
| pkgsettings = self._pkg._get_pkgsettings() |
| frozensets = self._frozensets |
| s = frozenset(pkgsettings.get("USE_EXPAND", "").lower().split()) |
| self._expand = frozensets.setdefault(s, s) |
| s = frozenset(pkgsettings.get("USE_EXPAND_HIDDEN", "").lower().split()) |
| self._expand_hidden = frozensets.setdefault(s, s) |
| s = pkgsettings.useforce |
| self._force = frozensets.setdefault(s, s) |
| s = pkgsettings.usemask |
| self._mask = frozensets.setdefault(s, s) |
| |
| @property |
| def expand(self): |
| if self._expand is None: |
| self._init_force_mask() |
| return self._expand |
| |
| @property |
| def expand_hidden(self): |
| if self._expand_hidden is None: |
| self._init_force_mask() |
| return self._expand_hidden |
| |
| @property |
| def force(self): |
| if self._force is None: |
| self._init_force_mask() |
| return self._force |
| |
| @property |
| def mask(self): |
| if self._mask is None: |
| self._init_force_mask() |
| return self._mask |
| |
| @property |
| def repo(self): |
| return self._metadata["repository"] |
| |
| @property |
| def repo_priority(self): |
| repo_info = self.root_config.settings.repositories.prepos.get(self.repo) |
| if repo_info is None: |
| return None |
| return repo_info.priority |
| |
| @property |
| def use(self): |
| if self._use is None: |
| self._init_use() |
| return self._use |
| |
| def _get_pkgsettings(self): |
| pkgsettings = self.root_config.trees["porttree"].dbapi.doebuild_settings |
| pkgsettings.setcpv(self) |
| return pkgsettings |
| |
| def _init_use(self): |
| if self.built: |
| # Use IUSE to validate USE settings for built packages, |
| # in case the package manager that built this package |
| # failed to do that for some reason (or in case of |
| # data corruption). The enabled flags must be consistent |
| # with implicit IUSE, in order to avoid potential |
| # inconsistencies in USE dep matching (see bug #453400). |
| use_str = self._metadata["USE"] |
| is_valid_flag = self.iuse.is_valid_flag |
| enabled_flags = [x for x in use_str.split() if is_valid_flag(x)] |
| use_str = " ".join(enabled_flags) |
| self._use = self._use_class(self, enabled_flags) |
| else: |
| try: |
| use_str = _PackageMetadataWrapperBase.__getitem__(self._metadata, "USE") |
| except KeyError: |
| use_str = None |
| calculated_use = False |
| if not use_str: |
| use_str = self._get_pkgsettings()["PORTAGE_USE"] |
| calculated_use = True |
| self._use = self._use_class(self, use_str.split()) |
| # Initialize these now, since USE access has just triggered |
| # setcpv, and we want to cache the result of the force/mask |
| # calculations that were done. |
| if calculated_use: |
| self._use._init_force_mask() |
| |
| _PackageMetadataWrapperBase.__setitem__(self._metadata, "USE", use_str) |
| |
| return use_str |
| |
| class _iuse: |
| |
| __slots__ = ( |
| "__weakref__", |
| "_iuse_implicit_match", |
| "_pkg", |
| "alias_mapping", |
| "all", |
| "all_aliases", |
| "enabled", |
| "disabled", |
| "tokens", |
| ) |
| |
| def __init__(self, pkg, tokens, iuse_implicit_match, aliases, eapi): |
| self._pkg = pkg |
| self.tokens = tuple(tokens) |
| self._iuse_implicit_match = iuse_implicit_match |
| enabled = [] |
| disabled = [] |
| other = [] |
| enabled_aliases = [] |
| disabled_aliases = [] |
| other_aliases = [] |
| aliases_supported = eapi_has_use_aliases(eapi) |
| self.alias_mapping = {} |
| for x in tokens: |
| prefix = x[:1] |
| if prefix == "+": |
| enabled.append(x[1:]) |
| if aliases_supported: |
| self.alias_mapping[x[1:]] = aliases.get(x[1:], []) |
| enabled_aliases.extend(self.alias_mapping[x[1:]]) |
| elif prefix == "-": |
| disabled.append(x[1:]) |
| if aliases_supported: |
| self.alias_mapping[x[1:]] = aliases.get(x[1:], []) |
| disabled_aliases.extend(self.alias_mapping[x[1:]]) |
| else: |
| other.append(x) |
| if aliases_supported: |
| self.alias_mapping[x] = aliases.get(x, []) |
| other_aliases.extend(self.alias_mapping[x]) |
| self.enabled = frozenset(chain(enabled, enabled_aliases)) |
| self.disabled = frozenset(chain(disabled, disabled_aliases)) |
| self.all = frozenset(chain(enabled, disabled, other)) |
| self.all_aliases = frozenset( |
| chain(enabled_aliases, disabled_aliases, other_aliases) |
| ) |
| |
| def is_valid_flag(self, flags): |
| """ |
| @return: True if all flags are valid USE values which may |
| be specified in USE dependencies, False otherwise. |
| """ |
| if isinstance(flags, str): |
| flags = [flags] |
| |
| for flag in flags: |
| if ( |
| not flag in self.all |
| and not flag in self.all_aliases |
| and not self._iuse_implicit_match(flag) |
| ): |
| return False |
| return True |
| |
| def get_missing_iuse(self, flags): |
| """ |
| @return: A list of flags missing from IUSE. |
| """ |
| if isinstance(flags, str): |
| flags = [flags] |
| missing_iuse = [] |
| for flag in flags: |
| if ( |
| not flag in self.all |
| and not flag in self.all_aliases |
| and not self._iuse_implicit_match(flag) |
| ): |
| missing_iuse.append(flag) |
| return missing_iuse |
| |
| def get_real_flag(self, flag): |
| """ |
| Returns the flag's name within the scope of this package |
| (accounting for aliases), or None if the flag is unknown. |
| """ |
| if flag in self.all: |
| return flag |
| |
| if flag in self.all_aliases: |
| for k, v in self.alias_mapping.items(): |
| if flag in v: |
| return k |
| |
| if self._iuse_implicit_match(flag): |
| return flag |
| |
| return None |
| |
| def __len__(self): |
| return 4 |
| |
| def __iter__(self): |
| """ |
| This is used to generate mtimedb resume mergelist entries, so we |
| limit it to 4 items for backward compatibility. |
| """ |
| return iter(self._hash_key[:4]) |
| |
| def __lt__(self, other): |
| if other.cp != self.cp: |
| return self.cp < other.cp |
| result = portage.vercmp(self.version, other.version) |
| if result < 0: |
| return True |
| if result == 0 and self.built and other.built: |
| return self.build_time < other.build_time |
| return False |
| |
| def __le__(self, other): |
| if other.cp != self.cp: |
| return self.cp <= other.cp |
| result = portage.vercmp(self.version, other.version) |
| if result <= 0: |
| return True |
| if result == 0 and self.built and other.built: |
| return self.build_time <= other.build_time |
| return False |
| |
| def __gt__(self, other): |
| if other.cp != self.cp: |
| return self.cp > other.cp |
| result = portage.vercmp(self.version, other.version) |
| if result > 0: |
| return True |
| if result == 0 and self.built and other.built: |
| return self.build_time > other.build_time |
| return False |
| |
| def __ge__(self, other): |
| if other.cp != self.cp: |
| return self.cp >= other.cp |
| result = portage.vercmp(self.version, other.version) |
| if result >= 0: |
| return True |
| if result == 0 and self.built and other.built: |
| return self.build_time >= other.build_time |
| return False |
| |
| def with_use(self, use): |
| """ |
| Return an Package instance with the specified USE flags. The |
| current instance may be returned if it has identical USE flags. |
| @param use: a set of USE flags |
| @type use: frozenset |
| @return: A package with the specified USE flags |
| @rtype: Package |
| """ |
| if use is not self.use.enabled: |
| pkg = self.copy() |
| pkg._metadata["USE"] = " ".join(use) |
| else: |
| pkg = self |
| return pkg |
| |
| |
| _all_metadata_keys = set(x for x in portage.auxdbkeys) |
| _all_metadata_keys.update(Package.metadata_keys) |
| _all_metadata_keys = frozenset(_all_metadata_keys) |
| |
| _PackageMetadataWrapperBase = slot_dict_class(_all_metadata_keys) |
| |
| |
| class _PackageMetadataWrapper(_PackageMetadataWrapperBase): |
| """ |
| Detect metadata updates and synchronize Package attributes. |
| """ |
| |
| __slots__ = ("_pkg",) |
| _wrapped_keys = frozenset(["COUNTER", "INHERITED", "USE", "_mtime_"]) |
| _use_conditional_keys = frozenset( |
| [ |
| "LICENSE", |
| "PROPERTIES", |
| "RESTRICT", |
| ] |
| ) |
| |
| def __init__(self, pkg, metadata): |
| _PackageMetadataWrapperBase.__init__(self) |
| self._pkg = pkg |
| if not pkg.built: |
| # USE is lazy, but we want it to show up in self.keys(). |
| _PackageMetadataWrapperBase.__setitem__(self, "USE", "") |
| |
| self.update(metadata) |
| |
| def __getitem__(self, k): |
| v = _PackageMetadataWrapperBase.__getitem__(self, k) |
| if k in self._use_conditional_keys: |
| if self._pkg.root_config.settings.local_config and "?" in v: |
| try: |
| v = paren_enclose( |
| use_reduce( |
| v, |
| uselist=self._pkg.use.enabled, |
| is_valid_flag=self._pkg.iuse.is_valid_flag, |
| ) |
| ) |
| except InvalidDependString: |
| # This error should already have been registered via |
| # self._pkg._invalid_metadata(). |
| pass |
| else: |
| self[k] = v |
| |
| elif k == "USE" and not self._pkg.built: |
| if not v: |
| # This is lazy because it's expensive. |
| v = self._pkg._init_use() |
| |
| return v |
| |
| def __setitem__(self, k, v): |
| _PackageMetadataWrapperBase.__setitem__(self, k, v) |
| if k in self._wrapped_keys: |
| getattr(self, "_set_" + k.lower())(k, v) |
| |
| def _set_inherited(self, k, v): |
| if isinstance(v, str): |
| v = frozenset(v.split()) |
| self._pkg.inherited = v |
| |
| def _set_counter(self, k, v): |
| if isinstance(v, str): |
| try: |
| v = int(v.strip()) |
| except ValueError: |
| v = 0 |
| self._pkg.counter = v |
| |
| def _set_use(self, k, v): |
| # Force regeneration of _use attribute |
| self._pkg._use = None |
| # Use raw metadata to restore USE conditional values |
| # to unevaluated state |
| raw_metadata = self._pkg._raw_metadata |
| for x in self._use_conditional_keys: |
| try: |
| self[x] = raw_metadata[x] |
| except KeyError: |
| pass |
| |
| def _set__mtime_(self, k, v): |
| if isinstance(v, str): |
| try: |
| v = int(v.strip()) |
| except ValueError: |
| v = 0 |
| self._pkg.mtime = v |
| |
| @property |
| def properties(self): |
| return self["PROPERTIES"].split() |
| |
| @property |
| def restrict(self): |
| return self["RESTRICT"].split() |
| |
| @property |
| def defined_phases(self): |
| """ |
| Returns tokens from DEFINED_PHASES metadata if it is defined, |
| otherwise returns a tuple containing all possible phases. This |
| makes it easy to do containment checks to see if it's safe to |
| skip execution of a given phase. |
| """ |
| s = self["DEFINED_PHASES"] |
| if s: |
| return s.split() |
| return EBUILD_PHASES |
