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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev407'
-__revision__ = '069daca807ba62f298b1fef1de82247d29c345c0'
+__version__ = '0.0.0.dev408'
+__revision__ = '5d4bd94d19abed3d89f070bc4748ab16aed6c9dc'
 
 
 #

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/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-0.0.0.dev407.dist-info → omlish-0.0.0.dev408.dist-info}/METADATA

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

{omlish-0.0.0.dev407.dist-info → omlish-0.0.0.dev408.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=uoNyxmEJL6Is-2YBuCTc7ay-o0M0jllCRS1Wi5csIrc,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
@@ -464,8 +465,8 @@ omlish/lang/classes/simple.py,sha256=9blmJdi4c15zyIEbNVjkA0ZTSImQbv4g0p2Il6knWAc
 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/lazy.py,sha256=Fhtb5tSAttff6G2pZdF8bh__GZlqJWHaMKtA8KubuX4,1479
+omlish/lang/imports/proxyinit.py,sha256=ALpV9LahE8SQl6jNO92Mk4PcaQPce9Cv53K8AwnH5fQ,16749
 omlish/lang/imports/resolution.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
@@ -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
@@ -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.dev408.dist-info/licenses/LICENSE,sha256=B_hVtavaA8zCYDW99DYdcpDLKz1n3BBRjZrcbv8uG8c,1451
+omlish-0.0.0.dev408.dist-info/METADATA,sha256=Qr8WqkJANqZkuNa9T-p-EbysqP66teV_LtOK3df82pw,18881
+omlish-0.0.0.dev408.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+omlish-0.0.0.dev408.dist-info/entry_points.txt,sha256=Lt84WvRZJskWCAS7xnQGZIeVWksprtUHj0llrvVmod8,35
+omlish-0.0.0.dev408.dist-info/top_level.txt,sha256=pePsKdLu7DvtUiecdYXJ78iO80uDNmBlqe-8hOzOmfs,7
+omlish-0.0.0.dev408.dist-info/RECORD,,