python-injection 0.7.5__py3-none-any.whl → 0.8.1__py3-none-any.whl

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
         """

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:

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()

injection/common/lazy.py

@@ -1,9 +1,8 @@
 from collections.abc import Callable, Iterator, Mapping
-from contextlib import suppress
 from types import MappingProxyType
-from typing import Any, Generic, TypeVar
+from typing import TypeVar
 
-from injection.common.tools.threading import thread_lock
+from injection.common.invertible import Invertible
 
 __all__ = ("Lazy", "LazyMapping")
 
@@ -12,36 +11,31 @@ _K = TypeVar("_K")
 _V = TypeVar("_V")
 
 
-class Lazy(Generic[_T]):
-    __slots__ = ("is_set", "__generator")
+class Lazy(Invertible[_T]):
+    __slots__ = ("__cache", "__is_set")
 
     def __init__(self, factory: Callable[[], _T]):
-        def generator() -> Iterator[_T]:
-            nonlocal factory
-
-            with thread_lock:
-                value = factory()
-                self.is_set = True
-                del factory
-
-            while True:
-                yield value
-
-        self.is_set = False
-        self.__generator = generator()
+        self.__setup_cache(factory)
 
     def __invert__(self) -> _T:
-        return next(self.__generator)
+        return next(self.__cache)
 
-    def __call__(self) -> _T:
-        return ~self
+    @property
+    def is_set(self) -> bool:
+        return self.__is_set
 
-    def __setattr__(self, name: str, value: Any, /):
-        with suppress(AttributeError):
-            if self.is_set:
-                raise TypeError(f"`{self}` is frozen.")
+    def __setup_cache(self, factory: Callable[[], _T]):
+        def cache_generator() -> Iterator[_T]:
+            nonlocal factory
+            cached = factory()
+            self.__is_set = True
+            del factory
+
+            while True:
+                yield cached
 
-        return super().__setattr__(name, value)
+        self.__cache = cache_generator()
+        self.__is_set = False
 
 
 class LazyMapping(Mapping[_K, _V]):

injection/common/queue.py

@@ -0,0 +1,63 @@
+from abc import abstractmethod
+from collections import deque
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from typing import NoReturn, Protocol, TypeVar
+
+__all__ = ("LimitedQueue",)
+
+_T = TypeVar("_T")
+
+
+class Queue(Iterator[_T], Protocol):
+    __slots__ = ()
+
+    @abstractmethod
+    def add(self, item: _T):
+        raise NotImplementedError
+
+
+@dataclass(repr=False, frozen=True, slots=True)
+class SimpleQueue(Queue[_T]):
+    __items: deque[_T] = field(default_factory=deque, init=False)
+
+    def __next__(self) -> _T:
+        try:
+            return self.__items.popleft()
+        except IndexError as exc:
+            raise StopIteration from exc
+
+    def add(self, item: _T):
+        self.__items.append(item)
+        return self
+
+
+class DeadQueue(Queue[_T]):
+    __slots__ = ()
+
+    def __bool__(self) -> bool:
+        return False
+
+    def __next__(self) -> NoReturn:
+        raise StopIteration
+
+    def add(self, item: _T) -> NoReturn:
+        raise TypeError("Queue is dead.")
+
+
+@dataclass(repr=False, slots=True)
+class LimitedQueue(Queue[_T]):
+    __state: Queue[_T] = field(default_factory=SimpleQueue)
+
+    def __next__(self) -> _T:
+        try:
+            return next(self.__state)
+        except StopIteration as exc:
+            if self.__state:
+                self.__state = DeadQueue()
+
+            raise exc
+
+    def add(self, item: _T):
+        self.__state.add(item)
+        return self

injection/common/tools/threading.py

@@ -1,28 +1,13 @@
-from collections.abc import Callable, Collection, Iterator
-from functools import wraps
+from contextlib import ContextDecorator, contextmanager
 from threading import RLock
-from typing import Any, TypeVar
+from typing import ContextManager
 
-__all__ = ("frozen_collection", "synchronized", "thread_lock")
+__all__ = ("synchronized",)
 
-_T = TypeVar("_T")
-thread_lock = RLock()
+__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
+@contextmanager
+def synchronized() -> ContextManager | ContextDecorator:
+    with __lock:
+        yield

injection/core/module.py

@@ -37,12 +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.tools.threading import (
-    frozen_collection,
-    synchronized,
-    thread_lock,
-)
+from injection.common.queue import LimitedQueue
+from injection.common.tools.threading import synchronized
 from injection.common.tools.type import find_types, format_type, get_origins
 from injection.exceptions import (
     InjectionError,
@@ -160,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]
@@ -192,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
 
@@ -200,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.")
 
@@ -263,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
@@ -359,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(
@@ -418,9 +422,14 @@ class Module(EventListener, Broker):
                 wp.__init__ = self.inject(wp.__init__)
                 return wp
 
-            wrapper = InjectedFunction(wp).update(self)
-            self.add_listener(wrapper)
-            return wrapper
+            function = InjectedFunction(wp)
+
+            @function.on_setup
+            def listen():
+                function.update(self)
+                self.add_listener(function)
+
+            return function
 
         return decorator(wrapped) if wrapped else decorator
 
@@ -436,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,
@@ -496,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
@@ -612,22 +632,36 @@ class Arguments(NamedTuple):
 
 
 class InjectedFunction(EventListener):
-    __slots__ = ("__dict__", "__wrapper", "__dependencies", "__owner")
+    __slots__ = (
+        "__dict__",
+        "__signature__",
+        "__dependencies",
+        "__owner",
+        "__setup_queue",
+        "__wrapper",
+    )
 
     def __init__(self, wrapped: Callable[..., Any], /):
         update_wrapper(self, wrapped)
-        self.__signature__ = Lazy[Signature](
-            lambda: inspect.signature(wrapped, eval_str=True)
-        )
 
         @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.on_setup(
+            lambda: self.__set_signature(
+                inspect.signature(
+                    wrapped,
+                    eval_str=True,
+                )
+            )
+        )
 
     def __repr__(self) -> str:
         return repr(self.__wrapper)
@@ -638,26 +672,18 @@ class InjectedFunction(EventListener):
     def __call__(self, /, *args, **kwargs) -> Any:
         return self.__wrapper(*args, **kwargs)
 
-    def __get__(self, instance: object | None, owner: type):
+    def __get__(self, instance: object = None, owner: type = None):
         if instance is None:
             return self
 
         return self.__wrapper.__get__(instance, owner)
 
     def __set_name__(self, owner: type, name: str):
-        if self.__dependencies.are_resolved:
-            raise TypeError(
-                "`__set_name__` is called after dependencies have been 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__()
+        return self.__signature__
 
     def bind(
         self,
@@ -671,21 +697,35 @@ class InjectedFunction(EventListener):
             return Arguments(args, kwargs)
 
         bound = self.signature.bind_partial(*args, **kwargs)
-        dependencies = self.__dependencies.arguments
-        bound.arguments = dependencies | bound.arguments
-
+        bound.arguments = (
+            bound.arguments | self.__dependencies.arguments | bound.arguments
+        )
         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 on_setup(self, wrapped: Callable[[], Any] = None, /):
+        def decorator(wp):
+            self.__setup_queue.add(wp)
+            return wp
+
+        return decorator(wrapped) if wrapped else decorator
+
     @singledispatchmethod
     def on_event(self, event: Event, /):
         pass
@@ -695,3 +735,13 @@ class InjectedFunction(EventListener):
     def _(self, event: ModuleEvent, /) -> ContextManager:
         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):
+        self.__signature__ = signature
+        return self

{python_injection-0.7.5.dist-info → python_injection-0.8.1.dist-info}/METADATA

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

{python_injection-0.7.5.dist-info → python_injection-0.8.1.dist-info}/RECORD

@@ -1,18 +1,20 @@
 injection/__init__.py,sha256=9_AVJILxKIBiL_6KJSh2RRydgSHXH38uahAGD0S1-dI,20
 injection/_pkg.py,sha256=nMIRLAQG6096bcR2Mz1egxe5FItBUsw8zR9yzjt1HDM,647
-injection/_pkg.pyi,sha256=5IE5vbi_sSeKjcFtUT9UuCWeIIwEi1hy3qmTdZeZSMI,5171
+injection/_pkg.pyi,sha256=7ep6m-8XK4H7XIFkael2UMIG01qYw73zjdv5DtEBwes,5327
 injection/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-injection/common/event.py,sha256=Lq3XTi2iTK9Y51uHtmsxoqeKJsgretqQQAb00HR454c,1392
-injection/common/lazy.py,sha256=BmjkcwxI-R4I81lzqF0dHmTlfBtflhGKXeBK9lJmG18,1596
+injection/common/event.py,sha256=uFoGRnxxkohH53JEStn4tN2Pn79HlgGExh7VkXdBwVQ,1316
+injection/common/invertible.py,sha256=CyGp57Ik1pSQ2G7bRvnFWkY0kJkZDD5_19OjMYNvQes,558
+injection/common/lazy.py,sha256=1C34uoG229Gl0DEUcD9-eQrL4K_oIofOLzdQ1SiY6rw,1401
+injection/common/queue.py,sha256=mV0AGxp5aYMr438MxmoIsZcV5jmqi5x_GD2S-utrnzA,1443
 injection/common/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-injection/common/tools/threading.py,sha256=doz_TQJWmo3qIaSAhFEyCmdVG7RZoXDmdyfbkYS_vgU,688
+injection/common/tools/threading.py,sha256=02mBkIir2kQaXt47ewMJnOvhCldXCmPI2V-BW_l_6V8,271
 injection/common/tools/type.py,sha256=-zL0dtoVZme71Mscvav7iEWxY2-JltzNTekbWOCPSFo,1276
 injection/core/__init__.py,sha256=zuf0ubI2dHnbjn1059eduhS-ACIkkROa6-dhp10krh0,22
-injection/core/module.py,sha256=J0BpNFlO3MlzBM6-4TPc9nMcSFeTU8eoxbjfcZwLAxM,18084
+injection/core/module.py,sha256=hYnNwFNzw-1TaTjPAtmCpKgghF1JTdbkrJ9jO07KQps,19284
 injection/exceptions.py,sha256=nE56jW00ZB1T-Z-dvfPczPShs3CwIc7tIvdYlOXlaXA,653
 injection/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/integrations/blacksheep.py,sha256=vcLil1IccS7JtXpuVu7s2LqN5Zravfe_7xpAt5cTIU0,723
 injection/utils.py,sha256=_79aiciimZpuoUTz5lojKySUMMzpkU-e7SotiHIFTI8,676
-python_injection-0.7.5.dist-info/METADATA,sha256=czSlDaVt9ev1mgzLpQOnrV2wb_Cx6VC1f4js-i-ClzE,3433
-python_injection-0.7.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-python_injection-0.7.5.dist-info/RECORD,,
+python_injection-0.8.1.dist-info/METADATA,sha256=Atf1DZFIwYCdMKnK7_xQf_muy_Ma7qQmEAnGYQr5P-M,3433
+python_injection-0.8.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+python_injection-0.8.1.dist-info/RECORD,,