python-injection 0.23.3__tar.gz → 0.25.0__tar.gz

{python_injection-0.23.3 → python_injection-0.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.23.3
+Version: 0.25.0
 Summary: Fast and easy dependency injection framework.
 Project-URL: Repository, https://github.com/100nm/python-injection
 Author: remimd
@@ -23,6 +23,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Testing
 Classifier: Typing :: Typed
 Requires-Python: <3.15,>=3.12
+Requires-Dist: type-analyzer
 Provides-Extra: async
 Requires-Dist: anyio; extra == 'async'
 Description-Content-Type: text/markdown

{python_injection-0.23.3 → python_injection-0.25.0}/injection/_core/common/type.py

@@ -10,19 +10,16 @@ from collections.abc import (
     Iterator,
 )
 from inspect import isclass, isfunction
-from types import GenericAlias, NoneType, UnionType
+from types import GenericAlias, UnionType
 from typing import (
-    Annotated,
     Any,
     TypeAliasType,
-    Union,
     get_args,
     get_origin,
     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]
@@ -67,43 +64,3 @@ def get_yield_hint[T](
             return (arg,)
 
     return ()
-
-
-def standardize_types(
-    *types: InputType[Any],
-    with_origin: bool = False,
-    ignore_none_type: bool = False,
-) -> Iterator[TypeDef[Any]]:
-    for tp in types:
-        if tp is None or (ignore_none_type and tp is NoneType):
-            continue
-
-        origin = get_origin(tp)
-
-        if origin is Union or isinstance(tp, UnionType):
-            inner_types = get_args(tp)
-
-        elif origin is Annotated:
-            inner_types = get_args(tp)[:1]
-
-        else:
-            yield tp
-
-            if with_origin:
-                if origin is not None:
-                    yield origin
-
-                for alias in (tp, origin):
-                    if isinstance(alias, TypeAliasType):
-                        yield from standardize_types(
-                            alias.__value__,
-                            with_origin=with_origin,
-                        )
-
-            continue
-
-        yield from standardize_types(
-            *inner_types,
-            with_origin=with_origin,
-            ignore_none_type=ignore_none_type,
-        )

{python_injection-0.23.3 → python_injection-0.25.0}/injection/_core/descriptors.py

@@ -53,11 +53,7 @@ class MappedScope:
             if name == descriptor_name:
                 continue
 
-            key = self.__module.reserve_scoped_slot(
-                hint,
-                scope_name=self.__name,
-                ignore_none_type=True,
-            )
+            key = self.__module.reserve_scoped_slot(hint, scope_name=self.__name)
             yield name, key
 
     def __mapping_from(self, instance: object) -> dict[SlotKey[Any], Any]:

{python_injection-0.23.3 → python_injection-0.25.0}/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.23.3 → python_injection-0.25.0}/injection/_core/module.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import itertools
 from abc import ABC, abstractmethod
 from collections import OrderedDict, deque
 from collections.abc import (
@@ -42,6 +43,8 @@ from typing import (
     runtime_checkable,
 )
 
+from type_analyzer import MatchingTypesConfig, iter_matching_types, matching_types
+
 from injection._core.common.asynchronous import (
     AsyncCaller,
     Caller,
@@ -55,11 +58,9 @@ 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,
-    standardize_types,
 )
 from injection._core.injectables import (
     AsyncCMScopedInjectable,
@@ -118,15 +119,25 @@ 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 is_duplicate(self) -> bool:
+        module, origin = self.module, self.origin
+        return any(
+            module is event.module and origin is event.origin
+            for event in self.proxy_history
+        )
 
     @property
     def origin(self) -> Event:
-        return next(self.history)
+        reversed_proxy_history = reversed(tuple(self.proxy_history))
+        return next(reversed_proxy_history, self).event
+
+    @property
+    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,8 +171,10 @@ class ModulePriorityUpdated(ModuleEvent):
 
 @dataclass(frozen=True, slots=True)
 class UnlockCalled(Event):
+    module: Module
+
     def __str__(self) -> str:
-        return "An `unlock` method has been called."
+        return f"`{self.module}.unlock` has been called."
 
 
 """
@@ -229,27 +242,10 @@ class Updater[T]:
     classes: Iterable[InputType[T]]
     injectable: Injectable[T]
     mode: Mode
-    ignore_none_type: bool
 
     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,
-        ignore_none_type: bool = False,
-    ) -> Self:
-        return cls(
-            classes=get_return_types(on),
-            injectable=injectable,
-            mode=Mode(mode),
-            ignore_none_type=ignore_none_type,
-        )
-
 
 @dataclass(repr=False, frozen=True, slots=True)
 class Locator(Broker):
@@ -263,21 +259,15 @@ class Locator(Broker):
     )
 
     def __getitem__[T](self, cls: InputType[T], /) -> Injectable[T]:
-        for input_class in self.__standardize_inputs((cls,)):
-            try:
-                record = self.__records[input_class]
-            except KeyError:
-                continue
-
+        try:
+            record = self.__records[cls]
+        except KeyError as exc:
+            raise NoInjectable(cls) from exc
+        else:
             return record.injectable
 
-        raise NoInjectable(cls)
-
     def __contains__(self, cls: InputType[Any], /) -> bool:
-        return any(
-            input_class in self.__records
-            for input_class in self.__standardize_inputs((cls,))
-        )
+        return cls in self.__records
 
     @property
     def is_locked(self) -> bool:
@@ -289,8 +279,7 @@ class Locator(Broker):
 
     def update[T](self, updater: Updater[T]) -> Self:
         record = updater.make_record()
-        classes = self.__reduce_classes(updater)
-        records = dict(self.__prepare_for_updating(classes, record))
+        records = dict(self.__prepare_for_updating(updater.classes, record))
 
         if records:
             event = LocatorDependenciesUpdated(self, records.keys(), record.mode)
@@ -351,21 +340,6 @@ class Locator(Broker):
 
         return new_mode.rank > existing_mode.rank
 
-    @staticmethod
-    def __reduce_classes[T](updater: Updater[T]) -> frozenset[TypeDef[T]]:
-        return frozenset(
-            standardize_types(
-                *updater.classes,
-                ignore_none_type=updater.ignore_none_type,
-            )
-        )
-
-    @staticmethod
-    def __standardize_inputs[T](
-        classes: Iterable[InputType[T]],
-    ) -> Iterator[InputType[T]]:
-        return standardize_types(*classes, with_origin=True)
-
 
 """
 Module
@@ -422,23 +396,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 broker in self._iter_brokers():
+            for key_type in key_types:
+                with suppress(KeyError):
+                    return broker[key_type]
 
         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 broker
+            for broker in self._iter_brokers()
+            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(broker.is_locked for broker in self._iter_brokers())
 
     def injectable[**P, T](
         self,
@@ -455,8 +432,7 @@ class Module(Broker, EventListener):
             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)
+            self.update_from(hints, injectable, mode)
             return wp
 
         return decorator(wrapped) if wrapped else decorator
@@ -507,8 +483,7 @@ 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)
+            self.update_from(wp, injectable, Mode.FALLBACK)
             return wp
 
         return decorator(wrapped) if wrapped else decorator
@@ -564,11 +539,9 @@ class Module(Broker, EventListener):
         scope_name: str,
         *,
         mode: Mode | ModeStr = Mode.get_default(),
-        ignore_none_type: bool = False,
     ) -> SlotKey[T]:
         injectable = ScopedSlotInjectable(cls, scope_name)
-        updater = Updater.with_basics(cls, injectable, mode, ignore_none_type)
-        self.update(updater)
+        self.update_from(cls, injectable, mode)
         return injectable.key
 
     def inject[**P, T](
@@ -791,6 +764,21 @@ class Module(Broker, EventListener):
         self.__locator.update(updater)
         return self
 
+    def update_from[T](
+        self,
+        on: TypeInfo[T],
+        /,
+        injectable: Injectable[T],
+        mode: Mode | ModeStr,
+    ) -> Self:
+        updater = Updater(
+            classes=self.__build_key_types(on),
+            injectable=injectable,
+            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)
@@ -860,7 +848,7 @@ class Module(Broker, EventListener):
         return self
 
     def unlock(self) -> Self:
-        event = UnlockCalled()
+        event = UnlockCalled(self)
 
         with self.dispatch(event, lock_bypass=True):
             self.unsafe_unlocking()
@@ -868,11 +856,11 @@ class Module(Broker, EventListener):
         return self
 
     def unsafe_unlocking(self) -> None:
-        for broker in self.__brokers:
+        for broker in self._iter_brokers():
             broker.unsafe_unlocking()
 
     async def all_ready(self) -> None:
-        for broker in self.__brokers:
+        for broker in self._iter_brokers():
             await broker.all_ready()
 
     def add_logger(self, logger: Logger) -> Self:
@@ -887,8 +875,12 @@ class Module(Broker, EventListener):
         self.__channel.remove_listener(listener)
         return self
 
-    def on_event(self, event: Event, /) -> ContextManager[None]:
+    def on_event(self, event: Event, /) -> ContextManager[None] | None:
         self_event = ModuleEventProxy(self, event)
+
+        if self_event.is_duplicate:
+            return None
+
         return self.dispatch(self_event)
 
     @contextmanager
@@ -902,6 +894,20 @@ class Module(Broker, EventListener):
             finally:
                 self.__debug(event)
 
+    def _iter_brokers(self, visited: set[Module] | None = None, /) -> Iterator[Broker]:
+        if visited is None:
+            visited = set()
+
+        if self in visited:
+            return
+
+        visited.add(self)
+
+        for module in self.__modules:
+            yield from module._iter_brokers(visited)
+
+        yield self.__locator
+
     def __debug(self, message: object) -> None:
         for logger in self.__loggers:
             logger.debug(message)
@@ -933,6 +939,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:

{python_injection-0.23.3 → python_injection-0.25.0}/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.0/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.23.3 → python_injection-0.25.0}/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.23.3 → python_injection-0.25.0}/pyproject.toml

@@ -30,7 +30,7 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.23.3"
+version = "0.25.0"
 description = "Fast and easy dependency injection framework."
 license = "MIT"
 license-files = ["LICENSE"]
@@ -55,7 +55,9 @@ classifiers = [
     "Natural Language :: English",
     "Typing :: Typed",
 ]
-dependencies = []
+dependencies = [
+    "type-analyzer",
+]
 
 [project.optional-dependencies]
 async = [
@@ -106,12 +108,12 @@ init_forbid_extra = true
 init_typed = true
 warn_required_dynamic_aliases = true
 
-[tool.pytest.ini_options]
-python_files = "test_*.py"
-addopts = "--tb short --cov ./ --cov-report term-missing:skip-covered"
+[tool.pytest]
+python_files = ["test_*.py"]
+addopts = ["--tb", "short", "--cov", "./", "--cov-report", "term-missing:skip-covered"]
 asyncio_default_fixture_loop_scope = "session"
 asyncio_mode = "auto"
-testpaths = "**/tests/"
+testpaths = ["**/tests/"]
 
 [tool.ruff]
 line-length = 88

python_injection-0.23.3/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)

{python_injection-0.23.3 → python_injection-0.25.0}/injection/loaders.py

@@ -176,12 +176,12 @@ class ProfileLoader:
 
     def __init_subsets_for(self, module: Module) -> Module:
         if not self.__is_empty and not self.__is_initialized(module):
+            self.__mark_initialized(module)
             target_modules = tuple(
                 self.__init_subsets_for(mod(name))
                 for name in self.module_subsets.get(module.name, ())
             )
             module.init_modules(*target_modules)
-            self.__mark_initialized(module)
 
         return module