anydi 0.32.2__py3-none-any.whl → 0.33.1__py3-none-any.whl

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, DependencyWrapper, Interface, Scope, 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,10 @@ 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)
 
     @overload
     async def aresolve(self, interface: Interface[T]) -> T: ...
@@ -361,7 +384,33 @@ 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 _patch_test_resolver(self, instance: Any) -> None:
+        """Patch the test resolver for the instance."""
+        if not hasattr(instance, "__dict__"):
+            return
+
+        wrapped = {
+            name: value.interface
+            for name, value in instance.__dict__.items()
+            if isinstance(value, DependencyWrapper)
+        }
+
+        # Custom resolver function
+        def _resolver(_self: Any, _name: str) -> Any:
+            if _name in wrapped:
+                # Resolve the dependency if it's wrapped
+                return self.resolve(wrapped[_name])
+            # Fall back to default behavior
+            return object.__getattribute__(_self, _name)
+
+        # Apply the patched resolver if wrapped attributes exist
+        if wrapped:
+            instance.__class__.__getattribute__ = _resolver
 
     def is_resolved(self, interface: AnyInterface) -> bool:
         """Check if an instance by interface exists."""
@@ -424,25 +473,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/_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, DependencyWrapper, Scope, 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,24 @@ 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 = DependencyWrapper(
+                            interface=parameter.annotation, instance=instance
+                        )
             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 +121,17 @@ 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 = DependencyWrapper(
+                            interface=parameter.annotation, instance=instance
+                        )
             if parameter.kind == parameter.POSITIONAL_ONLY:
                 args.append(instance)
             else:
@@ -128,7 +148,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 +163,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 +177,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 +194,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 +208,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 +309,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/_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/_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,14 @@ 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 DependencyWrapper:
+    interface: type[Any]
+    instance: Any
+
+    def __getattribute__(self, name: str) -> Any:
+        if name in {"interface", "instance"}:
+            return object.__getattribute__(self, name)
+        return getattr(self.instance, name)

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/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/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/ext/pytest_plugin.py

@@ -105,8 +105,10 @@ def _anydi_inject(
 
         try:
             request.node.funcargs[argname] = container.resolve(interface)
-        except Exception:  # noqa
-            logger.warning(f"Failed to resolve dependency for argument '{argname}'.")
+        except Exception as exc:
+            logger.warning(
+                f"Failed to resolve dependency for argument '{argname}'.", exc_info=exc
+            )
             _anydi_unresolved.append(interface)
 
 
@@ -131,6 +133,8 @@ async def _anydi_ainject(
 
         try:
             request.node.funcargs[argname] = await container.aresolve(interface)
-        except Exception:  # noqa
-            logger.warning(f"Failed to resolve dependency for argument '{argname}'.")
+        except Exception as exc:
+            logger.warning(
+                f"Failed to resolve dependency for argument '{argname}'.", exc_info=exc
+            )
             _anydi_unresolved.append(interface)

{anydi-0.32.2.dist-info → anydi-0.33.1.dist-info}/METADATA

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

{anydi-0.32.2.dist-info → anydi-0.33.1.dist-info}/RECORD

@@ -1,15 +1,14 @@
 anydi/__init__.py,sha256=EsR-HiMe8cWS9PQbY23ibc91STK1WTn02DFMPV-TNU4,509
-anydi/_container.py,sha256=gBcdz7wplCm-H8sj_QZpQsgISsg-B9RL6LuZ2kR_PdU,16925
-anydi/_context.py,sha256=XSXBpSCm6zwR5otLN2cj_mPDQXTM18aN6vmJhiNEoL4,11697
-anydi/_injector.py,sha256=GdI4NdcB72sJPyBFh9ZKyPflEs-6HaUbiHN2H5QIgHY,3454
+anydi/_container.py,sha256=shefN3SuhmPBzU6gxV-YRGJlz-m8Nv5RJ-T93veSxgE,21389
+anydi/_context.py,sha256=6Veqt15Tp4DfOzppUOIBaymosicYUWMeSa1b7ZAdtxw,12866
 anydi/_logger.py,sha256=UpubJUnW83kffFxkhUlObm2DmZX1Pjqoz9YFKS-JOPg,52
 anydi/_module.py,sha256=cgojC7Z7oMtsUnkfSc65cRYOfZ8Q6KwjusNJzx_VSbk,2729
-anydi/_provider.py,sha256=-CJXDvAEdV2IX--0XWAFhAs_LH_9cGp9XhhrrczuMgM,6193
+anydi/_provider.py,sha256=w_GnRo324aqNORRJwuURexA54c1M3smj34Q8EaV0QGE,6213
 anydi/_scanner.py,sha256=F2sHgJvkRYXYnu4F5iSrnIPVzwnNeS7tRPXziirh4NI,4898
-anydi/_types.py,sha256=At2VeJgwNC0gwMqdL0tkGtjSFsqOdrQStDwyzAGugr4,796
+anydi/_types.py,sha256=90xdbH2NrFXbridFf9mjOknhcXMW5L0jm92zP_LvKrg,1120
 anydi/_utils.py,sha256=guw4sFCvsisJmneKWlZi18YDYll_CjlO_f2cH97rDFQ,3280
 anydi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anydi/ext/_utils.py,sha256=PHOLjnohC4gbhZESDnnvuup25XTWmQzDaS2y-9SYzaw,2576
+anydi/ext/_utils.py,sha256=U6sRqWzccWUu7eMhbXX1NrwcaxitQF9cO1KxnKF37gw,2566
 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
@@ -19,15 +18,15 @@ anydi/ext/django/middleware.py,sha256=tryIaBVmfPmilGrnKpLNlLCOPN5rw4_pXY3ojFXv3O
 anydi/ext/django/ninja/__init__.py,sha256=kW3grUgWp_nkWSG_-39ADHMrZLGNcj9TsJ9OW8iWWrk,546
 anydi/ext/django/ninja/_operation.py,sha256=wSWa7D73XTVlOibmOciv2l6JHPe1ERZcXrqI8W-oO2w,2696
 anydi/ext/django/ninja/_signature.py,sha256=2cSzKxBIxXLqtwNuH6GSlmjVJFftoGmleWfyk_NVEWw,2207
-anydi/ext/fastapi.py,sha256=ebw6-352rMk_YpwPQrL8cUEK0XxGuxDAYCLfHwuDGTQ,2436
-anydi/ext/faststream.py,sha256=asH5Cup5Uu_mG95_OkJZYeLbJ1ttkVQHPRdQTTJmjGE,1898
+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=Df0pFgAOk-44UFsdZGAOSxElJTJLchs4sk2UZuV-KVk,4212
+anydi/ext/pytest_plugin.py,sha256=3x_ZYFcLp4ZCRrs7neoohmWz56O9ydm92jxi_LnyD7w,4298
 anydi/ext/starlette/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/ext/starlette/middleware.py,sha256=PKip_omFZDgg7h2OY-nnV2OIS1MbbmrrOJBwG7_Peuw,793
 anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anydi-0.32.2.dist-info/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
-anydi-0.32.2.dist-info/METADATA,sha256=gZZq6SbwsHOAgcT-gx9Y4SoG52zEW6EQPVbmZMCLAH8,5112
-anydi-0.32.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-anydi-0.32.2.dist-info/entry_points.txt,sha256=GmQblwzxFg42zva1HyBYJJ7TvrTIcSAGBHmyi3bvsi4,42
-anydi-0.32.2.dist-info/RECORD,,
+anydi-0.33.1.dist-info/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
+anydi-0.33.1.dist-info/METADATA,sha256=u-YkBHTqAbah4ytfw7CXHEUNDVyjhBFUwD2dV8z84Jc,5112
+anydi-0.33.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+anydi-0.33.1.dist-info/entry_points.txt,sha256=GmQblwzxFg42zva1HyBYJJ7TvrTIcSAGBHmyi3bvsi4,42
+anydi-0.33.1.dist-info/RECORD,,

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)}`."
-            )