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

omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev432'
-__revision__ = '7ead9c62b6897ffcbdb85f12366ebaaf41f89d7a'
+__version__ = '0.0.0.dev434'
+__revision__ = '17585e1a0390e30925b0e2c5e65944f8f99a9dc3'
 
 
 #
@@ -41,7 +41,7 @@ class Project(ProjectBase):
 
             'greenlet ~= 3.2',
 
-            'trio ~= 0.30',
+            'trio ~= 0.31',
             'trio-asyncio ~= 0.15',
         ],
 

omlish/asyncs/all.py

@@ -1,12 +1,3 @@
-from .bridge import (  # noqa
-    a_to_s,
-    is_in_bridge,
-    s_to_a,
-    s_to_a_await,
-    trivial_a_to_s,
-    trivial_s_to_a,
-)
-
 from .flavors import (  # noqa
     ContextManagerAdapter,
     Flavor,
@@ -25,7 +16,3 @@ from .flavors import (  # noqa
     mark_trio,
     with_adapter_loop,
 )
-
-from .utils import (  # noqa
-    call_with_async_exit_stack,
-)

omlish/inject/__init__.py

@@ -13,129 +13,155 @@ _dc.init_package(
 ##
 
 
-from .binder import (  # noqa
-    bind,
-    bind_as_fn,
-    bind_map_entry_const,
-    bind_set_entry_const,
-)
-
-from .bindings import (  # noqa
-    Binding,
-)
-
-from .eagers import (  # noqa
-    Eager,
-)
-
-from .elements import (  # noqa
-    Element,
-    Elemental,
-    Elements,
-    as_elements,
-)
-
-from .errors import (  # noqa
-    BaseKeyError,
-    ConflictingKeyError,
-    CyclicDependencyError,
-    ScopeAlreadyOpenError,
-    ScopeError,
-    ScopeNotOpenError,
-    UnboundKeyError,
-)
-
-from .injector import (  # noqa
-    create_injector,
-    Injector,
-)
-
-from .inspect import (  # noqa
-    Kwarg,
-    KwargsTarget,
-    build_kwargs_target,
-    tag,
-)
-
-from .keys import (  # noqa
-    Key,
-    as_key,
-)
-
-from .listeners import (  # noqa
-    ProvisionListener,
-    ProvisionListenerBinding,
-    bind_provision_listener,
-)
-
-from .managed import (  # noqa
-    create_async_managed_injector,
-    create_managed_injector,
-    make_async_managed_provider,
-    make_managed_provider,
-)
-
-from .multis import (  # noqa
-    MapBinding,
-    MapProvider,
-    SetBinding,
-    SetProvider,
-    MapBinder,
-    SetBinder,
-
-    MapBinder as map_binder,  # noqa
-    SetBinder as set_binder,  # noqa
-)
-
-
-from .overrides import (  # noqa
-    Overrides,
-    override,
-)
-
-from .origins import (  # noqa
-    HasOrigins,
-    Origin,
-    Origins,
-)
-
-from .privates import (  # noqa
-    Expose,
-    Private,
-    private,
-
-    Expose as expose,  # noqa
-)
-
-from .providers import (  # noqa
-    ConstProvider,
-    CtorProvider,
-    FnProvider,
-    LinkProvider,
-    Provider,
-)
-
-from .scopes import (  # noqa
-    ScopeBinding,
-    ScopeSeededProvider,
-    SeededScope,
-    Singleton,
-    ThreadScope,
-    bind_scope,
-    bind_scope_seed,
-    enter_seeded_scope,
-)
-
-from .tags import (  # noqa
-    Id,
-)
-
-from .types import (  # noqa
-    Scope,
-    Tag,
-    Unscoped,
-)
-
-from .utils import (  # noqa
-    ConstFn,
-)
+from .. import lang as _lang  # noqa
+
+
+with _lang.auto_proxy_init(globals()):
+    ##
+
+    from .binder import (  # noqa
+        bind,
+        bind_as_fn,
+        bind_map_entry_const,
+        bind_set_entry_const,
+    )
+
+    from .bindings import (  # noqa
+        Binding,
+    )
+
+    from .eagers import (  # noqa
+        Eager,
+    )
+
+    from .elements import (  # noqa
+        Element,
+        Elemental,
+        Elements,
+        as_elements,
+    )
+
+    from .errors import (  # noqa
+        BaseKeyError,
+        ConflictingKeyError,
+        CyclicDependencyError,
+        ScopeAlreadyOpenError,
+        ScopeError,
+        ScopeNotOpenError,
+        UnboundKeyError,
+    )
+
+    from .injector import (  # noqa
+        AsyncInjector,
+        create_async_injector,
+    )
+
+    from .inspect import (  # noqa
+        Kwarg,
+        KwargsTarget,
+        build_kwargs_target,
+        tag,
+    )
+
+    from .keys import (  # noqa
+        Key,
+        as_key,
+    )
+
+    from .listeners import (  # noqa
+        ProvisionListener,
+        ProvisionListenerBinding,
+        bind_provision_listener,
+    )
+
+    from .managed import (  # noqa
+        create_async_managed_injector,
+        make_async_managed_provider,
+
+        create_managed_injector,
+        make_managed_provider,
+
+        create_maysync_managed_injector,
+        make_maysync_managed_provider,
+    )
+
+    from .maysync import (  # noqa
+        MaysyncInjector,
+        create_maysync_injector,
+    )
+
+    from .multis import (  # noqa
+        MapBinding,
+        MapProvider,
+        SetBinding,
+        SetProvider,
+        MapBinder,
+        SetBinder,
+
+        MapBinder as map_binder,  # noqa
+        SetBinder as set_binder,  # noqa
+    )
+
+
+    from .overrides import (  # noqa
+        Overrides,
+        override,
+    )
+
+    from .origins import (  # noqa
+        HasOrigins,
+        Origin,
+        Origins,
+    )
+
+    from .privates import (  # noqa
+        Expose,
+        Private,
+        private,
+
+        Expose as expose,  # noqa
+    )
+
+    from .providers import (  # noqa
+        ConstProvider,
+        CtorProvider,
+        FnProvider,
+        LinkProvider,
+        Provider,
+    )
+
+    from .scopes import (  # noqa
+        ScopeBinding,
+        bind_scope,
+
+        Singleton,
+
+        ThreadScope,
+
+        SeededScope,
+        ScopeSeededProvider,
+        bind_scope_seed,
+
+        async_enter_seeded_scope,
+        enter_seeded_scope,
+        maysync_enter_seeded_scope,
+    )
+
+    from .sync import (  # noqa
+        Injector,
+        create_injector,
+    )
+
+    from .tags import (  # noqa
+        Id,
+    )
+
+    from .types import (  # noqa
+        Scope,
+        Tag,
+        Unscoped,
+    )
+
+    from .utils import (  # noqa
+        ConstFn,
+    )

omlish/inject/binder.py

@@ -19,6 +19,7 @@ from .multis import SetBinding
 from .multis import is_map_multi_key
 from .multis import is_set_multi_key
 from .privates import Expose
+from .providers import AsyncFnProvider
 from .providers import ConstProvider
 from .providers import CtorProvider
 from .providers import FnProvider
@@ -31,10 +32,8 @@ from .types import Scope
 from .types import Unscoped
 
 
-if ta.TYPE_CHECKING:
-    from .impl.inspect import inspect as _inspect
-else:
-    _inspect = lang.proxy_import('.impl.inspect', __package__)
+with lang.auto_proxy_import(globals()):
+    from .impl import inspect as _inspect
 
 
 T = ta.TypeVar('T')
@@ -83,6 +82,7 @@ def bind(
         *,
         tag: ta.Any = None,
 
+        to_async_fn: ta.Any = None,
         to_fn: ta.Any = None,
         to_ctor: ta.Any = None,
         to_const: ta.Any = None,
@@ -102,6 +102,7 @@ def bind(
     ##
 
     has_to = (
+        to_async_fn is not None or
         to_fn is not None or
         to_ctor is not None or
         to_const is not None or
@@ -137,6 +138,8 @@ def bind(
     ##
 
     providers: list[Provider] = []
+    if to_async_fn is not None:
+        providers.append(AsyncFnProvider(to_async_fn))
     if to_fn is not None:
         providers.append(FnProvider(to_fn))
     if to_ctor is not None:

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