omlish 0.0.0.dev407__tar.gz → 0.0.0.dev408__tar.gz

{omlish-0.0.0.dev407/omlish.egg-info → omlish-0.0.0.dev408}/PKG-INFO

@@ -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 → omlish-0.0.0.dev408}/omlish/__about__.py

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

omlish-0.0.0.dev408/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-0.0.0.dev407 → omlish-0.0.0.dev408}/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-0.0.0.dev407 → omlish-0.0.0.dev408}/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-0.0.0.dev407 → omlish-0.0.0.dev408}/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 → omlish-0.0.0.dev408/omlish.egg-info}/PKG-INFO

@@ -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 → omlish-0.0.0.dev408}/omlish.egg-info/SOURCES.txt

@@ -380,6 +380,7 @@ omlish/inject/injector.py
 omlish/inject/inspect.py
 omlish/inject/keys.py
 omlish/inject/listeners.py
+omlish/inject/lite.py
 omlish/inject/managed.py
 omlish/inject/multis.py
 omlish/inject/origins.py

{omlish-0.0.0.dev407 → omlish-0.0.0.dev408}/pyproject.toml

@@ -13,7 +13,7 @@ urls = {source = 'https://github.com/wrmsr/omlish'}
 license = 'BSD-3-Clause'
 readme = 'README.md'
 requires-python = '>=3.13'
-version = '0.0.0.dev407'
+version = '0.0.0.dev408'
 classifiers = [
     'Development Status :: 2 - Pre-Alpha',
     'Intended Audience :: Developers',