python-injection 0.14.5__py3-none-any.whl → 0.14.6.post0__py3-none-any.whl

injection/_core/common/asynchronous.py

@@ -1,7 +1,7 @@
 from abc import abstractmethod
 from collections.abc import Awaitable, Callable, Generator
 from dataclasses import dataclass
-from typing import Any, NoReturn, Protocol, runtime_checkable
+from typing import Any, AsyncContextManager, NoReturn, Protocol, runtime_checkable
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
@@ -45,3 +45,15 @@ class SyncCaller[**P, T](Caller[P, T]):
 
     def call(self, /, *args: P.args, **kwargs: P.kwargs) -> T:
         return self.callable(*args, **kwargs)
+
+
+try:
+    import anyio
+
+    def create_semaphore(value: int) -> AsyncContextManager[Any]:
+        return anyio.Semaphore(value)
+except ImportError:  # pragma: no cover
+    import asyncio
+
+    def create_semaphore(value: int) -> AsyncContextManager[Any]:
+        return asyncio.Semaphore(value)

injection/_core/injectables.py

@@ -1,7 +1,8 @@
 from abc import ABC, abstractmethod
-from collections.abc import MutableMapping
+from collections.abc import Awaitable, Callable, MutableMapping
 from contextlib import suppress
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from functools import partial
 from typing import (
     Any,
     AsyncContextManager,
@@ -13,6 +14,9 @@ from typing import (
 )
 
 from injection._core.common.asynchronous import Caller
+from injection._core.common.asynchronous import (
+    create_semaphore as _create_async_semaphore,
+)
 from injection._core.scope import Scope, get_active_scopes, get_scope
 from injection.exceptions import InjectionError
 
@@ -37,14 +41,10 @@ class Injectable[T](Protocol):
         raise NotImplementedError
 
 
-@dataclass(repr=False, frozen=True, slots=True)
-class BaseInjectable[T](Injectable[T], ABC):
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class SimpleInjectable[T](Injectable[T]):
     factory: Caller[..., T]
 
-
-class SimpleInjectable[T](BaseInjectable[T]):
-    __slots__ = ()
-
     async def aget_instance(self) -> T:
         return await self.factory.acall()
 
@@ -52,47 +52,74 @@ class SimpleInjectable[T](BaseInjectable[T]):
         return self.factory.call()
 
 
-class SingletonInjectable[T](BaseInjectable[T]):
-    __slots__ = ("__dict__",)
+class CacheLogic[T]:
+    __slots__ = ("__semaphore",)
 
-    __key: ClassVar[str] = "$instance"
+    __semaphore: AsyncContextManager[Any]
 
-    @property
-    def is_locked(self) -> bool:
-        return self.__key in self.__cache
+    def __init__(self) -> None:
+        self.__semaphore = _create_async_semaphore(1)
 
-    @property
-    def __cache(self) -> MutableMapping[str, Any]:
-        return self.__dict__
+    async def aget_or_create[K](
+        self,
+        cache: MutableMapping[K, T],
+        key: K,
+        factory: Callable[..., Awaitable[T]],
+    ) -> T:
+        async with self.__semaphore:
+            with suppress(KeyError):
+                return cache[key]
 
-    async def aget_instance(self) -> T:
-        cache = self.__cache
+            instance = await factory()
+            cache[key] = instance
 
+        return instance
+
+    def get_or_create[K](
+        self,
+        cache: MutableMapping[K, T],
+        key: K,
+        factory: Callable[..., T],
+    ) -> T:
         with suppress(KeyError):
-            return cache[self.__key]
+            return cache[key]
 
-        instance = await self.factory.acall()
-        cache[self.__key] = instance
+        instance = factory()
+        cache[key] = instance
         return instance
 
-    def get_instance(self) -> T:
-        cache = self.__cache
 
-        with suppress(KeyError):
-            return cache[self.__key]
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
+class SingletonInjectable[T](Injectable[T]):
+    factory: Caller[..., T]
+    cache: MutableMapping[str, T] = field(default_factory=dict)
+    logic: CacheLogic[T] = field(default_factory=CacheLogic)
 
-        instance = self.factory.call()
-        cache[self.__key] = instance
-        return instance
+    __key: ClassVar[str] = "$instance"
+
+    @property
+    def is_locked(self) -> bool:
+        return self.__key in self.cache
+
+    async def aget_instance(self) -> T:
+        return await self.logic.aget_or_create(
+            self.cache,
+            self.__key,
+            self.factory.acall,
+        )
+
+    def get_instance(self) -> T:
+        return self.logic.get_or_create(self.cache, self.__key, self.factory.call)
 
     def unlock(self) -> None:
-        self.__cache.pop(self.__key, None)
+        self.cache.pop(self.__key, None)
 
 
 @dataclass(repr=False, eq=False, frozen=True, slots=True)
 class ScopedInjectable[R, T](Injectable[T], ABC):
     factory: Caller[..., R]
     scope_name: str
+    logic: CacheLogic[T] = field(default_factory=CacheLogic)
 
     @property
     def is_locked(self) -> bool:
@@ -107,35 +134,26 @@ class ScopedInjectable[R, T](Injectable[T], ABC):
         raise NotImplementedError
 
     async def aget_instance(self) -> T:
-        scope = self.get_scope()
-
-        with suppress(KeyError):
-            return scope.cache[self]
-
-        instance = await self.abuild(scope)
-        self.set_instance(instance, scope)
-        return instance
+        scope = self.__get_scope()
+        factory = partial(self.abuild, scope)
+        return await self.logic.aget_or_create(scope.cache, self, factory)
 
     def get_instance(self) -> T:
-        scope = self.get_scope()
+        scope = self.__get_scope()
+        factory = partial(self.build, scope)
+        return self.logic.get_or_create(scope.cache, self, factory)
 
-        with suppress(KeyError):
-            return scope.cache[self]
-
-        instance = self.build(scope)
-        self.set_instance(instance, scope)
-        return instance
-
-    def get_scope(self) -> Scope:
-        return get_scope(self.scope_name)
-
-    def set_instance(self, instance: T, scope: Scope) -> None:
-        scope.cache[self] = instance
+    def setdefault(self, instance: T) -> T:
+        scope = self.__get_scope()
+        return self.logic.get_or_create(scope.cache, self, lambda: instance)
 
     def unlock(self) -> None:
         if self.is_locked:
             raise RuntimeError(f"To unlock, close the `{self.scope_name}` scope.")
 
+    def __get_scope(self) -> Scope:
+        return get_scope(self.scope_name)
+
 
 class AsyncCMScopedInjectable[T](ScopedInjectable[AsyncContextManager[T], T]):
     __slots__ = ()
@@ -174,7 +192,7 @@ class SimpleScopedInjectable[T](ScopedInjectable[T, T]):
             scope.cache.pop(self, None)
 
 
-@dataclass(repr=False, frozen=True, slots=True)
+@dataclass(repr=False, eq=False, frozen=True, slots=True)
 class ShouldBeInjectable[T](Injectable[T]):
     cls: type[T]
 

injection/_core/module.py

@@ -300,7 +300,8 @@ class Locator(Broker):
             if injectable.is_locked:
                 continue
 
-            await injectable.aget_instance()
+            with suppress(SkipInjectable):
+                await injectable.aget_instance()
 
     def add_listener(self, listener: EventListener) -> Self:
         self.__channel.add_listener(listener)

injection/_core/scope.py

@@ -98,13 +98,18 @@ def define_scope(name: str, *, shared: bool = False) -> Iterator[None]:
 
 
 def get_active_scopes(name: str) -> tuple[Scope, ...]:
-    return tuple(__SCOPES[name].active_scopes)
+    state = __SCOPES.get(name)
+
+    if state is None:
+        return ()
+
+    return tuple(state.active_scopes)
 
 
 def get_scope(name: str) -> Scope:
-    scope = __SCOPES[name].get_scope()
+    state = __SCOPES.get(name)
 
-    if scope is None:
+    if state is None or (scope := state.get_scope()) is None:
         raise ScopeUndefinedError(
             f"Scope `{name}` isn't defined in the current context."
         )

injection/_core/slots.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 from typing import Any, Protocol, runtime_checkable
 
 from injection._core.injectables import ScopedInjectable
+from injection.exceptions import InjectionError
 
 
 @runtime_checkable
@@ -19,6 +20,5 @@ class ScopedSlot[T](Slot[T]):
     injectable: ScopedInjectable[Any, T]
 
     def set(self, instance: T, /) -> None:
-        injectable = self.injectable
-        scope = injectable.get_scope()
-        injectable.set_instance(instance, scope)
+        if self.injectable.setdefault(instance) is not instance:
+            raise InjectionError("Slot already set.")

{python_injection-0.14.5.dist-info → python_injection-0.14.6.post0.dist-info}/METADATA

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

{python_injection-0.14.5.dist-info → python_injection-0.14.6.post0.dist-info}/RECORD

@@ -5,12 +5,12 @@ injection/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/utils.py,sha256=EuHMrix6gx2YnnUAn2_BPsDkvucGS5-pFhM3596oBK4,2796
 injection/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 injection/_core/descriptors.py,sha256=7fSHlgAqmgR_Uta8KocBapOt1Xyj2dI7RY9ZdoStTzw,726
-injection/_core/injectables.py,sha256=SKP9uKDO8U7ATw_pG-SjP8KIfPDYAC1nzZdONNv1blI,4682
-injection/_core/module.py,sha256=64M6bGtKUA3mmekBiaA8nwBSwBy_N9CohLt6YIU6qss,31767
-injection/_core/scope.py,sha256=pwOqVKOUM_ZteNScgp-hLqyOHg5Ew75jWlfWLLD2PU8,5437
-injection/_core/slots.py,sha256=O2OGLI6Zp5rVzort8ln5j4X54DJVjeIH5V5lj8lskX8,638
+injection/_core/injectables.py,sha256=idNkQZZ29vd73G_lE-eS5C7zGeVe_ALNkUt8M6YjZrk,5519
+injection/_core/module.py,sha256=DLw0pD3HDXfNhzbWM0yeCDKg-Mwg8JAzqZq43tFAXik,31814
+injection/_core/scope.py,sha256=SnjfYnZ62BkxEUh3wXKHl7ivCHRrPFiTa5GMxC-8ACM,5533
+injection/_core/slots.py,sha256=6LoG0XtaRnIGDSG8s-FfUIw_50gL0bl4X3Fo_n-hdak,680
 injection/_core/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-injection/_core/common/asynchronous.py,sha256=9bQDVRE6eqo9K0d5H9RzyFalf0WGoGP7cDrKDGbvZPI,1500
+injection/_core/common/asynchronous.py,sha256=QeS2Lc4gEBFvTA_snOWfme5mTL4BFZWqZ8EzJwOdVos,1816
 injection/_core/common/event.py,sha256=XjzV8gxtGlGvzZs_ykvoC60qmdpd3RN08Eiqz5QUwes,1236
 injection/_core/common/invertible.py,sha256=YZlAdh6bNJgf1-74TRjwJTm8xrlgY95ZhOUGLSJ4XcY,482
 injection/_core/common/key.py,sha256=ghkZD-Y8Moz6SEPNgMh3xgsZUjDVq-XYAmXaCu5VuCA,80
@@ -20,6 +20,6 @@ injection/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 injection/integrations/fastapi.py,sha256=YHSs85_3m6TUVtOwUcV157b3UZJQIw_aXWAg199a-YE,594
 injection/testing/__init__.py,sha256=SiImXDd0-DO1a8S5nbUQRtgDX8iaU_nHcp8DdqwtD2M,896
 injection/testing/__init__.pyi,sha256=iOii0i9F5n7znltGeGQYI2KXC_if9SAogLh1h03yx-0,540
-python_injection-0.14.5.dist-info/METADATA,sha256=jJ_lLiZ8gkIubQ9KXRRYiRwUcu18QXgQX5Ys04A2FU0,3199
-python_injection-0.14.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_injection-0.14.5.dist-info/RECORD,,
+python_injection-0.14.6.post0.dist-info/METADATA,sha256=sRxRmH0mUX84dvnm-e2Vw6dyZrSOqNqaoVdn5A82U_4,3205
+python_injection-0.14.6.post0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_injection-0.14.6.post0.dist-info/RECORD,,