python-injection 0.9.4.post0__tar.gz → 0.9.6__tar.gz

{python_injection-0.9.4.post0 → python_injection-0.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.9.4.post0
+Version: 0.9.6
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT
@@ -59,7 +59,8 @@ from injection import set_constant
 class ServiceC:
     """ class implementation """
 
-service_c = set_constant(ServiceC())
+service_c = ServiceC()
+set_constant(service_c)
 ```
 
 ## Inject an instance

{python_injection-0.9.4.post0 → python_injection-0.9.6}/documentation/basic-usage.md

@@ -33,7 +33,8 @@ from injection import set_constant
 class ServiceC:
     """ class implementation """
 
-service_c = set_constant(ServiceC())
+service_c = ServiceC()
+set_constant(service_c)
 ```
 
 ## Inject an instance

{python_injection-0.9.4.post0 → python_injection-0.9.6}/injection/__init__.py

@@ -1,6 +1,6 @@
-from .core import Injectable, Module
-from .core import Mode as InjectableMode
-from .core import Priority as ModulePriority
+from ._core import Injectable, Module
+from ._core import Mode as InjectableMode
+from ._core import Priority as ModulePriority
 
 __all__ = (
     "Injectable",

{python_injection-0.9.4.post0 → python_injection-0.9.6}/injection/__init__.pyi

@@ -1,7 +1,7 @@
 from abc import abstractmethod
 from collections.abc import Callable
 from contextlib import ContextDecorator
-from enum import StrEnum
+from enum import Enum
 from logging import Logger
 from types import UnionType
 from typing import (
@@ -13,11 +13,11 @@ from typing import (
     runtime_checkable,
 )
 
-from .common.invertible import Invertible
-from .common.tools.type import TypeInfo
-from .core import InjectableFactory
-from .core import ModeStr as InjectableModeStr
-from .core import PriorityStr as ModulePriorityStr
+from ._core import InjectableFactory as _InjectableFactory
+from ._core import ModeStr as InjectableModeStr
+from ._core import PriorityStr as ModulePriorityStr
+from ._core.common.invertible import Invertible as _Invertible
+from ._core.common.type import TypeInfo as _TypeInfo
 
 _: Module = ...
 
@@ -62,9 +62,9 @@ class Module:
         wrapped: Callable[..., T] = ...,
         /,
         *,
-        cls: InjectableFactory[T] = ...,
+        cls: _InjectableFactory[T] = ...,
         inject: bool = ...,
-        on: TypeInfo[T] = ...,
+        on: _TypeInfo[T] = ...,
         mode: InjectableMode | InjectableModeStr = ...,
     ):
         """
@@ -79,7 +79,7 @@ class Module:
         /,
         *,
         inject: bool = ...,
-        on: TypeInfo[T] = ...,
+        on: _TypeInfo[T] = ...,
         mode: InjectableMode | InjectableModeStr = ...,
     ):
         """
@@ -98,10 +98,10 @@ class Module:
     def set_constant[T](
         self,
         instance: T,
-        on: TypeInfo[T] = ...,
+        on: _TypeInfo[T] = ...,
         *,
         mode: InjectableMode | InjectableModeStr = ...,
-    ) -> T:
+    ) -> Self:
         """
         Function for registering a specific instance to be injected. This is useful for
         registering global variables. The difference with the singleton decorator is
@@ -125,7 +125,7 @@ class Module:
         cls: type[T],
         *,
         cache: bool = ...,
-    ) -> Invertible[T | None]:
+    ) -> _Invertible[T | None]:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or `None`. Return a `Invertible` object. To access the instance
@@ -199,7 +199,7 @@ class Module:
         """
 
 @final
-class ModulePriority(StrEnum):
+class ModulePriority(Enum):
     LOW = ...
     HIGH = ...
 
@@ -212,7 +212,7 @@ class Injectable[T](Protocol):
     def get_instance(self) -> T: ...
 
 @final
-class InjectableMode(StrEnum):
+class InjectableMode(Enum):
     FALLBACK = ...
     NORMAL = ...
     OVERRIDE = ...

{python_injection-0.9.4.post0/injection → python_injection-0.9.6/injection/_core}/common/lazy.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable, Iterator, Mapping
 from types import MappingProxyType
 
-from injection.common.invertible import Invertible
+from injection._core.common.invertible import Invertible
 
 __all__ = ("Lazy", "LazyMapping")
 

{python_injection-0.9.4.post0/injection/common/tools → python_injection-0.9.6/injection/_core/common}/threading.py

@@ -1,3 +1,4 @@
+from collections.abc import Iterator
 from contextlib import contextmanager
 from threading import RLock
 
@@ -5,7 +6,7 @@ __all__ = ("synchronized",)
 
 
 @contextmanager
-def synchronized():
+def synchronized() -> Iterator[RLock]:
     lock = RLock()
 
     with lock:

{python_injection-0.9.4.post0/injection/common/tools → python_injection-0.9.6/injection/_core/common}/type.py

@@ -59,9 +59,9 @@ def analyze_types(*types: type | Any) -> Iterator[TypeReport[Any]]:
 
 def get_return_types(*args: TypeInfo[Any]) -> Iterator[type | UnionType]:
     for arg in args:
-        origin = get_origin(arg) or arg
-
-        if isinstance(origin, Iterable) and not isinstance(origin, type | str):
+        if isinstance(arg, Iterable) and not (
+            isinstance(arg, type | str) or isinstance(get_origin(arg), type)
+        ):
             inner_args = arg
 
         elif isfunction(arg):

{python_injection-0.9.4.post0/injection/core → python_injection-0.9.6/injection/_core}/module.py

@@ -30,12 +30,13 @@ from typing import (
     Self,
     runtime_checkable,
 )
+from uuid import uuid4
 
-from injection.common.event import Event, EventChannel, EventListener
-from injection.common.invertible import Invertible, SimpleInvertible
-from injection.common.lazy import Lazy, LazyMapping
-from injection.common.tools.threading import synchronized
-from injection.common.tools.type import (
+from injection._core.common.event import Event, EventChannel, EventListener
+from injection._core.common.invertible import Invertible, SimpleInvertible
+from injection._core.common.lazy import Lazy, LazyMapping
+from injection._core.common.threading import synchronized
+from injection._core.common.type import (
     TypeInfo,
     TypeReport,
     analyze_types,
@@ -65,12 +66,12 @@ Events
 
 
 @dataclass(frozen=True, slots=True)
-class ContainerEvent(Event, ABC):
-    on_container: Container
+class LocatorEvent(Event, ABC):
+    locator: Locator
 
 
 @dataclass(frozen=True, slots=True)
-class ContainerDependenciesUpdated(ContainerEvent):
+class LocatorDependenciesUpdated(LocatorEvent):
     reports: Collection[TypeReport]
     mode: Mode
 
@@ -78,14 +79,14 @@ class ContainerDependenciesUpdated(ContainerEvent):
         length = len(self.reports)
         formatted_types = ", ".join(f"`{report.type}`" for report in self.reports)
         return (
-            f"{length} container dependenc{'ies' if length > 1 else 'y'} have "
-            f"been updated{f': {formatted_types}' if formatted_types else ''}."
+            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):
-    on_module: Module
+    module: Module
 
 
 @dataclass(frozen=True, slots=True)
@@ -93,7 +94,7 @@ class ModuleEventProxy(ModuleEvent):
     event: Event
 
     def __str__(self) -> str:
-        return f"`{self.on_module}` has propagated an event: {self.origin}"
+        return f"`{self.module}` has propagated an event: {self.origin}"
 
     @property
     def history(self) -> Iterator[Event]:
@@ -113,7 +114,7 @@ class ModuleAdded(ModuleEvent):
     priority: Priority
 
     def __str__(self) -> str:
-        return f"`{self.on_module}` now uses `{self.module_added}`."
+        return f"`{self.module}` now uses `{self.module_added}`."
 
 
 @dataclass(frozen=True, slots=True)
@@ -121,7 +122,7 @@ class ModuleRemoved(ModuleEvent):
     module_removed: Module
 
     def __str__(self) -> str:
-        return f"`{self.on_module}` no longer uses `{self.module_removed}`."
+        return f"`{self.module}` no longer uses `{self.module_removed}`."
 
 
 @dataclass(frozen=True, slots=True)
@@ -131,7 +132,7 @@ class ModulePriorityUpdated(ModuleEvent):
 
     def __str__(self) -> str:
         return (
-            f"In `{self.on_module}`, the priority `{self.priority}` "
+            f"In `{self.module}`, the priority `{self.priority}` "
             f"has been applied to `{self.module_updated}`."
         )
 
@@ -232,7 +233,7 @@ class Broker(Protocol):
 
 
 """
-Container
+Locator
 """
 
 
@@ -259,13 +260,13 @@ class Record[T](NamedTuple):
 
 
 @dataclass(repr=False, frozen=True, slots=True)
-class Container(Broker):
+class Locator(Broker):
     __records: dict[TypeReport, Record] = field(default_factory=dict, init=False)
     __channel: EventChannel = field(default_factory=EventChannel, init=False)
 
     def __getitem__[T](self, cls: type[T] | UnionType, /) -> Injectable[T]:
         for report in analyze_types(cls):
-            for scoped_report in dict.fromkeys((report, report.no_args)):
+            for scoped_report in OrderedDict.fromkeys((report, report.no_args)):
                 try:
                     injectable, _ = self.__records[scoped_report]
                 except KeyError:
@@ -294,15 +295,16 @@ class Container(Broker):
         mode: Mode | ModeStr,
     ) -> Self:
         mode = Mode(mode)
+        record = Record(injectable, mode)
         records = {
-            report: Record(injectable, mode)
+            report: record
             for report in self.__prepare_reports_for_updating(classes, mode)
         }
 
         if records:
-            event = ContainerDependenciesUpdated(self, records.keys(), mode)
+            event = LocatorDependenciesUpdated(self, records.keys(), mode)
 
-            with self.notify(event):
+            with self.dispatch(event):
                 self.__records.update(records)
 
         return self
@@ -318,7 +320,7 @@ class Container(Broker):
         self.__channel.add_listener(listener)
         return self
 
-    def notify(self, event: Event) -> ContextManager:
+    def dispatch(self, event: Event) -> ContextManager:
         return self.__channel.dispatch(event)
 
     def __prepare_reports_for_updating(
@@ -367,25 +369,25 @@ type InjectableFactory[T] = Callable[[Callable[..., T]], Injectable[T]]
 
 
 @dataclass(eq=False, frozen=True, slots=True)
-class Module(EventListener, Broker):
-    name: str | None = field(default=None)
+class Module(Broker, EventListener):
+    name: str = field(default_factory=lambda: f"anonymous@{uuid4().hex[:7]}")
     __channel: EventChannel = field(
         default_factory=EventChannel,
         init=False,
         repr=False,
     )
-    __container: Container = field(
-        default_factory=Container,
+    __locator: Locator = field(
+        default_factory=Locator,
         init=False,
         repr=False,
     )
-    __modules: OrderedDict[Module, None] = field(
-        default_factory=OrderedDict,
+    __loggers: list[Logger] = field(
+        default_factory=lambda: [getLogger(__name__)],
         init=False,
         repr=False,
     )
-    __loggers: list[Logger] = field(
-        default_factory=lambda: [getLogger(__name__)],
+    __modules: OrderedDict[Module, None] = field(
+        default_factory=OrderedDict,
         init=False,
         repr=False,
     )
@@ -393,7 +395,7 @@ class Module(EventListener, Broker):
     __instances: ClassVar[dict[str, Module]] = {}
 
     def __post_init__(self):
-        self.__container.add_listener(self)
+        self.__locator.add_listener(self)
 
     def __getitem__[T](self, cls: type[T] | UnionType, /) -> Injectable[T]:
         for broker in self.__brokers:
@@ -402,9 +404,6 @@ class Module(EventListener, Broker):
 
         raise NoInjectable(cls)
 
-    def __setitem__[T](self, cls: type[T] | UnionType, injectable: Injectable[T], /):
-        self.update((cls,), injectable)
-
     def __contains__(self, cls: type | UnionType, /) -> bool:
         return any(cls in broker for broker in self.__brokers)
 
@@ -415,7 +414,7 @@ class Module(EventListener, Broker):
     @property
     def __brokers(self) -> Iterator[Broker]:
         yield from tuple(self.__modules)
-        yield self.__container
+        yield self.__locator
 
     def injectable[T](
         self,
@@ -455,7 +454,7 @@ class Module(EventListener, Broker):
         on: TypeInfo[T] = (),
         *,
         mode: Mode | ModeStr = Mode.get_default(),
-    ) -> T:
+    ) -> Self:
         cls = type(instance)
         self.injectable(
             lambda: instance,
@@ -463,7 +462,7 @@ class Module(EventListener, Broker):
             on=(cls, on),
             mode=mode,
         )
-        return instance
+        return self
 
     def inject(
         self,
@@ -517,7 +516,7 @@ class Module(EventListener, Broker):
         injectable: Injectable[T],
         mode: Mode | ModeStr = Mode.get_default(),
     ) -> Self:
-        self.__container.update(classes, injectable, mode)
+        self.__locator.update(classes, injectable, mode)
         return self
 
     def init_modules(self, *modules: Module) -> Self:
@@ -544,7 +543,7 @@ class Module(EventListener, Broker):
         priority = Priority(priority)
         event = ModuleAdded(self, module, priority)
 
-        with self.notify(event):
+        with self.dispatch(event):
             self.__modules[module] = None
             self.__move_module(module, priority)
             module.add_listener(self)
@@ -555,7 +554,7 @@ class Module(EventListener, Broker):
         event = ModuleRemoved(self, module)
 
         with suppress(KeyError):
-            with self.notify(event):
+            with self.dispatch(event):
                 self.__modules.pop(module)
                 module.remove_listener(self)
 
@@ -576,7 +575,7 @@ class Module(EventListener, Broker):
         priority = Priority(priority)
         event = ModulePriorityUpdated(self, module, priority)
 
-        with self.notify(event):
+        with self.dispatch(event):
             self.__move_module(module, priority)
 
         return self
@@ -602,15 +601,20 @@ class Module(EventListener, Broker):
 
     def on_event(self, event: Event, /) -> ContextManager:
         self_event = ModuleEventProxy(self, event)
-        return self.notify(self_event)
+        return self.dispatch(self_event)
 
     @contextmanager
-    def notify(self, event: Event):
+    def dispatch(self, event: Event):
         self.__check_locking()
 
         with self.__channel.dispatch(event):
             yield
-            self.__send_debug(event)
+            message = str(event)
+            self.__debug(message)
+
+    def __debug(self, message: object):
+        for logger in tuple(self.__loggers):
+            logger.debug(message)
 
     def __check_locking(self):
         if self.is_locked:
@@ -626,10 +630,6 @@ class Module(EventListener, Broker):
                 f"`{module}` can't be found in the modules used by `{self}`."
             ) from exc
 
-    def __send_debug(self, message: object):
-        for logger in tuple(self.__loggers):
-            logger.debug(message)
-
     @classmethod
     def from_name(cls, name: str) -> Self:
         with suppress(KeyError):
@@ -816,7 +816,7 @@ class InjectedFunction(EventListener):
     @contextmanager
     def _(self, event: ModuleEvent, /):
         yield
-        self.update(event.on_module)
+        self.update(event.module)
 
     def __setup(self):
         queue = self.__setup_queue

{python_injection-0.9.4.post0 → python_injection-0.9.6}/injection/integrations/blacksheep.py

@@ -22,7 +22,6 @@ class InjectionServices(ContainerProtocol):
 
     def register(self, obj_type: type | Any, *args, **kwargs):
         self.__module.injectable(obj_type)
-        return self
 
     def resolve[T](self, obj_type: type[T] | Any, *args, **kwargs) -> T:
         return self.__module.find_instance(obj_type)

python_injection-0.9.6/injection/testing/__init__.py

@@ -0,0 +1,35 @@
+from contextlib import contextmanager
+from functools import partial
+
+from injection import Module, ModulePriority, mod
+
+__all__ = (
+    "set_test_constant",
+    "should_be_test_injectable",
+    "test_injectable",
+    "test_singleton",
+    "use_test_injectables",
+)
+
+
+tmod = partial(mod, "testing")
+
+set_test_constant = tmod().set_constant
+should_be_test_injectable = tmod().should_be_injectable
+test_injectable = tmod().injectable
+test_singleton = tmod().singleton
+
+
+@contextmanager
+def use_test_injectables(*, module: Module = None, test_module: Module = None):
+    module = module or mod()
+    test_module = test_module or tmod()
+
+    for m in (module, test_module):
+        m.unlock()
+
+    del m
+
+    with module.use_temporarily(test_module, priority=ModulePriority.HIGH):
+        yield
+        module.unlock()

{python_injection-0.9.4.post0 → python_injection-0.9.6}/injection/testing/__init__.pyi

@@ -11,7 +11,7 @@ test_singleton = _.singleton
 
 def use_test_injectables(
     *,
-    on: Module = ...,
+    module: Module = ...,
     test_module: Module = ...,
 ) -> ContextManager | ContextDecorator:
     """

{python_injection-0.9.4.post0 → python_injection-0.9.6}/injection/utils.py

@@ -1,12 +1,15 @@
-from collections.abc import Callable
+from collections.abc import Callable, Iterator
 from importlib import import_module
 from pkgutil import walk_packages
-from types import ModuleType
+from types import ModuleType as PythonModule
 
 __all__ = ("load_package",)
 
 
-def load_package(package: ModuleType | str, predicate: Callable[[str], bool] = None):
+def load_package(
+    package: PythonModule | str,
+    predicate: Callable[[str], bool] = lambda module_name: True,
+) -> dict[str, PythonModule]:
     """
     Function for importing all modules in a Python package.
     Pass the `predicate` parameter if you want to filter the modules to be imported.
@@ -15,6 +18,13 @@ def load_package(package: ModuleType | str, predicate: Callable[[str], bool] = N
     if isinstance(package, str):
         package = import_module(package)
 
+    return dict(__iter_modules_from(package, predicate))
+
+
+def __iter_modules_from(
+    package: PythonModule,
+    predicate: Callable[[str], bool],
+) -> Iterator[tuple[str, PythonModule]]:
     try:
         path = package.__path__
     except AttributeError as exc:
@@ -22,15 +32,10 @@ def load_package(package: ModuleType | str, predicate: Callable[[str], bool] = N
             "Package has no `__path__` attribute, as it's probably a module."
         ) from exc
 
-    if predicate is None:
-
-        def predicate(_: str) -> bool:
-            return True
-
     for info in walk_packages(path=path, prefix=f"{package.__name__}."):
         name = info.name
 
         if info.ispkg or not predicate(name):
             continue
 
-        import_module(name)
+        yield name, import_module(name)

{python_injection-0.9.4.post0 → python_injection-0.9.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-injection"
-version = "0.9.4.post0"
+version = "0.9.6"
 description = "Fast and easy dependency injection framework."
 license = "MIT"
 authors = ["remimd"]

python_injection-0.9.4.post0/injection/testing/__init__.py

@@ -1,35 +0,0 @@
-from contextlib import contextmanager
-from functools import partial
-
-from injection import Module, ModulePriority, mod
-
-__all__ = (
-    "set_test_constant",
-    "should_be_test_injectable",
-    "test_injectable",
-    "test_singleton",
-    "use_test_injectables",
-)
-
-
-testing_mod = partial(mod, "testing")
-
-set_test_constant = testing_mod().set_constant
-should_be_test_injectable = testing_mod().should_be_injectable
-test_injectable = testing_mod().injectable
-test_singleton = testing_mod().singleton
-
-
-@contextmanager
-def use_test_injectables(*, on: Module = None, test_module: Module = None):
-    on = on or mod()
-    test_module = test_module or testing_mod()
-
-    for module in (on, test_module):
-        module.unlock()
-
-    del module
-
-    with on.use_temporarily(test_module, priority=ModulePriority.HIGH):
-        yield
-        on.unlock()