modern-di 0.14.0__py3-none-any.whl → 1.0.0a3__py3-none-any.whl

modern_di/__init__.py

@@ -1,11 +1,13 @@
-from modern_di.container import Container
-from modern_di.graph import BaseGraph
+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__ = [
-    "BaseGraph",
-    "Container",
+    "AsyncContainer",
+    "Group",
     "Scope",
+    "SyncContainer",
     "providers",
 ]

modern_di/containers/abstract.py

@@ -0,0 +1,172 @@
+import asyncio
+import enum
+import threading
+import typing
+
+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.context_registry import ContextRegistry
+from modern_di.registries.overrides_registry import OverridesRegistry
+from modern_di.registries.providers_registry import ProvidersRegistry
+from modern_di.registries.state_registry.state_registry import StateRegistry
+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",
+        "_async_lock",
+        "_sync_lock",
+        "scope",
+        "parent_container",
+        "state_registry",
+        "context_registry",
+        "providers_registry",
+        "overrides_registry",
+    ]
+
+    def __init__(  # noqa: PLR0913
+        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_async_lock: bool = True,
+        use_sync_lock: bool = True,
+    ) -> None:
+        self._is_entered = False
+        self._async_lock = asyncio.Lock() if use_async_lock else None
+        self._sync_lock = threading.Lock() if use_sync_lock else None
+        self.scope = scope
+        self.parent_container = parent_container
+        self.state_registry = StateRegistry()
+        self.context_registry = ContextRegistry(context or {})
+        self.providers_registry: ProvidersRegistry
+        self.overrides_registry: OverridesRegistry
+        if parent_container:
+            self.providers_registry = parent_container.providers_registry
+            self.overrides_registry = parent_container.overrides_registry
+        else:
+            self.providers_registry = ProvidersRegistry()
+            self.overrides_registry = OverridesRegistry()
+        if groups:
+            for one_group in groups:
+                self.providers_registry.add_providers(**one_group.get_providers())
+
+    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 | None:
+        return self.context_registry.find_context(provider.context_type)
+
+    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 _sync_resolve_args(self, args: list[typing.Any]) -> list[typing.Any]:
+        return [self._sync_resolve_provider(x) if isinstance(x, AbstractProvider) else x for x in args]
+
+    def _sync_resolve_kwargs(self, kwargs: dict[str, typing.Any]) -> dict[str, typing.Any]:
+        return {k: self._sync_resolve_provider(v) if isinstance(v, AbstractProvider) else v for k, v in kwargs.items()}
+
+    def _sync_resolve(self, dependency_type: type[T_co] | None = None, *, dependency_name: str | None = None) -> T_co:
+        provider = self.providers_registry.find_provider(
+            dependency_type=dependency_type, dependency_name=dependency_name
+        )
+        if not provider:
+            msg = f"Provider is not found, {dependency_type=}, {dependency_name=}"
+            raise RuntimeError(msg)
+
+        return self._sync_resolve_provider(provider)
+
+    def _sync_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
+
+        args = self._sync_resolve_args(provider.args or [])
+        kwargs = self._sync_resolve_kwargs(provider.kwargs or {})
+
+        if provider_state and self._sync_lock:
+            self._sync_lock.acquire()
+        try:
+            if provider_state and provider_state.instance is not None:
+                return provider_state.instance
+
+            return provider.sync_resolve(
+                args=args,
+                kwargs=kwargs,
+                provider_state=provider_state,
+            )
+        finally:
+            if provider_state and self._sync_lock:
+                self._sync_lock.release()
+
+    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/containers/async_container.py

@@ -0,0 +1,97 @@
+import contextlib
+import types
+import typing
+
+from modern_di.containers.abstract import AbstractContainer
+from modern_di.providers.abstract import AbstractProvider
+from modern_di.providers.container_provider import ContainerProvider
+from modern_di.providers.context_provider import ContextProvider
+
+
+if typing.TYPE_CHECKING:
+    pass
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+class AsyncContainer(contextlib.AbstractAsyncContextManager["AsyncContainer"], AbstractContainer):
+    __slots__ = AbstractContainer.BASE_SLOTS
+
+    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:
+        provider = self.providers_registry.find_provider(
+            dependency_type=dependency_type, dependency_name=dependency_name
+        )
+        if not provider:
+            msg = f"Provider is not found, {dependency_type=}, {dependency_name=}"
+            raise RuntimeError(msg)
+
+        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
+
+        args = await self._resolve_args(provider.args or [])
+        kwargs = await self._resolve_kwargs(provider.kwargs or {})
+
+        if provider_state and self._async_lock:
+            await self._async_lock.acquire()
+        try:
+            if provider_state and provider_state.instance is not None:
+                return provider_state.instance
+
+            return await provider.async_resolve(
+                args=args,
+                kwargs=kwargs,
+                provider_state=provider_state,
+            )
+        finally:
+            if provider_state and self._async_lock:
+                self._async_lock.release()
+
+    def sync_resolve(self, dependency_type: type[T_co] | None = None, *, dependency_name: str | None = None) -> T_co:
+        return self._sync_resolve(dependency_type=dependency_type, dependency_name=dependency_name)
+
+    def sync_resolve_provider(self, provider: AbstractProvider[T_co]) -> T_co:
+        return self._sync_resolve_provider(provider)
+
+    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.async_tear_down()
+        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/containers/sync_container.py

@@ -0,0 +1,40 @@
+import contextlib
+import types
+import typing
+
+from modern_di.containers.abstract import AbstractContainer
+from modern_di.providers.abstract import AbstractProvider
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+class SyncContainer(contextlib.AbstractContextManager["SyncContainer"], AbstractContainer):
+    __slots__ = AbstractContainer.BASE_SLOTS
+
+    def resolve(self, dependency_type: type[T_co] | None = None, *, dependency_name: str | None = None) -> T_co:
+        return self._sync_resolve(dependency_type=dependency_type, dependency_name=dependency_name)
+
+    def resolve_provider(self, provider: AbstractProvider[T_co]) -> T_co:
+        return self._sync_resolve_provider(provider)
+
+    def enter(self) -> "SyncContainer":
+        self._is_entered = True
+        return self
+
+    def close(self) -> None:
+        self._check_entered()
+        self._is_entered = False
+        self.state_registry.sync_tear_down()
+        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/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/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/providers/__init__.py

@@ -1,26 +1,26 @@
 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
 
 
 __all__ = [
     "AbstractProvider",
     "AsyncFactory",
+    "AsyncSingleton",
     "ContainerProvider",
-    "ContextAdapter",
+    "ContextProvider",
     "Dict",
     "Factory",
     "List",
     "Object",
     "Resource",
-    "Selector",
     "Singleton",
 ]

modern_di/providers/abstract.py

@@ -1,13 +1,12 @@
 import abc
 import enum
-import itertools
 import typing
 import uuid
 
-from typing_extensions import override
+import typing_extensions
 
-from modern_di import Container
-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 ProviderState
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
@@ -15,57 +14,69 @@ R = typing.TypeVar("R")
 P = typing.ParamSpec("P")
 
 
-class AbstractProvider(typing.Generic[T_co], abc.ABC):
-    BASE_SLOTS: typing.ClassVar = ["scope", "provider_id"]
+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) -> None:
+    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
 
-    @abc.abstractmethod
-    async def async_resolve(self, container: Container) -> T_co:
+    async def async_resolve(
+        self,
+        *,
+        args: list[typing.Any],
+        kwargs: dict[str, typing.Any],
+        provider_state: ProviderState[T_co] | None,
+    ) -> T_co:  # pragma: no cover
         """Resolve dependency asynchronously."""
+        raise NotImplementedError
 
-    @abc.abstractmethod
-    def sync_resolve(self, container: Container) -> T_co:
+    def sync_resolve(
+        self,
+        *,
+        args: list[typing.Any],
+        kwargs: dict[str, typing.Any],
+        provider_state: ProviderState[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, 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)
-
-    def __getattr__(self, attr_name: str) -> typing.Any:  # noqa: ANN401
-        """Get an attribute from the resolve object.
+    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)
 
-        Args:
-            attr_name: name of attribute to get.
+        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)
 
-        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:
-        container.override(self.provider_id, override_object)
-
-    def reset_override(self, container: Container) -> None:
-        container.reset_override(self.provider_id)
-
-
-class AbstractCreatorProvider(AbstractOverrideProvider[T_co], abc.ABC):
-    BASE_SLOTS: typing.ClassVar = [*AbstractProvider.BASE_SLOTS, "_args", "_kwargs", "_creator"]
+class AbstractCreatorProvider(AbstractProvider[T_co], abc.ABC):
+    BASE_SLOTS: typing.ClassVar = [*AbstractProvider.BASE_SLOTS, "_creator"]
 
     def __init__(
         self,
@@ -74,72 +85,5 @@ class AbstractCreatorProvider(AbstractOverrideProvider[T_co], abc.ABC):
         *args: P.args,
         **kwargs: P.kwargs,
     ) -> None:
-        super().__init__(scope)
-        self._check_providers_scope(itertools.chain(args, kwargs.values()))
+        super().__init__(scope, args=list(args), kwargs=kwargs, bound_type=define_bound_type(creator))
         self._creator: typing.Final = creator
-        self._args: typing.Final = args
-        self._kwargs: typing.Final = kwargs
-
-    def _sync_resolve_args(self, container: Container) -> list[typing.Any]:
-        return [x.sync_resolve(container) if isinstance(x, AbstractProvider) else x for x in self._args]
-
-    def _sync_resolve_kwargs(self, container: Container) -> dict[str, typing.Any]:
-        return {k: v.sync_resolve(container) if isinstance(v, AbstractProvider) else v for k, v in self._kwargs.items()}
-
-    def _sync_build_creator(self, container: Container) -> typing.Any:  # noqa: ANN401
-        return self._creator(
-            *self._sync_resolve_args(container),
-            **self._sync_resolve_kwargs(container),
-        )
-
-    async def _async_resolve_args(self, container: Container) -> list[typing.Any]:
-        return [await x.async_resolve(container) if isinstance(x, AbstractProvider) else x for x in self._args]
-
-    async def _async_resolve_kwargs(self, container: Container) -> dict[str, typing.Any]:
-        return {
-            k: await v.async_resolve(container) if isinstance(v, AbstractProvider) else v
-            for k, v in self._kwargs.items()
-        }
-
-    async def _async_build_creator(self, container: Container) -> typing.Any:  # noqa: ANN401
-        return self._creator(
-            *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)

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
 
 
@@ -10,7 +9,7 @@ P = typing.ParamSpec("P")
 
 
 class AsyncFactory(AbstractCreatorProvider[T_co]):
-    __slots__ = [*AbstractCreatorProvider.BASE_SLOTS, "_creator"]
+    __slots__ = AbstractCreatorProvider.BASE_SLOTS
 
     def __init__(
         self,
@@ -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)