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

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,13 @@ 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_
+    from . import injector as _injector
 else:
-    injector_ = lang.proxy_import('.injector', __package__)
+    _injector = lang.proxy_import('.injector', __package__)
 
 
 ##
@@ -51,7 +50,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 +59,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 +73,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 +93,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 +103,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 +119,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 +147,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 +176,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,41 @@
+import typing as ta
+
+from ... import lang
+from ..elements import CollectedElements
+from ..injector import AsyncInjector
+from ..inspect import KwargsTarget
+from ..keys import Key
+from ..sync import Injector
+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(ce: CollectedElements) -> Injector:
+    si = InjectorImpl()
+    ai = AsyncInjectorImpl(
+        ce,
+        internal_consts={
+            Key(Injector): si,
+        },
+    )
+    si._ai = ai  # noqa
+    lang.sync_await(ai._init())  # noqa
+    return si

omlish/inject/injector.py

@@ -1,9 +1,12 @@
 import abc
 import typing as ta
 
+from .. import check
 from .. import lang
+from .elements import CollectedElements
 from .elements import Elemental
 from .elements import as_elements
+from .elements import collect_elements
 from .inspect import KwargsTarget
 from .keys import Key
 
@@ -20,29 +23,55 @@ 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))
+##
+
+
+@ta.final
+class _InjectorCreator(ta.Generic[T]):
+    def __init__(self, fac: ta.Callable[[CollectedElements], T]) -> None:
+        self._fac = fac
+
+    @ta.overload
+    def __call__(self, es: CollectedElements, /) -> T: ...
+
+    @ta.overload
+    def __call__(self, *es: Elemental) -> T: ...
+
+    def __call__(self, arg0, *argv):
+        ce: CollectedElements
+        if isinstance(arg0, CollectedElements):
+            check.arg(not argv)
+            ce = arg0
+        else:
+            ce = collect_elements(as_elements(arg0, *argv))
+        return self._fac(ce)
+
+
+##
+
+
+create_async_injector = _InjectorCreator[ta.Awaitable[AsyncInjector]](lambda ce: _injector.create_async_injector(ce))

omlish/inject/inspect.py

@@ -2,6 +2,7 @@ import typing as ta
 
 from .. import lang
 from .keys import Key
+from .keys import as_key
 
 
 if ta.TYPE_CHECKING:
@@ -21,11 +22,45 @@ class Kwarg(ta.NamedTuple):
     key: Key
     has_default: bool
 
+    @classmethod
+    def of(
+            cls,
+            name: str,
+            key: Key,
+            *,
+            has_default: bool = False,
+    ) -> 'Kwarg':
+        return cls(
+            name,
+            key,
+            has_default,
+        )
+
 
 class KwargsTarget(ta.NamedTuple):
     obj: ta.Any
     kwargs: ta.Sequence[Kwarg]
 
+    @classmethod
+    def of(
+            cls,
+            obj: ta.Any,
+            *kws: Kwarg,
+            **kwargs: tuple[Key, bool] | Key | ta.Any,
+    ) -> 'KwargsTarget':
+        kw_kwargs: list[Kwarg] = []
+        for n, v in kwargs.items():
+            if isinstance(v, tuple):
+                kw_k, kw_hd = v
+                kw_kwargs.append(Kwarg.of(n, kw_k, has_default=kw_hd))
+            else:
+                kw_kwargs.append(Kwarg.of(n, as_key(v)))
+
+        return cls(
+            obj,
+            [*kws, *kw_kwargs],
+        )
+
 
 def tag(obj: T, **kwargs: ta.Any) -> T:
     return _inspect.tag(obj, **kwargs)

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,16 @@ 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
+    from . import injector as _injector
+    from . import maysync as _maysync
+    from . import sync as _sync
 else:
-    _asyncs = lang.proxy_import('..asyncs.all', __package__)
+    _injector = lang.proxy_import('.injector', __package__)
+    _maysync = lang.proxy_import('.maysync', __package__)
+    _sync = lang.proxy_import('.sync', __package__)
 
 
 T = ta.TypeVar('T')
@@ -25,9 +27,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 +78,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 +95,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 .injector import _InjectorCreator
+from .sync import Injector
+
+
+if ta.TYPE_CHECKING:
+    from .impl import maysync as _maysync
+else:
+    _maysync = lang.proxy_import('.impl.maysync', __package__)
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class MaysyncInjector(Injector, lang.Abstract):
+    pass
+
+
+##
+
+
+create_maysync_injector = _InjectorCreator[MaysyncInjector](lambda ce: _maysync.create_maysync_injector(ce))

omlish/inject/multis.py

@@ -1,5 +1,7 @@
 """
 TODO:
+ - DynamicSetBinding / DynamicMapBinding ? provider of set[T] / map[K, V] ?
+  - doable not guicey - too much dynamism
  - scopes
 """
 import collections.abc
@@ -94,6 +96,9 @@ class SetBinder(ElementGenerator, ta.Generic[T]):
         yield from self._sbs
 
 
+set_binder = SetBinder
+
+
 #
 
 
@@ -123,3 +128,6 @@ class MapBinder(ElementGenerator, ta.Generic[K, V]):
     def __iter__(self) -> ta.Iterator[Element]:
         yield self._map_provider_binding
         yield from self._mbs
+
+
+map_binder = MapBinder

omlish/inject/overrides.py

@@ -14,9 +14,9 @@ from .elements import as_elements
 @dc.dataclass(frozen=True)
 @dc.extra_class_params(cache_hash=True)
 class Overrides(Element, lang.Final):
-    ovr: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
     src: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
+    ovr: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
 
 
-def override(ovr: ta.Any, *a: ta.Any) -> Element:
-    return Overrides(as_elements(ovr), as_elements(*a))
+def override(src: ta.Any, *ovr: ta.Any) -> Element:
+    return Overrides(as_elements(src), as_elements(*ovr))

omlish/inject/privates.py

@@ -18,6 +18,12 @@ class Expose(Element, lang.Final):
     key: Key = dc.xfield(coerce=as_key)
 
 
+expose = Expose
+
+
+#
+
+
 @dc.dataclass(frozen=True)
 @dc.extra_class_params(cache_hash=True)
 class Private(Element, lang.Final):

omlish/inject/providers.py

@@ -3,6 +3,7 @@ import typing as ta
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
+from .inspect import KwargsTarget
 from .keys import Key
 
 
@@ -17,10 +18,16 @@ 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=lambda v: callable(v) or isinstance(v, KwargsTarget))
+
+
 @dc.dataclass(frozen=True)
 @dc.extra_class_params(cache_hash=True)
 class FnProvider(Provider):
-    fn: ta.Any = dc.xfield(validate=callable)
+    fn: ta.Any = dc.xfield(validate=lambda v: callable(v) or isinstance(v, KwargsTarget))
 
 
 @dc.dataclass(frozen=True)

omlish/inject/scopes.py

@@ -5,9 +5,9 @@ import typing as ta
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
-from .. import reflect as rfl
 from .bindings import Binding
 from .elements import Element
+from .injector import AsyncInjector
 from .keys import Key
 from .keys import as_key
 from .providers import Provider
@@ -15,9 +15,13 @@ from .types import Scope
 
 
 if ta.TYPE_CHECKING:
-    from . import injector as injector_
+    from . import injector as _injector
+    from . import maysync as _maysync
+    from . import sync as _sync
 else:
-    injector_ = lang.proxy_import('.injector', __package__)
+    _injector = lang.proxy_import('.injector', __package__)
+    _maysync = lang.proxy_import('.maysync', __package__)
+    _sync = lang.proxy_import('.sync', __package__)
 
 
 ##
@@ -66,7 +70,7 @@ class SeededScope(Scope, lang.Final):
 
     class Manager(lang.Abstract):
         @abc.abstractmethod
-        def __call__(self, seeds: ta.Mapping[Key, ta.Any]) -> ta.ContextManager[None]:
+        def __call__(self, seeds: ta.Mapping[Key, ta.Any]) -> ta.AsyncContextManager[None]:
             raise NotImplementedError
 
 
@@ -76,20 +80,44 @@ class ScopeSeededProvider(Provider):
     ss: SeededScope = dc.xfield(coerce=check.of_isinstance(SeededScope))
     key: Key = dc.xfield(coerce=check.of_isinstance(Key))
 
-    def provided_ty(self) -> rfl.Type | None:
-        return self.key.ty
-
 
 def bind_scope_seed(k: ta.Any, ss: SeededScope) -> Element:
     k = as_key(k)
     return Binding(k, ScopeSeededProvider(ss, k))
 
 
-@contextlib.contextmanager
-def enter_seeded_scope(
-        i: injector_.Injector,
+##
+
+
+@contextlib.asynccontextmanager
+async def async_enter_seeded_scope(
+        i: '_injector.AsyncInjector',
         ss: SeededScope,
         keys: ta.Mapping[Key, ta.Any],
-) -> ta.Generator[None]:
-    with i.provide(Key(SeededScope.Manager, tag=ss))(keys):
+) -> ta.AsyncGenerator[None]:
+    async with (await i.provide(Key(SeededScope.Manager, tag=ss)))(keys):
         yield
+
+
+def enter_seeded_scope(
+        i: '_sync.Injector',
+        ss: SeededScope,
+        keys: ta.Mapping[Key, ta.Any],
+) -> ta.ContextManager[None]:
+    return lang.run_maysync_context_manager(async_enter_seeded_scope(
+        i[AsyncInjector],
+        ss,
+        keys,
+    ))
+
+
+def maysync_enter_seeded_scope(
+        i: '_maysync.MaysyncInjector',
+        ss: SeededScope,
+        keys: ta.Mapping[Key, ta.Any],
+) -> ta.ContextManager[None]:
+    return lang.sync_async_with(async_enter_seeded_scope(
+        i[AsyncInjector],
+        ss,
+        keys,
+    ))