omlish 0.0.0.dev447__py3-none-any.whl → 0.0.0.dev484__py3-none-any.whl

omlish/inject/binder.py

@@ -11,13 +11,8 @@ 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 .multis import MapBinding
-from .multis import SetBinding
-from .multis import is_map_multi_key
-from .multis import is_set_multi_key
 from .privates import Expose
 from .providers import AsyncFnProvider
 from .providers import ConstProvider
@@ -27,7 +22,6 @@ from .providers import LinkProvider
 from .providers import Provider
 from .scopes import SCOPE_ALIASES
 from .scopes import Singleton
-from .tags import Id
 from .types import Scope
 from .types import Unscoped
 
@@ -84,6 +78,7 @@ def bind(
         *,
         tag: ta.Any = None,
 
+        to_provider: Provider | None = None,
         to_async_fn: ta.Any = None,
         to_fn: ta.Any = None,
         to_ctor: ta.Any = None,
@@ -104,6 +99,7 @@ def bind(
     ##
 
     has_to = (
+        to_provider is not None or
         to_async_fn is not None or
         to_fn is not None or
         to_ctor is not None or
@@ -140,6 +136,8 @@ def bind(
     ##
 
     providers: list[Provider] = []
+    if to_provider is not None:
+        providers.append(to_provider)
     if to_async_fn is not None:
         providers.append(AsyncFnProvider(to_async_fn))
     if to_fn is not None:
@@ -191,45 +189,3 @@ def bind(
         return elements[0]
     else:
         return Elements(frozenset(elements))
-
-
-##
-
-
-def bind_set_entry_const(
-        multi_key: ta.Any,
-        obj: ta.Any,
-        *,
-        tag: ta.Any | None = None,
-) -> Elements:
-    multi_key = as_key(multi_key)
-    check.arg(is_set_multi_key(multi_key))
-
-    if tag is None:
-        tag = Id(id(obj), tag=multi_key.tag)
-    obj_key: Key = Key(type(obj), tag=tag)
-
-    return as_elements(
-        bind(obj_key, to_const=obj),
-        SetBinding(multi_key, obj_key),
-    )
-
-
-def bind_map_entry_const(
-        multi_key: ta.Any,
-        map_key: ta.Any,
-        obj: ta.Any,
-        *,
-        tag: ta.Any | None = None,
-) -> Elements:
-    multi_key = as_key(multi_key)
-    check.arg(is_map_multi_key(multi_key))
-
-    if tag is None:
-        tag = Id(id(obj), tag=multi_key.tag)
-    obj_key: Key = Key(type(obj), tag=tag)
-
-    return as_elements(
-        bind(obj_key, to_const=obj),
-        MapBinding(multi_key, map_key, obj_key),
-    )

omlish/inject/elements.py

@@ -6,6 +6,12 @@ from .. import lang
 from .impl.origins import HasOriginsImpl
 
 
+if ta.TYPE_CHECKING:
+    from .impl import elements as _elements
+else:
+    _elements = lang.proxy_import('.impl.elements', __package__)
+
+
 ##
 
 
@@ -64,3 +70,24 @@ def as_elements(*args: Elemental) -> Elements:
         es if es else None,
         cs if cs else None,
     )
+
+
+def iter_elements(*args: Elemental) -> ta.Iterator[Element]:
+    for a in args:
+        if isinstance(a, Element):
+            yield a
+        elif isinstance(a, (Elements, ElementGenerator)):
+            yield from a
+        else:
+            raise TypeError(a)
+
+
+##
+
+
+class CollectedElements(lang.PackageSealed, lang.Abstract):
+    pass
+
+
+def collect_elements(es: Elements | CollectedElements) -> CollectedElements:
+    return _elements.collect_elements(es)

omlish/inject/{utils.py → helpers/constfn.py}

@@ -1,8 +1,8 @@
 import typing as ta
 
-from .. import dataclasses as dc
-from .. import lang
-from .impl.origins import HasOriginsImpl
+from ... import dataclasses as dc
+from ... import lang
+from ..impl.origins import HasOriginsImpl
 
 
 T = ta.TypeVar('T')

omlish/inject/{tags.py → helpers/id.py}

@@ -1,7 +1,7 @@
 import typing as ta
 
-from .. import dataclasses as dc
-from .types import Tag
+from ... import dataclasses as dc
+from ..types import Tag
 
 
 ##

omlish/inject/helpers/multis.py

@@ -0,0 +1,143 @@
+import typing as ta
+
+from ... import cached
+from ... import check
+from ... import dataclasses as dc
+from ... import lang
+from ... import reflect as rfl
+from ..binder import bind
+from ..elements import Elements
+from ..elements import as_elements
+from ..inspect import KwargsTarget
+from ..keys import Key
+from ..keys import as_key
+from ..multis import MapBinding
+from ..multis import SetBinder
+from ..multis import SetBinding
+from ..multis import is_map_multi_key
+from ..multis import is_set_multi_key
+from ..providers import FnProvider
+from .id import Id
+
+
+ItemT = ta.TypeVar('ItemT')
+
+
+##
+
+
+def bind_set_entry_const(
+        multi_key: ta.Any,
+        obj: ta.Any,
+        *,
+        tag: ta.Any | None = None,
+) -> Elements:
+    multi_key = as_key(multi_key)
+    check.arg(is_set_multi_key(multi_key))
+
+    if tag is None:
+        tag = Id(id(obj), tag=multi_key.tag)
+    obj_key: Key = Key(type(obj), tag=tag)
+
+    return as_elements(
+        bind(obj_key, to_const=obj),
+        SetBinding(multi_key, obj_key),
+    )
+
+
+def bind_map_entry_const(
+        multi_key: ta.Any,
+        map_key: ta.Any,
+        obj: ta.Any,
+        *,
+        tag: ta.Any | None = None,
+) -> Elements:
+    multi_key = as_key(multi_key)
+    check.arg(is_map_multi_key(multi_key))
+
+    if tag is None:
+        tag = Id(id(obj), tag=multi_key.tag)
+    obj_key: Key = Key(type(obj), tag=tag)
+
+    return as_elements(
+        bind(obj_key, to_const=obj),
+        MapBinding(multi_key, map_key, obj_key),
+    )
+
+
+##
+
+
+@ta.final
+class ItemsBinderHelper(ta.Generic[ItemT]):
+    def __init__(self, items_cls: ta.Any) -> None:
+        self._items_cls = items_cls
+
+    @cached.property
+    def _item_rty(self) -> rfl.Type:
+        rty = check.isinstance(rfl.type_(rfl.get_orig_class(self)), rfl.Generic)
+        check.is_(rty.cls, self.__class__)
+        return check.single(rty.args)
+
+    @dc.dataclass(frozen=True, eq=False)
+    class _ItemsBox:
+        vs: ta.Sequence
+
+    @cached.property
+    def _items_box(self) -> type[_ItemsBox]:
+        if isinstance(item_rty := self._item_rty, type):
+            sfx = item_rty.__qualname__
+        else:
+            sfx = str(item_rty).replace("'", '')
+
+        return lang.new_type(  # noqa
+            f'{ItemsBinderHelper._ItemsBox.__qualname__}${sfx}@{id(self):x}',
+            (ItemsBinderHelper._ItemsBox,),
+            {},
+        )
+
+    @cached.property
+    def _set_key(self) -> Key:
+        return as_key(ta.AbstractSet[self._item_rty])  # type: ignore
+
+    def bind_item_consts(self, *items: ItemT) -> Elements:
+        return as_elements(
+            bind_set_entry_const(self._set_key, self._items_box(items)),
+        )
+
+    @dc.dataclass(frozen=True, eq=False)
+    @dc.extra_class_params(repr_id=True)
+    class _ItemTag:
+        pass
+
+    def bind_item(self, **kwargs: ta.Any) -> Elements:
+        tag = ItemsBinderHelper._ItemTag()
+        item_key: Key = Key(ta.Any, tag=tag)
+        items_box_key: Key = Key(self._items_box, tag=tag)
+        return as_elements(
+            bind(item_key, **kwargs),
+            bind(
+                items_box_key,
+                to_provider=FnProvider(KwargsTarget.of(
+                    lambda v: self._items_box([v]),
+                    v=item_key,
+                )),
+            ),
+            SetBinding(self._set_key, items_box_key),
+        )
+
+    def bind_items_provider(self, **kwargs: ta.Any) -> Elements:
+        return as_elements(
+            SetBinder[self._item_rty](),  # type: ignore
+            bind(
+                self._items_cls,
+                to_provider=FnProvider(KwargsTarget.of(
+                    lambda s: self._items_cls([v for i in s for v in i.vs]),
+                    s=self._set_key,
+                )),
+                **kwargs,
+            ),
+        )
+
+
+items_binder_helper = ItemsBinderHelper

omlish/inject/helpers/wrappers.py

@@ -0,0 +1,54 @@
+import typing as ta
+
+from ... import cached
+from ... import dataclasses as dc
+from ..binder import bind
+from ..elements import Elemental
+from ..keys import Key
+from ..keys import as_key
+from ..privates import private
+
+
+##
+
+
+@ta.final
+class WrapperBinderHelper:
+    def __init__(self, key: ta.Any) -> None:
+        self._key = as_key(key)
+        self._root = WrapperBinderHelper._Root()
+        self._top = WrapperBinderHelper._Level(self._root, 0)
+
+    @dc.dataclass(frozen=True, eq=False)
+    @dc.extra_class_params(repr_id=True)
+    class _Root:
+        pass
+
+    @dc.dataclass(frozen=True)
+    class _Level:
+        root: 'WrapperBinderHelper._Root'
+        level: int
+
+        def next(self) -> 'WrapperBinderHelper._Level':
+            return WrapperBinderHelper._Level(self.root, self.level + 1)
+
+        @cached.property
+        def key(self) -> Key:
+            return Key(ta.Any, tag=self)
+
+    @property
+    def top(self) -> Key:
+        return self._top.key
+
+    def push_bind(self, **kwargs: ta.Any) -> Elemental:
+        prv = self._top
+        nxt = prv.next()
+        out = private(
+            *([bind(self._key, to_key=prv.key)] if prv.level else []),
+            bind(nxt.key, **kwargs, expose=True),
+        )
+        self._top = nxt
+        return out
+
+
+wrapper_binder_helper = WrapperBinderHelper

omlish/inject/impl/elements.py

@@ -27,6 +27,7 @@ from ... import collections as col
 from ... import lang
 from ..bindings import Binding
 from ..eagers import Eager
+from ..elements import CollectedElements
 from ..elements import Element
 from ..elements import Elements
 from ..errors import ConflictingKeyError
@@ -47,7 +48,7 @@ from .multis import make_multi_provider_impl
 from .origins import Origins
 from .origins import set_origins
 from .providers import ProviderImpl
-from .providers2 import make_provider_impl
+from .providersmap import make_provider_impl
 from .scopes import make_scope_impl
 
 
@@ -63,7 +64,24 @@ ElementT = ta.TypeVar('ElementT', bound=Element)
 ##
 
 
-class ElementCollection(lang.Final):
+_SIMPLE_KEYED_ELEMENT_TYPES: tuple[type[Element], ...] = (
+    Binding,
+    Eager,
+    Expose,
+)
+
+_SIMPLE_NON_KEYED_ELEMENT_TYPES: tuple[type[Element], ...] = (
+    ProvisionListenerBinding,
+)
+
+_NON_BINDING_ELEMENT_TYPES: tuple[type[Element], ...] = (
+    Eager,
+    Expose,
+    ProvisionListenerBinding,
+)
+
+
+class ElementCollection(CollectedElements, lang.Final):
     def __init__(self, es: Elements) -> None:
         super().__init__()
 
@@ -96,28 +114,28 @@ class ElementCollection(lang.Final):
             out.setdefault(k, []).extend(e)
 
         for e in es:
-            if isinstance(e, ScopeBinding):
+            if isinstance(e, _SIMPLE_KEYED_ELEMENT_TYPES):
+                add(e.key, e)  # type: ignore[attr-defined]  # noqa
+
+            elif isinstance(e, _SIMPLE_NON_KEYED_ELEMENT_TYPES):
+                add(None, e)
+
+            elif isinstance(e, (SetBinding, MapBinding)):
+                add(e.multi_key, e)
+
+            elif isinstance(e, ScopeBinding):
                 add(None, e)
                 sci = make_scope_impl(e.scope)
                 if (sae := sci.auto_elements()) is not None:
                     self._build_raw_element_multimap(sae, out)
 
-            elif isinstance(e, (Binding, Eager, Expose)):
-                add(e.key, e)
-
             elif isinstance(e, Private):
                 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)
+                ovr = self._build_raw_element_multimap(e.ovr)
                 for k, b in src.items():  # FIXME: merge None keys?
                     try:
                         bs = ovr[k]
@@ -166,9 +184,8 @@ class ElementCollection(lang.Final):
 
             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)
+            for nb_ty in _NON_BINDING_ELEMENT_TYPES:
+                es_by_ty.pop(nb_ty, None)
 
             if (bs := es_by_ty.pop(Binding, None)):
                 b = self._get_single_binding(k, bs)  # type: ignore
@@ -176,7 +193,6 @@ class ElementCollection(lang.Final):
                 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)
 
@@ -193,6 +209,10 @@ class ElementCollection(lang.Final):
 
     ##
 
+    @lang.cached_function
+    def scope_binding_scopes(self) -> ta.Sequence[Scope]:
+        return [sb.scope for sb in self.elements_of_type(ScopeBinding)]
+
     @lang.cached_function
     def eager_keys_by_scope(self) -> ta.Mapping[Scope, ta.Sequence[Key]]:
         bim = self.binding_impl_map()
@@ -201,3 +221,13 @@ class ElementCollection(lang.Final):
             bi = bim[e.key]
             ret.setdefault(bi.scope, []).append(e.key)
         return ret
+
+
+##
+
+
+def collect_elements(es: Elements | CollectedElements) -> ElementCollection:
+    if isinstance(es, CollectedElements):
+        return check.isinstance(es, ElementCollection)
+    else:
+        return ElementCollection(es)

omlish/inject/impl/injector.py

@@ -2,16 +2,16 @@
 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
  - config - proxies, impl select, etc
   - config is probably shared with ElementCollection... but not 'bound', must be shared everywhere
   - InjectorRoot object?
  - ** 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?
+ - more listeners - UnboundKeyListener
+  - lazy parent listener chain cache thing
 """
 import contextlib
 import functools
@@ -22,7 +22,7 @@ import weakref
 from ... import check
 from ... import lang
 from ...logs import all as logs
-from ..elements import Elements
+from ..elements import CollectedElements
 from ..errors import CyclicDependencyError
 from ..errors import UnboundKeyError
 from ..injector import AsyncInjector
@@ -31,7 +31,6 @@ 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 ThreadScope
 from ..types import Scope
@@ -55,17 +54,16 @@ DEFAULT_SCOPES: list[Scope] = [
 ]
 
 
+@ta.final
 class AsyncInjectorImpl(AsyncInjector, lang.Final):
     def __init__(
             self,
-            ec: ElementCollection,
+            ec: CollectedElements,
             p: ta.Optional['AsyncInjectorImpl'] = None,
             *,
             internal_consts: dict[Key, ta.Any] | None = None,
     ) -> None:
-        super().__init__()
-
-        self._ec = check.isinstance(ec, ElementCollection)
+        self._ec = (ec := check.isinstance(ec, ElementCollection))
         self._p: AsyncInjectorImpl | None = check.isinstance(p, (AsyncInjectorImpl, None))
 
         self._internal_consts: dict[Key, ta.Any] = {
@@ -74,28 +72,31 @@ class AsyncInjectorImpl(AsyncInjector, lang.Final):
         }
 
         self._bim = ec.binding_impl_map()
+
         self._ekbs = ec.eager_keys_by_scope()
+
         self._pls: tuple[ProvisionListener, ...] = tuple(
             b.listener  # type: ignore[attr-defined]
             for b in itertools.chain(
                 ec.elements_of_type(ProvisionListenerBinding),
-                (p._pls if p is not None else ()),  # noqa
+                p._pls if p is not None else (),  # noqa
             )
         )
 
-        self._cs: weakref.WeakSet[AsyncInjectorImpl] | None = None
         self._root: AsyncInjectorImpl = p._root if p is not None else self  # noqa
 
-        self.__cur_req: AsyncInjectorImpl._Request | None = None
-
-        ss = [
-            *DEFAULT_SCOPES,
-            *[sb.scope for sb in ec.elements_of_type(ScopeBinding)],
-        ]
         self._scopes: dict[Scope, ScopeImpl] = {
-            s: make_scope_impl(s) for s in ss
+            s: make_scope_impl(s)
+            for s in itertools.chain(
+                DEFAULT_SCOPES,
+                ec.scope_binding_scopes(),
+            )
         }
 
+    _cs: weakref.WeakSet['AsyncInjectorImpl'] | None = None  # noqa
+
+    __cur_req: ta.Optional['AsyncInjectorImpl._Request'] = None
+
     #
 
     _has_run_init: bool = False
@@ -256,7 +257,7 @@ class AsyncInjectorImpl(AsyncInjector, lang.Final):
         return obj(**kws)
 
 
-async def create_async_injector(es: Elements) -> AsyncInjector:
-    i = AsyncInjectorImpl(ElementCollection(es))
+async def create_async_injector(ce: CollectedElements) -> AsyncInjector:
+    i = AsyncInjectorImpl(ce)
     await i._init()  # noqa
     return i

omlish/inject/impl/inspect.py

@@ -75,7 +75,11 @@ def build_kwargs_target(
         skip_args: int = 0,
         skip_kwargs: ta.Iterable[str] | None = None,
         raw_optional: bool = False,
+        non_strict: bool = False,
 ) -> KwargsTarget:
+    if isinstance(obj, KwargsTarget):
+        return obj
+
     sig = signature(obj)
     tags = _TAGS.get(obj)
 
@@ -90,11 +94,15 @@ def build_kwargs_target(
             continue
 
         if p.annotation is inspect.Signature.empty:
+            if non_strict:
+                continue
             if p.default is not inspect.Parameter.empty:
                 raise KeyError(f'{obj}, {p.name}')
             continue
 
         if p.kind not in (inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY):
+            if non_strict:
+                continue
             raise TypeError(sig)
 
         ann = p.annotation
@@ -119,7 +127,8 @@ def build_kwargs_target(
             k = dc.replace(k, tag=pt)
 
         if k in seen:
-            raise ConflictingKeyError(k)
+            if not non_strict:
+                raise ConflictingKeyError(k)
         seen.add(k)
 
         kws.append(Kwarg(

omlish/inject/impl/maysync.py

@@ -1,13 +1,12 @@
 import typing as ta
 
 from ... import lang
-from ..elements import Elements
+from ..elements import CollectedElements
 from ..injector import AsyncInjector
 from ..inspect import KwargsTarget
 from ..keys import Key
 from ..maysync import MaysyncInjector
 from ..sync import Injector
-from .elements import ElementCollection
 from .injector import AsyncInjectorImpl
 
 
@@ -30,10 +29,10 @@ class MaysyncInjectorImpl(MaysyncInjector, lang.Final):
         return lang.run_maysync(self._ai.inject(obj))
 
 
-def create_maysync_injector(es: Elements) -> MaysyncInjector:
+def create_maysync_injector(ce: CollectedElements) -> MaysyncInjector:
     si = MaysyncInjectorImpl()
     ai = AsyncInjectorImpl(
-        ElementCollection(es),
+        ce,
         internal_consts={
             Key(MaysyncInjector): si,
             Key(Injector): si,

omlish/inject/impl/multis.py

@@ -1,5 +1,6 @@
 import typing as ta
 
+from ... import check
 from ... import dataclasses as dc
 from ... import lang
 from ..elements import Element
@@ -58,6 +59,7 @@ class MapProviderImpl(ProviderImpl, lang.Final):
 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
+        check.empty(es_by_ty)
         return SetProviderImpl([
             LinkProviderImpl(LinkProvider(sb.dst))
             for sb in sbs
@@ -65,6 +67,7 @@ def make_multi_provider_impl(p: Provider, es_by_ty: ta.MutableMapping[type, list
 
     elif isinstance(p, MapProvider):
         mbs: ta.Iterable[MapBinding] = es_by_ty.pop(MapBinding, ())  # type: ignore
+        check.empty(es_by_ty)
         return MapProviderImpl([
             MapProviderImpl.Entry(
                 mb.map_key,

omlish/inject/impl/sync.py

@@ -1,12 +1,11 @@
 import typing as ta
 
 from ... import lang
-from ..elements import Elements
+from ..elements import CollectedElements
 from ..injector import AsyncInjector
 from ..inspect import KwargsTarget
 from ..keys import Key
 from ..sync import Injector
-from .elements import ElementCollection
 from .injector import AsyncInjectorImpl
 
 
@@ -29,10 +28,10 @@ class InjectorImpl(Injector, lang.Final):
         return lang.sync_await(self._ai.inject(obj))
 
 
-def create_injector(es: Elements) -> Injector:
+def create_injector(ce: CollectedElements) -> Injector:
     si = InjectorImpl()
     ai = AsyncInjectorImpl(
-        ElementCollection(es),
+        ce,
         internal_consts={
             Key(Injector): si,
         },