Merge pull request #136 from modern-python/refactor

lesnik512 · web-flow · commit f694b003f6f3 · 2026-02-06T10:08:28.000+03:00
refactor container provider, remove object provider
diff --git a/README.md b/README.md
@@ -9,11 +9,10 @@
 | modern-di-faststream | [![Supported versions](https://img.shields.io/pypi/pyversions/modern-di-faststream.svg)](https://pypi.python.org/pypi/modern-di-faststream) [![downloads](https://img.shields.io/pypi/dm/modern-di-faststream.svg)](https://pypistats.org/packages/modern-di-faststream)                        |
 | 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:
+`modern-di` is a python dependency injection framework which supports the following:
 
 - Automatic dependencies graph based on type annotations
-- Scopes and granular context management
+- Scopes and context management
 - Python 3.10+ support
 - Fully typed and tested
 - Integrations with `FastAPI`, `FastStream` and `LiteStar`
diff --git a/docs/dev/decisions.md b/docs/dev/decisions.md
@@ -1,8 +1,8 @@
 # Decisions
-1. Dependency resolving is sync only since 2.x version
-2. Singletons are thread-safe for concurrent resolving (`threading.Lock` is used)
-3. No global state -> all state lives in containers and registries:
-4. Focus on maximum compatibility with mypy:
+1. Dependency resolving is sync only (since 2.x version)
+2. Cached factories are thread-safe for concurrent resolving (`threading.Lock` is used)
+3. No global state -> all state lives in registries of containers:
+4. Focus on maximum type safety:
   - No need for `# type: ignore`
   - No need for `typing.cast`
 5. No adding new features while tasks can be solved by default implementation.
diff --git a/docs/index.md b/docs/index.md
@@ -2,11 +2,10 @@
 
 Welcome to the `modern-di` documentation!
 
-`modern-di` is a Python dependency injection framework which, among other things,
-supports the following:
+`modern-di` is a Python dependency injection framework whichsupports the following:
 
 - Automatic dependencies graph based on type annotations
-- Scopes and granular context management
+- Scopes and context management
 - Python 3.10+ support
 - Fully typed and tested
 - Integrations with `FastAPI`, `FastStream` and `LiteStar`
@@ -73,7 +72,7 @@ from modern_di import Group, Scope, providers
 
 class Dependencies(Group):
     singleton = providers.Factory(
-        scope=Scope.APP,
+        scope=Scope.APP,  # scope is APP by default, can be missing
         creator=create_singleton,
         cache_settings=providers.CacheSettings()
     )
diff --git a/docs/introduction/key-concepts.md b/docs/introduction/key-concepts.md
@@ -74,6 +74,8 @@ Container also provides methods for overriding providers with objects:
 
 When resolving by type, the container looks for a provider that was registered with a matching `bound_type`.
 
+The container itself can also be resolved as a dependency using `container.resolve(Container)`, which returns the same container instance.
+
 ## Group
 
 A Group is a collection of providers. They cannot be instantiated.
diff --git a/docs/introduction/resolving.md b/docs/introduction/resolving.md
@@ -16,6 +16,7 @@ One of the key features of `Modern-DI` since 2.x version is the automatic resolu
 ### How It Works
 
 When a factory is created:
+
 1. Modern-DI parses the creator's signature to identify parameter names and types
 2. For each parameter with a type annotation, it searches for a registered provider that matches by parameter type.
 3. If a matching provider is found, it's automatically injected when the factory is resolved
@@ -27,12 +28,12 @@ Example:
 import dataclasses
 from modern_di import Group, Container, Scope, providers
 
-@dataclasses.dataclass(kw_only=True, slots=True)
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
 class DatabaseConfig:
     host: str
     port: int
 
-@dataclasses.dataclass(kw_only=True, slots=True)
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
 class DatabaseConnection:
     config: DatabaseConfig  # Automatically resolved by type
     timeout: int = 30  # Uses default value
diff --git a/docs/providers/container.md b/docs/providers/container.md
@@ -0,0 +1,31 @@
+# Container Provider
+
+The Container Provider is a special provider that you should not initialize
+It is automatically registered with each container, so you can resolve the container itself directly:
+
+```python
+from modern_di import Container, providers
+
+container = Container()
+
+# Resolve the container itself
+the_container = container.resolve(Container)
+the_same_container = container.resolve_provider(providers.container_provider)
+```
+
+It's synthetic example just to show that it works. More useful example is to inject `Container` to another object:
+
+```python
+from modern_di import Container, Group, providers
+
+def some_creator(di_container: Container) -> str:
+    # do sth with container
+    return "string"
+
+class Dependencies(Group):
+    some_factory = providers.Factory(creator=some_creator)
+
+    # explicit container injection
+    another_factory = providers.Factory(creator=some_creator, kwargs={"di_container": providers.container_provider})
+
+```
diff --git a/docs/providers/context.md b/docs/providers/context.md
diff --git a/docs/testing/fixtures.md b/docs/testing/fixtures.md
@@ -30,6 +30,7 @@ async def di_container() -> typing.AsyncIterator[modern_di.Container]:
 
 @pytest.fixture
 async def request_di_container(di_container: modern_di.Container) -> typing.AsyncIterator[modern_di.Container]:
+    """Fixture with REQUEST-scope container."""
     di_container_ = di_container.build_child_container(scope=modern_di.Scope.REQUEST)
     try:
         yield di_container_
diff --git a/mkdocs.yml b/mkdocs.yml
@@ -9,7 +9,8 @@ nav:
       - Key Concepts: introduction/key-concepts.md
   - Providers:
       - Factories: providers/factories.md
-      - Context Providers: providers/context-providers.md
+      - Context: providers/context.md
+      - Container: providers/container.md
   - Integrations:
       - FastAPI: integrations/fastapi.md
       - FastStream: integrations/faststream.md
diff --git a/packages/modern-di/modern_di/container.py b/packages/modern-di/modern_di/container.py
@@ -6,6 +6,7 @@
 from modern_di import types
 from modern_di.group import Group
 from modern_di.providers.abstract import AbstractProvider
+from modern_di.providers.container_provider import container_provider
 from modern_di.registries.cache_registry import CacheRegistry
 from modern_di.registries.context_registry import ContextRegistry
 from modern_di.registries.overrides_registry import OverridesRegistry
@@ -44,7 +45,8 @@ def __init__(
             self.overrides_registry = parent_container.overrides_registry
         else:
             self.providers_registry = ProvidersRegistry()
-            self.providers_registry.add_providers(_ContainerProvider())
+            container_provider.bound_type = type(self)
+            self.providers_registry.add_providers(container_provider)
             self.overrides_registry = OverridesRegistry()
         if groups:
             for one_group in groups:
@@ -121,13 +123,3 @@ def __deepcopy__(self, *_: object, **__: object) -> "typing_extensions.Self":
     def __copy__(self, *_: object, **__: object) -> "typing_extensions.Self":
         """Prevent cloning object."""
         return self
-
-
-class _ContainerProvider(AbstractProvider[typing.Any]):
-    __slots__ = AbstractProvider.BASE_SLOTS
-
-    def __init__(self) -> None:
-        super().__init__(scope=Scope.APP, bound_type=Container)
-
-    def resolve(self, container: Container) -> Container:
-        return container
diff --git a/packages/modern-di/modern_di/providers/__init__.py b/packages/modern-di/modern_di/providers/__init__.py
@@ -1,13 +1,13 @@
 from modern_di.providers.abstract import AbstractProvider
+from modern_di.providers.container_provider import container_provider
 from modern_di.providers.context_provider import ContextProvider
 from modern_di.providers.factory import CacheSettings, Factory
-from modern_di.providers.object import Object
 
 
 __all__ = [
     "AbstractProvider",
     "CacheSettings",
     "ContextProvider",
     "Factory",
-    "Object",
+    "container_provider",
 ]
diff --git a/packages/modern-di/modern_di/providers/container_provider.py b/packages/modern-di/modern_di/providers/container_provider.py
@@ -0,0 +1,21 @@
+import typing
+
+from modern_di.providers import AbstractProvider
+from modern_di.scope import Scope
+
+
+if typing.TYPE_CHECKING:
+    from modern_di import Container
+
+
+class _ContainerProvider(AbstractProvider[typing.Any]):
+    __slots__ = AbstractProvider.BASE_SLOTS
+
+    def __init__(self) -> None:
+        super().__init__(scope=Scope.APP, bound_type=None)
+
+    def resolve(self, container: "Container") -> "Container":
+        return container
+
+
+container_provider = _ContainerProvider()
diff --git a/packages/modern-di/modern_di/providers/object.py b/packages/modern-di/modern_di/providers/object.py
diff --git a/packages/modern-di/modern_di/registries/cache_registry.py b/packages/modern-di/modern_di/registries/cache_registry.py
@@ -16,8 +16,6 @@ def _clear(self) -> None:
         if self.settings and self.settings.clear_cache:
             self.cache = None
 
-        self.kwargs = None
-
     async def close_async(self) -> None:
         if self.cache and self.settings and self.settings.finalizer:
             if self.settings.is_async_finalizer:
diff --git a/packages/modern-di/modern_di/registries/providers_registry.py b/packages/modern-di/modern_di/registries/providers_registry.py
@@ -1,5 +1,4 @@
 import typing
-import warnings
 
 from modern_di import types
 from modern_di.providers.abstract import AbstractProvider
@@ -21,10 +20,7 @@ def add_providers(self, *args: AbstractProvider[typing.Any]) -> None:
                 continue
 
             if provider_type in self._providers:
-                warnings.warn(
-                    f"Provider is duplicated by type {provider_type}",
-                    RuntimeWarning,
-                    stacklevel=2,
-                )
+                msg = f"Provider is duplicated by type {provider_type}"
+                raise RuntimeError(msg)
 
             self._providers[provider_type] = provider
diff --git a/packages/modern-di/tests_core/providers/test_container_provider.py b/packages/modern-di/tests_core/providers/test_container_provider.py
@@ -0,0 +1,23 @@
+from modern_di import Container, Group, Scope, providers
+
+
+def test_container_provider_direct_resolving() -> None:
+    app_container = Container()
+    assert app_container.resolve(Container) is app_container
+
+    request_container = app_container.build_child_container(scope=Scope.REQUEST)
+    assert request_container.resolve_provider(providers.container_provider) is request_container
+
+
+def test_container_provider_sub_dependency() -> None:
+    def creator(di_container: Container) -> Scope:
+        return di_container.scope
+
+    class MyGroup(Group):
+        factory = providers.Factory(scope=Scope.REQUEST, creator=creator)
+
+    app_container = Container(groups=[MyGroup])
+    request_container = app_container.build_child_container(scope=Scope.REQUEST)
+
+    instance = request_container.resolve(Scope)
+    assert instance == Scope.REQUEST
diff --git a/packages/modern-di/tests_core/providers/test_object.py b/packages/modern-di/tests_core/providers/test_object.py
diff --git a/packages/modern-di/tests_core/registries/test_providers_registry.py b/packages/modern-di/tests_core/registries/test_providers_registry.py
@@ -15,6 +15,6 @@ def test_providers_registry_add_provider_duplicates() -> None:
     providers_registry.add_providers(str_factory)
 
     with (
-        pytest.warns(RuntimeWarning, match="Provider is duplicated by type"),
+        pytest.raises(RuntimeError, match="Provider is duplicated by type"),
     ):
         providers_registry.add_providers(str_factory)
