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

omlish/inject/impl/inspect.py

@@ -5,24 +5,29 @@ TODO:
  - tag decorator - @inj.tag(x='foo')
  - *unpack optional here*
 """
+import dataclasses as dc
 import inspect
 import types
 import typing as ta
 import weakref
 
 from ... import reflect as rfl
-from ..exceptions import DuplicateKeyError
+from ..exceptions import ConflictingKeyError
 from ..inspect import Kwarg
 from ..inspect import KwargsTarget
 from ..keys import Key
 from ..keys import as_key
-from ..keys import tag
+from ..types import Tag
 
 
+T = ta.TypeVar('T')
 P = ta.ParamSpec('P')
 R = ta.TypeVar('R')
 
 
+##
+
+
 _signature_cache: ta.MutableMapping[ta.Any, inspect.Signature] = weakref.WeakKeyDictionary()
 
 
@@ -38,9 +43,20 @@ def signature(obj: ta.Any) -> inspect.Signature:
     return sig
 
 
+##
+
+
 _tags: ta.MutableMapping[ta.Any, dict[str, ta.Any]] = weakref.WeakKeyDictionary()
 
 
+def tag(obj: T, **kwargs: ta.Any) -> T:
+    for v in kwargs.values():
+        if isinstance(v, Tag):
+            raise TypeError(v)
+    _tags.setdefault(obj, {}).update(**kwargs)
+    return obj
+
+
 def tags(**kwargs: ta.Any) -> ta.Callable[[ta.Callable[P, R]], ta.Callable[P, R]]:
     def inner(obj):
         _tags[obj] = kwargs
@@ -48,6 +64,9 @@ def tags(**kwargs: ta.Any) -> ta.Callable[[ta.Callable[P, R]], ta.Callable[P, R]
     return inner
 
 
+##
+
+
 def build_kwargs_target(
         obj: ta.Any,
         *,
@@ -78,12 +97,21 @@ def build_kwargs_target(
         ):
             [ann] = [a for a in rf.args if a is not types.NoneType]
 
-        k = as_key(ann)
+        rty = rfl.type_(ann)
+
+        tag = None
+        if isinstance(rty, rfl.Annotated):
+            for e in rty.md:
+                if isinstance(e, Tag):
+                    tag = e.tag
+                    break
+
+        k: Key = Key(rfl.strip_annotations(rty), tag=tag)
         if tags is not None and (pt := tags.get(p.name)) is not None:
-            k = tag(k, pt)
+            k = dc.replace(k, tag=pt)
 
         if k in seen:
-            raise DuplicateKeyError(k)
+            raise ConflictingKeyError(k)
         seen.add(k)
 
         kws.append(Kwarg(

omlish/inject/impl/origins.py

@@ -0,0 +1,75 @@
+import sys
+import types
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+from ..origins import HasOrigins
+from ..origins import Origin
+from ..origins import Origins
+
+
+HasOriginsT = ta.TypeVar('HasOriginsT', bound=HasOrigins)
+
+
+##
+
+
+ORIGIN_NUM_FRAMES = 8
+ORIGIN_BASE_OFS = 2
+
+ORIGIN_IGNORED_PACKAGES = frozenset([
+    __package__,
+    __package__.rpartition('.')[0],
+
+    lang.__name__,
+    lang.functions.__name__,
+
+    dc.__name__,
+    dc.impl.__name__,  # noqa
+])
+
+
+def is_origin_frame(f: types.FrameType) -> bool:
+    gl = f.f_globals
+    try:
+        pkg = gl['__package__']
+    except KeyError:
+        pass
+    else:
+        if pkg in ORIGIN_IGNORED_PACKAGES:
+            return False
+    return True
+
+
+def build_origin(ofs: int = 0) -> Origin:
+    lst = []  # type: ignore
+    cur = sys._getframe(ORIGIN_BASE_OFS + ofs)  # noqa
+    while len(lst) < ORIGIN_NUM_FRAMES and cur is not None:
+        if is_origin_frame(cur):
+            lst.append(cur)
+        cur = cur.f_back  # type: ignore
+    return Origin(tuple(str(f) for f in lst))
+
+
+##
+
+
+ORIGINS_ATTR = '__inject_origins__'
+
+
+def set_origins(obj: HasOriginsT, origins: Origins) -> HasOriginsT:
+    obj.__dict__[ORIGINS_ATTR] = origins
+    return obj
+
+
+class HasOriginsImpl(HasOrigins):
+    @property
+    def origins(self) -> Origins:
+        return self.__dict__[ORIGINS_ATTR]
+
+    def __post_init__(self) -> None:
+        dc.maybe_post_init(super())
+        if ORIGINS_ATTR in self.__dict__:
+            raise AttributeError('Origin already set')
+        set_origins(self, Origins((build_origin(),)))

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

@@ -14,8 +14,8 @@ from ..eagers import Eager
 from ..elements import Element
 from ..injector import Injector
 from ..keys import Key
-from ..private import Expose
-from ..private import Private
+from ..privates import Expose
+from ..privates import Private
 from ..providers import Provider
 from ..scopes import Singleton
 from .elements import ElementCollection

omlish/inject/impl/scopes.py

@@ -1,3 +1,7 @@
+"""
+TODO:
+ - ContextVar ('context')
+"""
 import abc
 import contextlib
 import threading
@@ -13,8 +17,8 @@ from ..exceptions import ScopeAlreadyOpenError
 from ..exceptions import ScopeNotOpenError
 from ..injector import Injector
 from ..keys import Key
+from ..providers import FnProvider
 from ..providers import Provider
-from ..providers import fn
 from ..scopes import ScopeSeededProvider
 from ..scopes import SeededScope
 from ..scopes import Singleton
@@ -162,7 +166,7 @@ class SeededScopeImpl(ScopeImpl):
         return as_elements(
             Binding(
                 Key(SeededScope.Manager, tag=self._ss),
-                fn(lang.typed_partial(SeededScopeImpl.Manager, ss=self._ss)),
+                FnProvider(lang.typed_partial(SeededScopeImpl.Manager, ss=self._ss)),
                 scope=Singleton(),
             ),
         )

omlish/inject/injector.py

@@ -2,12 +2,16 @@ import abc
 import typing as ta
 
 from .. import lang
-from .elements import Elements
+from .elements import Elemental
+from .elements import as_elements
 from .inspect import KwargsTarget
 from .keys import Key
 
 
-_impl = lang.proxy_import('.impl.injector', __package__)
+if ta.TYPE_CHECKING:
+    from .impl import injector as _injector
+else:
+    _injector = lang.proxy_import('.impl.injector', __package__)
 
 
 T = ta.TypeVar('T')
@@ -37,5 +41,5 @@ class Injector(lang.Abstract):
         return self.provide(target)
 
 
-def create_injector(es: Elements) -> Injector:
-    return _impl.create_injector(es)
+def create_injector(*args: Elemental) -> Injector:
+    return _injector.create_injector(as_elements(*args))

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,27 @@
+import abc
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+
+
+@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))