python-injection 0.9.5__tar.gz → 0.9.7__tar.gz

{python_injection-0.9.5 → python_injection-0.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.9.5
+Version: 0.9.7
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT
@@ -63,6 +63,18 @@ service_c = ServiceC()
 set_constant(service_c)
 ```
 
+Or here is the decorator `constant` which is equivalent:
+
+> Unlike `@singleton`, dependencies will not be resolved.
+
+```python
+from injection import constant
+
+@constant
+class ServiceC:
+    """ class implementation """
+```
+
 ## Inject an instance
 
 To inject one or several instances, use `inject` decorator.
@@ -173,3 +185,18 @@ def service_d_recipe() -> ServiceD:
     """ recipe implementation """
 ```
 
+## Working with type aliases
+
+```python
+from injection import injectable, set_constant
+
+type APIKey = str
+
+set_constant("<secret_api_key>", APIKey, alias=True)
+
+@injectable
+class Client:
+    def __init__(self, api_key: APIKey):
+        ...
+```
+

{python_injection-0.9.5 → python_injection-0.9.7}/documentation/basic-usage.md

@@ -37,6 +37,18 @@ service_c = ServiceC()
 set_constant(service_c)
 ```
 
+Or here is the decorator `constant` which is equivalent:
+
+> Unlike `@singleton`, dependencies will not be resolved.
+
+```python
+from injection import constant
+
+@constant
+class ServiceC:
+    """ class implementation """
+```
+
 ## Inject an instance
 
 To inject one or several instances, use `inject` decorator.
@@ -146,3 +158,18 @@ from injection import injectable
 def service_d_recipe() -> ServiceD:
     """ recipe implementation """
 ```
+
+## Working with type aliases
+
+```python
+from injection import injectable, set_constant
+
+type APIKey = str
+
+set_constant("<secret_api_key>", APIKey, alias=True)
+
+@injectable
+class Client:
+    def __init__(self, api_key: APIKey):
+        ...
+```

{python_injection-0.9.5 → python_injection-0.9.7}/injection/__init__.py

@@ -1,12 +1,13 @@
-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",
     "InjectableMode",
     "Module",
     "ModulePriority",
+    "constant",
     "find_instance",
     "get_instance",
     "get_lazy_instance",
@@ -26,6 +27,7 @@ def mod(name: str = None, /) -> Module:
     return Module.from_name(name)
 
 
+constant = mod().constant
 find_instance = mod().find_instance
 get_instance = mod().get_instance
 get_lazy_instance = mod().get_lazy_instance

{python_injection-0.9.5 → python_injection-0.9.7}/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 (
@@ -9,18 +9,20 @@ from typing import (
     ContextManager,
     Protocol,
     Self,
+    TypeAliasType,
     final,
     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 = ...
 
+constant = _.constant
 find_instance = _.find_instance
 get_instance = _.get_instance
 get_lazy_instance = _.get_lazy_instance
@@ -47,7 +49,7 @@ class Module:
     """
 
     def __init__(self, name: str = ...): ...
-    def __contains__(self, cls: type | UnionType, /) -> bool: ...
+    def __contains__(self, cls: type | UnionType | TypeAliasType, /) -> bool: ...
     @property
     def is_locked(self) -> bool: ...
     def inject(self, wrapped: Callable[..., Any] = ..., /):
@@ -62,9 +64,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 +81,7 @@ class Module:
         /,
         *,
         inject: bool = ...,
-        on: TypeInfo[T] = ...,
+        on: _TypeInfo[T] = ...,
         mode: InjectableMode | InjectableModeStr = ...,
     ):
         """
@@ -95,11 +97,26 @@ class Module:
         registered.
         """
 
+    def constant[T](
+        self,
+        wrapped: Callable[..., T] = ...,
+        /,
+        *,
+        on: _TypeInfo[T] = ...,
+        mode: InjectableMode | InjectableModeStr = ...,
+    ):
+        """
+        Decorator applicable to a class or function. It is used to indicate how the
+        constant is constructed. At injection time, the injected instance will always
+        be the same. Unlike `@singleton`, dependencies will not be resolved.
+        """
+
     def set_constant[T](
         self,
         instance: T,
-        on: TypeInfo[T] = ...,
+        on: _TypeInfo[T] = ...,
         *,
+        alias: bool = ...,
         mode: InjectableMode | InjectableModeStr = ...,
     ) -> Self:
         """
@@ -108,13 +125,13 @@ class Module:
         that no dependencies are resolved, so the module doesn't need to be locked.
         """
 
-    def find_instance[T](self, cls: type[T]) -> T:
+    def find_instance[T](self, cls: type[T] | TypeAliasType) -> T:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or an exception will be raised.
         """
 
-    def get_instance[T](self, cls: type[T]) -> T | None:
+    def get_instance[T](self, cls: type[T] | TypeAliasType) -> T | None:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or return `None`.
@@ -122,10 +139,10 @@ class Module:
 
     def get_lazy_instance[T](
         self,
-        cls: type[T],
+        cls: type[T] | TypeAliasType,
         *,
         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 +216,7 @@ class Module:
         """
 
 @final
-class ModulePriority(StrEnum):
+class ModulePriority(Enum):
     LOW = ...
     HIGH = ...
 
@@ -212,7 +229,7 @@ class Injectable[T](Protocol):
     def get_instance(self) -> T: ...
 
 @final
-class InjectableMode(StrEnum):
+class InjectableMode(Enum):
     FALLBACK = ...
     NORMAL = ...
     OVERRIDE = ...

{python_injection-0.9.5/injection → python_injection-0.9.7/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.5/injection/common/tools → python_injection-0.9.7/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.5/injection/common/tools → python_injection-0.9.7/injection/_core/common}/type.py

@@ -6,6 +6,7 @@ from typing import (
     Any,
     NamedTuple,
     Self,
+    TypeAliasType,
     Union,
     get_args,
     get_origin,
@@ -13,7 +14,9 @@ from typing import (
 
 __all__ = ("TypeInfo", "TypeReport", "analyze_types", "get_return_types")
 
-type TypeInfo[T] = type[T] | Callable[..., T] | Iterable[TypeInfo[T]] | UnionType
+type TypeInfo[T] = (
+    type[T] | Callable[..., T] | Iterable[TypeInfo[T]] | UnionType | TypeAliasType
+)
 
 
 class TypeReport[T](NamedTuple):
@@ -57,7 +60,9 @@ def analyze_types(*types: type | Any) -> Iterator[TypeReport[Any]]:
         yield from analyze_types(*inner_types)
 
 
-def get_return_types(*args: TypeInfo[Any]) -> Iterator[type | UnionType]:
+def get_return_types(
+    *args: TypeInfo[Any],
+) -> Iterator[type | UnionType | TypeAliasType]:
     for arg in args:
         if isinstance(arg, Iterable) and not (
             isinstance(arg, type | str) or isinstance(get_origin(arg), type)

{python_injection-0.9.5/injection/core → python_injection-0.9.7/injection/_core}/module.py

@@ -28,14 +28,16 @@ from typing import (
     NoReturn,
     Protocol,
     Self,
+    TypeAliasType,
     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 +67,12 @@ Events
 
 
 @dataclass(frozen=True, slots=True)
-class ContainerEvent(Event, ABC):
-    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,8 +80,8 @@ 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 ""}."
         )
 
 
@@ -214,11 +216,15 @@ class Broker(Protocol):
     __slots__ = ()
 
     @abstractmethod
-    def __getitem__[T](self, cls: type[T] | UnionType, /) -> Injectable[T]:
+    def __getitem__[T](
+        self,
+        cls: type[T] | UnionType | TypeAliasType,
+        /,
+    ) -> Injectable[T]:
         raise NotImplementedError
 
     @abstractmethod
-    def __contains__(self, cls: type | UnionType, /) -> bool:
+    def __contains__(self, cls: type | UnionType | TypeAliasType, /) -> bool:
         raise NotImplementedError
 
     @property
@@ -232,7 +238,7 @@ class Broker(Protocol):
 
 
 """
-Container
+Locator
 """
 
 
@@ -259,11 +265,15 @@ 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]:
+    def __getitem__[T](
+        self,
+        cls: type[T] | UnionType | TypeAliasType,
+        /,
+    ) -> Injectable[T]:
         for report in analyze_types(cls):
             for scoped_report in OrderedDict.fromkeys((report, report.no_args)):
                 try:
@@ -275,7 +285,7 @@ class Container(Broker):
 
         raise NoInjectable(cls)
 
-    def __contains__(self, cls: type | UnionType, /) -> bool:
+    def __contains__(self, cls: type | UnionType | TypeAliasType, /) -> bool:
         return any(report in self.__records for report in analyze_types(cls))
 
     @property
@@ -289,18 +299,19 @@ class Container(Broker):
     @synchronized()
     def update[T](
         self,
-        classes: Iterable[type[T] | UnionType],
+        classes: Iterable[type[T] | UnionType | TypeAliasType],
         injectable: Injectable[T],
         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.dispatch(event):
                 self.__records.update(records)
@@ -323,7 +334,7 @@ class Container(Broker):
 
     def __prepare_reports_for_updating(
         self,
-        classes: Iterable[type | UnionType],
+        classes: Iterable[type | UnionType | TypeAliasType],
         mode: Mode,
     ) -> Iterator[TypeReport]:
         rank = mode.rank
@@ -367,25 +378,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,19 +404,20 @@ 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]:
+    def __getitem__[T](
+        self,
+        cls: type[T] | UnionType | TypeAliasType,
+        /,
+    ) -> Injectable[T]:
         for broker in self.__brokers:
             with suppress(KeyError):
                 return broker[cls]
 
         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:
+    def __contains__(self, cls: type | UnionType | TypeAliasType, /) -> bool:
         return any(cls in broker for broker in self.__brokers)
 
     @property
@@ -415,7 +427,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,
@@ -449,18 +461,41 @@ class Module(EventListener, Broker):
 
         return decorator(wrapped) if wrapped else decorator
 
+    def constant[T](
+        self,
+        wrapped: Callable[..., T] = None,
+        /,
+        *,
+        on: TypeInfo[T] = (),
+        mode: Mode | ModeStr = Mode.get_default(),
+    ):
+        def decorator(wp):
+            instance = wp()
+            self.set_constant(
+                instance,
+                on=on,
+                mode=mode,
+            )
+            return wp
+
+        return decorator(wrapped) if wrapped else decorator
+
     def set_constant[T](
         self,
         instance: T,
         on: TypeInfo[T] = (),
         *,
+        alias: bool = False,
         mode: Mode | ModeStr = Mode.get_default(),
     ) -> Self:
-        cls = type(instance)
+        if not alias:
+            cls = type(instance)
+            on = (cls, on)
+
         self.injectable(
             lambda: instance,
             inject=False,
-            on=(cls, on),
+            on=on,
             mode=mode,
         )
         return self
@@ -488,11 +523,11 @@ class Module(EventListener, Broker):
 
         return decorator(wrapped) if wrapped else decorator
 
-    def find_instance[T](self, cls: type[T]) -> T:
+    def find_instance[T](self, cls: type[T] | TypeAliasType) -> T:
         injectable = self[cls]
         return injectable.get_instance()
 
-    def get_instance[T](self, cls: type[T]) -> T | None:
+    def get_instance[T](self, cls: type[T] | TypeAliasType) -> T | None:
         try:
             return self.find_instance(cls)
         except KeyError:
@@ -500,7 +535,7 @@ class Module(EventListener, Broker):
 
     def get_lazy_instance[T](
         self,
-        cls: type[T],
+        cls: type[T] | TypeAliasType,
         *,
         cache: bool = False,
     ) -> Invertible[T | None]:
@@ -513,11 +548,11 @@ class Module(EventListener, Broker):
 
     def update[T](
         self,
-        classes: Iterable[type[T] | UnionType],
+        classes: Iterable[type[T] | UnionType | TypeAliasType],
         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:

{python_injection-0.9.5 → python_injection-0.9.7}/injection/testing/__init__.py

@@ -1,21 +1,24 @@
 from contextlib import contextmanager
-from functools import partial
 
 from injection import Module, ModulePriority, mod
 
 __all__ = (
     "set_test_constant",
     "should_be_test_injectable",
+    "test_constant",
     "test_injectable",
     "test_singleton",
     "use_test_injectables",
 )
 
 
-tmod = partial(mod, "testing")
+def tmod() -> Module:
+    return mod("testing")
+
 
 set_test_constant = tmod().set_constant
 should_be_test_injectable = tmod().should_be_injectable
+test_constant = tmod().constant
 test_injectable = tmod().injectable
 test_singleton = tmod().singleton
 

{python_injection-0.9.5 → python_injection-0.9.7}/injection/testing/__init__.pyi

@@ -6,6 +6,7 @@ from injection import Module
 
 set_test_constant = _.set_constant
 should_be_test_injectable = _.should_be_injectable
+test_constant = _.constant
 test_injectable = _.injectable
 test_singleton = _.singleton
 

{python_injection-0.9.5 → python_injection-0.9.7}/injection/utils.py

@@ -1,15 +1,15 @@
 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,
+    package: PythonModule | str,
     predicate: Callable[[str], bool] = lambda module_name: True,
-) -> tuple[ModuleType, ...]:
+) -> 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.
@@ -18,13 +18,13 @@ def load_package(
     if isinstance(package, str):
         package = import_module(package)
 
-    return tuple(__iter_modules(package, predicate))
+    return dict(__iter_modules_from(package, predicate))
 
 
-def __iter_modules(
-    package: ModuleType,
+def __iter_modules_from(
+    package: PythonModule,
     predicate: Callable[[str], bool],
-) -> Iterator[ModuleType]:
+) -> Iterator[tuple[str, PythonModule]]:
     try:
         path = package.__path__
     except AttributeError as exc:
@@ -38,4 +38,4 @@ def __iter_modules(
         if info.ispkg or not predicate(name):
             continue
 
-        yield import_module(name)
+        yield name, import_module(name)

{python_injection-0.9.5 → python_injection-0.9.7}/pyproject.toml

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