modern-di 0.7.2__py3-none-any.whl → 0.8.0__py3-none-any.whl

modern_di/container.py

@@ -14,7 +14,15 @@ T_co = typing.TypeVar("T_co", covariant=True)
 
 
 class Container(contextlib.AbstractAsyncContextManager["Container"]):
-    __slots__ = "scope", "parent_container", "context", "_is_async", "_provider_states", "_overrides"
+    __slots__ = (
+        "scope",
+        "parent_container",
+        "context",
+        "_is_async",
+        "_provider_states",
+        "_overrides",
+        "_use_threading_lock",
+    )
 
     def __init__(
         self,
@@ -22,6 +30,7 @@ class Container(contextlib.AbstractAsyncContextManager["Container"]):
         scope: enum.IntEnum,
         parent_container: typing.Optional["Container"] = None,
         context: dict[str, typing.Any] | None = None,
+        use_threading_lock: bool = True,
     ) -> None:
         self.scope = scope
         self.parent_container = parent_container
@@ -29,6 +38,7 @@ class Container(contextlib.AbstractAsyncContextManager["Container"]):
         self._is_async: bool | None = None
         self._provider_states: dict[str, ProviderState[typing.Any]] = {}
         self._overrides: dict[str, typing.Any] = {}
+        self._use_threading_lock = use_threading_lock
 
     def _exit(self) -> None:
         self._is_async = None
@@ -74,17 +84,28 @@ class Container(contextlib.AbstractAsyncContextManager["Container"]):
         return container
 
     def fetch_provider_state(
-        self, provider_id: str, is_async_resource: bool = False, is_lock_required: bool = False
+        self,
+        provider_id: str,
+        is_async_resource: bool = False,
+        use_asyncio_lock: bool = False,
+        use_threading_lock: bool = False,
     ) -> ProviderState[typing.Any]:
         self._check_entered()
         if is_async_resource and self._is_async is False:
             msg = "Resolving async resource in sync container is not allowed"
             raise RuntimeError(msg)
 
-        if provider_id not in self._provider_states:
-            self._provider_states[provider_id] = ProviderState(is_lock_required=is_lock_required)
-
-        return self._provider_states[provider_id]
+        if provider_state := self._provider_states.get(provider_id):
+            return provider_state
+
+        # expected to be thread-safe, because setdefault is atomic
+        return self._provider_states.setdefault(
+            provider_id,
+            ProviderState(
+                use_asyncio_lock=use_asyncio_lock,
+                use_threading_lock=self._use_threading_lock and use_threading_lock,
+            ),
+        )
 
     def override(self, provider_id: str, override_object: object) -> None:
         self._overrides[provider_id] = override_object

modern_di/provider_state.py

@@ -1,5 +1,6 @@
 import asyncio
 import contextlib
+import threading
 import typing
 
 
@@ -7,12 +8,13 @@ T_co = typing.TypeVar("T_co", covariant=True)
 
 
 class ProviderState(typing.Generic[T_co]):
-    __slots__ = "context_stack", "instance", "provider_lock"
+    __slots__ = "context_stack", "instance", "asyncio_lock", "threading_lock"
 
-    def __init__(self, is_lock_required: bool) -> None:
+    def __init__(self, use_asyncio_lock: bool, use_threading_lock: bool) -> None:
         self.context_stack: contextlib.AsyncExitStack | contextlib.ExitStack | None = None
         self.instance: T_co | None = None
-        self.provider_lock: typing.Final = asyncio.Lock() if is_lock_required else None
+        self.asyncio_lock: typing.Final = asyncio.Lock() if use_asyncio_lock else None
+        self.threading_lock: typing.Final = threading.Lock() if use_threading_lock else None
 
     async def async_tear_down(self) -> None:
         if self.context_stack is None:

modern_di/providers/resource.py

@@ -58,13 +58,13 @@ class Resource(AbstractCreatorProvider[T_co]):
             return typing.cast(T_co, override)
 
         provider_state = container.fetch_provider_state(
-            self.provider_id, is_async_resource=self._is_async, is_lock_required=True
+            self.provider_id, is_async_resource=self._is_async, use_asyncio_lock=True
         )
         if provider_state.instance is not None:
             return typing.cast(T_co, provider_state.instance)
 
-        assert provider_state.provider_lock
-        await provider_state.provider_lock.acquire()
+        if provider_state.asyncio_lock:
+            await provider_state.asyncio_lock.acquire()
 
         try:
             if provider_state.instance is not None:
@@ -79,7 +79,8 @@ class Resource(AbstractCreatorProvider[T_co]):
                 provider_state.context_stack = contextlib.ExitStack()
                 provider_state.instance = provider_state.context_stack.enter_context(_intermediate_)
         finally:
-            provider_state.provider_lock.release()
+            if provider_state.asyncio_lock:
+                provider_state.asyncio_lock.release()
 
         return typing.cast(T_co, provider_state.instance)
 
@@ -88,7 +89,9 @@ class Resource(AbstractCreatorProvider[T_co]):
         if (override := container.fetch_override(self.provider_id)) is not None:
             return typing.cast(T_co, override)
 
-        provider_state = container.fetch_provider_state(self.provider_id)
+        provider_state = container.fetch_provider_state(
+            self.provider_id, is_async_resource=self._is_async, use_threading_lock=True
+        )
         if provider_state.instance is not None:
             return typing.cast(T_co, provider_state.instance)
 
@@ -96,11 +99,21 @@ class Resource(AbstractCreatorProvider[T_co]):
             msg = "Async resource cannot be resolved synchronously"
             raise RuntimeError(msg)
 
-        _intermediate_ = self._sync_build_creator(container)
+        if provider_state.threading_lock:
+            provider_state.threading_lock.acquire()
 
-        provider_state.context_stack = contextlib.ExitStack()
-        provider_state.instance = provider_state.context_stack.enter_context(
-            typing.cast(contextlib.AbstractContextManager[typing.Any], _intermediate_)
-        )
+        try:
+            if provider_state.instance is not None:
+                return typing.cast(T_co, provider_state.instance)
+
+            _intermediate_ = self._sync_build_creator(container)
+
+            provider_state.context_stack = contextlib.ExitStack()
+            provider_state.instance = provider_state.context_stack.enter_context(
+                typing.cast(contextlib.AbstractContextManager[typing.Any], _intermediate_)
+            )
+        finally:
+            if provider_state.threading_lock:
+                provider_state.threading_lock.release()
 
         return typing.cast(T_co, provider_state.instance)

modern_di/providers/singleton.py

@@ -26,12 +26,12 @@ class Singleton(AbstractCreatorProvider[T_co]):
         if (override := container.fetch_override(self.provider_id)) is not None:
             return typing.cast(T_co, override)
 
-        provider_state = container.fetch_provider_state(self.provider_id, is_lock_required=True)
+        provider_state = container.fetch_provider_state(self.provider_id, use_asyncio_lock=True)
         if provider_state.instance is not None:
             return typing.cast(T_co, provider_state.instance)
 
-        assert provider_state.provider_lock
-        await provider_state.provider_lock.acquire()
+        assert provider_state.asyncio_lock
+        await provider_state.asyncio_lock.acquire()
 
         try:
             if provider_state.instance is not None:
@@ -39,7 +39,7 @@ class Singleton(AbstractCreatorProvider[T_co]):
 
             provider_state.instance = typing.cast(T_co, await self._async_build_creator(container))
         finally:
-            provider_state.provider_lock.release()
+            provider_state.asyncio_lock.release()
 
         return provider_state.instance
 
@@ -48,9 +48,20 @@ class Singleton(AbstractCreatorProvider[T_co]):
         if (override := container.fetch_override(self.provider_id)) is not None:
             return typing.cast(T_co, override)
 
-        provider_state = container.fetch_provider_state(self.provider_id)
+        provider_state = container.fetch_provider_state(self.provider_id, use_threading_lock=True)
         if provider_state.instance is not None:
             return typing.cast(T_co, provider_state.instance)
 
-        provider_state.instance = self._sync_build_creator(container)
+        if provider_state.threading_lock:
+            provider_state.threading_lock.acquire()
+
+        try:
+            if provider_state.instance is not None:
+                return typing.cast(T_co, provider_state.instance)
+
+            provider_state.instance = self._sync_build_creator(container)
+        finally:
+            if provider_state.threading_lock:
+                provider_state.threading_lock.release()
+
         return typing.cast(T_co, provider_state.instance)

{modern_di-0.7.2.dist-info → modern_di-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: modern-di
-Version: 0.7.2
+Version: 0.8.0
 Summary: Dependency Injection framework with IOC-container and scopes
 Project-URL: repository, https://github.com/modern-python/modern-di
 Project-URL: docs, https://modern-di.readthedocs.io

{modern_di-0.7.2.dist-info → modern_di-0.8.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
 modern_di/__init__.py,sha256=L01VkzSJiV0d0FPrh1DZ-Wy5mUmoG6X-oLz7xYxtehI,194
-modern_di/container.py,sha256=wJ18aOVb-RMFEBafTesZdvMUOSlJ-44qcNFtR0Cak1Q,4351
+modern_di/container.py,sha256=ySfFh9keq5XZvIEpxEFUPW226aVA_JGC2k3buTxPL9U,4831
 modern_di/graph.py,sha256=X60wtG3Mqus_5YZNiZlQuXoHODBp7rYl_IHJs7GzSQM,1356
-modern_di/provider_state.py,sha256=5Bl_iYEpXjMqoWZJ4op2-axo4Z8nR_vYbLVHL_u5R0c,1206
+modern_di/provider_state.py,sha256=JBn3Yi2KzFpclVr_Iyiewosqy9MNZk6jrkkF433fJGQ,1358
 modern_di/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 modern_di/scope.py,sha256=e6Olc-CF89clbYDNGciy-F8EqJt1Mw2703zfuJaEY94,113
 modern_di/providers/__init__.py,sha256=r594L4kWv_XCHVZcsfUIGBtlXCmih6NR1Ifa105XoQ4,649
@@ -12,9 +12,9 @@ modern_di/providers/dict.py,sha256=nCU9iaqteYHDbILAfhrdnbMgS9_emE4MS7Xn2VoUlPo,8
 modern_di/providers/factory.py,sha256=NozbrprJlRJPWSNdvKR0kOwPt1Q9i_ZLJTPOfzdDDJo,1359
 modern_di/providers/injected_factory.py,sha256=wK9GG5_d33BdrpimnR6W-zeviZcCS8qe8ZGTmjYtFf4,1135
 modern_di/providers/list.py,sha256=3hx34RfBRmqzh-cT5D6wSTDJPkBGMK_ul4n9gQz-o9M,769
-modern_di/providers/resource.py,sha256=UwIrX63Crf5iUXu3cp80hw7orl9ahy8frstxAf1Y7wc,4098
+modern_di/providers/resource.py,sha256=CsMekkVISklTqN539XqH4iE80vfc6sQMav5OT8fZvyA,4591
 modern_di/providers/selector.py,sha256=RQbHD2-Liw-TGqu6UELbfCzXYuqxiO_Mg1tLyF3mKQo,1419
-modern_di/providers/singleton.py,sha256=7XBNhVzhV5Rh_F7iWZx8is7i7_PuctQ9thKeqIkjnTs,1999
-modern_di-0.7.2.dist-info/METADATA,sha256=bmefLrcGPc-baBH_mToSar0qh2m3zEJBPM3_gkOafC8,5440
-modern_di-0.7.2.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-modern_di-0.7.2.dist-info/RECORD,,
+modern_di/providers/singleton.py,sha256=_hUpCmbHgLAigdhBiu0zypwWwrIGdB6_oZkGfuLxzNE,2372
+modern_di-0.8.0.dist-info/METADATA,sha256=io18Xr4sXvf11cQambypZuh4aB4IZ9XPaMq2SJJTG_c,5440
+modern_di-0.8.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+modern_di-0.8.0.dist-info/RECORD,,