modern-di 0.16.2__tar.gz → 0.17.0__tar.gz

{modern_di-0.16.2 → modern_di-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modern-di
-Version: 0.16.2
+Version: 0.17.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

modern_di-0.17.0/modern_di/__init__.py

@@ -0,0 +1,13 @@
+from modern_di.containers.async_container import AsyncContainer
+from modern_di.containers.sync_container import SyncContainer
+from modern_di.group import Group
+from modern_di.scope import Scope
+
+
+__all__ = [
+    "AsyncContainer",
+    "Group",
+    "Scope",
+    "SyncContainer",
+    "providers",
+]

modern_di-0.17.0/modern_di/containers/abstract.py

@@ -0,0 +1,110 @@
+import enum
+import typing
+
+from modern_di.group import Group
+from modern_di.providers.abstract import AbstractProvider
+from modern_di.providers.context_provider import ContextProvider
+from modern_di.registries.context_registry import ContextRegistry
+from modern_di.registries.overrides_registry import OverridesRegistry
+from modern_di.registries.providers_registry import ProvidersRegistry
+from modern_di.scope import Scope
+
+
+if typing.TYPE_CHECKING:
+    import typing_extensions
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+class AbstractContainer:
+    BASE_SLOTS: typing.ClassVar[list[str]] = [
+        "_is_entered",
+        "state_registry",
+        "context",
+        "parent_container",
+        "scope",
+        "overrides_registry",
+        "providers_registry",
+    ]
+
+    def __init__(
+        self,
+        *,
+        scope: Scope = Scope.APP,
+        parent_container: typing.Optional["typing_extensions.Self"] = None,
+        context: dict[type[typing.Any], typing.Any] | None = None,
+        groups: list[type[Group]] | None = None,
+    ) -> None:
+        self._is_entered = False
+        self.scope = scope
+        self.parent_container = parent_container
+        self.providers_registry = ProvidersRegistry()
+        if groups:
+            for one_group in groups:
+                self.providers_registry.add_providers(**one_group.get_providers())
+        self.overrides_registry: OverridesRegistry
+        self.context_registry = ContextRegistry(context or {})
+        if parent_container:
+            self.overrides_registry = parent_container.overrides_registry
+        else:
+            self.overrides_registry = OverridesRegistry()
+
+    def _check_entered(self) -> None:
+        if not self._is_entered:
+            msg = f"Enter the context of {self.scope.name} scope"
+            raise RuntimeError(msg)
+
+    def _resolve_context_provider(self, provider: ContextProvider[T_co]) -> T_co:
+        context = self.context_registry.find_context(provider.context_type)
+        if not context:
+            msg = f"Context of type {provider.context_type} is missing"
+            raise RuntimeError(msg)
+
+        return context
+
+    def build_child_container(
+        self, context: dict[type[typing.Any], typing.Any] | None = None, scope: Scope | None = None
+    ) -> "typing_extensions.Self":
+        self._check_entered()
+        if scope and scope <= self.scope:
+            msg = "Scope of child container must be more than current scope"
+            raise RuntimeError(msg)
+
+        if not scope:
+            try:
+                scope = self.scope.__class__(self.scope.value + 1)
+            except ValueError as exc:
+                msg = f"Max scope is reached, {self.scope.name}"
+                raise RuntimeError(msg) from exc
+
+        return self.__class__(scope=scope, parent_container=self, context=context)
+
+    def find_container(self, scope: enum.IntEnum) -> "typing_extensions.Self":
+        container = self
+        if container.scope < scope:
+            msg = f"Scope {scope.name} is not initialized"
+            raise RuntimeError(msg)
+
+        while container.scope > scope and container.parent_container:
+            container = container.parent_container
+
+        if container.scope != scope:
+            msg = f"Scope {scope.name} is skipped"
+            raise RuntimeError(msg)
+
+        return container
+
+    def override(self, provider: AbstractProvider[T_co], override_object: object) -> None:
+        self.overrides_registry.override(provider.provider_id, override_object)
+
+    def reset_override(self, provider: AbstractProvider[T_co] | None = None) -> None:
+        self.overrides_registry.reset_override(provider.provider_id if provider else None)
+
+    def __deepcopy__(self, *_: object, **__: object) -> "typing_extensions.Self":
+        """Hack to prevent cloning object."""
+        return self
+
+    def __copy__(self, *_: object, **__: object) -> "typing_extensions.Self":
+        """Hack to prevent cloning object."""
+        return self

modern_di-0.17.0/modern_di/containers/async_container.py

@@ -0,0 +1,104 @@
+import contextlib
+import types
+import typing
+
+from modern_di.containers.abstract import AbstractContainer
+from modern_di.group import Group
+from modern_di.providers.abstract import AbstractProvider
+from modern_di.providers.container_provider import ContainerProvider
+from modern_di.providers.context_provider import ContextProvider
+from modern_di.registries.state_registry.state_registry import AsyncStateRegistry
+from modern_di.scope import Scope
+
+
+if typing.TYPE_CHECKING:
+    import typing_extensions
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+class AsyncContainer(contextlib.AbstractAsyncContextManager["AsyncContainer"], AbstractContainer):
+    __slots__ = AbstractContainer.BASE_SLOTS
+
+    def __init__(
+        self,
+        *,
+        scope: Scope = Scope.APP,
+        parent_container: typing.Optional["typing_extensions.Self"] = None,
+        context: dict[type[typing.Any], typing.Any] | None = None,
+        groups: list[type[Group]] | None = None,
+        use_lock: bool = True,
+    ) -> None:
+        super().__init__(scope=scope, parent_container=parent_container, context=context, groups=groups)
+        self.state_registry = AsyncStateRegistry(use_lock=use_lock)
+
+    async def _resolve_args(self, args: list[typing.Any]) -> list[typing.Any]:
+        return [await self.resolve_provider(x) if isinstance(x, AbstractProvider) else x for x in args]
+
+    async def _resolve_kwargs(self, kwargs: dict[str, typing.Any]) -> dict[str, typing.Any]:
+        return {k: await self.resolve_provider(v) if isinstance(v, AbstractProvider) else v for k, v in kwargs.items()}
+
+    async def resolve(
+        self, dependency_type: type[T_co] | None = None, *, dependency_name: str | None = None
+    ) -> T_co | None:
+        provider = self.providers_registry.find_provider(
+            dependency_type=dependency_type, dependency_name=dependency_name
+        )
+        if not provider:
+            return None
+
+        return await self.resolve_provider(provider)
+
+    async def resolve_provider(self, provider: AbstractProvider[T_co]) -> T_co:
+        self._check_entered()
+
+        container = self.find_container(provider.scope)
+        if isinstance(provider, ContainerProvider):
+            return typing.cast(T_co, container)
+
+        if isinstance(provider, ContextProvider):
+            return typing.cast(T_co, self._resolve_context_provider(provider))
+
+        if (override := container.overrides_registry.fetch_override(provider.provider_id)) is not None:
+            return typing.cast(T_co, override)
+
+        provider_state = container.state_registry.fetch_provider_state(provider)
+        if provider_state and provider_state.instance is not None:
+            return provider_state.instance
+
+        if provider_state and provider_state.lock:
+            await provider_state.lock.acquire()
+        try:
+            if provider_state and provider_state.instance is not None:
+                return provider_state.instance
+
+            return await provider.async_resolve(
+                args=await self._resolve_args(provider.args or []),
+                kwargs=await self._resolve_kwargs(provider.kwargs or {}),
+                provider_state=provider_state,
+            )
+        finally:
+            if provider_state and provider_state.lock:
+                provider_state.lock.release()
+
+    def enter(self) -> "AsyncContainer":
+        self._is_entered = True
+        return self
+
+    async def close(self) -> None:
+        self._check_entered()
+        self._is_entered = False
+        await self.state_registry.clear_state()
+        self.overrides_registry.reset_override()
+
+    async def __aenter__(self) -> "AsyncContainer":
+        return self.enter()
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        traceback: types.TracebackType | None,
+    ) -> None:
+        await self.close()

modern_di-0.17.0/modern_di/containers/sync_container.py

@@ -0,0 +1,105 @@
+import contextlib
+import types
+import typing
+
+from modern_di.containers.abstract import AbstractContainer
+from modern_di.group import Group
+from modern_di.providers import ContainerProvider
+from modern_di.providers.abstract import AbstractProvider
+from modern_di.providers.context_provider import ContextProvider
+from modern_di.registries.state_registry.state_registry import SyncStateRegistry
+from modern_di.scope import Scope
+
+
+if typing.TYPE_CHECKING:
+    import typing_extensions
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+class SyncContainer(contextlib.AbstractContextManager["SyncContainer"], AbstractContainer):
+    __slots__ = AbstractContainer.BASE_SLOTS
+
+    def __init__(
+        self,
+        *,
+        scope: Scope = Scope.APP,
+        parent_container: typing.Optional["typing_extensions.Self"] = None,
+        context: dict[type[typing.Any], typing.Any] | None = None,
+        groups: list[type[Group]] | None = None,
+        use_lock: bool = True,
+    ) -> None:
+        super().__init__(scope=scope, parent_container=parent_container, context=context, groups=groups)
+        self.state_registry = SyncStateRegistry(use_lock=use_lock)
+
+    def _resolve_args(self, args: list[typing.Any]) -> list[typing.Any]:
+        return [self.resolve_provider(x) if isinstance(x, AbstractProvider) else x for x in args]
+
+    def _resolve_kwargs(self, kwargs: dict[str, typing.Any]) -> dict[str, typing.Any]:
+        return {k: self.resolve_provider(v) if isinstance(v, AbstractProvider) else v for k, v in kwargs.items()}
+
+    def resolve(self, dependency_type: type[T_co] | None = None, *, dependency_name: str | None = None) -> T_co | None:
+        provider = self.providers_registry.find_provider(
+            dependency_type=dependency_type, dependency_name=dependency_name
+        )
+        if not provider:
+            return None
+
+        return self.resolve_provider(provider)
+
+    def resolve_provider(self, provider: AbstractProvider[T_co]) -> T_co:
+        self._check_entered()
+        if provider.is_async:
+            msg = f"{type(provider).__name__} cannot be resolved synchronously"
+            raise RuntimeError(msg)
+
+        container = self.find_container(provider.scope)
+        if isinstance(provider, ContainerProvider):
+            return typing.cast(T_co, container)
+
+        if isinstance(provider, ContextProvider):
+            return typing.cast(T_co, self._resolve_context_provider(provider))
+
+        if (override := container.overrides_registry.fetch_override(provider.provider_id)) is not None:
+            return typing.cast(T_co, override)
+
+        provider_state = container.state_registry.fetch_provider_state(provider)
+        if provider_state and provider_state.instance is not None:
+            return provider_state.instance
+
+        if provider_state and provider_state.lock:
+            provider_state.lock.acquire()
+        try:
+            if provider_state and provider_state.instance is not None:
+                return provider_state.instance
+
+            return provider.sync_resolve(
+                args=self._resolve_args(provider.args or []),
+                kwargs=self._resolve_kwargs(provider.kwargs or {}),
+                provider_state=provider_state,
+            )
+        finally:
+            if provider_state and provider_state.lock:
+                provider_state.lock.release()
+
+    def enter(self) -> "SyncContainer":
+        self._is_entered = True
+        return self
+
+    def close(self) -> None:
+        self._check_entered()
+        self._is_entered = False
+        self.state_registry.clear_state()
+        self.overrides_registry.reset_override()
+
+    def __enter__(self) -> "SyncContainer":
+        return self.enter()
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: types.TracebackType | None,
+    ) -> None:
+        self.close()

modern_di-0.17.0/modern_di/group.py

@@ -0,0 +1,26 @@
+import typing
+
+from modern_di.providers.abstract import AbstractProvider
+
+
+if typing.TYPE_CHECKING:
+    import typing_extensions
+
+
+T = typing.TypeVar("T")
+P = typing.ParamSpec("P")
+
+
+class Group:
+    providers: dict[str, AbstractProvider[typing.Any]]
+
+    def __new__(cls, *_: typing.Any, **__: typing.Any) -> "typing_extensions.Self":  # noqa: ANN401
+        msg = f"{cls.__name__} cannot not be instantiated"
+        raise RuntimeError(msg)
+
+    @classmethod
+    def get_providers(cls) -> dict[str, AbstractProvider[typing.Any]]:
+        if not hasattr(cls, "providers"):
+            cls.providers = {k: v for k, v in cls.__dict__.items() if isinstance(v, AbstractProvider)}
+
+        return cls.providers

modern_di-0.17.0/modern_di/helpers/type_helpers.py

@@ -0,0 +1,33 @@
+import collections
+import types
+import typing
+
+
+GENERIC_TYPES = {
+    typing.Iterator,
+    typing.AsyncIterator,
+    collections.abc.Iterator,
+    collections.abc.AsyncIterator,
+}
+
+
+def define_bound_type(creator: type | object) -> type | None:
+    if isinstance(creator, type):
+        return creator
+
+    type_hints = typing.get_type_hints(creator)
+    return_annotation = type_hints.get("return")
+    if not return_annotation:
+        return None
+
+    if isinstance(return_annotation, type) and not isinstance(return_annotation, types.GenericAlias):
+        return return_annotation
+
+    if typing.get_origin(return_annotation) not in GENERIC_TYPES:
+        return None
+
+    args = typing.get_args(return_annotation)
+    if not args:
+        return None
+
+    return typing.cast(type, args[0])

{modern_di-0.16.2 → modern_di-0.17.0}/modern_di/providers/__init__.py

@@ -2,13 +2,12 @@ from modern_di.providers.abstract import AbstractProvider
 from modern_di.providers.async_factory import AsyncFactory
 from modern_di.providers.async_singleton import AsyncSingleton
 from modern_di.providers.container_provider import ContainerProvider
-from modern_di.providers.context_adapter import ContextAdapter
+from modern_di.providers.context_provider import ContextProvider
 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.object import Object
 from modern_di.providers.resource import Resource
-from modern_di.providers.selector import Selector
 from modern_di.providers.singleton import Singleton
 
 
@@ -17,12 +16,11 @@ __all__ = [
     "AsyncFactory",
     "AsyncSingleton",
     "ContainerProvider",
-    "ContextAdapter",
+    "ContextProvider",
     "Dict",
     "Factory",
     "List",
     "Object",
     "Resource",
-    "Selector",
     "Singleton",
 ]

modern_di-0.17.0/modern_di/providers/abstract.py

@@ -0,0 +1,142 @@
+import abc
+import enum
+import typing
+import uuid
+
+import typing_extensions
+from typing_extensions import override
+
+from modern_di.helpers.attr_getter_helpers import get_value_from_object_by_dotted_path
+from modern_di.helpers.type_helpers import define_bound_type
+from modern_di.registries.state_registry.state import AsyncState, SyncState
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+R = typing.TypeVar("R")
+P = typing.ParamSpec("P")
+
+
+class AbstractProvider(abc.ABC, typing.Generic[T_co]):
+    BASE_SLOTS: typing.ClassVar = ["scope", "provider_id", "args", "kwargs", "is_async", "bound_type"]
+    HAS_STATE: bool = False
+
+    def __init__(
+        self,
+        scope: enum.IntEnum,
+        args: list[typing.Any] | None = None,
+        kwargs: dict[str, typing.Any] | None = None,
+        bound_type: type | None = None,
+    ) -> None:
+        self.scope = scope
+        self.provider_id: typing.Final = str(uuid.uuid4())
+        self.args = args
+        self.kwargs = kwargs
+        self.is_async = False
+        self.bound_type = bound_type
+        self._check_providers_scope()
+
+    def bind_type(self, new_type: type) -> typing_extensions.Self:
+        self.bound_type = new_type
+        return self
+
+    async def async_resolve(
+        self,
+        *,
+        args: list[typing.Any],
+        kwargs: dict[str, typing.Any],
+        provider_state: AsyncState[T_co] | None,
+    ) -> T_co:  # pragma: no cover
+        """Resolve dependency asynchronously."""
+        raise NotImplementedError
+
+    def sync_resolve(
+        self,
+        *,
+        args: list[typing.Any],
+        kwargs: dict[str, typing.Any],
+        provider_state: SyncState[T_co] | None,
+    ) -> T_co:  # pragma: no cover
+        """Resolve dependency synchronously."""
+        raise NotImplementedError
+
+    @property
+    def cast(self) -> T_co:
+        return typing.cast(T_co, self)
+
+    def _check_providers_scope(self) -> None:
+        if self.args:
+            for provider in self.args:
+                if isinstance(provider, AbstractProvider) and provider.scope > self.scope:
+                    msg = f"Scope of dependency is {provider.scope.name} and current scope is {self.scope.name}"
+                    raise RuntimeError(msg)
+
+        if self.kwargs:
+            for name, provider in self.kwargs.items():
+                if isinstance(provider, AbstractProvider) and provider.scope > self.scope:
+                    msg = f"Scope of {name} is {provider.scope.name} and current scope is {self.scope.name}"
+                    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 AbstractCreatorProvider(AbstractProvider[T_co], abc.ABC):
+    BASE_SLOTS: typing.ClassVar = [*AbstractProvider.BASE_SLOTS, "_creator"]
+
+    def __init__(
+        self,
+        scope: enum.IntEnum,
+        creator: typing.Callable[P, typing.Any],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> None:
+        super().__init__(scope, args=list(args), kwargs=kwargs, bound_type=define_bound_type(creator))
+        self._creator: typing.Final = creator
+
+
+class AttrGetter(AbstractProvider[T_co]):
+    __slots__ = [*AbstractProvider.BASE_SLOTS, "_attrs"]
+
+    def __init__(self, provider: AbstractProvider[T_co], attr_name: str) -> None:
+        super().__init__(scope=provider.scope, args=[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,
+        *,
+        args: list[typing.Any],
+        **_: object,
+    ) -> typing.Any:
+        attribute_path = ".".join(self._attrs)
+        return get_value_from_object_by_dotted_path(args[0], attribute_path)
+
+    @override
+    def sync_resolve(
+        self,
+        *,
+        args: list[typing.Any],
+        **_: object,
+    ) -> typing.Any:
+        attribute_path = ".".join(self._attrs)
+        return get_value_from_object_by_dotted_path(args[0], attribute_path)

{modern_di-0.16.2 → modern_di-0.17.0}/modern_di/providers/async_factory.py

@@ -1,7 +1,6 @@
 import enum
 import typing
 
-from modern_di import Container
 from modern_di.providers.abstract import AbstractCreatorProvider
 
 
@@ -20,15 +19,14 @@ class AsyncFactory(AbstractCreatorProvider[T_co]):
         **kwargs: P.kwargs,
     ) -> None:
         super().__init__(scope, creator, *args, **kwargs)
+        self.is_async = True
 
-    async def async_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)
-
-        coroutine: typing.Awaitable[T_co] = await self._async_build_creator(container)
+    async def async_resolve(
+        self,
+        *,
+        args: list[typing.Any],
+        kwargs: dict[str, typing.Any],
+        **__: object,
+    ) -> T_co:
+        coroutine: typing.Awaitable[T_co] = self._creator(*args, **kwargs)
         return await coroutine
-
-    def sync_resolve(self, _: Container) -> typing.NoReturn:
-        msg = "AsyncFactory cannot be resolved synchronously"
-        raise RuntimeError(msg)

modern_di-0.17.0/modern_di/providers/async_singleton.py

@@ -0,0 +1,37 @@
+import enum
+import typing
+
+from modern_di.providers.abstract import AbstractCreatorProvider
+from modern_di.registries.state_registry.state import AsyncState
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+P = typing.ParamSpec("P")
+
+
+class AsyncSingleton(AbstractCreatorProvider[T_co]):
+    __slots__ = AbstractCreatorProvider.BASE_SLOTS
+    HAS_STATE = True
+
+    def __init__(
+        self,
+        scope: enum.IntEnum,
+        creator: typing.Callable[P, typing.Awaitable[T_co]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> None:
+        super().__init__(scope, creator, *args, **kwargs)
+        self.is_async = True
+
+    async def async_resolve(
+        self,
+        *,
+        args: list[typing.Any],
+        kwargs: dict[str, typing.Any],
+        provider_state: AsyncState[T_co] | None,
+        **__: object,
+    ) -> T_co:
+        assert provider_state
+        coroutine: typing.Awaitable[T_co] = self._creator(*args, **kwargs)
+        provider_state.instance = await coroutine
+        return provider_state.instance

modern_di-0.17.0/modern_di/providers/container_provider.py

@@ -0,0 +1,15 @@
+import enum
+import typing
+
+from modern_di.providers import AbstractProvider
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+P = typing.ParamSpec("P")
+
+
+class ContainerProvider(AbstractProvider[typing.Any]):
+    __slots__ = AbstractProvider.BASE_SLOTS
+
+    def __init__(self, scope: enum.IntEnum) -> None:
+        super().__init__(scope)

modern_di-0.17.0/modern_di/providers/context_provider.py

@@ -0,0 +1,16 @@
+import enum
+import typing
+
+from modern_di.providers import AbstractProvider
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+P = typing.ParamSpec("P")
+
+
+class ContextProvider(AbstractProvider[T_co]):
+    __slots__ = [*AbstractProvider.BASE_SLOTS, "context_type", "required"]
+
+    def __init__(self, scope: enum.IntEnum, context_type: type[T_co]) -> None:
+        super().__init__(scope)
+        self.context_type = context_type