anydi 0.34.1a1__tar.gz → 0.36.0__tar.gz

{anydi-0.34.1a1 → anydi-0.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: anydi
-Version: 0.34.1a1
+Version: 0.36.0
 Summary: Dependency Injection library
 Home-page: https://github.com/antonrh/anydi
 License: MIT

{anydi-0.34.1a1 → anydi-0.36.0}/anydi/_container.py

@@ -6,6 +6,7 @@ import contextlib
 import functools
 import importlib
 import inspect
+import logging
 import pkgutil
 import threading
 import types
@@ -19,13 +20,12 @@ from weakref import WeakKeyDictionary
 from typing_extensions import Concatenate, ParamSpec, Self, final
 
 from ._context import InstanceContext
-from ._logger import logger
 from ._provider import Provider
 from ._types import (
     AnyInterface,
     Dependency,
-    DependencyWrapper,
     InjectableDecoratorArgs,
+    InstanceProxy,
     ProviderDecoratorArgs,
     Scope,
     is_event_type,
@@ -74,6 +74,7 @@ class Module(metaclass=ModuleMeta):
         """Configure the AnyDI container with providers and their dependencies."""
 
 
+# noinspection PyShadowingNames
 @final
 class Container:
     """AnyDI is a dependency injection container."""
@@ -86,8 +87,12 @@ class Container:
         | None = None,
         strict: bool = False,
         testing: bool = False,
+        logger: logging.Logger | None = None,
     ) -> None:
         self._providers: dict[type[Any], Provider] = {}
+        self._strict = strict
+        self._testing = testing
+        self._logger = logger or logging.getLogger(__name__)
         self._resources: dict[str, list[type[Any]]] = defaultdict(list)
         self._singleton_context = InstanceContext()
         self._singleton_lock = threading.RLock()
@@ -96,8 +101,6 @@ class Container:
             "request_context", default=None
         )
         self._override_instances: dict[type[Any], Any] = {}
-        self._strict = strict
-        self._testing = testing
         self._unresolved_interfaces: set[type[Any]] = set()
         self._inject_cache: WeakKeyDictionary[
             Callable[..., Any], Callable[..., Any]
@@ -106,7 +109,7 @@ class Container:
         # Register providers
         providers = providers or []
         for provider in providers:
-            self._register_provider(provider)
+            self._register_provider(provider, False)
 
         # Register modules
         modules = modules or []
@@ -128,6 +131,11 @@ class Container:
         """Get the registered providers."""
         return self._providers
 
+    @property
+    def logger(self) -> logging.Logger:
+        """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
@@ -142,10 +150,10 @@ class Container:
     ) -> Provider:
         """Register a provider for the specified interface."""
         provider = Provider(call=call, scope=scope, interface=interface)
-        return self._register_provider(provider, override=override)
+        return self._register_provider(provider, override)
 
     def _register_provider(
-        self, provider: Provider, *, override: bool = False
+        self, provider: Provider, override: bool, /, **defaults: Any
     ) -> Provider:
         """Register a provider."""
         if provider.interface in self._providers:
@@ -158,7 +166,7 @@ class Container:
                 "already registered."
             )
 
-        self._validate_sub_providers(provider)
+        self._validate_sub_providers(provider, **defaults)
         self._set_provider(provider)
         return provider
 
@@ -196,7 +204,7 @@ class Container:
             ) from exc
 
     def _get_or_register_provider(
-        self, interface: AnyInterface, parent_scope: Scope | None = None
+        self, interface: AnyInterface, parent_scope: Scope | None, /, **defaults: Any
     ) -> Provider:
         """Get or register a provider by interface."""
         try:
@@ -212,8 +220,10 @@ class Container:
                 scope = getattr(interface, "__scope__", parent_scope)
                 # Try to detect scope
                 if scope is None:
-                    scope = self._detect_scope(interface)
-                return self.register(interface, interface, scope=scope or "transient")
+                    scope = self._detect_scope(interface, **defaults)
+                scope = scope or "transient"
+                provider = Provider(call=interface, scope=scope, interface=interface)
+                return self._register_provider(provider, False, **defaults)
             raise
 
     def _set_provider(self, provider: Provider) -> None:
@@ -229,13 +239,11 @@ class Container:
         if provider.is_resource:
             self._resources[provider.scope].remove(provider.interface)
 
-    def _validate_sub_providers(self, provider: Provider) -> None:
+    def _validate_sub_providers(self, provider: Provider, /, **defaults: Any) -> None:
         """Validate the sub-providers of a provider."""
 
         for parameter in provider.parameters:
-            annotation = parameter.annotation
-
-            if annotation is inspect.Parameter.empty:
+            if parameter.annotation is inspect.Parameter.empty:
                 raise TypeError(
                     f"Missing provider `{provider}` "
                     f"dependency `{parameter.name}` annotation."
@@ -243,11 +251,10 @@ class Container:
 
             try:
                 sub_provider = self._get_or_register_provider(
-                    annotation, parent_scope=provider.scope
+                    parameter.annotation, provider.scope
                 )
             except LookupError:
-                # Skip unresolved interfaces in non-strict mode
-                if not self.strict and parameter.default is not inspect.Parameter.empty:
+                if self._parameter_has_default(parameter, **defaults):
                     continue
 
                 if provider.scope not in {"singleton", "transient"}:
@@ -255,7 +262,7 @@ class Container:
                     continue
                 raise ValueError(
                     f"The provider `{provider}` depends on `{parameter.name}` of type "
-                    f"`{get_full_qualname(annotation)}`, which "
+                    f"`{get_full_qualname(parameter.annotation)}`, which "
                     "has not been registered or set. To resolve this, ensure that "
                     f"`{parameter.name}` is registered before attempting to use it."
                 ) from None
@@ -268,15 +275,17 @@ class Container:
                     "Please ensure all providers are registered with matching scopes."
                 )
 
-    def _detect_scope(self, call: Callable[..., Any]) -> Scope | None:
+    def _detect_scope(self, call: Callable[..., Any], **defaults: Any) -> Scope | None:
         """Detect the scope for a callable."""
         scopes = set()
 
         for parameter in get_typed_parameters(call):
             try:
-                sub_provider = self._get_or_register_provider(parameter.annotation)
+                sub_provider = self._get_or_register_provider(
+                    parameter.annotation, None
+                )
             except LookupError:
-                if not self.strict and parameter.default is not inspect.Parameter.empty:
+                if self._parameter_has_default(parameter, **defaults):
                     continue
                 raise
             scope = sub_provider.scope
@@ -297,6 +306,13 @@ class Container:
 
         return None
 
+    def _parameter_has_default(
+        self, parameter: inspect.Parameter, /, **defaults: Any
+    ) -> bool:
+        return (defaults and parameter.name in defaults) or (
+            not self.strict and parameter.default is not inspect.Parameter.empty
+        )
+
     def register_module(
         self, module: Module | type[Module] | Callable[[Container], None] | str
     ) -> None:
@@ -436,9 +452,9 @@ class Container:
         if interface in self._override_instances:
             return cast(T, self._override_instances[interface])
 
-        provider = self._get_or_register_provider(interface)
+        provider = self._get_or_register_provider(interface, None)
         if provider.scope == "transient":
-            instance, created = self._create_instance(provider), True
+            instance, created = self._create_instance(provider, None), True
         else:
             context = self._get_scoped_context(provider.scope)
             if provider.scope == "singleton":
@@ -465,9 +481,9 @@ class Container:
         if interface in self._override_instances:
             return cast(T, self._override_instances[interface])
 
-        provider = self._get_or_register_provider(interface)
+        provider = self._get_or_register_provider(interface, None)
         if provider.scope == "transient":
-            instance, created = await self._acreate_instance(provider), True
+            instance, created = await self._acreate_instance(provider, None), True
         else:
             context = self._get_scoped_context(provider.scope)
             if provider.scope == "singleton":
@@ -483,15 +499,46 @@ class Container:
             self._patch_test_resolver(instance)
         return cast(T, instance)
 
+    def create(self, interface: type[T], **defaults: Any) -> T:
+        """Create an instance by interface."""
+        provider = self._get_or_register_provider(interface, None, **defaults)
+        if provider.scope == "transient":
+            instance = self._create_instance(provider, None, **defaults)
+        else:
+            context = self._get_scoped_context(provider.scope)
+            if provider.scope == "singleton":
+                with self._singleton_lock:
+                    instance = self._create_instance(provider, context, **defaults)
+            else:
+                instance = self._create_instance(provider, context, **defaults)
+        return cast(T, instance)
+
+    async def acreate(self, interface: type[T], **defaults: Any) -> T:
+        """Create an instance by interface."""
+        provider = self._get_or_register_provider(interface, None, **defaults)
+        if provider.scope == "transient":
+            instance = await self._acreate_instance(provider, None, **defaults)
+        else:
+            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
+                    )
+            else:
+                instance = await self._acreate_instance(provider, context, **defaults)
+        return cast(T, instance)
+
     def _get_or_create_instance(
         self, provider: Provider, context: InstanceContext
     ) -> tuple[Any, bool]:
         """Get an instance of a dependency from the scoped context."""
         instance = context.get(provider.interface)
         if instance is None:
-            instance = self._create_instance(provider, context=context)
-            context.set(provider.interface, instance)
-            return instance, True
+            instance = self._create_instance(provider, context)
+            if not self._override_instances:
+                context.set(provider.interface, instance)
+                return instance, True
         return instance, False
 
     async def _aget_or_create_instance(
@@ -500,15 +547,14 @@ class Container:
         """Get an async instance of a dependency from the scoped context."""
         instance = context.get(provider.interface)
         if instance is None:
-            instance = await self._acreate_instance(provider, context=context)
-            context.set(provider.interface, instance)
-            return instance, True
+            instance = await self._acreate_instance(provider, context)
+            if not self._override_instances:
+                context.set(provider.interface, instance)
+                return instance, True
         return instance, False
 
     def _create_instance(
-        self,
-        provider: Provider,
-        context: InstanceContext | None = None,
+        self, provider: Provider, context: InstanceContext | None, /, **defaults: Any
     ) -> Any:
         """Create an instance using the provider."""
         if provider.is_async:
@@ -517,29 +563,29 @@ class Container:
                 "synchronous mode."
             )
 
-        args, kwargs = self._get_provided_args(provider, context=context)
+        provider_kwargs = self._get_provided_kwargs(provider, context, **defaults)
 
         if provider.is_generator:
             if context is None:
                 raise ValueError("The context is required for generator providers.")
-            cm = contextlib.contextmanager(provider.call)(*args, **kwargs)
+            cm = contextlib.contextmanager(provider.call)(**provider_kwargs)
             return context.enter(cm)
 
-        instance = provider.call(*args, **kwargs)
+        instance = provider.call(**provider_kwargs)
         if context is not None and is_context_manager(instance):
             context.enter(instance)
         return instance
 
     async def _acreate_instance(
-        self,
-        provider: Provider,
-        context: InstanceContext | None = None,
+        self, provider: Provider, context: InstanceContext | None, /, **defaults: Any
     ) -> Any:
         """Create an instance asynchronously using the provider."""
-        args, kwargs = await self._aget_provided_args(provider, context=context)
+        provider_kwargs = await self._aget_provided_kwargs(
+            provider, context, **defaults
+        )
 
         if provider.is_coroutine:
-            instance = await provider.call(*args, **kwargs)
+            instance = await provider.call(**provider_kwargs)
             if context is not None and is_async_context_manager(instance):
                 await context.aenter(instance)
             return instance
@@ -549,7 +595,7 @@ class Container:
                 raise ValueError(
                     "The async stack is required for async generator providers."
                 )
-            cm = contextlib.asynccontextmanager(provider.call)(*args, **kwargs)
+            cm = contextlib.asynccontextmanager(provider.call)(**provider_kwargs)
             return await context.aenter(cm)
 
         if provider.is_generator:
@@ -557,83 +603,102 @@ class Container:
             def _create() -> Any:
                 if context is None:
                     raise ValueError("The stack is required for generator providers.")
-                cm = contextlib.contextmanager(provider.call)(*args, **kwargs)
+                cm = contextlib.contextmanager(provider.call)(**provider_kwargs)
                 return context.enter(cm)
 
             return await run_async(_create)
 
-        instance = await run_async(provider.call, *args, **kwargs)
+        instance = await run_async(provider.call, **provider_kwargs)
         if context is not None and is_async_context_manager(instance):
             await context.aenter(instance)
         return instance
 
-    def _get_provided_args(
+    def _get_provided_kwargs(
+        self, provider: Provider, context: InstanceContext | None, /, **defaults: Any
+    ) -> dict[str, Any]:
+        """Retrieve the arguments for a provider."""
+        provided_kwargs = {}
+        for parameter in provider.parameters:
+            instance = self._get_provider_instance(
+                provider, parameter, context, **defaults
+            )
+            provided_kwargs[parameter.name] = instance
+        return {**defaults, **provided_kwargs}
+
+    def _get_provider_instance(
         self,
         provider: Provider,
+        parameter: inspect.Parameter,
         context: InstanceContext | None,
-        *args: Any,
-        **kwargs: Any,
-    ) -> tuple[list[Any], dict[str, Any]]:
-        """Retrieve the arguments for a provider."""
-        provided_args: list[Any] = []
-        provided_kwargs: dict[str, Any] = {}
+        /,
+        **defaults: Any,
+    ) -> Any:
+        """Retrieve an instance of a dependency from the scoped context."""
+        if parameter.name in defaults:
+            return defaults[parameter.name]
 
+        # Get instance from overrides or context cache
+        if parameter.annotation in self._override_instances:
+            return self._override_instances[parameter.annotation]
+        elif context and parameter.annotation in context:
+            return context[parameter.annotation]
+
+        # Resolve the instance
+        try:
+            instance = self._resolve_parameter(provider, parameter)
+        except LookupError:
+            if parameter.default is inspect.Parameter.empty:
+                raise
+            instance = parameter.default
+
+        # Wrap the instance in a proxy for testing
+        if self.testing:
+            return InstanceProxy(interface=parameter.annotation, instance=instance)
+
+        return instance
+
+    async def _aget_provided_kwargs(
+        self, provider: Provider, context: InstanceContext | None, /, **defaults: Any
+    ) -> dict[str, Any]:
+        """Asynchronously retrieve the arguments for a provider."""
+        provided_kwargs = {}
         for parameter in provider.parameters:
-            if parameter.annotation in self._override_instances:
-                instance = self._override_instances[parameter.annotation]
-            elif context and parameter.annotation in context:
-                instance = context[parameter.annotation]
-            else:
-                try:
-                    instance = self._resolve_parameter(provider, parameter)
-                except LookupError:
-                    if parameter.default is inspect.Parameter.empty:
-                        raise
-                    instance = parameter.default
-                else:
-                    if self.testing:
-                        instance = DependencyWrapper(
-                            interface=parameter.annotation, instance=instance
-                        )
-            if parameter.kind == parameter.POSITIONAL_ONLY:
-                provided_args.append(instance)
-            else:
-                provided_kwargs[parameter.name] = instance
-        return provided_args, provided_kwargs
+            instance = await self._aget_provider_instance(
+                provider, parameter, context, **defaults
+            )
+            provided_kwargs[parameter.name] = instance
+        return {**defaults, **provided_kwargs}
 
-    async def _aget_provided_args(
+    async def _aget_provider_instance(
         self,
         provider: Provider,
+        parameter: inspect.Parameter,
         context: InstanceContext | None,
-        *args: Any,
-        **kwargs: Any,
-    ) -> tuple[list[Any], dict[str, Any]]:
-        """Asynchronously retrieve the arguments for a provider."""
-        provided_args: list[Any] = []
-        provided_kwargs: dict[str, Any] = {}
+        /,
+        **defaults: Any,
+    ) -> Any:
+        """Asynchronously retrieve an instance of a dependency from the context."""
+        if parameter.name in defaults:
+            return defaults[parameter.name]
 
-        for parameter in provider.parameters:
-            if parameter.annotation in self._override_instances:
-                instance = self._override_instances[parameter.annotation]
-            elif context and parameter.annotation in context:
-                instance = context[parameter.annotation]
-            else:
-                try:
-                    instance = await self._aresolve_parameter(provider, parameter)
-                except LookupError:
-                    if parameter.default is inspect.Parameter.empty:
-                        raise
-                    instance = parameter.default
-                else:
-                    if self.testing:
-                        instance = DependencyWrapper(
-                            interface=parameter.annotation, instance=instance
-                        )
-            if parameter.kind == parameter.POSITIONAL_ONLY:
-                provided_args.append(instance)
-            else:
-                provided_kwargs[parameter.name] = instance
-        return provided_args, provided_kwargs
+        # Get instance from overrides or context cache
+        if parameter.annotation in self._override_instances:
+            return self._override_instances[parameter.annotation]
+        elif context and parameter.annotation in context:
+            return context[parameter.annotation]
+
+        # Resolve the instance
+        try:
+            instance = await self._aresolve_parameter(provider, parameter)
+        except LookupError:
+            if parameter.default is inspect.Parameter.empty:
+                raise
+            instance = parameter.default
+
+        # Wrap the instance in a proxy for testing
+        if self.testing:
+            return InstanceProxy(interface=parameter.annotation, instance=instance)
+        return instance
 
     def _resolve_parameter(
         self, provider: Provider, parameter: inspect.Parameter
@@ -667,7 +732,7 @@ class Container:
         wrapped = {
             name: value.interface
             for name, value in instance.__dict__.items()
-            if isinstance(value, DependencyWrapper)
+            if isinstance(value, InstanceProxy)
         }
 
         # Custom resolver function
@@ -728,7 +793,7 @@ class Container:
 
         def decorator(call: Callable[P, T]) -> Callable[P, T]:
             provider = Provider(call=call, scope=scope)
-            self._register_provider(provider, override=override)
+            self._register_provider(provider, override)
             return call
 
         return decorator
@@ -790,7 +855,7 @@ class Container:
                 self._validate_injected_parameter(call, parameter)
             except LookupError as exc:
                 if not self.strict:
-                    logger.debug(
+                    self.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 "

{anydi-0.34.1a1 → anydi-0.36.0}/anydi/_provider.py

@@ -209,13 +209,17 @@ class Provider:
 
     def _detect_parameters(self, signature: inspect.Signature) -> None:
         """Detect the parameters of the callable provider."""
-        self._parameters = [
-            parameter.replace(
-                annotation=get_typed_annotation(
-                    parameter.annotation,
-                    self._call_globals,
-                    module=self._call_module,
+        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,
             )
-            for parameter in signature.parameters.values()
-        ]
+            parameters.append(parameter.replace(annotation=annotation))
+        self._parameters = parameters

{anydi-0.34.1a1 → anydi-0.36.0}/anydi/_types.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import inspect
 from collections.abc import Iterable
-from dataclasses import dataclass
 from types import ModuleType
 from typing import Annotated, Any, NamedTuple, Union
 
@@ -38,24 +37,28 @@ def is_event_type(obj: Any) -> bool:
     return inspect.isclass(obj) and issubclass(obj, Event)
 
 
-@dataclass(frozen=True)
-class DependencyWrapper:
-    interface: type[Any]
-    instance: Any
+class InstanceProxy:
+    __slots__ = ("interface", "instance")
+
+    def __init__(self, *, interface: type[Any], instance: Any):
+        self.interface = interface
+        self.instance = instance
 
     def __getattribute__(self, name: str) -> Any:
-        if name in {"interface", "instance"}:
+        if name in ("interface", "instance"):
             return object.__getattribute__(self, name)
         return getattr(self.instance, name)
 
+    def __repr__(self) -> str:
+        return f"InstanceProxy({self.interface!r})"
+
 
 class ProviderDecoratorArgs(NamedTuple):
     scope: Scope
     override: bool
 
 
-@dataclass(frozen=True)
-class Dependency:
+class Dependency(NamedTuple):
     member: Any
     module: ModuleType
 

{anydi-0.34.1a1 → anydi-0.36.0}/anydi/ext/pytest_plugin.py

@@ -6,6 +6,8 @@ from collections.abc import Iterator
 from typing import Any, Callable, cast
 
 import pytest
+from _pytest.python import async_warn_and_skip
+from anyio.pytest_plugin import extract_backend_and_options, get_runner
 
 from anydi import Container
 from anydi._utils import get_typed_parameters
@@ -113,28 +115,44 @@ def _anydi_inject(
 
 
 @pytest.fixture(autouse=True)
-async def _anydi_ainject(
+def _anydi_ainject(
     request: pytest.FixtureRequest,
     _anydi_should_inject: bool,
     _anydi_injected_parameter_iterator: Callable[[], Iterator[tuple[str, Any]]],
     _anydi_unresolved: list[str],
 ) -> None:
     """Inject dependencies into the test function."""
-    if not inspect.iscoroutinefunction(request.function) or not _anydi_should_inject:
+    if (
+        not inspect.iscoroutinefunction(request.function)
+        and not inspect.isasyncgenfunction(request.function)
+        or not _anydi_should_inject
+    ):
         return
 
-    # Setup the container
-    container = cast(Container, request.getfixturevalue("anydi_setup_container"))
+    # Skip if the anyio backend is not available
+    if "anyio_backend" not in request.fixturenames:
+        async_warn_and_skip(request.node.nodeid)
 
-    for argname, interface in _anydi_injected_parameter_iterator():
-        # Skip if the interface is not registered
-        if container.strict and not container.is_registered(interface):
-            continue
+    async def _awrapper() -> None:
+        # Setup the container
+        container = cast(Container, request.getfixturevalue("anydi_setup_container"))
 
-        try:
-            request.node.funcargs[argname] = await container.aresolve(interface)
-        except Exception as exc:
-            logger.warning(
-                f"Failed to resolve dependency for argument '{argname}'.", exc_info=exc
-            )
-            _anydi_unresolved.append(interface)
+        for argname, interface in _anydi_injected_parameter_iterator():
+            # Skip if the interface is not registered
+            if container.strict and not container.is_registered(interface):
+                continue
+
+            try:
+                request.node.funcargs[argname] = await container.aresolve(interface)
+            except Exception as exc:
+                logger.warning(
+                    f"Failed to resolve dependency for argument '{argname}'.",
+                    exc_info=exc,
+                )
+                _anydi_unresolved.append(interface)
+
+    anyio_backend = request.getfixturevalue("anyio_backend")
+    backend_name, backend_options = extract_backend_and_options(anyio_backend)
+
+    with get_runner(backend_name, backend_options) as runner:
+        runner.run_fixture(_awrapper, {})

{anydi-0.34.1a1 → anydi-0.36.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "anydi"
-version = "0.34.1a1"
+version = "0.36.0"
 description = "Dependency Injection library"
 authors = ["Anton Ruhlov <antonruhlov@gmail.com>"]
 license = "MIT"

anydi-0.34.1a1/anydi/_logger.py

@@ -1,3 +0,0 @@
-import logging
-
-logger = logging.getLogger("anydi")