omlish 0.0.0.dev423__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/inject/impl/injector.py

@@ -2,36 +2,35 @@
 TODO:
  - ** can currently bind in a child/private scope shadowing an external parent binding **
  - better source tracking
- - cache/export ElementCollections lol
  - scope bindings, auto in root
  - injector-internal / blacklisted bindings (Injector itself, default scopes) without rebuilding ElementCollection
  - config - proxies, impl select, etc
   - config is probably shared with ElementCollection... but not 'bound', must be shared everywhere
   - InjectorRoot object?
  - ** eagers in any scope, on scope init/open
- - injection listeners
  - unions - raise on ambiguous - usecase: sql.AsyncEngineLike
  - multiple live request scopes on single injector - use private injectors?
+ - more listeners - UnboundKeyListener
+  - lazy parent listener chain cache thing
 """
 import contextlib
 import functools
 import itertools
-import logging
 import typing as ta
 import weakref
 
 from ... import check
 from ... import lang
-from ..elements import Elements
+from ...logs import all as logs
+from ..elements import CollectedElements
 from ..errors import CyclicDependencyError
 from ..errors import UnboundKeyError
-from ..injector import Injector
+from ..injector import AsyncInjector
 from ..inspect import KwargsTarget
 from ..keys import Key
 from ..keys import as_key
 from ..listeners import ProvisionListener
 from ..listeners import ProvisionListenerBinding
-from ..scopes import ScopeBinding
 from ..scopes import Singleton
 from ..scopes import ThreadScope
 from ..types import Scope
@@ -42,7 +41,7 @@ from .scopes import ScopeImpl
 from .scopes import make_scope_impl
 
 
-log = logging.getLogger(__name__)
+log = logs.get_module_logger(globals())
 
 
 ##
@@ -55,61 +54,84 @@ DEFAULT_SCOPES: list[Scope] = [
 ]
 
 
-class InjectorImpl(Injector, lang.Final):
-    def __init__(self, ec: ElementCollection, p: ta.Optional['InjectorImpl'] = None) -> None:
-        super().__init__()
-
-        self._ec = check.isinstance(ec, ElementCollection)
-        self._p: InjectorImpl | None = check.isinstance(p, (InjectorImpl, None))
+@ta.final
+class AsyncInjectorImpl(AsyncInjector, lang.Final):
+    def __init__(
+            self,
+            ec: CollectedElements,
+            p: ta.Optional['AsyncInjectorImpl'] = None,
+            *,
+            internal_consts: dict[Key, ta.Any] | None = None,
+    ) -> None:
+        self._ec = (ec := check.isinstance(ec, ElementCollection))
+        self._p: AsyncInjectorImpl | None = check.isinstance(p, (AsyncInjectorImpl, None))
 
         self._internal_consts: dict[Key, ta.Any] = {
-            Key(Injector): self,
+            Key(AsyncInjector): self,
+            **(internal_consts or {}),
         }
 
         self._bim = ec.binding_impl_map()
+
         self._ekbs = ec.eager_keys_by_scope()
+
         self._pls: tuple[ProvisionListener, ...] = tuple(
             b.listener  # type: ignore[attr-defined]
             for b in itertools.chain(
                 ec.elements_of_type(ProvisionListenerBinding),
-                (p._pls if p is not None else ()),  # noqa
+                p._pls if p is not None else (),  # noqa
             )
         )
 
-        self._cs: weakref.WeakSet[InjectorImpl] | None = None
-        self._root: InjectorImpl = p._root if p is not None else self  # noqa
-
-        self.__cur_req: InjectorImpl._Request | None = None
+        self._root: AsyncInjectorImpl = p._root if p is not None else self  # noqa
 
-        ss = [
-            *DEFAULT_SCOPES,
-            *[sb.scope for sb in ec.elements_of_type(ScopeBinding)],
-        ]
         self._scopes: dict[Scope, ScopeImpl] = {
-            s: make_scope_impl(s) for s in ss
+            s: make_scope_impl(s)
+            for s in itertools.chain(
+                DEFAULT_SCOPES,
+                ec.scope_binding_scopes(),
+            )
         }
 
-        self._instantiate_eagers(Unscoped())
-        self._instantiate_eagers(Singleton())
+    _cs: weakref.WeakSet['AsyncInjectorImpl'] | None = None  # noqa
+
+    __cur_req: ta.Optional['AsyncInjectorImpl._Request'] = None
+
+    #
+
+    _has_run_init: bool = False
+
+    async def _init(self) -> bool:
+        if self._has_run_init:
+            return False
+
+        self._has_run_init = True
+
+        await self._instantiate_eagers(Unscoped())
+        await self._instantiate_eagers(Singleton())
 
-    _root: 'InjectorImpl'
+        return True
 
-    def _instantiate_eagers(self, sc: Scope) -> None:
+    #
+
+    _root: 'AsyncInjectorImpl'
+
+    async def _instantiate_eagers(self, sc: Scope) -> None:
         for k in self._ekbs.get(sc, ()):
-            self.provide(k)
+            await self.provide(k)
 
     def get_scope_impl(self, sc: Scope) -> ScopeImpl:
         return self._scopes[sc]
 
-    def create_child(self, ec: ElementCollection) -> Injector:
-        c = InjectorImpl(ec, self)
+    def create_child(self, ec: ElementCollection) -> AsyncInjector:
+        c = AsyncInjectorImpl(ec, self)
         if self._cs is None:
             self._cs = weakref.WeakSet()
         self._cs.add(c)
         return c
 
     class _Request:
-        def __init__(self, injector: 'InjectorImpl') -> None:
+        def __init__(self, injector: 'AsyncInjectorImpl') -> None:
             super().__init__()
 
             self._injector = injector
@@ -162,10 +184,13 @@ class InjectorImpl(Injector, lang.Final):
             finally:
                 self.__cur_req = None
 
-    def _try_provide(self, key: ta.Any, *, source: ta.Any = None) -> lang.Maybe[ta.Any]:
+    async def _try_provide(self, key: ta.Any, *, source: ta.Any = None) -> lang.Maybe[ta.Any]:
+        if not self._has_run_init:
+            await self._init()
+
         key = as_key(key)
 
-        cr: InjectorImpl._Request
+        cr: AsyncInjectorImpl._Request
         with self._current_request() as cr:
             with cr.push_source(source):
                 if (rv := cr.handle_key(key)).present:
@@ -182,55 +207,57 @@ class InjectorImpl(Injector, lang.Final):
                     fn = lambda: sc.provide(bi, self)  # noqa
                     for pl in self._pls:
                         fn = functools.partial(pl, self, key, bi.binding, fn)
-                    v = fn()
+                    v = await fn()
 
                     return cr.handle_provision(key, lang.just(v))
 
                 if self._p is not None:
-                    pv = self._p._try_provide(key, source=source)  # noqa
+                    pv = await self._p._try_provide(key, source=source)  # noqa
                     if pv.present:
                         return cr.handle_provision(key, pv)
 
                 return cr.handle_provision(key, lang.empty())
 
-    def _provide(self, key: ta.Any, *, source: ta.Any = None) -> ta.Any:
-        v = self._try_provide(key, source=source)
+    async def _provide(self, key: ta.Any, *, source: ta.Any = None) -> ta.Any:
+        v = await self._try_provide(key, source=source)
         if v.present:
             return v.must()
         raise UnboundKeyError(key)
 
     #
 
-    def try_provide(self, key: ta.Any) -> lang.Maybe[ta.Any]:
-        return self.try_provide(key)
+    def try_provide(self, key: ta.Any) -> ta.Awaitable[lang.Maybe[ta.Any]]:
+        return self._try_provide(key)
 
-    def provide(self, key: ta.Any) -> ta.Any:
-        v = self._try_provide(key)
+    async def provide(self, key: ta.Any) -> ta.Any:
+        v = await self._try_provide(key)
         if v.present:
             return v.must()
         raise UnboundKeyError(key)
 
-    def provide_kwargs(self, kt: KwargsTarget) -> ta.Mapping[str, ta.Any]:
+    async def provide_kwargs(self, kt: KwargsTarget) -> ta.Mapping[str, ta.Any]:
         ret: dict[str, ta.Any] = {}
         for kw in kt.kwargs:
             if kw.has_default:
-                if not (mv := self._try_provide(kw.key, source=kt)).present:
+                if not (mv := await self._try_provide(kw.key, source=kt)).present:
                     continue
                 v = mv.must()
             else:
-                v = self._provide(kw.key, source=kt)
+                v = await self._provide(kw.key, source=kt)
             ret[kw.name] = v
         return ret
 
-    def inject(self, obj: ta.Any) -> ta.Any:
+    async def inject(self, obj: ta.Any) -> ta.Any:
         if isinstance(obj, KwargsTarget):
             obj, kt = obj.obj, obj
         else:
             kt = build_kwargs_target(obj)
-        kws = self.provide_kwargs(kt)
+        kws = await self.provide_kwargs(kt)
         # FIXME: still 'injecting' (as in has a req) if ctor needs and uses Injector
         return obj(**kws)
 
 
-def create_injector(es: Elements) -> Injector:
-    return InjectorImpl(ElementCollection(es))
+async def create_async_injector(ce: CollectedElements) -> AsyncInjector:
+    i = AsyncInjectorImpl(ce)
+    await i._init()  # noqa
+    return i

omlish/inject/impl/inspect.py

@@ -4,6 +4,7 @@ TODO:
  - tag annotations? x: ta.Annotated[int, inj.Tag('foo')]
  - tag decorator - @inj.tag(x='foo')
  - *unpack optional here*
+ - use ...metadata
 """
 import dataclasses as dc
 import inspect
@@ -74,7 +75,11 @@ def build_kwargs_target(
         skip_args: int = 0,
         skip_kwargs: ta.Iterable[str] | None = None,
         raw_optional: bool = False,
+        non_strict: bool = False,
 ) -> KwargsTarget:
+    if isinstance(obj, KwargsTarget):
+        return obj
+
     sig = signature(obj)
     tags = _TAGS.get(obj)
 
@@ -89,11 +94,15 @@ def build_kwargs_target(
             continue
 
         if p.annotation is inspect.Signature.empty:
+            if non_strict:
+                continue
             if p.default is not inspect.Parameter.empty:
                 raise KeyError(f'{obj}, {p.name}')
             continue
 
         if p.kind not in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY):
+            if non_strict:
+                continue
             raise TypeError(sig)
 
         ann = p.annotation
@@ -118,7 +127,8 @@ def build_kwargs_target(
             k = dc.replace(k, tag=pt)
 
         if k in seen:
-            raise ConflictingKeyError(k)
+            if not non_strict:
+                raise ConflictingKeyError(k)
         seen.add(k)
 
         kws.append(Kwarg(

omlish/inject/impl/maysync.py

@@ -0,0 +1,43 @@
+import typing as ta
+
+from ... import lang
+from ..elements import CollectedElements
+from ..injector import AsyncInjector
+from ..inspect import KwargsTarget
+from ..keys import Key
+from ..maysync import MaysyncInjector
+from ..sync import Injector
+from .injector import AsyncInjectorImpl
+
+
+##
+
+
+class MaysyncInjectorImpl(MaysyncInjector, lang.Final):
+    _ai: AsyncInjector
+
+    def try_provide(self, key: ta.Any) -> lang.Maybe[ta.Any]:
+        return lang.run_maysync(self._ai.try_provide(key))
+
+    def provide(self, key: ta.Any) -> ta.Any:
+        return lang.run_maysync(self._ai.provide(key))
+
+    def provide_kwargs(self, kt: KwargsTarget) -> ta.Mapping[str, ta.Any]:
+        return lang.run_maysync(self._ai.provide_kwargs(kt))
+
+    def inject(self, obj: ta.Any) -> ta.Any:
+        return lang.run_maysync(self._ai.inject(obj))
+
+
+def create_maysync_injector(ce: CollectedElements) -> MaysyncInjector:
+    si = MaysyncInjectorImpl()
+    ai = AsyncInjectorImpl(
+        ce,
+        internal_consts={
+            Key(MaysyncInjector): si,
+            Key(Injector): si,
+        },
+    )
+    si._ai = ai  # noqa
+    lang.run_maysync(ai._init())  # noqa
+    return si

omlish/inject/impl/multis.py

@@ -1,9 +1,10 @@
 import typing as ta
 
+from ... import check
 from ... import dataclasses as dc
 from ... import lang
 from ..elements import Element
-from ..injector import Injector
+from ..injector import AsyncInjector
 from ..multis import MapBinding
 from ..multis import MapProvider
 from ..multis import SetBinding
@@ -22,14 +23,14 @@ class SetProviderImpl(ProviderImpl, lang.Final):
     ps: ta.Sequence[ProviderImpl]
 
     @property
-    def providers(self) -> ta.Iterable[Provider]:
+    def providers(self) -> ta.Iterator[Provider]:
         for p in self.ps:
             yield from p.providers
 
-    def provide(self, injector: Injector) -> ta.Any:
+    async def provide(self, injector: AsyncInjector) -> ta.Any:
         rv = set()
         for ep in self.ps:
-            o = ep.provide(injector)
+            o = await ep.provide(injector)
             rv.add(o)
         return rv
 
@@ -43,14 +44,14 @@ class MapProviderImpl(ProviderImpl, lang.Final):
     es: ta.Sequence[Entry]
 
     @property
-    def providers(self) -> ta.Iterable[Provider]:
+    def providers(self) -> ta.Iterator[Provider]:
         for e in self.es:
             yield from e.v.providers
 
-    def provide(self, injector: Injector) -> ta.Any:
+    async def provide(self, injector: AsyncInjector) -> ta.Any:
         rv = {}
         for e in self.es:
-            o = e.v.provide(injector)
+            o = await e.v.provide(injector)
             rv[e.k] = o
         return rv
 
@@ -58,6 +59,7 @@ class MapProviderImpl(ProviderImpl, lang.Final):
 def make_multi_provider_impl(p: Provider, es_by_ty: ta.MutableMapping[type, list[Element]]) -> ProviderImpl:
     if isinstance(p, SetProvider):
         sbs: ta.Iterable[SetBinding] = es_by_ty.pop(SetBinding, ())  # type: ignore
+        check.empty(es_by_ty)
         return SetProviderImpl([
             LinkProviderImpl(LinkProvider(sb.dst))
             for sb in sbs
@@ -65,6 +67,7 @@ def make_multi_provider_impl(p: Provider, es_by_ty: ta.MutableMapping[type, list
 
     elif isinstance(p, MapProvider):
         mbs: ta.Iterable[MapBinding] = es_by_ty.pop(MapBinding, ())  # type: ignore
+        check.empty(es_by_ty)
         return MapProviderImpl([
             MapProviderImpl.Entry(
                 mb.map_key,

omlish/inject/impl/privates.py

@@ -12,14 +12,14 @@ from ... import lang
 from ..bindings import Binding
 from ..eagers import Eager
 from ..elements import Element
-from ..injector import Injector
+from ..injector import AsyncInjector
 from ..keys import Key
 from ..privates import Expose
 from ..privates import Private
 from ..providers import Provider
 from ..scopes import Singleton
 from .elements import ElementCollection
-from .injector import InjectorImpl
+from .injector import AsyncInjectorImpl
 from .providers import InternalProvider
 from .providers import ProviderImpl
 
@@ -47,8 +47,8 @@ class PrivateInjectorProviderImpl(ProviderImpl, lang.Final):
     def providers(self) -> ta.Iterable[Provider]:
         return ()
 
-    def provide(self, injector: Injector) -> ta.Any:
-        return check.isinstance(injector, InjectorImpl).create_child(self.ec)
+    async def provide(self, injector: AsyncInjector) -> ta.Any:
+        return check.isinstance(injector, AsyncInjectorImpl).create_child(self.ec)
 
 
 ##
@@ -63,9 +63,9 @@ class ExposedPrivateProviderImpl(ProviderImpl, lang.Final):
     def providers(self) -> ta.Iterable[Provider]:
         return ()
 
-    def provide(self, injector: Injector) -> ta.Any:
-        pi = injector.provide(self.pik)
-        return pi.provide(self.k)
+    async def provide(self, injector: AsyncInjector) -> ta.Any:
+        pi = await injector.provide(self.pik)
+        return await pi.provide(self.k)
 
 
 ##
@@ -82,7 +82,7 @@ class PrivateInfo(lang.Final):
 
     @cached.property
     def pik(self) -> Key:
-        return Key(InjectorImpl, tag=self.id)
+        return Key(AsyncInjectorImpl, tag=self.id)
 
     @cached.function
     def element_collection(self) -> ElementCollection:

omlish/inject/impl/providers.py

@@ -7,15 +7,14 @@ import typing as ta
 
 from ... import dataclasses as dc
 from ... import lang
-from ... import reflect as rfl
-from ..injector import Injector
+from ..injector import AsyncInjector
 from ..inspect import KwargsTarget
+from ..providers import AsyncFnProvider
 from ..providers import ConstProvider
 from ..providers import CtorProvider
 from ..providers import FnProvider
 from ..providers import LinkProvider
 from ..providers import Provider
-from .inspect import build_kwargs_target
 
 
 ##
@@ -28,7 +27,7 @@ class ProviderImpl(lang.Abstract):
         raise NotImplementedError
 
     @abc.abstractmethod
-    def provide(self, injector: Injector) -> ta.Any:
+    def provide(self, injector: AsyncInjector) -> ta.Awaitable[ta.Any]:
         raise NotImplementedError
 
 
@@ -39,8 +38,21 @@ class ProviderImpl(lang.Abstract):
 class InternalProvider(Provider):
     impl: ProviderImpl
 
-    def provided_ty(self) -> rfl.Type | None:
-        raise TypeError
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+class AsyncCallableProviderImpl(ProviderImpl, lang.Final):
+    p: AsyncFnProvider
+    kt: KwargsTarget
+
+    @property
+    def providers(self) -> ta.Iterable[Provider]:
+        return (self.p,)
+
+    async def provide(self, injector: AsyncInjector) -> ta.Any:
+        return await (await injector.inject(self.kt))
 
 
 ##
@@ -55,8 +67,8 @@ class CallableProviderImpl(ProviderImpl, lang.Final):
     def providers(self) -> ta.Iterable[Provider]:
         return (self.p,)
 
-    def provide(self, injector: Injector) -> ta.Any:
-        return injector.inject(self.kt)
+    async def provide(self, injector: AsyncInjector) -> ta.Any:
+        return await injector.inject(self.kt)
 
 
 ##
@@ -70,7 +82,7 @@ class ConstProviderImpl(ProviderImpl, lang.Final):
     def providers(self) -> ta.Iterable[Provider]:
         return (self.p,)
 
-    def provide(self, injector: Injector) -> ta.Any:
+    async def provide(self, injector: AsyncInjector) -> ta.Any:
         return self.p.v
 
 
@@ -85,28 +97,5 @@ class LinkProviderImpl(ProviderImpl, lang.Final):
     def providers(self) -> ta.Iterable[Provider]:
         return (self.p,)
 
-    def provide(self, injector: Injector) -> ta.Any:
-        return injector.provide(self.p.k)
-
-
-##
-
-
-PROVIDER_IMPLS_BY_PROVIDER: dict[type[Provider], ta.Callable[..., ProviderImpl]] = {
-    FnProvider: lambda p: CallableProviderImpl(p, build_kwargs_target(p.fn)),
-    CtorProvider: lambda p: CallableProviderImpl(p, build_kwargs_target(p.ty)),
-    ConstProvider: ConstProviderImpl,
-    LinkProvider: LinkProviderImpl,
-    InternalProvider: lambda p: p.impl,
-}
-
-
-def make_provider_impl(p: Provider) -> ProviderImpl:
-    try:
-        fac = PROVIDER_IMPLS_BY_PROVIDER[type(p)]
-    except KeyError:
-        pass
-    else:
-        return fac(p)
-
-    raise TypeError(p)
+    async def provide(self, injector: AsyncInjector) -> ta.Any:
+        return await injector.provide(self.p.k)

omlish/inject/impl/providersmap.py

@@ -0,0 +1,43 @@
+import typing as ta
+
+from ..providers import AsyncFnProvider
+from ..providers import ConstProvider
+from ..providers import CtorProvider
+from ..providers import FnProvider
+from ..providers import LinkProvider
+from ..providers import Provider
+from ..scopes import ScopeSeededProvider
+from .inspect import build_kwargs_target
+from .providers import AsyncCallableProviderImpl
+from .providers import CallableProviderImpl
+from .providers import ConstProviderImpl
+from .providers import InternalProvider
+from .providers import LinkProviderImpl
+from .providers import ProviderImpl
+from .scopes import ScopeSeededProviderImpl
+
+
+##
+
+
+PROVIDER_IMPLS_BY_PROVIDER: dict[type[Provider], ta.Callable[..., ProviderImpl]] = {
+    AsyncFnProvider: lambda p: AsyncCallableProviderImpl(p, build_kwargs_target(p.fn)),
+    FnProvider: lambda p: CallableProviderImpl(p, build_kwargs_target(p.fn)),
+    CtorProvider: lambda p: CallableProviderImpl(p, build_kwargs_target(p.ty)),
+    ConstProvider: ConstProviderImpl,
+    LinkProvider: LinkProviderImpl,
+    InternalProvider: lambda p: p.impl,
+
+    ScopeSeededProvider: ScopeSeededProviderImpl,
+}
+
+
+def make_provider_impl(p: Provider) -> ProviderImpl:
+    try:
+        fac = PROVIDER_IMPLS_BY_PROVIDER[type(p)]
+    except KeyError:
+        pass
+    else:
+        return fac(p)
+
+    raise TypeError(p)

omlish/inject/impl/proxy.py

@@ -12,7 +12,6 @@ def _cyclic_dependency_proxy() -> tuple[type, ta.Callable[[ta.Any, ta.Any], None
     import wrapt  # noqa
 
     class _CyclicDependencyPlaceholder(lang.Final):
-
         def __init__(self, cls: ta.Any) -> None:
             super().__init__()
 
@@ -22,7 +21,6 @@ def _cyclic_dependency_proxy() -> tuple[type, ta.Callable[[ta.Any, ta.Any], None
             return f'{type(self).__name__}({self.__cls!r})'
 
     class _CyclicDependencyProxy(wrapt.ObjectProxy, lang.Final):  # noqa
-
         def __init__(self, cls):
             super().__init__(_CyclicDependencyPlaceholder(cls))