anydi 0.32.2__tar.gz → 0.33.0__tar.gz

{anydi-0.32.2 → anydi-0.33.0}/PKG-INFO

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

{anydi-0.32.2 → anydi-0.33.0}/anydi/_container.py

@@ -3,12 +3,14 @@
 from __future__ import annotations
 
 import contextlib
+import functools
 import inspect
 import types
 from collections import defaultdict
-from collections.abc import AsyncIterator, Awaitable, Iterable, Iterator, Sequence
+from collections.abc import AsyncIterator, Iterable, Iterator, Sequence
 from contextvars import ContextVar
 from typing import Any, Callable, TypeVar, cast, overload
+from weakref import WeakKeyDictionary
 
 from typing_extensions import ParamSpec, Self, final
 
@@ -19,11 +21,11 @@ from ._context import (
     SingletonContext,
     TransientContext,
 )
-from ._injector import Injector
+from ._logger import logger
 from ._module import Module, ModuleRegistry
 from ._provider import Provider
 from ._scanner import Scanner
-from ._types import AnyInterface, Interface, Scope
+from ._types import AnyInterface, Interface, Scope, TestInterface, is_marker
 from ._utils import get_full_qualname, get_typed_parameters, is_builtin_type
 
 T = TypeVar("T", bound=Any)
@@ -47,6 +49,7 @@ class Container:
         modules: Sequence[Module | type[Module] | Callable[[Container], None] | str]
         | None = None,
         strict: bool = False,
+        testing: bool = False,
     ) -> None:
         self._providers: dict[type[Any], Provider] = {}
         self._resource_cache: dict[Scope, list[type[Any]]] = defaultdict(list)
@@ -57,10 +60,13 @@ class Container:
         )
         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]
+        ] = WeakKeyDictionary()
 
         # Components
-        self._injector = Injector(self)
         self._modules = ModuleRegistry(self)
         self._scanner = Scanner(self)
 
@@ -79,6 +85,11 @@ class Container:
         """Check if strict mode is enabled."""
         return self._strict
 
+    @property
+    def testing(self) -> bool:
+        """Check if testing mode is enabled."""
+        return self._testing
+
     @property
     def providers(self) -> dict[type[Any], Provider]:
         """Get the registered providers."""
@@ -202,6 +213,10 @@ class Container:
                     annotation, parent_scope=provider.scope
                 )
             except LookupError:
+                # Skip unresolved interfaces in non-strict mode
+                if not self.strict and parameter.default is not inspect.Parameter.empty:
+                    continue
+
                 if provider.scope not in {"singleton", "transient"}:
                     self._unresolved_interfaces.add(provider.interface)
                     continue
@@ -225,7 +240,12 @@ class Container:
         scopes = set()
 
         for parameter in get_typed_parameters(call):
-            sub_provider = self._get_or_register_provider(parameter.annotation)
+            try:
+                sub_provider = self._get_or_register_provider(parameter.annotation)
+            except LookupError:
+                if not self.strict and parameter.default is not inspect.Parameter.empty:
+                    continue
+                raise
             scope = sub_provider.scope
 
             if scope == "transient":
@@ -234,7 +254,7 @@ class Container:
 
             # If all scopes are found, we can return based on priority order
             if {"transient", "request", "singleton"}.issubset(scopes):
-                break
+                break  # pragma: no cover
 
         # Determine scope based on priority
         if "request" in scopes:
@@ -346,7 +366,32 @@ class Container:
 
         provider = self._get_or_register_provider(interface)
         scoped_context = self._get_scoped_context(provider.scope)
-        return cast(T, scoped_context.get(provider))
+        instance, created = scoped_context.get_or_create(provider)
+        if self.testing and created:
+            self._patch_test_resolver(instance)
+        return cast(T, instance)
+
+    def _patch_test_resolver(self, instance: Any) -> None:
+        """Patch the test resolver for the instance."""
+
+        def _resolver(_self: Any, _name: str) -> Any:
+            try:
+                test_interfaces = object.__getattribute__(_self, "__test_interfaces__")
+            except AttributeError:
+                test_interfaces = {
+                    name: value.interface
+                    for name, value in object.__getattribute__(
+                        _self, "__dict__"
+                    ).items()
+                    if isinstance(value, TestInterface)
+                }
+                object.__setattr__(_self, "__test_interfaces__", test_interfaces)
+            if _name in test_interfaces:
+                return self.resolve(test_interfaces[_name])
+            return object.__getattribute__(_self, _name)
+
+        if hasattr(instance, "__class__") and not is_builtin_type(instance.__class__):
+            instance.__class__.__getattribute__ = _resolver
 
     @overload
     async def aresolve(self, interface: Interface[T]) -> T: ...
@@ -361,7 +406,10 @@ class Container:
 
         provider = self._get_or_register_provider(interface)
         scoped_context = self._get_scoped_context(provider.scope)
-        return cast(T, await scoped_context.aget(provider))
+        instance, created = await scoped_context.aget_or_create(provider)
+        if self.testing and created:
+            self._patch_test_resolver(instance)
+        return cast(T, instance)
 
     def is_resolved(self, interface: AnyInterface) -> bool:
         """Check if an instance by interface exists."""
@@ -424,25 +472,92 @@ class Container:
     def inject(self) -> Callable[[Callable[P, T]], Callable[P, T]]: ...
 
     def inject(
-        self, func: Callable[P, T | Awaitable[T]] | None = None
-    ) -> (
-        Callable[[Callable[P, T | Awaitable[T]]], Callable[P, T | Awaitable[T]]]
-        | Callable[P, T | Awaitable[T]]
-    ):
+        self, func: Callable[P, T] | None = None
+    ) -> Callable[[Callable[P, T]], Callable[P, T]] | Callable[P, T]:
         """Decorator to inject dependencies into a callable."""
 
         def decorator(
-            inner: Callable[P, T | Awaitable[T]],
-        ) -> Callable[P, T | Awaitable[T]]:
-            return self._injector.inject(inner)
+            call: Callable[P, T],
+        ) -> Callable[P, T]:
+            return self._inject(call)
 
         if func is None:
             return decorator
         return decorator(func)
 
+    def _inject(
+        self,
+        call: Callable[P, T],
+    ) -> Callable[P, T]:
+        """Inject dependencies into a callable."""
+        if call in self._inject_cache:
+            return cast(Callable[P, T], self._inject_cache[call])
+
+        injected_params = self._get_injected_params(call)
+
+        if inspect.iscoroutinefunction(call):
+
+            @functools.wraps(call)
+            async def awrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+                for name, annotation in injected_params.items():
+                    kwargs[name] = await self.aresolve(annotation)
+                return cast(T, await call(*args, **kwargs))
+
+            self._inject_cache[call] = awrapper
+
+            return awrapper  # type: ignore[return-value]
+
+        @functools.wraps(call)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+            for name, annotation in injected_params.items():
+                kwargs[name] = self.resolve(annotation)
+            return call(*args, **kwargs)
+
+        self._inject_cache[call] = wrapper
+
+        return wrapper
+
+    def _get_injected_params(self, call: Callable[..., Any]) -> dict[str, Any]:
+        """Get the injected parameters of a callable object."""
+        injected_params = {}
+        for parameter in get_typed_parameters(call):
+            if not is_marker(parameter.default):
+                continue
+            try:
+                self._validate_injected_parameter(call, parameter)
+            except LookupError as exc:
+                if not self.strict:
+                    logger.debug(
+                        f"Cannot validate the `{get_full_qualname(call)}` parameter "
+                        f"`{parameter.name}` with an annotation of "
+                        f"`{get_full_qualname(parameter.annotation)} due to being "
+                        "in non-strict mode. It will be validated at the first call."
+                    )
+                else:
+                    raise exc
+            injected_params[parameter.name] = parameter.annotation
+        return injected_params
+
+    def _validate_injected_parameter(
+        self, call: Callable[..., Any], parameter: inspect.Parameter
+    ) -> None:
+        """Validate an injected parameter."""
+        if parameter.annotation is inspect.Parameter.empty:
+            raise TypeError(
+                f"Missing `{get_full_qualname(call)}` parameter "
+                f"`{parameter.name}` annotation."
+            )
+
+        if not self.is_registered(parameter.annotation):
+            raise LookupError(
+                f"`{get_full_qualname(call)}` has an unknown dependency parameter "
+                f"`{parameter.name}` with an annotation of "
+                f"`{get_full_qualname(parameter.annotation)}`."
+            )
+
     def run(self, func: Callable[P, T], /, *args: P.args, **kwargs: P.kwargs) -> T:
         """Run the given function with injected dependencies."""
-        return cast(T, self._injector.inject(func)(*args, **kwargs))
+        return self._inject(func)(*args, **kwargs)
 
     def scan(
         self,

{anydi-0.32.2 → anydi-0.33.0}/anydi/_context.py

@@ -9,7 +9,7 @@ from typing import TYPE_CHECKING, Any, Callable, ClassVar
 from typing_extensions import Self, final
 
 from ._provider import CallableKind, Provider
-from ._types import AnyInterface, Scope, is_event_type
+from ._types import AnyInterface, Scope, TestInterface, is_event_type
 from ._utils import get_full_qualname, run_async
 
 if TYPE_CHECKING:
@@ -30,12 +30,12 @@ class ScopedContext(abc.ABC):
         self._instances[interface] = instance
 
     @abc.abstractmethod
-    def get(self, provider: Provider) -> Any:
-        """Get an instance of a dependency from the scoped context."""
+    def get_or_create(self, provider: Provider) -> tuple[Any, bool]:
+        """Get or create an instance of a dependency from the scoped context."""
 
     @abc.abstractmethod
-    async def aget(self, provider: Provider) -> Any:
-        """Get an async instance of a dependency from the scoped context."""
+    async def aget_or_create(self, provider: Provider) -> tuple[Any, bool]:
+        """Get or create an async instance of a dependency from the scoped context."""
 
     def _create_instance(self, provider: Provider) -> Any:
         """Create an instance using the provider."""
@@ -44,12 +44,12 @@ class ScopedContext(abc.ABC):
                 f"The instance for the coroutine provider `{provider}` cannot be "
                 "created in synchronous mode."
             )
-        args, kwargs = self._get_provider_params(provider)
+        args, kwargs = self._get_provided_args(provider)
         return provider.call(*args, **kwargs)
 
     async def _acreate_instance(self, provider: Provider) -> Any:
         """Create an instance asynchronously using the provider."""
-        args, kwargs = await self._aget_provider_params(provider)
+        args, kwargs = await self._aget_provided_args(provider)
         if provider.kind == CallableKind.COROUTINE:
             return await provider.call(*args, **kwargs)
         return await run_async(provider.call, *args, **kwargs)
@@ -78,7 +78,7 @@ class ScopedContext(abc.ABC):
                 "or set in the scoped context."
             )
 
-    def _get_provider_params(
+    def _get_provided_args(
         self, provider: Provider
     ) -> tuple[list[Any], dict[str, Any]]:
         """Retrieve the arguments for a provider."""
@@ -91,14 +91,22 @@ class ScopedContext(abc.ABC):
             elif parameter.annotation in self._instances:
                 instance = self._instances[parameter.annotation]
             else:
-                instance = self._resolve_parameter(provider, parameter)
+                try:
+                    instance = self._resolve_parameter(provider, parameter)
+                except LookupError:
+                    if parameter.default is inspect.Parameter.empty:
+                        raise
+                    instance = parameter.default
+                else:
+                    if self.container.testing:
+                        instance = TestInterface(interface=parameter.annotation)
             if parameter.kind == parameter.POSITIONAL_ONLY:
                 args.append(instance)
             else:
                 kwargs[parameter.name] = instance
         return args, kwargs
 
-    async def _aget_provider_params(
+    async def _aget_provided_args(
         self, provider: Provider
     ) -> tuple[list[Any], dict[str, Any]]:
         """Asynchronously retrieve the arguments for a provider."""
@@ -111,7 +119,15 @@ class ScopedContext(abc.ABC):
             elif parameter.annotation in self._instances:
                 instance = self._instances[parameter.annotation]
             else:
-                instance = await self._aresolve_parameter(provider, parameter)
+                try:
+                    instance = await self._aresolve_parameter(provider, parameter)
+                except LookupError:
+                    if parameter.default is inspect.Parameter.empty:
+                        raise
+                    instance = parameter.default
+                else:
+                    if self.container.testing:
+                        instance = TestInterface(interface=parameter.annotation)
             if parameter.kind == parameter.POSITIONAL_ONLY:
                 args.append(instance)
             else:
@@ -128,7 +144,7 @@ class ResourceScopedContext(ScopedContext):
         self._stack = contextlib.ExitStack()
         self._async_stack = contextlib.AsyncExitStack()
 
-    def get(self, provider: Provider) -> Any:
+    def get_or_create(self, provider: Provider) -> tuple[Any, bool]:
         """Get an instance of a dependency from the scoped context."""
         instance = self._instances.get(provider.interface)
         if instance is None:
@@ -143,9 +159,10 @@ class ResourceScopedContext(ScopedContext):
             else:
                 instance = self._create_instance(provider)
             self._instances[provider.interface] = instance
-        return instance
+            return instance, True
+        return instance, False
 
-    async def aget(self, provider: Provider) -> Any:
+    async def aget_or_create(self, provider: Provider) -> tuple[Any, bool]:
         """Get an async instance of a dependency from the scoped context."""
         instance = self._instances.get(provider.interface)
         if instance is None:
@@ -156,7 +173,8 @@ class ResourceScopedContext(ScopedContext):
             else:
                 instance = await self._acreate_instance(provider)
             self._instances[provider.interface] = instance
-        return instance
+            return instance, True
+        return instance, False
 
     def has(self, interface: AnyInterface) -> bool:
         """Check if the scoped context has an instance of the dependency."""
@@ -172,7 +190,7 @@ class ResourceScopedContext(ScopedContext):
 
     def _create_resource(self, provider: Provider) -> Any:
         """Create a resource using the provider."""
-        args, kwargs = self._get_provider_params(provider)
+        args, kwargs = self._get_provided_args(provider)
         cm = contextlib.contextmanager(provider.call)(*args, **kwargs)
         return self._stack.enter_context(cm)
 
@@ -186,7 +204,7 @@ class ResourceScopedContext(ScopedContext):
 
     async def _acreate_resource(self, provider: Provider) -> Any:
         """Create a resource asynchronously using the provider."""
-        args, kwargs = await self._aget_provider_params(provider)
+        args, kwargs = await self._aget_provided_args(provider)
         cm = contextlib.asynccontextmanager(provider.call)(*args, **kwargs)
         return await self._async_stack.enter_async_context(cm)
 
@@ -287,10 +305,12 @@ class TransientContext(ScopedContext):
 
     scope = "transient"
 
-    def get(self, provider: Provider) -> Any:
-        """Get an instance of a dependency from the transient context."""
-        return self._create_instance(provider)
+    def get_or_create(self, provider: Provider) -> tuple[Any, bool]:
+        """Get or create an instance of a dependency from the transient context."""
+        return self._create_instance(provider), True
 
-    async def aget(self, provider: Provider) -> Any:
-        """Get an async instance of a dependency from the transient context."""
-        return await self._acreate_instance(provider)
+    async def aget_or_create(self, provider: Provider) -> tuple[Any, bool]:
+        """
+        Get or create an async instance of a dependency from the transient context.
+        """
+        return await self._acreate_instance(provider), True

{anydi-0.32.2 → anydi-0.33.0}/anydi/_provider.py

@@ -69,7 +69,7 @@ class Provider:
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, Provider):
-            return NotImplemented
+            return NotImplemented  # pragma: no cover
         return (
             self._call == other._call
             and self._scope == other._scope

{anydi-0.32.2 → anydi-0.33.0}/anydi/_types.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import inspect
+from dataclasses import dataclass
 from typing import Annotated, Any, TypeVar, Union
 
 from typing_extensions import Literal, Self, TypeAlias
@@ -35,3 +36,8 @@ class Event:
 def is_event_type(obj: Any) -> bool:
     """Checks if an object is an event type."""
     return inspect.isclass(obj) and issubclass(obj, Event)
+
+
+@dataclass(frozen=True)
+class TestInterface:
+    interface: type[Any]

{anydi-0.32.2 → anydi-0.33.0}/anydi/ext/_utils.py

@@ -61,7 +61,7 @@ def patch_annotated_parameter(parameter: inspect.Parameter) -> inspect.Parameter
 
 
 def patch_call_parameter(
-    call: Callable[..., Any], parameter: inspect.Parameter, container: Container
+    container: Container, call: Callable[..., Any], parameter: inspect.Parameter
 ) -> None:
     """Patch a parameter to inject dependencies using AnyDI."""
     parameter = patch_annotated_parameter(parameter)
@@ -78,6 +78,6 @@ def patch_call_parameter(
             "first call because it is running in non-strict mode."
         )
     else:
-        container._injector._validate_injected_parameter(call, parameter)  # noqa
+        container._validate_injected_parameter(call, parameter)  # noqa
 
     parameter.default.interface = parameter.annotation

{anydi-0.32.2 → anydi-0.33.0}/anydi/ext/fastapi.py

@@ -41,7 +41,7 @@ def install(app: FastAPI, container: Container) -> None:
             if not call:
                 continue  # pragma: no cover
             for parameter in get_typed_parameters(call):
-                patch_call_parameter(call, parameter, container)
+                patch_call_parameter(container, call, parameter)
 
 
 def get_container(request: Request) -> Container:

{anydi-0.32.2 → anydi-0.33.0}/anydi/ext/faststream.py

@@ -26,7 +26,7 @@ def install(broker: BrokerUsecase[Any, Any], container: Container) -> None:
     for handler in _get_broken_handlers(broker):
         call = handler._original_call  # noqa
         for parameter in get_typed_parameters(call):
-            patch_call_parameter(call, parameter, container)
+            patch_call_parameter(container, call, parameter)
 
 
 def _get_broken_handlers(broker: BrokerUsecase[Any, Any]) -> list[Any]:

{anydi-0.32.2 → anydi-0.33.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "anydi"
-version = "0.32.2"
+version = "0.33.0"
 description = "Dependency Injection library"
 authors = ["Anton Ruhlov <antonruhlov@gmail.com>"]
 license = "MIT"
@@ -45,8 +45,8 @@ docs = ["mkdocs", "mkdocs-material"]
 async = ["anyio"]
 
 [tool.poetry.group.dev.dependencies]
-mypy = "^1.13.0"
-ruff = "^0.7.1"
+mypy = { version = "^1.14.0", extras = ["faster-cache"] }
+ruff = "^0.8.4"
 pytest = "^8.3.1"
 pytest-cov = "^5.0.0"
 fastapi = "^0.100.0"

anydi-0.32.2/anydi/_injector.py

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