modern-di 0.16.3__py3-none-any.whl → 0.17.0__py3-none-any.whl

modern_di/providers/async_singleton.py

@@ -1,8 +1,8 @@
 import enum
 import typing
 
-from modern_di import Container
 from modern_di.providers.abstract import AbstractCreatorProvider
+from modern_di.registries.state_registry.state import AsyncState
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
@@ -11,6 +11,7 @@ P = typing.ParamSpec("P")
 
 class AsyncSingleton(AbstractCreatorProvider[T_co]):
     __slots__ = AbstractCreatorProvider.BASE_SLOTS
+    HAS_STATE = True
 
     def __init__(
         self,
@@ -20,30 +21,17 @@ class AsyncSingleton(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)
-
-        provider_state = container.fetch_provider_state(self.provider_id, use_asyncio_lock=True)
-        if provider_state.instance is not None:
-            return typing.cast(T_co, provider_state.instance)
-
-        assert provider_state.asyncio_lock
-        await provider_state.asyncio_lock.acquire()
-
-        try:
-            if provider_state.instance is not None:
-                return typing.cast(T_co, provider_state.instance)
-
-            coroutine: typing.Awaitable[T_co] = await self._async_build_creator(container)
-            provider_state.instance = await coroutine
-        finally:
-            provider_state.asyncio_lock.release()
-
+    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
-
-    def sync_resolve(self, _: Container) -> typing.NoReturn:
-        msg = "AsyncSingleton cannot be resolved synchronously"
-        raise RuntimeError(msg)

modern_di/providers/container_provider.py

@@ -1,7 +1,6 @@
+import enum
 import typing
 
-import modern_di
-from modern_di import Container
 from modern_di.providers import AbstractProvider
 
 
@@ -9,11 +8,8 @@ T_co = typing.TypeVar("T_co", covariant=True)
 P = typing.ParamSpec("P")
 
 
-class ContainerProvider(AbstractProvider[modern_di.Container]):
+class ContainerProvider(AbstractProvider[typing.Any]):
     __slots__ = AbstractProvider.BASE_SLOTS
 
-    async def async_resolve(self, container: Container) -> modern_di.Container:
-        return self.sync_resolve(container)
-
-    def sync_resolve(self, container: Container) -> modern_di.Container:
-        return container.find_container(self.scope)
+    def __init__(self, scope: enum.IntEnum) -> None:
+        super().__init__(scope)

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

modern_di/providers/dict.py

@@ -1,7 +1,6 @@
 import enum
 import typing
 
-from modern_di import Container
 from modern_di.providers.abstract import AbstractProvider
 
 
@@ -9,15 +8,23 @@ 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(kwargs=providers)
-        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()}
+    __slots__ = AbstractProvider.BASE_SLOTS
+
+    def __init__(self, scope: enum.IntEnum, **kwargs: AbstractProvider[T_co]) -> None:
+        super().__init__(scope, kwargs=kwargs)
+
+    async def async_resolve(
+        self,
+        *,
+        kwargs: dict[str, typing.Any] | None,
+        **__: object,
+    ) -> dict[str, T_co]:
+        return kwargs or {}
+
+    def sync_resolve(
+        self,
+        *,
+        kwargs: dict[str, typing.Any] | None,
+        **__: object,
+    ) -> dict[str, T_co]:
+        return kwargs or {}

modern_di/providers/factory.py

@@ -1,9 +1,7 @@
 import enum
 import typing
 
-from modern_di import Container
 from modern_di.providers.abstract import AbstractCreatorProvider
-from modern_di.providers.injected_factory import AsyncInjectedFactory, SyncInjectedFactory
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
@@ -22,24 +20,20 @@ class Factory(AbstractCreatorProvider[T_co]):
     ) -> None:
         super().__init__(scope, creator, *args, **kwargs)
 
-    @property
-    def sync_provider(self) -> SyncInjectedFactory[T_co]:
-        return SyncInjectedFactory(self)
-
-    @property
-    def async_provider(self) -> AsyncInjectedFactory[T_co]:
-        return AsyncInjectedFactory(self)
-
-    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)
-
-        return typing.cast(T_co, await self._async_build_creator(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 typing.cast(T_co, self._sync_build_creator(container))
+    async def async_resolve(
+        self,
+        *,
+        args: list[typing.Any],
+        kwargs: dict[str, typing.Any],
+        **__: object,
+    ) -> T_co:
+        return typing.cast(T_co, self._creator(*args, **kwargs))
+
+    def sync_resolve(
+        self,
+        *,
+        args: list[typing.Any],
+        kwargs: dict[str, typing.Any],
+        **__: object,
+    ) -> T_co:
+        return typing.cast(T_co, self._creator(*args, **kwargs))

modern_di/providers/list.py

@@ -1,7 +1,6 @@
 import enum
 import typing
 
-from modern_di import Container
 from modern_di.providers.abstract import AbstractProvider
 
 
@@ -9,15 +8,23 @@ 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(args=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]
+    __slots__ = AbstractProvider.BASE_SLOTS
+
+    def __init__(self, scope: enum.IntEnum, *args: AbstractProvider[T_co]) -> None:
+        super().__init__(scope, args=list(args))
+
+    async def async_resolve(
+        self,
+        *,
+        args: list[typing.Any] | None,
+        **__: object,
+    ) -> list[T_co]:
+        return args or []
+
+    def sync_resolve(
+        self,
+        *,
+        args: list[typing.Any] | None,
+        **__: object,
+    ) -> list[T_co]:
+        return args or []

modern_di/providers/object.py

@@ -1,27 +1,22 @@
 import enum
 import typing
 
-from modern_di import Container
-from modern_di.providers.abstract import AbstractOverrideProvider
+from modern_di.providers.abstract import AbstractProvider
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
 P = typing.ParamSpec("P")
 
 
-class Object(AbstractOverrideProvider[T_co]):
-    __slots__ = [*AbstractOverrideProvider.BASE_SLOTS, "_obj"]
+class Object(AbstractProvider[T_co]):
+    __slots__ = [*AbstractProvider.BASE_SLOTS, "_obj"]
 
     def __init__(self, scope: enum.IntEnum, obj: T_co) -> None:
         super().__init__(scope)
         self._obj: typing.Final = obj
 
-    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)
+    async def async_resolve(self, *_: object, **__: object) -> T_co:
+        return self._obj
 
+    def sync_resolve(self, *_: object, **__: object) -> T_co:
         return self._obj

modern_di/providers/resource.py

@@ -3,8 +3,8 @@ import enum
 import inspect
 import typing
 
-from modern_di import Container
 from modern_di.providers.abstract import AbstractCreatorProvider
+from modern_di.registries.state_registry.state import AsyncState, SyncState
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
@@ -12,13 +12,14 @@ P = typing.ParamSpec("P")
 
 
 class Resource(AbstractCreatorProvider[T_co]):
-    __slots__ = [*AbstractCreatorProvider.BASE_SLOTS, "_is_async"]
+    __slots__ = AbstractCreatorProvider.BASE_SLOTS
+    HAS_STATE = True
 
     def _is_creator_async(
         self,
         _: contextlib.AbstractContextManager[T_co] | contextlib.AbstractAsyncContextManager[T_co],
     ) -> typing.TypeGuard[contextlib.AbstractAsyncContextManager[T_co]]:
-        return self._is_async
+        return self.is_async
 
     def __init__(
         self,
@@ -35,85 +36,56 @@ class Resource(AbstractCreatorProvider[T_co]):
     ) -> None:
         new_creator: typing.Any
         if inspect.isasyncgenfunction(creator):
-            self._is_async = True
+            is_async = True
             new_creator = contextlib.asynccontextmanager(creator)
         elif inspect.isgeneratorfunction(creator):
-            self._is_async = False
+            is_async = False
             new_creator = contextlib.contextmanager(creator)
         elif isinstance(creator, type) and issubclass(creator, typing.AsyncContextManager):
-            self._is_async = True
+            is_async = True
             new_creator = creator
         elif isinstance(creator, type) and issubclass(creator, typing.ContextManager):
-            self._is_async = False
+            is_async = False
             new_creator = creator
         else:
             msg = "Unsupported resource type"
             raise TypeError(msg)
 
         super().__init__(scope, new_creator, *args, **kwargs)
+        self.is_async = is_async
 
-    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)
-
-        provider_state = container.fetch_provider_state(
-            self.provider_id, is_async_resource=self._is_async, use_asyncio_lock=True
-        )
-        if provider_state.instance is not None:
-            return typing.cast(T_co, provider_state.instance)
-
-        if provider_state.asyncio_lock:
-            await provider_state.asyncio_lock.acquire()
-
-        try:
-            if provider_state.instance is not None:
-                return typing.cast(T_co, provider_state.instance)
-
-            _intermediate_ = await self._async_build_creator(container)
-
-            if self._is_creator_async(self._creator):  # type: ignore[arg-type]
-                provider_state.context_stack = contextlib.AsyncExitStack()
-                provider_state.instance = await provider_state.context_stack.enter_async_context(_intermediate_)
-            else:
-                provider_state.context_stack = contextlib.ExitStack()
-                provider_state.instance = provider_state.context_stack.enter_context(_intermediate_)
-        finally:
-            if provider_state.asyncio_lock:
-                provider_state.asyncio_lock.release()
+    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
+        _intermediate_ = self._creator(*args, **kwargs)
+        if self._is_creator_async(self._creator):  # type: ignore[arg-type]
+            provider_state.context_stack = contextlib.AsyncExitStack()
+            provider_state.instance = await provider_state.context_stack.enter_async_context(_intermediate_)
+        else:
+            provider_state.context_stack = contextlib.ExitStack()
+            provider_state.instance = provider_state.context_stack.enter_context(_intermediate_)
 
         return typing.cast(T_co, provider_state.instance)
 
-    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)
-
-        provider_state = container.fetch_provider_state(
-            self.provider_id, is_async_resource=self._is_async, use_threading_lock=True
+    def sync_resolve(
+        self,
+        *,
+        args: list[typing.Any],
+        kwargs: dict[str, typing.Any],
+        provider_state: SyncState[T_co] | None,
+        **_: object,
+    ) -> T_co:
+        assert provider_state
+        _intermediate_ = self._creator(*args, **kwargs)
+        provider_state.context_stack = contextlib.ExitStack()
+        provider_state.instance = provider_state.context_stack.enter_context(
+            typing.cast(contextlib.AbstractContextManager[typing.Any], _intermediate_)
         )
-        if provider_state.instance is not None:
-            return typing.cast(T_co, provider_state.instance)
-
-        if self._is_async:
-            msg = "Async resource cannot be resolved synchronously"
-            raise RuntimeError(msg)
-
-        if provider_state.threading_lock:
-            provider_state.threading_lock.acquire()
-
-        try:
-            if provider_state.instance is not None:
-                return typing.cast(T_co, provider_state.instance)
-
-            _intermediate_ = self._sync_build_creator(container)
-
-            provider_state.context_stack = contextlib.ExitStack()
-            provider_state.instance = provider_state.context_stack.enter_context(
-                typing.cast(contextlib.AbstractContextManager[typing.Any], _intermediate_)
-            )
-        finally:
-            if provider_state.threading_lock:
-                provider_state.threading_lock.release()
 
         return typing.cast(T_co, provider_state.instance)

modern_di/providers/singleton.py

@@ -1,8 +1,8 @@
 import enum
 import typing
 
-from modern_di import Container
 from modern_di.providers.abstract import AbstractCreatorProvider
+from modern_di.registries.state_registry.state import AsyncState, SyncState
 
 
 T_co = typing.TypeVar("T_co", covariant=True)
@@ -11,6 +11,7 @@ P = typing.ParamSpec("P")
 
 class Singleton(AbstractCreatorProvider[T_co]):
     __slots__ = AbstractCreatorProvider.BASE_SLOTS
+    HAS_STATE = True
 
     def __init__(
         self,
@@ -21,47 +22,26 @@ class Singleton(AbstractCreatorProvider[T_co]):
     ) -> None:
         super().__init__(scope, creator, *args, **kwargs)
 
-    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)
-
-        provider_state = container.fetch_provider_state(self.provider_id, use_asyncio_lock=True)
-        if provider_state.instance is not None:
-            return typing.cast(T_co, provider_state.instance)
-
-        assert provider_state.asyncio_lock
-        await provider_state.asyncio_lock.acquire()
-
-        try:
-            if provider_state.instance is not None:
-                return typing.cast(T_co, provider_state.instance)
-
-            provider_state.instance = typing.cast(T_co, await self._async_build_creator(container))
-        finally:
-            provider_state.asyncio_lock.release()
-
+    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
+        provider_state.instance = self._creator(*args, **kwargs)
         return provider_state.instance
 
-    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)
-
-        provider_state = container.fetch_provider_state(self.provider_id, use_threading_lock=True)
-        if provider_state.instance is not None:
-            return typing.cast(T_co, provider_state.instance)
-
-        if provider_state.threading_lock:
-            provider_state.threading_lock.acquire()
-
-        try:
-            if provider_state.instance is not None:
-                return typing.cast(T_co, provider_state.instance)
-
-            provider_state.instance = self._sync_build_creator(container)
-        finally:
-            if provider_state.threading_lock:
-                provider_state.threading_lock.release()
-
-        return typing.cast(T_co, provider_state.instance)
+    def sync_resolve(
+        self,
+        *,
+        args: list[typing.Any],
+        kwargs: dict[str, typing.Any],
+        provider_state: SyncState[T_co] | None,
+        **__: object,
+    ) -> T_co:
+        assert provider_state
+        provider_state.instance = self._creator(*args, **kwargs)
+        return provider_state.instance

modern_di/registries/context_registry.py

@@ -0,0 +1,16 @@
+import dataclasses
+import typing
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class ContextRegistry:
+    context: dict[type[typing.Any], typing.Any]
+
+    def find_context(self, context_type: type[T_co]) -> T_co | None:
+        if context_type and (context := self.context.get(context_type)):
+            return typing.cast(T_co, context)
+
+        return None

modern_di/registries/overrides_registry.py

@@ -0,0 +1,22 @@
+import dataclasses
+import typing
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+@dataclasses.dataclass(kw_only=True, slots=True, frozen=True)
+class OverridesRegistry:
+    overrides: dict[str, typing.Any] = dataclasses.field(init=False, default_factory=dict)
+
+    def override(self, provider_id: str, override_object: object) -> None:
+        self.overrides[provider_id] = override_object
+
+    def reset_override(self, provider_id: str | None = None) -> None:
+        if provider_id is None:
+            self.overrides.clear()
+        else:
+            self.overrides.pop(provider_id, None)
+
+    def fetch_override(self, provider_id: str) -> object | None:
+        return self.overrides.get(provider_id)

modern_di/registries/providers_registry.py

@@ -0,0 +1,38 @@
+import dataclasses
+import typing
+import warnings
+
+from modern_di.providers.abstract import AbstractProvider
+
+
+T_co = typing.TypeVar("T_co", covariant=True)
+
+
+@dataclasses.dataclass(slots=True, frozen=True)
+class ProvidersRegistry:
+    providers_by_name: dict[str, AbstractProvider[typing.Any]] = dataclasses.field(init=False, default_factory=dict)
+    providers_by_type: dict[type, AbstractProvider[typing.Any]] = dataclasses.field(init=False, default_factory=dict)
+
+    def find_provider(
+        self, dependency_name: str | None = None, dependency_type: type[T_co] | None = None
+    ) -> AbstractProvider[T_co] | None:
+        if dependency_name and (provider := self.providers_by_name.get(dependency_name)):
+            return provider
+
+        if dependency_type and (provider := self.providers_by_type.get(dependency_type)):
+            return provider
+
+        return None
+
+    def add_providers(self, **kwargs: AbstractProvider[typing.Any]) -> None:
+        if duplicates_by_name := set(self.providers_by_name.keys()) & set(kwargs.keys()):
+            warnings.warn(f"Duplicated by name providers {duplicates_by_name}", RuntimeWarning, stacklevel=2)
+
+        self.providers_by_name.update(kwargs)
+
+        if duplicates_by_type := set(self.providers_by_type.keys()) & {
+            x.bound_type for x in kwargs.values() if x.bound_type
+        }:
+            warnings.warn(f"Duplicated by type providers {duplicates_by_type}", RuntimeWarning, stacklevel=2)
+
+        self.providers_by_type.update({x.bound_type: x for x in kwargs.values() if x.bound_type})

modern_di/{provider_state.py → registries/state_registry/state.py}

@@ -7,16 +7,15 @@ import typing
 T_co = typing.TypeVar("T_co", covariant=True)
 
 
-class ProviderState(typing.Generic[T_co]):
-    __slots__ = "asyncio_lock", "context_stack", "instance", "threading_lock"
+class AsyncState(typing.Generic[T_co]):
+    __slots__ = "context_stack", "instance", "lock", "use_lock"
 
-    def __init__(self, use_asyncio_lock: bool, use_threading_lock: bool) -> None:
+    def __init__(self, use_lock: bool = True) -> None:
+        self.lock: typing.Final = asyncio.Lock() if use_lock else None
         self.context_stack: contextlib.AsyncExitStack | contextlib.ExitStack | None = None
         self.instance: T_co | None = None
-        self.asyncio_lock: typing.Final = asyncio.Lock() if use_asyncio_lock else None
-        self.threading_lock: typing.Final = threading.Lock() if use_threading_lock else None
 
-    async def async_tear_down(self) -> None:
+    async def tear_down(self) -> None:
         if self.context_stack is None:
             return
 
@@ -27,14 +26,19 @@ class ProviderState(typing.Generic[T_co]):
         self.context_stack = None
         self.instance = None
 
-    def sync_tear_down(self) -> None:
+
+class SyncState(typing.Generic[T_co]):
+    __slots__ = "context_stack", "instance", "lock", "use_lock"
+
+    def __init__(self, use_lock: bool = True) -> None:
+        self.lock: typing.Final = threading.Lock() if use_lock else None
+        self.context_stack: contextlib.ExitStack | None = None
+        self.instance: T_co | None = None
+
+    def tear_down(self) -> None:
         if self.context_stack is None:
             return
 
-        if isinstance(self.context_stack, contextlib.AsyncExitStack):
-            msg = "Cannot tear down async context in `sync_tear_down`"
-            raise RuntimeError(msg)  # noqa: TRY004
-
         self.context_stack.close()
         self.context_stack = None
         self.instance = None