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

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/lang/objects.py

@@ -166,6 +166,7 @@ class SimpleProxy(ta.Generic[T]):
     class Descriptor:
         def __init__(self, attr: str) -> None:
             super().__init__()
+
             self._attr = attr
 
         def __get__(self, instance, owner=None):
@@ -189,6 +190,7 @@ class SimpleProxy(ta.Generic[T]):
 
     def __init__(self, wrapped: T) -> None:
         super().__init__()
+
         object.__setattr__(self, '__wrapped__', wrapped)
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:

omlish/lang/resolving.py

@@ -59,4 +59,5 @@ def get_fqcn_cls(fqcn: str, *, nocheck: bool = False) -> type:
 class Resolvable:
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
+
         get_cls_fqcn(cls, nocheck=True)

omlish/lifecycles/contextmanagers.py

@@ -33,6 +33,7 @@ class ContextManagerLifecycle(Lifecycle, lang.Final, ta.Generic[ContextManagerT]
 class LifecycleContextManager(ta.Generic[LifecycleT]):
     def __init__(self, lifecycle: LifecycleT) -> None:
         super().__init__()
+
         self._lifecycle = lifecycle
         self._controller = lifecycle if isinstance(lifecycle, LifecycleController) else LifecycleController(lifecycle)
 

omlish/lite/cached.py

@@ -13,6 +13,7 @@ CallableT = ta.TypeVar('CallableT', bound=ta.Callable)
 class _AbstractCachedNullary:
     def __init__(self, fn):
         super().__init__()
+
         self._fn = fn
         self._value = self._missing = object()
         functools.update_wrapper(self, fn)

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]
@@ -402,6 +403,7 @@ class ContextvarInjectorScope(InjectorScope, abc.ABC):
 
     def __init_subclass__(cls, **kwargs: ta.Any) -> None:
         super().__init_subclass__(**kwargs)
+
         check.not_in(abc.ABC, cls.__bases__)
         check.state(not hasattr(cls, '_cv'))
         cls._cv = contextvars.ContextVar(f'{cls.__name__}_cv')
@@ -676,6 +678,7 @@ class _Injector(Injector):
     class _Request:
         def __init__(self, injector: '_Injector') -> None:
             super().__init__()
+
             self._injector = injector
             self._provisions: ta.Dict[InjectorKey, Maybe] = {}
             self._seen_keys: ta.Set[InjectorKey] = set()

omlish/lite/secrets.py

@@ -12,6 +12,7 @@ class Secret:
 
     def __init__(self, *, key: ta.Optional[str] = None, value: str) -> None:
         super().__init__()
+
         self._key = key
         setattr(self, self._VALUE_ATTR, lambda: value)
 

omlish/logs/handlers.py

@@ -10,6 +10,7 @@ import typing as ta
 class ListHandler(logging.Handler):
     def __init__(self) -> None:
         super().__init__()
+
         self.records: ta.List[logging.LogRecord] = []
 
     def emit(self, record: logging.LogRecord) -> None:

omlish/marshal/factories.py

@@ -41,6 +41,7 @@ class TypeMapFactory(mfs.MatchFn[[C, rfl.Type], R]):
 class TypeCacheFactory(mfs.MatchFn[[C, rfl.Type], R]):
     def __init__(self, f: mfs.MatchFn[[C, rfl.Type], R]) -> None:
         super().__init__()
+
         self._f = f
         self._dct: dict[rfl.Type, R | None] = {}
         self._mtx = threading.RLock()
@@ -90,6 +91,7 @@ class RecursiveTypeFactory(mfs.MatchFn[[C, rfl.Type], R]):
             prx: ta.Callable[[], tuple[R, ta.Callable[[R], None]]],
     ) -> None:
         super().__init__()
+
         self._f = f
         self._prx = prx
         self._dct: dict[rfl.Type, R] = {}

omlish/marshal/polymorphism/metadata.py

@@ -39,6 +39,7 @@ class Impls(ta.Sequence[Impl]):
             lst: ta.Iterable[Impl],
     ) -> None:
         super().__init__()
+
         self._lst = list(lst)
 
         by_ty: dict[type, Impl] = {}
@@ -89,6 +90,7 @@ class Polymorphism:
             impls: ta.Iterable[Impl],
     ) -> None:
         super().__init__()
+
         self._ty = ty
         self._impls = Impls(impls)
 

omlish/marshal/registries.py

@@ -35,6 +35,7 @@ class _KeyRegistryItems:
 class Registry:
     def __init__(self) -> None:
         super().__init__()
+
         self._mtx = threading.Lock()
         self._idct: ta.MutableMapping[ta.Any, _KeyRegistryItems] = col.IdentityKeyDict()
         self._dct: dict[ta.Any, _KeyRegistryItems] = {}

omlish/multiprocessing/spawn.py

@@ -24,6 +24,7 @@ class ExtrasSpawnPosixPopen(mp.popen_spawn_posix.Popen):
     def __init__(self, process_obj: 'ExtrasSpawnProcess', *, extras: SpawnExtras) -> None:
         self.__extras = extras
         self.__pass_fds = extras.pass_fds
+
         super().__init__(process_obj)
 
     def _launch(self, process_obj: 'ExtrasSpawnProcess') -> None:
@@ -38,6 +39,7 @@ class ExtrasSpawnPosixPopen(mp.popen_spawn_posix.Popen):
 class ExtrasSpawnProcess(mp.context.SpawnProcess):
     def __init__(self, *args: ta.Any, extras: SpawnExtras, **kwargs: ta.Any) -> None:
         self.__extras = extras
+
         super().__init__(*args, **kwargs)
 
     def _Popen(self, process_obj: 'ExtrasSpawnProcess') -> ExtrasSpawnPosixPopen:  # type: ignore  # noqa
@@ -56,6 +58,7 @@ class ExtrasSpawnProcess(mp.context.SpawnProcess):
 class ExtrasSpawnContext(mp.context.SpawnContext):
     def __init__(self, extras: SpawnExtras = SpawnExtras()) -> None:
         self.__extras = extras
+
         super().__init__()
 
     def Process(self, *args: ta.Any, **kwargs: ta.Any):  # type: ignore  # noqa

omlish/secrets/openssl.py

@@ -56,6 +56,7 @@ class OpensslAescbcCrypto(Crypto):
             iters: int = 10_000,
     ) -> None:
         super().__init__()
+
         self._iters = iters
 
     def generate_key(self, sz: int = DEFAULT_KEY_SIZE) -> bytes:
@@ -131,6 +132,7 @@ class OpensslSubprocessAescbcCrypto(Crypto):
             file_input: SubprocessFileInputMethod = temp_subprocess_file_input,
     ) -> None:
         super().__init__()
+
         self._cmd = cmd
         self._timeout = timeout
         self._file_input = file_input