omlish 0.0.0.dev1__py3-none-any.whl

omlish/inject/impl/scopes.py

@@ -0,0 +1,198 @@
+import abc
+import contextlib
+import threading
+import typing as ta
+
+from ... import check
+from ... import dataclasses as dc
+from ... import lang
+from ..bindings import Binding
+from ..elements import Elements
+from ..elements import as_elements
+from ..exceptions import ScopeAlreadyOpenException
+from ..exceptions import ScopeNotOpenException
+from ..injector import Injector
+from ..keys import Key
+from ..providers import Provider
+from ..providers import fn
+from ..scopes import ScopeSeededProvider
+from ..scopes import SeededScope
+from ..scopes import Singleton
+from ..scopes import Thread
+from ..types import Scope
+from ..types import Unscoped
+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:
+    injector_ = lang.proxy_import('.injector', __package__)
+
+
+class ScopeImpl(lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def scope(self) -> Scope:
+        raise NotImplementedError
+
+    def auto_elements(self) -> Elements | None:
+        return None
+
+    @abc.abstractmethod
+    def provide(self, binding: BindingImpl, injector: Injector) -> ta.Any:
+        raise NotImplementedError
+
+
+class UnscopedScopeImpl(ScopeImpl, lang.Final):
+    @property
+    def scope(self) -> Unscoped:
+        return Unscoped()
+
+    def provide(self, binding: BindingImpl, injector: Injector) -> ta.Any:
+        return binding.provider.provide(injector)
+
+
+class SingletonScopeImpl(ScopeImpl, lang.Final):
+    def __init__(self) -> None:
+        super().__init__()
+        self._dct: dict[BindingImpl, ta.Any] = {}
+
+    @property
+    def scope(self) -> Singleton:
+        return Singleton()
+
+    def provide(self, binding: BindingImpl, injector: Injector) -> ta.Any:
+        try:
+            return self._dct[binding]
+        except KeyError:
+            pass
+        v = binding.provider.provide(injector)
+        self._dct[binding] = v
+        return v
+
+
+class ThreadScopeImpl(ScopeImpl, lang.Final):
+    def __init__(self) -> None:
+        super().__init__()
+        self._local = threading.local()
+
+    @property
+    def scope(self) -> Thread:
+        return Thread()
+
+    def provide(self, binding: BindingImpl, injector: Injector) -> ta.Any:
+        dct: dict[BindingImpl, ta.Any]
+        try:
+            dct = self._local.dct
+        except AttributeError:
+            dct = self._local.dct = {}
+        try:
+            return dct[binding]
+        except KeyError:
+            pass
+        v = binding.provider.provide(injector)
+        dct[binding] = v
+        return v
+
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+class ScopeSeededProviderImpl(ProviderImpl):
+    p: ScopeSeededProvider
+
+    @property
+    def providers(self) -> ta.Iterable[Provider]:
+        return (self.p,)
+
+    def provide(self, injector: Injector) -> ta.Any:
+        ii = check.isinstance(injector, injector_.InjectorImpl)
+        ssi = check.isinstance(ii.get_scope_impl(self.p.ss), SeededScopeImpl)
+        return ssi.must_state().seeds[self.p.key]
+
+
+PROVIDER_IMPLS_BY_PROVIDER[ScopeSeededProvider] = ScopeSeededProviderImpl
+
+
+class SeededScopeImpl(ScopeImpl):
+    @dc.dataclass(frozen=True)
+    class State:
+        seeds: dict[Key, ta.Any]
+        prvs: dict[BindingImpl, ta.Any] = dc.field(default_factory=dict)
+
+    def __init__(self, ss: SeededScope) -> None:
+        super().__init__()
+        self._ss = check.isinstance(ss, SeededScope)
+        self._st: SeededScopeImpl.State | None = None
+
+    @property
+    def scope(self) -> SeededScope:
+        return self._ss
+
+    def must_state(self) -> 'SeededScopeImpl.State':
+        if (st := self._st) is None:
+            raise ScopeNotOpenException(self._ss)
+        return st
+
+    class Manager(SeededScope.Manager, lang.Final):
+        def __init__(self, ss: SeededScope, i: Injector) -> None:
+            super().__init__()
+            self._ss = check.isinstance(ss, SeededScope)
+            ii = check.isinstance(i, injector_.InjectorImpl)
+            self._ssi = check.isinstance(ii.get_scope_impl(self._ss), SeededScopeImpl)
+
+        @contextlib.contextmanager
+        def __call__(self, seeds: ta.Mapping[Key, ta.Any]) -> ta.Generator[None, None, None]:
+            try:
+                if self._ssi._st is not None:
+                    raise ScopeAlreadyOpenException(self._ss)
+                self._ssi._st = SeededScopeImpl.State(dict(seeds))
+                yield
+            finally:
+                if self._ssi._st is None:
+                    raise ScopeNotOpenException(self._ss)
+                self._ssi._st = None
+
+    def auto_elements(self) -> Elements:
+        return as_elements(
+            Binding(
+                Key(SeededScope.Manager, tag=self._ss),
+                fn(lang.typed_partial(SeededScopeImpl.Manager, ss=self._ss)),
+                scope=Singleton(),
+            ),
+        )
+
+    def provide(self, binding: BindingImpl, injector: Injector) -> ta.Any:
+        st = self.must_state()
+        try:
+            return st.prvs[binding]
+        except KeyError:
+            pass
+        v = binding.provider.provide(injector)
+        st.prvs[binding] = v
+        return v
+
+
+##
+
+
+SCOPE_IMPLS_BY_SCOPE: dict[type[Scope], ta.Callable[..., ScopeImpl]] = {
+    Unscoped: lambda _: UnscopedScopeImpl(),
+    Singleton: lambda _: SingletonScopeImpl(),
+    Thread: lambda _: ThreadScopeImpl(),
+    SeededScope: lambda s: SeededScopeImpl(s),
+}
+
+
+def make_scope_impl(s: Scope) -> ScopeImpl:
+    try:
+        fac = SCOPE_IMPLS_BY_SCOPE[type(s)]
+    except KeyError:
+        pass
+    else:
+        return fac(s)
+
+    raise TypeError(s)

omlish/inject/injector.py

@@ -0,0 +1,40 @@
+import abc
+import typing as ta
+
+from .. import lang
+from .elements import Elements
+from .inspect import KwargsTarget
+from .keys import Key
+
+_impl = lang.proxy_import('.impl.injector', __package__)
+
+
+T = ta.TypeVar('T')
+
+
+class Injector(lang.Abstract):
+    @abc.abstractmethod
+    def try_provide(self, key: ta.Any) -> lang.Maybe[ta.Any]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def provide(self, key: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def provide_kwargs(self, kt: KwargsTarget) -> ta.Mapping[str, ta.Any]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def inject(self, obj: ta.Any) -> ta.Any:
+        raise NotImplementedError
+
+    def __getitem__(
+            self,
+            target: ta.Union[Key[T], type[T]],
+    ) -> T:
+        return self.provide(target)
+
+
+def create_injector(es: Elements) -> Injector:
+    return _impl.create_injector(es)

omlish/inject/inspect.py

@@ -0,0 +1,14 @@
+import typing as ta
+
+from .keys import Key
+
+
+class Kwarg(ta.NamedTuple):
+    name: str
+    key: Key
+    has_default: bool
+
+
+class KwargsTarget(ta.NamedTuple):
+    obj: ta.Any
+    kwargs: ta.Sequence[Kwarg]

omlish/inject/keys.py

@@ -0,0 +1,43 @@
+import inspect
+import typing as ta
+
+from .. import dataclasses as dc
+from .. import lang
+
+
+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)
+
+
+##
+
+
+def as_key(o: ta.Any) -> Key:
+    if 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)

omlish/inject/managed.py

@@ -0,0 +1,24 @@
+"""
+TODO:
+ - proper ManagedProvider[Impl], DeferringProvider[Impl], closing (-> Deferring('close'))
+"""
+import contextlib
+import typing as ta
+
+from .eagers import eager
+from .elements import Elements
+from .elements import as_elements
+from .injector import Injector
+from .injector import create_injector
+from .scopes import singleton
+
+
+@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),
+    ))
+    with i[contextlib.ExitStack]:
+        yield i

omlish/inject/overrides.py

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

omlish/inject/private.py

@@ -0,0 +1,29 @@
+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
+
+
+@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))
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
+class Private(Element, lang.Final):
+    elements: Elements
+
+
+def private(es: Elements) -> Element:
+    return Private(check.isinstance(es, Elements))

omlish/inject/providers.py

@@ -0,0 +1,111 @@
+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)
+
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+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: ta.Optional[Cls] = _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)
+
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+class CtorProvider(Provider):
+    cls: 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)
+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: ta.Optional[Cls] = _Missing) -> Provider:
+    if cls is _Missing:
+        cls = type(v)
+    return ConstProvider(v, cls)
+
+
+##
+
+
+@dc.dataclass(frozen=True, eq=False)
+class LinkProvider(Provider):
+    k: Key
+
+    def provided_cls(self) -> Cls | None:
+        return None
+
+
+def link(k: ta.Any) -> Provider:
+    return LinkProvider(as_key(k))

omlish/inject/proxy.py

@@ -0,0 +1,48 @@
+import typing as ta
+
+from .. import lang
+from .. import check
+
+
+@lang.cached_function
+def _cyclic_dependency_proxy() -> tuple[type, ta.Callable[[ta.Any, ta.Any], None]]:
+    import wrapt  # noqa
+
+    class _CyclicDependencyPlaceholder(lang.Final):
+
+        def __init__(self, cls: ta.Any) -> None:
+            super().__init__()
+            self.__cls = cls
+
+        def __repr__(self) -> str:
+            return f'{type(self).__name__}({self.__cls!r})'
+
+    class _CyclicDependencyProxy(wrapt.ObjectProxy, lang.Final):  # noqa
+
+        def __init__(self, cls):
+            super().__init__(_CyclicDependencyPlaceholder(cls))
+            if isinstance(cls, type):
+                self._self__class__ = cls
+
+        def __repr__(self) -> str:
+            return f'_CyclicDependencyProxy({self.__wrapped__!r})'
+
+        def __getattribute__(self, att):
+            if att == '__class__':
+                try:
+                    return object.__getattribute__(self, '_self__class__')  # noqa
+                except AttributeError:
+                    pass
+            return object.__getattribute__(self, att)  # noqa
+
+    def set(prox, obj):
+        check.state(type(prox) is _CyclicDependencyProxy)
+        check.not_isinstance(obj, _CyclicDependencyPlaceholder)
+        check.isinstance(prox.__wrapped__, _CyclicDependencyPlaceholder)
+        if hasattr(prox, '_self__class__'):
+            check.issubclass(type(obj), prox._self__class__)
+        prox.__wrapped__ = obj
+        if hasattr(prox, '_self__class__'):
+            del prox._self__class__
+
+    return (_CyclicDependencyProxy, set)  # noqa

omlish/inject/scopes.py

@@ -0,0 +1,84 @@
+import abc
+import contextlib
+import typing as ta
+
+from .. import check
+from .. import dataclasses as dc
+from .. import lang
+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):
+    scope: Scope = dc.xfield(coerce=check.of_isinstance(Scope))
+
+
+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())
+
+
+class Thread(Scope, lang.Singleton, lang.Final):
+    pass
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+@dc.extra_params(cache_hash=True)
+class SeededScope(Scope, lang.Final):
+    tag: ta.Any = dc.xfield(coerce=check.not_none)
+
+    class Manager(lang.Abstract):
+        @abc.abstractmethod
+        def __call__(self, seeds: ta.Mapping[Key, ta.Any]) -> ta.ContextManager[None]:
+            raise NotImplementedError
+
+
+@dc.dataclass(frozen=True, eq=False)
+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 bind_scope_seed(ss: SeededScope, k: ta.Any) -> Element:
+    k = as_key(k)
+    return Binding(k, ScopeSeededProvider(ss, k))
+
+
+@contextlib.contextmanager
+def enter_seeded_scope(
+        i: injector_.Injector,
+        ss: SeededScope,
+        keys: ta.Mapping[Key, ta.Any],
+) -> ta.Generator[None, None, None]:
+    with i.provide(Key(SeededScope.Manager, tag=ss))(keys):
+        yield

omlish/inject/types.py

@@ -0,0 +1,21 @@
+import typing as ta
+
+from .. import lang
+
+
+##
+
+
+Cls = type | ta.NewType
+
+
+##
+
+
+class Scope(lang.Abstract):
+    def __repr__(self) -> str:
+        return type(self).__name__
+
+
+class Unscoped(Scope, lang.Singleton, lang.Final):
+    pass