python-injection 0.8.4.post1__tar.gz → 0.8.5__tar.gz

{python_injection-0.8.4.post1 → python_injection-0.8.5}/PKG-INFO

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

{python_injection-0.8.4.post1 → python_injection-0.8.5}/injection/__init__.pyi

@@ -16,8 +16,8 @@ from typing import (
 
 from .common.invertible import Invertible
 
-_In_T = TypeVar("_In_T", covariant=False)
-_Co_T = TypeVar("_Co_T", covariant=True)
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
 
 default_module: Final[Module] = ...
 
@@ -88,24 +88,24 @@ class Module:
 
     def set_constant(
         self,
-        instance: _In_T,
+        instance: _T,
         on: type | Iterable[type] | UnionType = ...,
         *,
         mode: InjectableMode | Literal["fallback", "normal", "override"] = ...,
-    ) -> _In_T:
+    ) -> _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[_In_T]) -> _In_T:
+    def resolve(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[_In_T]) -> _In_T | None:
+    def get_instance(self, cls: type[_T]) -> _T | None:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or return `None`.
@@ -113,10 +113,10 @@ class Module:
 
     def get_lazy_instance(
         self,
-        cls: type[_In_T],
+        cls: type[_T],
         *,
         cache: bool = ...,
-    ) -> Invertible[_In_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
@@ -177,13 +177,13 @@ class ModulePriority(str, Enum):
     HIGH = ...
 
 @runtime_checkable
-class Injectable(Protocol[_Co_T]):
-    def __init__(self, factory: Callable[[], _Co_T] = ..., /): ...
+class Injectable(Protocol[_T_co]):
+    def __init__(self, factory: Callable[[], _T_co] = ..., /): ...
     @property
     def is_locked(self) -> bool: ...
     def unlock(self): ...
     @abstractmethod
-    def get_instance(self) -> _Co_T: ...
+    def get_instance(self) -> _T_co: ...
 
 @final
 class InjectableMode(str, Enum):

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

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

{python_injection-0.8.4.post1 → python_injection-0.8.5}/injection/core/module.py

@@ -17,6 +17,7 @@ from dataclasses import dataclass, field
 from enum import Enum
 from functools import partialmethod, singledispatchmethod, update_wrapper
 from inspect import Signature, isclass
+from queue import Queue
 from types import MethodType, UnionType
 from typing import (
     Any,
@@ -33,7 +34,6 @@ 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 synchronized
 from injection.common.tools.type import find_types, format_type, get_origins
 from injection.exceptions import (
@@ -48,9 +48,8 @@ __all__ = ("Injectable", "Mode", "Module", "Priority")
 
 _logger = logging.getLogger(__name__)
 
-_In_T = TypeVar("_In_T", covariant=False)
-_Co_T = TypeVar("_Co_T", covariant=True)
-
+_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
 
 """
 Events
@@ -135,10 +134,10 @@ Injectables
 
 
 @runtime_checkable
-class Injectable(Protocol[_Co_T]):
+class Injectable(Protocol[_T_co]):
     __slots__ = ()
 
-    def __init__(self, __factory: Callable[[], _Co_T] = None, /):
+    def __init__(self, __factory: Callable[[], _T_co] = None, /):
         pass
 
     @property
@@ -149,23 +148,23 @@ class Injectable(Protocol[_Co_T]):
         return
 
     @abstractmethod
-    def get_instance(self) -> _Co_T:
+    def get_instance(self) -> _T_co:
         raise NotImplementedError
 
 
 @dataclass(repr=False, frozen=True, slots=True)
-class BaseInjectable(Injectable[_In_T], ABC):
-    factory: Callable[[], _In_T]
+class BaseInjectable(Injectable[_T], ABC):
+    factory: Callable[[], _T]
 
 
-class NewInjectable(BaseInjectable[_In_T]):
+class NewInjectable(BaseInjectable[_T]):
     __slots__ = ()
 
-    def get_instance(self) -> _In_T:
+    def get_instance(self) -> _T:
         return self.factory()
 
 
-class SingletonInjectable(BaseInjectable[_In_T]):
+class SingletonInjectable(BaseInjectable[_T]):
     __slots__ = ("__dict__",)
 
     __INSTANCE_KEY: ClassVar[str] = "$instance"
@@ -181,7 +180,7 @@ class SingletonInjectable(BaseInjectable[_In_T]):
     def unlock(self):
         self.cache.clear()
 
-    def get_instance(self) -> _In_T:
+    def get_instance(self) -> _T:
         with suppress(KeyError):
             return self.cache[self.__INSTANCE_KEY]
 
@@ -193,8 +192,8 @@ class SingletonInjectable(BaseInjectable[_In_T]):
 
 
 @dataclass(repr=False, frozen=True, slots=True)
-class ShouldBeInjectable(Injectable[_In_T]):
-    cls: type[_In_T]
+class ShouldBeInjectable(Injectable[_T]):
+    cls: type[_T]
 
     def get_instance(self) -> NoReturn:
         raise InjectionError(f"`{format_type(self.cls)}` should be an injectable.")
@@ -210,7 +209,7 @@ class Broker(Protocol):
     __slots__ = ()
 
     @abstractmethod
-    def __getitem__(self, cls: type[_In_T] | UnionType, /) -> Injectable[_In_T]:
+    def __getitem__(self, cls: type[_T] | UnionType, /) -> Injectable[_T]:
         raise NotImplementedError
 
     @abstractmethod
@@ -259,7 +258,7 @@ class Container(Broker):
     __records: dict[type, Record] = field(default_factory=dict, init=False)
     __channel: EventChannel = field(default_factory=EventChannel, init=False)
 
-    def __getitem__(self, cls: type[_In_T] | UnionType, /) -> Injectable[_In_T]:
+    def __getitem__(self, cls: type[_T] | UnionType, /) -> Injectable[_T]:
         for cls in get_origins(cls):
             try:
                 injectable, _ = self.__records[cls]
@@ -372,7 +371,7 @@ class Module(EventListener, Broker):
     def __post_init__(self):
         self.__container.add_listener(self)
 
-    def __getitem__(self, cls: type[_In_T] | UnionType, /) -> Injectable[_In_T]:
+    def __getitem__(self, cls: type[_T] | UnionType, /) -> Injectable[_T]:
         for broker in self.__brokers:
             with suppress(KeyError):
                 return broker[cls]
@@ -431,11 +430,11 @@ class Module(EventListener, Broker):
 
     def set_constant(
         self,
-        instance: _In_T,
+        instance: _T,
         on: type | Iterable[type] | UnionType = (),
         *,
         mode: Mode | ModeStr = Mode.get_default(),
-    ) -> _In_T:
+    ) -> _T:
         cls = type(instance)
         self.injectable(
             lambda: instance,
@@ -468,11 +467,11 @@ class Module(EventListener, Broker):
 
         return decorator(wrapped) if wrapped else decorator
 
-    def resolve(self, cls: type[_In_T]) -> _In_T:
+    def resolve(self, cls: type[_T]) -> _T:
         injectable = self[cls]
         return injectable.get_instance()
 
-    def get_instance(self, cls: type[_In_T]) -> _In_T | None:
+    def get_instance(self, cls: type[_T]) -> _T | None:
         try:
             return self.resolve(cls)
         except KeyError:
@@ -480,10 +479,10 @@ class Module(EventListener, Broker):
 
     def get_lazy_instance(
         self,
-        cls: type[_In_T],
+        cls: type[_T],
         *,
         cache: bool = False,
-    ) -> Invertible[_In_T | None]:
+    ) -> Invertible[_T | None]:
         if cache:
             return Lazy(lambda: self.get_instance(cls))
 
@@ -684,8 +683,10 @@ class InjectedFunction(EventListener):
         update_wrapper(self, wrapped, updated=())
         self.__dependencies = Dependencies.empty()
         self.__owner = None
-        self.__setup_queue = LimitedQueue[Callable[[], Any]]()
-        self.on_setup(self.__set_signature)
+
+        queue = Queue[Callable[[], Any]]()
+        queue.put_nowait(self.__set_signature)
+        self.__setup_queue = queue
 
     def __repr__(self) -> str:  # pragma: no cover
         return repr(self.wrapped)
@@ -694,8 +695,12 @@ class InjectedFunction(EventListener):
         return str(self.wrapped)
 
     def __call__(self, /, *args, **kwargs) -> Any:
-        for function in self.__setup_queue:
-            function()
+        queue = self.__setup_queue
+
+        while not queue.empty():
+            setup = queue.get()
+            setup()
+            queue.task_done()
 
         arguments = self.bind(args, kwargs)
         return self.wrapped(*arguments.args, **arguments.kwargs)
@@ -753,7 +758,7 @@ class InjectedFunction(EventListener):
 
     def on_setup(self, wrapped: Callable[[], Any] = None, /):
         def decorator(wp):
-            self.__setup_queue.add(wp)
+            self.__setup_queue.put(wp)
             return wp
 
         return decorator(wrapped) if wrapped else decorator
@@ -781,12 +786,15 @@ class InjectedFunction(EventListener):
             self.__update_vars(variables)
 
     def __update_vars(self, variables: Mapping[str, Any]):
-        def is_dunder(var: str) -> bool:
-            return var.startswith("__") and var.endswith("__")
-
-        restricted_vars = frozenset(var for var in dir(self) if not is_dunder(var))
+        restricted_vars = frozenset(
+            var for var in dir(self) if not self.__is_dunder(var)
+        )
         vars(self).update(
             (var, value)
             for var, value in variables.items()
             if var not in restricted_vars
         )
+
+    @staticmethod
+    def __is_dunder(var: str) -> bool:
+        return var.startswith("__") and var.endswith("__")

{python_injection-0.8.4.post1 → python_injection-0.8.5}/pyproject.toml

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

python_injection-0.8.4.post1/injection/common/queue.py

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