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

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

@@ -1,11 +1,11 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: modern-di
-Version: 0.8.0
+Version: 0.10.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
 Author-email: Artur Shiriev <me@shiriev.ru>
-License: MIT
+License-Expression: MIT
 Keywords: DI,dependency injector,ioc-container,mocks,python
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -36,6 +36,7 @@ It is in development state yet and gives you the following:
 - Overriding dependencies for tests.
 - Package with zero dependencies.
 - Integration with FastAPI and LiteStar
+- Thread-safe and asyncio concurrency safe providers
 
 📚 [Documentation](https://modern-di.readthedocs.io)
 

{modern_di-0.8.0 → modern_di-0.10.0}/modern_di/container.py

@@ -13,15 +13,15 @@ if typing.TYPE_CHECKING:
 T_co = typing.TypeVar("T_co", covariant=True)
 
 
-class Container(contextlib.AbstractAsyncContextManager["Container"]):
+class Container(contextlib.AbstractAsyncContextManager["Container"], contextlib.AbstractContextManager["Container"]):
     __slots__ = (
-        "scope",
-        "parent_container",
-        "context",
         "_is_async",
-        "_provider_states",
         "_overrides",
+        "_provider_states",
         "_use_threading_lock",
+        "context",
+        "parent_container",
+        "scope",
     )
 
     def __init__(
@@ -37,7 +37,7 @@ class Container(contextlib.AbstractAsyncContextManager["Container"]):
         self.context: dict[str, typing.Any] = context or {}
         self._is_async: bool | None = None
         self._provider_states: dict[str, ProviderState[typing.Any]] = {}
-        self._overrides: dict[str, typing.Any] = {}
+        self._overrides: dict[str, typing.Any] = parent_container._overrides if parent_container else {}  # noqa: SLF001
         self._use_threading_lock = use_threading_lock
 
     def _exit(self) -> None:

{modern_di-0.8.0 → modern_di-0.10.0}/modern_di/provider_state.py

@@ -8,7 +8,7 @@ T_co = typing.TypeVar("T_co", covariant=True)
 
 
 class ProviderState(typing.Generic[T_co]):
-    __slots__ = "context_stack", "instance", "asyncio_lock", "threading_lock"
+    __slots__ = "asyncio_lock", "context_stack", "instance", "threading_lock"
 
     def __init__(self, use_asyncio_lock: bool, use_threading_lock: bool) -> None:
         self.context_stack: contextlib.AsyncExitStack | contextlib.ExitStack | None = None

{modern_di-0.8.0 → modern_di-0.10.0}/modern_di/providers/abstract.py

@@ -39,10 +39,10 @@ class AbstractProvider(typing.Generic[T_co], abc.ABC):
 
 class AbstractOverrideProvider(AbstractProvider[T_co], abc.ABC):
     def override(self, override_object: object, container: Container) -> None:
-        container.find_container(self.scope).override(self.provider_id, override_object)
+        container.override(self.provider_id, override_object)
 
     def reset_override(self, container: Container) -> None:
-        container.find_container(self.scope).reset_override(self.provider_id)
+        container.reset_override(self.provider_id)
 
 
 class AbstractCreatorProvider(AbstractOverrideProvider[T_co], abc.ABC):
@@ -61,31 +61,29 @@ class AbstractCreatorProvider(AbstractOverrideProvider[T_co], abc.ABC):
         self._args: typing.Final = args
         self._kwargs: typing.Final = kwargs
 
+    def _sync_resolve_args(self, container: Container) -> list[typing.Any]:
+        return [x.sync_resolve(container) if isinstance(x, AbstractProvider) else x for x in self._args]
+
+    def _sync_resolve_kwargs(self, container: Container) -> dict[str, typing.Any]:
+        return {k: v.sync_resolve(container) if isinstance(v, AbstractProvider) else v for k, v in self._kwargs.items()}
+
     def _sync_build_creator(self, container: Container) -> typing.Any:  # noqa: ANN401
         return self._creator(
-            *typing.cast(
-                P.args, [x.sync_resolve(container) if isinstance(x, AbstractProvider) else x for x in self._args]
-            ),
-            **typing.cast(
-                P.kwargs,
-                {
-                    k: v.sync_resolve(container) if isinstance(v, AbstractProvider) else v
-                    for k, v in self._kwargs.items()
-                },
-            ),
+            *typing.cast(P.args, self._sync_resolve_args(container)),
+            **typing.cast(P.kwargs, self._sync_resolve_kwargs(container)),
         )
 
+    async def _async_resolve_args(self, container: Container) -> list[typing.Any]:
+        return [await x.async_resolve(container) if isinstance(x, AbstractProvider) else x for x in self._args]
+
+    async def _async_resolve_kwargs(self, container: Container) -> dict[str, typing.Any]:
+        return {
+            k: await v.async_resolve(container) if isinstance(v, AbstractProvider) else v
+            for k, v in self._kwargs.items()
+        }
+
     async def _async_build_creator(self, container: Container) -> typing.Any:  # noqa: ANN401
         return self._creator(
-            *typing.cast(
-                P.args,
-                [await x.async_resolve(container) if isinstance(x, AbstractProvider) else x for x in self._args],
-            ),
-            **typing.cast(
-                P.kwargs,
-                {
-                    k: await v.async_resolve(container) if isinstance(v, AbstractProvider) else v
-                    for k, v in self._kwargs.items()
-                },
-            ),
+            *typing.cast(P.args, await self._async_resolve_args(container)),
+            **typing.cast(P.kwargs, await self._async_resolve_kwargs(container)),
         )

{modern_di-0.8.0 → modern_di-0.10.0}/modern_di/providers/factory.py

@@ -3,7 +3,7 @@ import typing
 
 from modern_di import Container
 from modern_di.providers.abstract import AbstractCreatorProvider
-from modern_di.providers.injected_factory import InjectedFactory
+from modern_di.providers.injected_factory import AsyncInjectedFactory, SyncInjectedFactory
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
@@ -23,8 +23,12 @@ class Factory(AbstractCreatorProvider[T_co]):
         super().__init__(scope, creator, *args, **kwargs)
 
     @property
-    def factory_provider(self) -> InjectedFactory[T_co]:
-        return InjectedFactory(self)
+    def sync_provider(self) -> SyncInjectedFactory[T_co]:
+        return SyncInjectedFactory(self)
+
+    @property
+    def async_provider(self) -> AsyncInjectedFactory[T_co]:
+        return AsyncInjectedFactory(self)
 
     async def async_resolve(self, container: Container) -> T_co:
         container = container.find_container(self.scope)

modern_di-0.10.0/modern_di/providers/injected_factory.py

@@ -0,0 +1,45 @@
+import functools
+import typing
+
+from modern_di import Container
+from modern_di.providers.abstract import AbstractProvider
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+P = typing.ParamSpec("P")
+
+
+class SyncInjectedFactory(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]:  # type: ignore[override]
+        return self.sync_resolve(container)
+
+    def sync_resolve(self, container: Container) -> typing.Callable[[], T_co]:  # type: ignore[override]
+        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)
+
+
+class AsyncInjectedFactory(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[[], typing.Awaitable[T_co]]:  # type: ignore[override]
+        return self.sync_resolve(container)
+
+    def sync_resolve(self, container: Container) -> typing.Callable[[], typing.Awaitable[T_co]]:  # type: ignore[override]
+        return functools.partial(self._factory_provider.async_resolve, container)
+
+    @property
+    def cast(self) -> typing.Callable[[], typing.Awaitable[T_co]]:  # type: ignore[override]
+        return typing.cast(typing.Callable[[], typing.Awaitable[T_co]], self)

modern_di-0.8.0/modern_di/providers/injected_factory.py

@@ -1,29 +0,0 @@
-import functools
-import typing
-
-from modern_di import Container
-from modern_di.providers.abstract import AbstractProvider
-
-
-T_co = typing.TypeVar("T_co", covariant=True)
-P = typing.ParamSpec("P")
-
-
-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]:  # 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]:  # 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.8.0 → modern_di-0.10.0}/modern_di/providers/__init__.py

@@ -13,10 +13,10 @@ __all__ = [
     "AbstractProvider",
     "ContainerProvider",
     "ContextAdapter",
-    "Factory",
     "Dict",
+    "Factory",
     "List",
+    "Resource",
     "Selector",
     "Singleton",
-    "Resource",
 ]