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

omlish/inject/__init__.py

@@ -1,26 +1,30 @@
 """
 ~> https://github.com/google/guice/commit/70248eafa90cd70a68b293763e53f6aec656e73c
 """
+from .binder import (  # noqa
+    bind,
+    bind_as_fn,
+)
+
 from .bindings import (  # noqa
     Binding,
-    as_,
-    as_binding,
 )
 
 from .eagers import (  # noqa
-    eager,
+    Eager,
 )
 
 from .elements import (  # noqa
-    as_elements,
     Element,
+    Elemental,
     Elements,
+    as_elements,
 )
 
 from .exceptions import (  # noqa
     BaseKeyError,
+    ConflictingKeyError,
     CyclicDependencyError,
-    DuplicateKeyError,
     ScopeAlreadyOpenError,
     ScopeError,
     ScopeNotOpenError,
@@ -35,57 +39,81 @@ from .injector import (  # noqa
 from .inspect import (  # noqa
     Kwarg,
     KwargsTarget,
+    build_kwargs_target,
+    tag,
 )
 
 from .keys import (  # noqa
     Key,
     as_key,
-    tag,
+)
+
+from .listeners import (  # noqa
+    ProvisionListener,
+    ProvisionListenerBinding,
+    bind_provision_listener,
 )
 
 from .managed import (  # noqa
+    create_async_managed_injector,
     create_managed_injector,
+    make_async_managed_provider,
+    make_managed_provider,
 )
 
 from .multis import (  # noqa
     MapBinding,
+    MapProvider,
     SetBinding,
-    bind_map_provider,
-    bind_set_provider,
+    SetProvider,
+    MapBinder,
+    SetBinder,
+
+    MapBinder as map_binder,  # noqa
+    SetBinder as set_binder,  # noqa
 )
 
 
 from .overrides import (  # noqa
+    Overrides,
     override,
 )
 
-from .private import (  # noqa
-    expose,
+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,
-    as_provider,
-    const,
-    ctor,
-    fn,
-    link,
 )
 
 from .scopes import (  # noqa
     ScopeBinding,
+    ScopeSeededProvider,
     SeededScope,
     Singleton,
     Thread,
     bind_scope,
     bind_scope_seed,
     enter_seeded_scope,
-    in_,
-    singleton,
 )
 
 from .types import (  # noqa
     Scope,
+    Tag,
     Unscoped,
 )

omlish/inject/binder.py

@@ -1,12 +1,192 @@
+"""
+TODO:
+ - multis?
+
+class SetBinding(Element, lang.Final):
+class SetProvider(Provider):
+
+class MapBinding(Element, lang.Final):
+class MapProvider(Provider):
+"""
+import functools
+import inspect
+import types
 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 .eagers import Eager
 from .elements import Element
 from .elements import Elements
-from .elements import as_elements
+from .keys import Key
+from .keys import as_key
+from .privates import Expose
+from .providers import ConstProvider
+from .providers import CtorProvider
+from .providers import FnProvider
+from .providers import LinkProvider
+from .providers import Provider
+from .scopes import SCOPE_ALIASES
+from .scopes import Singleton
+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__)
+
+
+T = ta.TypeVar('T')
+
+
+##
+
+
+_FN_TYPES: tuple[type, ...] = (
+    types.FunctionType,
+    types.MethodType,
+
+    classmethod,
+    staticmethod,
+
+    functools.partial,
+    functools.partialmethod,
+)
+
+
+def _is_fn(obj: ta.Any) -> bool:
+    return isinstance(obj, _FN_TYPES)
+
+
+def bind_as_fn(cls: type[T]) -> type[T]:
+    check.isinstance(cls, type)
+    global _FN_TYPES
+    if cls not in _FN_TYPES:
+        _FN_TYPES = (*_FN_TYPES, cls)
+    return cls
+
+
+##
+
+
+_BANNED_BIND_TYPES = (
+    Element,
+    Provider,
+    Elements,
+    Scope,
+)
+
+
+def bind(
+        obj: ta.Any,
+        *,
+        tag: ta.Any = None,
+
+        in_: Scope | None = None,
+        singleton: bool = False,
+
+        to_fn: ta.Any = None,
+        to_ctor: ta.Any = None,
+        to_const: ta.Any = None,
+        to_key: ta.Any = None,
+
+        eager: bool = False,
+        expose: bool = False,
+) -> Element | Elements:
+    if obj is None or obj is inspect.Parameter.empty:
+        raise TypeError(obj)
+    if isinstance(obj, _BANNED_BIND_TYPES):
+        raise TypeError(obj)
+
+    ##
+
+    has_to = (
+        to_fn is not None or
+        to_ctor is not None or
+        to_const is not None or
+        to_key is not None
+    )
+    if isinstance(obj, Key):
+        key = obj
+    elif isinstance(obj, type):
+        if not has_to:
+            to_ctor = obj
+        key = Key(obj)
+    elif isinstance(obj, rfl.TYPES) or rfl.is_type(obj):
+        key = Key(obj)
+    elif _is_fn(obj) and not has_to:
+        sig = _inspect.signature(obj)
+        ty = rfl.type_(sig.return_annotation)
+        to_fn = obj
+        key = Key(ty)
+    else:
+        if to_const is not None:
+            raise TypeError('Cannot bind instance with to_const')
+        to_const = obj
+        key = Key(type(obj))
+    del has_to
+
+    ##
+
+    if tag is not None:
+        if key.tag is not None:
+            raise TypeError('Tag already set')
+        key = dc.replace(key, tag=tag)
+
+    ##
+
+    providers: list[Provider] = []
+    if to_fn is not None:
+        providers.append(FnProvider(to_fn))
+    if to_ctor is not None:
+        providers.append(CtorProvider(to_ctor))
+    if to_const is not None:
+        providers.append(ConstProvider(to_const))
+    if to_key is not None:
+        providers.append(LinkProvider(as_key(to_key)))
+    if not providers:
+        raise TypeError('Must specify provider')
+    if len(providers) > 1:
+        raise TypeError('May not specify multiple providers')
+    provider, = providers
+
+    ##
+
+    scopes: list[Scope] = []
+    if in_ is not None:
+        if isinstance(in_, str):
+            scopes.append(SCOPE_ALIASES[in_])
+        else:
+            scopes.append(check.isinstance(in_, Scope))
+    if singleton:
+        scopes.append(Singleton())
+    if len(scopes) > 1:
+        raise TypeError('May not specify multiple scopes')
+    scope: Scope
+    if not scopes:
+        scope = Unscoped()
+    else:
+        scope, = scopes
+
+    ##
+
+    binding = Binding(key, provider, scope)
+
+    ##
 
+    elements: list[Element] = [binding]
 
-def bind(*args: ta.Any) -> Elements:
-    if all(isinstance(a, (Element, Elements)) for a in args):
-        return as_elements(*args)
+    if eager:
+        elements.append(Eager(key))
+    if expose:
+        elements.append(Expose(key))
 
-    raise TypeError(args)
+    if len(elements) == 1:
+        return elements[0]
+    else:
+        return Elements(frozenset(elements))

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):
+class Element(HasOriginsImpl, lang.Abstract, lang.PackageSealed):
     pass
 
 
+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

@@ -12,6 +12,8 @@ TODO:
  - multiple live request scopes on single injector - use private injectors?
 """
 import contextlib
+import functools
+import itertools
 import typing as ta
 import weakref
 
@@ -24,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
@@ -55,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
@@ -70,6 +81,7 @@ class InjectorImpl(Injector, lang.Final):
         }
 
         self._instantiate_eagers(Unscoped())
+        self._instantiate_eagers(Singleton())
 
     _root: 'InjectorImpl'
 
@@ -109,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:
@@ -142,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)