Merge pull request #45 from modern-python/41-feature-attrgetter-provider

add attr getter provider

Author: lesnik512

docs/index.md

@@ -11,6 +11,7 @@
     usage/key-concepts
     usage/inject-factories
     usage/context-data
+    usage/application-settings
     usage/migration-from-that-depends
 
 .. toctree::

docs/usage/application-settings.md

@@ -0,0 +1,24 @@
+# Application settings
+For example, you have application settings in `pydantic_settings`
+```python
+import pydantic_settings
+
+
+class Settings(pydantic_settings.BaseSettings):
+    service_name: str = "FastAPI template"
+    debug: bool = False
+    ...
+```
+
+You can register settings as `Singleton` in DI container
+
+```python
+from modern_di import BaseGraph, Scope, providers
+
+
+class DIContainer(BaseGraph):
+    settings = providers.Singleton(Scope.APP, Settings)
+    some_factory = providers.Factory(Scope.APP, SomeFactory, service_name=settings.cast.service_name)
+```
+
+And when `some_factory` is resolved it will receive `service_name` attribute from `Settings`

packages/modern-di/modern_di/helpers/__init__.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)

packages/modern-di/modern_di/helpers/attr_getter_helpers.py

@@ -4,7 +4,10 @@
 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 @@ def _check_providers_scope(self, providers: typing.Iterable[typing.Any]) -> None
             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:
@@ -87,3 +106,40 @@ async def _async_build_creator(self, container: Container) -> typing.Any:  # noq
             *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)

packages/modern-di/modern_di/providers/abstract.py

@@ -0,0 +1,113 @@
+import typing
+from dataclasses import dataclass, field
+
+import pytest
+from modern_di import Container, Scope, providers
+
+
+@dataclass
+class Nested2:
+    some_const = 144
+
+
+@dataclass
+class Nested1:
+    nested2_attr: Nested2 = field(default_factory=Nested2)
+
+
+@dataclass
+class Settings:
+    some_str_value: str = "some_string_value"
+    some_int_value: int = 3453621
+    nested1_attr: Nested1 = field(default_factory=Nested1)
+
+
+async def yield_settings_async() -> typing.AsyncIterator[Settings]:
+    yield Settings()
+
+
+def yield_settings_sync() -> typing.Iterator[Settings]:
+    yield Settings()
+
+
+@dataclass
+class NestingTestDTO: ...
+
+
+@pytest.fixture(
+    params=[
+        providers.Resource(Scope.APP, yield_settings_sync),
+        providers.Singleton(Scope.APP, Settings),
+        providers.Object(Scope.APP, Settings()),
+        providers.Factory(Scope.APP, Settings),
+        providers.Selector(Scope.APP, lambda: "sync", sync=providers.Factory(Scope.APP, Settings)),
+    ]
+)
+def some_sync_settings_provider(request: pytest.FixtureRequest) -> providers.AbstractProvider[Settings]:
+    return typing.cast(providers.AbstractProvider[Settings], request.param)
+
+
+@pytest.fixture(
+    params=[
+        providers.Resource(Scope.APP, yield_settings_async),
+    ]
+)
+def some_async_settings_provider(request: pytest.FixtureRequest) -> providers.AbstractProvider[Settings]:
+    return typing.cast(providers.AbstractProvider[Settings], request.param)
+
+
+@pytest.fixture
+async def di_container() -> typing.AsyncIterator[Container]:
+    di_container_: typing.Final = Container(scope=Scope.APP)
+    async with di_container_:
+        yield di_container_
+
+
+def test_attr_getter_with_zero_attribute_depth_sync(
+    some_sync_settings_provider: providers.AbstractProvider[Settings], di_container: Container
+) -> None:
+    attr_getter = some_sync_settings_provider.some_str_value
+    assert attr_getter.sync_resolve(di_container) == Settings().some_str_value
+
+
+async def test_attr_getter_with_zero_attribute_depth_async(
+    some_async_settings_provider: providers.AbstractProvider[Settings], di_container: Container
+) -> None:
+    attr_getter = some_async_settings_provider.some_str_value
+    assert await attr_getter.async_resolve(di_container) == Settings().some_str_value
+
+
+def test_attr_getter_with_more_than_zero_attribute_depth_sync(
+    some_sync_settings_provider: providers.AbstractProvider[Settings], di_container: Container
+) -> None:
+    attr_getter = some_sync_settings_provider.nested1_attr.nested2_attr.some_const
+    assert attr_getter.sync_resolve(di_container) == Nested2().some_const
+
+
+async def test_attr_getter_with_more_than_zero_attribute_depth_async(
+    some_async_settings_provider: providers.AbstractProvider[Settings], di_container: Container
+) -> None:
+    attr_getter = some_async_settings_provider.nested1_attr.nested2_attr.some_const
+    assert await attr_getter.async_resolve(di_container) == Nested2().some_const
+
+
+def test_attr_getter_with_invalid_attribute_sync(
+    some_sync_settings_provider: providers.AbstractProvider[Settings],
+) -> None:
+    with pytest.raises(AttributeError):
+        some_sync_settings_provider.nested1_attr.nested2_attr.__some_private__  # noqa: B018
+    with pytest.raises(AttributeError):
+        some_sync_settings_provider.nested1_attr.__another_private__  # noqa: B018
+    with pytest.raises(AttributeError):
+        some_sync_settings_provider.nested1_attr._final_private_  # noqa: B018
+
+
+async def test_attr_getter_with_invalid_attribute_async(
+    some_async_settings_provider: providers.AbstractProvider[Settings],
+) -> None:
+    with pytest.raises(AttributeError):
+        some_async_settings_provider.nested1_attr.nested2_attr.__some_private__  # noqa: B018
+    with pytest.raises(AttributeError):
+        some_async_settings_provider.nested1_attr.__another_private__  # noqa: B018
+    with pytest.raises(AttributeError):
+        some_async_settings_provider.nested1_attr._final_private_  # noqa: B018