python-injection 0.6.7__tar.gz → 0.6.9__tar.gz

{python_injection-0.6.7 → python_injection-0.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.6.7
+Version: 0.6.9
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT
@@ -19,6 +19,8 @@ Description-Content-Type: text/markdown
 
 ## Create an injectable
 
+> **Note**: If the class needs dependencies, these will be resolved when the instance is retrieved.
+
 If you wish to inject a singleton, use `singleton` decorator.
 
 ```python
@@ -39,7 +41,14 @@ class Injectable:
     """ class implementation """
 ```
 
-> **Note**: If the class needs dependencies, these will be resolved when the instance is retrieved.
+If you have a constant (such as a global variable) and wish to register it as an injectable, use `set_constant`
+function.
+
+```python
+from injection import set_constant
+
+app = set_constant(Application())
+```
 
 ## Inject an instance
 
@@ -57,6 +66,9 @@ def my_function(instance: Injectable):
 If `inject` decorates a class, it will be applied to the `__init__` method.
 _Especially useful for dataclasses:_
 
+> **Note**: Doesn't work with Pydantic `BaseModel` because the signature of the `__init__` method doesn't contain the
+> dependencies.
+
 ```python
 from dataclasses import dataclass
 
@@ -68,9 +80,6 @@ class DataClass:
     instance: Injectable = ...
 ```
 
-> **Note**: Doesn't work with Pydantic `BaseModel` because the signature of the `__init__` method doesn't contain the
-> dependencies.
-
 ## Get an instance
 
 _Example with `get_instance` function:_

{python_injection-0.6.7 → python_injection-0.6.9}/documentation/basic-usage.md

@@ -2,6 +2,8 @@
 
 ## Create an injectable
 
+> **Note**: If the class needs dependencies, these will be resolved when the instance is retrieved.
+
 If you wish to inject a singleton, use `singleton` decorator.
 
 ```python
@@ -22,7 +24,14 @@ class Injectable:
     """ class implementation """
 ```
 
-> **Note**: If the class needs dependencies, these will be resolved when the instance is retrieved.
+If you have a constant (such as a global variable) and wish to register it as an injectable, use `set_constant`
+function.
+
+```python
+from injection import set_constant
+
+app = set_constant(Application())
+```
 
 ## Inject an instance
 
@@ -40,6 +49,9 @@ def my_function(instance: Injectable):
 If `inject` decorates a class, it will be applied to the `__init__` method.
 _Especially useful for dataclasses:_
 
+> **Note**: Doesn't work with Pydantic `BaseModel` because the signature of the `__init__` method doesn't contain the
+> dependencies.
+
 ```python
 from dataclasses import dataclass
 
@@ -51,9 +63,6 @@ class DataClass:
     instance: Injectable = ...
 ```
 
-> **Note**: Doesn't work with Pydantic `BaseModel` because the signature of the `__init__` method doesn't contain the
-> dependencies.
-
 ## Get an instance
 
 _Example with `get_instance` function:_

{python_injection-0.6.7 → python_injection-0.6.9}/injection/_pkg.py

@@ -1,6 +1,7 @@
-from .core import Module, ModulePriorities
+from .core import Injectable, Module, ModulePriorities
 
 __all__ = (
+    "Injectable",
     "Module",
     "ModulePriorities",
     "default_module",
@@ -8,6 +9,7 @@ __all__ = (
     "get_lazy_instance",
     "inject",
     "injectable",
+    "set_constant",
     "singleton",
 )
 
@@ -15,7 +17,7 @@ default_module = Module(f"{__name__}:default_module")
 
 get_instance = default_module.get_instance
 get_lazy_instance = default_module.get_lazy_instance
-
 inject = default_module.inject
 injectable = default_module.injectable
+set_constant = default_module.set_constant
 singleton = default_module.singleton

{python_injection-0.6.7 → python_injection-0.6.9}/injection/_pkg.pyi

@@ -1,8 +1,17 @@
+from abc import abstractmethod
 from collections.abc import Callable, Iterable
 from contextlib import ContextDecorator
 from enum import Enum
 from types import UnionType
-from typing import Any, ContextManager, Final, TypeVar, final
+from typing import (
+    Any,
+    ContextManager,
+    Final,
+    Protocol,
+    TypeVar,
+    final,
+    runtime_checkable,
+)
 
 from injection.common.lazy import Lazy
 
@@ -12,9 +21,9 @@ default_module: Final[Module] = ...
 
 get_instance = default_module.get_instance
 get_lazy_instance = default_module.get_lazy_instance
-
 inject = default_module.inject
 injectable = default_module.injectable
+set_constant = default_module.set_constant
 singleton = default_module.singleton
 
 @final
@@ -40,6 +49,7 @@ class Module:
         wrapped: Callable[..., Any] = ...,
         /,
         *,
+        cls: type[Injectable] = ...,
         on: type | Iterable[type] | UnionType = ...,
     ):
         """
@@ -59,12 +69,22 @@ class Module:
         singleton will be constructed. At injection time, the injected instance will
         always be the same.
         """
-    def get_instance(self, cls: type[_T] | UnionType) -> _T | None:
+    def set_constant(
+        self,
+        instance: _T,
+        on: type | Iterable[type] | UnionType = ...,
+    ) -> _T:
+        """
+        Function for registering a specific instance to be injected. This is useful for
+        registering global variables. The difference with the singleton decorator is
+        that no dependencies are resolved, so the module doesn't need to be locked.
+        """
+    def get_instance(self, cls: type[_T]) -> _T | None:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or return `None`.
         """
-    def get_lazy_instance(self, cls: type[_T] | UnionType) -> Lazy[_T | None]:
+    def get_lazy_instance(self, cls: type[_T]) -> Lazy[_T | None]:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or `None`. Return a `Lazy` object. To access the instance contained
@@ -107,3 +127,12 @@ class Module:
 class ModulePriorities(Enum):
     HIGH = ...
     LOW = ...
+
+@runtime_checkable
+class Injectable(Protocol[_T]):
+    def __init__(self, factory: Callable[[], _T] = ..., *args, **kwargs): ...
+    @property
+    def is_locked(self) -> bool: ...
+    def unlock(self): ...
+    @abstractmethod
+    def get_instance(self) -> _T: ...

python_injection-0.6.9/injection/common/tools/_type.py

@@ -0,0 +1,48 @@
+from collections.abc import Iterable, Iterator
+from inspect import get_annotations, isfunction
+from types import NoneType, UnionType
+from typing import Annotated, Any, Union, get_args, get_origin
+
+__all__ = ("find_types", "format_type", "get_origins")
+
+
+def format_type(cls: type | Any) -> str:
+    try:
+        return f"{cls.__module__}.{cls.__qualname__}"
+    except AttributeError:
+        return str(cls)
+
+
+def get_origins(*types: type | Any) -> Iterator[type | Any]:
+    for tp in types:
+        origin = get_origin(tp) or tp
+
+        if origin in (None, NoneType):
+            continue
+
+        elif origin in (Union, UnionType):
+            args = get_args(tp)
+
+        elif origin is Annotated is not tp:
+            args = (tp.__origin__,)
+
+        else:
+            yield origin
+            continue
+
+        yield from get_origins(*args)
+
+
+def find_types(*args: Any) -> Iterator[type | UnionType]:
+    for argument in args:
+        if isinstance(argument, Iterable) and not isinstance(argument, type | str):
+            arguments = argument
+
+        elif isfunction(argument):
+            arguments = (get_annotations(argument, eval_str=True).get("return"),)
+
+        else:
+            yield argument
+            continue
+
+        yield from find_types(*arguments)

{python_injection-0.6.7 → python_injection-0.6.9}/injection/core/module.py

@@ -15,8 +15,8 @@ from collections.abc import (
 from contextlib import ContextDecorator, contextmanager, suppress
 from dataclasses import dataclass, field
 from enum import Enum, auto
-from functools import singledispatchmethod, wraps
-from inspect import Signature, get_annotations, isclass, isfunction
+from functools import partialmethod, singledispatchmethod, wraps
+from inspect import Signature, isclass
 from threading import RLock
 from types import MappingProxyType, UnionType
 from typing import (
@@ -26,13 +26,12 @@ from typing import (
     Protocol,
     TypeVar,
     cast,
-    final,
     runtime_checkable,
 )
 
 from injection.common.event import Event, EventChannel, EventListener
 from injection.common.lazy import Lazy, LazyMapping
-from injection.common.tools import format_type, get_origins
+from injection.common.tools import find_types, format_type, get_origins
 from injection.exceptions import (
     ModuleError,
     ModuleLockError,
@@ -46,6 +45,7 @@ _logger = logging.getLogger(__name__)
 _thread_lock = RLock()
 
 _T = TypeVar("_T")
+Types = Iterable[type] | UnionType
 
 
 """
@@ -132,6 +132,9 @@ Injectables
 class Injectable(Protocol[_T]):
     __slots__ = ()
 
+    def __init__(self, factory: Callable[[], _T] = ..., *args, **kwargs):
+        ...
+
     @property
     def is_locked(self) -> bool:
         return False
@@ -211,7 +214,7 @@ class Container:
     def __injectables(self) -> frozenset[Injectable]:
         return frozenset(self.__data.values())
 
-    def update(self, classes: Iterable[type] | UnionType, injectable: Injectable):
+    def update(self, classes: Types, injectable: Injectable):
         classes = frozenset(get_origins(*classes))
 
         if classes:
@@ -287,18 +290,6 @@ class Module(EventListener):
     def __str__(self) -> str:
         return self.name or object.__str__(self)
 
-    @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)
-
     @property
     def is_locked(self) -> bool:
         return any(broker.is_locked for broker in self.__brokers)
@@ -308,7 +299,58 @@ class Module(EventListener):
         yield from tuple(self.__modules)
         yield self.__container
 
-    def get_instance(self, cls: type[_T] | UnionType) -> _T | None:
+    def injectable(
+        self,
+        wrapped: Callable[..., Any] = None,
+        /,
+        *,
+        cls: type[Injectable] = NewInjectable,
+        on: type | Types = None,
+    ):
+        def decorator(wp):
+            factory = self.inject(wp, return_factory=True)
+            injectable = cls(factory)
+            classes = find_types(wp, on)
+            self.update(classes, injectable)
+            return wp
+
+        return decorator(wrapped) if wrapped else decorator
+
+    singleton = partialmethod(injectable, cls=SingletonInjectable)
+
+    def set_constant(self, instance: _T, on: type | Types = None) -> _T:
+        cls = type(instance)
+
+        @self.injectable(on=(cls, on))
+        def get_constant():
+            return instance
+
+        return instance
+
+    def inject(
+        self,
+        wrapped: Callable[..., Any] = None,
+        /,
+        *,
+        return_factory: bool = False,
+    ):
+        def decorator(wp):
+            if not return_factory and isclass(wp):
+                wp.__init__ = decorator(wp.__init__)
+                return wp
+
+            lazy_binder = Lazy[Binder](lambda: self.__new_binder(wp))
+
+            @wraps(wp)
+            def wrapper(*args, **kwargs):
+                arguments = (~lazy_binder).bind(*args, **kwargs)
+                return wp(*arguments.args, **arguments.kwargs)
+
+            return wrapper
+
+        return decorator(wrapped) if wrapped else decorator
+
+    def get_instance(self, cls: type[_T]) -> _T | None:
         try:
             injectable = self[cls]
         except KeyError:
@@ -317,10 +359,10 @@ class Module(EventListener):
         instance = injectable.get_instance()
         return cast(cls, instance)
 
-    def get_lazy_instance(self, cls: type[_T] | UnionType) -> Lazy[_T | None]:
+    def get_lazy_instance(self, cls: type[_T]) -> Lazy[_T | None]:
         return Lazy(lambda: self.get_instance(cls))
 
-    def update(self, classes: Iterable[type] | UnionType, injectable: Injectable):
+    def update(self, classes: Types, injectable: Injectable):
         self.__container.update(classes, injectable)
         return self
 
@@ -410,6 +452,12 @@ class Module(EventListener):
                 f"`{module}` can't be found in the modules used by `{self}`."
             ) from exc
 
+    def __new_binder(self, target: Callable[..., Any]) -> Binder:
+        signature = inspect.signature(target, eval_str=True)
+        binder = Binder(signature).update(self)
+        self.add_listener(binder)
+        return binder
+
 
 """
 Binder
@@ -492,95 +540,3 @@ class Binder(EventListener):
     def _(self, event: ModuleEvent, /) -> ContextManager:
         yield
         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 isclass(wp):
-                return self.__class_decorator(wp)
-
-            return self.__decorator(wp)
-
-        return decorator(wrapped) if wrapped else decorator
-
-    def __decorator(self, function: Callable[..., Any], /) -> Callable[..., Any]:
-        lazy_binder = Lazy[Binder](lambda: self.__new_binder(function))
-
-        @wraps(function)
-        def wrapper(*args, **kwargs):
-            arguments = (~lazy_binder).bind(*args, **kwargs)
-            return function(*arguments.args, **arguments.kwargs)
-
-        return wrapper
-
-    def __class_decorator(self, cls: type, /) -> type:
-        cls.__init__ = self.__decorator(cls.__init__)
-        return cls
-
-    def __new_binder(self, function: Callable[..., Any]) -> Binder:
-        signature = inspect.signature(function, eval_str=True)
-        binder = Binder(signature).update(self.__module)
-        self.__module.add_listener(binder)
-        return binder
-
-
-@final
-@dataclass(repr=False, frozen=True, slots=True)
-class InjectableDecorator:
-    __module: Module
-    __injectable_type: type[BaseInjectable]
-
-    def __repr__(self) -> str:
-        return f"<{self.__injectable_type.__qualname__} decorator>"
-
-    def __call__(
-        self,
-        wrapped: Callable[..., Any] = None,
-        /,
-        *,
-        on: type | Iterable[type] | UnionType = None,
-    ):
-        def decorator(wp):
-            @lambda fn: fn()
-            def classes():
-                if cls := self.__get_class(wp):
-                    yield cls
-
-                if on is None:
-                    return
-                elif isinstance(on, type | str):
-                    yield on
-                else:
-                    yield from on
-
-            @self.__module.inject
-            @wraps(wp, updated=())
-            def factory(*args, **kwargs):
-                return wp(*args, **kwargs)
-
-            injectable = self.__injectable_type(factory)
-            self.__module.update(classes, injectable)
-
-            return wp
-
-        return decorator(wrapped) if wrapped else decorator
-
-    @staticmethod
-    def __get_class(wrapped: Callable[..., Any]) -> type | None:
-        if isclass(wrapped):
-            return wrapped
-
-        if isfunction(wrapped):
-            return get_annotations(wrapped, eval_str=True).get("return")
-
-        return None

{python_injection-0.6.7 → python_injection-0.6.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-injection"
-version = "0.6.7"
+version = "0.6.9"
 description = "Fast and easy dependency injection framework."
 authors = ["remimd"]
 keywords = ["dependencies", "inject", "injection"]
@@ -14,7 +14,7 @@ python = ">=3.10, <4"
 
 [tool.poetry.group.dev.dependencies]
 black = "*"
-blacksheep = "^2.0.4"
+blacksheep = "^2.0.5"
 flake8 = "*"
 isort = "*"
 pydantic = "^2.5.3"

python_injection-0.6.7/injection/common/tools/_type.py

@@ -1,35 +0,0 @@
-from types import NoneType, UnionType
-from typing import Any, Iterator, Union, get_args
-
-__all__ = ("format_type", "get_origins")
-
-
-def format_type(cls: type | Any) -> str:
-    try:
-        return f"{cls.__module__}.{cls.__qualname__}"
-    except AttributeError:
-        return str(cls)
-
-
-def get_full_origin(cls: type | Any) -> type | Any:
-    try:
-        origin = cls.__origin__
-    except AttributeError:
-        return cls
-
-    return get_full_origin(origin)
-
-
-def get_origins(*classes: type | Any) -> Iterator[type | Any]:
-    for cls in classes:
-        if cls in (None, NoneType):
-            continue
-
-        origin = get_full_origin(cls)
-
-        if origin is Union or isinstance(cls, UnionType):
-            for argument in get_args(cls):
-                yield from get_origins(argument)
-
-        else:
-            yield origin