modern-di 0.5.1__tar.gz → 0.6.0__tar.gz

modern_di-0.6.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.3
+Name: modern-di
+Version: 0.6.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>
+Keywords: DI,dependency injector,ioc-container,mocks,python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: <4,>=3.10
+Description-Content-Type: text/markdown
+
+"Modern-DI"
+==
+
+| Project            | Badges                                                                                                                                                                                                                                                                                          |
+|--------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| common             | [![MyPy Strict](https://img.shields.io/badge/mypy-strict-blue)](https://mypy.readthedocs.io/en/stable/getting_started.html#strict-mode-and-configuration) [![GitHub stars](https://img.shields.io/github/stars/modern-python/modern-di)](https://github.com/modern-python/modern-di/stargazers) |
+| modern-di          | [![Supported versions](https://img.shields.io/pypi/pyversions/modern-di.svg)](https://pypi.python.org/pypi/modern-di ) [![downloads](https://img.shields.io/pypi/dm/modern-di.svg)](https://pypistats.org/packages/modern-di)                                                                   |
+| modern-di-fastapi  | [![Supported versions](https://img.shields.io/pypi/pyversions/modern-di-fastapi.svg)](https://pypi.python.org/pypi/modern-di-fastapi) [![downloads](https://img.shields.io/pypi/dm/modern-di-fastapi.svg)](https://pypistats.org/packages/modern-di-fastapi)                                    |
+| modern-di-litestar | [![Supported versions](https://img.shields.io/pypi/pyversions/modern-di-litestar.svg)](https://pypi.python.org/pypi/modern-di-litestar) [![downloads](https://img.shields.io/pypi/dm/modern-di-litestar.svg)](https://pypistats.org/packages/modern-di-litestar)                                |
+
+Dependency injection framework for Python inspired by `dependency-injector` and `dishka`.
+
+It is in early development state and gives you the following:
+- DI framework with IOC-container and scopes.
+- Async and sync resolving.
+- Python 3.10-3.13 support.
+- Full coverage by types annotations (mypy in strict mode).
+- Overriding dependencies for tests.
+- Package with zero dependencies.
+
+📚 [Documentation](https://modern-di.readthedocs.io)
+
+## Describe resources and classes:
+```python
+import dataclasses
+import logging
+import typing
+
+
+logger = logging.getLogger(__name__)
+
+
+# singleton provider with finalization
+def create_sync_resource() -> typing.Iterator[str]:
+    logger.debug("Resource initiated")
+    try:
+        yield "sync resource"
+    finally:
+        logger.debug("Resource destructed")
+
+
+# same, but async
+async def create_async_resource() -> typing.AsyncIterator[str]:
+    logger.debug("Async resource initiated")
+    try:
+        yield "async resource"
+    finally:
+        logger.debug("Async resource destructed")
+
+
+@dataclasses.dataclass(kw_only=True, slots=True)
+class DependentFactory:
+    sync_resource: str
+    async_resource: str
+```
+
+## Describe dependencies graph (IoC-container)
+```python
+from modern_di import BaseGraph, Scope, providers
+
+
+class Dependencies(BaseGraph):
+    sync_resource = providers.Resource(Scope.APP, create_sync_resource)
+    async_resource = providers.Resource(Scope.APP, create_async_resource)
+
+    simple_factory = providers.Factory(Scope.REQUEST, SimpleFactory, dep1="text", dep2=123)
+    dependent_factory = providers.Factory(
+        Scope.REQUEST,
+        sync_resource=sync_resource,
+        async_resource=async_resource,
+    )
+```
+
+## Create container and resolve dependencies in your code
+```python
+from modern_di import Container, Scope
+
+
+# init container of app scope in sync mode
+with Container(scope=Scope.APP) as app_container:
+    # resolve sync resource
+    Dependencies.sync_resource.sync_resolve(app_container)
+
+
+# init container of app scope in async mode
+async with Container(scope=Scope.APP) as app_container:
+    # resolve async resource
+    await Dependencies.async_resource.async_resolve(app_container)
+
+    # resolve sync resource
+    instance1 = await Dependencies.sync_resource.async_resolve(app_container)
+    instance2 = Dependencies.sync_resource.sync_resolve(app_container)
+    assert instance1 is instance2
+
+    # create container of request scope
+    async with app_container.build_child_container(scope=Scope.REQUEST) as request_container:
+        # resolve factories of request scope
+        Dependencies.simple_factory.sync_resolve(request_container)
+        await Dependencies.dependent_factory.async_resolve(request_container)
+        
+        # resources of app-scope also can be resolved here
+
+```

{modern_di-0.5.1 → modern_di-0.6.0}/modern_di/providers/factory.py

@@ -3,6 +3,7 @@ import typing
 
 from modern_di import Container
 from modern_di.providers.abstract import AbstractCreatorProvider
+from modern_di.providers.injected_factory import InjectedFactory
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
@@ -21,6 +22,10 @@ class Factory(AbstractCreatorProvider[T_co]):
     ) -> None:
         super().__init__(scope, creator, *args, **kwargs)
 
+    @property
+    def factory_provider(self) -> InjectedFactory[T_co]:
+        return InjectedFactory(self)
+
     async def async_resolve(self, container: Container) -> T_co:
         container = container.find_container(self.scope)
         if (override := container.fetch_override(self.provider_id)) is not None:

modern_di-0.6.0/modern_di/providers/injected_factory.py

@@ -0,0 +1,24 @@
+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(typing.Generic[T_co]):
+    __slots__ = ("_factory_provider",)
+
+    def __init__(self, factory_provider: AbstractProvider[T_co]) -> None:
+        self._factory_provider = factory_provider
+
+    async def async_resolve(self, container: Container) -> typing.Callable[[], T_co]:
+        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]:
+        self._factory_provider.sync_resolve(container)
+        return functools.partial(self._factory_provider.sync_resolve, container)

{modern_di-0.5.1 → modern_di-0.6.0}/modern_di/providers/resource.py

@@ -23,7 +23,13 @@ class Resource(AbstractCreatorProvider[T_co]):
     def __init__(
         self,
         scope: enum.IntEnum,
-        creator: typing.Callable[P, typing.Iterator[T_co] | typing.AsyncIterator[T_co]],
+        creator: typing.Callable[
+            P,
+            typing.Iterator[T_co]
+            | typing.AsyncIterator[T_co]
+            | typing.ContextManager[T_co]
+            | typing.AsyncContextManager[T_co],
+        ],
         *args: P.args,
         **kwargs: P.kwargs,
     ) -> None:
@@ -34,9 +40,15 @@ class Resource(AbstractCreatorProvider[T_co]):
         elif inspect.isgeneratorfunction(creator):
             self._is_async = False
             new_creator = contextlib.contextmanager(creator)
+        elif isinstance(creator, type) and issubclass(creator, typing.AsyncContextManager):
+            self._is_async = True
+            new_creator = creator
+        elif isinstance(creator, type) and issubclass(creator, typing.ContextManager):
+            self._is_async = False
+            new_creator = creator
         else:
             msg = "Unsupported resource type"
-            raise RuntimeError(msg)
+            raise TypeError(msg)
 
         super().__init__(scope, new_creator, *args, **kwargs)
 

{modern_di-0.5.1 → modern_di-0.6.0}/pyproject.toml

@@ -19,6 +19,16 @@ dynamic = ["version", "readme"]
 repository = "https://github.com/modern-python/modern-di"
 docs = "https://modern-di.readthedocs.io"
 
+[dependency-groups]
+dev = [
+    "pytest",
+    "pytest-cov",
+    "pytest-asyncio",
+    "ruff",
+    "mypy",
+    "typing-extensions",
+]
+
 [build-system]
 requires = ["hatchling", "hatch-vcs", "hatch-fancy-pypi-readme"]
 build-backend = "hatchling.build"
@@ -40,6 +50,7 @@ path = "../../README.md"
 [tool.pytest.ini_options]
 addopts = "--cov=. --cov-report term-missing"
 asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
 
 [tool.coverage.report]
 exclude_also = ["if typing.TYPE_CHECKING:"]

modern_di-0.5.1/PKG-INFO

@@ -1,38 +0,0 @@
-Metadata-Version: 2.3
-Name: modern-di
-Version: 0.5.1
-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-Expression: MIT
-Keywords: DI,dependency injector,ioc-container,mocks,python
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Typing :: Typed
-Requires-Python: <4,>=3.10
-Description-Content-Type: text/markdown
-
-"Modern-DI"
-==
-
-| Project           | Badges                                                                                                                                                                                                                                                                                          |
-|-------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| common            | [![MyPy Strict](https://img.shields.io/badge/mypy-strict-blue)](https://mypy.readthedocs.io/en/stable/getting_started.html#strict-mode-and-configuration) [![GitHub stars](https://img.shields.io/github/stars/modern-python/modern-di)](https://github.com/modern-python/modern-di/stargazers) |
-| modern-di         | [![Supported versions](https://img.shields.io/pypi/pyversions/modern-di.svg)](https://pypi.python.org/pypi/modern-di ) [![downloads](https://img.shields.io/pypi/dm/modern-di.svg)](https://pypistats.org/packages/modern-di)                                                                   |
-| modern-di-fastapi | [![Supported versions](https://img.shields.io/pypi/pyversions/modern-di-fastapi.svg)](https://pypi.python.org/pypi/modern-di-fastapi) [![downloads](https://img.shields.io/pypi/dm/modern-di-fastapi.svg)](https://pypistats.org/packages/modern-di-fastapi)                                    |
-
-Dependency injection framework for Python inspired by `dependency-injector` and `dishka`.
-
-It is in early development state and gives you the following:
-- DI framework with IOC-container and scopes.
-- Async and sync resolving.
-- Python 3.10-3.13 support.
-- Full coverage by types annotations (mypy in strict mode).
-- Overriding dependencies for tests.
-- Package with zero dependencies.
-
-📚 [Documentation](https://modern-di.readthedocs.io)