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)
