python-injection 0.18.9__tar.gz → 0.18.11__tar.gz

{python_injection-0.18.9 → python_injection-0.18.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-injection
-Version: 0.18.9
+Version: 0.18.11
 Summary: Fast and easy dependency injection framework.
 Project-URL: Repository, https://github.com/100nm/python-injection
 Author: remimd

{python_injection-0.18.9 → python_injection-0.18.11}/injection/__init__.pyi

@@ -217,8 +217,13 @@ class Module:
         /,
         threadsafe: bool = ...,
     ) -> Callable[..., Awaitable[T]]: ...
-    async def afind_instance[T](self, cls: _InputType[T]) -> T: ...
-    def find_instance[T](self, cls: _InputType[T]) -> T:
+    async def afind_instance[T](
+        self,
+        cls: _InputType[T],
+        *,
+        threadsafe: bool = ...,
+    ) -> T: ...
+    def find_instance[T](self, cls: _InputType[T], *, threadsafe: bool = ...) -> T:
         """
         Function used to retrieve an instance associated with the type passed in
         parameter or an exception will be raised.
@@ -229,59 +234,66 @@ class Module:
         self,
         cls: _InputType[T],
         default: Default,
+        *,
+        threadsafe: bool = ...,
     ) -> T | Default: ...
     @overload
     async def aget_instance[T](
         self,
         cls: _InputType[T],
-        default: None = ...,
-    ) -> T | None: ...
+        default: T = ...,
+        *,
+        threadsafe: bool = ...,
+    ) -> T: ...
     @overload
     def get_instance[T, Default](
         self,
         cls: _InputType[T],
         default: Default,
+        *,
+        threadsafe: bool = ...,
     ) -> T | Default:
         """
         Function used to retrieve an instance associated with the type passed in
-        parameter or return `None`.
+        parameter or return `NotImplemented`.
         """
 
     @overload
     def get_instance[T](
         self,
         cls: _InputType[T],
-        default: None = ...,
-    ) -> T | None: ...
+        default: T = ...,
+        *,
+        threadsafe: bool = ...,
+    ) -> T: ...
     @overload
     def aget_lazy_instance[T, Default](
         self,
         cls: _InputType[T],
         default: Default,
         *,
-        cache: bool = ...,
+        threadsafe: bool = ...,
     ) -> Awaitable[T | Default]: ...
     @overload
     def aget_lazy_instance[T](
         self,
         cls: _InputType[T],
-        default: None = ...,
+        default: T = ...,
         *,
-        cache: bool = ...,
-    ) -> Awaitable[T | None]: ...
+        threadsafe: bool = ...,
+    ) -> Awaitable[T]: ...
     @overload
     def get_lazy_instance[T, Default](
         self,
         cls: _InputType[T],
         default: Default,
         *,
-        cache: bool = ...,
+        threadsafe: bool = ...,
     ) -> _Invertible[T | Default]:
         """
         Function used to retrieve an instance associated with the type passed in
-        parameter or `None`. Return a `Invertible` object. To access the instance
+        parameter or `NotImplemented`. 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
         """
@@ -290,10 +302,10 @@ class Module:
     def get_lazy_instance[T](
         self,
         cls: _InputType[T],
-        default: None = ...,
+        default: T = ...,
         *,
-        cache: bool = ...,
-    ) -> _Invertible[T | None]: ...
+        threadsafe: bool = ...,
+    ) -> _Invertible[T]: ...
     def init_modules(self, *modules: Module) -> Self:
         """
         Function to clean modules in use and to use those passed as parameters.

{python_injection-0.18.9 → python_injection-0.18.11}/injection/_core/common/asynchronous.py

@@ -52,6 +52,7 @@ try:
 
     def create_semaphore(value: int) -> AsyncContextManager[Any]:
         return anyio.Semaphore(value)
+
 except ImportError:  # pragma: no cover
     import asyncio
 

{python_injection-0.18.9 → python_injection-0.18.11}/injection/_core/common/lazy.py

@@ -1,7 +1,6 @@
-from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
+from collections.abc import Callable, Iterator
 from functools import partial
 
-from injection._core.common.asynchronous import SimpleAwaitable
 from injection._core.common.invertible import Invertible, SimpleInvertible
 
 
@@ -18,19 +17,6 @@ def lazy[T](factory: Callable[..., T]) -> Invertible[T]:
     return SimpleInvertible(getter)
 
 
-def alazy[T](factory: Callable[..., Awaitable[T]]) -> Awaitable[T]:
-    async def cache() -> AsyncIterator[T]:
-        nonlocal factory
-        value = await factory()
-        del factory
-
-        while True:
-            yield value
-
-    getter = partial(anext, cache())
-    return SimpleAwaitable(getter)
-
-
 class Lazy[T](Invertible[T]):
     __slots__ = ("__invertible", "__is_set")
 

python_injection-0.18.11/injection/_core/common/threading.py

@@ -0,0 +1,7 @@
+from contextlib import nullcontext
+from threading import RLock
+from typing import Any, ContextManager
+
+
+def get_lock(threadsafe: bool) -> ContextManager[Any]:
+    return RLock() if threadsafe else nullcontext()

{python_injection-0.18.9 → python_injection-0.18.11}/injection/_core/module.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import threading
 from abc import ABC, abstractmethod
 from collections import OrderedDict, deque
 from collections.abc import (
@@ -14,7 +13,7 @@ from collections.abc import (
     Iterator,
     Mapping,
 )
-from contextlib import asynccontextmanager, contextmanager, nullcontext, suppress
+from contextlib import asynccontextmanager, contextmanager, suppress
 from dataclasses import dataclass, field
 from enum import StrEnum
 from functools import partial, partialmethod, singledispatchmethod, update_wrapper
@@ -51,7 +50,8 @@ from injection._core.common.asynchronous import (
 from injection._core.common.event import Event, EventChannel, EventListener
 from injection._core.common.invertible import Invertible, SimpleInvertible
 from injection._core.common.key import new_short_key
-from injection._core.common.lazy import Lazy, alazy, lazy
+from injection._core.common.lazy import Lazy, lazy
+from injection._core.common.threading import get_lock
 from injection._core.common.type import (
     InputType,
     TypeInfo,
@@ -617,35 +617,48 @@ class Module(Broker, EventListener):
         )
         return factory.__inject_metadata__.acall
 
-    async def afind_instance[T](self, cls: InputType[T]) -> T:
-        injectable = self[cls]
-        return await injectable.aget_instance()
+    async def afind_instance[T](
+        self,
+        cls: InputType[T],
+        *,
+        threadsafe: bool = False,
+    ) -> T:
+        with get_lock(threadsafe):
+            injectable = self[cls]
+            return await injectable.aget_instance()
 
-    def find_instance[T](self, cls: InputType[T]) -> T:
-        injectable = self[cls]
-        return injectable.get_instance()
+    def find_instance[T](self, cls: InputType[T], *, threadsafe: bool = False) -> T:
+        with get_lock(threadsafe):
+            injectable = self[cls]
+            return injectable.get_instance()
 
     @overload
     async def aget_instance[T, Default](
         self,
         cls: InputType[T],
         default: Default,
+        *,
+        threadsafe: bool = ...,
     ) -> T | Default: ...
 
     @overload
     async def aget_instance[T](
         self,
         cls: InputType[T],
-        default: None = ...,
-    ) -> T | None: ...
+        default: T = ...,
+        *,
+        threadsafe: bool = ...,
+    ) -> T: ...
 
     async def aget_instance[T, Default](
         self,
         cls: InputType[T],
-        default: Default | None = None,
-    ) -> T | Default | None:
+        default: Default = NotImplemented,
+        *,
+        threadsafe: bool = False,
+    ) -> T | Default:
         try:
-            return await self.afind_instance(cls)
+            return await self.afind_instance(cls, threadsafe=threadsafe)
         except (KeyError, SkipInjectable):
             return default
 
@@ -654,22 +667,28 @@ class Module(Broker, EventListener):
         self,
         cls: InputType[T],
         default: Default,
+        *,
+        threadsafe: bool = ...,
     ) -> T | Default: ...
 
     @overload
     def get_instance[T](
         self,
         cls: InputType[T],
-        default: None = ...,
-    ) -> T | None: ...
+        default: T = ...,
+        *,
+        threadsafe: bool = ...,
+    ) -> T: ...
 
     def get_instance[T, Default](
         self,
         cls: InputType[T],
-        default: Default | None = None,
-    ) -> T | Default | None:
+        default: Default = NotImplemented,
+        *,
+        threadsafe: bool = False,
+    ) -> T | Default:
         try:
-            return self.find_instance(cls)
+            return self.find_instance(cls, threadsafe=threadsafe)
         except (KeyError, SkipInjectable):
             return default
 
@@ -679,29 +698,29 @@ class Module(Broker, EventListener):
         cls: InputType[T],
         default: Default,
         *,
-        cache: bool = ...,
+        threadsafe: bool = ...,
     ) -> Awaitable[T | Default]: ...
 
     @overload
     def aget_lazy_instance[T](
         self,
         cls: InputType[T],
-        default: None = ...,
+        default: T = ...,
         *,
-        cache: bool = ...,
-    ) -> Awaitable[T | None]: ...
+        threadsafe: bool = ...,
+    ) -> Awaitable[T]: ...
 
     def aget_lazy_instance[T, Default](
         self,
         cls: InputType[T],
-        default: Default | None = None,
+        default: Default = NotImplemented,
         *,
-        cache: bool = False,
-    ) -> Awaitable[T | Default | None]:
-        if cache:
-            return alazy(lambda: self.aget_instance(cls, default))
-
-        function = self.make_injected_function(lambda instance=default: instance)
+        threadsafe: bool = False,
+    ) -> Awaitable[T | Default]:
+        function = self.make_injected_function(
+            lambda instance=default: instance,
+            threadsafe=threadsafe,
+        )
         metadata = function.__inject_metadata__.set_owner(cls)
         return SimpleAwaitable(metadata.acall)
 
@@ -711,29 +730,29 @@ class Module(Broker, EventListener):
         cls: InputType[T],
         default: Default,
         *,
-        cache: bool = ...,
+        threadsafe: bool = ...,
     ) -> Invertible[T | Default]: ...
 
     @overload
     def get_lazy_instance[T](
         self,
         cls: InputType[T],
-        default: None = ...,
+        default: T = ...,
         *,
-        cache: bool = ...,
-    ) -> Invertible[T | None]: ...
+        threadsafe: bool = ...,
+    ) -> Invertible[T]: ...
 
     def get_lazy_instance[T, Default](
         self,
         cls: InputType[T],
-        default: Default | None = None,
+        default: Default = NotImplemented,
         *,
-        cache: bool = False,
-    ) -> Invertible[T | Default | None]:
-        if cache:
-            return lazy(lambda: self.get_instance(cls, default))
-
-        function = self.make_injected_function(lambda instance=default: instance)
+        threadsafe: bool = False,
+    ) -> Invertible[T | Default]:
+        function = self.make_injected_function(
+            lambda instance=default: instance,
+            threadsafe=threadsafe,
+        )
         metadata = function.__inject_metadata__.set_owner(cls)
         return SimpleInvertible(metadata.call)
 
@@ -996,7 +1015,7 @@ class InjectMetadata[**P, T](Caller[P, T], EventListener):
 
     def __init__(self, wrapped: Callable[P, T], /, threadsafe: bool) -> None:
         self.__dependencies = Dependencies.empty()
-        self.__lock = threading.RLock() if threadsafe else nullcontext()
+        self.__lock = get_lock(threadsafe)
         self.__owner = None
         self.__tasks = deque()
         self.__wrapped = wrapped

{python_injection-0.18.9 → python_injection-0.18.11}/injection/_core/scope.py

@@ -1,17 +1,10 @@
 from __future__ import annotations
 
 import itertools
-import threading
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from collections.abc import AsyncIterator, Iterator, Mapping, MutableMapping
-from contextlib import (
-    AsyncExitStack,
-    ExitStack,
-    asynccontextmanager,
-    contextmanager,
-    nullcontext,
-)
+from contextlib import AsyncExitStack, ExitStack, asynccontextmanager, contextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass, field
 from enum import StrEnum
@@ -30,6 +23,7 @@ from typing import (
 )
 
 from injection._core.common.key import new_short_key
+from injection._core.common.threading import get_lock
 from injection._core.slots import SlotKey
 from injection.exceptions import (
     InjectionError,
@@ -202,7 +196,7 @@ def _bind_scope(
     kind: ScopeKind | ScopeKindStr,
     threadsafe: bool,
 ) -> Iterator[ScopeFacade]:
-    lock = threading.RLock() if threadsafe else nullcontext()
+    lock = get_lock(threadsafe)
 
     with lock:
         match ScopeKind(kind):
@@ -223,11 +217,10 @@ def _bind_scope(
             )
 
         stack = ExitStack()
-        binder = states[name].bind(scope)
-        stack.enter_context(binder)
+        stack.enter_context(states[name].bind(scope))
 
     try:
-        yield _UserScope(scope)
+        yield _UserScope(scope, lock)
 
     finally:
         with lock:
@@ -325,6 +318,7 @@ class ScopeFacade(Protocol):
 @dataclass(repr=False, frozen=True, slots=True)
 class _UserScope(ScopeFacade):
     scope: Scope
+    lock: ContextManager[Any]
 
     def set_slot[T](self, key: SlotKey[T], value: T) -> Self:
         return self.slot_map({key: value})
@@ -332,9 +326,11 @@ class _UserScope(ScopeFacade):
     def slot_map(self, mapping: Mapping[SlotKey[Any], Any], /) -> Self:
         cache = self.scope.cache
 
-        for slot_key in mapping:
-            if slot_key in cache:
-                raise InjectionError("Slot already set.")
+        with self.lock:
+            for slot_key in mapping:
+                if slot_key in cache:
+                    raise InjectionError("Slot already set.")
+
+            cache.update(mapping)
 
-        cache.update(mapping)
         return self

{python_injection-0.18.9 → python_injection-0.18.11}/injection/ext/fastapi.py

@@ -1,3 +1,4 @@
+from dataclasses import dataclass, field
 from types import GenericAlias
 from typing import Annotated, Any, TypeAliasType
 
@@ -5,20 +6,26 @@ from fastapi import Depends
 
 from injection import Module, mod
 
-__all__ = ("Inject",)
+__all__ = ("Inject", "InjectThreadSafe")
 
 
+@dataclass(eq=False, frozen=True, slots=True)
 class FastAPIInject:
-    __slots__ = ()
+    module: Module = field(default_factory=mod)
+    threadsafe: bool = field(default=False)
 
     def __call__[T](
         self,
         cls: type[T] | TypeAliasType | GenericAlias,
         /,
         default: T = NotImplemented,
+        *,
         module: Module | None = None,
+        threadsafe: bool | None = None,
     ) -> Any:
-        ainstance = (module or mod()).aget_lazy_instance(cls, default)
+        module = module or self.module
+        threadsafe = self.threadsafe if threadsafe is None else threadsafe
+        ainstance = module.aget_lazy_instance(cls, default, threadsafe=threadsafe)
 
         async def dependency() -> T:
             return await ainstance
@@ -34,5 +41,6 @@ class FastAPIInject:
 
 
 Inject = FastAPIInject()
+InjectThreadSafe = FastAPIInject(threadsafe=True)
 
 del FastAPIInject

{python_injection-0.18.9 → python_injection-0.18.11}/injection/ext/fastapi.pyi

@@ -3,3 +3,5 @@ from typing import Annotated
 from fastapi import Depends
 
 type Inject[T, *Metadata] = Annotated[T, Depends(...), *Metadata]
+
+type InjectThreadSafe[T, *Metadata] = Inject[T, *Metadata]

{python_injection-0.18.9 → python_injection-0.18.11}/pyproject.toml

@@ -29,7 +29,7 @@ test = [
 
 [project]
 name = "python-injection"
-version = "0.18.9"
+version = "0.18.11"
 description = "Fast and easy dependency injection framework."
 license = "MIT"
 license-files = ["LICENSE"]