omlish 0.0.0.dev433__tar.gz → 0.0.0.dev434__tar.gz

{omlish-0.0.0.dev433/omlish.egg-info → omlish-0.0.0.dev434}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omlish
-Version: 0.0.0.dev433
+Version: 0.0.0.dev434
 Summary: omlish
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -294,9 +294,6 @@ examples are:
 - **pytest** - What is used for all standard testing - as lite code has no dependencies of any kind its testing uses
   stdlib's [unittest](https://docs.python.org/3/library/unittest.html).
 - **wrapt** - For (optionally-enabled) injector circular proxies.
-- **greenlet** - For some gnarly stuff like the
-  [sync<->async bridge](https://github.com/wrmsr/omlish/blob/master/omlish/asyncs/bridge.py) and the
-  [io trampoline](https://github.com/wrmsr/omlish/blob/master/omextra/io/trampoline.py).
 - **sqlalchemy** - Parts of the codebase use SQLAlchemy for db stuff, but it is being migrated away from in favor of the
   internal api. It will however likely still remain as an optional dep for the api adapter.
 

{omlish-0.0.0.dev433 → omlish-0.0.0.dev434}/README.md

@@ -185,9 +185,6 @@ examples are:
 - **pytest** - What is used for all standard testing - as lite code has no dependencies of any kind its testing uses
   stdlib's [unittest](https://docs.python.org/3/library/unittest.html).
 - **wrapt** - For (optionally-enabled) injector circular proxies.
-- **greenlet** - For some gnarly stuff like the
-  [sync<->async bridge](https://github.com/wrmsr/omlish/blob/master/omlish/asyncs/bridge.py) and the
-  [io trampoline](https://github.com/wrmsr/omlish/blob/master/omextra/io/trampoline.py).
 - **sqlalchemy** - Parts of the codebase use SQLAlchemy for db stuff, but it is being migrated away from in favor of the
   internal api. It will however likely still remain as an optional dep for the api adapter.
 

{omlish-0.0.0.dev433 → omlish-0.0.0.dev434}/omlish/__about__.py

@@ -1,5 +1,5 @@
-__version__ = '0.0.0.dev433'
-__revision__ = '8b1520428b44d4d75317513a61d17c5e6f0c7711'
+__version__ = '0.0.0.dev434'
+__revision__ = '17585e1a0390e30925b0e2c5e65944f8f99a9dc3'
 
 
 #

{omlish-0.0.0.dev433 → omlish-0.0.0.dev434}/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-0.0.0.dev434/omlish/inject/__init__.py

@@ -0,0 +1,167 @@
+"""
+~> https://github.com/google/guice/commit/70248eafa90cd70a68b293763e53f6aec656e73c
+"""
+from .. import dataclasses as _dc
+
+
+_dc.init_package(
+    globals(),
+    codegen=True,
+)
+
+
+##
+
+
+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-0.0.0.dev433 → omlish-0.0.0.dev434}/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-0.0.0.dev433 → omlish-0.0.0.dev434}/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-0.0.0.dev433 → omlish-0.0.0.dev434}/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-0.0.0.dev433 → omlish-0.0.0.dev434}/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-0.0.0.dev434/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-0.0.0.dev433 → omlish-0.0.0.dev434}/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-0.0.0.dev433 → omlish-0.0.0.dev434}/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: