anydi 0.22.1__py3-none-any.whl → 0.37.4__py3-none-any.whl

anydi/_context.py

@@ -1,326 +1,84 @@
 from __future__ import annotations
 
-import abc
 import contextlib
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Dict, List, Tuple, Type, TypeVar, cast
+from typing import Any
 
-from typing_extensions import Self, final
+from typing_extensions import Self
 
-from ._types import AnyInterface, Interface, Provider
 from ._utils import run_async
 
-if TYPE_CHECKING:
-    from ._container import Container
 
-T = TypeVar("T")
+class InstanceContext:
+    """A context to store instances."""
 
+    __slots__ = ("_instances", "_stack", "_async_stack")
 
-class ScopedContext(abc.ABC):
-    """ScopedContext base class."""
-
-    def __init__(self, container: Container) -> None:
-        self.container = container
-
-    @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.
-        """
-
-    @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.
-
-        Returns:
-            An async instance of the dependency.
-        """
-
-    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:
-            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)
-
-    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)
-
-    def _get_provider_arguments(
-        self, provider: Provider
-    ) -> Tuple[List[Any], Dict[str, Any]]:
-        """Retrieve the arguments for a provider.
-
-        Args:
-            provider: The provider object.
-
-        Returns:
-            The arguments for the provider.
-        """
-        args, kwargs = [], {}
-        for parameter in provider.parameters.values():
-            instance = self.container.resolve(parameter.annotation)
-            if parameter.kind == parameter.POSITIONAL_ONLY:
-                args.append(instance)
-            else:
-                kwargs[parameter.name] = instance
-        return args, kwargs
-
-    async def _aget_provider_arguments(
-        self, provider: Provider
-    ) -> Tuple[List[Any], Dict[str, Any]]:
-        """Asynchronously retrieve the arguments for a provider.
-
-        Args:
-            provider: The provider object.
-
-        Returns:
-            The arguments for the provider.
-        """
-        args, kwargs = [], {}
-        for parameter in provider.parameters.values():
-            instance = await self.container.aresolve(parameter.annotation)
-            if parameter.kind == parameter.POSITIONAL_ONLY:
-                args.append(instance)
-            else:
-                kwargs[parameter.name] = instance
-        return args, kwargs
-
-
-class ResourceScopedContext(ScopedContext):
-    """ScopedContext with closable resources support."""
-
-    def __init__(self, container: Container) -> None:
-        """Initialize the ScopedContext."""
-        super().__init__(container)
-        self._instances: Dict[Type[Any], Any] = {}
+    def __init__(self) -> None:
+        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)
-        if instance is None:
-            if provider.is_generator:
-                instance = self._create_resource(provider)
-            elif provider.is_async_generator:
-                raise TypeError(
-                    f"The provider `{provider}` cannot be started in synchronous mode "
-                    "because it is an asynchronous provider. Please start the provider "
-                    "in asynchronous mode before using it."
-                )
-            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.
+    def get(self, interface: type[Any]) -> Any | None:
+        """Get an instance from the context."""
+        return self._instances.get(interface)
 
-        Args:
-            interface: The interface of the dependency.
-            provider: The provider for the instance.
+    def set(self, interface: type[Any], value: Any) -> None:
+        """Set an instance in the context."""
+        self._instances[interface] = value
 
-        Returns:
-            An async instance of the dependency.
-        """
-        instance = self._instances.get(interface)
-        if instance is None:
-            if provider.is_generator:
-                instance = await run_async(self._create_resource, provider)
-            elif provider.is_async_generator:
-                instance = await self._acreate_resource(provider)
-            else:
-                instance = await self._acreate_instance(provider)
-            self._instances[interface] = instance
-        return cast(T, 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.
-        """
-        return interface in self._instances
-
-    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)
+    def enter(self, cm: contextlib.AbstractContextManager[Any]) -> Any:
+        """Enter the context."""
         return self._stack.enter_context(cm)
 
-    async def _acreate_resource(self, provider: Provider) -> Any:
-        """Create a resource asynchronously using the provider.
+    async def aenter(self, cm: contextlib.AbstractAsyncContextManager[Any]) -> Any:
+        """Enter the context asynchronously."""
+        return await self._async_stack.enter_async_context(cm)
 
-        Args:
-            provider: The provider for the resource.
+    def __setitem__(self, interface: type[Any], value: Any) -> None:
+        self._instances[interface] = value
 
-        Returns:
-            The created resource.
-        """
-        args, kwargs = await self._aget_provider_arguments(provider)
-        cm = contextlib.asynccontextmanager(provider.obj)(*args, **kwargs)
-        return await self._async_stack.enter_async_context(cm)
+    def __getitem__(self, interface: type[Any]) -> Any:
+        return self._instances[interface]
 
-    def delete(self, interface: AnyInterface) -> None:
-        """Delete a dependency instance from the scoped context.
+    def __contains__(self, interface: type[Any]) -> bool:
+        return interface in self._instances
 
-        Args:
-             interface: The interface of the dependency.
-        """
+    def __delitem__(self, interface: type[Any]) -> None:
         self._instances.pop(interface, None)
 
     def __enter__(self) -> Self:
-        """Enter the context.
-
-        Returns:
-            The scoped context.
-        """
+        """Enter the context."""
         return self
 
     def __exit__(
         self,
-        exc_type: Type[BaseException] | None,
+        exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
-    ) -> None:
-        """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.
-        """
-        self.close()
-        return
+    ) -> Any:
+        """Exit the context."""
+        return self._stack.__exit__(exc_type, exc_val, exc_tb)
 
     def close(self) -> None:
         """Close the scoped context."""
-        self._stack.close()
+        self._stack.__exit__(None, None, None)
 
     async def __aenter__(self) -> Self:
-        """Enter the context asynchronously.
-
-        Returns:
-            The scoped context.
-        """
+        """Enter the context asynchronously."""
         return self
 
     async def __aexit__(
         self,
-        exc_type: Type[BaseException] | None,
+        exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
-    ) -> None:
-        """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.
-        """
-        await self.aclose()
-        return
+    ) -> bool:
+        """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)
 
     async def aclose(self) -> None:
         """Close the scoped context asynchronously."""
-        await run_async(self._stack.close)
-        await self._async_stack.aclose()
-
-
-@final
-class SingletonContext(ResourceScopedContext):
-    """A scoped context representing the "singleton" scope."""
-
-
-@final
-class RequestContext(ResourceScopedContext):
-    """A scoped context representing the "request" scope."""
-
-
-@final
-class TransientContext(ScopedContext):
-    """A scoped context representing the "transient" scope."""
-
-    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.
-
-        Returns:
-            An instance of the dependency.
-        """
-        instance = await self._acreate_instance(provider)
-        return cast(T, instance)
+        await self.__aexit__(None, None, None)

anydi/_provider.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+import inspect
+import uuid
+from collections.abc import AsyncIterator, Iterator
+from enum import IntEnum
+from typing import Any, Callable
+
+from typing_extensions import get_args, get_origin
+
+try:
+    from types import NoneType
+except ImportError:
+    NoneType = type(None)  # type: ignore[misc]
+
+
+from ._types import Event, Scope
+from ._utils import get_full_qualname, get_typed_annotation
+
+_sentinel = object()
+
+
+class CallableKind(IntEnum):
+    CLASS = 1
+    FUNCTION = 2
+    COROUTINE = 3
+    GENERATOR = 4
+    ASYNC_GENERATOR = 5
+
+
+class Provider:
+    __slots__ = (
+        "_call",
+        "_call_module",
+        "_call_globals",
+        "_scope",
+        "_qualname",
+        "_kind",
+        "_interface",
+        "_parameters",
+        "_is_class",
+        "_is_coroutine",
+        "_is_generator",
+        "_is_async_generator",
+        "_is_async",
+        "_is_resource",
+    )
+
+    def __init__(
+        self, call: Callable[..., Any], *, scope: Scope, interface: Any = _sentinel
+    ) -> None:
+        self._call = call
+        self._call_module = getattr(call, "__module__", None)
+        self._call_globals = getattr(call, "__globals__", {})
+        self._scope = scope
+        self._qualname = get_full_qualname(call)
+
+        # Detect the kind of callable provider
+        self._detect_kind()
+
+        self._is_class = self._kind == CallableKind.CLASS
+        self._is_coroutine = self._kind == CallableKind.COROUTINE
+        self._is_generator = self._kind == CallableKind.GENERATOR
+        self._is_async_generator = self._kind == CallableKind.ASYNC_GENERATOR
+        self._is_async = self._is_coroutine or self._is_async_generator
+        self._is_resource = self._is_generator or self._is_async_generator
+
+        # Validate the scope of the provider
+        self._validate_scope()
+
+        # Get the signature
+        signature = inspect.signature(call)
+
+        # Detect the interface
+        self._detect_interface(interface, signature)
+
+        # Detect the parameters
+        self._detect_parameters(signature)
+
+    def __str__(self) -> str:
+        return self._qualname
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Provider):
+            return NotImplemented  # pragma: no cover
+        return (
+            self._call == other._call
+            and self._scope == other._scope
+            and self._interface == other._interface
+        )
+
+    @property
+    def call(self) -> Callable[..., Any]:
+        return self._call
+
+    @property
+    def kind(self) -> CallableKind:
+        return self._kind
+
+    @property
+    def scope(self) -> Scope:
+        return self._scope
+
+    @property
+    def interface(self) -> Any:
+        return self._interface
+
+    @property
+    def parameters(self) -> list[inspect.Parameter]:
+        return self._parameters
+
+    @property
+    def is_class(self) -> bool:
+        """Check if the provider is a class."""
+        return self._is_class
+
+    @property
+    def is_coroutine(self) -> bool:
+        """Check if the provider is a coroutine."""
+        return self._is_coroutine
+
+    @property
+    def is_generator(self) -> bool:
+        """Check if the provider is a generator."""
+        return self._is_generator
+
+    @property
+    def is_async_generator(self) -> bool:
+        """Check if the provider is an async generator."""
+        return self._is_async_generator
+
+    @property
+    def is_async(self) -> bool:
+        """Check if the provider is an async callable."""
+        return self._is_async
+
+    @property
+    def is_resource(self) -> bool:
+        """Check if the provider is a resource."""
+        return self._is_resource
+
+    def _validate_scope(self) -> None:
+        """Validate the scope of the provider."""
+        if self.scope not in get_args(Scope):
+            raise ValueError(
+                "The scope provided is invalid. Only the following scopes are "
+                f"supported: {', '.join(get_args(Scope))}. Please use one of the "
+                "supported scopes when registering a provider."
+            )
+        if self.is_resource and self.scope == "transient":
+            raise TypeError(
+                f"The resource provider `{self}` is attempting to register "
+                "with a transient scope, which is not allowed."
+            )
+
+    def _detect_kind(self) -> None:
+        """Detect the kind of callable provider."""
+        if inspect.isclass(self.call):
+            self._kind = CallableKind.CLASS
+        elif inspect.iscoroutinefunction(self.call):
+            self._kind = CallableKind.COROUTINE
+        elif inspect.isasyncgenfunction(self.call):
+            self._kind = CallableKind.ASYNC_GENERATOR
+        elif inspect.isgeneratorfunction(self.call):
+            self._kind = CallableKind.GENERATOR
+        elif inspect.isfunction(self.call) or inspect.ismethod(self.call):
+            self._kind = CallableKind.FUNCTION
+        else:
+            raise TypeError(
+                f"The provider `{self.call}` is invalid because it is not a callable "
+                "object. Only callable providers are allowed."
+            )
+
+    def _detect_interface(self, interface: Any, signature: inspect.Signature) -> None:
+        """Detect the interface of callable provider."""
+        # If the callable is a class, return the class itself
+        if self._kind == CallableKind.CLASS:
+            self._interface = self._call
+            return
+
+        if interface is _sentinel:
+            interface = self._resolve_interface(interface, signature)
+
+        # If the callable is an iterator, return the actual type
+        iterator_types = {Iterator, AsyncIterator}
+        if interface in iterator_types or get_origin(interface) in iterator_types:
+            if args := get_args(interface):
+                interface = args[0]
+                # If the callable is a generator, return the resource type
+                if interface is NoneType or interface is None:
+                    self._interface = type(f"Event_{uuid.uuid4().hex}", (Event,), {})
+                    return
+            else:
+                raise TypeError(
+                    f"Cannot use `{self}` resource type annotation "
+                    "without actual type argument."
+                )
+
+        # None interface is not allowed
+        if interface in {None, NoneType}:
+            raise TypeError(f"Missing `{self}` provider return annotation.")
+
+        # Set the interface
+        self._interface = interface
+
+    def _resolve_interface(self, interface: Any, signature: inspect.Signature) -> Any:
+        """Resolve the interface of the callable provider."""
+        interface = signature.return_annotation
+        if interface is inspect.Signature.empty:
+            return None
+        return get_typed_annotation(
+            interface,
+            self._call_globals,
+            module=self._call_module,
+        )
+
+    def _detect_parameters(self, signature: inspect.Signature) -> None:
+        """Detect the parameters of the callable provider."""
+        parameters = []
+        for parameter in signature.parameters.values():
+            if parameter.kind == inspect.Parameter.POSITIONAL_ONLY:
+                raise TypeError(
+                    f"Positional-only parameter `{parameter.name}` is not allowed "
+                    f"in the provider `{self}`."
+                )
+            annotation = get_typed_annotation(
+                parameter.annotation,
+                self._call_globals,
+                module=self._call_module,
+            )
+            parameters.append(parameter.replace(annotation=annotation))
+        self._parameters = parameters