python-injection 0.8.0__tar.gz → 0.8.1.post0__tar.gz

{python_injection-0.8.0 → python_injection-0.8.1.post0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.8.0
+Version: 0.8.1.post0
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT
@@ -27,7 +27,7 @@ If you wish to inject a singleton, use `singleton` decorator.
 from injection import singleton
 
 @singleton
-class Singleton:
+class ServiceA:
     """ class implementation """
 ```
 
@@ -37,7 +37,7 @@ If you wish to inject a new instance each time, use `injectable` decorator.
 from injection import injectable
 
 @injectable
-class Injectable:
+class ServiceB:
     """ class implementation """
 ```
 
@@ -47,7 +47,10 @@ function.
 ```python
 from injection import set_constant
 
-app = set_constant(Application())
+class ServiceC:
+    """ class implementation """
+
+service_c = set_constant(ServiceC())
 ```
 
 ## Inject an instance
@@ -59,7 +62,7 @@ _Don't forget to annotate type of parameter to inject._
 from injection import inject
 
 @inject
-def my_function(instance: Injectable):
+def some_function(service_a: ServiceA):
     """ function implementation """
 ```
 
@@ -76,8 +79,8 @@ from injection import inject
 
 @inject
 @dataclass
-class DataClass:
-    instance: Injectable = ...
+class SomeDataClass:
+    service_a: ServiceA = ...
 ```
 
 ## Get an instance
@@ -87,7 +90,7 @@ _Example with `get_instance` function:_
 ```python
 from injection import get_instance
 
-instance = get_instance(Injectable)
+service_a = get_instance(ServiceA)
 ```
 
 _Example with `get_lazy_instance` function:_
@@ -95,9 +98,9 @@ _Example with `get_lazy_instance` function:_
 ```python
 from injection import get_lazy_instance
 
-lazy_instance = get_lazy_instance(Injectable)
+lazy_service_a = get_lazy_instance(ServiceA)
 # ...
-instance = ~lazy_instance
+service_a = ~lazy_service_a
 ```
 
 ## Inheritance
@@ -111,43 +114,39 @@ classes.
 _Example with one class:_
 
 ```python
-from injection import singleton
-
-class A:
+class AbstractService(ABC):
     ...
 
-@singleton(on=A)
-class B(A):
+@injectable(on=AbstractService)
+class ConcreteService(AbstractService):
     ...
 ```
 
 _Example with several classes:_
 
 ```python
-from injection import singleton
-
-class A:
+class AbstractService(ABC):
     ...
 
-class B(A):
+class ConcreteService(AbstractService):
     ...
 
-@singleton(on=(A, B))
-class C(B):
+@injectable(on=(AbstractService, ConcreteService))
+class ConcreteServiceOverload(ConcreteService):
     ...
 ```
 
 If a class is registered in a package and you want to override it, there is the `override` parameter:
 
 ```python
-@singleton
-class A:
+@injectable
+class InaccessibleService:
     ...
 
 # ...
 
-@singleton(on=A, override=True)
-class B(A):
+@injectable(on=InaccessibleService, override=True)
+class ServiceOverload(InaccessibleService):
     ...
 ```
 
@@ -157,10 +156,10 @@ A recipe is a function that tells the injector how to construct the instance to
 the return type annotation when defining the recipe.
 
 ```python
-from injection import singleton
+from injection import injectable
 
-@singleton
-def my_recipe() -> Singleton:
+@injectable
+def service_d_recipe() -> ServiceD:
     """ recipe implementation """
 ```
 

{python_injection-0.8.0 → python_injection-0.8.1.post0}/documentation/basic-usage.md

@@ -10,7 +10,7 @@ If you wish to inject a singleton, use `singleton` decorator.
 from injection import singleton
 
 @singleton
-class Singleton:
+class ServiceA:
     """ class implementation """
 ```
 
@@ -20,7 +20,7 @@ If you wish to inject a new instance each time, use `injectable` decorator.
 from injection import injectable
 
 @injectable
-class Injectable:
+class ServiceB:
     """ class implementation """
 ```
 
@@ -30,7 +30,10 @@ function.
 ```python
 from injection import set_constant
 
-app = set_constant(Application())
+class ServiceC:
+    """ class implementation """
+
+service_c = set_constant(ServiceC())
 ```
 
 ## Inject an instance
@@ -42,7 +45,7 @@ _Don't forget to annotate type of parameter to inject._
 from injection import inject
 
 @inject
-def my_function(instance: Injectable):
+def some_function(service_a: ServiceA):
     """ function implementation """
 ```
 
@@ -59,8 +62,8 @@ from injection import inject
 
 @inject
 @dataclass
-class DataClass:
-    instance: Injectable = ...
+class SomeDataClass:
+    service_a: ServiceA = ...
 ```
 
 ## Get an instance
@@ -70,7 +73,7 @@ _Example with `get_instance` function:_
 ```python
 from injection import get_instance
 
-instance = get_instance(Injectable)
+service_a = get_instance(ServiceA)
 ```
 
 _Example with `get_lazy_instance` function:_
@@ -78,9 +81,9 @@ _Example with `get_lazy_instance` function:_
 ```python
 from injection import get_lazy_instance
 
-lazy_instance = get_lazy_instance(Injectable)
+lazy_service_a = get_lazy_instance(ServiceA)
 # ...
-instance = ~lazy_instance
+service_a = ~lazy_service_a
 ```
 
 ## Inheritance
@@ -94,43 +97,39 @@ classes.
 _Example with one class:_
 
 ```python
-from injection import singleton
-
-class A:
+class AbstractService(ABC):
     ...
 
-@singleton(on=A)
-class B(A):
+@injectable(on=AbstractService)
+class ConcreteService(AbstractService):
     ...
 ```
 
 _Example with several classes:_
 
 ```python
-from injection import singleton
-
-class A:
+class AbstractService(ABC):
     ...
 
-class B(A):
+class ConcreteService(AbstractService):
     ...
 
-@singleton(on=(A, B))
-class C(B):
+@injectable(on=(AbstractService, ConcreteService))
+class ConcreteServiceOverload(ConcreteService):
     ...
 ```
 
 If a class is registered in a package and you want to override it, there is the `override` parameter:
 
 ```python
-@singleton
-class A:
+@injectable
+class InaccessibleService:
     ...
 
 # ...
 
-@singleton(on=A, override=True)
-class B(A):
+@injectable(on=InaccessibleService, override=True)
+class ServiceOverload(InaccessibleService):
     ...
 ```
 
@@ -140,9 +139,9 @@ A recipe is a function that tells the injector how to construct the instance to
 the return type annotation when defining the recipe.
 
 ```python
-from injection import singleton
+from injection import injectable
 
-@singleton
-def my_recipe() -> Singleton:
+@injectable
+def service_d_recipe() -> ServiceD:
     """ recipe implementation """
 ```

{python_injection-0.8.0 → python_injection-0.8.1.post0}/injection/_pkg.pyi

@@ -13,7 +13,7 @@ from typing import (
     runtime_checkable,
 )
 
-from injection.common.lazy import Lazy
+from injection.common.invertible import Invertible
 
 _T = TypeVar("_T")
 
@@ -104,11 +104,16 @@ class Module:
         will be raised.
         """
 
-    def get_lazy_instance(self, cls: type[_T]) -> Lazy[_T | None]:
+    def get_lazy_instance(
+        self,
+        cls: type[_T],
+        cache: bool = ...,
+    ) -> Invertible[_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
-        in a lazy object, simply use a wavy line (~).
+        parameter or `None`. Return a `Invertible` object. To access the instance
+        contained in an invertible object, simply use a wavy line (~).
+        With `cache=True`, the instance retrieved will always be the same.
 
         Example: instance = ~lazy_instance
         """

{python_injection-0.8.0 → python_injection-0.8.1.post0}/injection/common/event.py

@@ -4,8 +4,6 @@ from dataclasses import dataclass, field
 from typing import ContextManager
 from weakref import WeakSet
 
-from injection.common.tools.threading import frozen_collection
-
 __all__ = ("Event", "EventChannel", "EventListener")
 
 
@@ -28,7 +26,7 @@ class EventChannel:
     @contextmanager
     def dispatch(self, event: Event) -> ContextManager | ContextDecorator:
         with ExitStack() as stack:
-            for listener in frozen_collection(self.__listeners):
+            for listener in tuple(self.__listeners):
                 context_manager = listener.on_event(event)
 
                 if context_manager is None:

python_injection-0.8.1.post0/injection/common/invertible.py

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

{python_injection-0.8.0 → python_injection-0.8.1.post0}/injection/common/lazy.py

@@ -1,8 +1,8 @@
 from collections.abc import Callable, Iterator, Mapping
 from types import MappingProxyType
-from typing import Generic, TypeVar
+from typing import TypeVar
 
-from injection.common.tools.threading import thread_lock
+from injection.common.invertible import Invertible
 
 __all__ = ("Lazy", "LazyMapping")
 
@@ -11,7 +11,7 @@ _K = TypeVar("_K")
 _V = TypeVar("_V")
 
 
-class Lazy(Generic[_T]):
+class Lazy(Invertible[_T]):
     __slots__ = ("__cache", "__is_set")
 
     def __init__(self, factory: Callable[[], _T]):
@@ -25,18 +25,16 @@ class Lazy(Generic[_T]):
         return self.__is_set
 
     def __setup_cache(self, factory: Callable[[], _T]):
-        def new_cache() -> Iterator[_T]:
-            with thread_lock:
-                self.__is_set = True
-
+        def cache_generator() -> Iterator[_T]:
             nonlocal factory
             cached = factory()
+            self.__is_set = True
             del factory
 
             while True:
                 yield cached
 
-        self.__cache = new_cache()
+        self.__cache = cache_generator()
         self.__is_set = False
 
 

{python_injection-0.8.0 → python_injection-0.8.1.post0}/injection/common/queue.py

@@ -4,8 +4,6 @@ from collections.abc import Iterator
 from dataclasses import dataclass, field
 from typing import NoReturn, Protocol, TypeVar
 
-from injection.common.tools.threading import thread_lock
-
 __all__ = ("LimitedQueue",)
 
 _T = TypeVar("_T")
@@ -34,7 +32,7 @@ class SimpleQueue(Queue[_T]):
         return self
 
 
-class NoQueue(Queue[_T]):
+class DeadQueue(Queue[_T]):
     __slots__ = ()
 
     def __bool__(self) -> bool:
@@ -44,25 +42,22 @@ class NoQueue(Queue[_T]):
         raise StopIteration
 
     def add(self, item: _T) -> NoReturn:
-        raise TypeError("Queue doesn't exist.")
+        raise TypeError("Queue is dead.")
 
 
 @dataclass(repr=False, slots=True)
 class LimitedQueue(Queue[_T]):
-    __queue: Queue[_T] = field(default_factory=SimpleQueue)
+    __state: Queue[_T] = field(default_factory=SimpleQueue)
 
     def __next__(self) -> _T:
-        if not self.__queue:
-            raise StopIteration
-
         try:
-            return next(self.__queue)
+            return next(self.__state)
         except StopIteration as exc:
-            with thread_lock:
-                self.__queue = NoQueue()
+            if self.__state:
+                self.__state = DeadQueue()
 
             raise exc
 
     def add(self, item: _T):
-        self.__queue.add(item)
+        self.__state.add(item)
         return self

python_injection-0.8.1.post0/injection/common/tools/threading.py

@@ -0,0 +1,13 @@
+from contextlib import ContextDecorator, contextmanager
+from threading import RLock
+from typing import ContextManager
+
+__all__ = ("synchronized",)
+
+__lock = RLock()
+
+
+@contextmanager
+def synchronized() -> ContextManager | ContextDecorator:
+    with __lock:
+        yield

{python_injection-0.8.0 → python_injection-0.8.1.post0}/injection/core/module.py

@@ -16,14 +16,9 @@ from collections.abc import (
 from contextlib import ContextDecorator, contextmanager, suppress
 from dataclasses import dataclass, field
 from enum import Enum, auto
-from functools import (
-    partialmethod,
-    singledispatchmethod,
-    update_wrapper,
-    wraps,
-)
+from functools import partialmethod, singledispatchmethod, update_wrapper
 from inspect import Signature, isclass
-from types import UnionType
+from types import MethodType, UnionType
 from typing import (
     Any,
     ClassVar,
@@ -37,13 +32,10 @@ from typing import (
 )
 
 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.queue import LimitedQueue
-from injection.common.tools.threading import (
-    frozen_collection,
-    synchronized,
-    thread_lock,
-)
+from injection.common.tools.threading import synchronized
 from injection.common.tools.type import find_types, format_type, get_origins
 from injection.exceptions import (
     InjectionError,
@@ -161,6 +153,13 @@ class Injectable(Protocol[_T]):
         raise NotImplementedError
 
 
+class FallbackInjectable(Injectable[_T], ABC):
+    __slots__ = ()
+
+    def __bool__(self) -> bool:
+        return False
+
+
 @dataclass(repr=False, frozen=True, slots=True)
 class BaseInjectable(Injectable[_T], ABC):
     factory: Callable[[], _T]
@@ -193,7 +192,7 @@ class SingletonInjectable(BaseInjectable[_T]):
         with suppress(KeyError):
             return self.cache[self.__INSTANCE_KEY]
 
-        with thread_lock:
+        with synchronized():
             instance = self.factory()
             self.cache[self.__INSTANCE_KEY] = instance
 
@@ -201,12 +200,9 @@ class SingletonInjectable(BaseInjectable[_T]):
 
 
 @dataclass(repr=False, frozen=True, slots=True)
-class ShouldBeInjectable(Injectable[_T]):
+class ShouldBeInjectable(FallbackInjectable[_T]):
     cls: type[_T]
 
-    def __bool__(self) -> bool:
-        return False
-
     def get_instance(self) -> NoReturn:
         raise InjectionError(f"`{format_type(self.cls)}` should be an injectable.")
 
@@ -264,36 +260,38 @@ class Container(Broker):
 
     @property
     def __classes(self) -> frozenset[type]:
-        return frozenset(self.__data.keys())
+        return frozenset(self.__data)
 
     @property
     def __injectables(self) -> frozenset[Injectable]:
         return frozenset(self.__data.values())
 
+    @synchronized()
     def update(self, classes: Iterable[type], injectable: Injectable, override: bool):
         classes = frozenset(get_origins(*classes))
 
-        with thread_lock:
-            if not injectable:
-                classes -= self.__classes
-                override = True
+        if not injectable:
+            classes -= self.__classes
+            override = True
 
-            if classes:
-                event = ContainerDependenciesUpdated(self, classes, override)
+        if classes:
+            event = ContainerDependenciesUpdated(self, classes, override)
 
-                with self.notify(event):
-                    if not override:
-                        self.__check_if_exists(classes)
+            with self.notify(event):
+                if not override:
+                    self.__check_if_exists(classes)
 
-                    self.__data.update((cls, injectable) for cls in classes)
+                self.__data.update((cls, injectable) for cls in classes)
 
         return self
 
-    @synchronized
+    @synchronized()
     def unlock(self):
         for injectable in self.__injectables:
             injectable.unlock()
 
+        return self
+
     def add_listener(self, listener: EventListener):
         self.__channel.add_listener(listener)
         return self
@@ -360,7 +358,7 @@ class Module(EventListener, Broker):
 
     @property
     def __brokers(self) -> Iterator[Broker]:
-        yield from frozen_collection(self.__modules)
+        yield from tuple(self.__modules)
         yield self.__container
 
     def injectable(
@@ -421,7 +419,7 @@ class Module(EventListener, Broker):
 
             function = InjectedFunction(wp)
 
-            @function.setup
+            @function.on_setup
             def listen():
                 function.update(self)
                 self.add_listener(function)
@@ -442,8 +440,17 @@ class Module(EventListener, Broker):
         instance = injectable.get_instance()
         return cast(cls, instance)
 
-    def get_lazy_instance(self, cls: type[_T]) -> Lazy[_T | None]:
-        return Lazy(lambda: self.get_instance(cls))
+    def get_lazy_instance(
+        self,
+        cls: type[_T],
+        cache: bool = False,
+    ) -> Invertible[_T | None]:
+        if cache:
+            return Lazy(lambda: self.get_instance(cls))
+
+        function = self.inject(lambda instance=None: instance)
+        function.set_owner(cls)
+        return SimpleInvertible(function)
 
     def update(
         self,
@@ -502,11 +509,13 @@ class Module(EventListener, Broker):
 
         return self
 
-    @synchronized
+    @synchronized()
     def unlock(self):
         for broker in self.__brokers:
             broker.unlock()
 
+        return self
+
     def add_listener(self, listener: EventListener):
         self.__channel.add_listener(listener)
         return self
@@ -621,64 +630,49 @@ class InjectedFunction(EventListener):
     __slots__ = (
         "__dict__",
         "__signature__",
+        "__wrapped__",
         "__dependencies",
         "__owner",
         "__setup_queue",
-        "__wrapper",
     )
 
     def __init__(self, wrapped: Callable[..., Any], /):
         update_wrapper(self, wrapped)
-
-        @wraps(wrapped)
-        def wrapper(*args, **kwargs):
-            self.__consume_setup_queue()
-            args, kwargs = self.bind(args, kwargs)
-            return wrapped(*args, **kwargs)
-
-        self.__wrapper = wrapper
         self.__dependencies = Dependencies.empty()
         self.__owner = None
         self.__setup_queue = LimitedQueue[Callable[[], Any]]()
-        self.setup(
-            lambda: self.__set_signature(
-                inspect.signature(
-                    wrapped,
-                    eval_str=True,
-                )
-            )
-        )
+        self.on_setup(self.__set_signature)
 
     def __repr__(self) -> str:
-        return repr(self.__wrapper)
+        return repr(self.wrapped)
 
     def __str__(self) -> str:
-        return str(self.__wrapper)
+        return str(self.wrapped)
 
     def __call__(self, /, *args, **kwargs) -> Any:
-        return self.__wrapper(*args, **kwargs)
+        for function in self.__setup_queue:
+            function()
+
+        args, kwargs = self.bind(args, kwargs)
+        return self.wrapped(*args, **kwargs)
 
     def __get__(self, instance: object = None, owner: type = None):
         if instance is None:
             return self
 
-        return self.__wrapper.__get__(instance, owner)
+        return MethodType(self, instance)
 
     def __set_name__(self, owner: type, name: str):
-        if self.__dependencies.are_resolved:
-            raise TypeError(
-                "Function owner must be assigned before dependencies are resolved."
-            )
-
-        if self.__owner:
-            raise TypeError("Function owner is already defined.")
-
-        self.__owner = owner
+        self.set_owner(owner)
 
     @property
     def signature(self) -> Signature:
         return self.__signature__
 
+    @property
+    def wrapped(self) -> Callable[..., Any]:
+        return self.__wrapped__
+
     def bind(
         self,
         args: Iterable[Any] = (),
@@ -696,17 +690,24 @@ class InjectedFunction(EventListener):
         )
         return Arguments(bound.args, bound.kwargs)
 
-    def update(self, module: Module):
-        with thread_lock:
-            self.__dependencies = Dependencies.resolve(
-                self.signature,
-                module,
-                self.__owner,
+    def set_owner(self, owner: type):
+        if self.__dependencies.are_resolved:
+            raise TypeError(
+                "Function owner must be assigned before dependencies are resolved."
             )
 
+        if self.__owner:
+            raise TypeError("Function owner is already defined.")
+
+        self.__owner = owner
+        return self
+
+    @synchronized()
+    def update(self, module: Module):
+        self.__dependencies = Dependencies.resolve(self.signature, module, self.__owner)
         return self
 
-    def setup(self, wrapped: Callable[[], Any] = None, /):
+    def on_setup(self, wrapped: Callable[[], Any] = None, /):
         def decorator(wp):
             self.__setup_queue.add(wp)
             return wp
@@ -723,14 +724,6 @@ class InjectedFunction(EventListener):
         yield
         self.update(event.on_module)
 
-    def __consume_setup_queue(self):
-        for function in self.__setup_queue:
-            function()
-
-        return self
-
-    def __set_signature(self, signature: Signature):
-        with thread_lock:
-            self.__signature__ = signature
-
+    def __set_signature(self):
+        self.__signature__ = inspect.signature(self.wrapped, eval_str=True)
         return self

{python_injection-0.8.0 → python_injection-0.8.1.post0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-injection"
-version = "0.8.0"
+version = "0.8.1.post0"
 description = "Fast and easy dependency injection framework."
 authors = ["remimd"]
 keywords = ["dependencies", "inject", "injection"]
@@ -13,7 +13,9 @@ repository = "https://github.com/100nm/python-injection"
 python = ">=3.10, <4"
 
 [tool.poetry.group.dev.dependencies]
+argon2-cffi = "*"
 blacksheep = "*"
+faker = "*"
 pydantic = "*"
 pytest = "*"
 pytest-asyncio = "*"
@@ -31,7 +33,7 @@ exclude_lines = [
 python_files = "test_*.py"
 addopts = "-p no:warnings --tb=short"
 asyncio_mode = "auto"
-testpaths = "tests/"
+testpaths = "**/tests/"
 
 [tool.ruff]
 line-length = 88

python_injection-0.8.0/injection/common/tools/threading.py

@@ -1,28 +0,0 @@
-from collections.abc import Callable, Collection, Iterator
-from functools import wraps
-from threading import RLock
-from typing import Any, TypeVar
-
-__all__ = ("frozen_collection", "synchronized", "thread_lock")
-
-_T = TypeVar("_T")
-thread_lock = RLock()
-
-
-def synchronized(function: Callable[..., Any] = None, /):
-    def decorator(fn):
-        @wraps(fn)
-        def wrapper(*args, **kwargs):
-            with thread_lock:
-                return fn(*args, **kwargs)
-
-        return wrapper
-
-    return decorator(function) if function else decorator
-
-
-def frozen_collection(collection: Collection[_T]) -> Iterator[_T]:
-    with thread_lock:
-        t = tuple(collection)
-
-    yield from t