modern-di 0.7.1__tar.gz → 0.8.0__tar.gz

{modern_di-0.7.1 → modern_di-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: modern-di
-Version: 0.7.1
+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.1 → modern_di-0.8.0}/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-0.7.1 → modern_di-0.8.0}/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-0.7.1 → modern_di-0.8.0}/modern_di/providers/injected_factory.py

@@ -9,16 +9,21 @@ T_co = typing.TypeVar("T_co", covariant=True)
 P = typing.ParamSpec("P")
 
 
-class InjectedFactory(typing.Generic[T_co]):
-    __slots__ = ("_factory_provider",)
+class InjectedFactory(AbstractProvider[T_co]):
+    __slots__ = [*AbstractProvider.BASE_SLOTS, "_factory_provider"]
 
     def __init__(self, factory_provider: AbstractProvider[T_co]) -> None:
+        super().__init__(factory_provider.scope)
         self._factory_provider = factory_provider
 
-    async def async_resolve(self, container: Container) -> typing.Callable[[], T_co]:
+    async def async_resolve(self, container: Container) -> typing.Callable[[], T_co]:  # type: ignore[override]
         await self._factory_provider.async_resolve(container)
         return functools.partial(self._factory_provider.sync_resolve, container)
 
-    def sync_resolve(self, container: Container) -> typing.Callable[[], T_co]:
+    def sync_resolve(self, container: Container) -> typing.Callable[[], T_co]:  # type: ignore[override]
         self._factory_provider.sync_resolve(container)
         return functools.partial(self._factory_provider.sync_resolve, container)
+
+    @property
+    def cast(self) -> typing.Callable[[], T_co]:  # type: ignore[override]
+        return typing.cast(typing.Callable[[], T_co], self)

{modern_di-0.7.1 → modern_di-0.8.0}/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-0.7.1 → modern_di-0.8.0}/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.1 → modern_di-0.8.0}/pyproject.toml

@@ -24,6 +24,7 @@ dev = [
     "pytest",
     "pytest-cov",
     "pytest-asyncio",
+    "pytest-repeat",
     "ruff",
     "mypy",
     "typing-extensions",