omlish 0.0.0.dev5__py3-none-any.whl → 0.0.0.dev7__py3-none-any.whl

omlish/inject/inspect.py

@@ -1,8 +1,18 @@
 import typing as ta
 
+from .. import lang
 from .keys import Key
 
 
+if ta.TYPE_CHECKING:
+    from .impl import inspect as _inspect
+else:
+    _inspect = lang.proxy_import('.impl.inspect', __package__)
+
+
+T = ta.TypeVar('T')
+
+
 class Kwarg(ta.NamedTuple):
     name: str
     key: Key
@@ -12,3 +22,11 @@ class Kwarg(ta.NamedTuple):
 class KwargsTarget(ta.NamedTuple):
     obj: ta.Any
     kwargs: ta.Sequence[Kwarg]
+
+
+def tag(obj: T, **kwargs: ta.Any) -> T:
+    return _inspect.tag(obj, **kwargs)
+
+
+def build_kwargs_target(obj: ta.Any, **kwargs: ta.Any) -> KwargsTarget:
+    return _inspect.build_kwargs_target(obj, **kwargs)

omlish/inject/keys.py

@@ -4,34 +4,28 @@ import typing as ta
 from .. import dataclasses as dc
 from .. import lang
 from .. import reflect as rfl
+from .types import Tag
 
 
 T = ta.TypeVar('T')
 
 
-##
-
-
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class Key(lang.Final, ta.Generic[T]):
     ty: rfl.Type = dc.xfield(coerce=rfl.type_)
-    tag: ta.Any = dc.field(default=None, kw_only=True)
 
-
-##
+    tag: ta.Any = dc.xfield(
+        default=None,
+        kw_only=True,
+        check=lambda o: not isinstance(o, Tag),
+        repr_fn=dc.opt_repr,
+    )
 
 
 def as_key(o: ta.Any) -> Key:
-    if o is inspect.Parameter.empty:
+    if o is None or o is inspect.Parameter.empty:
         raise TypeError(o)
     if isinstance(o, Key):
         return o
     return Key(rfl.type_(o))
-
-
-##
-
-
-def tag(o: ta.Any, t: ta.Any) -> Key:
-    return dc.replace(as_key(o), tag=t)

omlish/inject/listeners.py

@@ -0,0 +1,26 @@
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+from .bindings import Binding
+from .elements import Element
+from .injector import Injector
+from .keys import Key
+
+
+ProvisionListener: ta.TypeAlias = ta.Callable[[
+    Injector,
+    Key,
+    Binding,
+    ta.Callable[[], ta.Any],
+], ta.Callable[[], ta.Any]]
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
+class ProvisionListenerBinding(Element, lang.Final):
+    listener: ProvisionListener
+
+
+def bind_provision_listener(l: ProvisionListener) -> Element:
+    return ProvisionListenerBinding(l)

omlish/inject/managed.py

@@ -5,20 +5,86 @@ TODO:
 import contextlib
 import typing as ta
 
-from .eagers import eager
-from .elements import Elements
-from .elements import as_elements
+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
-from .scopes import singleton
+
+
+if ta.TYPE_CHECKING:
+    from .. import asyncs as _asyncs
+else:
+    _asyncs = lang.proxy_import('..asyncs', __package__)
+
+
+T = ta.TypeVar('T')
+
+
+##
 
 
 @contextlib.contextmanager
-def create_managed_injector(es: Elements) -> ta.Generator[Injector, None, None]:
-    i = create_injector(as_elements(
-        es,
-        singleton(contextlib.ExitStack),
-        eager(contextlib.ExitStack),
-    ))
+def create_managed_injector(*args: Elemental) -> ta.Generator[Injector, None, None]:
+    i = create_injector(
+        bind(contextlib.ExitStack, singleton=True, eager=True),
+        *args,
+    )
     with i[contextlib.ExitStack]:
         yield i
+
+
+def make_managed_provider(
+        fac: ta.Callable[..., T],
+        *fns: ta.Callable[[T], ta.ContextManager[T]],
+) -> ta.Callable[..., T]:
+    kt = build_kwargs_target(fac)
+
+    def _provide(
+            i: Injector,
+            es: contextlib.ExitStack,
+    ):
+        obj = i.inject(kt)
+        if not fns:
+            obj = es.enter_context(obj)
+        else:
+            for fn in fns:
+                es.enter_context(fn(obj))
+        return obj
+
+    return _provide
+
+
+##
+
+
+@contextlib.asynccontextmanager
+async def create_async_managed_injector(*args: Elemental) -> ta.AsyncGenerator[Injector, None]:
+    i = await _asyncs.s_to_a(create_injector)(
+        bind(contextlib.AsyncExitStack, singleton=True, eager=True),
+        *args,
+    )
+    async with i[contextlib.AsyncExitStack]:
+        yield i
+
+
+def make_async_managed_provider(
+        fac: ta.Callable[..., T],
+        *fns: ta.Callable[[T], ta.AsyncContextManager[T]],
+) -> ta.Callable[..., T]:
+    kt = build_kwargs_target(fac)
+
+    def _provide(
+            i: Injector,
+            aes: contextlib.AsyncExitStack,
+    ):
+        obj = i.inject(kt)
+        if not fns:
+            obj = _asyncs.a_to_s(aes.enter_async_context)(obj)
+        else:
+            for fn in fns:
+                _asyncs.a_to_s(aes.enter_async_context)(fn(obj))
+        return obj
+
+    return _provide

omlish/inject/multis.py

@@ -5,16 +5,23 @@ TODO:
 import collections.abc
 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 .elements import ElementGenerator
 from .keys import Key
 from .keys import as_key
 from .providers import Provider
 
 
+T = ta.TypeVar('T')
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
 ##
 
 
@@ -26,21 +33,14 @@ def _check_set_multi_key(mk: Key) -> bool:
 @dc.extra_params(cache_hash=True)
 class SetBinding(Element, lang.Final):
     multi_key: Key = dc.xfield(check=_check_set_multi_key)
-    dst: Key = dc.xfield()
+    dst: Key = dc.xfield(coerce=check.of_isinstance(Key))
 
 
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class SetProvider(Provider):
     multi_key: Key = dc.xfield(check=_check_set_multi_key)
 
-    def provided_ty(self) -> rfl.Type | None:
-        return self.multi_key.ty
-
-
-def bind_set_provider(multi_key: ta.Any) -> Element:
-    multi_key = as_key(multi_key)
-    return Binding(multi_key, SetProvider(multi_key))
-
 
 ##
 
@@ -53,18 +53,68 @@ def _check_map_multi_key(mk: Key) -> bool:
 @dc.extra_params(cache_hash=True)
 class MapBinding(Element, lang.Final):
     multi_key: Key = dc.xfield(check=_check_map_multi_key)
-    map_key: ta.Any = dc.xfield(())
-    dst: Key = dc.xfield(())
+    map_key: ta.Any = dc.xfield()
+    dst: Key = dc.xfield(coerce=check.of_isinstance(Key))
 
 
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class MapProvider(Provider):
     multi_key: Key = dc.xfield(check=_check_map_multi_key)
 
-    def provided_ty(self) -> rfl.Type | None:
-        return self.multi_key.ty
+
+##
 
 
-def bind_map_provider(multi_key: ta.Any) -> Element:
-    multi_key = as_key(multi_key)
-    return Binding(multi_key, MapProvider(multi_key))
+class SetBinder(ElementGenerator, ta.Generic[T]):
+    def __init__(self, *, tag: ta.Any = None) -> None:
+        super().__init__()
+        self._tag: ta.Any = tag
+        self._sbs: list[SetBinding] = []
+
+    @lang.cached_property
+    def _multi_key(self) -> Key:
+        oty = rfl.type_(rfl.get_orig_class(self))
+        ety = check.single(check.isinstance(oty, rfl.Generic).args)
+        return Key(ta.AbstractSet[ety], tag=self._tag)  # type: ignore
+
+    @lang.cached_property
+    def _set_provider_binding(self) -> Element:
+        return Binding(self._multi_key, SetProvider(self._multi_key))
+
+    def bind(self, *keys: ta.Any) -> ta.Self:
+        if not isinstance(self, SetBinder):
+            raise TypeError
+        self._sbs.extend(SetBinding(self._multi_key, as_key(k)) for k in keys)
+        return self  # type: ignore
+
+    def __iter__(self) -> ta.Iterator[Element]:
+        yield self._set_provider_binding
+        yield from self._sbs
+
+
+class MapBinder(ElementGenerator, ta.Generic[K, V]):
+    def __init__(self, *, tag: ta.Any = None) -> None:
+        super().__init__()
+        self._tag: ta.Any = tag
+        self._mbs: list[MapBinding] = []
+
+    @lang.cached_property
+    def _multi_key(self) -> Key:
+        oty = rfl.type_(rfl.get_orig_class(self))
+        kty, vty = check.isinstance(oty, rfl.Generic).args
+        return Key(ta.Mapping[kty, vty], tag=self._tag)  # type: ignore
+
+    @lang.cached_property
+    def _map_provider_binding(self) -> Element:
+        return Binding(self._multi_key, MapProvider(self._multi_key))
+
+    def bind(self, map_key: K, map_value_key: ta.Any) -> ta.Self:
+        if not isinstance(self, MapBinder):
+            raise TypeError
+        self._mbs.append(MapBinding(self._multi_key, map_key, as_key(map_value_key)))
+        return self  # type: ignore
+
+    def __iter__(self) -> ta.Iterator[Element]:
+        yield self._map_provider_binding
+        yield from self._mbs

omlish/inject/origins.py

@@ -0,0 +1,30 @@
+import abc
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+
+
+T = ta.TypeVar('T')
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
+class Origin:
+    lst: ta.Sequence[str]
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
+class Origins:
+    lst: ta.Sequence[Origin]
+
+    def __iter__(self) -> ta.Iterator[Origin]:
+        yield from self.lst
+
+
+class HasOrigins(lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def origins(self) -> Origins:
+        raise NotImplementedError

omlish/inject/overrides.py

@@ -1,18 +1,19 @@
 import typing as ta
 
+from .. import check
 from .. import dataclasses as dc
 from .. import lang
-from .binder import bind
 from .elements import Element
 from .elements import Elements
+from .elements import as_elements
 
 
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class Overrides(Element, lang.Final):
-    ovr: Elements
-    src: Elements
+    ovr: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
+    src: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
 
 
 def override(ovr: ta.Any, *a: ta.Any) -> Element:
-    return Overrides(bind(ovr), bind(*a))
+    return Overrides(as_elements(ovr), as_elements(*a))

omlish/inject/{private.py → privates.py}

@@ -1,10 +1,10 @@
-import typing as ta
-
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
 from .elements import Element
+from .elements import Elemental
 from .elements import Elements
+from .elements import as_elements
 from .keys import Key
 from .keys import as_key
 
@@ -12,18 +12,14 @@ from .keys import as_key
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class Expose(Element, lang.Final):
-    key: Key
-
-
-def expose(k: ta.Any) -> Element:
-    return Expose(as_key(k))
+    key: Key = dc.xfield(coerce=as_key)
 
 
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class Private(Element, lang.Final):
-    elements: Elements
+    elements: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
 
 
-def private(es: Elements) -> Element:
-    return Private(check.isinstance(es, Elements))
+def private(*args: Elemental) -> Private:
+    return Private(as_elements(*args))

omlish/inject/providers.py

@@ -1,111 +1,38 @@
-import abc
 import typing as ta
 
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
-from .. import reflect as rfl
-from .elements import Element
-from .elements import Elements
-from .impl.inspect import signature
 from .keys import Key
-from .keys import as_key
 
 
 class _Missing(lang.NotInstantiable):
     pass
 
 
-##
-
-
 class Provider(lang.Abstract):
-    @abc.abstractmethod
-    def provided_ty(self) -> rfl.Type | None:
-        raise NotImplementedError
-
-
-##
-
-
-def as_provider(o: ta.Any) -> Provider:
-    check.not_isinstance(o, (Element, Elements))
-    if isinstance(o, Provider):
-        return o
-    if isinstance(o, Key):
-        return link(o)
-    if isinstance(o, type):
-        return ctor(o)
-    if callable(o):
-        return fn(o)
-    return const(o)
-
-
-##
+    pass
 
 
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class FnProvider(Provider):
-    fn: ta.Any
-    ty: rfl.Type | None = None
-
-    def provided_ty(self) -> rfl.Type | None:
-        return self.ty
-
-
-def fn(fn: ta.Any, ty: rfl.Type | None = _Missing) -> Provider:
-    check.not_isinstance(fn, type)
-    check.callable(fn)
-    if ty is _Missing:
-        sig = signature(fn)
-        ty = check.isinstance(sig.return_annotation, type)
-    return FnProvider(fn, ty)
-
-
-##
+    fn: ta.Any = dc.xfield(check=callable)
 
 
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class CtorProvider(Provider):
-    ty: type
+    ty: type = dc.xfield(coerce=check.of_isinstance(type))
 
-    def provided_ty(self) -> type:
-        return self.ty
 
-
-def ctor(ty: type) -> Provider:
-    check.isinstance(ty, type)
-    return CtorProvider(ty)
-
-
-##
-
-
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class ConstProvider(Provider):
     v: ta.Any
-    ty: rfl.Type | None = None
-
-    def provided_ty(self) -> rfl.Type | None:
-        return self.ty
-
 
-def const(v: ta.Any, ty: rfl.Type | None = _Missing) -> Provider:
-    if ty is _Missing:
-        ty = type(v)
-    return ConstProvider(v, ty)
 
-
-##
-
-
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class LinkProvider(Provider):
-    k: Key
-
-    def provided_ty(self) -> rfl.Type | None:
-        return None
-
-
-def link(k: ta.Any) -> Provider:
-    return LinkProvider(as_key(k))
+    k: Key = dc.xfield(coerce=check.of_isinstance(Key))

omlish/inject/scopes.py

@@ -7,7 +7,6 @@ from .. import dataclasses as dc
 from .. import lang
 from .. import reflect as rfl
 from .bindings import Binding
-from .bindings import as_binding
 from .elements import Element
 from .keys import Key
 from .keys import as_key
@@ -24,6 +23,9 @@ else:
 ##
 
 
+SCOPE_ALIASES: dict[str, Scope] = {}
+
+
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class ScopeBinding(Element, lang.Final):
@@ -34,22 +36,26 @@ def bind_scope(sc: Scope) -> Element:
     return ScopeBinding(sc)
 
 
-def in_(b: ta.Any, sc: Scope) -> 'Binding':
-    return dc.replace(as_binding(b), scope=check.isinstance(sc, Scope))
+##
 
 
 class Singleton(Scope, lang.Singleton, lang.Final):
     pass
 
 
-def singleton(b: ta.Any) -> 'Binding':
-    return in_(b, Singleton())
+SCOPE_ALIASES['singleton'] = Singleton()
+
+
+##
 
 
 class Thread(Scope, lang.Singleton, lang.Final):
     pass
 
 
+SCOPE_ALIASES['thread'] = Thread()
+
+
 ##
 
 
@@ -64,7 +70,8 @@ class SeededScope(Scope, lang.Final):
             raise NotImplementedError
 
 
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class ScopeSeededProvider(Provider):
     ss: SeededScope = dc.xfield(coerce=check.of_isinstance(SeededScope))
     key: Key = dc.xfield(coerce=check.of_isinstance(Key))

omlish/inject/types.py

@@ -1,7 +1,9 @@
+import collections
+
 from .. import lang
 
 
-##
+Tag = collections.namedtuple('Tag', 'tag')  # noqa
 
 
 class Scope(lang.Abstract):

omlish/inject/utils.py

@@ -0,0 +1,18 @@
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+from .impl.origins import HasOriginsImpl
+
+
+T = ta.TypeVar('T')
+
+
+@dc.dataclass(frozen=True, eq=False)
+class ConstFn(HasOriginsImpl, lang.Final, ta.Generic[T]):
+    """An origin tracking provider function for a constant value. Equivalent to `lambda: v` but transparent."""
+
+    v: T
+
+    def __call__(self) -> T:
+        return self.v