omlish 0.0.0.dev433__py3-none-any.whl → 0.0.0.dev435__py3-none-any.whl

omlish/inject/impl/elements.py

@@ -47,14 +47,12 @@ from .multis import make_multi_provider_impl
 from .origins import Origins
 from .origins import set_origins
 from .providers import ProviderImpl
-from .providers import make_provider_impl
+from .providers2 import make_provider_impl
 from .scopes import make_scope_impl
 
 
-if ta.TYPE_CHECKING:
-    from . import privates as privates_
-else:
-    privates_ = lang.proxy_import('.privates', __package__)
+with lang.auto_proxy_import(globals()):
+    from . import privates as _privates
 
 
 ElementT = ta.TypeVar('ElementT', bound=Element)
@@ -69,17 +67,17 @@ class ElementCollection(lang.Final):
 
         self._es = check.isinstance(es, Elements)
 
-        self._private_infos: ta.MutableMapping[Private, privates_.PrivateInfo] | None = None
+        self._private_infos: ta.MutableMapping[Private, _privates.PrivateInfo] | None = None
 
     ##
 
-    def _get_private_info(self, p: Private) -> 'privates_.PrivateInfo':
+    def _get_private_info(self, p: Private) -> '_privates.PrivateInfo':
         if (pis := self._private_infos) is None:
             self._private_infos = pis = col.IdentityKeyDict()
         try:
             return pis[p]
         except KeyError:
-            pis[p] = ec = privates_.PrivateInfo(self, p)
+            pis[p] = ec = _privates.PrivateInfo(self, p)
             return ec
 
     ##

omlish/inject/impl/injector.py

@@ -25,7 +25,7 @@ from ...logs import all as logs
 from ..elements import Elements
 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
@@ -55,15 +55,22 @@ DEFAULT_SCOPES: list[Scope] = [
 ]
 
 
-class InjectorImpl(Injector, lang.Final):
-    def __init__(self, ec: ElementCollection, p: ta.Optional['InjectorImpl'] = None) -> None:
+class AsyncInjectorImpl(AsyncInjector, lang.Final):
+    def __init__(
+            self,
+            ec: ElementCollection,
+            p: ta.Optional['AsyncInjectorImpl'] = None,
+            *,
+            internal_consts: dict[Key, ta.Any] | None = None,
+    ) -> None:
         super().__init__()
 
         self._ec = check.isinstance(ec, ElementCollection)
-        self._p: InjectorImpl | None = check.isinstance(p, (InjectorImpl, None))
+        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()
@@ -76,10 +83,10 @@ class InjectorImpl(Injector, lang.Final):
             )
         )
 
-        self._cs: weakref.WeakSet[InjectorImpl] | None = None
-        self._root: InjectorImpl = p._root if p is not None else self  # noqa
+        self._cs: weakref.WeakSet[AsyncInjectorImpl] | None = None
+        self._root: AsyncInjectorImpl = p._root if p is not None else self  # noqa
 
-        self.__cur_req: InjectorImpl._Request | None = None
+        self.__cur_req: AsyncInjectorImpl._Request | None = None
 
         ss = [
             *DEFAULT_SCOPES,
@@ -89,27 +96,41 @@ class InjectorImpl(Injector, lang.Final):
             s: make_scope_impl(s) for s in ss
         }
 
-        self._instantiate_eagers(Unscoped())
-        self._instantiate_eagers(Singleton())
+    #
+
+    _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 +183,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 +206,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]:
+    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(es: Elements) -> AsyncInjector:
+    i = AsyncInjectorImpl(ElementCollection(es))
+    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

omlish/inject/impl/maysync.py

@@ -0,0 +1,44 @@
+import typing as ta
+
+from ... import lang
+from ..elements import Elements
+from ..injector import AsyncInjector
+from ..inspect import KwargsTarget
+from ..keys import Key
+from ..maysync import MaysyncInjector
+from ..sync import Injector
+from .elements import ElementCollection
+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(es: Elements) -> MaysyncInjector:
+    si = MaysyncInjectorImpl()
+    ai = AsyncInjectorImpl(
+        ElementCollection(es),
+        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

@@ -3,7 +3,7 @@ import typing as ta
 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
@@ -26,10 +26,10 @@ class SetProviderImpl(ProviderImpl, lang.Final):
         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
 
@@ -47,10 +47,10 @@ class MapProviderImpl(ProviderImpl, lang.Final):
         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
 

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,14 +7,14 @@ import typing as ta
 
 from ... import dataclasses as dc
 from ... import lang
-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
 
 
 ##
@@ -27,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
 
 
@@ -43,66 +43,59 @@ class InternalProvider(Provider):
 
 
 @dc.dataclass(frozen=True, eq=False)
-class CallableProviderImpl(ProviderImpl, lang.Final):
-    p: FnProvider | CtorProvider
+class AsyncCallableProviderImpl(ProviderImpl, lang.Final):
+    p: AsyncFnProvider
     kt: KwargsTarget
 
     @property
     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 (await injector.inject(self.kt))
 
 
 ##
 
 
 @dc.dataclass(frozen=True, eq=False)
-class ConstProviderImpl(ProviderImpl, lang.Final):
-    p: ConstProvider
+class CallableProviderImpl(ProviderImpl, lang.Final):
+    p: FnProvider | CtorProvider
+    kt: KwargsTarget
 
     @property
     def providers(self) -> ta.Iterable[Provider]:
         return (self.p,)
 
-    def provide(self, injector: Injector) -> ta.Any:
-        return self.p.v
+    async def provide(self, injector: AsyncInjector) -> ta.Any:
+        return await injector.inject(self.kt)
 
 
 ##
 
 
 @dc.dataclass(frozen=True, eq=False)
-class LinkProviderImpl(ProviderImpl, lang.Final):
-    p: LinkProvider
+class ConstProviderImpl(ProviderImpl, lang.Final):
+    p: ConstProvider
 
     @property
     def providers(self) -> ta.Iterable[Provider]:
         return (self.p,)
 
-    def provide(self, injector: Injector) -> ta.Any:
-        return injector.provide(self.p.k)
+    async def provide(self, injector: AsyncInjector) -> ta.Any:
+        return self.p.v
 
 
 ##
 
 
-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,
-}
-
+@dc.dataclass(frozen=True, eq=False)
+class LinkProviderImpl(ProviderImpl, lang.Final):
+    p: LinkProvider
 
-def make_provider_impl(p: Provider) -> ProviderImpl:
-    try:
-        fac = PROVIDER_IMPLS_BY_PROVIDER[type(p)]
-    except KeyError:
-        pass
-    else:
-        return fac(p)
+    @property
+    def providers(self) -> ta.Iterable[Provider]:
+        return (self.p,)
 
-    raise TypeError(p)
+    async def provide(self, injector: AsyncInjector) -> ta.Any:
+        return await injector.provide(self.p.k)

omlish/inject/impl/providers2.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/scopes.py

@@ -17,7 +17,7 @@ from ..elements import Elements
 from ..elements import as_elements
 from ..errors import ScopeAlreadyOpenError
 from ..errors import ScopeNotOpenError
-from ..injector import Injector
+from ..injector import AsyncInjector
 from ..keys import Key
 from ..providers import FnProvider
 from ..providers import Provider
@@ -28,14 +28,11 @@ from ..scopes import ThreadScope
 from ..types import Scope
 from ..types import Unscoped
 from .bindings import BindingImpl
-from .providers import PROVIDER_IMPLS_BY_PROVIDER
 from .providers import ProviderImpl
 
 
-if ta.TYPE_CHECKING:
-    from . import injector as injector_
-else:
-    injector_ = lang.proxy_import('.injector', __package__)
+with lang.auto_proxy_import(globals()):
+    from . import injector as _injector
 
 
 ##
@@ -51,7 +48,7 @@ class ScopeImpl(lang.Abstract):
         return None
 
     @abc.abstractmethod
-    def provide(self, binding: BindingImpl, injector: Injector) -> ta.Any:
+    def provide(self, binding: BindingImpl, injector: AsyncInjector) -> ta.Awaitable[ta.Any]:
         raise NotImplementedError
 
 
@@ -60,8 +57,8 @@ class UnscopedScopeImpl(ScopeImpl, lang.Final):
     def scope(self) -> Unscoped:
         return Unscoped()
 
-    def provide(self, binding: BindingImpl, injector: Injector) -> ta.Any:
-        return binding.provider.provide(injector)
+    async def provide(self, binding: BindingImpl, injector: AsyncInjector) -> ta.Any:
+        return await binding.provider.provide(injector)
 
 
 class SingletonScopeImpl(ScopeImpl, lang.Final):
@@ -74,12 +71,12 @@ class SingletonScopeImpl(ScopeImpl, lang.Final):
     def scope(self) -> Singleton:
         return Singleton()
 
-    def provide(self, binding: BindingImpl, injector: Injector) -> ta.Any:
+    async def provide(self, binding: BindingImpl, injector: AsyncInjector) -> ta.Any:
         try:
             return self._dct[binding]
         except KeyError:
             pass
-        v = binding.provider.provide(injector)
+        v = await binding.provider.provide(injector)
         self._dct[binding] = v
         return v
 
@@ -94,7 +91,7 @@ class ThreadScopeImpl(ScopeImpl, lang.Final):
     def scope(self) -> ThreadScope:
         return ThreadScope()
 
-    def provide(self, binding: BindingImpl, injector: Injector) -> ta.Any:
+    async def provide(self, binding: BindingImpl, injector: AsyncInjector) -> ta.Any:
         dct: dict[BindingImpl, ta.Any]
         try:
             dct = self._local.dct
@@ -104,7 +101,7 @@ class ThreadScopeImpl(ScopeImpl, lang.Final):
             return dct[binding]
         except KeyError:
             pass
-        v = binding.provider.provide(injector)
+        v = await binding.provider.provide(injector)
         dct[binding] = v
         return v
 
@@ -120,15 +117,12 @@ class ScopeSeededProviderImpl(ProviderImpl):
     def providers(self) -> ta.Iterable[Provider]:
         return (self.p,)
 
-    def provide(self, injector: Injector) -> ta.Any:
-        ii = check.isinstance(injector, injector_.InjectorImpl)
+    async def provide(self, injector: AsyncInjector) -> ta.Any:
+        ii = check.isinstance(injector, _injector.AsyncInjectorImpl)
         ssi = check.isinstance(ii.get_scope_impl(self.p.ss), SeededScopeImpl)
         return ssi.must_state().seeds[self.p.key]
 
 
-PROVIDER_IMPLS_BY_PROVIDER[ScopeSeededProvider] = ScopeSeededProviderImpl
-
-
 class SeededScopeImpl(ScopeImpl):
     @dc.dataclass(frozen=True)
     class State:
@@ -151,20 +145,20 @@ class SeededScopeImpl(ScopeImpl):
         return st
 
     class Manager(SeededScope.Manager, lang.Final):
-        def __init__(self, ss: SeededScope, i: Injector) -> None:
+        def __init__(self, ss: SeededScope, i: AsyncInjector) -> None:
             super().__init__()
 
             self._ss = check.isinstance(ss, SeededScope)
-            self._ii = check.isinstance(i, injector_.InjectorImpl)
+            self._ii = check.isinstance(i, _injector.AsyncInjectorImpl)
             self._ssi = check.isinstance(self._ii.get_scope_impl(self._ss), SeededScopeImpl)
 
-        @contextlib.contextmanager
-        def __call__(self, seeds: ta.Mapping[Key, ta.Any]) -> ta.Generator[None]:
+        @contextlib.asynccontextmanager
+        async def __call__(self, seeds: ta.Mapping[Key, ta.Any]) -> ta.AsyncGenerator[None]:
             try:
                 if self._ssi._st is not None:  # noqa
                     raise ScopeAlreadyOpenError(self._ss)
                 self._ssi._st = SeededScopeImpl.State(dict(seeds))  # noqa
-                self._ii._instantiate_eagers(self._ss)  # noqa
+                await self._ii._instantiate_eagers(self._ss)  # noqa
                 yield
             finally:
                 if self._ssi._st is None:  # noqa
@@ -180,13 +174,13 @@ class SeededScopeImpl(ScopeImpl):
             ),
         )
 
-    def provide(self, binding: BindingImpl, injector: Injector) -> ta.Any:
+    async def provide(self, binding: BindingImpl, injector: AsyncInjector) -> ta.Any:
         st = self.must_state()
         try:
             return st.prvs[binding]
         except KeyError:
             pass
-        v = binding.provider.provide(injector)
+        v = await binding.provider.provide(injector)
         st.prvs[binding] = v
         return v