python-injection 0.8.5__tar.gz → 0.9.1__tar.gz

{python_injection-0.8.5 → python_injection-0.9.1}/PKG-INFO

@@ -1,23 +1,21 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.8.5
+Version: 0.9.1
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT
 Keywords: dependencies,inject,injection
 Author: remimd
-Requires-Python: >=3.10,<4
+Requires-Python: >=3.12,<4
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Project-URL: Repository, https://github.com/100nm/python-injection
 Description-Content-Type: text/markdown
 
 # Basic usage
 
-## Create an injectable
+## Register an injectable
 
 > **Note**: If the class needs dependencies, these will be resolved when the instance is retrieved.
 

{python_injection-0.8.5 → python_injection-0.9.1}/documentation/basic-usage.md

@@ -1,6 +1,6 @@
 # Basic usage
 
-## Create an injectable
+## Register an injectable
 
 > **Note**: If the class needs dependencies, these will be resolved when the instance is retrieved.
 

python_injection-0.9.1/injection/__init__.py

@@ -0,0 +1,29 @@
+from .core import Injectable, Module
+from .core import Mode as InjectableMode
+from .core import Priority as ModulePriority
+
+__all__ = (
+    "Injectable",
+    "InjectableMode",
+    "Module",
+    "ModulePriority",
+    "get_instance",
+    "get_lazy_instance",
+    "inject",
+    "injectable",
+    "set_constant",
+    "should_be_injectable",
+    "singleton",
+)
+
+_module = Module.default()
+
+get_instance = _module.get_instance
+get_lazy_instance = _module.get_lazy_instance
+inject = _module.inject
+injectable = _module.injectable
+set_constant = _module.set_constant
+should_be_injectable = _module.should_be_injectable
+singleton = _module.singleton
+
+del _module

{python_injection-0.8.5 → python_injection-0.9.1}/injection/__init__.pyi

@@ -1,33 +1,34 @@
 from abc import abstractmethod
-from collections.abc import Callable, Iterable
+from collections.abc import Callable
 from contextlib import ContextDecorator
-from enum import Enum
+from enum import StrEnum
 from types import UnionType
 from typing import (
     Any,
     ContextManager,
-    Final,
-    Literal,
     Protocol,
-    TypeVar,
+    Self,
     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
 
-_T = TypeVar("_T")
-_T_co = TypeVar("_T_co", covariant=True)
+_module: Module = ...
 
-default_module: Final[Module] = ...
+get_instance = _module.get_instance
+get_lazy_instance = _module.get_lazy_instance
+inject = _module.inject
+injectable = _module.injectable
+set_constant = _module.set_constant
+should_be_injectable = _module.should_be_injectable
+singleton = _module.singleton
 
-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
-should_be_injectable = default_module.should_be_injectable
-singleton = default_module.singleton
+del _module
 
 @final
 class Module:
@@ -41,6 +42,8 @@ class Module:
 
     def __init__(self, name: str = ...): ...
     def __contains__(self, cls: type | UnionType, /) -> bool: ...
+    @property
+    def is_locked(self) -> bool: ...
     def inject(self, wrapped: Callable[..., Any] = ..., /):
         """
         Decorator applicable to a class or function. Inject function dependencies using
@@ -48,15 +51,15 @@ class Module:
         will be those of the `__init__` method.
         """
 
-    def injectable(
+    def injectable[T](
         self,
-        wrapped: Callable[..., Any] = ...,
+        wrapped: Callable[..., T] = ...,
         /,
         *,
-        cls: type[Injectable] = ...,
+        cls: InjectableFactory[T] = ...,
         inject: bool = ...,
-        on: type | Iterable[type] | UnionType = ...,
-        mode: InjectableMode | Literal["fallback", "normal", "override"] = ...,
+        on: TypeInfo[T] = ...,
+        mode: InjectableMode | InjectableModeStr = ...,
     ):
         """
         Decorator applicable to a class or function. It is used to indicate how the
@@ -64,14 +67,14 @@ class Module:
         injected each time.
         """
 
-    def singleton(
+    def singleton[T](
         self,
-        wrapped: Callable[..., Any] = ...,
+        wrapped: Callable[..., T] = ...,
         /,
         *,
         inject: bool = ...,
-        on: type | Iterable[type] | UnionType = ...,
-        mode: InjectableMode | Literal["fallback", "normal", "override"] = ...,
+        on: TypeInfo[T] = ...,
+        mode: InjectableMode | InjectableModeStr = ...,
     ):
         """
         Decorator applicable to a class or function. It is used to indicate how the
@@ -86,37 +89,37 @@ class Module:
         registered.
         """
 
-    def set_constant(
+    def set_constant[T](
         self,
-        instance: _T,
-        on: type | Iterable[type] | UnionType = ...,
+        instance: T,
+        on: TypeInfo[T] = ...,
         *,
-        mode: InjectableMode | Literal["fallback", "normal", "override"] = ...,
-    ) -> _T:
+        mode: InjectableMode | InjectableModeStr = ...,
+    ) -> 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 resolve(self, cls: type[_T]) -> _T:
+    def resolve[T](self, cls: type[T]) -> T:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or an exception will be raised.
         """
 
-    def get_instance(self, cls: type[_T]) -> _T | None:
+    def get_instance[T](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(
+    def get_lazy_instance[T](
         self,
-        cls: type[_T],
+        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
@@ -126,19 +129,24 @@ class Module:
         Example: instance = ~lazy_instance
         """
 
+    def init_modules(self, *modules: Module) -> Self:
+        """
+        Function to clean modules in use and to use those passed as parameters.
+        """
+
     def use(
         self,
         module: Module,
         *,
-        priority: ModulePriority | Literal["low", "high"] = ...,
-    ):
+        priority: ModulePriority | ModulePriorityStr = ...,
+    ) -> Self:
         """
         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.
         """
 
-    def stop_using(self, module: Module):
+    def stop_using(self, module: Module) -> Self:
         """
         Function to remove a module in use.
         """
@@ -147,7 +155,7 @@ class Module:
         self,
         module: Module,
         *,
-        priority: ModulePriority | Literal["low", "high"] = ...,
+        priority: ModulePriority | ModulePriorityStr = ...,
     ) -> ContextManager | ContextDecorator:
         """
         Context manager or decorator for temporary use of a module.
@@ -156,8 +164,8 @@ class Module:
     def change_priority(
         self,
         module: Module,
-        priority: ModulePriority | Literal["low", "high"],
-    ):
+        priority: ModulePriority | ModulePriorityStr,
+    ) -> Self:
         """
         Function for changing the priority of a module in use.
         There are two priority values:
@@ -166,27 +174,38 @@ class Module:
         * **HIGH**: The module concerned becomes the most important of the modules used.
         """
 
-    def unlock(self):
+    def unlock(self) -> Self:
         """
         Function to unlock the module by deleting cached instances of singletons.
         """
 
+    @classmethod
+    def from_name(cls, name: str) -> Self:
+        """
+        Class method for getting or creating a module by name.
+        """
+
+    @classmethod
+    def default(cls) -> Self:
+        """
+        Class method for getting the default module.
+        """
+
 @final
-class ModulePriority(str, Enum):
+class ModulePriority(StrEnum):
     LOW = ...
     HIGH = ...
 
 @runtime_checkable
-class Injectable(Protocol[_T_co]):
-    def __init__(self, factory: Callable[[], _T_co] = ..., /): ...
+class Injectable[T](Protocol):
     @property
     def is_locked(self) -> bool: ...
     def unlock(self): ...
     @abstractmethod
-    def get_instance(self) -> _T_co: ...
+    def get_instance(self) -> T: ...
 
 @final
-class InjectableMode(str, Enum):
+class InjectableMode(StrEnum):
     FALLBACK = ...
     NORMAL = ...
     OVERRIDE = ...

{python_injection-0.8.5 → python_injection-0.9.1}/injection/common/event.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from contextlib import ExitStack, contextmanager, suppress
 from dataclasses import dataclass, field
-from typing import ContextManager
+from typing import ContextManager, Self
 from weakref import WeakSet
 
 __all__ = ("Event", "EventChannel", "EventListener")
@@ -36,11 +36,11 @@ class EventChannel:
 
             yield
 
-    def add_listener(self, listener: EventListener):
+    def add_listener(self, listener: EventListener) -> Self:
         self.__listeners.add(listener)
         return self
 
-    def remove_listener(self, listener: EventListener):
+    def remove_listener(self, listener: EventListener) -> Self:
         with suppress(KeyError):
             self.__listeners.remove(listener)
 

{python_injection-0.8.5 → python_injection-0.9.1}/injection/common/invertible.py

@@ -1,23 +1,21 @@
 from abc import abstractmethod
 from collections.abc import Callable
 from dataclasses import dataclass
-from typing import Protocol, TypeVar, runtime_checkable
+from typing import Protocol, runtime_checkable
 
 __all__ = ("Invertible", "SimpleInvertible")
 
-_T_co = TypeVar("_T_co", covariant=True)
-
 
 @runtime_checkable
-class Invertible(Protocol[_T_co]):
+class Invertible[T](Protocol):
     @abstractmethod
-    def __invert__(self) -> _T_co:
+    def __invert__(self) -> T:
         raise NotImplementedError
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
-class SimpleInvertible(Invertible[_T_co]):
-    callable: Callable[[], _T_co]
+class SimpleInvertible[T](Invertible[T]):
+    callable: Callable[[], T]
 
-    def __invert__(self) -> _T_co:
+    def __invert__(self) -> T:
         return self.callable()

{python_injection-0.8.5 → python_injection-0.9.1}/injection/common/lazy.py

@@ -1,31 +1,26 @@
 from collections.abc import Callable, Iterator, Mapping
 from types import MappingProxyType
-from typing import TypeVar
 
 from injection.common.invertible import Invertible
 
 __all__ = ("Lazy", "LazyMapping")
 
-_T = TypeVar("_T")
-_K = TypeVar("_K")
-_V = TypeVar("_V")
 
-
-class Lazy(Invertible[_T]):
+class Lazy[T](Invertible[T]):
     __slots__ = ("__cache", "__is_set")
 
-    def __init__(self, factory: Callable[[], _T]):
+    def __init__(self, factory: Callable[[], T]):
         self.__setup_cache(factory)
 
-    def __invert__(self) -> _T:
+    def __invert__(self) -> T:
         return next(self.__cache)
 
     @property
     def is_set(self) -> bool:
         return self.__is_set
 
-    def __setup_cache(self, factory: Callable[[], _T]):
-        def cache_generator() -> Iterator[_T]:
+    def __setup_cache(self, factory: Callable[[], T]):
+        def cache_generator() -> Iterator[T]:
             nonlocal factory
             cached = factory()
             self.__is_set = True
@@ -38,16 +33,16 @@ class Lazy(Invertible[_T]):
         self.__is_set = False
 
 
-class LazyMapping(Mapping[_K, _V]):
+class LazyMapping[K, V](Mapping[K, V]):
     __slots__ = ("__lazy",)
 
-    def __init__(self, iterator: Iterator[tuple[_K, _V]]):
+    def __init__(self, iterator: Iterator[tuple[K, V]]):
         self.__lazy = Lazy(lambda: MappingProxyType(dict(iterator)))
 
-    def __getitem__(self, key: _K, /) -> _V:
+    def __getitem__(self, key: K, /) -> V:
         return (~self.__lazy)[key]
 
-    def __iter__(self) -> Iterator[_K]:
+    def __iter__(self) -> Iterator[K]:
         yield from ~self.__lazy
 
     def __len__(self) -> int:

{python_injection-0.8.5 → python_injection-0.9.1}/injection/common/tools/threading.py

@@ -3,10 +3,10 @@ from threading import RLock
 
 __all__ = ("synchronized",)
 
-__lock = RLock()
-
 
 @contextmanager
 def synchronized():
-    with __lock:
-        yield
+    lock = RLock()
+
+    with lock:
+        yield lock

python_injection-0.9.1/injection/common/tools/type.py

@@ -0,0 +1,75 @@
+from collections.abc import Callable, Iterable, Iterator
+from inspect import get_annotations, isfunction
+from types import UnionType
+from typing import (
+    Annotated,
+    Any,
+    NamedTuple,
+    Self,
+    Union,
+    get_args,
+    get_origin,
+)
+
+__all__ = ("TypeInfo", "TypeReport", "analyze_types", "get_return_types")
+
+type TypeInfo[T] = type[T] | Callable[..., T] | Iterable[TypeInfo[T]] | UnionType
+
+
+class TypeReport[T](NamedTuple):
+    origin: type[T]
+    args: tuple[Any, ...]
+
+    @property
+    def type(self) -> type[T]:
+        origin = self.origin
+
+        if args := self.args:
+            return origin[*args]
+
+        return origin
+
+    @property
+    def no_args(self) -> Self:
+        if self.args:
+            return type(self)(self.origin, ())
+
+        return self
+
+
+def analyze_types(*types: type | Any) -> Iterator[TypeReport[Any]]:
+    for tp in types:
+        if tp is None:
+            continue
+
+        origin = get_origin(tp)
+
+        if origin is Union or isinstance(tp, UnionType):
+            inner_types = get_args(tp)
+
+        elif origin is Annotated:
+            inner_types = get_args(tp)[:1]
+
+        else:
+            yield TypeReport(origin or tp, get_args(tp))
+            continue
+
+        yield from analyze_types(*inner_types)
+
+
+def get_return_types(*args: TypeInfo[Any]) -> Iterator[type | UnionType]:
+    for arg in args:
+        if isinstance(arg, Iterable) and not isinstance(
+            get_origin(arg) or arg,
+            type | str,
+        ):
+            inner_args = arg
+
+        elif isfunction(arg):
+            inner_args = (get_annotations(arg, eval_str=True).get("return"),)
+
+        else:
+            yield arg
+            continue
+
+        yield from get_return_types(*inner_args)