omlish 0.0.0.dev407__py3-none-any.whl → 0.0.0.dev409__py3-none-any.whl

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev407'
-__revision__ = '069daca807ba62f298b1fef1de82247d29c345c0'
+__version__ = '0.0.0.dev409'
+__revision__ = '9ee675d7bba914e838f5f8ce55dc0af32638a52c'
 
 
 #

omlish/inject/lite.py

@@ -0,0 +1,112 @@
+"""
+TODO:
+ - explicit blacklisted key element - blacklist lite Injector
+"""
+import dataclasses as dc
+import typing as ta
+
+from .. import check
+from .. import reflect as rfl
+from ..lite import inject as lij
+from .bindings import Binding
+from .elements import Elements
+from .keys import Key
+from .providers import ConstProvider
+from .providers import CtorProvider
+from .providers import FnProvider
+from .providers import LinkProvider
+from .providers import Provider
+from .scopes import Singleton
+from .types import Scope
+from .types import Unscoped
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class BoxedLiteProvider:
+    p: Provider
+    sc: Scope | None = None
+
+
+##
+
+
+@ta.overload
+def convert_from_lite(o: lij.InjectorBindings) -> Elements:
+    ...
+
+
+@ta.overload
+def convert_from_lite(o: lij.InjectorKey) -> Key:
+    ...
+
+
+@ta.overload
+def convert_from_lite(o: lij.InjectorBinding) -> Binding:
+    ...
+
+
+@ta.overload
+def convert_from_lite(o: lij.InjectorProvider) -> BoxedLiteProvider:
+    ...
+
+
+def convert_from_lite(o):
+    if isinstance(o, lij.InjectorBindings):
+        return Elements([
+            convert_from_lite(c)
+            for c in o.bindings()
+        ])
+
+    elif isinstance(o, lij.InjectorKey):
+        check.not_equal(o.cls_, lij.InjectorKeyCls)
+        check.arg(not o.array)
+        return Key(rfl.type_(o.cls_), tag=o.tag)
+
+    elif isinstance(o, lij.InjectorBinding):
+        blp = convert_from_lite(o.provider)
+        return Binding(
+            convert_from_lite(o.key),
+            blp.p,
+            blp.sc if blp.sc is not None else Unscoped(),
+        )
+
+    elif isinstance(o, lij.InjectorProvider):
+        if isinstance(o, lij.FnInjectorProvider):
+            return BoxedLiteProvider(FnProvider(
+                o.fn,
+            ))
+
+        elif isinstance(o, lij.CtorInjectorProvider):
+            return BoxedLiteProvider(CtorProvider(
+                o.cls_,
+            ))
+
+        elif isinstance(o, lij.ConstInjectorProvider):
+            return BoxedLiteProvider(ConstProvider(
+                o.v,
+            ))
+
+        elif isinstance(o, lij.SingletonInjectorProvider):
+            blp = convert_from_lite(o.p)
+            check.none(blp.sc)
+            return dc.replace(
+                blp,
+                sc=Singleton(),
+            )
+
+        elif isinstance(o, lij.LinkInjectorProvider):
+            return BoxedLiteProvider(LinkProvider(
+                convert_from_lite(o.k),
+            ))
+
+        elif isinstance(o, lij.ScopedInjectorProvider):
+            raise NotImplementedError
+
+        else:
+            raise TypeError(o)
+
+    else:
+        raise TypeError(o)

omlish/lang/__init__.py

@@ -237,7 +237,7 @@ from .imports.proxyinit import (  # noqa
     auto_proxy_init,
 )
 
-from .imports.resolution import (  # noqa
+from .imports.resolving import (  # noqa
     can_import,
     get_real_module_name,
     resolve_import_name,

omlish/lang/imports/conditional.py

@@ -1,6 +1,6 @@
 import sys
 
-from .resolution import resolve_import_name
+from .resolving import resolve_import_name
 
 
 ##

omlish/lang/imports/lazy.py

@@ -62,5 +62,5 @@ def proxy_import(
         return getattr(omod, att)
 
     lmod = types.ModuleType(name)
-    lmod.__getattr__ = __getattr__  # type: ignore
+    lmod.__getattr__ = __getattr__  # type: ignore[method-assign]
     return lmod

omlish/lang/imports/proxyinit.py

@@ -1,10 +1,3 @@
-"""
-TODO:
- - auto_proxy_init can capture `import as` by scanning globals for sentinels
-  - replaces _AutoProxyInitCapture._attrs dict outright
-  - should raise on unbound or shadowed import - was probably imported for side-effects but will never get
-    proxy imported
-"""
 import builtins
 import contextlib
 import functools
@@ -18,12 +11,11 @@ from ..lazyglobals import LazyGlobals
 ##
 
 
-class NamePackage(ta.NamedTuple):
-    name: str
-    package: str
-
-
 class _ProxyInit:
+    class NamePackage(ta.NamedTuple):
+        name: str
+        package: str
+
     class _Import(ta.NamedTuple):
         pkg: str
         attr: str | None
@@ -48,26 +40,16 @@ class _ProxyInit:
     def add(
             self,
             package: str,
-            attrs: ta.Iterable[str | tuple[str, str]] | None = None,
+            attrs: ta.Iterable[tuple[str | None, str]],
     ) -> None:
-        if isinstance(attrs, str):
-            raise TypeError(attrs)
-
-        if attrs is None:
-            whole_attr = package.split('.')[-1]
+        for imp_attr, as_attr in attrs:
+            if imp_attr is None:
+                self._imps_by_attr[as_attr] = self._Import(package, None)
+                self._lazy_globals.set_fn(as_attr, functools.partial(self.get, as_attr))
 
-            self._imps_by_attr[whole_attr] = self._Import(package, None)
-            self._lazy_globals.set_fn(whole_attr, functools.partial(self.get, whole_attr))
-
-        else:
-            for attr in attrs:
-                if isinstance(attr, tuple):
-                    imp_attr, attr = attr
-                else:
-                    imp_attr = attr
-
-                self._imps_by_attr[attr] = self._Import(package, imp_attr)
-                self._lazy_globals.set_fn(attr, functools.partial(self.get, attr))
+            else:
+                self._imps_by_attr[as_attr] = self._Import(package, imp_attr)
+                self._lazy_globals.set_fn(as_attr, functools.partial(self.get, as_attr))
 
     def _import_module(self, name: str) -> ta.Any:
         return importlib.import_module(name, package=self._name_package.package)
@@ -98,12 +80,38 @@ class _ProxyInit:
 def proxy_init(
         init_globals: ta.MutableMapping[str, ta.Any],
         package: str,
-        attrs: ta.Iterable[str | tuple[str, str]] | None = None,
+        attrs: ta.Iterable[str | tuple[str | None, str | None] | None] | None = None,
 ) -> None:
     if isinstance(attrs, str):
         raise TypeError(attrs)
 
-    init_name_package = NamePackage(
+    if attrs is None:
+        attrs = [None]
+
+    whole_attr = package.split('.')[-1]
+    al: list[tuple[str | None, str]] = []
+    for attr in attrs:
+        if attr is None:
+            al.append((None, whole_attr))
+
+        elif isinstance(attr, str):
+            al.append((attr, attr))
+
+        elif isinstance(attr, tuple):
+            imp_attr, as_attr = attr
+            if as_attr is None:
+                if imp_attr is None:
+                    as_attr = whole_attr
+                else:
+                    as_attr = imp_attr
+            al.append((imp_attr, as_attr))
+
+        else:
+            raise TypeError(attr)
+
+    #
+
+    init_name_package = _ProxyInit.NamePackage(
         init_globals['__name__'],
         init_globals['__package__'],
     )
@@ -123,7 +131,7 @@ def proxy_init(
         if pi.name_package != init_name_package:
             raise Exception(f'Wrong init name: {pi.name_package=} != {init_name_package=}')
 
-    pi.add(package, attrs)
+    pi.add(package, al)
 
 
 ##
@@ -166,6 +174,15 @@ class AutoProxyInitErrors:
     class UnproxiedImportForbiddenError(ImportError):
         pass
 
+    class UnreferencedImportsError(AutoProxyInitError):
+        def __init__(self, unreferenced: ta.Mapping[str, ta.Sequence[str | None]]) -> None:
+            super().__init__()
+
+            self.unreferenced = unreferenced
+
+        def __repr__(self) -> str:
+            return f'{self.__class__.__qualname__}(unreferenced={self.unreferenced!r})'
+
 
 class _AutoProxyInitCapture:
     class ModuleSpec(ta.NamedTuple):
@@ -178,8 +195,22 @@ class _AutoProxyInitCapture:
         def __repr__(self) -> str:
             return repr(str(self))
 
+    def __init__(self) -> None:
+        super().__init__()
+
+        self._modules_by_spec: dict[_AutoProxyInitCapture.ModuleSpec, _AutoProxyInitCapture._Module] = {}
+        self._modules_by_module_obj: dict[types.ModuleType, _AutoProxyInitCapture._Module] = {}
+
+        self._attrs: dict[_AutoProxyInitCapture._ModuleAttr, tuple[_AutoProxyInitCapture._Module, str]] = {}
+
+    #
+
     class _ModuleAttr:
-        def __init__(self, module: '_AutoProxyInitCapture._Module', name: str) -> None:
+        def __init__(
+                self,
+                module: '_AutoProxyInitCapture._Module',
+                name: str,
+        ) -> None:
             super().__init__()
 
             self.__module = module
@@ -189,24 +220,62 @@ class _AutoProxyInitCapture:
             return f'<{self.__class__.__name__}: {f"{self.__module.spec}:{self.__name}"!r}>'
 
     class _Module:
-        def __init__(self, spec: '_AutoProxyInitCapture.ModuleSpec') -> None:
+        def __init__(
+                self,
+                spec: '_AutoProxyInitCapture.ModuleSpec',
+                *,
+                getattr_handler: ta.Callable[['_AutoProxyInitCapture._Module', str], ta.Any] | None = None,
+        ) -> None:
             super().__init__()
 
             self.spec = spec
 
-            self.module = types.ModuleType(f'<{self.__class__.__qualname__}: {spec!r}>')
+            self.module_obj = types.ModuleType(f'<{self.__class__.__qualname__}: {spec!r}>')
+            if getattr_handler is not None:
+                self.module_obj.__getattr__ = functools.partial(getattr_handler, self)  # type: ignore[method-assign]  # noqa
+            self.initial_module_dict = dict(self.module_obj.__dict__)
 
-            self.attrs: dict[str, _AutoProxyInitCapture._ModuleAttr] = {}
+            self.contents: dict[str, _AutoProxyInitCapture._ModuleAttr | types.ModuleType] = {}
             self.imported_whole = False
 
         def __repr__(self) -> str:
             return f'{self.__class__.__name__}({self.spec!r})'
 
-    def __init__(self) -> None:
-        super().__init__()
+    def _get_or_make_module(self, spec: ModuleSpec) -> _Module:
+        try:
+            return self._modules_by_spec[spec]
+        except KeyError:
+            pass
 
-        self._modules: dict[_AutoProxyInitCapture.ModuleSpec, _AutoProxyInitCapture._Module] = {}
-        self._attrs: dict[str, _AutoProxyInitCapture._ModuleAttr | _AutoProxyInitCapture._Module] = {}
+        module = self._Module(
+            spec,
+            getattr_handler=self._handle_module_getattr,
+        )
+        self._modules_by_spec[spec] = module
+        self._modules_by_module_obj[module.module_obj] = module
+        return module
+
+    def _handle_module_getattr(self, module: _Module, attr: str) -> ta.Any:
+        if attr in module.contents:
+            raise AutoProxyInitErrors.AttrError(str(module.spec), attr)
+
+        v: _AutoProxyInitCapture._ModuleAttr | types.ModuleType
+        if not module.spec.name:
+            if not module.spec.level:
+                raise AutoProxyInitError
+            cs = _AutoProxyInitCapture.ModuleSpec(attr, module.spec.level)
+            cm = self._get_or_make_module(cs)
+            cm.imported_whole = True
+            v = cm.module_obj
+
+        else:
+            ma = _AutoProxyInitCapture._ModuleAttr(module, attr)
+            self._attrs[ma] = (module, attr)
+            v = ma
+
+        module.contents[attr] = v
+        setattr(module.module_obj, attr, v)
+        return v
 
     def _handle_import(
             self,
@@ -218,23 +287,6 @@ class _AutoProxyInitCapture:
             if module.spec.level or not module.spec.name:
                 raise AutoProxyInitError
 
-            attr = module.spec.name
-
-            try:
-                xma: ta.Any = self._attrs[attr]
-            except KeyError:
-                pass
-
-            else:
-                if (
-                        xma is not self._attrs.get(attr) or
-                        not module.imported_whole
-                ):
-                    raise AutoProxyInitErrors.AttrError(str(module.spec), attr)
-
-                return
-
-            self._attrs[attr] = module
             module.imported_whole = True
 
         else:
@@ -242,27 +294,23 @@ class _AutoProxyInitCapture:
                 if attr == '*':
                     raise AutoProxyInitErrors.ImportStarForbiddenError(str(module.spec), from_list)
 
-                try:
-                    xma = getattr(module.module, attr)
-                except AttributeError:
-                    pass
-
+                x = getattr(module.module_obj, attr)
+
+                bad = False
+                if x is not module.contents.get(attr):
+                    bad = True
+                if isinstance(x, _AutoProxyInitCapture._ModuleAttr):
+                    if self._attrs[x] != (module, attr):
+                        bad = True
+                elif isinstance(x, types.ModuleType):
+                    if x not in self._modules_by_module_obj:
+                        bad = True
                 else:
-                    if (
-                            xma is not module.attrs.get(attr) or
-                            xma is not self._attrs.get(attr)
-                    ):
-                        raise AutoProxyInitErrors.AttrError(str(module.spec), attr)
-
-                    continue
-
-                if attr in self._attrs:
+                    bad = True
+                if bad:
                     raise AutoProxyInitErrors.AttrError(str(module.spec), attr)
 
-                ma = _AutoProxyInitCapture._ModuleAttr(module, attr)
-                self._attrs[attr] = ma
-                module.attrs[attr] = ma
-                setattr(module.module, attr, ma)
+    #
 
     _MOD_SELF_ATTR: ta.ClassVar[str] = '__auto_proxy_init_capture__'
 
@@ -281,18 +329,14 @@ class _AutoProxyInitCapture:
             return None
 
         spec = _AutoProxyInitCapture.ModuleSpec(name, level)
-        try:
-            module = self._modules[spec]
-        except KeyError:
-            module = self._Module(spec)
-            self._modules[spec] = module
+        module = self._get_or_make_module(spec)
 
         self._handle_import(
             module,
             from_list=from_list,
         )
 
-        return module.module
+        return module.module_obj
 
     @contextlib.contextmanager
     def hook_context(
@@ -353,54 +397,103 @@ class _AutoProxyInitCapture:
             del init_globals[self._MOD_SELF_ATTR]
             builtins.__import__ = old_import
 
-    def verify_globals(
+    #
+
+    def verify_state(
             self,
             init_globals: ta.MutableMapping[str, ta.Any],  # noqa
     ) -> None:
-        for attr, obj in self._attrs.items():
-            try:
-                xo = init_globals[attr]
-            except KeyError:
-                raise AutoProxyInitErrors.AttrError(None, attr) from None
+        for m in self._modules_by_spec.values():
+            for a, o in m.module_obj.__dict__.items():
+                try:
+                    i = m.initial_module_dict[a]
 
-            if isinstance(obj, _AutoProxyInitCapture._ModuleAttr):
-                if xo is not obj:
-                    raise AutoProxyInitErrors.AttrError(None, attr) from None
+                except KeyError:
+                    if o is not m.contents[a]:
+                        raise AutoProxyInitErrors.AttrError(str(m.spec), a) from None
 
-            elif isinstance(obj, _AutoProxyInitCapture._Module):
-                if xo is not obj.module:
-                    raise AutoProxyInitErrors.AttrError(None, attr) from None
+                else:
+                    if o != i:
+                        raise AutoProxyInitErrors.AttrError(str(m.spec), a)
 
-            else:
-                raise TypeError(obj)
-
-    @property
-    def all_attrs(self) -> ta.AbstractSet[str]:
-        return self._attrs.keys()
+    #
 
     class ProxyInit(ta.NamedTuple):
         package: str
-        attrs: ta.Sequence[str] | None
+        attrs: ta.Sequence[tuple[str | None, str]]
 
-    def build_proxy_inits(self) -> list[ProxyInit]:
-        lst: list[_AutoProxyInitCapture.ProxyInit] = []
+    class BuiltProxyInits(ta.NamedTuple):
+        proxy_inits: ta.Sequence['_AutoProxyInitCapture.ProxyInit']
+        unreferenced: ta.Mapping[str, ta.Sequence[str | None]] | None
 
-        for module in self._modules.values():
-            if module.imported_whole:
-                lst.append(_AutoProxyInitCapture.ProxyInit(str(module.spec), None))
+    def build_proxy_inits(
+            self,
+            init_globals: ta.MutableMapping[str, ta.Any],  # noqa
+            *,
+            collect_unreferenced: bool = False,
+    ) -> BuiltProxyInits:
+        dct: dict[_AutoProxyInitCapture._Module, list[tuple[str | None, str]]] = {}
 
-            if module.attrs:
-                if not module.spec.name:
-                    for attr in module.attrs:
-                        if not module.spec.level:
-                            raise AutoProxyInitError
+        rem_whole_mods: set[_AutoProxyInitCapture._Module] = set()
+        rem_mod_attrs: set[_AutoProxyInitCapture._ModuleAttr] = set()
+        if collect_unreferenced:
+            rem_whole_mods.update([m for m in self._modules_by_spec.values() if m.imported_whole])
+            rem_mod_attrs.update(self._attrs)
 
-                        lst.append(_AutoProxyInitCapture.ProxyInit('.' * module.spec.level + attr, None))
+        for attr, obj in init_globals.items():
+            if isinstance(obj, _AutoProxyInitCapture._ModuleAttr):
+                try:
+                    m, a = self._attrs[obj]
+                except KeyError:
+                    raise AutoProxyInitErrors.AttrError(None, attr) from None
+                dct.setdefault(m, []).append((a, attr))
+                rem_mod_attrs.discard(obj)
 
-                else:
-                    lst.append(_AutoProxyInitCapture.ProxyInit(str(module.spec), list(module.attrs)))
+            elif isinstance(obj, _AutoProxyInitCapture._Module):
+                raise AutoProxyInitErrors.AttrError(None, attr) from None
 
-        return lst
+            elif isinstance(obj, types.ModuleType):
+                try:
+                    m = self._modules_by_module_obj[obj]
+                except KeyError:
+                    continue
+                if not m.imported_whole:
+                    raise RuntimeError(f'AutoProxyInit module {m.spec!r} not imported_whole')
+                dct.setdefault(m, []).append((None, attr))
+                rem_whole_mods.discard(m)
+
+        lst: list[_AutoProxyInitCapture.ProxyInit] = []
+        for m, ts in dct.items():
+            if not m.spec.name:
+                if not m.spec.level:
+                    raise AutoProxyInitError
+                for imp_attr, as_attr in ts:
+                    if not imp_attr:
+                        raise RuntimeError
+                    lst.append(_AutoProxyInitCapture.ProxyInit(
+                        '.' * m.spec.level + imp_attr,
+                        [(None, as_attr)],
+                    ))
+
+            else:
+                lst.append(_AutoProxyInitCapture.ProxyInit(
+                    str(m.spec),
+                    ts,
+                ))
+
+        unreferenced: dict[str, list[str | None]] | None = None
+        if collect_unreferenced and (rem_whole_mods or rem_mod_attrs):
+            unreferenced = {}
+            for m in rem_whole_mods:
+                unreferenced.setdefault(str(m.spec), []).append(None)
+            for ma in rem_mod_attrs:
+                m, a = self._attrs[ma]
+                unreferenced.setdefault(str(m.spec), []).append(a)
+
+        return _AutoProxyInitCapture.BuiltProxyInits(
+            lst,
+            unreferenced,
+        )
 
 
 @contextlib.contextmanager
@@ -409,6 +502,9 @@ def auto_proxy_init(
         *,
         disable: bool = False,
         eager: bool = False,
+
+        unreferenced_callback: ta.Callable[[ta.Mapping[str, ta.Sequence[str | None]]], None] | None = None,
+        raise_unreferenced: bool = False,
 ) -> ta.Iterator[None]:
     """
     This is a bit extreme - use sparingly. It relies on an interpreter-global import lock, but much of the ecosystem
@@ -425,14 +521,23 @@ def auto_proxy_init(
     with cap.hook_context(init_globals):
         yield
 
-    cap.verify_globals(init_globals)
+    cap.verify_state(init_globals)
 
-    pis = cap.build_proxy_inits()
+    blt = cap.build_proxy_inits(
+        init_globals,
+        collect_unreferenced=unreferenced_callback is not None or raise_unreferenced,
+    )
 
-    for attr in cap.all_attrs:
-        del init_globals[attr]
+    if blt.unreferenced:
+        if unreferenced_callback:
+            unreferenced_callback(blt.unreferenced)
+        if raise_unreferenced:
+            raise AutoProxyInitErrors.UnreferencedImportsError(blt.unreferenced)
+
+    for pi in blt.proxy_inits:
+        for _, a in pi.attrs:
+            del init_globals[a]
 
-    for pi in pis:
         proxy_init(
             init_globals,
             pi.package,
@@ -441,5 +546,7 @@ def auto_proxy_init(
 
     if eager:
         lg = LazyGlobals.install(init_globals)
-        for attr in cap.all_attrs:
-            lg.get(attr)
+
+        for pi in blt.proxy_inits:
+            for _, a in pi.attrs:
+                lg.get(a)

omlish/lite/inject.py

@@ -19,6 +19,7 @@ from .reflect import is_optional_alias
 T = ta.TypeVar('T')
 U = ta.TypeVar('U')
 
+
 InjectorKeyCls = ta.Union[type, ta.NewType]
 
 InjectorProviderFn = ta.Callable[['Injector'], ta.Any]

omlish/manifests/loading.py

@@ -209,6 +209,7 @@ class ManifestLoader:
     @classmethod
     def _discover_packages_uncached(cls) -> ta.Sequence[str]:
         from importlib import metadata as importlib_metadata  # noqa
+
         return [
             ep.value
             for ep in importlib_metadata.entry_points(group=cls.ENTRY_POINT_GROUP)
@@ -262,35 +263,31 @@ class ManifestLoader:
 
     ##
 
-    _detected_packages: ta.Set[str]
-
-    def _do_initialize(self) -> None:
-        self._detected_packages = set()
+    def _detect_packages_uncached(self) -> ta.AbstractSet[str]:
+        ret: ta.Set[str] = set()
 
         for r in self._config.package_scan_root_dirs or []:
-            self._detected_packages.update(self._scan_package_root_dir_locked(r))
+            ret.update(self._scan_package_root_dir_locked(r))
 
         if self._config.discover_packages:
-            self._detected_packages.update(dps := self.discover_packages())
+            ret.update(dps := self.discover_packages())
             if not dps:
                 for r in self._config.discover_packages_fallback_scan_root_dirs or []:
-                    self._detected_packages.update(self._scan_package_root_dir_locked(r))
+                    ret.update(self._scan_package_root_dir_locked(r))
 
-    _has_initialized = False
+        return ret
 
-    def _initialize_locked(self) -> None:
-        if not self._has_initialized:
-            self._do_initialize()
-            self._has_initialized = True
+    _detected_packages: ta.Optional[ta.AbstractSet[str]] = None
 
-    def has_initialized(self) -> bool:
-        with self._lock:
-            return self._has_initialized
+    def _detect_packages_locked(self) -> ta.AbstractSet[str]:
+        if self._detected_packages is None:
+            self._detected_packages = self._detect_packages_uncached()
 
-    def initialize(self) -> None:
-        if not self._has_initialized:
-            with self._lock:
-                self._initialize_locked()
+        return self._detected_packages
+
+    def detect_packages(self) -> ta.AbstractSet[str]:
+        with self._lock:
+            return self._detect_packages_locked()
 
     ##
 
@@ -429,6 +426,7 @@ class ManifestLoader:
                     return f.read()
 
         from importlib import resources as importlib_resources  # noqa
+
         t = importlib_resources.files(package_name).joinpath(file_name)
         if not t.is_file():
             return None
@@ -497,7 +495,7 @@ class ManifestLoader:
 
     ##
 
-    def _load_initialized(
+    def _load_locked(
             self,
             *,
             packages: ta.Optional[ta.Collection[str]] = None,
@@ -511,7 +509,7 @@ class ManifestLoader:
             class_keys = {self.get_class_key(cls) for cls in classes}
 
         if packages is None:
-            packages = self._detected_packages
+            packages = self._detect_packages_locked()
 
         lst: ta.List[ManifestLoader.LoadedManifest] = []
         for pn in packages:
@@ -527,18 +525,6 @@ class ManifestLoader:
 
         return lst
 
-    def _load_locked(
-            self,
-            *,
-            packages: ta.Optional[ta.Collection[str]] = None,
-            classes: ta.Optional[ta.Collection[type]] = None,
-    ) -> ta.Sequence[LoadedManifest]:
-        self._initialize_locked()
-        return self._load_initialized(
-            packages=packages,
-            classes=classes,
-        )
-
     def load(
             self,
             *,

{omlish-0.0.0.dev407.dist-info → omlish-0.0.0.dev409.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev407
+Version: 0.0.0.dev409
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause

{omlish-0.0.0.dev407.dist-info → omlish-0.0.0.dev409.dist-info}/RECORD

@@ -1,5 +1,5 @@
 omlish/.manifests.json,sha256=FLw7xkPiSXuImZgqSP8BwrEib2R1doSzUPLUkc-QUIA,8410
-omlish/__about__.py,sha256=O8Q9qajIb2jh65cp6pHJd0NZKoPAJTNlKXkbL_Ozf_4,3601
+omlish/__about__.py,sha256=4QkSZDk0KGwNDUXL28RW4dosDTkKwvPxAM7iBzddM4g,3601
 omlish/__init__.py,sha256=SsyiITTuK0v74XpKV8dqNaCmjOlan1JZKrHQv5rWKPA,253
 omlish/c3.py,sha256=rer-TPOFDU6fYq_AWio_AmA-ckZ8JDY5shIzQ_yXfzA,8414
 omlish/cached.py,sha256=MLap_p0rdGoDIMVhXVHm1tsbcWobJF0OanoodV03Ju8,542
@@ -370,6 +370,7 @@ omlish/inject/injector.py,sha256=fyvaRoJXo_oibx1_IiGkncP9oXnZSKtDm7-ULNKRXHE,107
 omlish/inject/inspect.py,sha256=Uq4KMloGWF_YS2mgZbrx-JXhZQnYHHKJSr68i9yoBVc,597
 omlish/inject/keys.py,sha256=7jnI2cw7cvLlzZAfe5SC50O3oPOpOB6iGZGTigyfQvs,682
 omlish/inject/listeners.py,sha256=Ffaun2fVWAgAwKgLdgziJynG_jhAWaaPEsy-2I2Cmpw,599
+omlish/inject/lite.py,sha256=AFOCj_SznDCPjkiVSKdFXL2hH1q2o4kaDnzkxRWDpsI,2615
 omlish/inject/managed.py,sha256=-9aBm1vRPOjNz4kgOmpt8S2T55s727t9RiggFBH8maU,2096
 omlish/inject/multis.py,sha256=Dn63jE8P5ahSKc1IDBdzzx6ByBCgVOth5t4frG9m4UA,3336
 omlish/inject/origins.py,sha256=-qXa18rIIkNwBdTrvASRDjgPYnoY6n6OPC222jJDrXg,551
@@ -425,7 +426,7 @@ omlish/iterators/iterators.py,sha256=RxW35yQ5ed8vBQ22IqpDXFx-i5JiLQdp7-pkMZXhJJ8
 omlish/iterators/recipes.py,sha256=wOwOZg-zWG9Zc3wcAxJFSe2rtavVBYwZOfG09qYEx_4,472
 omlish/iterators/tools.py,sha256=M16LXrJhMdsz5ea2qH0vws30ZvhQuQSCVFSLpRf_gTg,2096
 omlish/iterators/unique.py,sha256=BSE-eanva8byFCJi09Nt2zzTsVr8LnTqY1PIInGYRs0,1396
-omlish/lang/__init__.py,sha256=le8N_Hj6ahtWnG6-gGEo53CK270rDA9wuhh6rUDS9ws,7232
+omlish/lang/__init__.py,sha256=7Xe1YcE2PPgx-NI-V9VTsvUl4qZD0RPANxuDv9ddRXg,7231
 omlish/lang/attrs.py,sha256=zFiVuGVOq88x45464T_LxDa-ZEq_RD9zJLq2zeVEBDc,5105
 omlish/lang/casing.py,sha256=cFUlbDdXLhwnWwcYx4qnM5c4zGX7hIRUfcjiZbxUD28,4636
 omlish/lang/clsdct.py,sha256=HAGIvBSbCefzRjXriwYSBLO7QHKRv2UsE78jixOb-fA,1828
@@ -463,10 +464,10 @@ omlish/lang/classes/restrict.py,sha256=CUyvLpMYiQwTjpzo5sdG_lQxdeEIq2z2xSVNrsI9K
 omlish/lang/classes/simple.py,sha256=9blmJdi4c15zyIEbNVjkA0ZTSImQbv4g0p2Il6knWAc,2539
 omlish/lang/classes/virtual.py,sha256=z0MYQD9Q5MkX8DzF325wDB4J9XoYbsB09jZ1omC62To,3366
 omlish/lang/imports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-omlish/lang/imports/conditional.py,sha256=qxHYlE_xuwPJb6F9K8upagHxuYL0APPLWRVo5079Ipg,1007
-omlish/lang/imports/lazy.py,sha256=gDv7ffrGsPEAHZ9a1Myt7Uf-4vqWErhCd1DaS7SQL0c,1464
-omlish/lang/imports/proxyinit.py,sha256=prcQSZYdXSvZLsWZClNSOhIJVHNMuO8nD9NTtG-fFv4,12636
-omlish/lang/imports/resolution.py,sha256=DeRarn35Fryg5JhVhy8wbiC9lvr58AnllI9B_reswUE,2085
+omlish/lang/imports/conditional.py,sha256=R-E47QD95mMonPImWlrde3rnJrFKCCkYz71c94W05sc,1006
+omlish/lang/imports/lazy.py,sha256=Fhtb5tSAttff6G2pZdF8bh__GZlqJWHaMKtA8KubuX4,1479
+omlish/lang/imports/proxyinit.py,sha256=ALpV9LahE8SQl6jNO92Mk4PcaQPce9Cv53K8AwnH5fQ,16749
+omlish/lang/imports/resolving.py,sha256=DeRarn35Fryg5JhVhy8wbiC9lvr58AnllI9B_reswUE,2085
 omlish/lang/imports/traversal.py,sha256=pbFQIa880NGjSfcLsno2vE_G41_CLwDHb-7gWg2J3BI,2855
 omlish/lifecycles/__init__.py,sha256=1FjYceXs-4fc-S-C9zFYmc2axHs4znnQHcJVHdY7a6E,578
 omlish/lifecycles/abstract.py,sha256=c9UY7oxzYZ_neh5DPE4yv5HfuDv7B4Mj_9Zo-B8KDSs,1114
@@ -484,7 +485,7 @@ omlish/lite/configs.py,sha256=4-1uVxo-aNV7vMKa7PVNhM610eejG1WepB42-Dw2xQI,914
 omlish/lite/contextmanagers.py,sha256=QEqVxUtmr9aJJ_03A-YC4vVUy8jkiIDCYIGIOlXvn8U,5827
 omlish/lite/dataclasses.py,sha256=aRSCZz1jN_UI-CWJhN0SJeKxa-79vXNUZ6YOMgG31SE,3610
 omlish/lite/imports.py,sha256=GyEDKL-WuHtdOKIL-cc8aFd0-bHwZFDEjAB52ItabX0,1341
-omlish/lite/inject.py,sha256=WC5uazLkxAF5QB2dq6qgrhKXkRwkANqO2oGD0G6C_k8,29021
+omlish/lite/inject.py,sha256=SJt0KjvzMz3vBswYhVbiA0cQqxzZO7HmsGvdtjkwgg4,29022
 omlish/lite/json.py,sha256=m0Ce9eqUZG23-H7-oOp8n1sf4fzno5vtK4AK_4Vc-Mg,706
 omlish/lite/logs.py,sha256=CWFG0NKGhqNeEgryF5atN2gkPYbUdTINEw_s1phbINM,51
 omlish/lite/marshal.py,sha256=K_wnZwfC8cftGILyE3RlmzQEYuZOfzkMLKey41zuwtM,20296
@@ -519,7 +520,7 @@ omlish/logs/utils.py,sha256=OkFWf1exmWImmT7BaSiIC7c0Fk9tAis-PRqo8H4ny3c,398
 omlish/manifests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 omlish/manifests/base.py,sha256=Dt44a3qppWaxkoi3naFFMetxbxw14qnz2naTKK93GNU,915
 omlish/manifests/globals.py,sha256=kVqQ-fT4kc7xWzLHoI731GviitFPv2v2yqw-p7t7Exs,2628
-omlish/manifests/loading.py,sha256=guLx-3y4rqQ2YIgTtqlpCk59inePtcEUE19JrWDzleM,17639
+omlish/manifests/loading.py,sha256=Br1OyI23pis_FfYju9xoacms608lzB1Zh_IqdVw_7vg,17201
 omlish/manifests/static.py,sha256=9BaPBLkuzxHmg5A-5k9BjjBFINCdmFOIu06dMFgCfz4,497
 omlish/manifests/types.py,sha256=NeOGuIVrcbqjCDbQ3MnCxxHAgHnw0CkWJsBzo230PWE,453
 omlish/marshal/.dataclasses.json,sha256=wXWUy_IR8AolAa2RQnqn_mo2QnmVcvUJmayIykdVl0I,22
@@ -908,9 +909,9 @@ omlish/typedvalues/marshal.py,sha256=AtBz7Jq-BfW8vwM7HSxSpR85JAXmxK2T0xDblmm1HI0
 omlish/typedvalues/of_.py,sha256=UXkxSj504WI2UrFlqdZJbu2hyDwBhL7XVrc2qdR02GQ,1309
 omlish/typedvalues/reflect.py,sha256=PAvKW6T4cW7u--iX80w3HWwZUS3SmIZ2_lQjT65uAyk,1026
 omlish/typedvalues/values.py,sha256=ym46I-q2QJ_6l4UlERqv3yj87R-kp8nCKMRph0xQ3UA,1307
-omlish-0.0.0.dev407.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
-omlish-0.0.0.dev407.dist-info/METADATA,sha256=zAQhPHsAgpSKxDHdzuCl9iDtCb-tRFEYeRuMln15HoE,18881
-omlish-0.0.0.dev407.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-omlish-0.0.0.dev407.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
-omlish-0.0.0.dev407.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
-omlish-0.0.0.dev407.dist-info/RECORD,,
+omlish-0.0.0.dev409.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev409.dist-info/METADATA,sha256=fCzoIaINPTeVtCOvdUmzuUWQqKIGW40xgEmeKO4bIxg,18881
+omlish-0.0.0.dev409.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omlish-0.0.0.dev409.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev409.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev409.dist-info/RECORD,,