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

modern_di-0.13.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: modern-di
+Version: 0.13.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-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)                                    |
+| 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)                                |
+
+`modern-di` is a python dependency injection framework which, among other things,
+supports the following:
+
+- Async and sync dependency resolution
+- Scopes and granular context management
+- Python 3.10+ support
+- Fully typed and tested
+- Compatibility with popular frameworks like `FastAPI` and `LiteStar`
+- Thread-safe and asyncio concurrency safe providers
+
+## 📚 [Documentation](https://modern-di.readthedocs.io)
+
+## 📦 [PyPi](https://pypi.org/project/modern-di)
+
+## 📝 [License](LICENSE)

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

@@ -123,16 +123,19 @@ class Container(contextlib.AbstractAsyncContextManager["Container"], contextlib.
         self._is_async = True
         return self
 
+    async def async_close(self) -> None:
+        self._check_entered()
+        for provider_state in reversed(self._provider_states.values()):
+            await provider_state.async_tear_down()
+        self._exit()
+
     async def __aexit__(
         self,
         exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         traceback: types.TracebackType | None,
     ) -> None:
-        self._check_entered()
-        for provider_state in reversed(self._provider_states.values()):
-            await provider_state.async_tear_down()
-        self._exit()
+        await self.async_close()
 
     def __enter__(self) -> "Container":
         self._is_async = False

modern_di-0.13.0/modern_di/helpers/attr_getter_helpers.py

@@ -0,0 +1,7 @@
+import typing
+from operator import attrgetter
+
+
+def get_value_from_object_by_dotted_path(obj: typing.Any, path: str) -> typing.Any:  # noqa: ANN401
+    attribute_getter = attrgetter(path)
+    return attribute_getter(obj)

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

@@ -4,7 +4,10 @@ import itertools
 import typing
 import uuid
 
+from typing_extensions import override
+
 from modern_di import Container
+from modern_di.helpers.attr_getter_helpers import get_value_from_object_by_dotted_path
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
@@ -36,6 +39,22 @@ class AbstractProvider(typing.Generic[T_co], abc.ABC):
             msg = "Scope of dependency cannot be more than scope of dependent"
             raise RuntimeError(msg)
 
+    def __getattr__(self, attr_name: str) -> typing.Any:  # noqa: ANN401
+        """Get an attribute from the resolve object.
+
+        Args:
+            attr_name: name of attribute to get.
+
+        Returns:
+            An `AttrGetter` provider that will get the attribute after resolving the current provider.
+
+        """
+        if attr_name.startswith("_"):
+            msg = f"'{type(self)}' object has no attribute '{attr_name}'"
+            raise AttributeError(msg)
+
+        return AttrGetter(provider=self, attr_name=attr_name)
+
 
 class AbstractOverrideProvider(AbstractProvider[T_co], abc.ABC):
     def override(self, override_object: object, container: Container) -> None:
@@ -69,8 +88,8 @@ class AbstractCreatorProvider(AbstractOverrideProvider[T_co], abc.ABC):
 
     def _sync_build_creator(self, container: Container) -> typing.Any:  # noqa: ANN401
         return self._creator(
-            *typing.cast(P.args, self._sync_resolve_args(container)),
-            **typing.cast(P.kwargs, self._sync_resolve_kwargs(container)),
+            *self._sync_resolve_args(container),
+            **self._sync_resolve_kwargs(container),
         )
 
     async def _async_resolve_args(self, container: Container) -> list[typing.Any]:
@@ -84,6 +103,43 @@ class AbstractCreatorProvider(AbstractOverrideProvider[T_co], abc.ABC):
 
     async def _async_build_creator(self, container: Container) -> typing.Any:  # noqa: ANN401
         return self._creator(
-            *typing.cast(P.args, await self._async_resolve_args(container)),
-            **typing.cast(P.kwargs, await self._async_resolve_kwargs(container)),
+            *await self._async_resolve_args(container),
+            **await self._async_resolve_kwargs(container),
         )
+
+
+class AttrGetter(AbstractProvider[T_co]):
+    """Provides an attribute after resolving the wrapped provider."""
+
+    __slots__ = [*AbstractProvider.BASE_SLOTS, "_attrs", "_provider"]
+
+    def __init__(self, provider: AbstractProvider[T_co], attr_name: str) -> None:
+        """Create a new AttrGetter instance.
+
+        Args:
+            provider: provider to wrap.
+            attr_name: attribute name to resolve when the provider is resolved.
+
+        """
+        super().__init__(scope=provider.scope)
+        self._provider = provider
+        self._attrs = [attr_name]
+
+    def __getattr__(self, attr: str) -> "AttrGetter[T_co]":
+        if attr.startswith("_"):
+            msg = f"'{type(self)}' object has no attribute '{attr}'"
+            raise AttributeError(msg)
+        self._attrs.append(attr)
+        return self
+
+    @override
+    async def async_resolve(self, container: Container) -> typing.Any:
+        resolved_provider_object = await self._provider.async_resolve(container)
+        attribute_path = ".".join(self._attrs)
+        return get_value_from_object_by_dotted_path(resolved_provider_object, attribute_path)
+
+    @override
+    def sync_resolve(self, container: Container) -> typing.Any:
+        resolved_provider_object = self._provider.sync_resolve(container)
+        attribute_path = ".".join(self._attrs)
+        return get_value_from_object_by_dotted_path(resolved_provider_object, attribute_path)

modern_di-0.11.0/PKG-INFO

@@ -1,141 +0,0 @@
-Metadata-Version: 2.4
-Name: modern-di
-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-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)                                    |
-| 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 development state yet 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.
-- Integration with FastAPI and LiteStar
-- Thread-safe and asyncio concurrency safe providers
-
-📚 [Documentation](https://modern-di.readthedocs.io)
-
-# 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
-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
-```
-
-## 3. Describe dependencies graph
-```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,
-    )
-```
-
-## 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
-
-
-# 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
-
-```