anydi 0.38.1__py3-none-any.whl → 0.38.2rc0__py3-none-any.whl

anydi/__init__.py

@@ -11,8 +11,7 @@ from ._container import (
     singleton,
     transient,
 )
-from ._provider import Provider
-from ._types import Marker, Scope
+from ._types import Marker, ProviderArgs as Provider, Scope
 
 # Alias for dependency auto marker
 auto = cast(Any, Marker())

anydi/_container.py

@@ -10,23 +10,27 @@ import logging
 import pkgutil
 import threading
 import types
+import uuid
 from collections import defaultdict
 from collections.abc import AsyncIterator, Iterable, Iterator, Sequence
 from contextvars import ContextVar
 from types import ModuleType
-from typing import Any, Callable, TypeVar, Union, cast, overload
-from weakref import WeakKeyDictionary
+from typing import Any, Callable, TypeVar, Union, cast, get_origin, overload
 
-from typing_extensions import Concatenate, ParamSpec, Self, final
+from typing_extensions import Concatenate, ParamSpec, Self, final, get_args
 
 from ._context import InstanceContext
-from ._provider import Provider
 from ._types import (
+    NOT_SET,
     AnyInterface,
-    Dependency,
+    Event,
     InjectableDecoratorArgs,
     InstanceProxy,
+    Provider,
+    ProviderArgs,
     ProviderDecoratorArgs,
+    ProviderKind,
+    ScannedDependency,
     Scope,
     is_event_type,
     is_marker,
@@ -34,6 +38,7 @@ from ._types import (
 from ._utils import (
     AsyncRLock,
     get_full_qualname,
+    get_typed_annotation,
     get_typed_parameters,
     import_string,
     is_async_context_manager,
@@ -42,6 +47,12 @@ from ._utils import (
     run_async,
 )
 
+try:
+    from types import NoneType
+except ImportError:
+    NoneType = type(None)  # type: ignore[misc]
+
+
 T = TypeVar("T", bound=Any)
 M = TypeVar("M", bound="Module")
 P = ParamSpec("P")
@@ -74,7 +85,6 @@ class Module(metaclass=ModuleMeta):
         """Configure the AnyDI container with providers and their dependencies."""
 
 
-# noinspection PyShadowingNames
 @final
 class Container:
     """AnyDI is a dependency injection container."""
@@ -82,7 +92,7 @@ class Container:
     def __init__(
         self,
         *,
-        providers: Sequence[Provider] | None = None,
+        providers: Sequence[ProviderArgs] | None = None,
         modules: Sequence[Module | type[Module] | Callable[[Container], None] | str]
         | None = None,
         strict: bool = False,
@@ -104,20 +114,27 @@ class Container:
         )
         self._override_instances: dict[type[Any], Any] = {}
         self._unresolved_interfaces: set[type[Any]] = set()
-        self._inject_cache: WeakKeyDictionary[
-            Callable[..., Any], Callable[..., Any]
-        ] = WeakKeyDictionary()
+        self._inject_cache: dict[Callable[..., Any], Callable[..., Any]] = {}
 
         # Register providers
         providers = providers or []
         for provider in providers:
-            self._register_provider(provider, False)
+            _provider = self._create_provider(
+                call=provider.call,
+                scope=provider.scope,
+                interface=provider.interface,
+            )
+            self._register_provider(_provider, False)
 
         # Register modules
         modules = modules or []
         for module in modules:
             self.register_module(module)
 
+    ############################
+    # Properties
+    ############################
+
     @property
     def strict(self) -> bool:
         """Check if strict mode is enabled."""
@@ -143,9 +160,110 @@ class Container:
         """Get the logger instance."""
         return self._logger
 
-    def is_registered(self, interface: AnyInterface) -> bool:
-        """Check if a provider is registered for the specified interface."""
-        return interface in self._providers
+    ############################
+    # Lifespan/Context Methods
+    ############################
+
+    def __enter__(self) -> Self:
+        """Enter the singleton context."""
+        self.start()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: types.TracebackType | None,
+    ) -> Any:
+        """Exit the singleton context."""
+        return self._singleton_context.__exit__(exc_type, exc_val, exc_tb)
+
+    def start(self) -> None:
+        """Start the singleton context."""
+        # Resolve all singleton resources
+        for interface in self._resources.get("singleton", []):
+            self.resolve(interface)
+
+    def close(self) -> None:
+        """Close the singleton context."""
+        self._singleton_context.close()
+
+    async def __aenter__(self) -> Self:
+        """Enter the singleton context."""
+        await self.astart()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: types.TracebackType | None,
+    ) -> bool:
+        """Exit the singleton context."""
+        return await self._singleton_context.__aexit__(exc_type, exc_val, exc_tb)
+
+    async def astart(self) -> None:
+        """Start the singleton context asynchronously."""
+        for interface in self._resources.get("singleton", []):
+            await self.aresolve(interface)
+
+    async def aclose(self) -> None:
+        """Close the singleton context asynchronously."""
+        await self._singleton_context.aclose()
+
+    @contextlib.contextmanager
+    def request_context(self) -> Iterator[InstanceContext]:
+        """Obtain a context manager for the request-scoped context."""
+        context = InstanceContext()
+
+        token = self._request_context_var.set(context)
+
+        # Resolve all request resources
+        for interface in self._resources.get("request", []):
+            if not is_event_type(interface):
+                continue
+            self.resolve(interface)
+
+        with context:
+            yield context
+            self._request_context_var.reset(token)
+
+    @contextlib.asynccontextmanager
+    async def arequest_context(self) -> AsyncIterator[InstanceContext]:
+        """Obtain an async context manager for the request-scoped context."""
+        context = InstanceContext()
+
+        token = self._request_context_var.set(context)
+
+        for interface in self._resources.get("request", []):
+            if not is_event_type(interface):
+                continue
+            await self.aresolve(interface)
+
+        async with context:
+            yield context
+            self._request_context_var.reset(token)
+
+    def _get_request_context(self) -> InstanceContext:
+        """Get the current request context."""
+        request_context = self._request_context_var.get()
+        if request_context is None:
+            raise LookupError(
+                "The request context has not been started. Please ensure that "
+                "the request context is properly initialized before attempting "
+                "to use it."
+            )
+        return request_context
+
+    def _get_scoped_context(self, scope: Scope) -> InstanceContext:
+        """Get the instance context for the specified scope."""
+        if scope == "singleton":
+            return self._singleton_context
+        return self._get_request_context()
+
+    ############################
+    # Provider Methods
+    ############################
 
     def register(
         self,
@@ -156,26 +274,12 @@ class Container:
         override: bool = False,
     ) -> Provider:
         """Register a provider for the specified interface."""
-        provider = Provider(call=call, scope=scope, interface=interface)
+        provider = self._create_provider(call=call, scope=scope, interface=interface)
         return self._register_provider(provider, override)
 
-    def _register_provider(
-        self, provider: Provider, override: bool, /, **defaults: Any
-    ) -> Provider:
-        """Register a provider."""
-        if provider.interface in self._providers:
-            if override:
-                self._set_provider(provider)
-                return provider
-
-            raise LookupError(
-                f"The provider interface `{get_full_qualname(provider.interface)}` "
-                "already registered."
-            )
-
-        self._validate_sub_providers(provider, **defaults)
-        self._set_provider(provider)
-        return provider
+    def is_registered(self, interface: AnyInterface) -> bool:
+        """Check if a provider is registered for the specified interface."""
+        return interface in self._providers
 
     def unregister(self, interface: AnyInterface) -> None:
         """Unregister a provider by interface."""
@@ -199,6 +303,120 @@ class Container:
         # Cleanup provider references
         self._delete_provider(provider)
 
+    def provider(
+        self, *, scope: Scope, override: bool = False
+    ) -> Callable[[Callable[P, T]], Callable[P, T]]:
+        """Decorator to register a provider function with the specified scope."""
+
+        def decorator(call: Callable[P, T]) -> Callable[P, T]:
+            provider = self._create_provider(call=call, scope=scope)
+            self._register_provider(provider, override)
+            return call
+
+        return decorator
+
+    def _create_provider(  # noqa: C901
+        self, call: Callable[..., Any], *, scope: Scope, interface: Any = NOT_SET
+    ) -> Provider:
+        name = get_full_qualname(call)
+
+        # Detect the kind of callable provider
+        kind = ProviderKind.from_call(call)
+
+        # Validate the scope of the provider
+        if scope not in get_args(Scope):
+            raise ValueError(
+                f"The provider `{name}` scope is invalid. Only the following "
+                f"scopes are supported: {', '.join(get_args(Scope))}. "
+                "Please use one of the supported scopes when registering a provider."
+            )
+
+        # Validate the scope of the provider
+        if (
+            kind in {ProviderKind.GENERATOR, ProviderKind.ASYNC_GENERATOR}
+            and scope == "transient"
+        ):
+            raise TypeError(
+                f"The resource provider `{name}` is attempting to register "
+                "with a transient scope, which is not allowed."
+            )
+
+        # Get the signature
+        globalns = getattr(call, "__globals__", {})
+        signature = inspect.signature(call, globals=globalns)
+
+        # Detect the interface
+        if kind == ProviderKind.CLASS:
+            interface = call
+        else:
+            if interface is NOT_SET:
+                interface = signature.return_annotation
+                if interface is inspect.Signature.empty:
+                    interface = None
+                else:
+                    interface = get_typed_annotation(interface, globalns)
+
+            # 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 in {None, NoneType}:
+                        interface = type(f"Event_{uuid.uuid4().hex}", (Event,), {})
+                else:
+                    raise TypeError(
+                        f"Cannot use `{name}` resource type annotation "
+                        "without actual type argument."
+                    )
+
+            # None interface is not allowed
+            if interface in {None, NoneType}:
+                raise TypeError(f"Missing `{name}` provider return annotation.")
+
+        # Detect the parameters
+        parameters = []
+        for parameter in signature.parameters.values():
+            if parameter.annotation is inspect.Parameter.empty:
+                raise TypeError(
+                    f"Missing provider `{name}` "
+                    f"dependency `{parameter.name}` annotation."
+                )
+            if parameter.kind == inspect.Parameter.POSITIONAL_ONLY:
+                raise TypeError(
+                    "Positional-only parameters "
+                    f"are not allowed in the provider `{name}`."
+                )
+            annotation = get_typed_annotation(parameter.annotation, globalns)
+            parameters.append(parameter.replace(annotation=annotation))
+
+        return Provider(
+            call=call,
+            scope=scope,
+            interface=interface,
+            name=name,
+            kind=kind,
+            parameters=parameters,
+        )
+
+    def _register_provider(
+        self, provider: Provider, override: bool, /, **defaults: Any
+    ) -> Provider:
+        """Register a provider."""
+        if provider.interface in self._providers:
+            if override:
+                self._set_provider(provider)
+                return provider
+
+            raise LookupError(
+                f"The provider interface `{get_full_qualname(provider.interface)}` "
+                "already registered."
+            )
+
+        self._validate_sub_providers(provider, **defaults)
+        self._set_provider(provider)
+        return provider
+
     def _get_provider(self, interface: AnyInterface) -> Provider:
         """Get provider by interface."""
         try:
@@ -227,9 +445,11 @@ class Container:
                 scope = getattr(interface, "__scope__", parent_scope)
                 # Try to detect scope
                 if scope is None:
-                    scope = self._detect_scope(interface, **defaults)
+                    scope = self._detect_provider_scope(interface, **defaults)
                 scope = scope or self.default_scope
-                provider = Provider(call=interface, scope=scope, interface=interface)
+                provider = self._create_provider(
+                    call=interface, scope=scope, interface=interface
+                )
                 return self._register_provider(provider, False, **defaults)
             raise
 
@@ -250,12 +470,6 @@ class Container:
         """Validate the sub-providers of a provider."""
 
         for parameter in provider.parameters:
-            if parameter.annotation is inspect.Parameter.empty:
-                raise TypeError(
-                    f"Missing provider `{provider}` "
-                    f"dependency `{parameter.name}` annotation."
-                )
-
             try:
                 sub_provider = self._get_or_register_provider(
                     parameter.annotation, provider.scope
@@ -282,7 +496,9 @@ class Container:
                     "Please ensure all providers are registered with matching scopes."
                 )
 
-    def _detect_scope(self, call: Callable[..., Any], **defaults: Any) -> Scope | None:
+    def _detect_provider_scope(
+        self, call: Callable[..., Any], /, **defaults: Any
+    ) -> Scope | None:
         """Detect the scope for a callable."""
         scopes = set()
 
@@ -320,122 +536,56 @@ class Container:
             not self.strict and parameter.default is not inspect.Parameter.empty
         )
 
-    def register_module(
-        self, module: Module | type[Module] | Callable[[Container], None] | str
-    ) -> None:
-        """Register a module as a callable, module type, or module instance."""
-        # Callable Module
-        if inspect.isfunction(module):
-            module(self)
-            return
-
-        # Module path
-        if isinstance(module, str):
-            module = import_string(module)
-
-        # Class based Module or Module type
-        if inspect.isclass(module) and issubclass(module, Module):
-            module = module()
-
-        if isinstance(module, Module):
-            module.configure(self)
-            for provider_name, decorator_args in module.providers:
-                obj = getattr(module, provider_name)
-                self.provider(
-                    scope=decorator_args.scope,
-                    override=decorator_args.override,
-                )(obj)
-
-    def __enter__(self) -> Self:
-        """Enter the singleton context."""
-        self.start()
-        return self
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: types.TracebackType | None,
-    ) -> Any:
-        """Exit the singleton context."""
-        return self._singleton_context.__exit__(exc_type, exc_val, exc_tb)
-
-    def start(self) -> None:
-        """Start the singleton context."""
-        # Resolve all singleton resources
-        for interface in self._resources.get("singleton", []):
-            self.resolve(interface)
-
-    def close(self) -> None:
-        """Close the singleton context."""
-        self._singleton_context.close()
-
-    @contextlib.contextmanager
-    def request_context(self) -> Iterator[InstanceContext]:
-        """Obtain a context manager for the request-scoped context."""
-        context = InstanceContext()
-
-        token = self._request_context_var.set(context)
+    ############################
+    # Instance Methods
+    ############################
 
-        # Resolve all request resources
-        for interface in self._resources.get("request", []):
-            if not is_event_type(interface):
-                continue
-            self.resolve(interface)
-
-        with context:
-            yield context
-            self._request_context_var.reset(token)
+    @overload
+    def resolve(self, interface: type[T]) -> T: ...
 
-    async def __aenter__(self) -> Self:
-        """Enter the singleton context."""
-        await self.astart()
-        return self
+    @overload
+    def resolve(self, interface: T) -> T: ...
 
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc_val: BaseException | None,
-        exc_tb: types.TracebackType | None,
-    ) -> bool:
-        """Exit the singleton context."""
-        return await self._singleton_context.__aexit__(exc_type, exc_val, exc_tb)
+    def resolve(self, interface: type[T]) -> T:
+        """Resolve an instance by interface."""
+        return self._resolve_or_create(interface, False)
 
-    async def astart(self) -> None:
-        """Start the singleton context asynchronously."""
-        for interface in self._resources.get("singleton", []):
-            await self.aresolve(interface)
+    @overload
+    async def aresolve(self, interface: type[T]) -> T: ...
 
-    async def aclose(self) -> None:
-        """Close the singleton context asynchronously."""
-        await self._singleton_context.aclose()
+    @overload
+    async def aresolve(self, interface: T) -> T: ...
 
-    @contextlib.asynccontextmanager
-    async def arequest_context(self) -> AsyncIterator[InstanceContext]:
-        """Obtain an async context manager for the request-scoped context."""
-        context = InstanceContext()
+    async def aresolve(self, interface: type[T]) -> T:
+        """Resolve an instance by interface asynchronously."""
+        return await self._aresolve_or_acreate(interface, False)
 
-        token = self._request_context_var.set(context)
+    def create(self, interface: type[T], /, **defaults: Any) -> T:
+        """Create an instance by interface."""
+        return self._resolve_or_create(interface, True, **defaults)
 
-        for interface in self._resources.get("request", []):
-            if not is_event_type(interface):
-                continue
-            await self.aresolve(interface)
+    async def acreate(self, interface: type[T], /, **defaults: Any) -> T:
+        """Create an instance by interface asynchronously."""
+        return await self._aresolve_or_acreate(interface, True, **defaults)
 
-        async with context:
-            yield context
-            self._request_context_var.reset(token)
+    def is_resolved(self, interface: AnyInterface) -> bool:
+        """Check if an instance by interface exists."""
+        try:
+            provider = self._get_provider(interface)
+        except LookupError:
+            return False
+        if provider.scope == "transient":
+            return False
+        context = self._get_scoped_context(provider.scope)
+        return interface in context
 
-    def _get_request_context(self) -> InstanceContext:
-        """Get the current request context."""
-        request_context = self._request_context_var.get()
-        if request_context is None:
-            raise LookupError(
-                "The request context has not been started. Please ensure that "
-                "the request context is properly initialized before attempting "
-                "to use it."
-            )
-        return request_context
+    def release(self, interface: AnyInterface) -> None:
+        """Release an instance by interface."""
+        provider = self._get_provider(interface)
+        if provider.scope == "transient":
+            return None
+        context = self._get_scoped_context(provider.scope)
+        del context[interface]
 
     def reset(self) -> None:
         """Reset resolved instances."""
@@ -448,52 +598,10 @@ class Container:
                 continue
             del context[interface]
 
-    @overload
-    def resolve(self, interface: type[T]) -> T: ...
-
-    @overload
-    def resolve(self, interface: T) -> T: ...
-
-    def resolve(self, interface: type[T]) -> T:
-        """Resolve an instance by interface."""
-        provider = self._get_or_register_provider(interface, None)
-        if provider.scope == "transient":
-            instance = self._create_instance(provider, None)
-        else:
-            context = self._get_scoped_context(provider.scope)
-            if provider.scope == "singleton":
-                with self._singleton_lock:
-                    instance = self._get_or_create_instance(provider, context)
-            else:
-                instance = self._get_or_create_instance(provider, context)
-        if self.testing:
-            instance = self._patch_test_resolver(provider.interface, instance)
-        return cast(T, instance)
-
-    @overload
-    async def aresolve(self, interface: type[T]) -> T: ...
-
-    @overload
-    async def aresolve(self, interface: T) -> T: ...
-
-    async def aresolve(self, interface: type[T]) -> T:
-        """Resolve an instance by interface asynchronously."""
-        provider = self._get_or_register_provider(interface, None)
-        if provider.scope == "transient":
-            instance = await self._acreate_instance(provider, None)
-        else:
-            context = self._get_scoped_context(provider.scope)
-            if provider.scope == "singleton":
-                async with self._singleton_async_lock:
-                    instance = await self._aget_or_create_instance(provider, context)
-            else:
-                instance = await self._aget_or_create_instance(provider, context)
-        if self.testing:
-            instance = self._patch_test_resolver(interface, instance)
-        return cast(T, instance)
-
-    def create(self, interface: type[T], **defaults: Any) -> T:
-        """Create an instance by interface."""
+    def _resolve_or_create(
+        self, interface: type[T], create: bool, /, **defaults: Any
+    ) -> T:
+        """Internal method to handle instance resolution and creation."""
         provider = self._get_or_register_provider(interface, None, **defaults)
         if provider.scope == "transient":
             instance = self._create_instance(provider, None, **defaults)
@@ -501,15 +609,27 @@ class Container:
             context = self._get_scoped_context(provider.scope)
             if provider.scope == "singleton":
                 with self._singleton_lock:
-                    instance = self._create_instance(provider, context, **defaults)
+                    instance = (
+                        self._get_or_create_instance(provider, context)
+                        if not create
+                        else self._create_instance(provider, context, **defaults)
+                    )
             else:
-                instance = self._create_instance(provider, context, **defaults)
+                instance = (
+                    self._get_or_create_instance(provider, context)
+                    if not create
+                    else self._create_instance(provider, context, **defaults)
+                )
+
         if self.testing:
             instance = self._patch_test_resolver(provider.interface, instance)
+
         return cast(T, instance)
 
-    async def acreate(self, interface: type[T], **defaults: Any) -> T:
-        """Create an instance by interface."""
+    async def _aresolve_or_acreate(
+        self, interface: type[T], create: bool, /, **defaults: Any
+    ) -> T:
+        """Internal method to handle instance resolution and creation asynchronously."""
         provider = self._get_or_register_provider(interface, None, **defaults)
         if provider.scope == "transient":
             instance = await self._acreate_instance(provider, None, **defaults)
@@ -517,13 +637,21 @@ class Container:
             context = self._get_scoped_context(provider.scope)
             if provider.scope == "singleton":
                 async with self._singleton_async_lock:
-                    instance = await self._acreate_instance(
-                        provider, context, **defaults
+                    instance = (
+                        await self._aget_or_create_instance(provider, context)
+                        if not create
+                        else await self._acreate_instance(provider, context, **defaults)
                     )
             else:
-                instance = await self._acreate_instance(provider, context, **defaults)
+                instance = (
+                    await self._aget_or_create_instance(provider, context)
+                    if not create
+                    else await self._acreate_instance(provider, context, **defaults)
+                )
+
         if self.testing:
             instance = self._patch_test_resolver(provider.interface, instance)
+
         return cast(T, instance)
 
     def _get_or_create_instance(
@@ -700,26 +828,48 @@ class Container:
     def _resolve_parameter(
         self, provider: Provider, parameter: inspect.Parameter
     ) -> Any:
-        self._validate_resolvable_parameter(parameter, call=provider.call)
+        self._validate_resolvable_parameter(provider, parameter)
         return self.resolve(parameter.annotation)
 
     async def _aresolve_parameter(
         self, provider: Provider, parameter: inspect.Parameter
     ) -> Any:
-        self._validate_resolvable_parameter(parameter, call=provider.call)
+        self._validate_resolvable_parameter(provider, parameter)
         return await self.aresolve(parameter.annotation)
 
     def _validate_resolvable_parameter(
-        self, parameter: inspect.Parameter, call: Callable[..., Any]
+        self, provider: Provider, parameter: inspect.Parameter
     ) -> None:
         """Ensure that the specified interface is resolved."""
         if parameter.annotation in self._unresolved_interfaces:
             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."
+                f"dependency into `{get_full_qualname(provider.call)}` which is "
+                "not registered or set in the scoped context."
+            )
+
+    @contextlib.contextmanager
+    def override(self, interface: AnyInterface, instance: Any) -> Iterator[None]:
+        """
+        Override the provider for the specified interface with a specific instance.
+        """
+        if not self.testing:
+            raise RuntimeError(
+                "The `override` method can only be used in testing mode."
             )
+        if not self.is_registered(interface) and self.strict:
+            raise LookupError(
+                f"The provider interface `{get_full_qualname(interface)}` "
+                "not registered."
+            )
+        self._override_instances[interface] = instance
+        yield
+        del self._override_instances[interface]
+
+    ############################
+    # Testing Methods
+    ############################
 
     def _patch_test_resolver(self, interface: type[Any], instance: Any) -> Any:
         """Patch the test resolver for the instance."""
@@ -769,60 +919,9 @@ class Container:
 
         return instance
 
-    def is_resolved(self, interface: AnyInterface) -> bool:
-        """Check if an instance by interface exists."""
-        try:
-            provider = self._get_provider(interface)
-        except LookupError:
-            return False
-        if provider.scope == "transient":
-            return False
-        context = self._get_scoped_context(provider.scope)
-        return interface in context
-
-    def release(self, interface: AnyInterface) -> None:
-        """Release an instance by interface."""
-        provider = self._get_provider(interface)
-        if provider.scope == "transient":
-            return None
-        context = self._get_scoped_context(provider.scope)
-        del context[interface]
-
-    def _get_scoped_context(self, scope: Scope) -> InstanceContext:
-        """Get the instance context for the specified scope."""
-        if scope == "singleton":
-            return self._singleton_context
-        return self._get_request_context()
-
-    @contextlib.contextmanager
-    def override(self, interface: AnyInterface, instance: Any) -> Iterator[None]:
-        """
-        Override the provider for the specified interface with a specific instance.
-        """
-        if not self.testing:
-            raise RuntimeError(
-                "The `override` method can only be used in testing mode."
-            )
-        if not self.is_registered(interface) and self.strict:
-            raise LookupError(
-                f"The provider interface `{get_full_qualname(interface)}` "
-                "not registered."
-            )
-        self._override_instances[interface] = instance
-        yield
-        del self._override_instances[interface]
-
-    def provider(
-        self, *, scope: Scope, override: bool = False
-    ) -> Callable[[Callable[P, T]], Callable[P, T]]:
-        """Decorator to register a provider function with the specified scope."""
-
-        def decorator(call: Callable[P, T]) -> Callable[P, T]:
-            provider = Provider(call=call, scope=scope)
-            self._register_provider(provider, override)
-            return call
-
-        return decorator
+    ############################
+    # Injector Methods
+    ############################
 
     @overload
     def inject(self, func: Callable[P, T]) -> Callable[P, T]: ...
@@ -842,6 +941,10 @@ class Container:
             return decorator
         return decorator(func)
 
+    def run(self, func: Callable[P, T], /, *args: P.args, **kwargs: P.kwargs) -> T:
+        """Run the given function with injected dependencies."""
+        return self._inject(func)(*args, **kwargs)
+
     def _inject(self, call: Callable[P, T]) -> Callable[P, T]:
         """Inject dependencies into a callable."""
         if call in self._inject_cache:
@@ -909,9 +1012,39 @@ class Container:
                 f"`{get_full_qualname(parameter.annotation)}`."
             )
 
-    def run(self, func: Callable[P, T], /, *args: P.args, **kwargs: P.kwargs) -> T:
-        """Run the given function with injected dependencies."""
-        return self._inject(func)(*args, **kwargs)
+    ############################
+    # Module Methods
+    ############################
+
+    def register_module(
+        self, module: Module | type[Module] | Callable[[Container], None] | str
+    ) -> None:
+        """Register a module as a callable, module type, or module instance."""
+        # Callable Module
+        if inspect.isfunction(module):
+            module(self)
+            return
+
+        # Module path
+        if isinstance(module, str):
+            module = import_string(module)
+
+        # Class based Module or Module type
+        if inspect.isclass(module) and issubclass(module, Module):
+            module = module()
+
+        if isinstance(module, Module):
+            module.configure(self)
+            for provider_name, decorator_args in module.providers:
+                obj = getattr(module, provider_name)
+                self.provider(
+                    scope=decorator_args.scope,
+                    override=decorator_args.override,
+                )(obj)
+
+    ############################
+    # Scanner Methods
+    ############################
 
     def scan(
         self,
@@ -921,7 +1054,7 @@ class Container:
         tags: Iterable[str] | None = None,
     ) -> None:
         """Scan packages or modules for decorated members and inject dependencies."""
-        dependencies: list[Dependency] = []
+        dependencies: list[ScannedDependency] = []
 
         if isinstance(packages, Iterable) and not isinstance(packages, str):
             scan_packages: Iterable[ModuleType | str] = packages
@@ -940,7 +1073,7 @@ class Container:
         package: ModuleType | str,
         *,
         tags: Iterable[str] | None = None,
-    ) -> list[Dependency]:
+    ) -> list[ScannedDependency]:
         """Scan a package or module for decorated members."""
         tags = tags or []
         if isinstance(package, str):
@@ -951,7 +1084,7 @@ class Container:
         if not package_path:
             return self._scan_module(package, tags=tags)
 
-        dependencies: list[Dependency] = []
+        dependencies: list[ScannedDependency] = []
 
         for module_info in pkgutil.walk_packages(
             path=package_path, prefix=package.__name__ + "."
@@ -963,9 +1096,9 @@ class Container:
 
     def _scan_module(
         self, module: ModuleType, *, tags: Iterable[str]
-    ) -> list[Dependency]:
+    ) -> list[ScannedDependency]:
         """Scan a module for decorated members."""
-        dependencies: list[Dependency] = []
+        dependencies: list[ScannedDependency] = []
 
         for _, member in inspect.getmembers(module):
             if getattr(member, "__module__", None) != module.__name__ or not callable(
@@ -988,7 +1121,7 @@ class Container:
 
             if decorator_args.wrapped:
                 dependencies.append(
-                    self._create_dependency(member=member, module=module)
+                    self._create_scanned_dependency(member=member, module=module)
                 )
                 continue
 
@@ -996,17 +1129,24 @@ class Container:
             for parameter in get_typed_parameters(member):
                 if is_marker(parameter.default):
                     dependencies.append(
-                        self._create_dependency(member=member, module=module)
+                        self._create_scanned_dependency(member=member, module=module)
                     )
                     continue
 
         return dependencies
 
-    def _create_dependency(self, member: Any, module: ModuleType) -> Dependency:
+    def _create_scanned_dependency(
+        self, member: Any, module: ModuleType
+    ) -> ScannedDependency:
         """Create a `Dependency` object from the scanned member and module."""
         if hasattr(member, "__wrapped__"):
             member = member.__wrapped__
-        return Dependency(member=member, module=module)
+        return ScannedDependency(member=member, module=module)
+
+
+############################
+# Decorators
+############################
 
 
 def transient(target: T) -> T:

anydi/_types.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
+import enum
 import inspect
 from collections.abc import Iterable
+from dataclasses import dataclass
+from functools import cached_property
 from types import ModuleType
-from typing import Annotated, Any, NamedTuple, Union
+from typing import Annotated, Any, Callable, NamedTuple, Union
 
 import wrapt
 from typing_extensions import Literal, Self, TypeAlias
@@ -12,6 +15,8 @@ Scope = Literal["transient", "singleton", "request"]
 
 AnyInterface: TypeAlias = Union[type[Any], Annotated[Any, ...]]
 
+NOT_SET = object()
+
 
 class Marker:
     """A marker class for marking dependencies."""
@@ -53,12 +58,85 @@ class InstanceProxy(wrapt.ObjectProxy):  # type: ignore[misc]
         return object.__getattribute__(self, item)
 
 
+class ProviderKind(enum.IntEnum):
+    CLASS = 1
+    FUNCTION = 2
+    COROUTINE = 3
+    GENERATOR = 4
+    ASYNC_GENERATOR = 5
+
+    @classmethod
+    def from_call(cls, call: Callable[..., Any]) -> ProviderKind:
+        if inspect.isclass(call):
+            return cls.CLASS
+        elif inspect.iscoroutinefunction(call):
+            return cls.COROUTINE
+        elif inspect.isasyncgenfunction(call):
+            return cls.ASYNC_GENERATOR
+        elif inspect.isgeneratorfunction(call):
+            return cls.GENERATOR
+        elif inspect.isfunction(call) or inspect.ismethod(call):
+            return cls.FUNCTION
+        raise TypeError(
+            f"The provider `{call}` is invalid because it is not a callable "
+            "object. Only callable providers are allowed."
+        )
+
+
+@dataclass(kw_only=True, frozen=True)
+class ProviderParameter:
+    pass
+
+
+@dataclass(kw_only=True, frozen=True)
+class Provider:
+    call: Callable[..., Any]
+    scope: Scope
+    interface: Any
+    name: str
+    parameters: list[inspect.Parameter]
+    kind: ProviderKind
+
+    def __str__(self) -> str:
+        return self.name
+
+    @cached_property
+    def is_class(self) -> bool:
+        return self.kind == ProviderKind.CLASS
+
+    @cached_property
+    def is_coroutine(self) -> bool:
+        return self.kind == ProviderKind.COROUTINE
+
+    @cached_property
+    def is_generator(self) -> bool:
+        return self.kind == ProviderKind.GENERATOR
+
+    @cached_property
+    def is_async_generator(self) -> bool:
+        return self.kind == ProviderKind.ASYNC_GENERATOR
+
+    @cached_property
+    def is_async(self) -> bool:
+        return self.is_coroutine or self.is_async_generator
+
+    @cached_property
+    def is_resource(self) -> bool:
+        return self.is_generator or self.is_async_generator
+
+
+class ProviderArgs(NamedTuple):
+    call: Callable[..., Any]
+    scope: Scope
+    interface: Any | None = None
+
+
 class ProviderDecoratorArgs(NamedTuple):
     scope: Scope
     override: bool
 
 
-class Dependency(NamedTuple):
+class ScannedDependency(NamedTuple):
     member: Any
     module: ModuleType
 

anydi/ext/pytest_plugin.py

@@ -35,11 +35,9 @@ CONTAINER_FIXTURE_NAME = "container"
 
 
 @pytest.fixture
-def anydi_setup_container(
-    request: pytest.FixtureRequest,
-) -> Iterator[Container]:
+def anydi_setup_container(request: pytest.FixtureRequest) -> Container:
     try:
-        container = request.getfixturevalue(CONTAINER_FIXTURE_NAME)
+        return cast(Container, request.getfixturevalue(CONTAINER_FIXTURE_NAME))
     except pytest.FixtureLookupError as exc:
         exc.msg = (
             "`container` fixture is not found. Make sure to define it in your test "
@@ -47,8 +45,6 @@ def anydi_setup_container(
         )
         raise exc
 
-    yield container
-
 
 @pytest.fixture
 def _anydi_should_inject(request: pytest.FixtureRequest) -> bool:

{anydi-0.38.1.dist-info → anydi-0.38.2rc0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anydi
-Version: 0.38.1
+Version: 0.38.2rc0
 Summary: Dependency Injection library
 Project-URL: Repository, https://github.com/antonrh/anydi
 Author-email: Anton Ruhlov <antonruhlov@gmail.com>

{anydi-0.38.1.dist-info → anydi-0.38.2rc0.dist-info}/RECORD

@@ -1,8 +1,7 @@
-anydi/__init__.py,sha256=OfRg2EfXD65pHTGQKhfkABMwUhw5LvsuTQV_Tv4V4wk,501
-anydi/_container.py,sha256=b2WKdDLwLj50u0DUOdAku2oYOKpw3UD7rCuytu2x_R4,38732
+anydi/__init__.py,sha256=aAq10a1V_zQ3_Me3p_pll5d1O77PIgqotkOm3pshORI,495
+anydi/_container.py,sha256=BqpvUPeYt6OW7TLIDm-OvMGCbcxnvXA6KyOF9XBmi7M,43072
 anydi/_context.py,sha256=7LV_SL4QWkJeiG7_4D9PZ5lmU-MPzhofxC95zCgY9Gc,2651
-anydi/_provider.py,sha256=1IyxHO83NHjsPDHLDIZtW1pJ7i8VpWD3EM4T6duw9zA,7661
-anydi/_types.py,sha256=fdO4xNXtGMxVArmlfDkFYbyR895ixkBTW6V8lMceN7Q,1562
+anydi/_types.py,sha256=oFyx6jxkEsz5FZk6tdRjUmBBQ2tX7eA_bLaa2elq7Mg,3586
 anydi/_utils.py,sha256=INI0jNIXrJ6LS4zqJymMO2yUEobpxmBGASf4G_vR6AU,4378
 anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -10,7 +9,7 @@ anydi/ext/_utils.py,sha256=U6sRqWzccWUu7eMhbXX1NrwcaxitQF9cO1KxnKF37gw,2566
 anydi/ext/fastapi.py,sha256=AEL3ubu-LxUPHMMt1YIn3En_JZC7nyBKmKxmhka3O3c,2436
 anydi/ext/faststream.py,sha256=qXnNGvAqWWp9kbhbQUE6EF_OPUiYQmtOH211_O7BI_0,1898
 anydi/ext/pydantic_settings.py,sha256=8IXXLuG_OvKbvKlBkBRQUHcXgbTpgQUxeWyoMcRIUQM,1488
-anydi/ext/pytest_plugin.py,sha256=25A93Yon0cr4y8CszQB7zOJRiAXW-ZwtO7_Ji8mqcXs,4639
+anydi/ext/pytest_plugin.py,sha256=yR_vos8qt8uFS9uy_G_HJjNgudzJIXawrtpWnn3Pu_s,4613
 anydi/ext/django/__init__.py,sha256=QI1IABCVgSDTUoh7M9WMECKXwB3xvh04HfQ9TOWw1Mk,223
 anydi/ext/django/_container.py,sha256=cxVoYQG16WP0S_Yv4TnLwuaaT7NVEOhLWO-YdALJUb4,418
 anydi/ext/django/_settings.py,sha256=Z0RlAuXoO73oahWeMkK10w8c-4uCBde-DBpeKTV5USY,853
@@ -22,8 +21,8 @@ anydi/ext/django/ninja/_operation.py,sha256=wSWa7D73XTVlOibmOciv2l6JHPe1ERZcXrqI
 anydi/ext/django/ninja/_signature.py,sha256=2cSzKxBIxXLqtwNuH6GSlmjVJFftoGmleWfyk_NVEWw,2207
 anydi/ext/starlette/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/ext/starlette/middleware.py,sha256=9CQtGg5ZzUz2gFSzJr8U4BWzwNjK8XMctm3n52M77Z0,792
-anydi-0.38.1.dist-info/METADATA,sha256=_DWptDh85lW1UwzL1AnIaCiB9THnpeaCI4AlupFYjG0,4917
-anydi-0.38.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-anydi-0.38.1.dist-info/entry_points.txt,sha256=Nklo9f3Oe4AkNsEgC4g43nCJ-23QDngZSVDNRMdaILI,43
-anydi-0.38.1.dist-info/licenses/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
-anydi-0.38.1.dist-info/RECORD,,
+anydi-0.38.2rc0.dist-info/METADATA,sha256=t8FL1ILCUK37XUFQ_gqgAlwX77UytT5FeP4QueIDX50,4920
+anydi-0.38.2rc0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+anydi-0.38.2rc0.dist-info/entry_points.txt,sha256=Nklo9f3Oe4AkNsEgC4g43nCJ-23QDngZSVDNRMdaILI,43
+anydi-0.38.2rc0.dist-info/licenses/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
+anydi-0.38.2rc0.dist-info/RECORD,,

anydi/_provider.py

@@ -1,232 +0,0 @@
-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