omlish 0.0.0.dev432__py3-none-any.whl → 0.0.0.dev434__py3-none-any.whl

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
 

omlish/inject/impl/sync.py

@@ -0,0 +1,42 @@
+import typing as ta
+
+from ... import lang
+from ..elements import Elements
+from ..injector import AsyncInjector
+from ..inspect import KwargsTarget
+from ..keys import Key
+from ..sync import Injector
+from .elements import ElementCollection
+from .injector import AsyncInjectorImpl
+
+
+##
+
+
+class InjectorImpl(Injector, lang.Final):
+    _ai: AsyncInjector
+
+    def try_provide(self, key: ta.Any) -> lang.Maybe[ta.Any]:
+        return lang.sync_await(self._ai.try_provide(key))
+
+    def provide(self, key: ta.Any) -> ta.Any:
+        return lang.sync_await(self._ai.provide(key))
+
+    def provide_kwargs(self, kt: KwargsTarget) -> ta.Mapping[str, ta.Any]:
+        return lang.sync_await(self._ai.provide_kwargs(kt))
+
+    def inject(self, obj: ta.Any) -> ta.Any:
+        return lang.sync_await(self._ai.inject(obj))
+
+
+def create_injector(es: Elements) -> Injector:
+    si = InjectorImpl()
+    ai = AsyncInjectorImpl(
+        ElementCollection(es),
+        internal_consts={
+            Key(Injector): si,
+        },
+    )
+    si._ai = ai  # noqa
+    lang.sync_await(ai._init())  # noqa
+    return si

omlish/inject/injector.py

@@ -8,10 +8,8 @@ from .inspect import KwargsTarget
 from .keys import Key
 
 
-if ta.TYPE_CHECKING:
+with lang.auto_proxy_import(globals()):
     from .impl import injector as _injector
-else:
-    _injector = lang.proxy_import('.impl.injector', __package__)
 
 
 T = ta.TypeVar('T')
@@ -20,29 +18,29 @@ T = ta.TypeVar('T')
 ##
 
 
-class Injector(lang.Abstract):
+class AsyncInjector(lang.Abstract):
     @abc.abstractmethod
-    def try_provide(self, key: ta.Any) -> lang.Maybe[ta.Any]:
+    def try_provide(self, key: ta.Any) -> ta.Awaitable[lang.Maybe[ta.Any]]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def provide(self, key: ta.Any) -> ta.Any:
+    def provide(self, key: ta.Any) -> ta.Awaitable[ta.Any]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def provide_kwargs(self, kt: KwargsTarget) -> ta.Mapping[str, ta.Any]:
+    def provide_kwargs(self, kt: KwargsTarget) -> ta.Awaitable[ta.Mapping[str, ta.Any]]:
         raise NotImplementedError
 
     @abc.abstractmethod
-    def inject(self, obj: ta.Any) -> ta.Any:
+    def inject(self, obj: ta.Any) -> ta.Awaitable[ta.Any]:
         raise NotImplementedError
 
     def __getitem__(
             self,
             target: Key[T] | type[T],
-    ) -> T:
+    ) -> ta.Awaitable[T]:
         return self.provide(target)
 
 
-def create_injector(*args: Elemental) -> Injector:
-    return _injector.create_injector(as_elements(*args))
+def create_async_injector(*args: Elemental) -> ta.Awaitable[AsyncInjector]:
+    return _injector.create_async_injector(as_elements(*args))

omlish/inject/inspect.py

@@ -4,10 +4,8 @@ from .. import lang
 from .keys import Key
 
 
-if ta.TYPE_CHECKING:
+with lang.auto_proxy_import(globals()):
     from .impl import inspect as _inspect
-else:
-    _inspect = lang.proxy_import('.impl.inspect', __package__)
 
 
 T = ta.TypeVar('T')

omlish/inject/listeners.py

@@ -4,7 +4,7 @@ from .. import dataclasses as dc
 from .. import lang
 from .bindings import Binding
 from .elements import Element
-from .injector import Injector
+from .injector import AsyncInjector
 from .keys import Key
 
 
@@ -12,11 +12,11 @@ from .keys import Key
 
 
 ProvisionListener: ta.TypeAlias = ta.Callable[[
-    Injector,
+    AsyncInjector,
     Key,
     Binding | None,
-    ta.Callable[[], ta.Any],
-], ta.Callable[[], ta.Any]]
+    ta.Callable[[], ta.Awaitable[ta.Any]],
+], ta.Awaitable[ta.Any]]
 
 
 @dc.dataclass(frozen=True)

omlish/inject/managed.py

@@ -9,14 +9,12 @@ from .. import lang
 from .binder import bind
 from .elements import Elemental
 from .impl.inspect import build_kwargs_target
-from .injector import Injector
-from .injector import create_injector
 
 
-if ta.TYPE_CHECKING:
-    from ..asyncs import all as _asyncs
-else:
-    _asyncs = lang.proxy_import('..asyncs.all', __package__)
+with lang.auto_proxy_import(globals()):
+    from . import injector as _injector
+    from . import maysync as _maysync
+    from . import sync as _sync
 
 
 T = ta.TypeVar('T')
@@ -25,9 +23,43 @@ T = ta.TypeVar('T')
 ##
 
 
+@contextlib.asynccontextmanager
+async def create_async_managed_injector(*args: Elemental) -> ta.AsyncGenerator['_injector.AsyncInjector']:
+    ai = await _injector.create_async_injector(
+        bind(contextlib.AsyncExitStack, singleton=True, eager=True),
+        *args,
+    )
+    async with (await ai[contextlib.AsyncExitStack]):
+        yield ai
+
+
+def make_async_managed_provider(
+        fac: ta.Callable[..., T],
+        *fns: ta.Callable[[T], ta.AsyncContextManager[T]],
+) -> ta.Callable[..., ta.Awaitable[T]]:
+    kt = build_kwargs_target(fac)
+
+    async def _provide(
+            ai: _injector.AsyncInjector,
+            aes: contextlib.AsyncExitStack,
+    ):
+        obj = await ai.inject(kt)
+        if not fns:
+            obj = await aes.enter_async_context(obj)
+        else:
+            for fn in fns:
+                await aes.enter_async_context(fn(obj))
+        return obj
+
+    return _provide
+
+
+##
+
+
 @contextlib.contextmanager
-def create_managed_injector(*args: Elemental) -> ta.Generator[Injector]:
-    i = create_injector(
+def create_managed_injector(*args: Elemental) -> ta.Generator['_sync.Injector']:
+    i = _sync.create_injector(
         bind(contextlib.ExitStack, singleton=True, eager=True),
         *args,
     )
@@ -42,7 +74,7 @@ def make_managed_provider(
     kt = build_kwargs_target(fac)
 
     def _provide(
-            i: Injector,
+            i: _sync.Injector,
             es: contextlib.ExitStack,
     ):
         obj = i.inject(kt)
@@ -59,32 +91,32 @@ def make_managed_provider(
 ##
 
 
-@contextlib.asynccontextmanager
-async def create_async_managed_injector(*args: Elemental) -> ta.AsyncGenerator[Injector]:
-    i = await _asyncs.s_to_a(create_injector)(
-        bind(contextlib.AsyncExitStack, singleton=True, eager=True),
+@contextlib.contextmanager
+def create_maysync_managed_injector(*args: Elemental) -> ta.Generator['_maysync.MaysyncInjector']:
+    i = _maysync.create_maysync_injector(
+        bind(contextlib.ExitStack, singleton=True, eager=True),
         *args,
     )
-    async with i[contextlib.AsyncExitStack]:
+    with i[contextlib.ExitStack]:
         yield i
 
 
-def make_async_managed_provider(
+def make_maysync_managed_provider(
         fac: ta.Callable[..., T],
-        *fns: ta.Callable[[T], ta.AsyncContextManager[T]],
+        *fns: ta.Callable[[T], ta.ContextManager[T]],
 ) -> ta.Callable[..., T]:
     kt = build_kwargs_target(fac)
 
     def _provide(
-            i: Injector,
-            aes: contextlib.AsyncExitStack,
+            i: _maysync.MaysyncInjector,
+            es: contextlib.ExitStack,
     ):
         obj = i.inject(kt)
         if not fns:
-            obj = _asyncs.a_to_s(aes.enter_async_context)(obj)
+            obj = es.enter_context(obj)
         else:
             for fn in fns:
-                _asyncs.a_to_s(aes.enter_async_context)(fn(obj))
+                es.enter_context(fn(obj))
         return obj
 
     return _provide

omlish/inject/maysync.py

@@ -0,0 +1,27 @@
+import typing as ta
+
+from .. import lang
+from .elements import Elemental
+from .elements import as_elements
+from .sync import Injector
+
+
+with lang.auto_proxy_import(globals()):
+    from .impl import maysync as _maysync
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class MaysyncInjector(Injector, lang.Abstract):
+    pass
+
+
+##
+
+
+def create_maysync_injector(*args: Elemental) -> MaysyncInjector:
+    return _maysync.create_maysync_injector(as_elements(*args))

omlish/inject/providers.py

@@ -17,6 +17,12 @@ class Provider(lang.Abstract):
     pass
 
 
+@dc.dataclass(frozen=True)
+@dc.extra_class_params(cache_hash=True)
+class AsyncFnProvider(Provider):
+    fn: ta.Any = dc.xfield(validate=callable)
+
+
 @dc.dataclass(frozen=True)
 @dc.extra_class_params(cache_hash=True)
 class FnProvider(Provider):