def __new__(cls, name, bases, d): if '__del__' in d: d['__finalizer__'] = d.pop("__del__") elif '__finalizer__' not in d and not \ any(hasattr(parent, "__finalizer__") for parent in bases): raise TypeError( "cls %s doesn't have either __del__ nor a __finalizer__" % (name, )) if '__disable_finalization__' not in d and not \ any(hasattr(parent, "__disable_finalization__") for parent in bases): # install tracking d['__disable_finalization__'] = __disable_finalization__ d['__enable_finalization__'] = __enable_finalization__ # install tracking bits. We do this per class- this is intended to # avoid any potential stupid subclasses wiping a parents tracking. d['__finalizer_weakrefs__'] = defaultdict(dict) new_cls = super(WeakRefFinalizer, cls).__new__(cls, name, bases, d) new_cls.__proxy_class__ = partial(make_kls(new_cls, WeakRefProxy), cls, lambda x: x) new_cls.__proxy_class__.__name__ = name cls.__known_classes__[new_cls] = True return new_cls
def __init__(self, raw_repo, domain, domain_settings, fetcher=None): """ :param raw_repo: :obj:`_UnconfiguredTree` instance :param domain_settings: environment settings to bind :param fetcher: :obj:`pkgcore.fetch.base.fetcher` instance to use for getting access to fetchable files """ if "USE" not in domain_settings: raise errors.InitializationError( "%s requires the following settings: 'USE', not supplied" % ( self.__class__,)) elif 'CHOST' not in domain_settings: raise errors.InitializationError( "%s requires the following settings: 'CHOST', not supplied" % ( self.__class__,)) chost = domain_settings['CHOST'] scope_update = {'chost': chost} scope_update.update((x, domain_settings.get(x.upper(), chost)) for x in ('cbuild', 'ctarget')) scope_update['operations_callback'] = self._generate_pkg_operations self.config_wrappables['iuse_effective'] = partial( self._generate_iuse_effective, domain.profile) configured.tree.__init__(self, raw_repo, self.config_wrappables, pkg_kls_injections=scope_update) self._get_pkg_use = domain.get_package_use_unconfigured self._get_pkg_use_for_building = domain.get_package_use_buildable self.domain_settings = domain_settings self.fetcher_override = fetcher self._delayed_iuse = partial(make_kls(InvertedContains), InvertedContains)
class ConfiguredTree(configured.tree): """Wrapper around a :obj:`UnconfiguredTree` binding build/configuration data (USE).""" configurable = "use" config_wrappables = { x: klass.alias_method("evaluate_depset") for x in ( "bdepend", "depend", "rdepend", "pdepend", "idepend", "fetchables", "license", "src_uri", "restrict", "required_use", ) } def __init__(self, raw_repo, domain, domain_settings): """ :param raw_repo: :obj:`UnconfiguredTree` instance :param domain_settings: environment settings to bind """ required_settings = {'USE', 'CHOST'} if missing_settings := required_settings.difference(domain_settings): s = pluralism(missing_settings) raise errors.InitializationError( f"{self.__class__} missing required setting{s}: " f"{', '.join(map(repr, missing_settings))}") chost = domain_settings['CHOST'] scope_update = {'chost': chost} scope_update.update((x, domain_settings.get(x.upper(), chost)) for x in ('cbuild', 'ctarget')) scope_update.update((x, domain_settings.get(x.upper(), '')) for x in ('cflags', 'cxxflags', 'ldflags')) scope_update['operations_callback'] = self._generate_pkg_operations # update wrapped attr funcs requiring access to the class instance for k, v in self.config_wrappables.items(): if isinstance(v, str): self.config_wrappables[k] = getattr(self, v) super().__init__(raw_repo, self.config_wrappables, pkg_kls_injections=scope_update) self.domain = domain self.domain_settings = domain_settings self._delayed_iuse = partial(make_kls(InvertedContains), InvertedContains)
def __init__(self, raw_repo, domain, domain_settings, fetcher=None): """ :param raw_repo: :obj:`_UnconfiguredTree` instance :param domain_settings: environment settings to bind :param fetcher: :obj:`pkgcore.fetch.base.fetcher` instance to use for getting access to fetchable files """ if "USE" not in domain_settings: raise errors.InitializationError( "%s requires the following settings: 'USE', not supplied" % (self.__class__, )) elif 'CHOST' not in domain_settings: raise errors.InitializationError( "%s requires the following settings: 'CHOST', not supplied" % (self.__class__, )) chost = domain_settings['CHOST'] scope_update = {'chost': chost} scope_update.update((x, domain_settings.get(x.upper(), chost)) for x in ('cbuild', 'ctarget')) scope_update.update((x, domain_settings[x.upper()]) for x in ('cflags', 'cxxflags', 'ldflags')) scope_update['operations_callback'] = self._generate_pkg_operations # update wrapped attr funcs requiring access to the class instance for k, v in self.config_wrappables.iteritems(): if isinstance(v, basestring): self.config_wrappables[k] = getattr(self, v) configured.tree.__init__(self, raw_repo, self.config_wrappables, pkg_kls_injections=scope_update) self._get_pkg_use = domain.get_package_use_unconfigured self._get_pkg_use_for_building = domain.get_package_use_buildable self.domain = domain self.domain_settings = domain_settings self._fetcher_override = fetcher self._delayed_iuse = partial(make_kls(InvertedContains), InvertedContains)
def __new__(cls, name, bases, d): if "__del__" in d: d["__finalizer__"] = d.pop("__del__") elif "__finalizer__" not in d and not any(hasattr(parent, "__finalizer__") for parent in bases): raise TypeError("cls %s doesn't have either __del__ nor a __finalizer__" % (name,)) if "__disable_finalization__" not in d and not any( hasattr(parent, "__disable_finalization__") for parent in bases ): # install tracking d["__disable_finalization__"] = __disable_finalization__ d["__enable_finalization__"] = __enable_finalization__ # install tracking bits. We do this per class- this is intended to # avoid any potential stupid subclasses wiping a parents tracking. d["__finalizer_weakrefs__"] = defaultdict(dict) new_cls = super(WeakRefFinalizer, cls).__new__(cls, name, bases, d) new_cls.__proxy_class__ = partial(make_kls(new_cls, WeakRefProxy), cls, lambda x: x) new_cls.__proxy_class__.__name__ = name cls.__known_classes__[new_cls] = True return new_cls
def __init__(self, raw_repo, domain, domain_settings, fetcher=None): """ :param raw_repo: :obj:`UnconfiguredTree` instance :param domain_settings: environment settings to bind :param fetcher: :obj:`pkgcore.fetch.base.fetcher` instance to use for getting access to fetchable files """ required_settings = {'USE', 'CHOST'} missing_settings = required_settings.difference(domain_settings) if missing_settings: raise errors.InitializationError( f"{self.__class__} missing required setting{_pl(missing_settings)}: " f"{', '.join(map(repr, missing_settings))}") chost = domain_settings['CHOST'] scope_update = {'chost': chost} scope_update.update((x, domain_settings.get(x.upper(), chost)) for x in ('cbuild', 'ctarget')) scope_update.update((x, domain_settings[x.upper()]) for x in ('cflags', 'cxxflags', 'ldflags')) scope_update['operations_callback'] = self._generate_pkg_operations # update wrapped attr funcs requiring access to the class instance for k, v in self.config_wrappables.items(): if isinstance(v, str): self.config_wrappables[k] = getattr(self, v) super().__init__(raw_repo, self.config_wrappables, pkg_kls_injections=scope_update) self.domain = domain self.domain_settings = domain_settings self._fetcher_override = fetcher self._delayed_iuse = partial(make_kls(InvertedContains), InvertedContains)
def __init__(self, raw_repo, domain, domain_settings, fetcher=None): """ :param raw_repo: :obj:`UnconfiguredTree` instance :param domain_settings: environment settings to bind :param fetcher: :obj:`pkgcore.fetch.base.fetcher` instance to use for getting access to fetchable files """ required_settings = {'USE', 'CHOST'} missing_settings = required_settings.difference(domain_settings) if missing_settings: raise errors.InitializationError( f"{self.__class__} missing required setting{_pl(missing_settings)}: " f"{', '.join(map(repr, missing_settings))}") chost = domain_settings['CHOST'] scope_update = {'chost': chost} scope_update.update( (x, domain_settings.get(x.upper(), chost)) for x in ('cbuild', 'ctarget')) scope_update.update( (x, domain_settings[x.upper()]) for x in ('cflags', 'cxxflags', 'ldflags')) scope_update['operations_callback'] = self._generate_pkg_operations # update wrapped attr funcs requiring access to the class instance for k, v in self.config_wrappables.items(): if isinstance(v, str): self.config_wrappables[k] = getattr(self, v) super().__init__( raw_repo, self.config_wrappables, pkg_kls_injections=scope_update) self.domain = domain self.domain_settings = domain_settings self._fetcher_override = fetcher self._delayed_iuse = partial(make_kls(InvertedContains), InvertedContains)