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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modern-di
-Version: 0.11.0
+Version: 0.12.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
@@ -39,103 +39,3 @@ It is in development state yet and gives you the following:
 - 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
-
-```

modern_di-0.12.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.12.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)