modern-di 0.3.0__tar.gz → 0.4.0__tar.gz

modern_di-0.4.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.3
+Name: modern-di
+Version: 0.4.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
+License-File: LICENSE
+Keywords: dependency injector,di,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)

modern_di-0.4.0/README.md

@@ -0,0 +1,20 @@
+"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)

{modern_di-0.3.0 → modern_di-0.4.0}/modern_di/graph.py

@@ -1,7 +1,7 @@
 import typing
 
 from modern_di import Container
-from modern_di.providers import AbstractProvider, BaseCreatorProvider
+from modern_di.providers.abstract import AbstractCreatorProvider, AbstractProvider
 
 
 if typing.TYPE_CHECKING:
@@ -29,11 +29,11 @@ class BaseGraph:
     @classmethod
     async def async_resolve_creators(cls, container: Container) -> None:
         for provider in cls.get_providers().values():
-            if isinstance(provider, BaseCreatorProvider) and provider.scope == container.scope:
+            if isinstance(provider, AbstractCreatorProvider) and provider.scope == container.scope:
                 await provider.async_resolve(container)
 
     @classmethod
     def sync_resolve_creators(cls, container: Container) -> None:
         for provider in cls.get_providers().values():
-            if isinstance(provider, BaseCreatorProvider) and provider.scope == container.scope:
+            if isinstance(provider, AbstractCreatorProvider) and provider.scope == container.scope:
                 provider.sync_resolve(container)

{modern_di-0.3.0 → modern_di-0.4.0}/modern_di/providers/__init__.py

@@ -1,15 +1,16 @@
-from modern_di.providers.base import AbstractProvider, BaseCreatorProvider
-from modern_di.providers.context_adapter import ContextAdapter
+from modern_di.providers.dict import Dict
 from modern_di.providers.factory import Factory
+from modern_di.providers.list import List
 from modern_di.providers.resource import Resource
+from modern_di.providers.selector import Selector
 from modern_di.providers.singleton import Singleton
 
 
 __all__ = [
-    "AbstractProvider",
-    "BaseCreatorProvider",
-    "ContextAdapter",
     "Factory",
+    "Dict",
+    "List",
+    "Selector",
     "Singleton",
     "Resource",
 ]

modern_di-0.3.0/modern_di/providers/base.py → modern_di-0.4.0/modern_di/providers/abstract.py

@@ -27,18 +27,25 @@ class AbstractProvider(typing.Generic[T_co], abc.ABC):
     def sync_resolve(self, container: Container) -> T_co:
         """Resolve dependency synchronously."""
 
+    @property
+    def cast(self) -> T_co:
+        return typing.cast(T_co, self)
+
+    def _check_providers_scope(self, providers: typing.Iterable[typing.Any]) -> None:
+        if any(x.scope > self.scope for x in providers if isinstance(x, AbstractProvider)):
+            msg = "Scope of dependency cannot be more than scope of dependent"
+            raise RuntimeError(msg)
+
+
+class AbstractOverrideProvider(AbstractProvider[T_co], abc.ABC):
     def override(self, override_object: object, container: Container) -> None:
         container.override(self.provider_id, override_object)
 
     def reset_override(self, container: Container) -> None:
         container.reset_override(self.provider_id)
 
-    @property
-    def cast(self) -> T_co:
-        return typing.cast(T_co, self)
-
 
-class BaseCreatorProvider(AbstractProvider[T_co], abc.ABC):
+class AbstractCreatorProvider(AbstractOverrideProvider[T_co], abc.ABC):
     BASE_SLOTS: typing.ClassVar = [*AbstractProvider.BASE_SLOTS, "_args", "_kwargs", "_creator"]
 
     def __init__(
@@ -49,11 +56,7 @@ class BaseCreatorProvider(AbstractProvider[T_co], abc.ABC):
         **kwargs: P.kwargs,
     ) -> None:
         super().__init__(scope)
-
-        if any(x.scope > self.scope for x in itertools.chain(args, kwargs.values()) if isinstance(x, AbstractProvider)):
-            msg = "Scope of dependency cannot be more than scope of dependent"
-            raise RuntimeError(msg)
-
+        self._check_providers_scope(itertools.chain(args, kwargs.values()))
         self._creator: typing.Final = creator
         self._args: typing.Final = args
         self._kwargs: typing.Final = kwargs

modern_di-0.4.0/modern_di/providers/dict.py

@@ -0,0 +1,23 @@
+import enum
+import typing
+
+from modern_di import Container
+from modern_di.providers.abstract import AbstractProvider
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+class Dict(AbstractProvider[dict[str, T_co]]):
+    __slots__ = [*AbstractProvider.BASE_SLOTS, "_providers"]
+
+    def __init__(self, scope: enum.IntEnum, **providers: AbstractProvider[T_co]) -> None:
+        super().__init__(scope)
+        self._check_providers_scope(providers.values())
+        self._providers: typing.Final = providers
+
+    async def async_resolve(self, container: Container) -> dict[str, T_co]:
+        return {key: await provider.async_resolve(container) for key, provider in self._providers.items()}
+
+    def sync_resolve(self, container: Container) -> dict[str, T_co]:
+        return {key: provider.sync_resolve(container) for key, provider in self._providers.items()}

{modern_di-0.3.0 → modern_di-0.4.0}/modern_di/providers/factory.py

@@ -2,15 +2,15 @@ import enum
 import typing
 
 from modern_di import Container
-from modern_di.providers import BaseCreatorProvider
+from modern_di.providers.abstract import AbstractCreatorProvider
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
 P = typing.ParamSpec("P")
 
 
-class Factory(BaseCreatorProvider[T_co]):
-    __slots__ = [*BaseCreatorProvider.BASE_SLOTS, "_creator"]
+class Factory(AbstractCreatorProvider[T_co]):
+    __slots__ = [*AbstractCreatorProvider.BASE_SLOTS, "_creator"]
 
     def __init__(
         self,

modern_di-0.4.0/modern_di/providers/list.py

@@ -0,0 +1,23 @@
+import enum
+import typing
+
+from modern_di import Container
+from modern_di.providers.abstract import AbstractProvider
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+class List(AbstractProvider[list[T_co]]):
+    __slots__ = [*AbstractProvider.BASE_SLOTS, "_providers"]
+
+    def __init__(self, scope: enum.IntEnum, *providers: AbstractProvider[T_co]) -> None:
+        super().__init__(scope)
+        self._check_providers_scope(providers)
+        self._providers: typing.Final = providers
+
+    async def async_resolve(self, container: Container) -> list[T_co]:
+        return [await x.async_resolve(container) for x in self._providers]
+
+    def sync_resolve(self, container: Container) -> list[T_co]:
+        return [x.sync_resolve(container) for x in self._providers]

{modern_di-0.3.0 → modern_di-0.4.0}/modern_di/providers/resource.py

@@ -4,15 +4,15 @@ import inspect
 import typing
 
 from modern_di import Container
-from modern_di.providers import BaseCreatorProvider
+from modern_di.providers.abstract import AbstractCreatorProvider
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
 P = typing.ParamSpec("P")
 
 
-class Resource(BaseCreatorProvider[T_co]):
-    __slots__ = [*BaseCreatorProvider.BASE_SLOTS, "_creator", "_args", "_kwargs", "_is_async"]
+class Resource(AbstractCreatorProvider[T_co]):
+    __slots__ = [*AbstractCreatorProvider.BASE_SLOTS, "_creator", "_args", "_kwargs", "_is_async"]
 
     def _is_creator_async(
         self,

modern_di-0.4.0/modern_di/providers/selector.py

@@ -0,0 +1,39 @@
+import enum
+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 Selector(AbstractProvider[T_co]):
+    __slots__ = [*AbstractProvider.BASE_SLOTS, "_function", "_providers"]
+
+    def __init__(
+        self, scope: enum.IntEnum, function: typing.Callable[..., str], **providers: AbstractProvider[T_co]
+    ) -> None:
+        super().__init__(scope)
+        self._check_providers_scope(providers.values())
+        self._function: typing.Final = function
+        self._providers: typing.Final = providers
+
+    async def async_resolve(self, container: Container) -> T_co:
+        container = container.find_container(self.scope)
+        selected_key = self._function(**container.context)
+        if selected_key not in self._providers:
+            msg = f"No provider matches {selected_key}"
+            raise RuntimeError(msg)
+
+        return await self._providers[selected_key].async_resolve(container)
+
+    def sync_resolve(self, container: Container) -> T_co:
+        container = container.find_container(self.scope)
+        selected_key = self._function(**container.context)
+        if selected_key not in self._providers:
+            msg = f"No provider matches {selected_key}"
+            raise RuntimeError(msg)
+
+        return self._providers[selected_key].sync_resolve(container)

{modern_di-0.3.0 → modern_di-0.4.0}/modern_di/providers/singleton.py

@@ -2,15 +2,15 @@ import enum
 import typing
 
 from modern_di import Container
-from modern_di.providers import BaseCreatorProvider
+from modern_di.providers.abstract import AbstractCreatorProvider
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
 P = typing.ParamSpec("P")
 
 
-class Singleton(BaseCreatorProvider[T_co]):
-    __slots__ = [*BaseCreatorProvider.BASE_SLOTS, "_creator"]
+class Singleton(AbstractCreatorProvider[T_co]):
+    __slots__ = [*AbstractCreatorProvider.BASE_SLOTS, "_creator"]
 
     def __init__(
         self,

modern_di-0.4.0/tests/providers/test_dict.py

@@ -0,0 +1,24 @@
+import pytest
+
+from modern_di import Container, Scope, providers
+from tests.creators import create_async_resource, create_sync_resource
+
+
+async_resource = providers.Resource(Scope.APP, create_async_resource)
+sync_resource = providers.Resource(Scope.APP, create_sync_resource)
+mapping = providers.Dict(Scope.APP, dep1=async_resource, dep2=sync_resource)
+
+
+async def test_dict() -> None:
+    async with Container(scope=Scope.APP, context={"option": "app"}) as app_container:
+        mapping1 = await mapping.async_resolve(app_container)
+        mapping2 = mapping.sync_resolve(app_container)
+        resource1 = await async_resource.async_resolve(app_container)
+        resource2 = sync_resource.sync_resolve(app_container)
+        assert mapping1 == mapping2 == {"dep1": resource1, "dep2": resource2}
+
+
+async def test_dict_wrong_scope() -> None:
+    request_factory_ = providers.Factory(Scope.REQUEST, lambda: "")
+    with pytest.raises(RuntimeError, match="Scope of dependency cannot be more than scope of dependent"):
+        providers.Dict(Scope.APP, dep1=request_factory_)

modern_di-0.4.0/tests/providers/test_list.py

@@ -0,0 +1,24 @@
+import pytest
+
+from modern_di import Container, Scope, providers
+from tests.creators import create_async_resource, create_sync_resource
+
+
+async_resource = providers.Resource(Scope.APP, create_async_resource)
+sync_resource = providers.Resource(Scope.APP, create_sync_resource)
+sequence = providers.List(Scope.APP, async_resource, sync_resource)
+
+
+async def test_list() -> None:
+    async with Container(scope=Scope.APP, context={"option": "app"}) as app_container:
+        sequence1 = await sequence.async_resolve(app_container)
+        sequence2 = sequence.sync_resolve(app_container)
+        resource1 = await async_resource.async_resolve(app_container)
+        resource2 = sync_resource.sync_resolve(app_container)
+        assert sequence1 == sequence2 == [resource1, resource2]
+
+
+async def test_list_wrong_scope() -> None:
+    request_factory_ = providers.Factory(Scope.REQUEST, lambda: "")
+    with pytest.raises(RuntimeError, match="Scope of dependency cannot be more than scope of dependent"):
+        providers.List(Scope.APP, request_factory_)

modern_di-0.4.0/tests/providers/test_selector.py

@@ -0,0 +1,45 @@
+import pytest
+
+from modern_di import Container, Scope, providers
+
+
+def selector_function(*, option: str, **_: object) -> "str":
+    return option
+
+
+app_factory = providers.Factory(Scope.APP, lambda: "app")
+request_factory = providers.Factory(Scope.APP, lambda: "request")
+app_selector = providers.Selector(Scope.APP, selector_function, app=app_factory, request=request_factory)
+request_selector = providers.Selector(Scope.REQUEST, selector_function, app=app_factory, request=request_factory)
+
+
+async def test_selector() -> None:
+    async with Container(scope=Scope.APP, context={"option": "app"}) as app_container:
+        instance1 = await app_selector.async_resolve(app_container)
+        instance2 = app_selector.sync_resolve(app_container)
+        assert instance1 == instance2 == "app"
+
+
+async def test_selector_in_request_scope() -> None:
+    async with (
+        Container(scope=Scope.APP) as app_container,
+        app_container.build_child_container(context={"option": "request"}) as request_container,
+    ):
+        instance1 = await request_selector.async_resolve(request_container)
+        instance2 = request_selector.sync_resolve(request_container)
+        assert instance1 == instance2 == "request"
+
+
+async def test_selector_no_match() -> None:
+    async with Container(scope=Scope.APP, context={"option": "wrong"}) as app_container:
+        with pytest.raises(RuntimeError, match="No provider matches wrong"):
+            await app_selector.async_resolve(app_container)
+
+        with pytest.raises(RuntimeError, match="No provider matches wrong"):
+            app_selector.sync_resolve(app_container)
+
+
+async def test_selector_wrong_scope() -> None:
+    request_factory_ = providers.Factory(Scope.REQUEST, lambda: "")
+    with pytest.raises(RuntimeError, match="Scope of dependency cannot be more than scope of dependent"):
+        providers.Selector(Scope.APP, lambda: "", request=request_factory_)

modern_di-0.3.0/PKG-INFO

@@ -1,37 +0,0 @@
-Metadata-Version: 2.3
-Name: modern-di
-Version: 0.3.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
-License-File: LICENSE
-Keywords: dependency injector,di,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"
-==
-[![MyPy Strict](https://img.shields.io/badge/mypy-strict-blue)](https://mypy.readthedocs.io/en/stable/getting_started.html#strict-mode-and-configuration)
-[![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)
-[![GitHub stars](https://img.shields.io/github/stars/modern-python/modern-di)](https://github.com/modern-python/modern-di/stargazers)
-
-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)

modern_di-0.3.0/README.md

@@ -1,18 +0,0 @@
-"Modern-DI"
-==
-[![MyPy Strict](https://img.shields.io/badge/mypy-strict-blue)](https://mypy.readthedocs.io/en/stable/getting_started.html#strict-mode-and-configuration)
-[![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)
-[![GitHub stars](https://img.shields.io/github/stars/modern-python/modern-di)](https://github.com/modern-python/modern-di/stargazers)
-
-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)

modern_di-0.3.0/modern_di/providers/context_adapter.py

@@ -1,31 +0,0 @@
-import enum
-import typing
-
-from modern_di import Container
-from modern_di.providers import AbstractProvider
-
-
-T_co = typing.TypeVar("T_co", covariant=True)
-P = typing.ParamSpec("P")
-
-
-class ContextAdapter(AbstractProvider[T_co]):
-    __slots__ = [*AbstractProvider.BASE_SLOTS, "_function"]
-
-    def __init__(
-        self,
-        scope: enum.IntEnum,
-        function: typing.Callable[..., T_co],
-    ) -> None:
-        super().__init__(scope)
-        self._function = function
-
-    async def async_resolve(self, container: Container) -> T_co:
-        return self.sync_resolve(container)
-
-    def sync_resolve(self, container: Container) -> T_co:
-        container = container.find_container(self.scope)
-        if (override := container.fetch_override(self.provider_id)) is not None:
-            return typing.cast(T_co, override)
-
-        return self._function(**container.context)

modern_di-0.3.0/tests/resolvers/test_context_adapter.py

@@ -1,40 +0,0 @@
-import datetime
-
-from modern_di import Container, Scope, providers
-
-
-def context_adapter_function(*, now: datetime.datetime, **_: object) -> datetime.datetime:
-    return now
-
-
-context_adapter = providers.ContextAdapter(Scope.APP, context_adapter_function)
-request_context_adapter = providers.ContextAdapter(Scope.REQUEST, context_adapter_function)
-
-
-async def test_context_adapter() -> None:
-    now = datetime.datetime.now(tz=datetime.timezone.utc)
-    async with Container(scope=Scope.APP, context={"now": now}) as app_container:
-        instance1 = await context_adapter.async_resolve(app_container)
-        instance2 = context_adapter.sync_resolve(app_container)
-        assert instance1 is instance2 is now
-
-
-async def test_context_adapter_in_request_scope() -> None:
-    now = datetime.datetime.now(tz=datetime.timezone.utc)
-    async with (
-        Container(scope=Scope.APP) as app_container,
-        app_container.build_child_container(context={"now": now}) as request_container,
-    ):
-        instance1 = await request_context_adapter.async_resolve(request_container)
-        instance2 = request_context_adapter.sync_resolve(request_container)
-        assert instance1 is instance2 is now
-
-
-async def test_context_adapter_override() -> None:
-    now = datetime.datetime.now(tz=datetime.timezone.utc)
-    async with Container(scope=Scope.APP, context={"now": now}) as app_container:
-        instance1 = await context_adapter.async_resolve(app_container)
-        context_adapter.override(datetime.datetime.now(tz=datetime.timezone.utc), container=app_container)
-        instance2 = context_adapter.sync_resolve(app_container)
-        assert instance1 is now
-        assert instance2 is not now