anydi 0.30.0__py3-none-any.whl → 0.32.0__py3-none-any.whl

anydi/_context.py

@@ -2,19 +2,19 @@ from __future__ import annotations
 
 import abc
 import contextlib
+import inspect
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, ClassVar, TypeVar, cast
+from typing import TYPE_CHECKING, Any, Callable, ClassVar
 
 from typing_extensions import Self, final
 
-from ._types import AnyInterface, Interface, Provider, Scope, is_event_type
-from ._utils import run_async
+from ._provider import CallableKind, Provider
+from ._types import AnyInterface, Scope, is_event_type
+from ._utils import get_full_qualname, run_async
 
 if TYPE_CHECKING:
     from ._container import Container
 
-T = TypeVar("T")
-
 
 class ScopedContext(abc.ABC):
     """ScopedContext base class."""
@@ -23,104 +23,91 @@ class ScopedContext(abc.ABC):
 
     def __init__(self, container: Container) -> None:
         self.container = container
+        self._instances: dict[Any, Any] = {}
 
-    @abc.abstractmethod
-    def get(self, interface: Interface[T], provider: Provider) -> T:
-        """Get an instance of a dependency from the scoped context.
-
-        Args:
-            interface: The interface of the dependency.
-            provider: The provider for the instance.
-
-        Returns:
-            An instance of the dependency.
-        """
+    def set(self, interface: AnyInterface, instance: Any) -> None:
+        """Set an instance of a dependency in the scoped context."""
+        self._instances[interface] = instance
 
     @abc.abstractmethod
-    async def aget(self, interface: Interface[T], provider: Provider) -> T:
-        """Get an async instance of a dependency from the scoped context.
-
-        Args:
-            interface: The interface of the dependency.
-            provider: The provider for the instance.
+    def get(self, provider: Provider) -> Any:
+        """Get an instance of a dependency from the scoped context."""
 
-        Returns:
-            An async instance of the dependency.
-        """
+    @abc.abstractmethod
+    async def aget(self, provider: Provider) -> Any:
+        """Get an async instance of a dependency from the scoped context."""
 
     def _create_instance(self, provider: Provider) -> Any:
-        """Create an instance using the provider.
-
-        Args:
-            provider: The provider for the instance.
-
-        Returns:
-            The created instance.
-
-        Raises:
-            TypeError: If the provider's instance is a coroutine provider
-                and synchronous mode is used.
-        """
-        if provider.is_coroutine:
+        """Create an instance using the provider."""
+        if provider.kind == CallableKind.COROUTINE:
             raise TypeError(
                 f"The instance for the coroutine provider `{provider}` cannot be "
                 "created in synchronous mode."
             )
-        args, kwargs = self._get_provider_arguments(provider)
-        return provider.obj(*args, **kwargs)
+        args, kwargs = self._get_provider_params(provider)
+        return provider.call(*args, **kwargs)
 
     async def _acreate_instance(self, provider: Provider) -> Any:
-        """Create an instance asynchronously using the provider.
-
-        Args:
-            provider: The provider for the instance.
-
-        Returns:
-            The created instance.
-
-        Raises:
-            TypeError: If the provider's instance is a coroutine provider
-                and asynchronous mode is used.
-        """
-        args, kwargs = await self._aget_provider_arguments(provider)
-        if provider.is_coroutine:
-            return await provider.obj(*args, **kwargs)
-        return await run_async(provider.obj, *args, **kwargs)
+        """Create an instance asynchronously using the provider."""
+        args, kwargs = await self._aget_provider_params(provider)
+        if provider.kind == CallableKind.COROUTINE:
+            return await provider.call(*args, **kwargs)
+        return await run_async(provider.call, *args, **kwargs)
+
+    def _resolve_parameter(
+        self, provider: Provider, parameter: inspect.Parameter
+    ) -> Any:
+        self._validate_resolvable_parameter(parameter, call=provider.call)
+        return self.container.resolve(parameter.annotation)
+
+    async def _aresolve_parameter(
+        self, provider: Provider, parameter: inspect.Parameter
+    ) -> Any:
+        self._validate_resolvable_parameter(parameter, call=provider.call)
+        return await self.container.aresolve(parameter.annotation)
+
+    def _validate_resolvable_parameter(
+        self, parameter: inspect.Parameter, call: Callable[..., Any]
+    ) -> None:
+        """Ensure that the specified interface is resolved."""
+        if parameter.annotation in self.container._unresolved_interfaces:  # noqa
+            raise LookupError(
+                f"You are attempting to get the parameter `{parameter.name}` with the "
+                f"annotation `{get_full_qualname(parameter.annotation)}` as a "
+                f"dependency into `{get_full_qualname(call)}` which is not registered "
+                "or set in the scoped context."
+            )
 
-    def _get_provider_arguments(
+    def _get_provider_params(
         self, provider: Provider
     ) -> tuple[list[Any], dict[str, Any]]:
-        """Retrieve the arguments for a provider.
+        """Retrieve the arguments for a provider."""
+        args: list[Any] = []
+        kwargs: dict[str, Any] = {}
 
-        Args:
-            provider: The provider object.
-
-        Returns:
-            The arguments for the provider.
-        """
-        args, kwargs = [], {}
         for parameter in provider.parameters:
-            instance = self.container.resolve(parameter.annotation)
+            if parameter.annotation in self._instances:
+                instance = self._instances[parameter.annotation]
+            else:
+                instance = self._resolve_parameter(provider, parameter)
             if parameter.kind == parameter.POSITIONAL_ONLY:
                 args.append(instance)
             else:
                 kwargs[parameter.name] = instance
         return args, kwargs
 
-    async def _aget_provider_arguments(
+    async def _aget_provider_params(
         self, provider: Provider
     ) -> tuple[list[Any], dict[str, Any]]:
-        """Asynchronously retrieve the arguments for a provider.
-
-        Args:
-            provider: The provider object.
+        """Asynchronously retrieve the arguments for a provider."""
+        args: list[Any] = []
+        kwargs: dict[str, Any] = {}
 
-        Returns:
-            The arguments for the provider.
-        """
-        args, kwargs = [], {}
         for parameter in provider.parameters:
-            instance = await self.container.aresolve(parameter.annotation)
+            if parameter.annotation in self._instances:
+                instance = self._instances[parameter.annotation]
+            else:
+                instance = await self._aresolve_parameter(provider, parameter)
             if parameter.kind == parameter.POSITIONAL_ONLY:
                 args.append(instance)
             else:
@@ -134,25 +121,16 @@ class ResourceScopedContext(ScopedContext):
     def __init__(self, container: Container) -> None:
         """Initialize the ScopedContext."""
         super().__init__(container)
-        self._instances: dict[type[Any], Any] = {}
         self._stack = contextlib.ExitStack()
         self._async_stack = contextlib.AsyncExitStack()
 
-    def get(self, interface: Interface[T], provider: Provider) -> T:
-        """Get an instance of a dependency from the scoped context.
-
-        Args:
-            interface: The interface of the dependency.
-            provider: The provider for the instance.
-
-        Returns:
-            An instance of the dependency.
-        """
-        instance = self._instances.get(interface)
+    def get(self, provider: Provider) -> Any:
+        """Get an instance of a dependency from the scoped context."""
+        instance = self._instances.get(provider.interface)
         if instance is None:
-            if provider.is_generator:
+            if provider.kind == CallableKind.GENERATOR:
                 instance = self._create_resource(provider)
-            elif provider.is_async_generator:
+            elif provider.kind == CallableKind.ASYNC_GENERATOR:
                 raise TypeError(
                     f"The provider `{provider}` cannot be started in synchronous mode "
                     "because it is an asynchronous provider. Please start the provider "
@@ -160,39 +138,24 @@ class ResourceScopedContext(ScopedContext):
                 )
             else:
                 instance = self._create_instance(provider)
-            self._instances[interface] = instance
-        return cast(T, instance)
-
-    async def aget(self, interface: Interface[T], provider: Provider) -> T:
-        """Get an async instance of a dependency from the scoped context.
-
-        Args:
-            interface: The interface of the dependency.
-            provider: The provider for the instance.
+            self._instances[provider.interface] = instance
+        return instance
 
-        Returns:
-            An async instance of the dependency.
-        """
-        instance = self._instances.get(interface)
+    async def aget(self, provider: Provider) -> Any:
+        """Get an async instance of a dependency from the scoped context."""
+        instance = self._instances.get(provider.interface)
         if instance is None:
-            if provider.is_generator:
+            if provider.kind == CallableKind.GENERATOR:
                 instance = await run_async(self._create_resource, provider)
-            elif provider.is_async_generator:
+            elif provider.kind == CallableKind.ASYNC_GENERATOR:
                 instance = await self._acreate_resource(provider)
             else:
                 instance = await self._acreate_instance(provider)
-            self._instances[interface] = instance
-        return cast(T, instance)
+            self._instances[provider.interface] = instance
+        return instance
 
     def has(self, interface: AnyInterface) -> bool:
-        """Check if the scoped context has an instance of the dependency.
-
-        Args:
-            interface: The interface of the dependency.
-
-        Returns:
-            Whether the scoped context has an instance of the dependency.
-        """
+        """Check if the scoped context has an instance of the dependency."""
         return interface in self._instances
 
     def _create_instance(self, provider: Provider) -> Any:
@@ -204,16 +167,9 @@ class ResourceScopedContext(ScopedContext):
         return instance
 
     def _create_resource(self, provider: Provider) -> Any:
-        """Create a resource using the provider.
-
-        Args:
-            provider: The provider for the resource.
-
-        Returns:
-            The created resource.
-        """
-        args, kwargs = self._get_provider_arguments(provider)
-        cm = contextlib.contextmanager(provider.obj)(*args, **kwargs)
+        """Create a resource using the provider."""
+        args, kwargs = self._get_provider_params(provider)
+        cm = contextlib.contextmanager(provider.call)(*args, **kwargs)
         return self._stack.enter_context(cm)
 
     async def _acreate_instance(self, provider: Provider) -> Any:
@@ -225,32 +181,17 @@ class ResourceScopedContext(ScopedContext):
         return instance
 
     async def _acreate_resource(self, provider: Provider) -> Any:
-        """Create a resource asynchronously using the provider.
-
-        Args:
-            provider: The provider for the resource.
-
-        Returns:
-            The created resource.
-        """
-        args, kwargs = await self._aget_provider_arguments(provider)
-        cm = contextlib.asynccontextmanager(provider.obj)(*args, **kwargs)
+        """Create a resource asynchronously using the provider."""
+        args, kwargs = await self._aget_provider_params(provider)
+        cm = contextlib.asynccontextmanager(provider.call)(*args, **kwargs)
         return await self._async_stack.enter_async_context(cm)
 
     def delete(self, interface: AnyInterface) -> None:
-        """Delete a dependency instance from the scoped context.
-
-        Args:
-             interface: The interface of the dependency.
-        """
+        """Delete a dependency instance from the scoped context."""
         self._instances.pop(interface, None)
 
     def __enter__(self) -> Self:
-        """Enter the context.
-
-        Returns:
-            The scoped context.
-        """
+        """Enter the context."""
         self.start()
         return self
 
@@ -260,13 +201,7 @@ class ResourceScopedContext(ScopedContext):
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> bool:
-        """Exit the context.
-
-        Args:
-            exc_type: The type of the exception, if any.
-            exc_val: The exception instance, if any.
-            exc_tb: The traceback, if any.
-        """
+        """Exit the context."""
         return self._stack.__exit__(exc_type, exc_val, exc_tb)  # type: ignore[return-value]
 
     @abc.abstractmethod
@@ -280,11 +215,7 @@ class ResourceScopedContext(ScopedContext):
         self._stack.__exit__(None, None, None)
 
     async def __aenter__(self) -> Self:
-        """Enter the context asynchronously.
-
-        Returns:
-            The scoped context.
-        """
+        """Enter the context asynchronously."""
         await self.astart()
         return self
 
@@ -294,13 +225,7 @@ class ResourceScopedContext(ScopedContext):
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> bool:
-        """Exit the context asynchronously.
-
-        Args:
-            exc_type: The type of the exception, if any.
-            exc_val: The exception instance, if any.
-            exc_tb: The traceback, if any.
-        """
+        """Exit the context asynchronously."""
         return await run_async(
             self.__exit__, exc_type, exc_val, exc_tb
         ) or await self._async_stack.__aexit__(exc_type, exc_val, exc_tb)
@@ -358,28 +283,10 @@ class TransientContext(ScopedContext):
 
     scope = "transient"
 
-    def get(self, interface: Interface[T], provider: Provider) -> T:
-        """Get an instance of a dependency from the transient context.
-
-        Args:
-            interface: The interface of the dependency.
-            provider: The provider for the instance.
-
-        Returns:
-            An instance of the dependency.
-        """
-        instance = self._create_instance(provider)
-        return cast(T, instance)
-
-    async def aget(self, interface: Interface[T], provider: Provider) -> T:
-        """Get an async instance of a dependency from the transient context.
-
-        Args:
-            interface: The interface of the dependency.
-            provider: The provider for the instance.
+    def get(self, provider: Provider) -> Any:
+        """Get an instance of a dependency from the transient context."""
+        return self._create_instance(provider)
 
-        Returns:
-            An instance of the dependency.
-        """
-        instance = await self._acreate_instance(provider)
-        return cast(T, instance)
+    async def aget(self, provider: Provider) -> Any:
+        """Get an async instance of a dependency from the transient context."""
+        return await self._acreate_instance(provider)

anydi/_injector.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import inspect
+from collections.abc import Awaitable
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Callable, TypeVar, Union, cast
+
+from typing_extensions import ParamSpec
+
+from ._logger import logger
+from ._types import is_marker
+from ._utils import get_full_qualname, get_typed_parameters
+
+if TYPE_CHECKING:
+    from ._container import Container
+
+
+T = TypeVar("T", bound=Any)
+P = ParamSpec("P")
+
+
+class Injector:
+    def __init__(self, container: Container) -> None:
+        self.container = container
+
+    def inject(
+        self,
+        call: Callable[P, T | Awaitable[T]],
+    ) -> Callable[P, T | Awaitable[T]]:
+        # Check if the inner callable has already been wrapped
+        if hasattr(call, "__inject_wrapper__"):
+            return cast(Callable[P, Union[T, Awaitable[T]]], call.__inject_wrapper__)
+
+        injected_params = self._get_injected_params(call)
+
+        if inspect.iscoroutinefunction(call):
+
+            @wraps(call)
+            async def awrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+                for name, annotation in injected_params.items():
+                    kwargs[name] = await self.container.aresolve(annotation)
+                return cast(T, await call(*args, **kwargs))
+
+            call.__inject_wrapper__ = awrapper  # type: ignore[attr-defined]
+
+            return awrapper
+
+        @wraps(call)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+            for name, annotation in injected_params.items():
+                kwargs[name] = self.container.resolve(annotation)
+            return cast(T, call(*args, **kwargs))
+
+        call.__inject_wrapper__ = wrapper  # type: ignore[attr-defined]
+
+        return wrapper
+
+    def _get_injected_params(self, call: Callable[..., Any]) -> dict[str, Any]:
+        """Get the injected parameters of a callable object."""
+        injected_params = {}
+        for parameter in get_typed_parameters(call):
+            if not is_marker(parameter.default):
+                continue
+            try:
+                self._validate_injected_parameter(call, parameter)
+            except LookupError as exc:
+                if not self.container.strict:
+                    logger.debug(
+                        f"Cannot validate the `{get_full_qualname(call)}` parameter "
+                        f"`{parameter.name}` with an annotation of "
+                        f"`{get_full_qualname(parameter.annotation)} due to being "
+                        "in non-strict mode. It will be validated at the first call."
+                    )
+                else:
+                    raise exc
+            injected_params[parameter.name] = parameter.annotation
+        return injected_params
+
+    def _validate_injected_parameter(
+        self, call: Callable[..., Any], parameter: inspect.Parameter
+    ) -> None:
+        """Validate an injected parameter."""
+        if parameter.annotation is inspect.Parameter.empty:
+            raise TypeError(
+                f"Missing `{get_full_qualname(call)}` parameter "
+                f"`{parameter.name}` annotation."
+            )
+
+        if not self.container.is_registered(parameter.annotation):
+            raise LookupError(
+                f"`{get_full_qualname(call)}` has an unknown dependency parameter "
+                f"`{parameter.name}` with an annotation of "
+                f"`{get_full_qualname(parameter.annotation)}`."
+            )

anydi/_module.py

@@ -19,26 +19,9 @@ P = ParamSpec("P")
 
 
 class ModuleMeta(type):
-    """A metaclass used for the Module base class.
-
-    This metaclass extracts provider information from the class attributes
-    and stores it in the `providers` attribute.
-    """
+    """A metaclass used for the Module base class."""
 
     def __new__(cls, name: str, bases: tuple[type, ...], attrs: dict[str, Any]) -> Any:
-        """Create a new instance of the ModuleMeta class.
-
-        This method extracts provider information from the class attributes and
-        stores it in the `providers` attribute.
-
-        Args:
-            name: The name of the class.
-            bases: The base classes of the class.
-            attrs: The attributes of the class.
-
-        Returns:
-            The new instance of the class.
-        """
         attrs["providers"] = [
             (name, getattr(value, "__provider__"))
             for name, value in attrs.items()
@@ -53,14 +36,7 @@ class Module(metaclass=ModuleMeta):
     providers: list[tuple[str, ProviderDecoratorArgs]]
 
     def configure(self, container: Container) -> None:
-        """Configure the AnyDI container with providers and their dependencies.
-
-        This method can be overridden in derived classes to provide the
-        configuration logic.
-
-        Args:
-            container: The AnyDI container to be configured.
-        """
+        """Configure the AnyDI container with providers and their dependencies."""
 
 
 class ModuleRegistry:
@@ -70,11 +46,7 @@ class ModuleRegistry:
     def register(
         self, module: Module | type[Module] | Callable[[Container], None] | str
     ) -> None:
-        """Register a module as a callable, module type, or module instance.
-
-        Args:
-            module: The module to register.
-        """
+        """Register a module as a callable, module type, or module instance."""
 
         # Callable Module
         if inspect.isfunction(module):
@@ -107,16 +79,7 @@ class ProviderDecoratorArgs(NamedTuple):
 def provider(
     *, scope: Scope, override: bool = False
 ) -> Callable[[Callable[Concatenate[M, P], T]], Callable[Concatenate[M, P], T]]:
-    """Decorator for marking a function or method as a provider in a AnyDI module.
-
-    Args:
-        scope: The scope in which the provided instance should be managed.
-        override: Whether the provider should override existing providers
-            with the same interface.
-
-    Returns:
-        A decorator that marks the target function or method as a provider.
-    """
+    """Decorator for marking a function or method as a provider in a AnyDI module."""
 
     def decorator(
         target: Callable[Concatenate[M, P], T],