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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-injection
-Version: 0.8.0
+Version: 0.8.1
 Summary: Fast and easy dependency injection framework.
 Home-page: https://github.com/100nm/python-injection
 License: MIT

{python_injection-0.8.0 → python_injection-0.8.1}/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}/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/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}/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}/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/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}/injection/core/module.py

@@ -37,13 +37,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 +158,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 +197,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 +205,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 +265,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 +363,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 +424,7 @@ class Module(EventListener, Broker):
 
             function = InjectedFunction(wp)
 
-            @function.setup
+            @function.on_setup
             def listen():
                 function.update(self)
                 self.add_listener(function)
@@ -442,8 +445,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 +514,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
@@ -640,7 +654,7 @@ class InjectedFunction(EventListener):
         self.__dependencies = Dependencies.empty()
         self.__owner = None
         self.__setup_queue = LimitedQueue[Callable[[], Any]]()
-        self.setup(
+        self.on_setup(
             lambda: self.__set_signature(
                 inspect.signature(
                     wrapped,
@@ -665,15 +679,7 @@ class InjectedFunction(EventListener):
         return self.__wrapper.__get__(instance, owner)
 
     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:
@@ -696,17 +702,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
 
-    def setup(self, wrapped: Callable[[], Any] = None, /):
+    @synchronized()
+    def update(self, module: Module):
+        self.__dependencies = Dependencies.resolve(self.signature, module, self.__owner)
+        return self
+
+    def on_setup(self, wrapped: Callable[[], Any] = None, /):
         def decorator(wp):
             self.__setup_queue.add(wp)
             return wp
@@ -730,7 +743,5 @@ class InjectedFunction(EventListener):
         return self
 
     def __set_signature(self, signature: Signature):
-        with thread_lock:
-            self.__signature__ = signature
-
+        self.__signature__ = signature
         return self

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-injection"
-version = "0.8.0"
+version = "0.8.1"
 description = "Fast and easy dependency injection framework."
 authors = ["remimd"]
 keywords = ["dependencies", "inject", "injection"]

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