python-injection 0.18.9__py3-none-any.whl → 0.18.11__py3-none-any.whl

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.

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
 

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

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

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

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

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

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.dist-info → python_injection-0.18.11.dist-info}/METADATA

@@ -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.dist-info → python_injection-0.18.11.dist-info}/RECORD

@@ -1,5 +1,5 @@
 injection/__init__.py,sha256=7ZRUlO5EEPWO7IlbYHD-8DOX-cg4Np4nYq5fpw-U56o,1259
-injection/__init__.pyi,sha256=aV1Ebgb7zdCs6b4K-aVzm0JX6W3x0fGp8vtFmWe2U_o,10718
+injection/__init__.pyi,sha256=K9hz6jPK6-uManEmrs4ep2k2dxo_xJKftdYP5xPRNpA,10908
 injection/entrypoint.py,sha256=12b0_zHAFxHCerAoJTIHkhqi3mLkgheECYAaCUZv_DU,4751
 injection/exceptions.py,sha256=v57yMujiq6H_zwwn30A8UYEZX9R9k-bY8FnsdaimPM4,1025
 injection/loaders.py,sha256=6TjVz9yaQDCVIPIIhjeC6GSXm9rn3oUU2b5KjfOYlsM,6568
@@ -7,22 +7,23 @@ injection/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/_core/descriptors.py,sha256=jH0pyIlPurMmU4yXr-HKS_7BJ-9d0XUvEx4pQre3QeI,704
 injection/_core/injectables.py,sha256=Rg1nxDkbcpeX4ELohrNVMguPhN36SNQuD0JKfyfL6bI,6192
-injection/_core/module.py,sha256=4WqrDti98A5CrIWaHlld1GYYm4K-8XkKltchJoyXUTU,32016
-injection/_core/scope.py,sha256=6EKhwbXMwx8ZvqQ5TKzfVtg_JWHhZj_qkHACiDqs6h0,8731
+injection/_core/module.py,sha256=aSUHKLFJ63yx6FgJ6AKpDccaZ-H1YpKQyoaKxb4YXfk,32414
+injection/_core/scope.py,sha256=NY6YWcIIXqBKTjXVsqsahxbw-bPJiL0CwHp6CyjBGJo,8753
 injection/_core/slots.py,sha256=g9TG6CbqRzCsjg01iPyfRtTTUCJnnJOwcj9mJabH0dc,37
 injection/_core/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-injection/_core/common/asynchronous.py,sha256=QeS2Lc4gEBFvTA_snOWfme5mTL4BFZWqZ8EzJwOdVos,1816
+injection/_core/common/asynchronous.py,sha256=lx1Ce3o6K00vzrZNRZUuf7wWlUKrdV3M53YZGyxQhOk,1817
 injection/_core/common/event.py,sha256=XjzV8gxtGlGvzZs_ykvoC60qmdpd3RN08Eiqz5QUwes,1236
 injection/_core/common/invertible.py,sha256=gA_vw5nBjgp_w9MrDK5jMO8lhuOQWON8BbPpKzEuIY0,502
 injection/_core/common/key.py,sha256=ghkZD-Y8Moz6SEPNgMh3xgsZUjDVq-XYAmXaCu5VuCA,80
-injection/_core/common/lazy.py,sha256=6xh5h0lmaNvl32V0WoX4VCTsNJ3zUJdWVqpLJ_YeIIU,1363
+injection/_core/common/lazy.py,sha256=L7C2dB5UBI--W5Kkvntp_jypYhudY3SHqs8rM6jxxsk,965
+injection/_core/common/threading.py,sha256=EsIvJl1brMsi551zzMILsMCXNHYUkQP22Mg4FZhp0hw,211
 injection/_core/common/type.py,sha256=SCDtmBv9qFvEf5o5tTgCuwMDfuo1fgjSW0bUqA8ACis,2251
 injection/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-injection/ext/fastapi.py,sha256=layUUer5IWiZX6Mmx1_RCYDLNCtEHtpya5ZL6TTBOkY,968
-injection/ext/fastapi.pyi,sha256=8OZEUjHFB9n7QXv_dtXdDuXW-r2huQEFsJ03gJOOvwQ,125
+injection/ext/fastapi.py,sha256=0nx83KoLVvo1F01cOTuLaPKTLuWnBVgNOFmgJfTORiM,1374
+injection/ext/fastapi.pyi,sha256=HLs7mfruIEFRrN_Xf8oCvSa4qwHWfwm6HHU_KMedXkE,185
 injection/testing/__init__.py,sha256=bJ7WXBXrw4rHc91AFVFnOwFLWOlpvX9Oh2SnRQ_NESo,919
 injection/testing/__init__.pyi,sha256=raGsGlxwbz3jkzJwA_5oCIE1emWINjT2UuwzbnqRb-0,577
-python_injection-0.18.9.dist-info/METADATA,sha256=ReK9ZuwTqgR5Pv9RI-o2p-j33O2GgGz0Fq_WUpxBkZU,3397
-python_injection-0.18.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_injection-0.18.9.dist-info/licenses/LICENSE,sha256=oC77BOa9kaaQni5rW-Z-ytz3E5h4EVg248BHg9UFgyg,1063
-python_injection-0.18.9.dist-info/RECORD,,
+python_injection-0.18.11.dist-info/METADATA,sha256=IP-VWz5cIjn8xala0lvU-b4ecUkQrt0k9jLTNUH6ptA,3398
+python_injection-0.18.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_injection-0.18.11.dist-info/licenses/LICENSE,sha256=oC77BOa9kaaQni5rW-Z-ytz3E5h4EVg248BHg9UFgyg,1063
+python_injection-0.18.11.dist-info/RECORD,,