modern-di 0.9.0__tar.gz → 0.11.0__tar.gz

{modern_di-0.9.0 → modern_di-0.11.0}/PKG-INFO

@@ -1,11 +1,11 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: modern-di
-Version: 0.9.0
+Version: 0.11.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
@@ -40,7 +40,17 @@ It is in development state yet and gives you the following:
 
 📚 [Documentation](https://modern-di.readthedocs.io)
 
-## Describe resources and classes:
+# Quickstart
+
+## 1. Install `modern-di` using your favorite tool:
+
+```shell
+pip install modern-di
+uv add modern-di
+poetry add modern-di
+```
+
+## 2. Describe resources and classes:
 ```python
 import dataclasses
 import logging
@@ -74,7 +84,7 @@ class DependentFactory:
     async_resource: str
 ```
 
-## Describe dependencies graph (IoC-container)
+## 3. Describe dependencies graph
 ```python
 from modern_di import BaseGraph, Scope, providers
 
@@ -91,7 +101,15 @@ class Dependencies(BaseGraph):
     )
 ```
 
-## Create container and resolve dependencies in your code
+## 4.1. Integrate with your framework
+
+For now there are integration for the following frameworks:
+1. [FastAPI](https://modern-di.readthedocs.io/en/latest/integrations/fastapi.html)
+2. [LiteStar](https://modern-di.readthedocs.io/en/latest/integrations/litestar.html)
+
+## 4.2. Or use `modern-di` without integrations
+
+Create container and resolve dependencies in your code
 ```python
 from modern_di import Container, Scope
 

{modern_di-0.9.0 → modern_di-0.11.0}/modern_di/container.py

@@ -13,7 +13,7 @@ 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__ = (
         "_is_async",
         "_overrides",

{modern_di-0.9.0 → modern_di-0.11.0}/modern_di/providers/__init__.py

@@ -4,6 +4,7 @@ from modern_di.providers.context_adapter import ContextAdapter
 from modern_di.providers.dict import Dict
 from modern_di.providers.factory import Factory
 from modern_di.providers.list import List
+from modern_di.providers.object import Object
 from modern_di.providers.resource import Resource
 from modern_di.providers.selector import Selector
 from modern_di.providers.singleton import Singleton
@@ -16,6 +17,7 @@ __all__ = [
     "Dict",
     "Factory",
     "List",
+    "Object",
     "Resource",
     "Selector",
     "Singleton",

{modern_di-0.9.0 → modern_di-0.11.0}/modern_di/providers/abstract.py

@@ -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.9.0 → modern_di-0.11.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.11.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.11.0/modern_di/providers/object.py

@@ -0,0 +1,27 @@
+import enum
+import typing
+
+from modern_di import Container
+from modern_di.providers.abstract import AbstractOverrideProvider
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+P = typing.ParamSpec("P")
+
+
+class Object(AbstractOverrideProvider[T_co]):
+    __slots__ = [*AbstractOverrideProvider.BASE_SLOTS, "_obj"]
+
+    def __init__(self, scope: enum.IntEnum, obj: T_co) -> None:
+        super().__init__(scope)
+        self._obj: typing.Final = obj
+
+    async def async_resolve(self, container: Container) -> T_co:
+        return self.sync_resolve(container)
+
+    def sync_resolve(self, container: Container) -> T_co:
+        container = container.find_container(self.scope)
+        if (override := container.fetch_override(self.provider_id)) is not None:
+            return typing.cast(T_co, override)
+
+        return self._obj

{modern_di-0.9.0 → modern_di-0.11.0}/modern_di/providers/resource.py

@@ -1,4 +1,4 @@
-import contextlib
+import contextlib  # noqa: A005
 import enum
 import inspect
 import typing

modern_di-0.9.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)