python-injection 0.4.2__py3-none-any.whl → 0.5.1__py3-none-any.whl

injection/__init__.py

@@ -1,17 +1,19 @@
-from .core import Module, new_module
+from .core import Injectable, Module, ModulePriorities
 
 __all__ = (
+    "Injectable",
     "Module",
+    "ModulePriorities",
+    "default_module",
     "get_instance",
     "inject",
     "injectable",
-    "new_module",
     "singleton",
 )
 
-_default_module = new_module()
+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
+get_instance = default_module.get_instance
+inject = default_module.inject
+injectable = default_module.injectable
+singleton = default_module.singleton

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

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)
 

injection/core/module.py

@@ -2,14 +2,17 @@ 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 functools import singledispatchmethod, wraps
-from inspect import Parameter, Signature
+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,
-    Generic,
     Iterable,
     Iterator,
     Mapping,
@@ -24,49 +27,145 @@ from typing import (
 
 from injection.common.event import Event, EventChannel, EventListener
 from injection.common.lazy import LazyMapping
-from injection.exceptions import NoInjectable
+from injection.exceptions import ModuleError, NoInjectable
 
-__all__ = ("Module", "new_module")
+__all__ = ("Injectable", "Module", "ModulePriorities")
+
+_logger = getLogger(__name__)
 
 T = TypeVar("T")
 
 
-@dataclass(repr=False, frozen=True, slots=True)
-class Injectable(Generic[T], ABC):
-    factory: Callable[[], 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
 
 
-class NewInjectable(Injectable[T]):
+@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(Injectable[T]):
-    __instance_attribute: str = "_instance"
-
-    __slots__ = (__instance_attribute,)
+class SingletonInjectable(_BaseInjectable[T]):
+    @cached_property
+    def __instance(self) -> T:
+        return self.factory()
 
     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 self.__instance
 
-        return instance
 
-
-@dataclass(repr=False, frozen=True, slots=True)
-class ContainerUpdated(Event):
-    container: Container
+"""
+Container
+"""
 
 
 @dataclass(repr=False, frozen=True, slots=True)
@@ -74,57 +173,241 @@ 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:
+    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:
-            try:
-                name = f"{cls.__module__}.{cls.__qualname__}"
-            except AttributeError:
-                name = repr(reference)
+            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)
 
-            raise NoInjectable(f"No injectable for `{name}`.") from exc
+    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 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()
+    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 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__}`."
-            )
+    def stop_using(self, module: Module):
+        """
+        Function to remove a module in use.
+        """
 
-        return reference
+        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 __notify(self):
-        event = ContainerUpdated(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:
@@ -150,20 +433,20 @@ class Dependencies:
         return cls.from_mapping({})
 
     @classmethod
-    def resolve(cls, signature: Signature, container: Container):
-        dependencies = LazyMapping(cls.__resolver(signature, container))
+    def resolve(cls, signature: Signature, module: Module):
+        dependencies = LazyMapping(cls.__resolver(signature, module))
         return cls.from_mapping(dependencies)
 
     @classmethod
     def __resolver(
         cls,
         signature: Signature,
-        container: Container,
+        module: Module,
     ) -> Iterator[tuple[str, Injectable]]:
         for name, parameter in signature.parameters.items():
             try:
-                injectable = container[parameter.annotation]
-            except NoInjectable:
+                injectable = module[parameter.annotation]
+            except KeyError:
                 continue
 
             yield name, injectable
@@ -186,48 +469,33 @@ class Binder(EventListener):
             return Arguments(args, kwargs)
 
         bound = self.__signature.bind_partial(*args, **kwargs)
-        arguments = self.__dependencies.arguments | bound.arguments
-
-        positional = []
-        keywords = {}
+        bound.arguments = self.__dependencies.arguments | bound.arguments
+        return Arguments(bound.args, bound.kwargs)
 
-        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)
+    def update(self, module: Module):
+        self.__dependencies = Dependencies.resolve(self.__signature, module)
         return self
 
     @singledispatchmethod
     def on_event(self, event: Event, /):
-        ...  # pragma: no cover
+        ...
 
     @on_event.register
-    def _(self, event: ContainerUpdated, /):
-        self.update(event.container)
+    def _(self, event: ModuleEvent, /):
+        self.update(event.on_module)
+
+
+"""
+Decorators
+"""
 
 
 @final
 @dataclass(repr=False, frozen=True, slots=True)
 class InjectDecorator:
-    __container: Container
+    __module: Module
 
-    def __call__(self, wrapped=None, /):
+    def __call__(self, wrapped: Callable[..., Any] = None, /):
         def decorator(wp):
             if isinstance(wp, type):
                 return self.__class_decorator(wp)
@@ -237,9 +505,9 @@ class InjectDecorator:
         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)
+        signature = inspect.signature(function, eval_str=True)
+        binder = Binder(signature).update(self.__module)
+        self.__module.add_listener(binder)
 
         @wraps(function)
         def wrapper(*args, **kwargs):
@@ -257,21 +525,27 @@ class InjectDecorator:
 @final
 @dataclass(repr=False, frozen=True, slots=True)
 class InjectableDecorator:
-    __container: Container
-    __class: type[Injectable]
+    __module: Module
+    __class: type[_BaseInjectable]
 
     def __repr__(self) -> str:
-        return f"<{self.__class.__name__} decorator>"  # pragma: no cover
-
-    def __call__(self, wrapped=None, /, on=None, auto_inject=True):
+        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.__container.inject(wp)
+                wp = self.__module.inject(wp)
 
-            @lambda fn: fn()
+            @lambda function: function()
             def references():
-                if isinstance(wp, type):
-                    yield wp
+                if reference := self.__get_reference(wp):
+                    yield reference
 
                 if on is None:
                     return
@@ -280,56 +554,20 @@ class InjectableDecorator:
                 else:
                     yield on
 
-            injectable = self.__class(wp)
-            self.__container.set_multiple(references, injectable)
-
+            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
 
-@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)
+        elif callable(wrapped):
+            return_type = get_annotations(wrapped, eval_str=True).get("return")
 
+            if isinstance(return_type, type):
+                return return_type
 
-def new_module() -> Module:
-    module = InjectionModule()
-    return cast(Module, module)
+        return None

injection/exceptions.py

@@ -1,4 +1,4 @@
-__all__ = ("InjectionError", "NoInjectable")
+__all__ = ("InjectionError", "ModuleError", "NoInjectable")
 
 
 class InjectionError(Exception):
@@ -7,3 +7,7 @@ class InjectionError(Exception):
 
 class NoInjectable(KeyError, InjectionError):
     ...
+
+
+class ModuleError(InjectionError):
+    ...

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.dist-info → python_injection-0.5.1.dist-info}/METADATA

@@ -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.5.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+injection/__init__.py,sha256=4WiI0l-y8fDBm_Rt7-z9oZ5aJKApHvIyEBDhvN03TOA,423
+injection/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+injection/common/event.py,sha256=0Jvfvws7bx-NxA32JrqeD-9ywBEgSmHtdEHbJNg_hAo,961
+injection/common/lazy.py,sha256=TqFcozHOVY6OY9Y43oCXzNHydTITf3JkM5hzEn7Z4cw,1503
+injection/core/__init__.py,sha256=zuf0ubI2dHnbjn1059eduhS-ACIkkROa6-dhp10krh0,22
+injection/core/module.py,sha256=DC-iawfHKnNmNjTP7pIi3Na-v4jU9O2dQoLTrMaGnB0,15910
+injection/exceptions.py,sha256=o_LN7rDeX0fRw2cdQlyxvS4OAO2y9P2aRiiBKXPwbCQ,204
+injection/utils.py,sha256=Y_5EEbcpDNdaCaPq8g1e6lHcHRCTMWsGOnZYuHa46aQ,598
+python_injection-0.5.1.dist-info/METADATA,sha256=DJT_0yMjoi9dZ82cfWIiEYUGKKgRzgspiNK4DyPUodQ,2842
+python_injection-0.5.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+python_injection-0.5.1.dist-info/RECORD,,

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.
-    """

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.
-    """

python_injection-0.4.2.dist-info/RECORD

@@ -1,13 +0,0 @@
-injection/__init__.py,sha256=kcWDMrMTrUtrn0wDYSD1FbTP8G0WV1IAKhFDfHNI83c,340
-injection/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-injection/common/event.py,sha256=ncSFjFWCOsZczpfIkKtvA33hAmyTTcpvVpjCm9CJQmo,762
-injection/common/lazy.py,sha256=_mnEq8A2aFhgNYEaz8QNEfRhdlwVclgTGHg6koYeAiU,1523
-injection/core/__init__.py,sha256=zuf0ubI2dHnbjn1059eduhS-ACIkkROa6-dhp10krh0,22
-injection/core/module.py,sha256=Mj7h-tDoW4VEYkXEeDCWlRHdtEGJHQfPFGS5rh02pW8,9256
-injection/core/module.pyi,sha256=PHWQ92faA56FQCwhDzi1K9mZkbKAPXbm2Pru7VX8cTQ,1792
-injection/exceptions.py,sha256=bxWdH61sB6gRfAMltt4GdrPHh-1k6QqV8m3vKQN8O_o,144
-injection/utils.py,sha256=fSVNgUhsbiWzS8I8db9hWhlX6rv5mDJS-d1Vfb6EBMI,521
-injection/utils.pyi,sha256=xpSq678YijDe1SRO9_B2q4SW9WYCYEQgPUhRCTEwVlY,153
-python_injection-0.4.2.dist-info/METADATA,sha256=tAPJfNrnnVqoxHlkz47BXZSeypEQXiLgDDJQfjbubzc,2845
-python_injection-0.4.2.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-python_injection-0.4.2.dist-info/RECORD,,