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

omlish/inject/keys.py

@@ -3,41 +3,29 @@ import typing as ta
 
 from .. import dataclasses as dc
 from .. import lang
+from .. import reflect as rfl
+from .types import Tag
 
 
 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
-    tag: ta.Any = dc.field(default=None, kw_only=True)
-    multi: bool = dc.field(default=False, kw_only=True)
-
+    ty: rfl.Type = dc.xfield(coerce=rfl.type_)
 
-##
+    tag: ta.Any = dc.xfield(
+        default=None,
+        kw_only=True,
+        check=lambda o: not isinstance(o, Tag),
+        repr_fn=dc.opt_repr,
+    )
 
 
 def as_key(o: ta.Any) -> Key:
-    if o is inspect.Parameter.empty:
+    if o is None or o is inspect.Parameter.empty:
         raise TypeError(o)
     if isinstance(o, Key):
         return o
-    if isinstance(o, (type, ta.NewType)):  # noqa
-        return Key(o)
-    raise TypeError(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)
+    return Key(rfl.type_(o))

omlish/inject/listeners.py

@@ -0,0 +1,26 @@
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+from .bindings import Binding
+from .elements import Element
+from .injector import Injector
+from .keys import Key
+
+
+ProvisionListener: ta.TypeAlias = ta.Callable[[
+    Injector,
+    Key,
+    Binding,
+    ta.Callable[[], ta.Any],
+], ta.Callable[[], ta.Any]]
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
+class ProvisionListenerBinding(Element, lang.Final):
+    listener: ProvisionListener
+
+
+def bind_provision_listener(l: ProvisionListener) -> Element:
+    return ProvisionListenerBinding(l)

omlish/inject/managed.py

@@ -5,20 +5,86 @@ TODO:
 import contextlib
 import typing as ta
 
-from .eagers import eager
-from .elements import Elements
-from .elements import as_elements
+from .. import lang
+from .binder import bind
+from .elements import Elemental
+from .impl.inspect import build_kwargs_target
 from .injector import Injector
 from .injector import create_injector
-from .scopes import singleton
+
+
+if ta.TYPE_CHECKING:
+    from .. import asyncs as _asyncs
+else:
+    _asyncs = lang.proxy_import('..asyncs', __package__)
+
+
+T = ta.TypeVar('T')
+
+
+##
 
 
 @contextlib.contextmanager
-def create_managed_injector(es: Elements) -> ta.Generator[Injector, None, None]:
-    i = create_injector(as_elements(
-        es,
-        singleton(contextlib.ExitStack),
-        eager(contextlib.ExitStack),
-    ))
+def create_managed_injector(*args: Elemental) -> ta.Generator[Injector, None, None]:
+    i = create_injector(
+        bind(contextlib.ExitStack, singleton=True, eager=True),
+        *args,
+    )
     with i[contextlib.ExitStack]:
         yield i
+
+
+def make_managed_provider(
+        fac: ta.Callable[..., T],
+        *fns: ta.Callable[[T], ta.ContextManager[T]],
+) -> ta.Callable[..., T]:
+    kt = build_kwargs_target(fac)
+
+    def _provide(
+            i: Injector,
+            es: contextlib.ExitStack,
+    ):
+        obj = i.inject(kt)
+        if not fns:
+            obj = es.enter_context(obj)
+        else:
+            for fn in fns:
+                es.enter_context(fn(obj))
+        return obj
+
+    return _provide
+
+
+##
+
+
+@contextlib.asynccontextmanager
+async def create_async_managed_injector(*args: Elemental) -> ta.AsyncGenerator[Injector, None]:
+    i = await _asyncs.s_to_a(create_injector)(
+        bind(contextlib.AsyncExitStack, singleton=True, eager=True),
+        *args,
+    )
+    async with i[contextlib.AsyncExitStack]:
+        yield i
+
+
+def make_async_managed_provider(
+        fac: ta.Callable[..., T],
+        *fns: ta.Callable[[T], ta.AsyncContextManager[T]],
+) -> ta.Callable[..., T]:
+    kt = build_kwargs_target(fac)
+
+    def _provide(
+            i: Injector,
+            aes: contextlib.AsyncExitStack,
+    ):
+        obj = i.inject(kt)
+        if not fns:
+            obj = _asyncs.a_to_s(aes.enter_async_context)(obj)
+        else:
+            for fn in fns:
+                _asyncs.a_to_s(aes.enter_async_context)(fn(obj))
+        return obj
+
+    return _provide

omlish/inject/multis.py

@@ -0,0 +1,120 @@
+"""
+TODO:
+ - scopes
+"""
+import collections.abc
+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 .elements import Element
+from .elements import ElementGenerator
+from .keys import Key
+from .keys import as_key
+from .providers import Provider
+
+
+T = ta.TypeVar('T')
+K = ta.TypeVar('K')
+V = ta.TypeVar('V')
+
+
+##
+
+
+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(coerce=check.of_isinstance(Key))
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
+class SetProvider(Provider):
+    multi_key: Key = dc.xfield(check=_check_set_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(coerce=check.of_isinstance(Key))
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
+class MapProvider(Provider):
+    multi_key: Key = dc.xfield(check=_check_map_multi_key)
+
+
+##
+
+
+class SetBinder(ElementGenerator, ta.Generic[T]):
+    def __init__(self, *, tag: ta.Any = None) -> None:
+        super().__init__()
+        self._tag: ta.Any = tag
+        self._sbs: list[SetBinding] = []
+
+    @lang.cached_property
+    def _multi_key(self) -> Key:
+        oty = rfl.type_(rfl.get_orig_class(self))
+        ety = check.single(check.isinstance(oty, rfl.Generic).args)
+        return Key(ta.AbstractSet[ety], tag=self._tag)  # type: ignore
+
+    @lang.cached_property
+    def _set_provider_binding(self) -> Element:
+        return Binding(self._multi_key, SetProvider(self._multi_key))
+
+    def bind(self, *keys: ta.Any) -> ta.Self:
+        if not isinstance(self, SetBinder):
+            raise TypeError
+        self._sbs.extend(SetBinding(self._multi_key, as_key(k)) for k in keys)
+        return self  # type: ignore
+
+    def __iter__(self) -> ta.Iterator[Element]:
+        yield self._set_provider_binding
+        yield from self._sbs
+
+
+class MapBinder(ElementGenerator, ta.Generic[K, V]):
+    def __init__(self, *, tag: ta.Any = None) -> None:
+        super().__init__()
+        self._tag: ta.Any = tag
+        self._mbs: list[MapBinding] = []
+
+    @lang.cached_property
+    def _multi_key(self) -> Key:
+        oty = rfl.type_(rfl.get_orig_class(self))
+        kty, vty = check.isinstance(oty, rfl.Generic).args
+        return Key(ta.Mapping[kty, vty], tag=self._tag)  # type: ignore
+
+    @lang.cached_property
+    def _map_provider_binding(self) -> Element:
+        return Binding(self._multi_key, MapProvider(self._multi_key))
+
+    def bind(self, map_key: K, map_value_key: ta.Any) -> ta.Self:
+        if not isinstance(self, MapBinder):
+            raise TypeError
+        self._mbs.append(MapBinding(self._multi_key, map_key, as_key(map_value_key)))
+        return self  # type: ignore
+
+    def __iter__(self) -> ta.Iterator[Element]:
+        yield self._map_provider_binding
+        yield from self._mbs

omlish/inject/origins.py

@@ -0,0 +1,27 @@
+import abc
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
+class Origin:
+    lst: ta.Sequence[str]
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
+class Origins:
+    lst: ta.Sequence[Origin]
+
+    def __iter__(self) -> ta.Iterator[Origin]:
+        yield from self.lst
+
+
+class HasOrigins(lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def origins(self) -> Origins:
+        raise NotImplementedError

omlish/inject/overrides.py

@@ -1,18 +1,19 @@
 import typing as ta
 
+from .. import check
 from .. import dataclasses as dc
 from .. import lang
-from .binder import bind
 from .elements import Element
 from .elements import Elements
+from .elements import as_elements
 
 
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class Overrides(Element, lang.Final):
-    ovr: Elements
-    src: Elements
+    ovr: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
+    src: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
 
 
 def override(ovr: ta.Any, *a: ta.Any) -> Element:
-    return Overrides(bind(ovr), bind(*a))
+    return Overrides(as_elements(ovr), as_elements(*a))

omlish/inject/{private.py → privates.py}

@@ -1,10 +1,10 @@
-import typing as ta
-
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
 from .elements import Element
+from .elements import Elemental
 from .elements import Elements
+from .elements import as_elements
 from .keys import Key
 from .keys import as_key
 
@@ -12,18 +12,14 @@ from .keys import as_key
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class Expose(Element, lang.Final):
-    key: Key
-
-
-def expose(k: ta.Any) -> Element:
-    return Expose(as_key(k))
+    key: Key = dc.xfield(coerce=as_key)
 
 
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class Private(Element, lang.Final):
-    elements: Elements
+    elements: Elements = dc.xfield(coerce=check.of_isinstance(Elements))
 
 
-def private(es: Elements) -> Element:
-    return Private(check.isinstance(es, Elements))
+def private(*args: Elemental) -> Private:
+    return Private(as_elements(*args))

omlish/inject/providers.py

@@ -1,111 +1,38 @@
-import abc
 import typing as ta
 
 from .. import check
 from .. import dataclasses as dc
 from .. import lang
-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):
     pass
 
 
-##
-
-
 class Provider(lang.Abstract):
-    @abc.abstractmethod
-    def provided_cls(self) -> Cls | None:
-        raise NotImplementedError
-
-
-##
-
-
-def as_provider(o: ta.Any) -> Provider:
-    check.not_isinstance(o, (Element, Elements))
-    if isinstance(o, Provider):
-        return o
-    if isinstance(o, Key):
-        return link(o)
-    if isinstance(o, type):
-        return ctor(o)
-    if callable(o):
-        return fn(o)
-    return const(o)
-
-
-##
+    pass
 
 
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class FnProvider(Provider):
-    fn: ta.Any
-    cls: Cls | None = None
-
-    def provided_cls(self) -> Cls | None:
-        return self.cls
-
-
-def fn(fn: ta.Any, cls: Cls | None = _Missing) -> Provider:
-    check.not_isinstance(fn, type)
-    check.callable(fn)
-    if cls is _Missing:
-        sig = signature(fn)
-        cls = check.isinstance(sig.return_annotation, type)
-    return FnProvider(fn, cls)
-
-
-##
+    fn: ta.Any = dc.xfield(check=callable)
 
 
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class CtorProvider(Provider):
-    cls: type
+    ty: type = dc.xfield(coerce=check.of_isinstance(type))
 
-    def provided_cls(self) -> Cls:
-        return self.cls
 
-
-def ctor(cls: type) -> Provider:
-    check.isinstance(cls, type)
-    return CtorProvider(cls)
-
-
-##
-
-
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class ConstProvider(Provider):
     v: ta.Any
-    cls: Cls | None = None
-
-    def provided_cls(self) -> Cls | None:
-        return self.cls
-
 
-def const(v: ta.Any, cls: Cls | None = _Missing) -> Provider:
-    if cls is _Missing:
-        cls = type(v)
-    return ConstProvider(v, cls)
 
-
-##
-
-
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 class LinkProvider(Provider):
-    k: Key
-
-    def provided_cls(self) -> Cls | None:
-        return None
-
-
-def link(k: ta.Any) -> Provider:
-    return LinkProvider(as_key(k))
+    k: Key = dc.xfield(coerce=check.of_isinstance(Key))

omlish/inject/scopes.py

@@ -5,21 +5,27 @@ 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__)
 
 
+##
+
+
+SCOPE_ALIASES: dict[str, Scope] = {}
+
+
 @dc.dataclass(frozen=True)
 @dc.extra_params(cache_hash=True)
 class ScopeBinding(Element, lang.Final):
@@ -30,22 +36,26 @@ def bind_scope(sc: Scope) -> Element:
     return ScopeBinding(sc)
 
 
-def in_(b: ta.Any, sc: Scope) -> 'Binding':
-    return dc.replace(as_binding(b), scope=check.isinstance(sc, Scope))
+##
 
 
 class Singleton(Scope, lang.Singleton, lang.Final):
     pass
 
 
-def singleton(b: ta.Any) -> 'Binding':
-    return in_(b, Singleton())
+SCOPE_ALIASES['singleton'] = Singleton()
+
+
+##
 
 
 class Thread(Scope, lang.Singleton, lang.Final):
     pass
 
 
+SCOPE_ALIASES['thread'] = Thread()
+
+
 ##
 
 
@@ -60,13 +70,14 @@ class SeededScope(Scope, lang.Final):
             raise NotImplementedError
 
 
-@dc.dataclass(frozen=True, eq=False)
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
 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,15 +1,9 @@
-import typing as ta
+import collections
 
 from .. import lang
 
 
-##
-
-
-Cls = type | ta.NewType
-
-
-##
+Tag = collections.namedtuple('Tag', 'tag')  # noqa
 
 
 class Scope(lang.Abstract):

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/lang/__init__.py

@@ -46,7 +46,9 @@ from .cmp import (  # noqa
 )
 
 from .contextmanagers import (  # noqa
+    AsyncContextManager,
     ContextManaged,
+    ContextManager,
     ContextWrapped,
     DefaultLockable,
     ExitStacked,
@@ -78,9 +80,13 @@ from .descriptors import (  # noqa
     access_forbidden,
     attr_property,
     classonly,
+    decorator,
     is_method_descriptor,
     item_property,
+    unwrap_func,
+    unwrap_func_with_partials,
     unwrap_method_descriptors,
+    update_wrapper_except_dict,
 )
 
 from .exceptions import (  # noqa
@@ -90,24 +96,26 @@ from .exceptions import (  # noqa
 from .functions import (  # noqa
     Args,
     VoidError,
+    as_async,
     constant,
     finally_,
     identity,
     is_lambda,
     is_none,
     is_not_none,
+    isinstance_of,
+    issubclass_of,
     maybe_call,
     periodically,
     raise_,
     raising,
     recurse,
     try_,
-    unwrap_func,
-    unwrap_func_with_partials,
     void,
 )
 
 from .imports import (  # noqa
+    can_import,
     import_all,
     import_module,
     import_module_attr,
@@ -123,8 +131,10 @@ from .iterables import (  # noqa
     asrange,
     exhaust,
     ilen,
+    itergen,
     peek,
     prodrange,
+    renumerate,
     take,
 )
 

omlish/lang/cached.py

@@ -11,8 +11,8 @@ import typing as ta
 
 from .contextmanagers import DefaultLockable
 from .contextmanagers import default_lock
-from .functions import unwrap_func
-from .functions import unwrap_func_with_partials
+from .descriptors import unwrap_func
+from .descriptors import unwrap_func_with_partials
 
 
 P = ta.ParamSpec('P')