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

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

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

{python_injection-0.7.4 → python_injection-0.8.0}/injection/_pkg.pyi

@@ -39,19 +39,11 @@ class Module:
 
     def __init__(self, name: str = ...): ...
     def __contains__(self, cls: type | UnionType, /) -> bool: ...
-    def inject(
-        self,
-        wrapped: Callable[..., Any] = ...,
-        /,
-        *,
-        force: bool = ...,
-    ):
+    def inject(self, wrapped: Callable[..., Any] = ..., /):
         """
         Decorator applicable to a class or function. Inject function dependencies using
         parameter type annotations. If applied to a class, the dependencies resolved
         will be those of the `__init__` method.
-
-        With `force=True`, parameters passed to replace dependencies will be ignored.
         """
 
     def injectable(

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

@@ -4,6 +4,8 @@ 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")
 
 
@@ -26,7 +28,7 @@ class EventChannel:
     @contextmanager
     def dispatch(self, event: Event) -> ContextManager | ContextDecorator:
         with ExitStack() as stack:
-            for listener in tuple(self.__listeners):
+            for listener in frozen_collection(self.__listeners):
                 context_manager = listener.on_event(event)
 
                 if context_manager is None:

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

@@ -1,12 +1,10 @@
 from collections.abc import Callable, Iterator, Mapping
-from threading import RLock
 from types import MappingProxyType
-from typing import Any, Generic, TypeVar
+from typing import Generic, TypeVar
 
-__all__ = ("Lazy", "LazyMapping")
+from injection.common.tools.threading import thread_lock
 
-_sentinel = object()
-_thread_lock = RLock()
+__all__ = ("Lazy", "LazyMapping")
 
 _T = TypeVar("_T")
 _K = TypeVar("_K")
@@ -14,39 +12,37 @@ _V = TypeVar("_V")
 
 
 class Lazy(Generic[_T]):
-    __slots__ = ("__factory", "__value")
+    __slots__ = ("__cache", "__is_set")
 
     def __init__(self, factory: Callable[[], _T]):
-        self.__factory = factory
-        self.__value = _sentinel
+        self.__setup_cache(factory)
 
     def __invert__(self) -> _T:
-        if not self.is_set:
-            with _thread_lock:
-                self.__value = self.__factory()
-                self.__factory = _sentinel
+        return next(self.__cache)
 
-        return self.__value
+    @property
+    def is_set(self) -> bool:
+        return self.__is_set
 
-    def __setattr__(self, name: str, value: Any, /):
-        if self.is_set:
-            raise TypeError(f"`{self}` is frozen.")
+    def __setup_cache(self, factory: Callable[[], _T]):
+        def new_cache() -> Iterator[_T]:
+            with thread_lock:
+                self.__is_set = True
 
-        return super().__setattr__(name, value)
+            nonlocal factory
+            cached = factory()
+            del factory
 
-    @property
-    def is_set(self) -> bool:
-        try:
-            return self.__factory is _sentinel
-        except AttributeError:
-            return False
+            while True:
+                yield cached
+
+        self.__cache = new_cache()
+        self.__is_set = False
 
 
 class LazyMapping(Mapping[_K, _V]):
     __slots__ = ("__lazy",)
 
-    __lazy: Lazy[MappingProxyType[_K, _V]]
-
     def __init__(self, iterator: Iterator[tuple[_K, _V]]):
         self.__lazy = Lazy(lambda: MappingProxyType(dict(iterator)))
 
@@ -58,3 +54,7 @@ class LazyMapping(Mapping[_K, _V]):
 
     def __len__(self) -> int:
         return len(~self.__lazy)
+
+    @property
+    def is_set(self) -> bool:
+        return self.__lazy.is_set

python_injection-0.8.0/injection/common/queue.py

@@ -0,0 +1,68 @@
+from abc import abstractmethod
+from collections import deque
+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")
+
+
+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 NoQueue(Queue[_T]):
+    __slots__ = ()
+
+    def __bool__(self) -> bool:
+        return False
+
+    def __next__(self) -> NoReturn:
+        raise StopIteration
+
+    def add(self, item: _T) -> NoReturn:
+        raise TypeError("Queue doesn't exist.")
+
+
+@dataclass(repr=False, slots=True)
+class LimitedQueue(Queue[_T]):
+    __queue: Queue[_T] = field(default_factory=SimpleQueue)
+
+    def __next__(self) -> _T:
+        if not self.__queue:
+            raise StopIteration
+
+        try:
+            return next(self.__queue)
+        except StopIteration as exc:
+            with thread_lock:
+                self.__queue = NoQueue()
+
+            raise exc
+
+    def add(self, item: _T):
+        self.__queue.add(item)
+        return self

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

@@ -0,0 +1,28 @@
+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

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

@@ -16,12 +16,17 @@ 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, wraps
+from functools import (
+    partialmethod,
+    singledispatchmethod,
+    update_wrapper,
+    wraps,
+)
 from inspect import Signature, isclass
-from threading import RLock
-from types import MappingProxyType, UnionType
+from types import UnionType
 from typing import (
     Any,
+    ClassVar,
     ContextManager,
     NamedTuple,
     NoReturn,
@@ -33,7 +38,13 @@ from typing import (
 
 from injection.common.event import Event, EventChannel, EventListener
 from injection.common.lazy import Lazy, LazyMapping
-from injection.common.tools import find_types, format_type, get_origins
+from injection.common.queue import LimitedQueue
+from injection.common.tools.threading import (
+    frozen_collection,
+    synchronized,
+    thread_lock,
+)
+from injection.common.tools.type import find_types, format_type, get_origins
 from injection.exceptions import (
     InjectionError,
     ModuleError,
@@ -45,7 +56,6 @@ from injection.exceptions import (
 __all__ = ("Injectable", "Module", "ModulePriority")
 
 _logger = logging.getLogger(__name__)
-_thread_lock = RLock()
 
 _T = TypeVar("_T")
 Types = Iterable[type] | UnionType
@@ -166,7 +176,7 @@ class NewInjectable(BaseInjectable[_T]):
 class SingletonInjectable(BaseInjectable[_T]):
     __slots__ = ("__dict__",)
 
-    __INSTANCE_KEY = "$instance"
+    __INSTANCE_KEY: ClassVar[str] = "$instance"
 
     @property
     def cache(self) -> MutableMapping[str, Any]:
@@ -183,7 +193,7 @@ class SingletonInjectable(BaseInjectable[_T]):
         with suppress(KeyError):
             return self.cache[self.__INSTANCE_KEY]
 
-        with _thread_lock:
+        with thread_lock:
             instance = self.factory()
             self.cache[self.__INSTANCE_KEY] = instance
 
@@ -263,7 +273,7 @@ class Container(Broker):
     def update(self, classes: Iterable[type], injectable: Injectable, override: bool):
         classes = frozenset(get_origins(*classes))
 
-        with _thread_lock:
+        with thread_lock:
             if not injectable:
                 classes -= self.__classes
                 override = True
@@ -279,6 +289,7 @@ class Container(Broker):
 
         return self
 
+    @synchronized
     def unlock(self):
         for injectable in self.__injectables:
             injectable.unlock()
@@ -349,7 +360,7 @@ class Module(EventListener, Broker):
 
     @property
     def __brokers(self) -> Iterator[Broker]:
-        yield from tuple(self.__modules)
+        yield from frozen_collection(self.__modules)
         yield self.__container
 
     def injectable(
@@ -401,22 +412,21 @@ class Module(EventListener, Broker):
         wrapped: Callable[..., Any] = None,
         /,
         *,
-        force: bool = False,
         return_factory: bool = False,
     ):
         def decorator(wp):
             if not return_factory and isclass(wp):
-                wp.__init__ = self.inject(wp.__init__, force=force)
+                wp.__init__ = self.inject(wp.__init__)
                 return wp
 
-            lazy_binder = Lazy[Binder](lambda: self.__new_binder(wp))
+            function = InjectedFunction(wp)
 
-            @wraps(wp)
-            def wrapper(*args, **kwargs):
-                arguments = (~lazy_binder).bind(args, kwargs, force)
-                return wp(*arguments.args, **arguments.kwargs)
+            @function.setup
+            def listen():
+                function.update(self)
+                self.add_listener(function)
 
-            return wrapper
+            return function
 
         return decorator(wrapped) if wrapped else decorator
 
@@ -492,6 +502,7 @@ class Module(EventListener, Broker):
 
         return self
 
+    @synchronized
     def unlock(self):
         for broker in self.__brokers:
             broker.unlock()
@@ -530,44 +541,45 @@ class Module(EventListener, Broker):
                 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
+InjectedFunction
 """
 
 
 @dataclass(repr=False, frozen=True, slots=True)
 class Dependencies:
-    __mapping: MappingProxyType[str, Injectable]
+    mapping: Mapping[str, Injectable]
 
     def __bool__(self) -> bool:
-        return bool(self.__mapping)
+        return bool(self.mapping)
 
     def __iter__(self) -> Iterator[tuple[str, Any]]:
-        for name, injectable in self.__mapping.items():
+        for name, injectable in self.mapping.items():
             yield name, injectable.get_instance()
 
+    @property
+    def are_resolved(self) -> bool:
+        if isinstance(self.mapping, LazyMapping) and not self.mapping.is_set:
+            return False
+
+        return bool(self)
+
     @property
     def arguments(self) -> OrderedDict[str, Any]:
         return OrderedDict(self)
 
     @classmethod
     def from_mapping(cls, mapping: Mapping[str, Injectable]):
-        return cls(MappingProxyType(mapping))
+        return cls(mapping=mapping)
 
     @classmethod
     def empty(cls):
         return cls.from_mapping({})
 
     @classmethod
-    def resolve(cls, signature: Signature, module: Module):
-        dependencies = LazyMapping(cls.__resolver(signature, module))
+    def resolve(cls, signature: Signature, module: Module, owner: type = None):
+        dependencies = LazyMapping(cls.__resolver(signature, module, owner))
         return cls.from_mapping(dependencies)
 
     @classmethod
@@ -575,33 +587,102 @@ class Dependencies:
         cls,
         signature: Signature,
         module: Module,
+        owner: type = None,
     ) -> Iterator[tuple[str, Injectable]]:
-        for name, parameter in signature.parameters.items():
+        for name, annotation in cls.__get_annotations(signature, owner):
             try:
-                injectable = module[parameter.annotation]
+                injectable = module[annotation]
             except KeyError:
                 continue
 
             yield name, injectable
 
+    @staticmethod
+    def __get_annotations(
+        signature: Signature,
+        owner: type = None,
+    ) -> Iterator[tuple[str, type | Any]]:
+        parameters = iter(signature.parameters.items())
+
+        if owner:
+            name, _ = next(parameters)
+            yield name, owner
+
+        for name, parameter in parameters:
+            yield name, parameter.annotation
+
 
 class Arguments(NamedTuple):
     args: Iterable[Any]
     kwargs: Mapping[str, Any]
 
 
-class Binder(EventListener):
-    __slots__ = ("__signature", "__dependencies")
+class InjectedFunction(EventListener):
+    __slots__ = (
+        "__dict__",
+        "__signature__",
+        "__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)
 
-    def __init__(self, signature: Signature):
-        self.__signature = signature
+        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,
+                )
+            )
+        )
+
+    def __repr__(self) -> str:
+        return repr(self.__wrapper)
+
+    def __str__(self) -> str:
+        return str(self.__wrapper)
+
+    def __call__(self, /, *args, **kwargs) -> Any:
+        return self.__wrapper(*args, **kwargs)
+
+    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(
+                "Function owner must be assigned before dependencies are resolved."
+            )
+
+        if self.__owner:
+            raise TypeError("Function owner is already defined.")
+
+        self.__owner = owner
+
+    @property
+    def signature(self) -> Signature:
+        return self.__signature__
 
     def bind(
         self,
         args: Iterable[Any] = (),
         kwargs: Mapping[str, Any] = None,
-        force: bool = False,
     ) -> Arguments:
         if kwargs is None:
             kwargs = {}
@@ -609,22 +690,29 @@ class Binder(EventListener):
         if not self.__dependencies:
             return Arguments(args, kwargs)
 
-        bound = self.__signature.bind_partial(*args, **kwargs)
-        dependencies = self.__dependencies.arguments
-
-        if force:
-            bound.arguments |= dependencies
-        else:
-            bound.arguments = dependencies | bound.arguments
-
+        bound = self.signature.bind_partial(*args, **kwargs)
+        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)
+        with thread_lock:
+            self.__dependencies = Dependencies.resolve(
+                self.signature,
+                module,
+                self.__owner,
+            )
 
         return self
 
+    def 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
@@ -634,3 +722,15 @@ class Binder(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):
+        with thread_lock:
+            self.__signature__ = signature
+
+        return self

{python_injection-0.7.4 → python_injection-0.8.0}/injection/exceptions.py

@@ -1,4 +1,4 @@
-from injection.common.tools import format_type
+from injection.common.tools.type import format_type
 
 __all__ = (
     "InjectionError",

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

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

python_injection-0.7.4/injection/common/tools/__init__.py

@@ -1 +0,0 @@
-from ._type import *