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

omlish/inject/scopes.py

@@ -7,16 +7,17 @@ from .. import dataclasses as dc
 from .. import lang
 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
 from .types import Scope
 
 
-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
+    from . import maysync as _maysync
+    from . import sync as _sync
 
 
 ##
@@ -65,7 +66,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
 
 
@@ -81,11 +82,38 @@ def bind_scope_seed(k: ta.Any, ss: SeededScope) -> Element:
     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_context_manager(async_enter_seeded_scope(
+        i[AsyncInjector],
+        ss,
+        keys,
+    ))

omlish/inject/sync.py

@@ -0,0 +1,46 @@
+import abc
+import typing as ta
+
+from .. import lang
+from .elements import Elemental
+from .elements import as_elements
+from .inspect import KwargsTarget
+from .keys import Key
+
+
+with lang.auto_proxy_import(globals()):
+    from .impl import sync as _sync
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+class Injector(lang.Abstract):
+    @abc.abstractmethod
+    def try_provide(self, key: ta.Any) -> lang.Maybe[ta.Any]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def provide(self, key: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def provide_kwargs(self, kt: KwargsTarget) -> ta.Mapping[str, ta.Any]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def inject(self, obj: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    def __getitem__(
+            self,
+            target: Key[T] | type[T],
+    ) -> T:
+        return self.provide(target)
+
+
+def create_injector(*args: Elemental) -> Injector:
+    return _sync.create_injector(as_elements(*args))

omlish/lang/__init__.py

@@ -15,6 +15,9 @@ with _auto_proxy_init(
 
         sync_await,
         sync_async_list,
+
+        SyncAsyncContextManager,
+        sync_async_context_manager,
     )
 
     from .attrstorage import (  # noqa
@@ -184,6 +187,9 @@ with _auto_proxy_init(
         Timer,
 
         double_check_setdefault,
+
+        call_with_exit_stack,
+        call_with_async_exit_stack,
     )
 
     from .datetimes import (  # noqa
@@ -260,6 +266,12 @@ with _auto_proxy_init(
         nextgen,
     )
 
+    from .imports.capture import (  # noqa
+        ImportCaptureError,
+        ImportCaptureErrors,
+        ImportCapture,
+    )
+
     from .imports.conditional import (  # noqa
         register_conditional_import,
         trigger_conditional_imports,
@@ -267,15 +279,17 @@ with _auto_proxy_init(
 
     from .imports.lazy import (  # noqa
         lazy_import,
+    )
+
+    from .imports.proxy import (  # noqa
         proxy_import,
+
+        auto_proxy_import,
     )
 
     from .imports.proxyinit import (  # noqa
         proxy_init,
 
-        AutoProxyInitError,
-        AutoProxyInitErrors,
-        AutoProxyInit,
         auto_proxy_init,
     )
 
@@ -479,9 +493,6 @@ with _auto_proxy_init(
     )
 
     from ..lite.maysync import (  # noqa
-        mark_maysync,
-        is_maysync,
-
         AnyMaysyncFn,
 
         MaywaitableAlreadyConsumedError,
@@ -496,6 +507,12 @@ with _auto_proxy_init(
         is_running_maysync,
 
         run_maysync,
+
+        RunMaysyncContextManager,
+        run_maysync_context_manager,
+
+        mark_maysync,
+        is_maysync,
     )
 
     from ..lite.objects import (  # noqa

omlish/lang/asyncs.py

@@ -79,3 +79,21 @@ def sync_async_list(
         raise TypeError(lst)
 
     return lst
+
+
+@ta.final
+class SyncAsyncContextManager(ta.Generic[T]):
+    def __init__(self, acm: ta.AsyncContextManager[T]) -> None:
+        self._acm = acm
+
+    def __repr__(self) -> str:
+        return f'{self.__class__.__name__}({self._acm!r})'
+
+    def __enter__(self) -> T:
+        return sync_await(self._acm.__aenter__())
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return sync_await(self._acm.__aexit__(exc_type, exc_val, exc_tb))
+
+
+sync_async_context_manager = SyncAsyncContextManager

omlish/lang/contextmanagers.py

@@ -20,6 +20,8 @@ T = ta.TypeVar('T')
 K = ta.TypeVar('K')
 V = ta.TypeVar('V')
 
+P = ta.ParamSpec('P')
+
 
 ##
 
@@ -382,3 +384,24 @@ def double_check_setdefault(
         v = fn()
         dct[k] = v
         return v
+
+
+##
+
+
+def call_with_exit_stack(
+        fn: ta.Callable[ta.Concatenate[contextlib.ExitStack, P], T],
+        *args: ta.Any,
+        **kwargs: ta.Any,
+) -> T:
+    with contextlib.ExitStack() as es:
+        return fn(es, *args, **kwargs)
+
+
+async def call_with_async_exit_stack(
+        fn: ta.Callable[ta.Concatenate[contextlib.AsyncExitStack, P], ta.Awaitable[T]],
+        *args: ta.Any,
+        **kwargs: ta.Any,
+) -> T:
+    async with contextlib.AsyncExitStack() as aes:
+        return await fn(aes, *args, **kwargs)