python-injection 0.24.0__tar.gz → 0.25.1__tar.gz

{python_injection-0.24.0 → python_injection-0.25.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.24.0
+Version: 0.25.1
 Summary: Fast and easy dependency injection framework.
 Project-URL: Repository, https://github.com/100nm/python-injection
 Author: remimd

{python_injection-0.24.0 → python_injection-0.25.1}/injection/__init__.pyi

@@ -9,8 +9,9 @@ from ._core.asfunction import AsFunctionWrappedType as _AsFunctionWrappedType
 from ._core.common.invertible import Invertible as _Invertible
 from ._core.common.type import InputType as _InputType
 from ._core.common.type import TypeInfo as _TypeInfo
-from ._core.module import InjectableFactory as _InjectableFactory
-from ._core.module import ModeStr, PriorityStr
+from ._core.locator import InjectableFactory as _InjectableFactory
+from ._core.locator import ModeStr
+from ._core.module import PriorityStr
 from ._core.scope import ScopeKindStr
 
 type _Decorator[T] = Callable[[T], T]

{python_injection-0.24.0 → python_injection-0.25.1}/injection/_core/asfunction.py

@@ -23,7 +23,7 @@ def asfunction[**P, T](
         factory: Caller[..., Callable[P, T]] = module.make_injected_function(
             wp,
             threadsafe=threadsafe,
-        ).__inject_metadata__
+        ).__injection_metadata__
 
         wrapper: Callable[P, T]
 

{python_injection-0.24.0 → python_injection-0.25.1}/injection/_core/common/asynchronous.py

@@ -64,3 +64,17 @@ class SyncCaller[**P, T](Caller[P, T]):
 
     def call(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
         return self.callable(*args, **kwargs)
+
+
+@runtime_checkable
+class HiddenCaller[**P, T](Protocol):
+    __slots__ = ()
+
+    @property
+    @abstractmethod
+    def __injection_hidden_caller__(self) -> Caller[P, T]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def __call__(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
+        raise NotImplementedError

{python_injection-0.24.0 → python_injection-0.25.1}/injection/_core/common/type.py

@@ -19,8 +19,7 @@ from typing import (
     get_type_hints,
 )
 
-type TypeDef[T] = type[T] | TypeAliasType | GenericAlias
-type InputType[T] = TypeDef[T] | UnionType
+type InputType[T] = type[T] | TypeAliasType | GenericAlias | UnionType
 type TypeInfo[T] = (
     InputType[T]
     | Callable[..., T]

{python_injection-0.24.0 → python_injection-0.25.1}/injection/_core/injectables.py

@@ -122,11 +122,12 @@ class SingletonInjectable[T](Injectable[T]):
 class ScopedInjectable[R, T](Injectable[T], ABC):
     factory: Caller[..., R]
     scope_name: str
+    key: SlotKey[T] = field(default_factory=SlotKey)
     logic: CacheLogic[T] = field(default_factory=CacheLogic)
 
     @property
     def is_locked(self) -> bool:
-        return in_scope_cache(self, self.scope_name)
+        return in_scope_cache(self.key, self.scope_name)
 
     @abstractmethod
     async def abuild(self, scope: Scope) -> T:
@@ -139,12 +140,12 @@ class ScopedInjectable[R, T](Injectable[T], ABC):
     async def aget_instance(self) -> T:
         scope = self.__get_scope()
         factory = partial(self.abuild, scope)
-        return await self.logic.aget_or_create(scope.cache, self, factory)
+        return await self.logic.aget_or_create(scope.cache, self.key, factory)
 
     def get_instance(self) -> T:
         scope = self.__get_scope()
         factory = partial(self.build, scope)
-        return self.logic.get_or_create(scope.cache, self, factory)
+        return self.logic.get_or_create(scope.cache, self.key, factory)
 
     def unlock(self) -> None:
         if self.is_locked:
@@ -187,7 +188,7 @@ class SimpleScopedInjectable[T](ScopedInjectable[T, T]):
         return self.factory.call()
 
     def unlock(self) -> None:
-        remove_scoped_values(self, self.scope_name)
+        remove_scoped_values(self.key, self.scope_name)
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)

python_injection-0.25.1/injection/_core/locator.py

@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Awaitable, Callable, Collection, Iterable, Iterator
+from contextlib import suppress
+from dataclasses import dataclass, field
+from enum import StrEnum
+from inspect import iscoroutinefunction
+from typing import (
+    Any,
+    ContextManager,
+    Literal,
+    NamedTuple,
+    Protocol,
+    Self,
+    runtime_checkable,
+)
+from weakref import WeakKeyDictionary
+
+from injection._core.common.asynchronous import (
+    AsyncCaller,
+    Caller,
+    HiddenCaller,
+    SyncCaller,
+)
+from injection._core.common.event import Event, EventChannel, EventListener
+from injection._core.common.type import InputType
+from injection._core.injectables import Injectable
+from injection.exceptions import NoInjectable, SkipInjectable
+
+
+@dataclass(frozen=True, slots=True)
+class LocatorEvent(Event, ABC):
+    locator: Locator
+
+
+@dataclass(frozen=True, slots=True)
+class LocatorDependenciesUpdated[T](LocatorEvent):
+    classes: Collection[InputType[T]]
+    mode: Mode
+
+    def __str__(self) -> str:
+        length = len(self.classes)
+        formatted_types = ", ".join(f"`{cls}`" for cls in self.classes)
+        return (
+            f"{length} dependenc{'ies' if length > 1 else 'y'} have been "
+            f"updated{f': {formatted_types}' if formatted_types else ''}."
+        )
+
+
+type InjectableFactory[T] = Callable[[Caller[..., T]], Injectable[T]]
+
+type Recipe[**P, T] = Callable[P, T] | Callable[P, Awaitable[T]]
+
+
+class InjectionProvider(ABC):
+    __slots__ = ("__weakref__",)
+
+    @abstractmethod
+    def make_injected_function[**P, T](
+        self,
+        wrapped: Callable[P, T],
+        /,
+    ) -> Callable[P, T]:
+        raise NotImplementedError
+
+
+@runtime_checkable
+class InjectableBroker[T](Protocol):
+    __slots__ = ()
+
+    @abstractmethod
+    def get(self, provider: InjectionProvider) -> Injectable[T] | None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def request(self, provider: InjectionProvider) -> Injectable[T]:
+        raise NotImplementedError
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class DynamicInjectableBroker[T](InjectableBroker[T]):
+    injectable_factory: InjectableFactory[T]
+    recipe: Recipe[..., T]
+    cache: WeakKeyDictionary[InjectionProvider, Injectable[T]] = field(
+        default_factory=WeakKeyDictionary,
+        init=False,
+    )
+
+    def get(self, provider: InjectionProvider) -> Injectable[T] | None:
+        return self.cache.get(provider)
+
+    def request(self, provider: InjectionProvider) -> Injectable[T]:
+        with suppress(KeyError):
+            return self.cache[provider]
+
+        injectable = _make_injectable(
+            self.injectable_factory,
+            provider.make_injected_function(self.recipe),  # type: ignore[misc]
+        )
+        self.cache[provider] = injectable
+        return injectable
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class StaticInjectableBroker[T](InjectableBroker[T]):
+    value: Injectable[T]
+
+    def get(self, provider: InjectionProvider) -> Injectable[T] | None:
+        return self.value
+
+    def request(self, provider: InjectionProvider) -> Injectable[T]:
+        return self.value
+
+    @classmethod
+    def from_factory(
+        cls,
+        injectable_factory: InjectableFactory[T],
+        recipe: Recipe[..., T],
+    ) -> Self:
+        return cls(_make_injectable(injectable_factory, recipe))
+
+
+class Mode(StrEnum):
+    FALLBACK = "fallback"
+    NORMAL = "normal"
+    OVERRIDE = "override"
+
+    @property
+    def rank(self) -> int:
+        return tuple(type(self)).index(self)
+
+    @classmethod
+    def get_default(cls) -> Mode:
+        return cls.NORMAL
+
+
+type ModeStr = Literal["fallback", "normal", "override"]
+
+
+class Record[T](NamedTuple):
+    broker: InjectableBroker[T]
+    mode: Mode
+
+
+@dataclass(repr=False, eq=False, frozen=True, kw_only=True, slots=True)
+class Updater[T]:
+    classes: Collection[InputType[T]]
+    broker: InjectableBroker[T]
+    mode: Mode
+
+    def make_record(self) -> Record[T]:
+        return Record(self.broker, self.mode)
+
+
+@dataclass(repr=False, frozen=True, slots=True)
+class Locator:
+    __records: dict[InputType[Any], Record[Any]] = field(
+        default_factory=dict,
+        init=False,
+    )
+    __channel: EventChannel = field(
+        default_factory=EventChannel,
+        init=False,
+    )
+
+    def __contains__(self, cls: InputType[Any], /) -> bool:
+        return cls in self.__records
+
+    @property
+    def __brokers(self) -> frozenset[InjectableBroker[Any]]:
+        return frozenset(record.broker for record in self.__records.values())
+
+    def is_locked(self, provider: InjectionProvider) -> bool:
+        return any(
+            injectable.is_locked for injectable in self.__iter_injectables(provider)
+        )
+
+    def request[T](
+        self,
+        cls: InputType[T],
+        /,
+        provider: InjectionProvider,
+    ) -> Injectable[T]:
+        try:
+            record = self.__records[cls]
+        except KeyError as exc:
+            raise NoInjectable(cls) from exc
+        else:
+            return record.broker.request(provider)
+
+    def update[T](self, updater: Updater[T]) -> Self:
+        record = updater.make_record()
+        records = dict(self.__prepare_for_updating(updater.classes, record))
+
+        if records:
+            event = LocatorDependenciesUpdated(self, records.keys(), record.mode)
+
+            with self.dispatch(event):
+                self.__records.update(records)
+
+        return self
+
+    def unlock(self, provider: InjectionProvider) -> None:
+        for injectable in self.__iter_injectables(provider):
+            injectable.unlock()
+
+    async def all_ready(self, provider: InjectionProvider) -> None:
+        for injectable in self.__iter_injectables(provider):
+            if injectable.is_locked:
+                continue
+
+            with suppress(SkipInjectable):
+                await injectable.aget_instance()
+
+    def add_listener(self, listener: EventListener) -> Self:
+        self.__channel.add_listener(listener)
+        return self
+
+    def dispatch(self, event: Event) -> ContextManager[None]:
+        return self.__channel.dispatch(event)
+
+    def __iter_injectables(
+        self,
+        provider: InjectionProvider,
+    ) -> Iterator[Injectable[Any]]:
+        for broker in self.__brokers:
+            injectable = broker.get(provider)
+
+            if injectable is None:
+                continue
+
+            yield injectable
+
+    def __prepare_for_updating[T](
+        self,
+        classes: Iterable[InputType[T]],
+        record: Record[T],
+    ) -> Iterator[tuple[InputType[T], Record[T]]]:
+        for cls in classes:
+            try:
+                existing = self.__records[cls]
+            except KeyError:
+                ...
+            else:
+                if not self.__keep_new_record(record, existing, cls):
+                    continue
+
+            yield cls, record
+
+    @staticmethod
+    def __keep_new_record[T](
+        new: Record[T],
+        existing: Record[T],
+        cls: InputType[T],
+    ) -> bool:
+        new_mode, existing_mode = new.mode, existing.mode
+
+        if new_mode == Mode.OVERRIDE:
+            return True
+
+        elif new_mode == existing_mode:
+            raise RuntimeError(f"An injectable already exists for the class `{cls}`.")
+
+        return new_mode.rank > existing_mode.rank
+
+
+def _extract_caller[**P, T](
+    function: Callable[P, T] | Callable[P, Awaitable[T]],
+) -> Caller[P, T]:
+    if iscoroutinefunction(function):
+        return AsyncCaller(function)
+
+    elif isinstance(function, HiddenCaller):
+        return function.__injection_hidden_caller__
+
+    return SyncCaller(function)  # type: ignore[arg-type]
+
+
+def _make_injectable[T](
+    injectable_factory: InjectableFactory[T],
+    recipe: Recipe[..., T],
+) -> Injectable[T]:
+    return injectable_factory(_extract_caller(recipe))

{python_injection-0.24.0 → python_injection-0.25.1}/injection/_core/module.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
 import itertools
-from abc import ABC, abstractmethod
+from abc import ABC
 from collections import OrderedDict, deque
 from collections.abc import (
     AsyncGenerator,
     AsyncIterator,
     Awaitable,
     Callable,
-    Collection,
     Generator,
     Iterable,
     Iterator,
@@ -37,19 +36,16 @@ from typing import (
     ContextManager,
     Literal,
     NamedTuple,
-    Protocol,
     Self,
     overload,
-    runtime_checkable,
 )
 
-from type_analyzer import MatchingTypesConfig, iter_matching_types
+from type_analyzer import MatchingTypesConfig, iter_matching_types, matching_types
 
 from injection._core.common.asynchronous import (
-    AsyncCaller,
     Caller,
+    HiddenCaller,
     SimpleAwaitable,
-    SyncCaller,
 )
 from injection._core.common.event import Event, EventChannel, EventListener
 from injection._core.common.invertible import Invertible, SimpleInvertible
@@ -58,7 +54,6 @@ from injection._core.common.lazy import Lazy, alazy, lazy
 from injection._core.common.threading import get_lock
 from injection._core.common.type import (
     InputType,
-    TypeDef,
     TypeInfo,
     get_return_types,
     get_yield_hint,
@@ -74,6 +69,18 @@ from injection._core.injectables import (
     SingletonInjectable,
     TransientInjectable,
 )
+from injection._core.locator import (
+    DynamicInjectableBroker,
+    InjectableBroker,
+    InjectableFactory,
+    InjectionProvider,
+    Locator,
+    Mode,
+    ModeStr,
+    Recipe,
+    StaticInjectableBroker,
+    Updater,
+)
 from injection._core.slots import SlotKey
 from injection.exceptions import (
     ModuleError,
@@ -88,25 +95,6 @@ Events
 """
 
 
-@dataclass(frozen=True, slots=True)
-class LocatorEvent(Event, ABC):
-    locator: Locator
-
-
-@dataclass(frozen=True, slots=True)
-class LocatorDependenciesUpdated[T](LocatorEvent):
-    classes: Collection[InputType[T]]
-    mode: Mode
-
-    def __str__(self) -> str:
-        length = len(self.classes)
-        formatted_types = ", ".join(f"`{cls}`" for cls in self.classes)
-        return (
-            f"{length} dependenc{'ies' if length > 1 else 'y'} have been "
-            f"updated{f': {formatted_types}' if formatted_types else ''}."
-        )
-
-
 @dataclass(frozen=True, slots=True)
 class ModuleEvent(Event, ABC):
     module: Module
@@ -120,15 +108,17 @@ class ModuleEventProxy(ModuleEvent):
         return f"`{self.module}` has propagated an event: {self.origin}"
 
     @property
-    def history(self) -> Iterator[Event]:
-        if isinstance(self.event, ModuleEventProxy):
-            yield from self.event.history
-
-        yield self.event
+    def origin(self) -> Event:
+        reversed_proxy_history = reversed(tuple(self.proxy_history))
+        return next(reversed_proxy_history, self).event
 
     @property
-    def origin(self) -> Event:
-        return next(self.history)
+    def proxy_history(self) -> Iterator[ModuleEventProxy]:
+        event = self.event
+
+        if isinstance(event, ModuleEventProxy):
+            yield event
+            yield from event.proxy_history
 
 
 @dataclass(frozen=True, slots=True)
@@ -160,211 +150,6 @@ class ModulePriorityUpdated(ModuleEvent):
         )
 
 
-@dataclass(frozen=True, slots=True)
-class UnlockCalled(Event):
-    def __str__(self) -> str:
-        return "An `unlock` method has been called."
-
-
-"""
-Broker
-"""
-
-
-@runtime_checkable
-class Broker(Protocol):
-    __slots__ = ()
-
-    @abstractmethod
-    def __getitem__[T](self, cls: InputType[T], /) -> Injectable[T]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def __contains__(self, cls: InputType[Any], /) -> bool:
-        raise NotImplementedError
-
-    @property
-    @abstractmethod
-    def is_locked(self) -> bool:
-        raise NotImplementedError
-
-    @abstractmethod
-    def unsafe_unlocking(self) -> None:
-        raise NotImplementedError
-
-    @abstractmethod
-    async def all_ready(self) -> None:
-        raise NotImplementedError
-
-
-"""
-Locator
-"""
-
-
-class Mode(StrEnum):
-    FALLBACK = "fallback"
-    NORMAL = "normal"
-    OVERRIDE = "override"
-
-    @property
-    def rank(self) -> int:
-        return tuple(type(self)).index(self)
-
-    @classmethod
-    def get_default(cls) -> Mode:
-        return cls.NORMAL
-
-
-type ModeStr = Literal["fallback", "normal", "override"]
-
-type InjectableFactory[T] = Callable[[Caller[..., T]], Injectable[T]]
-
-
-class Record[T](NamedTuple):
-    injectable: Injectable[T]
-    mode: Mode
-
-
-@dataclass(repr=False, eq=False, frozen=True, kw_only=True, slots=True)
-class Updater[T]:
-    classes: Iterable[InputType[T]]
-    injectable: Injectable[T]
-    mode: Mode
-
-    def make_record(self) -> Record[T]:
-        return Record(self.injectable, self.mode)
-
-    @classmethod
-    def with_basics(
-        cls,
-        on: TypeInfo[T],
-        /,
-        injectable: Injectable[T],
-        mode: Mode | ModeStr,
-    ) -> Self:
-        return cls(
-            classes=get_return_types(on),
-            injectable=injectable,
-            mode=Mode(mode),
-        )
-
-
-@dataclass(repr=False, frozen=True, slots=True)
-class Locator(Broker):
-    __records: dict[InputType[Any], Record[Any]] = field(
-        default_factory=dict,
-        init=False,
-    )
-    __channel: EventChannel = field(
-        default_factory=EventChannel,
-        init=False,
-    )
-
-    def __getitem__[T](self, cls: InputType[T], /) -> Injectable[T]:
-        for key_type in self.__iter_key_types((cls,)):
-            try:
-                record = self.__records[key_type]
-            except KeyError:
-                continue
-
-            return record.injectable
-
-        raise NoInjectable(cls)
-
-    def __contains__(self, cls: InputType[Any], /) -> bool:
-        return any(
-            key_type in self.__records for key_type in self.__iter_key_types((cls,))
-        )
-
-    @property
-    def is_locked(self) -> bool:
-        return any(injectable.is_locked for injectable in self.__injectables)
-
-    @property
-    def __injectables(self) -> frozenset[Injectable[Any]]:
-        return frozenset(record.injectable for record in self.__records.values())
-
-    def update[T](self, updater: Updater[T]) -> Self:
-        record = updater.make_record()
-        key_types = self.__build_key_types(updater.classes)
-        records = dict(self.__prepare_for_updating(key_types, record))
-
-        if records:
-            event = LocatorDependenciesUpdated(self, records.keys(), record.mode)
-
-            with self.dispatch(event):
-                self.__records.update(records)
-
-        return self
-
-    def unsafe_unlocking(self) -> None:
-        for injectable in self.__injectables:
-            injectable.unlock()
-
-    async def all_ready(self) -> None:
-        for injectable in self.__injectables:
-            if injectable.is_locked:
-                continue
-
-            with suppress(SkipInjectable):
-                await injectable.aget_instance()
-
-    def add_listener(self, listener: EventListener) -> Self:
-        self.__channel.add_listener(listener)
-        return self
-
-    def dispatch(self, event: Event) -> ContextManager[None]:
-        return self.__channel.dispatch(event)
-
-    def __prepare_for_updating[T](
-        self,
-        classes: Iterable[InputType[T]],
-        record: Record[T],
-    ) -> Iterator[tuple[InputType[T], Record[T]]]:
-        for cls in classes:
-            try:
-                existing = self.__records[cls]
-            except KeyError:
-                ...
-            else:
-                if not self.__keep_new_record(record, existing, cls):
-                    continue
-
-            yield cls, record
-
-    @staticmethod
-    def __build_key_types[T](classes: Iterable[InputType[T]]) -> frozenset[TypeDef[T]]:
-        config = MatchingTypesConfig(ignore_none=True)
-        return frozenset(
-            itertools.chain.from_iterable(
-                iter_matching_types(cls, config) for cls in classes
-            )
-        )
-
-    @staticmethod
-    def __iter_key_types[T](classes: Iterable[InputType[T]]) -> Iterator[InputType[T]]:
-        config = MatchingTypesConfig(with_origin=True, with_type_alias_value=True)
-        for cls in classes:
-            yield from iter_matching_types(cls, config)
-
-    @staticmethod
-    def __keep_new_record[T](
-        new: Record[T],
-        existing: Record[T],
-        cls: InputType[T],
-    ) -> bool:
-        new_mode, existing_mode = new.mode, existing.mode
-
-        if new_mode == Mode.OVERRIDE:
-            return True
-
-        elif new_mode == existing_mode:
-            raise RuntimeError(f"An injectable already exists for the class `{cls}`.")
-
-        return new_mode.rank > existing_mode.rank
-
-
 """
 Module
 """
@@ -387,11 +172,10 @@ type ContextManagerLikeRecipe[**P, T] = (
 type GeneratorRecipe[**P, T] = (
     Callable[P, Generator[T, Any, Any]] | Callable[P, AsyncGenerator[T, Any]]
 )
-type Recipe[**P, T] = Callable[P, T] | Callable[P, Awaitable[T]]
 
 
 @dataclass(eq=False, frozen=True, slots=True)
-class Module(Broker, EventListener):
+class Module(EventListener, InjectionProvider):  # type: ignore[misc]
     name: str = field(default_factory=lambda: f"anonymous@{new_short_key()}")
     __channel: EventChannel = field(
         default_factory=EventChannel,
@@ -420,23 +204,26 @@ class Module(Broker, EventListener):
         self.__locator.add_listener(self)
 
     def __getitem__[T](self, cls: InputType[T], /) -> Injectable[T]:
-        for broker in self.__brokers:
-            with suppress(KeyError):
-                return broker[cls]
+        key_types = self.__matching_key_types(cls)
+
+        for locator in self._iter_locators():
+            for key_type in key_types:
+                with suppress(KeyError):
+                    return locator.request(key_type, self)
 
         raise NoInjectable(cls)
 
     def __contains__(self, cls: InputType[Any], /) -> bool:
-        return any(cls in broker for broker in self.__brokers)
+        key_types = self.__matching_key_types(cls)
+        return any(
+            key_type in locator
+            for locator in self._iter_locators()
+            for key_type in key_types
+        )
 
     @property
     def is_locked(self) -> bool:
-        return any(broker.is_locked for broker in self.__brokers)
-
-    @property
-    def __brokers(self) -> Iterator[Broker]:
-        yield from self.__modules
-        yield self.__locator
+        return any(locator.is_locked(self) for locator in self._iter_locators())
 
     def injectable[**P, T](
         self,
@@ -450,11 +237,13 @@ class Module(Broker, EventListener):
         mode: Mode | ModeStr = Mode.get_default(),
     ) -> Any:
         def decorator(wp: Recipe[P, T]) -> Recipe[P, T]:
-            factory = extract_caller(self.make_injected_function(wp) if inject else wp)
-            injectable = cls(factory)  # type: ignore[arg-type]
             hints = on if ignore_type_hint else (wp, on)
-            updater = Updater.with_basics(hints, injectable, mode)
-            self.update(updater)
+            broker = (
+                DynamicInjectableBroker(cls, wp)
+                if inject
+                else StaticInjectableBroker.from_factory(cls, wp)
+            )
+            self.update_from(hints, broker, mode)
             return wp
 
         return decorator(wrapped) if wrapped else decorator
@@ -505,8 +294,8 @@ class Module(Broker, EventListener):
     def should_be_injectable[T](self, wrapped: type[T] | None = None, /) -> Any:
         def decorator(wp: type[T]) -> type[T]:
             injectable = ShouldBeInjectable(wp)
-            updater = Updater.with_basics(wp, injectable, Mode.FALLBACK)
-            self.update(updater)
+            broker = StaticInjectableBroker(injectable)
+            self.update_from(wp, broker, Mode.FALLBACK)
             return wp
 
         return decorator(wrapped) if wrapped else decorator
@@ -564,8 +353,8 @@ class Module(Broker, EventListener):
         mode: Mode | ModeStr = Mode.get_default(),
     ) -> SlotKey[T]:
         injectable = ScopedSlotInjectable(cls, scope_name)
-        updater = Updater.with_basics(cls, injectable, mode)
-        self.update(updater)
+        broker = StaticInjectableBroker(injectable)
+        self.update_from(cls, broker, mode)
         return injectable.key
 
     def inject[**P, T](
@@ -630,7 +419,7 @@ class Module(Broker, EventListener):
             wrapped,
             threadsafe,
         )
-        return factory.__inject_metadata__.acall
+        return factory.__injection_metadata__.acall
 
     async def afind_instance[T](
         self,
@@ -747,7 +536,7 @@ class Module(Broker, EventListener):
             lambda instance=default: instance,
             threadsafe=threadsafe,
         )
-        metadata = function.__inject_metadata__.set_owner(cls)
+        metadata = function.__injection_metadata__.set_owner(cls)
         return SimpleAwaitable(metadata.acall)
 
     if TYPE_CHECKING:  # pragma: no cover
@@ -781,13 +570,28 @@ class Module(Broker, EventListener):
             lambda instance=default: instance,
             threadsafe=threadsafe,
         )
-        metadata = function.__inject_metadata__.set_owner(cls)
+        metadata = function.__injection_metadata__.set_owner(cls)
         return SimpleInvertible(metadata.call)
 
     def update[T](self, updater: Updater[T]) -> Self:
         self.__locator.update(updater)
         return self
 
+    def update_from[T](
+        self,
+        on: TypeInfo[T],
+        /,
+        broker: InjectableBroker[T],
+        mode: Mode | ModeStr,
+    ) -> Self:
+        updater = Updater(
+            classes=self.__build_key_types(on),
+            broker=broker,
+            mode=Mode(mode),
+        )
+        self.update(updater)
+        return self
+
     def init_modules(self, *modules: Module) -> Self:
         for module in tuple(self.__modules):
             self.stop_using(module)
@@ -857,20 +661,14 @@ class Module(Broker, EventListener):
         return self
 
     def unlock(self) -> Self:
-        event = UnlockCalled()
-
-        with self.dispatch(event, lock_bypass=True):
-            self.unsafe_unlocking()
+        for locator in self._iter_locators():
+            locator.unlock(self)
 
         return self
 
-    def unsafe_unlocking(self) -> None:
-        for broker in self.__brokers:
-            broker.unsafe_unlocking()
-
     async def all_ready(self) -> None:
-        for broker in self.__brokers:
-            await broker.all_ready()
+        for locator in self._iter_locators():
+            await locator.all_ready(self)
 
     def add_logger(self, logger: Logger) -> Self:
         self.__loggers.append(logger)
@@ -889,9 +687,8 @@ class Module(Broker, EventListener):
         return self.dispatch(self_event)
 
     @contextmanager
-    def dispatch(self, event: Event, *, lock_bypass: bool = False) -> Iterator[None]:
-        if not lock_bypass:
-            self.__check_locking()
+    def dispatch(self, event: Event) -> Iterator[None]:
+        self.__check_locking()
 
         with self.__channel.dispatch(event):
             try:
@@ -899,6 +696,12 @@ class Module(Broker, EventListener):
             finally:
                 self.__debug(event)
 
+    def _iter_locators(self) -> Iterator[Locator]:
+        for module in self.__modules:
+            yield from module._iter_locators()
+
+        yield self.__locator
+
     def __debug(self, message: object) -> None:
         for logger in self.__loggers:
             logger.debug(message)
@@ -930,6 +733,20 @@ class Module(Broker, EventListener):
     def default(cls) -> Module:
         return cls.from_name("__default__")
 
+    @staticmethod
+    def __build_key_types(input_cls: Any) -> frozenset[Any]:
+        config = MatchingTypesConfig(ignore_none=True)
+        return frozenset(
+            itertools.chain.from_iterable(
+                iter_matching_types(cls, config) for cls in get_return_types(input_cls)
+            )
+        )
+
+    @staticmethod
+    def __matching_key_types(input_cls: Any) -> tuple[Any, ...]:
+        config = MatchingTypesConfig(with_origin=True, with_type_alias_value=True)
+        return matching_types(input_cls, config)
+
 
 def mod(name: str | None = None, /) -> Module:
     if name is None:
@@ -1151,24 +968,24 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
             task()
 
 
-class InjectedFunction[**P, T](ABC):
-    __slots__ = ("__dict__", "__inject_metadata__")
+class InjectedFunction[**P, T](HiddenCaller[P, T], ABC):
+    __slots__ = ("__dict__", "__injection_metadata__")
 
-    __inject_metadata__: InjectMetadata[P, T]
+    __injection_metadata__: InjectMetadata[P, T]
 
     def __init__(self, metadata: InjectMetadata[P, T]) -> None:
         update_wrapper(self, metadata.wrapped)
-        self.__inject_metadata__ = metadata
+        self.__injection_metadata__ = metadata
 
     def __repr__(self) -> str:  # pragma: no cover
-        return repr(self.__inject_metadata__.wrapped)
+        return repr(self.__injection_metadata__.wrapped)
 
     def __str__(self) -> str:  # pragma: no cover
-        return str(self.__inject_metadata__.wrapped)
+        return str(self.__injection_metadata__.wrapped)
 
-    @abstractmethod
-    def __call__(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
-        raise NotImplementedError
+    @property
+    def __injection_hidden_caller__(self) -> Caller[P, T]:
+        return self.__injection_metadata__
 
     def __get__(
         self,
@@ -1181,7 +998,7 @@ class InjectedFunction[**P, T](ABC):
         return MethodType(self, instance)
 
     def __set_name__(self, owner: type, name: str) -> None:
-        self.__inject_metadata__.set_owner(owner)
+        self.__injection_metadata__.set_owner(owner)
 
 
 class AsyncInjectedFunction[**P, T](InjectedFunction[P, Awaitable[T]]):
@@ -1192,23 +1009,11 @@ class AsyncInjectedFunction[**P, T](InjectedFunction[P, Awaitable[T]]):
         markcoroutinefunction(self)
 
     async def __call__(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
-        return await (await self.__inject_metadata__.acall(*args, **kwargs))
+        return await (await self.__injection_metadata__.acall(*args, **kwargs))
 
 
 class SyncInjectedFunction[**P, T](InjectedFunction[P, T]):
     __slots__ = ()
 
     def __call__(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
-        return self.__inject_metadata__.call(*args, **kwargs)
-
-
-def extract_caller[**P, T](
-    function: Callable[P, T] | Callable[P, Awaitable[T]],
-) -> Caller[P, T]:
-    if iscoroutinefunction(function):
-        return AsyncCaller(function)
-
-    elif isinstance(function, InjectedFunction):
-        return function.__inject_metadata__
-
-    return SyncCaller(function)  # type: ignore[arg-type]
+        return self.__injection_metadata__.call(*args, **kwargs)

{python_injection-0.24.0 → python_injection-0.25.1}/injection/_core/scope.py

@@ -182,11 +182,11 @@ def get_scope[T](name: str, default: T | EllipsisType = ...) -> Scope | T:
     return default
 
 
-def in_scope_cache(key: Any, scope_name: str) -> bool:
+def in_scope_cache(key: SlotKey[Any], scope_name: str) -> bool:
     return any(key in scope.cache for scope in get_active_scopes(scope_name))
 
 
-def remove_scoped_values(key: Any, scope_name: str) -> None:
+def remove_scoped_values(key: SlotKey[Any], scope_name: str) -> None:
     for scope in get_active_scopes(scope_name):
         scope.cache.pop(key, None)
 
@@ -233,7 +233,7 @@ def _bind_scope(
 class Scope(Protocol):
     __slots__ = ()
 
-    cache: MutableMapping[Any, Any]
+    cache: MutableMapping[SlotKey[Any], Any]
 
     @abstractmethod
     async def aenter[T](self, context_manager: AsyncContextManager[T]) -> T:
@@ -247,7 +247,7 @@ class Scope(Protocol):
 @dataclass(repr=False, frozen=True, slots=True)
 class BaseScope[T](Scope, ABC):
     delegate: T
-    cache: MutableMapping[Any, Any] = field(
+    cache: MutableMapping[SlotKey[Any], Any] = field(
         default_factory=dict,
         init=False,
         hash=False,

python_injection-0.25.1/injection/testing/__init__.py

@@ -0,0 +1,30 @@
+from typing import Final
+
+from injection import mod
+from injection.loaders import LoadedProfile, ProfileLoader, load_profile
+
+__all__ = (
+    "TEST_PROFILE_NAME",
+    "load_test_profile",
+    "reserve_scoped_test_slot",
+    "set_test_constant",
+    "should_be_test_injectable",
+    "test_constant",
+    "test_injectable",
+    "test_scoped",
+    "test_singleton",
+)
+
+TEST_PROFILE_NAME: Final[str] = "__testing__"
+
+reserve_scoped_test_slot = mod(TEST_PROFILE_NAME).reserve_scoped_slot
+set_test_constant = mod(TEST_PROFILE_NAME).set_constant
+should_be_test_injectable = mod(TEST_PROFILE_NAME).should_be_injectable
+test_constant = mod(TEST_PROFILE_NAME).constant
+test_injectable = mod(TEST_PROFILE_NAME).injectable
+test_scoped = mod(TEST_PROFILE_NAME).scoped
+test_singleton = mod(TEST_PROFILE_NAME).singleton
+
+
+def load_test_profile(loader: ProfileLoader | None = None) -> LoadedProfile:
+    return load_profile(TEST_PROFILE_NAME, loader)

{python_injection-0.24.0 → python_injection-0.25.1}/injection/testing/__init__.pyi

@@ -3,6 +3,8 @@ from typing import Final
 from injection import Module
 from injection.loaders import LoadedProfile, ProfileLoader
 
+TEST_PROFILE_NAME: Final[str] = ...
+
 __MODULE: Final[Module] = ...
 
 reserve_scoped_test_slot = __MODULE.reserve_scoped_slot

{python_injection-0.24.0 → python_injection-0.25.1}/pyproject.toml

@@ -30,7 +30,7 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.24.0"
+version = "0.25.1"
 description = "Fast and easy dependency injection framework."
 license = "MIT"
 license-files = ["LICENSE"]

python_injection-0.24.0/injection/testing/__init__.py

@@ -1,29 +0,0 @@
-from typing import Final
-
-from injection import mod
-from injection.loaders import LoadedProfile, ProfileLoader, load_profile
-
-__all__ = (
-    "load_test_profile",
-    "reserve_scoped_test_slot",
-    "set_test_constant",
-    "should_be_test_injectable",
-    "test_constant",
-    "test_injectable",
-    "test_scoped",
-    "test_singleton",
-)
-
-_TEST_PROFILE_NAME: Final[str] = "__testing__"
-
-reserve_scoped_test_slot = mod(_TEST_PROFILE_NAME).reserve_scoped_slot
-set_test_constant = mod(_TEST_PROFILE_NAME).set_constant
-should_be_test_injectable = mod(_TEST_PROFILE_NAME).should_be_injectable
-test_constant = mod(_TEST_PROFILE_NAME).constant
-test_injectable = mod(_TEST_PROFILE_NAME).injectable
-test_scoped = mod(_TEST_PROFILE_NAME).scoped
-test_singleton = mod(_TEST_PROFILE_NAME).singleton
-
-
-def load_test_profile(loader: ProfileLoader | None = None) -> LoadedProfile:
-    return load_profile(_TEST_PROFILE_NAME, loader)