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

omlish/inject/bindings.py

@@ -1,49 +1,16 @@
-import typing as ta
-
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
 from .elements import Element
-from .elements import Elements
 from .keys import Key
-from .keys import as_key
 from .providers import Provider
-from .providers import as_provider
-from .providers import const
-from .providers import ctor
-from .providers import fn
 from .types import Scope
 from .types import Unscoped
 
 
-##
-
-
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class Binding(Element, lang.Final):
-    key: Key
-    provider: Provider
-    scope: Scope = Unscoped()
-
-
-##
-
-
-def as_binding(o: ta.Any) -> Binding:
-    check.not_none(o)
-    if isinstance(o, Binding):
-        return o
-    check.not_isinstance(o, (Element, Elements))
-    if isinstance(o, Provider):
-        return Binding(Key(check.not_none(o.provided_ty())), o)
-    if isinstance(o, type):
-        return as_binding(ctor(o))
-    if callable(o):
-        return as_binding(fn(o))
-    ty = type(o)
-    return Binding(Key(ty), const(o, ty))
-
-
-def as_(k: ta.Any, p: ta.Any) -> Binding:
-    return Binding(as_key(k), as_provider(p))
+    key: Key = dc.xfield(coerce=check.of_isinstance(Key))
+    provider: Provider = dc.xfield(coerce=check.of_isinstance(Provider))
+    scope: Scope = dc.xfield(default=Unscoped(), coerce=check.of_isinstance(Scope))

omlish/inject/eagers.py

@@ -2,20 +2,14 @@
 TODO:
  - SCOPED - eagers for EACH SCOPE
 """
-import typing as ta
-
+from .. import check
 from .. import dataclasses as dc
 from .. import lang
 from .elements import Element
 from .keys import Key
-from .keys import as_key
 
 
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class Eager(Element, lang.Final):
-    key: Key
-
-
-def eager(k: ta.Any) -> Element:
-    return Eager(as_key(k))
+    key: Key = dc.xfield(coerce=check.of_isinstance(Key))

omlish/inject/elements.py

@@ -1,21 +1,26 @@
-"""
-TODO:
- - as_element[s] - universal
-"""
+import abc
 import typing as ta
 
+from .. import check
 from .. import dataclasses as dc
 from .. import lang
+from .impl.origins import HasOriginsImpl
 
 
-class Element(lang.Abstract):
-    pass
+class Element(HasOriginsImpl, lang.Abstract, lang.PackageSealed):
+    """Note: inheritors must be dataclasses."""
+
+
+class ElementGenerator(lang.Abstract, lang.PackageSealed):
+    @abc.abstractmethod
+    def __iter__(self) -> ta.Iterator[Element]:
+        raise NotImplementedError
 
 
 @dc.dataclass(frozen=True)
 class Elements(lang.Final):
-    es: frozenset[Element] | None = None
-    cs: frozenset['Elements'] | None = None
+    es: frozenset[Element] | None = dc.xfield(None, coerce=check.of_isinstance((frozenset, None)))
+    cs: frozenset['Elements'] | None = dc.xfield(None, coerce=check.of_isinstance((frozenset, None)))
 
     def __iter__(self) -> ta.Generator[Element, None, None]:
         if self.es:
@@ -25,18 +30,34 @@ class Elements(lang.Final):
                 yield from c
 
 
-def as_elements(*args: Element | Elements) -> Elements:
+Elemental = ta.Union[  # noqa
+    Element,
+    Elements,
+    ElementGenerator,
+]
+
+
+def as_elements(*args: Elemental) -> Elements:
     es: set[Element] = set()
     cs: set[Elements] = set()
-    for a in args:
+
+    def rec(a):
         if isinstance(a, Element):
             es.add(a)
         elif isinstance(a, Elements):
             cs.add(a)
+        elif isinstance(a, ElementGenerator):
+            for n in a:
+                rec(n)
         else:
             raise TypeError(a)
+
+    for a in args:
+        rec(a)
+
     if not es and len(cs) == 1:
         return next(iter(cs))
+
     return Elements(
         frozenset(es) if es else None,
         frozenset(cs) if cs else None,

omlish/inject/exceptions.py

@@ -22,7 +22,7 @@ class UnboundKeyError(BaseKeyError):
 
 
 @dc.dataclass()
-class DuplicateKeyError(BaseKeyError):
+class ConflictingKeyError(BaseKeyError):
     pass
 
 

omlish/inject/impl/elements.py

@@ -10,6 +10,7 @@ Multi's + Scopes:
 
 Element Types:
  - Binding
+ - ProvisionListenerBinding
  - SetBinding
  - MapBinding
  - Eager
@@ -18,6 +19,7 @@ Element Types:
  - Private
  - ScopeBinding
 """
+import copy
 import typing as ta
 
 from ... import check
@@ -27,28 +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 .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)
@@ -60,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
 
     ##
@@ -103,6 +109,9 @@ class ElementCollection(lang.Final):
             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)
@@ -128,6 +137,24 @@ class ElementCollection(lang.Final):
 
     ##
 
+    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:
+            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] = {}
         for k, es in em.items():
@@ -138,14 +165,12 @@ class ElementCollection(lang.Final):
 
             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)):
-                if len(bs) > 1:
-                    raise DuplicateKeyError(k)
+                b = self._get_single_binding(k, bs)  # type: ignore
 
-                b: Binding = check.isinstance(check.single(bs), Binding)
                 p: ProviderImpl
-
                 if isinstance(b.provider, (SetProvider, MapProvider)):
                     p = make_multi_provider_impl(b.provider, es_by_ty)
 

omlish/inject/impl/injector.py

@@ -1,5 +1,7 @@
 """
 TODO:
+ - ** can currently bind in a child/private scope shadowing an external parent binding **
+ - better source tracking
  - cache/export ElementCollections lol
  - scope bindings, auto in root
  - injector-internal / blacklisted bindings (Injector itself, default scopes) without rebuilding ElementCollection
@@ -12,6 +14,9 @@ TODO:
  - multiple live request scopes on single injector - use private injectors?
 """
 import contextlib
+import functools
+import itertools
+import logging
 import typing as ta
 import weakref
 
@@ -24,6 +29,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
@@ -35,6 +42,9 @@ from .scopes import ScopeImpl
 from .scopes import make_scope_impl
 
 
+log = logging.getLogger(__name__)
+
+
 DEFAULT_SCOPES: list[Scope] = [
     Unscoped(),
     Singleton(),
@@ -55,6 +65,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
@@ -70,6 +87,7 @@ class InjectorImpl(Injector, lang.Final):
         }
 
         self._instantiate_eagers(Unscoped())
+        self._instantiate_eagers(Singleton())
 
     _root: 'InjectorImpl'
 
@@ -91,10 +109,11 @@ class InjectorImpl(Injector, lang.Final):
         def __init__(self, injector: 'InjectorImpl') -> None:
             super().__init__()
             self._injector = injector
-            self._provisions: dict[Key, ta.Any] = {}
+            self._provisions: dict[Key, lang.Maybe] = {}
             self._seen_keys: set[Key] = set()
+            self._source_stack: list[ta.Any] = []
 
-        def handle_key(self, key: Key) -> lang.Maybe:
+        def handle_key(self, key: Key) -> lang.Maybe[lang.Maybe]:
             try:
                 return lang.just(self._provisions[key])
             except KeyError:
@@ -104,12 +123,23 @@ class InjectorImpl(Injector, lang.Final):
             self._seen_keys.add(key)
             return lang.empty()
 
-        def handle_provision(self, key: Key, v: ta.Any) -> None:
+        def handle_provision(self, key: Key, mv: lang.Maybe) -> lang.Maybe:
             check.in_(key, self._seen_keys)
             check.not_in(key, self._provisions)
-            self._provisions[key] = v
+            self._provisions[key] = mv
+            return mv
+
+        @contextlib.contextmanager
+        def push_source(self, source: ta.Any) -> ta.Iterator[None]:
+            self._source_stack.append(source)
+            try:
+                yield
+            finally:
+                nsource = self._source_stack.pop()
+                if source is not nsource:
+                    raise Exception(f'Stack error: {source=} is not {nsource=}')
 
-        def __enter__(self: ta.Self) -> ta.Self:
+        def __enter__(self) -> ta.Self:
             return self
 
         def __exit__(self, *exc) -> None:
@@ -128,33 +158,50 @@ class InjectorImpl(Injector, lang.Final):
             finally:
                 self.__cur_req = None
 
-    def try_provide(self, key: ta.Any) -> lang.Maybe[ta.Any]:
+    def _try_provide(self, key: ta.Any, *, source: ta.Any = None) -> lang.Maybe[ta.Any]:
         key = as_key(key)
 
+        cr: InjectorImpl._Request
         with self._current_request() as cr:
-            ic = self._internal_consts.get(key)
-            if ic is not None:
-                return lang.just(ic)
+            with cr.push_source(source):
+                if (rv := cr.handle_key(key)).present:
+                    return rv.must()
 
-            if (rv := cr.handle_key(key)).present:
-                return rv
+                ic = self._internal_consts.get(key)
+                if ic is not None:
+                    return cr.handle_provision(key, lang.just(ic))
 
-            bi = self._bim.get(key)
-            if bi is not None:
-                sc = self._scopes[bi.scope]
-                v = sc.provide(bi, self)
-                cr.handle_provision(key, v)
-                return lang.just(v)
+                bi = self._bim.get(key)
+                if bi is not None:
+                    sc = self._scopes[bi.scope]
 
-            if self._p is not None:
-                pv = self._p.try_provide(key)
-                if pv is not None:
-                    return pv
+                    fn = lambda: sc.provide(bi, self)  # noqa
+                    for pl in self._pls:
+                        fn = functools.partial(pl, self, key, bi.binding, fn)
+                    v = fn()
 
-            return lang.empty()
+                    return cr.handle_provision(key, lang.just(v))
+
+                if self._p is not None:
+                    pv = 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)
+        if v.present:
+            return v.must()
+        raise UnboundKeyError(key)
+
+    #
+
+    def try_provide(self, key: ta.Any) -> lang.Maybe[ta.Any]:
+        return self.try_provide(key)
 
     def provide(self, key: ta.Any) -> ta.Any:
-        v = self.try_provide(key)
+        v = self._try_provide(key)
         if v.present:
             return v.must()
         raise UnboundKeyError(key)
@@ -163,11 +210,11 @@ class InjectorImpl(Injector, lang.Final):
         ret: dict[str, ta.Any] = {}
         for kw in kt.kwargs:
             if kw.has_default:
-                if not (mv := self.try_provide(kw.key)).present:
+                if not (mv := self._try_provide(kw.key, source=kt)).present:
                     continue
                 v = mv.must()
             else:
-                v = self.provide(kw.key)
+                v = self._provide(kw.key, source=kt)
             ret[kw.name] = v
         return ret
 

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,77 @@
+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):
+    """Note: inheritors must be dataclasses."""
+
+    @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))