anydi 0.68.0__tar.gz → 0.70.0__tar.gz

{anydi-0.68.0 → anydi-0.70.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anydi
-Version: 0.68.0
+Version: 0.70.0
 Summary: Dependency Injection library
 Keywords: dependency injection,dependencies,di,async,asyncio,application
 Author: Anton Ruhlov

{anydi-0.68.0 → anydi-0.70.0}/anydi/_container.py

@@ -17,7 +17,7 @@ from typing import Any, Literal, TypeVar, get_args, get_origin, overload
 from typing_extensions import ParamSpec, Self, type_repr
 
 from ._context import InstanceContext
-from ._decorators import is_provided
+from ._decorators import get_alias_list, is_provided
 from ._graph import Graph
 from ._injector import Injector
 from ._marker import Marker
@@ -49,6 +49,7 @@ class Container:
         }
 
         self._resources: dict[str, list[Any]] = defaultdict(list)
+        self._aliases: dict[Any, Any] = {}  # alias_type → canonical_type
         self._singleton_context = InstanceContext()
         self._scoped_context: dict[str, ContextVar[InstanceContext]] = {}
 
@@ -95,6 +96,11 @@ class Container:
         """Get the registered providers."""
         return self._providers
 
+    @property
+    def aliases(self) -> dict[Any, Any]:
+        """Get the registered aliases."""
+        return self._aliases
+
     @property
     def ready(self) -> bool:
         """Check if the container is ready."""
@@ -370,9 +376,30 @@ class Container:
             dependency_type, factory, scope, from_context, override, None
         )
 
+    def alias(self, alias_type: Any, canonical_type: Any, /) -> None:
+        """Register an alias for a dependency type."""
+        if self.ready:
+            raise RuntimeError(
+                "Cannot register aliases after build() has been called. "
+                "All aliases must be registered before building the container."
+            )
+        if alias_type == canonical_type:
+            raise ValueError("Alias type cannot be the same as canonical type.")
+        if alias_type in self._aliases:
+            raise ValueError(
+                f"Alias `{type_repr(alias_type)}` is already registered "
+                f"for `{type_repr(self._aliases[alias_type])}`."
+            )
+        self._aliases[alias_type] = canonical_type
+
+    def _resolve_alias(self, dependency_type: Any) -> Any:
+        """Resolve an alias to its canonical type."""
+        return self._aliases.get(dependency_type, dependency_type)
+
     def is_registered(self, dependency_type: Any, /) -> bool:
         """Check if a provider is registered for the specified dependency type."""
-        return dependency_type in self._providers
+        canonical = self._resolve_alias(dependency_type)
+        return canonical in self._providers
 
     def has_provider_for(self, dependency_type: Any, /) -> bool:
         """Check if a provider exists for the specified dependency type."""
@@ -570,9 +597,10 @@ class Container:
         return provider
 
     def _get_provider(self, dependency_type: Any) -> Provider:
-        """Get provider by dependency type."""
+        """Get provider by dependency type, resolving aliases."""
+        canonical = self._resolve_alias(dependency_type)
         try:
-            return self._providers[dependency_type]
+            return self._providers[canonical]
         except KeyError:
             raise LookupError(
                 f"The provider for `{type_repr(dependency_type)}` has "
@@ -597,6 +625,10 @@ class Container:
                     False,
                     defaults,
                 )
+                # Register aliases if specified
+                if not self.ready:
+                    for alias_type in get_alias_list(dependency_type.__provided__):
+                        self.alias(alias_type, dependency_type)
                 registered = True
             else:
                 raise LookupError(
@@ -677,6 +709,9 @@ class Container:
                         False,
                         None,
                     )
+                    # Register aliases if specified
+                    for alias_type in get_alias_list(dependency_type.__provided__):
+                        self._aliases[alias_type] = dependency_type
                     # Recursively ensure the @provided class is resolved
                     dep_provider = self._ensure_provider_resolved(
                         dep_provider, resolving
@@ -977,6 +1012,11 @@ class Container:
                             False,
                             None,
                         )
+                        # Register aliases if specified
+                        for alias_type in get_alias_list(
+                            param_dependency_type.__provided__
+                        ):
+                            self._aliases[alias_type] = param_dependency_type
                     elif param.has_default:
                         # Has default, can be missing
                         resolved_params.append(param)

{anydi-0.68.0 → anydi-0.70.0}/anydi/_decorators.py

@@ -29,32 +29,30 @@ ModuleT = TypeVar("ModuleT", bound="Module")
 class ProvidedMetadata(TypedDict):
     """Metadata for classes marked as provided by AnyDI."""
 
-    dependency_type: NotRequired[Any]
     scope: Scope
+    alias: NotRequired[Any]
     from_context: NotRequired[bool]
 
 
-@overload
-def provided(
-    dependency_type: Any, /, *, scope: Scope, from_context: bool = False
-) -> Callable[[ClassT], ClassT]: ...
-
-
-@overload
-def provided(
-    *, scope: Scope, from_context: bool = False
-) -> Callable[[ClassT], ClassT]: ...
+def get_alias_list(provided: ProvidedMetadata) -> list[Any]:
+    """Get alias list from __provided__ metadata, normalizing single to list."""
+    alias = provided.get("alias")
+    if alias is None:
+        return []
+    if isinstance(alias, list | tuple):
+        return list(alias)  # type: ignore
+    return [alias]
 
 
 def provided(
-    dependency_type: Any = NOT_SET, /, *, scope: Scope, from_context: bool = False
+    *, scope: Scope, alias: Any = NOT_SET, from_context: bool = False
 ) -> Callable[[ClassT], ClassT]:
     """Decorator for marking a class as provided by AnyDI with a specific scope."""
 
     def decorator(cls: ClassT) -> ClassT:
         metadata: ProvidedMetadata = {"scope": scope}
-        if dependency_type is not NOT_SET:
-            metadata["dependency_type"] = dependency_type
+        if alias is not NOT_SET:
+            metadata["alias"] = alias
         if from_context:
             metadata["from_context"] = from_context
         cls.__provided__ = metadata  # type: ignore[attr-defined]
@@ -69,19 +67,19 @@ def singleton(cls: ClassT, /) -> ClassT: ...
 
 @overload
 def singleton(
-    cls: None = None, /, *, dependency_type: Any = NOT_SET
+    cls: None = None, /, *, alias: Any = NOT_SET
 ) -> Callable[[ClassT], ClassT]: ...
 
 
 def singleton(
-    cls: ClassT | None = None, /, *, dependency_type: Any = NOT_SET
+    cls: ClassT | None = None, /, *, alias: Any = NOT_SET
 ) -> Callable[[ClassT], ClassT] | ClassT:
     """Decorator for marking a class as a singleton dependency."""
 
     def decorator(c: ClassT) -> ClassT:
         metadata: ProvidedMetadata = {"scope": "singleton"}
-        if dependency_type is not NOT_SET:
-            metadata["dependency_type"] = dependency_type
+        if alias is not NOT_SET:
+            metadata["alias"] = alias
         c.__provided__ = metadata  # type: ignore[attr-defined]
         return c
 
@@ -97,19 +95,19 @@ def transient(cls: ClassT, /) -> ClassT: ...
 
 @overload
 def transient(
-    cls: None = None, /, *, dependency_type: Any = NOT_SET
+    cls: None = None, /, *, alias: Any = NOT_SET
 ) -> Callable[[ClassT], ClassT]: ...
 
 
 def transient(
-    cls: ClassT | None = None, /, *, dependency_type: Any = NOT_SET
+    cls: ClassT | None = None, /, *, alias: Any = NOT_SET
 ) -> Callable[[ClassT], ClassT] | ClassT:
     """Decorator for marking a class as a transient dependency."""
 
     def decorator(c: ClassT) -> ClassT:
         metadata: ProvidedMetadata = {"scope": "transient"}
-        if dependency_type is not NOT_SET:
-            metadata["dependency_type"] = dependency_type
+        if alias is not NOT_SET:
+            metadata["alias"] = alias
         c.__provided__ = metadata  # type: ignore[attr-defined]
         return c
 
@@ -125,7 +123,7 @@ def request(cls: ClassT, /, *, from_context: bool = False) -> ClassT: ...
 
 @overload
 def request(
-    cls: None = None, /, *, dependency_type: Any = NOT_SET, from_context: bool = False
+    cls: None = None, /, *, alias: Any = NOT_SET, from_context: bool = False
 ) -> Callable[[ClassT], ClassT]: ...
 
 
@@ -133,15 +131,15 @@ def request(
     cls: ClassT | None = None,
     /,
     *,
-    dependency_type: Any = NOT_SET,
+    alias: Any = NOT_SET,
     from_context: bool = False,
 ) -> Callable[[ClassT], ClassT] | ClassT:
     """Decorator for marking a class as a request-scoped dependency."""
 
     def decorator(c: ClassT) -> ClassT:
         metadata: ProvidedMetadata = {"scope": "request"}
-        if dependency_type is not NOT_SET:
-            metadata["dependency_type"] = dependency_type
+        if alias is not NOT_SET:
+            metadata["alias"] = alias
         if from_context:
             metadata["from_context"] = from_context
         c.__provided__ = metadata  # type: ignore[attr-defined]

{anydi-0.68.0 → anydi-0.70.0}/anydi/_graph.py

@@ -19,6 +19,14 @@ class Graph:
     def __init__(self, container: Container) -> None:
         self._container = container
 
+    def _get_aliases_for(self, dependency_type: Any) -> list[str]:
+        """Get list of alias names that point to a dependency type."""
+        aliases: list[str] = []
+        for alias, canonical in self._container.aliases.items():
+            if canonical == dependency_type:
+                aliases.append(type_repr(alias).rsplit(".", 1)[-1])
+        return aliases
+
     def draw(
         self,
         output_format: Literal["tree", "mermaid", "dot", "json"] = "tree",
@@ -127,14 +135,16 @@ class Graph:
                     }
                 )
 
-            providers.append(
-                {
-                    "type": self._get_name(provider, full_path),
-                    "scope": provider.scope,
-                    "from_context": provider.from_context,
-                    "dependencies": dependencies,
-                }
-            )
+            aliases = self._get_aliases_for(provider.dependency_type)
+            provider_data: dict[str, Any] = {
+                "type": self._get_name(provider, full_path),
+                "scope": provider.scope,
+                "from_context": provider.from_context,
+                "dependencies": dependencies,
+            }
+            if aliases:
+                provider_data["aliases"] = aliases
+            providers.append(provider_data)
 
         return json.dumps({"providers": providers}, indent=ident)
 
@@ -167,19 +177,20 @@ class Graph:
 
         return "\n".join(lines)
 
-    @classmethod
     def _format_tree_node(
-        cls, provider: Provider, full_path: bool, param_name: str | None = None
+        self, provider: Provider, full_path: bool, param_name: str | None = None
     ) -> str:
-        name = cls._get_name(provider, full_path)
+        name = self._get_name(provider, full_path)
         scope_label = Graph._get_scope_label(provider.scope, provider.from_context)
         context_marker = " [context]" if provider.from_context else ""
+        aliases = self._get_aliases_for(provider.dependency_type)
+        alias_marker = f" [alias: {', '.join(aliases)}]" if aliases else ""
         if param_name:
-            return f"{param_name}: {name} ({scope_label}){context_marker}"
-        return f"{name} ({scope_label}){context_marker}"
+            return f"{param_name}: {name} ({scope_label}){context_marker}{alias_marker}"
+        return f"{name} ({scope_label}){context_marker}{alias_marker}"
 
-    @staticmethod
     def _render_tree_children(
+        self,
         provider: Provider,
         prefix: str,
         visited: set[Any],
@@ -197,10 +208,10 @@ class Graph:
                 continue
             is_last = i == len(deps) - 1
             connector = "└── " if is_last else "├── "
-            node_text = Graph._format_tree_node(dep_provider, full_path, param.name)
+            node_text = self._format_tree_node(dep_provider, full_path, param.name)
             lines.append(f"{prefix}{connector}{node_text}")
             extension = "    " if is_last else "│   "
-            Graph._render_tree_children(
+            self._render_tree_children(
                 dep_provider, prefix + extension, visited, lines, full_path
             )
 

{anydi-0.68.0 → anydi-0.70.0}/anydi/_resolver.py

@@ -51,12 +51,24 @@ class Resolver:
         return bool(self._overrides) or getattr(self._container, "_test_mode", False)
 
     def add_override(self, dependency_type: Any, instance: Any) -> None:
-        """Add an override instance for a dependency type."""
+        """Add an override for a type, its canonical type, and all aliases."""
         self._overrides[dependency_type] = instance
+        canonical = self._container.aliases.get(dependency_type)
+        if canonical is not None:
+            self._overrides[canonical] = instance
+        for alias, canon in self._container.aliases.items():
+            if canon == dependency_type:
+                self._overrides[alias] = instance
 
     def remove_override(self, dependency_type: Any) -> None:
-        """Remove an override instance for a dependency type."""
+        """Remove an override for a type, its canonical type, and all aliases."""
         self._overrides.pop(dependency_type, None)
+        canonical = self._container.aliases.get(dependency_type)
+        if canonical is not None:
+            self._overrides.pop(canonical, None)
+        for alias, canon in self._container.aliases.items():
+            if canon == dependency_type:
+                self._overrides.pop(alias, None)
 
     def clear_caches(self) -> None:
         """Clear all cached resolvers."""
@@ -105,6 +117,11 @@ class Resolver:
         # Store the compiled functions in the cache
         cache[provider.dependency_type] = compiled
 
+        # Also store under all aliases that point to this type
+        for alias, canonical in self._container.aliases.items():
+            if canonical == provider.dependency_type:
+                cache[alias] = compiled
+
         return compiled
 
     def _add_override_check(

{anydi-0.68.0 → anydi-0.70.0}/anydi/_scanner.py

@@ -8,7 +8,7 @@ from dataclasses import dataclass
 from types import ModuleType
 from typing import TYPE_CHECKING, Any
 
-from ._decorators import Provided, is_injectable, is_provided
+from ._decorators import Provided, get_alias_list, is_injectable, is_provided
 
 if TYPE_CHECKING:
     from ._container import Container
@@ -58,13 +58,15 @@ class Scanner:
 
         # First: register @provided classes
         for cls in provided_classes:
-            dependency_type = cls.__provided__.get("dependency_type", cls)
-            if not self._container.is_registered(dependency_type):
+            if not self._container.is_registered(cls):
                 scope = cls.__provided__["scope"]
                 from_context = cls.__provided__.get("from_context", False)
                 self._container.register(
-                    dependency_type, cls, scope=scope, from_context=from_context
+                    cls, cls, scope=scope, from_context=from_context
                 )
+            # Create aliases if specified (alias → cls)
+            for alias_type in get_alias_list(cls.__provided__):
+                self._container.alias(alias_type, cls)
 
         # Second: inject @injectable functions
         for dependency in injectable_dependencies:

anydi-0.70.0/anydi/ext/pytest_plugin.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import importlib.util
+import inspect
+import logging
+import warnings
+from collections.abc import Generator
+from typing import TYPE_CHECKING, Annotated, Any, cast, get_args, get_origin
+
+import pytest
+from anyio.pytest_plugin import extract_backend_and_options, get_runner
+from typing_extensions import get_annotations
+
+from anydi import Container, import_container
+from anydi._marker import is_marker
+
+if TYPE_CHECKING:
+    from _pytest.fixtures import SubRequest
+
+logger = logging.getLogger(__name__)
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    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_autoinject",
+        help="Automatically inject dependencies into all test functions",
+        type="bool",
+        default=True,
+    )
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line(
+        "markers",
+        "inject: mark test as needing dependency injection (deprecated)",
+    )
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_fixture_setup(
+    fixturedef: pytest.FixtureDef[Any], request: SubRequest
+) -> Generator[None]:
+    """Automatically enable test mode on the container fixture."""
+    yield
+    if fixturedef.argname == "container" and fixturedef.cached_result is not None:
+        container = fixturedef.cached_result[0]
+        if isinstance(container, Container):
+            container.enable_test_mode()
+
+
+@pytest.fixture(scope="session")
+def container(request: pytest.FixtureRequest) -> Container:
+    """Container fixture."""
+    return _find_container(request)
+
+
+@pytest.fixture(autouse=True)
+def _anydi_inject(request: pytest.FixtureRequest) -> None:
+    """Inject dependencies into sync test functions."""
+    if inspect.iscoroutinefunction(request.function):
+        return
+
+    parameters, uses_deprecated = _get_injectable_params(request)
+    if not parameters:
+        return
+
+    container = cast(Container, request.getfixturevalue("container"))
+
+    warned = False
+    for name, dependency_type in parameters:
+        if not container.has_provider_for(dependency_type):
+            continue
+        if uses_deprecated and not warned:
+            _warn_deprecated_marker(request.node.name)
+            warned = True
+        try:
+            request.node.funcargs[name] = container.resolve(dependency_type)
+        except Exception:  # pragma: no cover
+            logger.warning("Failed to resolve '%s' for %s", name, request.node.nodeid)
+
+
+@pytest.fixture(autouse=True)
+def _anydi_ainject(request: pytest.FixtureRequest) -> None:
+    """Inject dependencies into async test functions."""
+    if not inspect.iscoroutinefunction(
+        request.function
+    ) and not inspect.isasyncgenfunction(request.function):
+        return
+
+    parameters, uses_deprecated = _get_injectable_params(request)
+    if not parameters:
+        return
+
+    if "anyio_backend" not in request.fixturenames:
+        pytest.fail(
+            "To run async test functions with `anyio`, "
+            "please configure the `anyio` pytest plugin.\n"
+            "See: https://anyio.readthedocs.io/en/stable/testing.html",
+            pytrace=False,
+        )
+
+    container = cast(Container, request.getfixturevalue("container"))
+
+    async def _resolve() -> None:
+        warned = False
+        for name, dependency_type in parameters:
+            if not container.has_provider_for(dependency_type):
+                continue
+            if uses_deprecated and not warned:
+                _warn_deprecated_marker(request.node.name)
+                warned = True
+            try:
+                request.node.funcargs[name] = await container.aresolve(dependency_type)
+            except Exception:  # pragma: no cover
+                logger.warning(
+                    "Failed to resolve '%s' for %s", name, request.node.nodeid
+                )
+
+    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(_resolve, {})
+
+
+def _get_injectable_params(
+    request: pytest.FixtureRequest,
+) -> tuple[list[tuple[str, Any]], bool]:
+    """Get injectable parameters for a test function.
+
+    Returns (parameters, uses_deprecated_marker) tuple.
+    """
+    fixture_names = set(request.node._fixtureinfo.initialnames) - set(
+        request.node._fixtureinfo.name2fixturedefs.keys()
+    )
+
+    marker = request.node.get_closest_marker("inject")
+    autoinject = cast(bool, request.config.getini("anydi_autoinject"))
+
+    has_any_explicit = False
+    explicit_params: list[tuple[str, Any]] = []
+    all_params: list[tuple[str, Any]] = []
+
+    annotations = get_annotations(request.function, eval_str=True)
+
+    for name, annotation in annotations.items():
+        if name in ("request", "return"):
+            continue
+
+        dependency_type, is_explicit = _extract_dependency_type(annotation)
+
+        if is_explicit:
+            has_any_explicit = True
+            explicit_params.append((name, dependency_type))
+        elif name in fixture_names:
+            all_params.append((name, dependency_type))
+
+    # Priority: explicit markers > deprecated @pytest.mark.inject > autoinject
+    if has_any_explicit:
+        return explicit_params, False
+    if marker is not None:
+        return all_params, True
+    if autoinject:
+        return all_params, False
+    return [], False
+
+
+def _extract_dependency_type(annotation: Any) -> tuple[Any, bool]:
+    """Extract the actual type and whether it has an explicit injection marker.
+
+    Handles Provide[T] and Annotated[T, Inject()].
+    Returns (unwrapped_type, is_explicit).
+    """
+    if get_origin(annotation) is Annotated:
+        args = get_args(annotation)
+        for arg in args[1:]:
+            if is_marker(arg):
+                return args[0], True
+    return annotation, False
+
+
+def _find_container(request: pytest.FixtureRequest) -> Container:
+    """Find container from config or auto-detection."""
+    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
+
+    pluginmanager = request.config.pluginmanager
+    if pluginmanager.hasplugin("django") and importlib.util.find_spec("anydi_django"):
+        return import_container("anydi_django.container")
+
+    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 _warn_deprecated_marker(test_name: str) -> None:
+    warnings.warn(
+        f"Using @pytest.mark.inject on test '{test_name}' is deprecated. "
+        "Use Provide[T] instead.",
+        DeprecationWarning,
+        stacklevel=4,
+    )

{anydi-0.68.0 → anydi-0.70.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anydi"
-version = "0.68.0"
+version = "0.70.0"
 description = "Dependency Injection library"
 authors = [{ name = "Anton Ruhlov", email = "antonruhlov@gmail.com" }]
 requires-python = ">=3.10.0, <3.15"
@@ -114,6 +114,7 @@ enableExperimentalFeatures = true
 addopts = [
     "--strict-config",
     "--strict-markers",
+    "-p", "no:anydi",
 ]
 xfail_strict = true
 junit_family = "xunit2"

anydi-0.68.0/anydi/ext/pytest_plugin.py

@@ -1,481 +0,0 @@
-from __future__ import annotations
-
-import importlib.util
-import inspect
-import logging
-from collections.abc import Callable, Iterator
-from typing import Any, cast
-
-import pytest
-from anyio.pytest_plugin import extract_backend_and_options, get_runner
-from typing_extensions import get_annotations
-
-from anydi import Container, import_container
-
-logger = logging.getLogger(__name__)
-
-# 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="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,
-    )
-
-
-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.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:
-        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)
-        )
-        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 with testing mode enabled."""
-    container = _find_container(request)
-    container.enable_test_mode()
-    return container
-
-
-@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"))
-    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
-def _anydi_injected_parameter_iterator(
-    request: pytest.FixtureRequest,
-) -> Callable[[], Iterator[tuple[str, Any]]]:
-    fixturenames = set(request.node._fixtureinfo.initialnames) - set(
-        request.node._fixtureinfo.name2fixturedefs.keys()
-    )
-
-    def _iterator() -> Iterator[tuple[str, Any]]:
-        for name, annotation in _iter_injectable_parameters(request.function):
-            if name not in fixturenames:
-                continue
-            yield name, annotation
-
-    return _iterator
-
-
-@pytest.fixture(autouse=True)
-def _anydi_inject(
-    request: pytest.FixtureRequest,
-    _anydi_should_inject: bool,
-    _anydi_injected_parameter_iterator: Callable[[], Iterator[tuple[str, Any]]],
-) -> None:
-    """Inject dependencies into the test function."""
-
-    if inspect.iscoroutinefunction(request.function) or not _anydi_should_inject:
-        return
-
-    parameters = list(_anydi_injected_parameter_iterator())
-    if not parameters:
-        return
-
-    container = cast(Container, request.getfixturevalue("container"))
-    resolvable = _select_resolvable_parameters(container, parameters)
-    if not resolvable:
-        return
-
-    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)
-def _anydi_ainject(
-    request: pytest.FixtureRequest,
-    _anydi_should_inject: bool,
-    _anydi_injected_parameter_iterator: Callable[[], Iterator[tuple[str, Any]]],
-) -> None:
-    """Inject dependencies into the test function."""
-    if (
-        not inspect.iscoroutinefunction(request.function)
-        and not inspect.isasyncgenfunction(request.function)
-        or not _anydi_should_inject
-    ):
-        return
-
-    # Skip if the anyio backend is not available
-    if "anyio_backend" not in request.fixturenames:
-        msg = (
-            "To run async test functions with `anyio`, "
-            "please configure the `anyio` pytest plugin.\n"
-            "See: https://anyio.readthedocs.io/en/stable/testing.html"
-        )
-        pytest.fail(msg, pytrace=False)
-
-    parameters = list(_anydi_injected_parameter_iterator())
-    if not parameters:
-        return
-
-    container = cast(Container, request.getfixturevalue("container"))
-    resolvable = _select_resolvable_parameters(container, parameters)
-    if not resolvable:
-        return
-
-    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]:
-    container.enable_test_mode()
-    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]:
-    container.enable_test_mode()
-    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