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

omlish/inject/impl/elements.py

@@ -10,6 +10,8 @@ Multi's + Scopes:
 
 Element Types:
  - Binding
+ - SetBinding
+ - MapBinding
  - Eager
  - Overrides
  - Expose
@@ -27,16 +29,22 @@ from ..elements import Element
 from ..elements import Elements
 from ..exceptions import DuplicateKeyError
 from ..keys import Key
+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 ..scopes import ScopeBinding
 from ..types import Scope
 from .bindings import BindingImpl
-from .providers import MultiProviderImpl
+from .multis import make_multi_provider_impl
+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_
 else:
@@ -92,10 +100,13 @@ 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, 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 +128,34 @@ 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 ()
-
-        else:
-            raise TypeError(e)
-
     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:
+            es_by_ty = col.multi_map_by(type, es)
+
+            es_by_ty.pop(Eager, None)
+            es_by_ty.pop(Expose, None)
+
+            if (bs := es_by_ty.pop(Binding, None)):
+                if len(bs) > 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
+                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)
+
+                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,6 +9,7 @@ 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 typing as ta

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/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

@@ -25,6 +25,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:

omlish/inject/injector.py

@@ -6,6 +6,7 @@ from .elements import Elements
 from .inspect import KwargsTarget
 from .keys import Key
 
+
 _impl = lang.proxy_import('.impl.injector', __package__)
 
 

omlish/inject/keys.py

@@ -3,6 +3,7 @@ import typing as ta
 
 from .. import dataclasses as dc
 from .. import lang
+from .. import reflect as rfl
 
 
 T = ta.TypeVar('T')
@@ -14,9 +15,8 @@ T = ta.TypeVar('T')
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class Key(lang.Final, ta.Generic[T]):
-    cls: type[T] | ta.NewType
+    ty: rfl.Type = dc.xfield(coerce=rfl.type_)
     tag: ta.Any = dc.field(default=None, kw_only=True)
-    multi: bool = dc.field(default=False, kw_only=True)
 
 
 ##
@@ -27,17 +27,11 @@ def as_key(o: ta.Any) -> Key:
         raise TypeError(o)
     if isinstance(o, Key):
         return o
-    if isinstance(o, (type, ta.NewType)):  # noqa
-        return Key(o)
-    raise TypeError(o)
+    return Key(rfl.type_(o))
 
 
 ##
 
 
-def multi(o: ta.Any) -> Key:
-    return dc.replace(as_key(o), multi=True)
-
-
 def tag(o: ta.Any, t: ta.Any) -> Key:
     return dc.replace(as_key(o), tag=t)

omlish/inject/multis.py

@@ -0,0 +1,70 @@
+"""
+TODO:
+ - scopes
+"""
+import collections.abc
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+from .. import reflect as rfl
+from .bindings import Binding
+from .elements import Element
+from .keys import Key
+from .keys import as_key
+from .providers import Provider
+
+
+##
+
+
+def _check_set_multi_key(mk: Key) -> bool:
+    return rfl.get_concrete_type(mk.ty) is collections.abc.Set
+
+
+@dc.dataclass(frozen=True)
+@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()
+
+
+@dc.dataclass(frozen=True, eq=False)
+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))
+
+
+##
+
+
+def _check_map_multi_key(mk: Key) -> bool:
+    return rfl.get_concrete_type(mk.ty) is collections.abc.Mapping
+
+
+@dc.dataclass(frozen=True)
+@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(())
+
+
+@dc.dataclass(frozen=True, eq=False)
+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))

omlish/inject/providers.py

@@ -4,12 +4,12 @@ import typing as ta
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
+from .. import reflect as rfl
 from .elements import Element
 from .elements import Elements
 from .impl.inspect import signature
 from .keys import Key
 from .keys import as_key
-from .types import Cls
 
 
 class _Missing(lang.NotInstantiable):
@@ -21,7 +21,7 @@ class _Missing(lang.NotInstantiable):
 
 class Provider(lang.Abstract):
     @abc.abstractmethod
-    def provided_cls(self) -> Cls | None:
+    def provided_ty(self) -> rfl.Type | None:
         raise NotImplementedError
 
 
@@ -47,19 +47,19 @@ def as_provider(o: ta.Any) -> Provider:
 @dc.dataclass(frozen=True, eq=False)
 class FnProvider(Provider):
     fn: ta.Any
-    cls: Cls | None = None
+    ty: rfl.Type | None = None
 
-    def provided_cls(self) -> Cls | None:
-        return self.cls
+    def provided_ty(self) -> rfl.Type | None:
+        return self.ty
 
 
-def fn(fn: ta.Any, cls: Cls | None = _Missing) -> Provider:
+def fn(fn: ta.Any, ty: rfl.Type | None = _Missing) -> Provider:
     check.not_isinstance(fn, type)
     check.callable(fn)
-    if cls is _Missing:
+    if ty is _Missing:
         sig = signature(fn)
-        cls = check.isinstance(sig.return_annotation, type)
-    return FnProvider(fn, cls)
+        ty = check.isinstance(sig.return_annotation, type)
+    return FnProvider(fn, ty)
 
 
 ##
@@ -67,15 +67,15 @@ def fn(fn: ta.Any, cls: Cls | None = _Missing) -> Provider:
 
 @dc.dataclass(frozen=True, eq=False)
 class CtorProvider(Provider):
-    cls: type
+    ty: type
 
-    def provided_cls(self) -> Cls:
-        return self.cls
+    def provided_ty(self) -> type:
+        return self.ty
 
 
-def ctor(cls: type) -> Provider:
-    check.isinstance(cls, type)
-    return CtorProvider(cls)
+def ctor(ty: type) -> Provider:
+    check.isinstance(ty, type)
+    return CtorProvider(ty)
 
 
 ##
@@ -84,16 +84,16 @@ def ctor(cls: type) -> Provider:
 @dc.dataclass(frozen=True, eq=False)
 class ConstProvider(Provider):
     v: ta.Any
-    cls: Cls | None = None
+    ty: rfl.Type | None = None
 
-    def provided_cls(self) -> Cls | None:
-        return self.cls
+    def provided_ty(self) -> rfl.Type | None:
+        return self.ty
 
 
-def const(v: ta.Any, cls: Cls | None = _Missing) -> Provider:
-    if cls is _Missing:
-        cls = type(v)
-    return ConstProvider(v, cls)
+def const(v: ta.Any, ty: rfl.Type | None = _Missing) -> Provider:
+    if ty is _Missing:
+        ty = type(v)
+    return ConstProvider(v, ty)
 
 
 ##
@@ -103,7 +103,7 @@ def const(v: ta.Any, cls: Cls | None = _Missing) -> Provider:
 class LinkProvider(Provider):
     k: Key
 
-    def provided_cls(self) -> Cls | None:
+    def provided_ty(self) -> rfl.Type | None:
         return None
 
 

omlish/inject/scopes.py

@@ -5,21 +5,25 @@ 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 .bindings import as_binding
 from .elements import Element
 from .keys import Key
 from .keys import as_key
 from .providers import Provider
-from .types import Cls
 from .types import Scope
 
+
 if ta.TYPE_CHECKING:
     from . import injector as injector_
 else:
     injector_ = lang.proxy_import('.injector', __package__)
 
 
+##
+
+
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class ScopeBinding(Element, lang.Final):
@@ -65,8 +69,8 @@ class ScopeSeededProvider(Provider):
     ss: SeededScope = dc.xfield(coerce=check.of_isinstance(SeededScope))
     key: Key = dc.xfield(coerce=check.of_isinstance(Key))
 
-    def provided_cls(self) -> Cls | None:
-        return self.key.cls
+    def provided_ty(self) -> rfl.Type | None:
+        return self.key.ty
 
 
 def bind_scope_seed(ss: SeededScope, k: ta.Any) -> Element:

omlish/inject/types.py

@@ -1,17 +1,9 @@
-import typing as ta
-
 from .. import lang
 
 
 ##
 
 
-Cls = type | ta.NewType
-
-
-##
-
-
 class Scope(lang.Abstract):
     def __repr__(self) -> str:
         return type(self).__name__

omlish/iterators.py

@@ -218,3 +218,16 @@ def expand_indexed_pairs(
         if idx < width_:
             result[idx] = value
     return result
+
+
+##
+# https://docs.python.org/3/library/itertools.html#itertools-recipes
+
+
+def sliding_window(it: ta.Iterable[T], n: int) -> ta.Iterator[tuple[T, ...]]:
+    # sliding_window('ABCDEFG', 4) -> ABCD BCDE CDEF DEFG
+    iterator = iter(it)
+    window = collections.deque(itertools.islice(iterator, n - 1), maxlen=n)
+    for x in iterator:
+        window.append(x)
+        yield tuple(window)

omlish/json.py

@@ -127,6 +127,7 @@ import typing as ta
 
 from . import lang
 
+
 if ta.TYPE_CHECKING:
     import orjson as _orjson
     import ujson as _ujson
@@ -165,7 +166,7 @@ dumps_pretty: ta.Callable[..., str] = functools.partial(dumps, **PRETTY_KWARGS)
 COMPACT_SEPARATORS = (',', ':')
 
 COMPACT_KWARGS: ta.Mapping[str, ta.Any] = dict(
-    indent=0,
+    indent=None,
     separators=COMPACT_SEPARATORS,
 )
 

omlish/lang/__init__.py

@@ -46,7 +46,9 @@ from .cmp import (  # noqa
 )
 
 from .contextmanagers import (  # noqa
+    AsyncContextManager,
     ContextManaged,
+    ContextManager,
     ContextWrapped,
     DefaultLockable,
     ExitStacked,
@@ -90,6 +92,7 @@ from .exceptions import (  # noqa
 from .functions import (  # noqa
     Args,
     VoidError,
+    as_async,
     constant,
     finally_,
     identity,
@@ -108,6 +111,7 @@ from .functions import (  # noqa
 )
 
 from .imports import (  # noqa
+    can_import,
     import_all,
     import_module,
     import_module_attr,

omlish/lang/classes/restrict.py

@@ -89,7 +89,7 @@ class PackageSealed:
 class NotInstantiable(Abstract):
     __slots__ = ()
 
-    def __new__(cls, *args, **kwargs):
+    def __new__(cls, *args, **kwargs):  # noqa
         raise TypeError
 
 

omlish/lang/classes/virtual.py

@@ -3,8 +3,8 @@ import types
 import typing as ta
 
 from .abstract import make_abstract
-from .restrict import NotInstantiable
 from .restrict import Final
+from .restrict import NotInstantiable
 
 
 T = ta.TypeVar('T')
@@ -122,7 +122,7 @@ class Callable(NotInstantiable, Final, ta.Generic[T]):
 
     @classmethod
     def __subclasscheck__(cls, subclass: type) -> bool:
-        if not hasattr(subclass, '__call__'):
+        if not hasattr(subclass, '__call__'):  # noqa
             return False
         call = subclass.__call__
         if isinstance(call, types.MethodWrapperType) and call.__self__ is subclass: