anydi 0.56.0__py3-none-any.whl → 0.57.0__py3-none-any.whl

anydi/ext/fastapi.py

@@ -11,37 +11,12 @@ from fastapi.dependencies.models import Dependant
 from fastapi.routing import APIRoute
 from starlette.requests import Request
 
-from anydi._container import Container
-from anydi._types import InjectMarker
+from anydi import Container
+from anydi._types import Inject, ProvideMarker, set_provide_factory
 
 from .starlette.middleware import RequestScopedMiddleware
 
-__all__ = ["RequestScopedMiddleware", "install", "get_container", "Inject"]
-
-
-def install(app: FastAPI, container: Container) -> None:
-    """Install AnyDI into a FastAPI application.
-
-    This function installs the AnyDI container into a FastAPI application by attaching
-    it to the application state. It also patches the route dependencies to inject the
-    required dependencies using AnyDI.
-    """
-    app.state.container = container  # noqa
-
-    patched = []
-
-    for route in app.routes:
-        if not isinstance(route, APIRoute):
-            continue
-        for dependant in _iter_dependencies(route.dependant):
-            if dependant.cache_key in patched:
-                continue
-            patched.append(dependant.cache_key)
-            call, *params = dependant.cache_key
-            if not call:
-                continue  # pragma: no cover
-            for parameter in inspect.signature(call, eval_str=True).parameters.values():
-                container.validate_injected_parameter(parameter, call=call)
+__all__ = ["install", "get_container", "Inject", "RequestScopedMiddleware"]
 
 
 def get_container(request: Request) -> Container:
@@ -49,10 +24,10 @@ def get_container(request: Request) -> Container:
     return cast(Container, request.app.state.container)
 
 
-class _Inject(params.Depends, InjectMarker):
+class _ProvideMarker(params.Depends, ProvideMarker):
     def __init__(self) -> None:
         super().__init__(dependency=self._dependency, use_cache=True)
-        InjectMarker.__init__(self)
+        ProvideMarker.__init__(self)
 
     async def _dependency(
         self, container: Annotated[Container, Depends(get_container)]
@@ -60,13 +35,36 @@ class _Inject(params.Depends, InjectMarker):
         return await container.aresolve(self.interface)
 
 
-def Inject() -> Any:
-    return _Inject()
+# Configure Inject() and Provide[T] to use FastAPI-specific marker
+set_provide_factory(_ProvideMarker)
 
 
 def _iter_dependencies(dependant: Dependant) -> Iterator[Dependant]:
-    """Iterate over the dependencies of a dependant."""
     yield dependant
     if dependant.dependencies:
         for sub_dependant in dependant.dependencies:
             yield from _iter_dependencies(sub_dependant)
+
+
+def _validate_route_dependencies(
+    route: APIRoute, container: Container, patched: set[tuple[Any, ...]]
+) -> None:
+    for dependant in _iter_dependencies(route.dependant):
+        if dependant.cache_key in patched:
+            continue
+        patched.add(dependant.cache_key)
+        call, *_ = dependant.cache_key
+        if not call:
+            continue  # pragma: no cover
+        for parameter in inspect.signature(call, eval_str=True).parameters.values():
+            container.validate_injected_parameter(parameter, call=call)
+
+
+def install(app: FastAPI, container: Container) -> None:
+    """Install AnyDI into a FastAPI application."""
+    app.state.container = container  # noqa
+    patched: set[tuple[Any, ...]] = set()
+    for route in app.routes:
+        if not isinstance(route, APIRoute):
+            continue
+        _validate_route_dependencies(route, container, patched)

anydi/ext/faststream.py

@@ -10,49 +10,43 @@ from faststream import ContextRepo
 from faststream.broker.core.usecase import BrokerUsecase
 
 from anydi import Container
-from anydi._types import InjectMarker
+from anydi._types import Inject, ProvideMarker, set_provide_factory
 
-
-def install(broker: BrokerUsecase[Any, Any], container: Container) -> None:
-    """Install AnyDI into a FastStream broker.
-
-    This function installs the AnyDI container into a FastStream broker by attaching
-    it to the broker. It also patches the broker handlers to inject the required
-    dependencies using AnyDI.
-    """
-    broker._container = container  # type: ignore
-
-    for handler in _get_broken_handlers(broker):
-        call = handler._original_call  # noqa
-        for parameter in inspect.signature(call, eval_str=True).parameters.values():
-            container.validate_injected_parameter(parameter, call=call)
-
-
-def _get_broken_handlers(broker: BrokerUsecase[Any, Any]) -> list[Any]:
-    if (handlers := getattr(broker, "handlers", None)) is not None:
-        return [handler.calls[0][0] for handler in handlers.values()]
-    # faststream > 0.5.0
-    return [
-        subscriber.calls[0].handler
-        for subscriber in broker._subscribers.values()  # noqa
-    ]
+__all__ = ["install", "get_container", "Inject"]
 
 
 def get_container(broker: BrokerUsecase[Any, Any]) -> Container:
+    """Get the AnyDI container from a FastStream broker."""
     return cast(Container, getattr(broker, "_container"))  # noqa
 
 
-class _Inject(Depends, InjectMarker):
-    """Parameter dependency class for injecting dependencies using AnyDI."""
-
+class _ProvideMarker(Depends, ProvideMarker):
     def __init__(self) -> None:
         super().__init__(dependency=self._dependency, use_cache=True, cast=True)
-        InjectMarker.__init__(self)
+        ProvideMarker.__init__(self)
 
     async def _dependency(self, context: ContextRepo) -> Any:
         container = get_container(context.get("broker"))
         return await container.aresolve(self.interface)
 
 
-def Inject() -> Any:
-    return _Inject()
+# Configure Inject() and Provide[T] to use FastStream-specific marker
+set_provide_factory(_ProvideMarker)
+
+
+def _get_broker_handlers(broker: BrokerUsecase[Any, Any]) -> list[Any]:
+    if (handlers := getattr(broker, "handlers", None)) is not None:
+        return [handler.calls[0][0] for handler in handlers.values()]
+    return [
+        subscriber.calls[0].handler
+        for subscriber in broker._subscribers.values()  # noqa
+    ]
+
+
+def install(broker: BrokerUsecase[Any, Any], container: Container) -> None:
+    """Install AnyDI into a FastStream broker."""
+    broker._container = container  # type: ignore
+    for handler in _get_broker_handlers(broker):
+        call = handler._original_call  # noqa
+        for parameter in inspect.signature(call, eval_str=True).parameters.values():
+            container.validate_injected_parameter(parameter, call=call)

anydi/ext/pydantic_settings.py

@@ -22,7 +22,8 @@ def install(
         prefix += "."
 
     def _register_settings(_settings: BaseSettings) -> None:
-        all_fields = {**_settings.model_fields, **_settings.model_computed_fields}
+        settings_cls = type(_settings)
+        all_fields = {**settings_cls.model_fields, **settings_cls.model_computed_fields}
         for setting_name, field_info in all_fields.items():
             if isinstance(field_info, ComputedFieldInfo):
                 interface = field_info.return_type

anydi/ext/pytest_plugin.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import importlib.util
 import inspect
 import logging
 from collections.abc import Callable, Iterator
@@ -9,47 +10,199 @@ import pytest
 from anyio.pytest_plugin import extract_backend_and_options, get_runner
 from typing_extensions import get_annotations
 
-from anydi import Container
+from anydi import Container, import_container
 
 logger = logging.getLogger(__name__)
 
-
-def pytest_configure(config: pytest.Config) -> None:
-    config.addinivalue_line(
-        "markers",
-        "inject: mark test as needing dependency injection",
-    )
+# Storage for fixtures with inject markers
+_INJECTED_FIXTURES: dict[str, dict[str, Any]] = {}
 
 
 def pytest_addoption(parser: pytest.Parser) -> None:
+    parser.addini(
+        "anydi_autoinject",
+        help="Automatically inject dependencies into all test functions",
+        type="bool",
+        default=False,
+    )
     parser.addini(
         "anydi_inject_all",
-        help="Inject all dependencies",
+        help="Deprecated: use 'anydi_autoinject' instead",
+        type="bool",
+        default=False,
+    )
+    parser.addini(
+        "anydi_container",
+        help=(
+            "Path to container instance or factory "
+            "(e.g., 'myapp.container:container' or 'myapp.container.container')"
+        ),
+        type="string",
+        default=None,
+    )
+    parser.addini(
+        "anydi_fixture_inject_enabled",
+        help=(
+            "Enable dependency injection into fixtures marked with @pytest.mark.inject"
+        ),
         type="bool",
         default=False,
     )
 
 
-CONTAINER_FIXTURE_NAME = "container"
+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line(
+        "markers",
+        "inject: mark test as needing dependency injection",
+    )
 
+    # Enable fixture injection if configured
+    inject_fixtures_enabled = cast(bool, config.getini("anydi_fixture_inject_enabled"))
+    if inject_fixtures_enabled:
+        autoinject = cast(bool, config.getini("anydi_autoinject"))
+        inject_all = cast(bool, config.getini("anydi_inject_all"))
+        _patch_pytest_fixtures(autoinject=autoinject or inject_all)
+        logger.debug(
+            "Fixture injection enabled via anydi_fixture_inject_enabled config"
+        )
 
-@pytest.fixture
-def anydi_setup_container(request: pytest.FixtureRequest) -> Container:
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_fixture_setup(  # noqa: C901
+    fixturedef: pytest.FixtureDef[Any],
+    request: pytest.FixtureRequest,
+) -> Iterator[None]:
+    """Inject dependencies into fixtures marked with @pytest.mark.inject."""
+    # Check if this fixture has injection metadata
+    fixture_name = fixturedef.argname
+    if fixture_name not in _INJECTED_FIXTURES:
+        yield
+        return
+
+    # Get the metadata
+    fixture_info = _INJECTED_FIXTURES[fixture_name]
+    original_func = fixture_info["func"]
+    parameters: list[tuple[str, Any]] = fixture_info["parameters"]
+
+    # Get the container
     try:
-        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 "
-            "module or override `anydi_setup_container` fixture."
+        container = cast(Container, request.getfixturevalue("container"))
+    except pytest.FixtureLookupError:
+        yield
+        return
+
+    resolvable_params = _select_resolvable_parameters(container, parameters)
+
+    if not resolvable_params:
+        yield
+        return
+
+    target_name = f"fixture '{fixture_name}'"
+
+    def _prepare_sync_call_kwargs(kwargs: dict[str, Any]) -> dict[str, Any]:
+        combined_kwargs = dict(kwargs)
+        combined_kwargs.update(
+            _resolve_dependencies_sync(container, resolvable_params, target=target_name)
         )
-        raise exc
+        return combined_kwargs
+
+    async def _prepare_async_call_kwargs(kwargs: dict[str, Any]) -> dict[str, Any]:
+        combined_kwargs = dict(kwargs)
+        combined_kwargs.update(
+            await _resolve_dependencies_async(
+                container, resolvable_params, target=target_name
+            )
+        )
+        return combined_kwargs
+
+    def _ensure_anyio_backend() -> tuple[str, dict[str, Any]]:
+        try:
+            backend = request.getfixturevalue("anyio_backend")
+        except pytest.FixtureLookupError as exc:  # pragma: no cover - defensive
+            msg = (
+                "To run async fixtures with AnyDI, please configure the `anyio` pytest "
+                "plugin (provide the `anyio_backend` fixture)."
+            )
+            pytest.fail(msg, pytrace=False)
+            raise RuntimeError from exc  # Unreachable but satisfies type checkers
+
+        return extract_backend_and_options(backend)
+
+    # Replace the fixture function with one that mirrors the original's type and
+    # injects dependencies before delegating to the user-defined function.
+    original_fixture_func = fixturedef.func
+
+    if inspect.isasyncgenfunction(original_func):
+
+        def asyncgen_wrapper(*args: Any, **kwargs: Any) -> Iterator[Any]:
+            backend_name, backend_options = _ensure_anyio_backend()
+
+            async def _fixture() -> Any:
+                call_kwargs = await _prepare_async_call_kwargs(kwargs)
+                async for value in original_func(**call_kwargs):
+                    yield value
+
+            with get_runner(backend_name, backend_options) as runner:
+                yield from runner.run_asyncgen_fixture(_fixture, {})  # type: ignore
+
+        fixturedef.func = asyncgen_wrapper  # type: ignore[misc]
+    elif inspect.iscoroutinefunction(original_func):
+
+        def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+            backend_name, backend_options = _ensure_anyio_backend()
+
+            async def _fixture() -> Any:
+                call_kwargs = await _prepare_async_call_kwargs(kwargs)
+                return await original_func(**call_kwargs)
+
+            with get_runner(backend_name, backend_options) as runner:
+                return runner.run_fixture(_fixture, {})
+
+        fixturedef.func = async_wrapper  # type: ignore[misc]
+    elif inspect.isgeneratorfunction(original_func):
+
+        def generator_wrapper(*args: Any, **kwargs: Any) -> Iterator[Any]:
+            call_kwargs = _prepare_sync_call_kwargs(kwargs)
+            yield from original_func(**call_kwargs)
+
+        fixturedef.func = generator_wrapper  # type: ignore[misc]
+    else:
+
+        def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+            call_kwargs = _prepare_sync_call_kwargs(kwargs)
+            return original_func(**call_kwargs)
+
+        fixturedef.func = sync_wrapper  # type: ignore[misc]
+
+    # Let pytest execute the modified fixture
+    yield
+
+    # Restore the original function
+    fixturedef.func = original_fixture_func  # type: ignore[misc]
+
+
+@pytest.fixture(scope="session")
+def container(request: pytest.FixtureRequest) -> Container:
+    """Container fixture."""
+    return _find_container(request)
 
 
 @pytest.fixture
 def _anydi_should_inject(request: pytest.FixtureRequest) -> bool:
     marker = request.node.get_closest_marker("inject")
+
+    # Check new config option first
+    autoinject = cast(bool, request.config.getini("anydi_autoinject"))
+
+    # Check deprecated option for backward compatibility
     inject_all = cast(bool, request.config.getini("anydi_inject_all"))
-    return marker is not None or inject_all
+    if inject_all:
+        logger.warning(
+            "Configuration option 'anydi_inject_all' is deprecated. "
+            "Please use 'anydi_autoinject' instead."
+        )
+
+    return marker is not None or autoinject or inject_all
 
 
 @pytest.fixture
@@ -60,12 +213,8 @@ def _anydi_injected_parameter_iterator(
         request.node._fixtureinfo.name2fixturedefs.keys()
     )
 
-    def _iterator() -> Iterator[tuple[str, inspect.Parameter]]:
-        for name, annotation in get_annotations(
-            request.function, eval_str=True
-        ).items():
-            if name == "return":
-                continue
+    def _iterator() -> Iterator[tuple[str, Any]]:
+        for name, annotation in _iter_injectable_parameters(request.function):
             if name not in fixturenames:
                 continue
             yield name, annotation
@@ -84,20 +233,20 @@ def _anydi_inject(
     if inspect.iscoroutinefunction(request.function) or not _anydi_should_inject:
         return
 
-    # Setup the container
-    container = cast(Container, request.getfixturevalue("anydi_setup_container"))
+    parameters = list(_anydi_injected_parameter_iterator())
+    if not parameters:
+        return
 
-    for argname, interface in _anydi_injected_parameter_iterator():
-        # Skip if the interface has no provider
-        if not container.has_provider_for(interface):
-            continue
+    container = cast(Container, request.getfixturevalue("container"))
+    resolvable = _select_resolvable_parameters(container, parameters)
+    if not resolvable:
+        return
 
-        try:
-            request.node.funcargs[argname] = container.resolve(interface)
-        except Exception as exc:
-            logger.warning(
-                f"Failed to resolve dependency for argument '{argname}'.", exc_info=exc
-            )
+    resolved = _resolve_dependencies_sync(
+        container, resolvable, target=request.node.nodeid
+    )
+    for argname, value in resolved.items():
+        request.node.funcargs[argname] = value
 
 
 @pytest.fixture(autouse=True)
@@ -123,25 +272,206 @@ def _anydi_ainject(
         )
         pytest.fail(msg, pytrace=False)
 
-    async def _awrapper() -> None:
-        # Setup the container
-        container = cast(Container, request.getfixturevalue("anydi_setup_container"))
+    parameters = list(_anydi_injected_parameter_iterator())
+    if not parameters:
+        return
 
-        for argname, interface in _anydi_injected_parameter_iterator():
-            # Skip if the interface has no provider
-            if not container.has_provider_for(interface):
-                continue
+    container = cast(Container, request.getfixturevalue("container"))
+    resolvable = _select_resolvable_parameters(container, parameters)
+    if not resolvable:
+        return
 
-            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,
-                )
+    async def _awrapper() -> None:
+        resolved = await _resolve_dependencies_async(
+            container, resolvable, target=request.node.nodeid
+        )
+        for argname, value in resolved.items():
+            request.node.funcargs[argname] = value
 
     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, {})
+
+
+def _find_container(request: pytest.FixtureRequest) -> Container:
+    """Find container."""
+
+    # Look for 'anydi_container' defined in pytest.ini (highest priority)
+    container_path = cast(str | None, request.config.getini("anydi_container"))
+    if container_path:
+        try:
+            return import_container(container_path)
+        except ImportError as exc:
+            raise RuntimeError(
+                f"Failed to load container from config "
+                f"'anydi_container={container_path}': {exc}"
+            ) from exc
+
+    # Detect pytest-django + anydi_django availability
+    pluginmanager = request.config.pluginmanager
+    if pluginmanager.hasplugin("django") and importlib.util.find_spec("anydi_django"):
+        return import_container("anydi_django.container")
+
+    # Neither fixture nor config found
+    raise pytest.FixtureLookupError(
+        None,
+        request,
+        "`container` fixture is not found and 'anydi_container' config is not set. "
+        "Either define a `container` fixture in your test module "
+        "or set 'anydi_container' in pytest.ini.",
+    )
+
+
+def _patch_pytest_fixtures(*, autoinject: bool) -> None:  # noqa: C901
+    """Patch pytest.fixture decorator to intercept fixtures with inject markers."""
+    from _pytest.fixtures import fixture as original_fixture_decorator
+
+    def patched_fixture(*args: Any, **kwargs: Any) -> Any:  # noqa: C901
+        """Patched fixture decorator that handles inject markers."""
+
+        def should_process(func: Callable[..., Any]) -> bool:
+            has_inject_marker = False
+            if hasattr(func, "pytestmark"):
+                markers = getattr(func, "pytestmark", [])
+                if not isinstance(markers, list):
+                    markers = [markers]
+
+                has_inject_marker = any(
+                    marker.name == "inject"
+                    for marker in markers
+                    if hasattr(marker, "name")
+                )
+
+            return autoinject or has_inject_marker
+
+        def register_fixture(func: Callable[..., Any]) -> Callable[..., Any] | None:
+            if not should_process(func):
+                return None
+
+            parameters = list(_iter_injectable_parameters(func))
+            if not parameters:
+                return None
+
+            sig = inspect.signature(func, eval_str=True)
+            has_request_param = "request" in sig.parameters
+
+            if has_request_param:
+
+                def wrapper_with_request(request: Any) -> Any:
+                    return func
+
+                wrapper_func = wrapper_with_request
+            else:
+
+                def wrapper_no_request() -> Any:
+                    return func
+
+                wrapper_func = wrapper_no_request
+
+            wrapper_func.__name__ = func.__name__
+            wrapper_func.__annotations__ = {}
+
+            fixture_name = func.__name__
+            _INJECTED_FIXTURES[fixture_name] = {
+                "func": func,
+                "parameters": parameters,
+            }
+            logger.debug(
+                "Registered injectable fixture '%s' with params: %s",
+                fixture_name,
+                [name for name, _ in parameters],
+            )
+
+            return wrapper_func
+
+        # Handle both @pytest.fixture and @pytest.fixture() usage
+        if len(args) == 1 and callable(args[0]) and not kwargs:
+            func = args[0]
+            wrapper_func = register_fixture(func)
+            if wrapper_func:
+                return original_fixture_decorator(wrapper_func)
+
+            return original_fixture_decorator(func)
+        else:
+
+            def decorator(func: Callable[..., Any]) -> Any:
+                wrapper_func = register_fixture(func)
+                if wrapper_func:
+                    return original_fixture_decorator(*args, **kwargs)(wrapper_func)
+
+                return original_fixture_decorator(*args, **kwargs)(func)
+
+            return decorator
+
+    # Replace pytest.fixture
+    pytest.fixture = patched_fixture  # type: ignore[assignment]
+    # Also patch _pytest.fixtures.fixture
+    import _pytest.fixtures
+
+    _pytest.fixtures.fixture = patched_fixture  # type: ignore[assignment]
+
+
+def _iter_injectable_parameters(
+    func: Callable[..., Any], *, skip: tuple[str, ...] = ("request",)
+) -> Iterator[tuple[str, Any]]:
+    annotations = get_annotations(func, eval_str=True)
+    skip_names = set(skip)
+    for name, annotation in annotations.items():
+        if name in skip_names or name == "return":
+            continue
+        yield name, annotation
+
+
+def _select_resolvable_parameters(
+    container: Container,
+    parameters: Iterator[tuple[str, Any]] | list[tuple[str, Any]],
+) -> list[tuple[str, Any]]:
+    return [
+        (name, annotation)
+        for name, annotation in parameters
+        if container.has_provider_for(annotation)
+    ]
+
+
+def _resolve_dependencies_sync(
+    container: Container,
+    parameters: list[tuple[str, Any]],
+    *,
+    target: str,
+) -> dict[str, Any]:
+    resolved: dict[str, Any] = {}
+    for param_name, annotation in parameters:
+        try:
+            resolved[param_name] = container.resolve(annotation)
+            logger.debug("Resolved %s=%s for %s", param_name, annotation, target)
+        except Exception as exc:  # pragma: no cover - defensive logging
+            logger.warning(
+                "Failed to resolve dependency for '%s' on %s.",
+                param_name,
+                target,
+                exc_info=exc,
+            )
+    return resolved
+
+
+async def _resolve_dependencies_async(
+    container: Container,
+    parameters: list[tuple[str, Any]],
+    *,
+    target: str,
+) -> dict[str, Any]:
+    resolved: dict[str, Any] = {}
+    for param_name, annotation in parameters:
+        try:
+            resolved[param_name] = await container.aresolve(annotation)
+            logger.debug("Resolved %s=%s for async %s", param_name, annotation, target)
+        except Exception as exc:  # pragma: no cover - defensive logging
+            logger.warning(
+                "Failed to resolve async dependency for '%s' on %s.",
+                param_name,
+                target,
+                exc_info=exc,
+            )
+    return resolved