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

omlish/inject/impl/elements.py

@@ -10,12 +10,16 @@ Multi's + Scopes:
 
 Element Types:
  - Binding
+ - ProvisionListenerBinding
+ - SetBinding
+ - MapBinding
  - Eager
  - Overrides
  - Expose
  - Private
  - ScopeBinding
 """
+import copy
 import typing as ta
 
 from ... import check
@@ -25,22 +29,32 @@ from ..bindings import Binding
 from ..eagers import Eager
 from ..elements import Element
 from ..elements import Elements
-from ..exceptions import DuplicateKeyError
+from ..exceptions import ConflictingKeyError
+from ..exceptions import UnboundKeyError
 from ..keys import Key
+from ..listeners import ProvisionListenerBinding
+from ..multis import MapBinding
+from ..multis import MapProvider
+from ..multis import SetBinding
+from ..multis import SetProvider
 from ..overrides import Overrides
-from ..private import Expose
-from ..private import Private
+from ..privates import Expose
+from ..privates import Private
 from ..scopes import ScopeBinding
 from ..types import Scope
 from .bindings import BindingImpl
-from .providers import MultiProviderImpl
+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 .scopes import make_scope_impl
 
+
 if ta.TYPE_CHECKING:
-    from . import private as private_
+    from . import privates as privates_
 else:
-    private_ = lang.proxy_import('.private', __package__)
+    privates_ = lang.proxy_import('.privates', __package__)
 
 
 ElementT = ta.TypeVar('ElementT', bound=Element)
@@ -52,17 +66,17 @@ class ElementCollection(lang.Final):
 
         self._es = check.isinstance(es, Elements)
 
-        self._private_infos: ta.MutableMapping[Private, private_.PrivateInfo] | None = None
+        self._private_infos: ta.MutableMapping[Private, privates_.PrivateInfo] | None = None
 
     ##
 
-    def _get_private_info(self, p: Private) -> 'private_.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 = private_.PrivateInfo(self, p)
+            pis[p] = ec = privates_.PrivateInfo(self, p)
             return ec
 
     ##
@@ -92,10 +106,16 @@ class ElementCollection(lang.Final):
                 pi = self._get_private_info(e)
                 self._build_raw_element_multimap(pi.owner_elements(), out)
 
+            elif isinstance(e, (SetBinding, MapBinding)):
+                add(e.multi_key, e)
+
+            elif isinstance(e, ProvisionListenerBinding):
+                add(None, e)
+
             elif isinstance(e, Overrides):
                 ovr = self._build_raw_element_multimap(e.ovr)
                 src = self._build_raw_element_multimap(e.src)
-                for k, b in src.items():
+                for k, b in src.items():  # FIXME: merge None keys?
                     try:
                         bs = ovr[k]
                     except KeyError:
@@ -117,36 +137,50 @@ class ElementCollection(lang.Final):
 
     ##
 
-    def _make_binding_impls(self, e: Element) -> ta.Iterable[BindingImpl]:
-        if isinstance(e, Binding):
-            p = make_provider_impl(e.provider)
-            return (BindingImpl(e.key, p, e.scope, e),)
-
-        elif isinstance(e, (Eager, Expose)):
-            return ()
+    def _get_single_binding(self, k: Key, bs: ta.Sequence[Binding]) -> Binding:
+        if not bs:
+            raise UnboundKeyError(k)
+
+        elif len(bs) > 1:
+            d: dict = {}
+            for b in bs:
+                d.setdefault(b, []).append(b)
+            if len(d) > 1:
+                raise ConflictingKeyError(k)
+            l = check.single(d.values())
+            b = copy.copy(l[0])
+            set_origins(b, Origins(tuple(o for c in l for o in c.origins)))
+            return b
 
         else:
-            raise TypeError(e)
+            return check.isinstance(check.single(bs), Binding)
 
     def _build_binding_impl_map(self, em: ta.Mapping[Key | None, ta.Sequence[Element]]) -> dict[Key, BindingImpl]:
         pm: dict[Key, BindingImpl] = {}
-        mm: dict[Key, list[BindingImpl]] = {}
         for k, es in em.items():
             if k is None:
                 continue
 
-            bis = [bi for e in es for bi in self._make_binding_impls(e)]
-            if k.multi:
-                mm.setdefault(k, []).extend(bis)
-            else:
-                if len(bis) > 1:
-                    raise DuplicateKeyError(k)
-                [pm[k]] = bis
-
-        if mm:
-            for k, aps in mm.items():
-                mp = MultiProviderImpl([ap.provider for ap in aps])
-                pm[k] = BindingImpl(k, mp)  # FIXME: SCOPING
+            es_by_ty = col.multi_map_by(type, es)
+
+            es_by_ty.pop(Eager, None)
+            es_by_ty.pop(Expose, None)
+            es_by_ty.pop(ProvisionListenerBinding, None)
+
+            if (bs := es_by_ty.pop(Binding, None)):
+                b = self._get_single_binding(k, bs)  # type: ignore
+
+                p: ProviderImpl
+                if isinstance(b.provider, (SetProvider, MapProvider)):
+                    p = make_multi_provider_impl(b.provider, es_by_ty)
+
+                else:
+                    p = make_provider_impl(b.provider)
+
+                pm[k] = BindingImpl(b.key, p, b.scope, b)
+
+            if es_by_ty:
+                raise TypeError(set(es_by_ty))
 
         return pm
 

omlish/inject/impl/injector.py

@@ -9,8 +9,11 @@ TODO:
  - ** eagers in any scope, on scope init/open
  - injection listeners
  - unions - raise on ambiguous - usecase: sql.AsyncEngineLike
+ - multiple live request scopes on single injector - use private injectors?
 """
 import contextlib
+import functools
+import itertools
 import typing as ta
 import weakref
 
@@ -23,6 +26,8 @@ from ..injector import Injector
 from ..inspect import KwargsTarget
 from ..keys import Key
 from ..keys import as_key
+from ..listeners import ProvisionListener
+from ..listeners import ProvisionListenerBinding
 from ..scopes import ScopeBinding
 from ..scopes import Singleton
 from ..scopes import Thread
@@ -54,6 +59,13 @@ class InjectorImpl(Injector, lang.Final):
 
         self._bim = ec.binding_impl_map()
         self._ekbs = ec.eager_keys_by_scope()
+        self._pls: tuple[ProvisionListener, ...] = tuple(
+            b.listener
+            for b in itertools.chain(
+                ec.elements_of_type(ProvisionListenerBinding),
+                (p._pls if p is not None else ()),  # noqa
+            )
+        )
 
         self._cs: weakref.WeakSet[InjectorImpl] | None = None
         self._root: InjectorImpl = p._root if p is not None else self  # noqa
@@ -69,6 +81,7 @@ class InjectorImpl(Injector, lang.Final):
         }
 
         self._instantiate_eagers(Unscoped())
+        self._instantiate_eagers(Singleton())
 
     _root: 'InjectorImpl'
 
@@ -108,7 +121,7 @@ class InjectorImpl(Injector, lang.Final):
             check.not_in(key, self._provisions)
             self._provisions[key] = v
 
-        def __enter__(self: ta.Self) -> ta.Self:
+        def __enter__(self) -> ta.Self:
             return self
 
         def __exit__(self, *exc) -> None:
@@ -141,7 +154,12 @@ class InjectorImpl(Injector, lang.Final):
             bi = self._bim.get(key)
             if bi is not None:
                 sc = self._scopes[bi.scope]
-                v = sc.provide(bi, self)
+
+                fn = lambda: sc.provide(bi, self)  # noqa
+                for pl in self._pls:
+                    fn = functools.partial(pl, self, key, bi.binding, fn)
+                v = fn()
+
                 cr.handle_provision(key, v)
                 return lang.just(v)
 

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/multis.py

@@ -0,0 +1,74 @@
+import typing as ta
+
+from ... import dataclasses as dc
+from ... import lang
+from ..elements import Element
+from ..injector import Injector
+from ..multis import MapBinding
+from ..multis import MapProvider
+from ..multis import SetBinding
+from ..multis import SetProvider
+from ..providers import LinkProvider
+from ..providers import Provider
+from .providers import LinkProviderImpl
+from .providers import ProviderImpl
+
+
+@dc.dataclass(frozen=True, eq=False)
+class SetProviderImpl(ProviderImpl, lang.Final):
+    ps: ta.Sequence[ProviderImpl]
+
+    @property
+    def providers(self) -> ta.Iterable[Provider]:
+        for p in self.ps:
+            yield from p.providers
+
+    def provide(self, injector: Injector) -> ta.Any:
+        rv = set()
+        for ep in self.ps:
+            o = ep.provide(injector)
+            rv.add(o)
+        return rv
+
+
+@dc.dataclass(frozen=True, eq=False)
+class MapProviderImpl(ProviderImpl, lang.Final):
+    class Entry(ta.NamedTuple):
+        k: ta.Any
+        v: ProviderImpl
+
+    es: ta.Sequence[Entry]
+
+    @property
+    def providers(self) -> ta.Iterable[Provider]:
+        for e in self.es:
+            yield from e.v.providers
+
+    def provide(self, injector: Injector) -> ta.Any:
+        rv = {}
+        for e in self.es:
+            o = e.v.provide(injector)
+            rv[e.k] = o
+        return rv
+
+
+def make_multi_provider_impl(p: Provider, es_by_ty: ta.MutableMapping[type, list[Element]]) -> ProviderImpl:
+    if isinstance(p, SetProvider):
+        sbs: ta.Iterable[SetBinding] = es_by_ty.pop(SetBinding, ())  # type: ignore
+        return SetProviderImpl([
+            LinkProviderImpl(LinkProvider(sb.dst))
+            for sb in sbs
+        ])
+
+    elif isinstance(p, MapProvider):
+        mbs: ta.Iterable[MapBinding] = es_by_ty.pop(MapBinding, ())  # type: ignore
+        return MapProviderImpl([
+            MapProviderImpl.Entry(
+                mb.map_key,
+                LinkProviderImpl(LinkProvider(mb.dst)),
+            )
+            for mb in mbs
+        ])
+
+    else:
+        raise TypeError(p)

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/providers.py

@@ -5,10 +5,9 @@ TODO:
 import abc
 import typing as ta
 
-from .. import Cls
-from ... import check
 from ... import dataclasses as dc
 from ... import lang
+from ... import reflect as rfl
 from ..injector import Injector
 from ..inspect import KwargsTarget
 from ..providers import ConstProvider
@@ -19,6 +18,9 @@ from ..providers import Provider
 from .inspect import build_kwargs_target
 
 
+##
+
+
 class ProviderImpl(lang.Abstract):
     @property
     @abc.abstractmethod
@@ -30,14 +32,20 @@ class ProviderImpl(lang.Abstract):
         raise NotImplementedError
 
 
+##
+
+
 @dc.dataclass(frozen=True, eq=False)
 class InternalProvider(Provider):
     impl: ProviderImpl
 
-    def provided_cls(self) -> Cls | None:
+    def provided_ty(self) -> rfl.Type | None:
         raise TypeError
 
 
+##
+
+
 @dc.dataclass(frozen=True, eq=False)
 class CallableProviderImpl(ProviderImpl, lang.Final):
     p: FnProvider | CtorProvider
@@ -51,6 +59,9 @@ class CallableProviderImpl(ProviderImpl, lang.Final):
         return injector.inject(self.kt)
 
 
+##
+
+
 @dc.dataclass(frozen=True, eq=False)
 class ConstProviderImpl(ProviderImpl, lang.Final):
     p: ConstProvider
@@ -63,6 +74,9 @@ class ConstProviderImpl(ProviderImpl, lang.Final):
         return self.p.v
 
 
+##
+
+
 @dc.dataclass(frozen=True, eq=False)
 class LinkProviderImpl(ProviderImpl, lang.Final):
     p: LinkProvider
@@ -75,46 +89,12 @@ class LinkProviderImpl(ProviderImpl, lang.Final):
         return injector.provide(self.p.k)
 
 
-_ILLEGAL_MULTI_TYPES = (str, bytes, bytearray)
-
-
-def _unnest_multi_providers(ps: ta.Iterable[ProviderImpl]) -> ta.Sequence[ProviderImpl]:
-    lst = []
-
-    def rec(o):
-        if isinstance(o, MultiProviderImpl):
-            for c in o.ps:
-                rec(c)
-        else:
-            lst.append(check.isinstance(o, ProviderImpl))
-
-    for o in ps:
-        rec(o)
-    return tuple(lst)
-
-
-@dc.dataclass(frozen=True, eq=False)
-class MultiProviderImpl(ProviderImpl, lang.Final):
-    ps: ta.Sequence[ProviderImpl] = dc.xfield(coerce=_unnest_multi_providers)
-
-    @property
-    def providers(self) -> ta.Iterable[Provider]:
-        for p in self.ps:
-            yield from p.providers
-
-    def provide(self, injector: Injector) -> ta.Any:
-        rv = []
-        for ep in self.ps:
-            o = ep.provide(injector)
-            if isinstance(o, _ILLEGAL_MULTI_TYPES):
-                raise TypeError(o)
-            rv.extend(o)
-        return rv
+##
 
 
 PROVIDER_IMPLS_BY_PROVIDER: dict[type[Provider], ta.Callable[..., ProviderImpl]] = {
     FnProvider: lambda p: CallableProviderImpl(p, build_kwargs_target(p.fn)),
-    CtorProvider: lambda p: CallableProviderImpl(p, build_kwargs_target(p.cls)),
+    CtorProvider: lambda p: CallableProviderImpl(p, build_kwargs_target(p.ty)),
     ConstProvider: ConstProviderImpl,
     LinkProvider: LinkProviderImpl,
     InternalProvider: lambda p: p.impl,

omlish/inject/{proxy.py → impl/proxy.py}

@@ -1,7 +1,7 @@
 import typing as ta
 
-from .. import lang
-from .. import check
+from ... import check
+from ... import lang
 
 
 @lang.cached_function

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
@@ -25,6 +29,7 @@ from .bindings import BindingImpl
 from .providers import PROVIDER_IMPLS_BY_PROVIDER
 from .providers import ProviderImpl
 
+
 if ta.TYPE_CHECKING:
     from . import injector as injector_
 else:
@@ -161,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,11 +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')
@@ -36,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)