omlish 0.0.0.dev1__py3-none-any.whl

omlish/inject/impl/elements.py

@@ -0,0 +1,154 @@
+"""
+Scopes in general:
+ - clearly some notion of 'activeness for a given request'
+
+Overrides + Scopes:
+ -
+
+Multi's + Scopes:
+ - scope on a multi vs each element?
+
+Element Types:
+ - Binding
+ - Eager
+ - Overrides
+ - Expose
+ - Private
+ - ScopeSeed
+"""
+import typing as ta
+
+from ... import check
+from ... import collections as col
+from ... import lang
+from ..bindings import Binding
+from ..eagers import Eager
+from ..elements import Element
+from ..elements import Elements
+from ..exceptions import DuplicateKeyException
+from ..keys import Key
+from ..overrides import Overrides
+from ..private import Expose
+from ..private import Private
+from ..scopes import ScopeBinding
+from .bindings import BindingImpl
+from .providers import MultiProviderImpl
+from .providers import make_provider_impl
+from .scopes import make_scope_impl
+
+if ta.TYPE_CHECKING:
+    from . import private as private_
+else:
+    private_ = lang.proxy_import('.private', __package__)
+
+
+ElementT = ta.TypeVar('ElementT', bound=Element)
+
+
+class ElementCollection(lang.Final):
+    def __init__(self, es: Elements) -> None:
+        super().__init__()
+
+        self._es = check.isinstance(es, Elements)
+
+        self._private_infos: ta.MutableMapping[Private, 'private_.PrivateInfo'] | None = None
+
+    ##
+
+    def _get_private_info(self, p: Private) -> 'private_.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)
+            return ec
+
+    ##
+
+    def _build_raw_element_multimap(
+            self,
+            es: ta.Iterable[Element],
+            out: dict[Key | None, list[Element]] | None = None,
+    ) -> dict[Key | None, list[Element]]:
+        if out is None:
+            out = {}
+
+        def add(k: Key | None, *e: Element) -> None:
+            out.setdefault(k, []).extend(e)
+
+        for e in es:
+            if 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, Overrides):
+                ovr = self._build_raw_element_multimap(e.ovr)
+                src = self._build_raw_element_multimap(e.src)
+                for k, b in src.items():
+                    try:
+                        bs = ovr[k]
+                    except KeyError:
+                        bs = src[k]
+                    add(k, *bs)
+
+            else:
+                raise TypeError(e)
+
+        return out
+
+    @lang.cached_function
+    def element_multimap(self) -> ta.Mapping[Key | None, ta.Sequence[Element]]:
+        return self._build_raw_element_multimap(self._es)
+
+    @lang.cached_function
+    def elements_of_type(self, *tys: type[ElementT]) -> ta.Sequence[ElementT]:
+        return tuple(e for es in self.element_multimap().values() for e in es if isinstance(e, tys))  # noqa
+
+    ##
+
+    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:
+                    raise DuplicateKeyException(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
+
+        return pm
+
+    @lang.cached_function
+    def binding_impl_map(self) -> ta.Mapping[Key, BindingImpl]:
+        return self._build_binding_impl_map(self.element_multimap())

omlish/inject/impl/injector.py

@@ -0,0 +1,182 @@
+"""
+TODO:
+ - 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
+"""
+import contextlib
+import typing as ta
+import weakref
+
+from ... import check
+from ... import lang
+from ..eagers import Eager
+from ..elements import Elements
+from ..exceptions import CyclicDependencyException
+from ..exceptions import UnboundKeyException
+from ..injector import Injector
+from ..inspect import KwargsTarget
+from ..keys import Key
+from ..keys import as_key
+from ..scopes import ScopeBinding
+from ..scopes import Singleton
+from ..scopes import Thread
+from ..types import Scope
+from ..types import Unscoped
+from .elements import ElementCollection
+from .inspect import build_kwargs_target
+from .scopes import ScopeImpl
+from .scopes import make_scope_impl
+
+
+DEFAULT_SCOPES: list[Scope] = [
+    Unscoped(),
+    Singleton(),
+    Thread(),
+]
+
+
+class InjectorImpl(Injector, lang.Final):
+    def __init__(self, ec: ElementCollection, p: ta.Optional['InjectorImpl'] = None) -> None:
+        super().__init__()
+
+        self._ec = check.isinstance(ec, ElementCollection)
+        self._p: ta.Optional[InjectorImpl] = check.isinstance(p, (InjectorImpl, None))
+
+        self._internal_consts: dict[Key, ta.Any] = {
+            Key(Injector): self,
+        }
+
+        self._bim = ec.binding_impl_map()
+
+        self._cs: weakref.WeakSet[InjectorImpl] | None = None
+        self._root: InjectorImpl = p._root if p is not None else self
+
+        self.__cur_req: InjectorImpl._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
+        }
+
+        self._instantiate_eagers()
+
+    _root: 'InjectorImpl'
+
+    def _instantiate_eagers(self) -> None:
+        for e in self._ec.elements_of_type(Eager):
+            self.provide(e.key)
+
+    def get_scope_impl(self, sc: Scope) -> ScopeImpl:
+        return self._scopes[sc]
+
+    def create_child(self, ec: ElementCollection) -> Injector:
+        c = InjectorImpl(ec, self)
+        if self._cs is None:
+            self._cs = weakref.WeakSet()
+        self._cs.add(c)
+        return c
+
+    class _Request:
+        def __init__(self, injector: 'InjectorImpl') -> None:
+            super().__init__()
+            self._injector = injector
+            self._provisions: dict[Key, ta.Any] = {}
+            self._seen_keys: set[Key] = set()
+
+        def handle_key(self, key: Key) -> lang.Maybe:
+            try:
+                return lang.just(self._provisions[key])
+            except KeyError:
+                pass
+            if key in self._seen_keys:
+                raise CyclicDependencyException(key)
+            self._seen_keys.add(key)
+            return lang.empty()
+
+        def handle_provision(self, key: Key, v: ta.Any) -> None:
+            check.in_(key, self._seen_keys)
+            check.not_in(key, self._provisions)
+            self._provisions[key] = v
+
+        def __enter__(self: ta.Self) -> ta.Self:
+            return self
+
+        def __exit__(self, *exc) -> None:
+            pass
+
+    @contextlib.contextmanager
+    def _current_request(self) -> ta.Generator[_Request, None, None]:
+        if (cr := self.__cur_req) is not None:
+            yield cr
+            return
+
+        with self._Request(self) as cr:
+            try:
+                self.__cur_req = cr
+                yield cr
+            finally:
+                self.__cur_req = None
+
+    def try_provide(self, key: ta.Any) -> lang.Maybe[ta.Any]:
+        key = as_key(key)
+
+        with self._current_request() as cr:
+            ic = self._internal_consts.get(key)
+            if ic is not None:
+                return lang.just(ic)
+
+            if (rv := cr.handle_key(key)).present:
+                return rv
+
+            bi = self._bim.get(key)
+            if bi is not None:
+                sc = self._scopes[bi.scope]
+                v = sc.provide(bi, self)
+                cr.handle_provision(key, v)
+                return lang.just(v)
+
+            if self._p is not None:
+                pv = self._p.try_provide(key)
+                if pv is not None:
+                    return pv
+
+            return lang.empty()
+
+    def provide(self, key: ta.Any) -> ta.Any:
+        v = self.try_provide(key)
+        if v.present:
+            return v.must()
+        raise UnboundKeyException(key)
+
+    def provide_kwargs(self, kt: KwargsTarget) -> ta.Mapping[str, ta.Any]:
+        ret: dict[str, ta.Any] = {}
+        for kw in kt.kwargs:
+            if kw.has_default:
+                if not (mv := self.try_provide(kw.key)).present:
+                    continue
+                v = mv.must()
+            else:
+                v = self.provide(kw.key)
+            ret[kw.name] = v
+        return ret
+
+    def inject(self, obj: ta.Any) -> ta.Any:
+        if isinstance(obj, KwargsTarget):
+            obj, kt = obj.obj, obj
+        else:
+            kt = build_kwargs_target(obj)
+        kws = self.provide_kwargs(kt)
+        # FIXME: still 'injecting' (as in has a req) if ctor needs and uses Injector
+        return obj(**kws)
+
+
+def create_injector(es: Elements) -> Injector:
+    return InjectorImpl(ElementCollection(es))

omlish/inject/impl/inspect.py

@@ -0,0 +1,98 @@
+"""
+TODO:
+ - cache kwarg_keys
+ - tag annotations? x: ta.Annotated[int, inj.Tag('foo')]
+ - tag decorator - @inj.tag(x='foo')
+ - *unpack optional here*
+"""
+import inspect
+import types
+import typing as ta
+import weakref
+
+from ... import reflect as rfl
+from ..exceptions import DuplicateKeyException
+from ..inspect import Kwarg
+from ..inspect import KwargsTarget
+from ..keys import Key
+from ..keys import as_key
+from ..keys import tag
+
+
+P = ta.ParamSpec('P')
+R = ta.TypeVar('R')
+
+
+_signature_cache: ta.MutableMapping[ta.Any, inspect.Signature] = weakref.WeakKeyDictionary()
+
+
+def signature(obj: ta.Any) -> inspect.Signature:
+    try:
+        return _signature_cache[obj]
+    except TypeError:
+        return inspect.signature(obj)
+    except KeyError:
+        pass
+    sig = inspect.signature(obj)
+    _signature_cache[obj] = sig
+    return sig
+
+
+_tags: ta.MutableMapping[ta.Any, dict[str, ta.Any]] = weakref.WeakKeyDictionary()
+
+
+def tags(**kwargs: ta.Any) -> ta.Callable[[ta.Callable[P, R]], ta.Callable[P, R]]:
+    def inner(obj):
+        _tags[obj] = kwargs
+        return obj
+    return inner
+
+
+def build_kwargs_target(
+        obj: ta.Any,
+        *,
+        skip_args: int = 0,
+        skip_kwargs: ta.Optional[ta.Iterable[ta.Any]] = None,
+        raw_optional: bool = False,
+) -> KwargsTarget:
+    sig = signature(obj)
+    tags = _tags.get(obj)
+
+    seen: set[Key] = set(map(as_key, skip_kwargs)) if skip_kwargs is not None else set()
+    kws: list[Kwarg] = []
+    for p in list(sig.parameters.values())[skip_args:]:
+        if p.annotation is inspect.Signature.empty:
+            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):
+            raise TypeError(sig)
+
+        ann = p.annotation
+        if (
+                not raw_optional and
+                isinstance(rf := rfl.type_(ann), rfl.Union) and
+                len(rf.args) == 2   # noqa
+                and types.NoneType in rf.args
+        ):
+            [ann] = [a for a in rf.args if a is not types.NoneType]
+
+        k = as_key(ann)
+        if tags is not None and (pt := tags.get(p.name)) is not None:
+            k = tag(k, pt)
+
+        if k in seen:
+            raise DuplicateKeyException(k)
+        seen.add(k)
+
+        kws.append(Kwarg(
+            p.name,
+            k,
+            p.default is not inspect.Parameter.empty,
+        ))
+
+    return KwargsTarget(
+        obj,
+        kws,
+    )

omlish/inject/impl/private.py

@@ -0,0 +1,109 @@
+"""
+TODO:
+ - add origin to Id
+"""
+import itertools
+import typing as ta
+
+from ... import cached
+from ... import check
+from ... import dataclasses as dc
+from ... import lang
+from ..bindings import Binding
+from ..eagers import Eager
+from ..elements import Element
+from ..injector import Injector
+from ..keys import Key
+from ..private import Expose
+from ..private import Private
+from ..providers import Provider
+from ..scopes import Singleton
+from .elements import ElementCollection
+from .injector import InjectorImpl
+from .providers import InternalProvider
+from .providers import ProviderImpl
+
+
+##
+
+
+_PRIVATE_COUNT = itertools.count()
+
+
+@dc.dataclass(frozen=True)
+class PrivateInjectorId(lang.Final):
+    id: int
+
+
+##
+
+
+@dc.dataclass(eq=False)
+class PrivateInjectorProviderImpl(ProviderImpl, lang.Final):
+    id: PrivateInjectorId
+    ec: ElementCollection
+
+    @property
+    def providers(self) -> ta.Iterable[Provider]:
+        return ()
+
+    def provide(self, injector: Injector) -> ta.Any:
+        return check.isinstance(injector, InjectorImpl).create_child(self.ec)
+
+
+##
+
+
+@dc.dataclass(eq=False)
+class ExposedPrivateProviderImpl(ProviderImpl, lang.Final):
+    pik: Key
+    k: Key
+
+    @property
+    def providers(self) -> ta.Iterable[Provider]:
+        return ()
+
+    def provide(self, injector: Injector) -> ta.Any:
+        pi = injector.provide(self.pik)
+        return pi.provide(self.k)
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class PrivateInfo(lang.Final):
+    owner: ElementCollection
+    p: Private
+
+    @cached.property
+    def id(self) -> PrivateInjectorId:
+        return PrivateInjectorId(next(_PRIVATE_COUNT))
+
+    @cached.property
+    def pik(self) -> Key:
+        return Key(InjectorImpl, tag=self.id)
+
+    @cached.function
+    def element_collection(self) -> ElementCollection:
+        return ElementCollection(self.p.elements)
+
+    ##
+
+    @cached.function
+    def private_provider_impl(self) -> PrivateInjectorProviderImpl:
+        return PrivateInjectorProviderImpl(self.id, self.element_collection())
+
+    @cached.function
+    def exposed_provider_impls(self) -> ta.Sequence[ExposedPrivateProviderImpl]:
+        exs = self.element_collection().elements_of_type(Expose)
+        return [ExposedPrivateProviderImpl(self.pik, ex.key) for ex in exs]
+
+    @cached.function
+    def owner_elements(self) -> ta.Iterable[Element]:
+        lst: list[Element] = [
+            Binding(self.pik, InternalProvider(self.private_provider_impl()), Singleton()),
+            Eager(self.pik),
+            *(Binding(ep.k, InternalProvider(ep)) for ep in self.exposed_provider_impls()),
+        ]
+        return lst

omlish/inject/impl/providers.py

@@ -0,0 +1,132 @@
+"""
+TODO:
+ - required_keys
+"""
+import abc
+import typing as ta
+
+from .. import Cls
+from ... import check
+from ... import dataclasses as dc
+from ... import lang
+from ..injector import Injector
+from ..inspect import KwargsTarget
+from ..providers import ConstProvider
+from ..providers import CtorProvider
+from ..providers import FnProvider
+from ..providers import LinkProvider
+from ..providers import Provider
+from .inspect import build_kwargs_target
+
+
+class ProviderImpl(lang.Abstract):
+    @property
+    @abc.abstractmethod
+    def providers(self) -> ta.Iterable[Provider]:
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def provide(self, injector: Injector) -> ta.Any:
+        raise NotImplementedError
+
+
+@dc.dataclass(frozen=True, eq=False)
+class InternalProvider(Provider):
+    impl: ProviderImpl
+
+    def provided_cls(self) -> Cls | None:
+        raise TypeError
+
+
+@dc.dataclass(frozen=True, eq=False)
+class CallableProviderImpl(ProviderImpl, lang.Final):
+    p: FnProvider | CtorProvider
+    kt: KwargsTarget
+
+    @property
+    def providers(self) -> ta.Iterable[Provider]:
+        return (self.p,)
+
+    def provide(self, injector: Injector) -> ta.Any:
+        return injector.inject(self.kt)
+
+
+@dc.dataclass(frozen=True, eq=False)
+class ConstProviderImpl(ProviderImpl, lang.Final):
+    p: ConstProvider
+
+    @property
+    def providers(self) -> ta.Iterable[Provider]:
+        return (self.p,)
+
+    def provide(self, injector: Injector) -> ta.Any:
+        return self.p.v
+
+
+@dc.dataclass(frozen=True, eq=False)
+class LinkProviderImpl(ProviderImpl, lang.Final):
+    p: LinkProvider
+
+    @property
+    def providers(self) -> ta.Iterable[Provider]:
+        return (self.p,)
+
+    def provide(self, injector: Injector) -> ta.Any:
+        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)),
+    ConstProvider: ConstProviderImpl,
+    LinkProvider: LinkProviderImpl,
+    InternalProvider: lambda p: p.impl,
+}
+
+
+def make_provider_impl(p: Provider) -> ProviderImpl:
+    try:
+        fac = PROVIDER_IMPLS_BY_PROVIDER[type(p)]
+    except KeyError:
+        pass
+    else:
+        return fac(p)
+
+    raise TypeError(p)