python-injection 0.4.2__tar.gz → 0.5.1__tar.gz

{python_injection-0.4.2 → python_injection-0.5.1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.4.2
+Version: 0.5.1
 Summary: Fast and easy dependency injection framework.
-Home-page: https://github.com/soon-app/python-injection
+Home-page: https://github.com/simplysquare/python-injection
 License: MIT
 Keywords: dependencies,inject,injection
 Author: remimd
@@ -13,10 +13,10 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: frozendict
-Project-URL: Repository, https://github.com/soon-app/python-injection
+Project-URL: Repository, https://github.com/simplysquare/python-injection
 Description-Content-Type: text/markdown
 
-# How to use?
+# Basic usage
 
 ## Create an injectable
 
@@ -108,12 +108,12 @@ class C(B):
 ## Recipes
 
 A recipe is a function that tells the injector how to construct the instance to be injected. It is important to specify 
-the reference class(es) when defining the recipe.
+the return type annotation when defining the recipe.
 
 ```python
 from injection import singleton
 
-@singleton(on=Singleton)
+@singleton
 def my_recipe() -> Singleton:
     """ recipe implementation """
 ```

python_injection-0.4.2/documentation/how-to-use.md → python_injection-0.5.1/documentation/basic-usage.md

@@ -1,4 +1,4 @@
-# How to use?
+# Basic usage
 
 ## Create an injectable
 
@@ -90,12 +90,12 @@ class C(B):
 ## Recipes
 
 A recipe is a function that tells the injector how to construct the instance to be injected. It is important to specify 
-the reference class(es) when defining the recipe.
+the return type annotation when defining the recipe.
 
 ```python
 from injection import singleton
 
-@singleton(on=Singleton)
+@singleton
 def my_recipe() -> Singleton:
     """ recipe implementation """
 ```

python_injection-0.5.1/injection/__init__.py

@@ -0,0 +1,19 @@
+from .core import Injectable, Module, ModulePriorities
+
+__all__ = (
+    "Injectable",
+    "Module",
+    "ModulePriorities",
+    "default_module",
+    "get_instance",
+    "inject",
+    "injectable",
+    "singleton",
+)
+
+default_module = Module(f"{__name__}:default_module")
+
+get_instance = default_module.get_instance
+inject = default_module.inject
+injectable = default_module.injectable
+singleton = default_module.singleton

{python_injection-0.4.2 → python_injection-0.5.1}/injection/common/event.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+from contextlib import suppress
 from dataclasses import dataclass, field
 from weakref import WeakSet
 
@@ -17,7 +18,7 @@ class EventListener(ABC):
         raise NotImplementedError
 
 
-@dataclass(repr=False, frozen=True, slots=True)
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
 class EventChannel:
     __listeners: WeakSet[EventListener] = field(default_factory=WeakSet, init=False)
 
@@ -30,3 +31,9 @@ class EventChannel:
     def add_listener(self, listener: EventListener):
         self.__listeners.add(listener)
         return self
+
+    def remove_listener(self, listener: EventListener):
+        with suppress(KeyError):
+            self.__listeners.remove(listener)
+
+        return self

{python_injection-0.4.2 → python_injection-0.5.1}/injection/common/lazy.py

@@ -22,7 +22,7 @@ class Lazy(Generic[T]):
 
     def __setattr__(self, name: str, value: Any):
         if self.is_set:
-            raise TypeError(f"`{repr(self)}` is frozen.")  # pragma: no cover
+            raise TypeError(f"`{repr(self)}` is frozen.")
 
         return super().__setattr__(name, value)
 

python_injection-0.5.1/injection/core/module.py

@@ -0,0 +1,573 @@
+from __future__ import annotations
+
+import inspect
+from abc import ABC, abstractmethod
+from collections import ChainMap, OrderedDict
+from contextlib import ContextDecorator, contextmanager
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from functools import cached_property, singledispatchmethod, wraps
+from inspect import Signature, get_annotations
+from logging import getLogger
+from types import MappingProxyType
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    Iterator,
+    Mapping,
+    NamedTuple,
+    Protocol,
+    TypeVar,
+    cast,
+    final,
+    get_origin,
+    runtime_checkable,
+)
+
+from injection.common.event import Event, EventChannel, EventListener
+from injection.common.lazy import LazyMapping
+from injection.exceptions import ModuleError, NoInjectable
+
+__all__ = ("Injectable", "Module", "ModulePriorities")
+
+_logger = getLogger(__name__)
+
+T = TypeVar("T")
+
+
+def _format_type(cls: type) -> str:
+    try:
+        return f"{cls.__module__}.{cls.__qualname__}"
+    except AttributeError:
+        return str(cls)
+
+
+"""
+Events
+"""
+
+
+@dataclass(frozen=True, slots=True)
+class ContainerEvent(Event, ABC):
+    on_container: Container
+
+
+@dataclass(frozen=True, slots=True)
+class ContainerDependenciesUpdated(ContainerEvent):
+    references: set[type]
+
+    def __str__(self) -> str:
+        length = len(self.references)
+        formatted_references = ", ".join(
+            f"`{_format_type(reference)}`" for reference in self.references
+        )
+        return (
+            f"{length} container dependenc{'ies' if length > 1 else 'y'} have been "
+            f"updated{f': {formatted_references}' if formatted_references else ''}."
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class ModuleEvent(Event, ABC):
+    on_module: Module
+
+
+@dataclass(frozen=True)
+class ModuleEventProxy(ModuleEvent):
+    event: Event
+
+    def __str__(self) -> str:
+        return f"`{self.on_module}` has propagated an event: {self.origin}"
+
+    @cached_property
+    def origin(self) -> Event:
+        if isinstance(self.event, ModuleEventProxy):
+            return self.event.origin
+
+        return self.event
+
+    @property
+    def is_circular(self) -> bool:
+        origin = self.origin
+        return isinstance(origin, ModuleEvent) and origin.on_module is self.on_module
+
+    @property
+    def previous_module(self) -> Module | None:
+        if isinstance(self.event, ModuleEvent):
+            return self.event.on_module
+
+        return None
+
+
+@dataclass(frozen=True, slots=True)
+class ModuleAdded(ModuleEvent):
+    module_added: Module
+
+    def __str__(self) -> str:
+        return f"`{self.on_module}` now uses `{self.module_added}`."
+
+
+@dataclass(frozen=True, slots=True)
+class ModuleRemoved(ModuleEvent):
+    module_removed: Module
+
+    def __str__(self) -> str:
+        return f"`{self.on_module}` no longer uses `{self.module_removed}`."
+
+
+@dataclass(frozen=True, slots=True)
+class ModulePriorityUpdated(ModuleEvent):
+    module_updated: Module
+    priority: ModulePriorities
+
+    def __str__(self) -> str:
+        return (
+            f"In `{self.on_module}`, the priority `{self.priority.name}` "
+            f"has been applied to `{self.module_updated}`."
+        )
+
+
+"""
+Injectables
+"""
+
+
+@runtime_checkable
+class Injectable(Protocol[T]):
+    __slots__ = ()
+
+    @abstractmethod
+    def get_instance(self) -> T:
+        raise NotImplementedError
+
+
+@dataclass(repr=False, frozen=True, slots=True)
+class _BaseInjectable(Injectable[T], ABC):
+    factory: Callable[[], T]
+
+
+class NewInjectable(_BaseInjectable[T]):
+    __slots__ = ()
+
+    def get_instance(self) -> T:
+        return self.factory()
+
+
+class SingletonInjectable(_BaseInjectable[T]):
+    @cached_property
+    def __instance(self) -> T:
+        return self.factory()
+
+    def get_instance(self) -> T:
+        return self.__instance
+
+
+"""
+Container
+"""
+
+
+@dataclass(repr=False, frozen=True, slots=True)
+class Container:
+    __data: dict[type, Injectable] = field(default_factory=dict, init=False)
+    __channel: EventChannel = field(default_factory=EventChannel, init=False)
+
+    def __getitem__(self, reference: type[T]) -> Injectable[T]:
+        cls = origin if (origin := get_origin(reference)) else reference
+
+        try:
+            return self.__data[cls]
+        except KeyError as exc:
+            raise NoInjectable(f"No injectable for `{_format_type(cls)}`.") from exc
+
+    def set_multiple(self, references: Iterable[type], injectable: Injectable):
+        if not isinstance(references, set):
+            references = set(references)
+
+        if references:
+            new_values = (
+                (self.check_if_exists(reference), injectable)
+                for reference in references
+            )
+            self.__data.update(new_values)
+            event = ContainerDependenciesUpdated(self, references)
+            self.notify(event)
+
+        return self
+
+    def check_if_exists(self, reference: type) -> type:
+        if reference in self.__data:
+            raise RuntimeError(
+                "An injectable already exists for the reference "
+                f"class `{_format_type(reference)}`."
+            )
+
+        return reference
+
+    def add_listener(self, listener: EventListener):
+        self.__channel.add_listener(listener)
+        return self
+
+    def notify(self, event: Event):
+        self.__channel.dispatch(event)
+        return self
+
+
+"""
+Module
+"""
+
+
+class ModulePriorities(Enum):
+    HIGH = auto()
+    LOW = auto()
+
+
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class Module(EventListener):
+    """
+    Object with isolated injection environment.
+
+    Modules have been designed to simplify unit test writing. So think carefully before
+    instantiating a new one. They could increase complexity unnecessarily if used
+    extensively.
+    """
+
+    name: str = field(default=None)
+    __container: Container = field(default_factory=Container, init=False)
+    __channel: EventChannel = field(default_factory=EventChannel, init=False)
+    __modules: OrderedDict[Module, None] = field(
+        default_factory=OrderedDict,
+        init=False,
+    )
+
+    def __post_init__(self):
+        self.__container.add_listener(self)
+
+    def __getitem__(self, reference: type[T], /) -> Injectable[T]:
+        return ChainMap(*self.__modules, self.__container)[reference]
+
+    def __setitem__(self, on: type | Iterable[type], injectable: Injectable, /):
+        references = on if isinstance(on, Iterable) else (on,)
+        self.__container.set_multiple(references, injectable)
+
+    def __str__(self) -> str:
+        return self.name or object.__str__(self)
+
+    @property
+    def inject(self) -> InjectDecorator:
+        """
+        Decorator applicable to a class or function. Inject function dependencies using
+        parameter type annotations. If applied to a class, the dependencies resolved
+        will be those of the `__init__` method.
+        """
+
+        return InjectDecorator(self)
+
+    @property
+    def injectable(self) -> InjectableDecorator:
+        """
+        Decorator applicable to a class or function. It is used to indicate how the
+        injectable will be constructed. At injection time, a new instance will be
+        injected each time. Automatically injects constructor dependencies, can be
+        disabled with `auto_inject=False`.
+        """
+
+        return InjectableDecorator(self, NewInjectable)
+
+    @property
+    def singleton(self) -> InjectableDecorator:
+        """
+        Decorator applicable to a class or function. It is used to indicate how the
+        singleton will be constructed. At injection time, the injected instance will
+        always be the same. Automatically injects constructor dependencies, can be
+        disabled with `auto_inject=False`.
+        """
+
+        return InjectableDecorator(self, SingletonInjectable)
+
+    def get_instance(self, reference: type[T]) -> T | None:
+        """
+        Function used to retrieve an instance associated with the type passed in
+        parameter or return `None`.
+        """
+
+        try:
+            injectable = self[reference]
+        except KeyError:
+            return None
+
+        instance = injectable.get_instance()
+        return cast(reference, instance)
+
+    def use(
+        self,
+        module: Module,
+        priority: ModulePriorities = ModulePriorities.LOW,
+    ):
+        """
+        Function for using another module. Using another module replaces the module's
+        dependencies with those of the module used. If the dependency is not found, it
+        will be searched for in the module's dependency container.
+        """
+
+        if module is self:
+            raise ModuleError("Module can't be used by itself.")
+
+        if module in self.__modules:
+            raise ModuleError(f"`{self}` already uses `{module}`.")
+
+        self.__modules[module] = None
+        self.__move_module(module, priority)
+        module.add_listener(self)
+        event = ModuleAdded(self, module)
+        self.notify(event)
+        return self
+
+    def stop_using(self, module: Module):
+        """
+        Function to remove a module in use.
+        """
+
+        try:
+            self.__modules.pop(module)
+        except KeyError:
+            ...
+        else:
+            module.remove_listener(self)
+            event = ModuleRemoved(self, module)
+            self.notify(event)
+
+        return self
+
+    @contextmanager
+    def use_temporarily(
+        self,
+        module: Module,
+        priority: ModulePriorities = ModulePriorities.LOW,
+    ) -> ContextDecorator:
+        """
+        Context manager or decorator for temporary use of a module.
+        """
+
+        self.use(module, priority)
+        yield
+        self.stop_using(module)
+
+    def change_priority(self, module: Module, priority: ModulePriorities):
+        """
+        Function for changing the priority of a module in use.
+        There are two priority values:
+
+        * **LOW**: The module concerned becomes the least important of the modules used.
+        * **HIGH**: The module concerned becomes the most important of the modules used.
+        """
+
+        self.__move_module(module, priority)
+        event = ModulePriorityUpdated(self, module, priority)
+        self.notify(event)
+        return self
+
+    def add_listener(self, listener: EventListener):
+        self.__channel.add_listener(listener)
+        return self
+
+    def remove_listener(self, listener: EventListener):
+        self.__channel.remove_listener(listener)
+        return self
+
+    def on_event(self, event: Event, /):
+        self_event = ModuleEventProxy(self, event)
+
+        if self_event.is_circular:
+            raise ModuleError(
+                "Circular dependency between two modules: "
+                f"`{self_event.previous_module}` and `{self}`."
+            )
+
+        self.notify(self_event)
+
+    def notify(self, event: Event):
+        _logger.debug(f"{event}")
+        self.__channel.dispatch(event)
+        return self
+
+    def __move_module(self, module: Module, priority: ModulePriorities):
+        last = priority == ModulePriorities.LOW
+
+        try:
+            self.__modules.move_to_end(module, last=last)
+        except KeyError as exc:
+            raise ModuleError(
+                f"`{module}` can't be found in the modules used by `{self}`."
+            ) from exc
+
+
+"""
+Binder
+"""
+
+
+@dataclass(repr=False, frozen=True, slots=True)
+class Dependencies:
+    __mapping: MappingProxyType[str, Injectable]
+
+    def __bool__(self) -> bool:
+        return bool(self.__mapping)
+
+    def __iter__(self) -> Iterator[tuple[str, Any]]:
+        for name, injectable in self.__mapping.items():
+            yield name, injectable.get_instance()
+
+    @property
+    def arguments(self) -> Mapping[str, Any]:
+        return dict(self)
+
+    @classmethod
+    def from_mapping(cls, mapping: Mapping[str, Injectable]):
+        return cls(MappingProxyType(mapping))
+
+    @classmethod
+    def empty(cls):
+        return cls.from_mapping({})
+
+    @classmethod
+    def resolve(cls, signature: Signature, module: Module):
+        dependencies = LazyMapping(cls.__resolver(signature, module))
+        return cls.from_mapping(dependencies)
+
+    @classmethod
+    def __resolver(
+        cls,
+        signature: Signature,
+        module: Module,
+    ) -> Iterator[tuple[str, Injectable]]:
+        for name, parameter in signature.parameters.items():
+            try:
+                injectable = module[parameter.annotation]
+            except KeyError:
+                continue
+
+            yield name, injectable
+
+
+class Arguments(NamedTuple):
+    args: Iterable[Any]
+    kwargs: Mapping[str, Any]
+
+
+class Binder(EventListener):
+    __slots__ = ("__signature", "__dependencies")
+
+    def __init__(self, signature: Signature):
+        self.__signature = signature
+        self.__dependencies = Dependencies.empty()
+
+    def bind(self, /, *args, **kwargs) -> Arguments:
+        if not self.__dependencies:
+            return Arguments(args, kwargs)
+
+        bound = self.__signature.bind_partial(*args, **kwargs)
+        bound.arguments = self.__dependencies.arguments | bound.arguments
+        return Arguments(bound.args, bound.kwargs)
+
+    def update(self, module: Module):
+        self.__dependencies = Dependencies.resolve(self.__signature, module)
+        return self
+
+    @singledispatchmethod
+    def on_event(self, event: Event, /):
+        ...
+
+    @on_event.register
+    def _(self, event: ModuleEvent, /):
+        self.update(event.on_module)
+
+
+"""
+Decorators
+"""
+
+
+@final
+@dataclass(repr=False, frozen=True, slots=True)
+class InjectDecorator:
+    __module: Module
+
+    def __call__(self, wrapped: Callable[..., Any] = None, /):
+        def decorator(wp):
+            if isinstance(wp, type):
+                return self.__class_decorator(wp)
+
+            return self.__decorator(wp)
+
+        return decorator(wrapped) if wrapped else decorator
+
+    def __decorator(self, function: Callable[..., Any], /) -> Callable[..., Any]:
+        signature = inspect.signature(function, eval_str=True)
+        binder = Binder(signature).update(self.__module)
+        self.__module.add_listener(binder)
+
+        @wraps(function)
+        def wrapper(*args, **kwargs):
+            arguments = binder.bind(*args, **kwargs)
+            return function(*arguments.args, **arguments.kwargs)
+
+        return wrapper
+
+    def __class_decorator(self, cls: type, /) -> type:
+        init_function = type.__getattribute__(cls, "__init__")
+        type.__setattr__(cls, "__init__", self.__decorator(init_function))
+        return cls
+
+
+@final
+@dataclass(repr=False, frozen=True, slots=True)
+class InjectableDecorator:
+    __module: Module
+    __class: type[_BaseInjectable]
+
+    def __repr__(self) -> str:
+        return f"<{self.__class.__qualname__} decorator>"
+
+    def __call__(
+        self,
+        wrapped: Callable[..., Any] = None,
+        /,
+        on: type | Iterable[type] = None,
+        auto_inject: bool = True,
+    ):
+        def decorator(wp):
+            if auto_inject:
+                wp = self.__module.inject(wp)
+
+            @lambda function: function()
+            def references():
+                if reference := self.__get_reference(wp):
+                    yield reference
+
+                if on is None:
+                    return
+                elif isinstance(on, Iterable):
+                    yield from on
+                else:
+                    yield on
+
+            self.__module[references] = self.__class(wp)
+            return wp
+
+        return decorator(wrapped) if wrapped else decorator
+
+    @staticmethod
+    def __get_reference(wrapped: Callable[..., Any], /) -> type | None:
+        if isinstance(wrapped, type):
+            return wrapped
+
+        elif callable(wrapped):
+            return_type = get_annotations(wrapped, eval_str=True).get("return")
+
+            if isinstance(return_type, type):
+                return return_type
+
+        return None

python_injection-0.5.1/injection/exceptions.py

@@ -0,0 +1,13 @@
+__all__ = ("InjectionError", "ModuleError", "NoInjectable")
+
+
+class InjectionError(Exception):
+    ...
+
+
+class NoInjectable(KeyError, InjectionError):
+    ...
+
+
+class ModuleError(InjectionError):
+    ...

{python_injection-0.4.2 → python_injection-0.5.1}/injection/utils.py

@@ -6,6 +6,10 @@ __all__ = ("load_package",)
 
 
 def load_package(package: Package):
+    """
+    Function for importing all modules in a Python package.
+    """
+
     try:
         path = package.__path__
     except AttributeError as exc:

{python_injection-0.4.2 → python_injection-0.5.1}/pyproject.toml

@@ -1,13 +1,13 @@
 [tool.poetry]
 name = "python-injection"
-version = "0.4.2"
+version = "0.5.1"
 description = "Fast and easy dependency injection framework."
 authors = ["remimd"]
 keywords = ["dependencies", "inject", "injection"]
 license = "MIT"
 packages = [{ include = "injection" }]
-readme = "documentation/how-to-use.md"
-repository = "https://github.com/soon-app/python-injection"
+readme = "documentation/basic-usage.md"
+repository = "https://github.com/simplysquare/python-injection"
 
 [tool.poetry.dependencies]
 python = ">=3.10, <4"

python_injection-0.4.2/injection/__init__.py

@@ -1,17 +0,0 @@
-from .core import Module, new_module
-
-__all__ = (
-    "Module",
-    "get_instance",
-    "inject",
-    "injectable",
-    "new_module",
-    "singleton",
-)
-
-_default_module = new_module()
-
-get_instance = _default_module.get_instance
-inject = _default_module.inject
-injectable = _default_module.injectable
-singleton = _default_module.singleton

python_injection-0.4.2/injection/core/module.py

@@ -1,335 +0,0 @@
-from __future__ import annotations
-
-import inspect
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from functools import singledispatchmethod, wraps
-from inspect import Parameter, Signature
-from types import MappingProxyType
-from typing import (
-    Any,
-    Callable,
-    Generic,
-    Iterable,
-    Iterator,
-    Mapping,
-    NamedTuple,
-    Protocol,
-    TypeVar,
-    cast,
-    final,
-    get_origin,
-    runtime_checkable,
-)
-
-from injection.common.event import Event, EventChannel, EventListener
-from injection.common.lazy import LazyMapping
-from injection.exceptions import NoInjectable
-
-__all__ = ("Module", "new_module")
-
-T = TypeVar("T")
-
-
-@dataclass(repr=False, frozen=True, slots=True)
-class Injectable(Generic[T], ABC):
-    factory: Callable[[], T]
-
-    @abstractmethod
-    def get_instance(self) -> T:
-        raise NotImplementedError
-
-
-class NewInjectable(Injectable[T]):
-    __slots__ = ()
-
-    def get_instance(self) -> T:
-        return self.factory()
-
-
-class SingletonInjectable(Injectable[T]):
-    __instance_attribute: str = "_instance"
-
-    __slots__ = (__instance_attribute,)
-
-    def get_instance(self) -> T:
-        cls = type(self)
-
-        try:
-            instance = getattr(self, cls.__instance_attribute)
-        except AttributeError:
-            instance = self.factory()
-            object.__setattr__(self, cls.__instance_attribute, instance)
-
-        return instance
-
-
-@dataclass(repr=False, frozen=True, slots=True)
-class ContainerUpdated(Event):
-    container: Container
-
-
-@dataclass(repr=False, frozen=True, slots=True)
-class Container:
-    __data: dict[type, Injectable] = field(default_factory=dict, init=False)
-    __channel: EventChannel = field(default_factory=EventChannel, init=False)
-
-    def __getitem__(self, reference: type) -> Injectable:
-        cls = origin if (origin := get_origin(reference)) else reference
-
-        try:
-            return self.__data[cls]
-        except KeyError as exc:
-            try:
-                name = f"{cls.__module__}.{cls.__qualname__}"
-            except AttributeError:
-                name = repr(reference)
-
-            raise NoInjectable(f"No injectable for `{name}`.") from exc
-
-    @property
-    def inject(self) -> InjectDecorator:
-        return InjectDecorator(self)
-
-    @property
-    def injectable(self) -> InjectableDecorator:
-        return InjectableDecorator(self, NewInjectable)
-
-    @property
-    def singleton(self) -> InjectableDecorator:
-        return InjectableDecorator(self, SingletonInjectable)
-
-    def set_multiple(self, references: Iterable[type], injectable: Injectable):
-        new_values = (
-            (self.check_if_exists(reference), injectable) for reference in references
-        )
-        self.__data.update(new_values)
-        self.__notify()
-        return self
-
-    def check_if_exists(self, reference: type) -> type:
-        if reference in self.__data:
-            raise RuntimeError(
-                "An injectable already exists for the "
-                f"reference class `{reference.__name__}`."
-            )
-
-        return reference
-
-    def add_listener(self, listener: EventListener):
-        self.__channel.add_listener(listener)
-        return self
-
-    def __notify(self):
-        event = ContainerUpdated(self)
-        self.__channel.dispatch(event)
-        return self
-
-
-@dataclass(repr=False, frozen=True, slots=True)
-class Dependencies:
-    __mapping: MappingProxyType[str, Injectable]
-
-    def __bool__(self) -> bool:
-        return bool(self.__mapping)
-
-    def __iter__(self) -> Iterator[tuple[str, Any]]:
-        for name, injectable in self.__mapping.items():
-            yield name, injectable.get_instance()
-
-    @property
-    def arguments(self) -> Mapping[str, Any]:
-        return dict(self)
-
-    @classmethod
-    def from_mapping(cls, mapping: Mapping[str, Injectable]):
-        return cls(MappingProxyType(mapping))
-
-    @classmethod
-    def empty(cls):
-        return cls.from_mapping({})
-
-    @classmethod
-    def resolve(cls, signature: Signature, container: Container):
-        dependencies = LazyMapping(cls.__resolver(signature, container))
-        return cls.from_mapping(dependencies)
-
-    @classmethod
-    def __resolver(
-        cls,
-        signature: Signature,
-        container: Container,
-    ) -> Iterator[tuple[str, Injectable]]:
-        for name, parameter in signature.parameters.items():
-            try:
-                injectable = container[parameter.annotation]
-            except NoInjectable:
-                continue
-
-            yield name, injectable
-
-
-class Arguments(NamedTuple):
-    args: Iterable[Any]
-    kwargs: Mapping[str, Any]
-
-
-class Binder(EventListener):
-    __slots__ = ("__signature", "__dependencies")
-
-    def __init__(self, signature: Signature):
-        self.__signature = signature
-        self.__dependencies = Dependencies.empty()
-
-    def bind(self, /, *args, **kwargs) -> Arguments:
-        if not self.__dependencies:
-            return Arguments(args, kwargs)
-
-        bound = self.__signature.bind_partial(*args, **kwargs)
-        arguments = self.__dependencies.arguments | bound.arguments
-
-        positional = []
-        keywords = {}
-
-        for name, parameter in self.__signature.parameters.items():
-            try:
-                value = arguments.pop(name)
-            except KeyError:
-                continue
-
-            match parameter.kind:
-                case Parameter.POSITIONAL_ONLY:
-                    positional.append(value)
-                case Parameter.VAR_POSITIONAL:
-                    positional.extend(value)
-                case Parameter.VAR_KEYWORD:
-                    keywords.update(value)
-                case _:
-                    keywords[name] = value
-
-        return Arguments(tuple(positional), keywords)
-
-    def update(self, container: Container):
-        self.__dependencies = Dependencies.resolve(self.__signature, container)
-        return self
-
-    @singledispatchmethod
-    def on_event(self, event: Event, /):
-        ...  # pragma: no cover
-
-    @on_event.register
-    def _(self, event: ContainerUpdated, /):
-        self.update(event.container)
-
-
-@final
-@dataclass(repr=False, frozen=True, slots=True)
-class InjectDecorator:
-    __container: Container
-
-    def __call__(self, wrapped=None, /):
-        def decorator(wp):
-            if isinstance(wp, type):
-                return self.__class_decorator(wp)
-
-            return self.__decorator(wp)
-
-        return decorator(wrapped) if wrapped else decorator
-
-    def __decorator(self, function: Callable[..., Any], /) -> Callable[..., Any]:
-        signature = inspect.signature(function)
-        binder = Binder(signature).update(self.__container)
-        self.__container.add_listener(binder)
-
-        @wraps(function)
-        def wrapper(*args, **kwargs):
-            arguments = binder.bind(*args, **kwargs)
-            return function(*arguments.args, **arguments.kwargs)
-
-        return wrapper
-
-    def __class_decorator(self, cls: type, /) -> type:
-        init_function = type.__getattribute__(cls, "__init__")
-        type.__setattr__(cls, "__init__", self.__decorator(init_function))
-        return cls
-
-
-@final
-@dataclass(repr=False, frozen=True, slots=True)
-class InjectableDecorator:
-    __container: Container
-    __class: type[Injectable]
-
-    def __repr__(self) -> str:
-        return f"<{self.__class.__name__} decorator>"  # pragma: no cover
-
-    def __call__(self, wrapped=None, /, on=None, auto_inject=True):
-        def decorator(wp):
-            if auto_inject:
-                wp = self.__container.inject(wp)
-
-            @lambda fn: fn()
-            def references():
-                if isinstance(wp, type):
-                    yield wp
-
-                if on is None:
-                    return
-                elif isinstance(on, Iterable):
-                    yield from on
-                else:
-                    yield on
-
-            injectable = self.__class(wp)
-            self.__container.set_multiple(references, injectable)
-
-            return wp
-
-        return decorator(wrapped) if wrapped else decorator
-
-
-@runtime_checkable
-class Module(Protocol):
-    __slots__ = ()
-
-    @abstractmethod
-    def get_instance(self, *args, **kwargs):
-        raise NotImplementedError
-
-    @abstractmethod
-    def inject(self, *args, **kwargs):
-        raise NotImplementedError
-
-    @abstractmethod
-    def injectable(self, *args, **kwargs):
-        raise NotImplementedError
-
-    @abstractmethod
-    def singleton(self, *args, **kwargs):
-        raise NotImplementedError
-
-
-@dataclass(repr=False, frozen=True, slots=True)
-class InjectionModule:
-    __container: Container = field(default_factory=Container, init=False)
-
-    @property
-    def inject(self) -> InjectDecorator:
-        return self.__container.inject
-
-    @property
-    def injectable(self) -> InjectableDecorator:
-        return self.__container.injectable
-
-    @property
-    def singleton(self) -> InjectableDecorator:
-        return self.__container.singleton
-
-    def get_instance(self, reference: type[T]) -> T:
-        instance = self.__container[reference].get_instance()
-        return cast(reference, instance)
-
-
-def new_module() -> Module:
-    module = InjectionModule()
-    return cast(Module, module)

python_injection-0.4.2/injection/core/module.pyi

@@ -1,44 +0,0 @@
-from abc import abstractmethod
-from typing import Any, Callable, Iterable, Protocol, TypeVar, runtime_checkable
-
-_T = TypeVar("_T")
-
-@runtime_checkable
-class Module(Protocol):
-    """
-    Object with isolated injection environment.
-    """
-
-    @abstractmethod
-    def get_instance(self, reference: type[_T]) -> _T:
-        """
-        Function used to retrieve an instance associated with the type passed in parameter or raise `NoInjectable`
-        exception.
-        """
-    @abstractmethod
-    def inject(self, wrapped: Callable[..., Any] = ..., /):
-        """
-        Decorator applicable to a class or function. Inject function dependencies using parameter type annotations. If
-        applied to a class, the dependencies resolved will be those of the `__init__` method.
-
-        Doesn't work with type annotations resolved by `__future__` module.
-        """
-    @abstractmethod
-    def injectable(self, *, on: type | Iterable[type] = ..., auto_inject: bool = ...):
-        """
-        Decorator applicable to a class or function. It is used to indicate how the injectable will be constructed. At
-        injection time, a new instance will be injected each time. Automatically injects constructor dependencies, can
-        be disabled with `auto_inject=False`.
-        """
-    @abstractmethod
-    def singleton(self, *, on: type | Iterable[type] = ..., auto_inject: bool = ...):
-        """
-        Decorator applicable to a class or function. It is used to indicate how the singleton will be constructed. At
-        injection time, the injected instance will always be the same. Automatically injects constructor dependencies,
-        can be disabled with `auto_inject=False`.
-        """
-
-def new_module() -> Module:
-    """
-    Function to create a new injection module.
-    """

python_injection-0.4.2/injection/exceptions.py

@@ -1,9 +0,0 @@
-__all__ = ("InjectionError", "NoInjectable")
-
-
-class InjectionError(Exception):
-    ...
-
-
-class NoInjectable(KeyError, InjectionError):
-    ...

python_injection-0.4.2/injection/utils.pyi

@@ -1,6 +0,0 @@
-from types import ModuleType as Package
-
-def load_package(package: Package):
-    """
-    Function for importing all modules in a Python package.
-    """