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

anydi/_container.py

@@ -671,13 +671,17 @@ class Container:
     ) -> None:
         self._scanner.scan(packages=packages, tags=tags)
 
-    # == Testing ==
+    # == Testing / Override Support ==
 
     @contextlib.contextmanager
     def override(self, interface: Any, instance: Any) -> Iterator[None]:
-        raise RuntimeError(
-            "Dependency overriding is not supported in this container.\n"
-            "Wrap your container with `anydi.testing.Container` instead.\n"
-            "Example:\n\n"
-            "    container = TestContainer.from_container(container)"
-        )
+        """Override a dependency with a specific instance for testing."""
+        if not self.has_provider_for(interface):
+            raise LookupError(
+                f"The provider interface `{type_repr(interface)}` not registered."
+            )
+        self._resolver.add_override(interface, instance)
+        try:
+            yield
+        finally:
+            self._resolver.remove_override(interface)

anydi/_resolver.py

@@ -6,6 +6,7 @@ import contextlib
 from typing import TYPE_CHECKING, Any, NamedTuple
 
 import anyio.to_thread
+import wrapt  # type: ignore
 from typing_extensions import type_repr
 
 from ._provider import Provider
@@ -15,6 +16,18 @@ if TYPE_CHECKING:
     from ._container import Container
 
 
+class InstanceProxy(wrapt.ObjectProxy):  # type: ignore
+    """Proxy for dependency instances to enable override support."""
+
+    def __init__(self, wrapped: Any, *, interface: type[Any]) -> None:
+        super().__init__(wrapped)  # type: ignore
+        self._self_interface = interface
+
+    @property
+    def interface(self) -> type[Any]:
+        return self._self_interface
+
+
 class CompiledResolver(NamedTuple):
     resolve: Any
     create: Any
@@ -24,32 +37,46 @@ class Resolver:
     def __init__(self, container: Container) -> None:
         self._container = container
         self._unresolved_interfaces: set[Any] = set()
+        # Normal caches (fast path, no override checks)
         self._cache: dict[Any, CompiledResolver] = {}
         self._async_cache: dict[Any, CompiledResolver] = {}
+        # Override caches (with override support)
+        self._override_cache: dict[Any, CompiledResolver] = {}
+        self._async_override_cache: dict[Any, CompiledResolver] = {}
+        # Override instances storage
+        self._override_instances: dict[Any, Any] = {}
 
-        # Determine compilation flags based on whether methods are overridden
-        self._has_override_support = callable(
-            getattr(self._container, "_hook_override_for", None)
-        )
-        self._wrap_dependencies = callable(
-            getattr(self._container, "_hook_wrap_dependency", None)
-        )
-        self._wrap_instance = callable(
-            getattr(self._container, "_hook_post_resolve", None)
-        )
+    @property
+    def override_mode(self) -> bool:
+        """Check if override mode is enabled."""
+        return bool(self._override_instances)
+
+    def add_override(self, interface: Any, instance: Any) -> None:
+        """Add an override instance for an interface."""
+        self._override_instances[interface] = instance
+
+    def remove_override(self, interface: Any) -> None:
+        """Remove an override instance for an interface."""
+        self._override_instances.pop(interface, None)
 
     def add_unresolved(self, interface: Any) -> None:
         self._unresolved_interfaces.add(interface)
 
     def get_cached(self, interface: Any, *, is_async: bool) -> CompiledResolver | None:
         """Get cached resolver if it exists."""
-        cache = self._async_cache if is_async else self._cache
+        if self.override_mode:
+            cache = self._async_override_cache if is_async else self._override_cache
+        else:
+            cache = self._async_cache if is_async else self._cache
         return cache.get(interface)
 
     def compile(self, provider: Provider, *, is_async: bool) -> CompiledResolver:
         """Compile an optimized resolver function for the given provider."""
-        # Select the appropriate cache based on sync/async mode
-        cache = self._async_cache if is_async else self._cache
+        # Select the appropriate cache based on sync/async mode and override mode
+        if self.override_mode:
+            cache = self._async_override_cache if is_async else self._override_cache
+        else:
+            cache = self._async_cache if is_async else self._cache
 
         # Check if already compiled in cache
         if provider.interface in cache:
@@ -61,20 +88,58 @@ class Resolver:
                 self.compile(p.provider, is_async=is_async)
 
         # Compile the resolver and creator functions
-        compiled = self._compile_resolver(provider, is_async=is_async)
+        compiled = self._compile_resolver(
+            provider, is_async=is_async, with_override=self.override_mode
+        )
 
         # Store the compiled functions in the cache
         cache[provider.interface] = compiled
 
         return compiled
 
+    def _add_override_check(
+        self, lines: list[str], *, include_not_set: bool = False
+    ) -> None:
+        """Add override checking code to generated resolver."""
+        lines.append("    override_mode = resolver.override_mode")
+        lines.append("    if override_mode:")
+        if include_not_set:
+            lines.append("        NOT_SET_ = _NOT_SET")
+        lines.append("        override = resolver._get_override_for(_interface)")
+        lines.append("        if override is not NOT_SET_:")
+        lines.append("            return override")
+
+    def _add_create_call(
+        self,
+        lines: list[str],
+        *,
+        is_async: bool,
+        with_override: bool,
+        context: str,
+        store: bool,
+        defaults: str = "None",
+        indent: str = "    ",
+    ) -> None:
+        """Add _create_instance call to generated resolver."""
+        override_arg = "override_mode" if with_override else "False"
+        context_arg = context if context else "None"
+        store_arg = "True" if store else "False"
+
+        if is_async:
+            lines.append(
+                f"{indent}return await _create_instance("
+                f"container, {context_arg}, {store_arg}, {defaults}, {override_arg})"
+            )
+        else:
+            lines.append(
+                f"{indent}return _create_instance("
+                f"container, {context_arg}, {store_arg}, {defaults}, {override_arg})"
+            )
+
     def _compile_resolver(  # noqa: C901
-        self, provider: Provider, *, is_async: bool
+        self, provider: Provider, *, is_async: bool, with_override: bool = False
     ) -> CompiledResolver:
         """Compile optimized resolver functions for the given provider."""
-        has_override_support = self._has_override_support
-        wrap_dependencies = self._wrap_dependencies
-        wrap_instance = self._wrap_instance
         num_params = len(provider.parameters)
         param_resolvers: list[Any] = [None] * num_params
         param_annotations: list[Any] = [None] * num_params
@@ -84,7 +149,11 @@ class Resolver:
         param_shared_scopes: list[bool] = [False] * num_params
         unresolved_messages: list[str] = [""] * num_params
 
-        cache = self._async_cache if is_async else self._cache
+        cache = (
+            (self._async_override_cache if is_async else self._override_cache)
+            if with_override
+            else (self._async_cache if is_async else self._cache)
+        )
 
         for idx, p in enumerate(provider.parameters):
             param_annotations[idx] = p.annotation
@@ -100,13 +169,13 @@ class Resolver:
                     cache[p.provider.interface] = compiled
                 param_resolvers[idx] = compiled.resolve
 
-            msg = (
+            unresolved_message = (
                 f"You are attempting to get the parameter `{p.name}` with the "
                 f"annotation `{type_repr(p.annotation)}` as a dependency into "
                 f"`{type_repr(provider.call)}` which is not registered or set in the "
                 "scoped context."
             )
-            unresolved_messages[idx] = msg
+            unresolved_messages[idx] = unresolved_message
 
         scope = provider.scope
         is_generator = provider.is_generator
@@ -117,11 +186,13 @@ class Resolver:
         create_lines: list[str] = []
         if is_async:
             create_lines.append(
-                "async def _create_instance(container, context, store, defaults):"
+                "async def _create_instance("
+                "container, context, store, defaults, override_mode):"
             )
         else:
             create_lines.append(
-                "def _create_instance(container, context, store, defaults):"
+                "def _create_instance("
+                "container, context, store, defaults, override_mode):"
             )
 
         if no_params:
@@ -170,8 +241,10 @@ class Resolver:
                 create_lines.append(
                     f"                raise LookupError(_unresolved_messages[{idx}])"
                 )
-                create_lines.append(f"            resolver = _param_resolvers[{idx}]")
-                create_lines.append("            if resolver is None:")
+                create_lines.append(
+                    f"            _dep_resolver = _param_resolvers[{idx}]"
+                )
+                create_lines.append("            if _dep_resolver is None:")
                 create_lines.append("                try:")
                 if is_async:
                     create_lines.append(
@@ -230,21 +303,23 @@ class Resolver:
                 create_lines.append("            else:")
                 if is_async:
                     create_lines.append(
-                        f"                arg_{idx} = await resolver("
+                        f"                arg_{idx} = await _dep_resolver("
                         f"container, "
                         f"context if _param_shared_scopes[{idx}] else None)"
                     )
                 else:
                     create_lines.append(
-                        f"                arg_{idx} = resolver("
+                        f"                arg_{idx} = _dep_resolver("
                         f"container, "
                         f"context if _param_shared_scopes[{idx}] else None)"
                     )
                 create_lines.append("        else:")
                 create_lines.append(f"            arg_{idx} = cached")
-                if wrap_dependencies:
+                # Wrap dependencies if in override mode (only for override version)
+                if with_override:
+                    create_lines.append("    if override_mode:")
                     create_lines.append(
-                        f"    arg_{idx} = container._hook_wrap_dependency("
+                        f"        arg_{idx} = resolver._wrap_for_override("
                         f"_param_annotations[{idx}], arg_{idx})"
                     )
 
@@ -380,9 +455,11 @@ class Resolver:
         create_lines.append("    if context is not None and store:")
         create_lines.append("        context.set(_interface, inst)")
 
-        if wrap_instance:
+        # Wrap instance if in override mode (only for override version)
+        if with_override:
+            create_lines.append("    if override_mode:")
             create_lines.append(
-                "    inst = container._hook_post_resolve(_interface, inst)"
+                "        inst = resolver._post_resolve_override(_interface, inst)"
             )
         create_lines.append("    return inst")
 
@@ -393,7 +470,7 @@ class Resolver:
             resolver_lines.append("def _resolver(container, context=None):")
 
         # Only define NOT_SET_ if we actually need it
-        needs_not_set = has_override_support or scope in ("singleton", "request")
+        needs_not_set = scope in ("singleton", "request")
         if needs_not_set:
             resolver_lines.append("    NOT_SET_ = _NOT_SET")
 
@@ -406,22 +483,14 @@ class Resolver:
         else:
             resolver_lines.append("    context = None")
 
-        if has_override_support:
-            resolver_lines.append(
-                "    override = container._hook_override_for(_interface)"
-            )
-            resolver_lines.append("    if override is not NOT_SET_:")
-            resolver_lines.append("        return override")
-
         if scope == "singleton":
+            if with_override:
+                self._add_override_check(resolver_lines)
+
+            # Fast path: check cached instance
             resolver_lines.append("    inst = context.get(_interface)")
             resolver_lines.append("    if inst is not NOT_SET_:")
-            if wrap_instance:
-                resolver_lines.append(
-                    "        return container._hook_post_resolve(_provider, inst)"
-                )
-            else:
-                resolver_lines.append("        return inst")
+            resolver_lines.append("        return inst")
 
             if is_async:
                 resolver_lines.append("    async with context.alock():")
@@ -429,47 +498,43 @@ class Resolver:
                 resolver_lines.append("    with context.lock():")
             resolver_lines.append("        inst = context.get(_interface)")
             resolver_lines.append("        if inst is not NOT_SET_:")
-            if wrap_instance:
-                resolver_lines.append(
-                    "            return container._hook_post_resolve(_provider, inst)"
-                )
-            else:
-                resolver_lines.append("            return inst")
-            if is_async:
-                resolver_lines.append(
-                    "        return await "
-                    "_create_instance(container, context, True, None)"
-                )
-            else:
-                resolver_lines.append(
-                    "        return _create_instance(container, context, True, None)"
-                )
+            resolver_lines.append("            return inst")
+            self._add_create_call(
+                resolver_lines,
+                is_async=is_async,
+                with_override=with_override,
+                context="context",
+                store=True,
+                indent="        ",
+            )
         elif scope == "request":
+            if with_override:
+                self._add_override_check(resolver_lines)
+
+            # Fast path: check cached instance
             resolver_lines.append("    inst = context.get(_interface)")
             resolver_lines.append("    if inst is not NOT_SET_:")
-            if wrap_instance:
-                resolver_lines.append(
-                    "        return container._hook_post_resolve(_provider, inst)"
-                )
-            else:
-                resolver_lines.append("        return inst")
-            if is_async:
-                resolver_lines.append(
-                    "    return await _create_instance(container, context, True, None)"
-                )
-            else:
-                resolver_lines.append(
-                    "    return _create_instance(container, context, True, None)"
-                )
+            resolver_lines.append("        return inst")
+
+            self._add_create_call(
+                resolver_lines,
+                is_async=is_async,
+                with_override=with_override,
+                context="context",
+                store=True,
+            )
         else:
-            if is_async:
-                resolver_lines.append(
-                    "    return await _create_instance(container, None, False, None)"
-                )
-            else:
-                resolver_lines.append(
-                    "    return _create_instance(container, None, False, None)"
-                )
+            # Transient scope
+            if with_override:
+                self._add_override_check(resolver_lines, include_not_set=True)
+
+            self._add_create_call(
+                resolver_lines,
+                is_async=is_async,
+                with_override=with_override,
+                context="",
+                store=False,
+            )
 
         create_resolver_lines: list[str] = []
         if is_async:
@@ -481,9 +546,9 @@ class Resolver:
                 "def _resolver_create(container, defaults=None):"
             )
 
-        # Only define NOT_SET_ if needed for override support
-        if has_override_support:
-            create_resolver_lines.append("    NOT_SET_ = _NOT_SET")
+        if with_override:
+            # Cache override mode check
+            create_resolver_lines.append("    override_mode = resolver.override_mode")
 
         if scope == "singleton":
             create_resolver_lines.append("    context = container._singleton_context")
@@ -494,43 +559,20 @@ class Resolver:
         else:
             create_resolver_lines.append("    context = None")
 
-        if has_override_support:
-            create_resolver_lines.append(
-                "    override = container._hook_override_for(_interface)"
-            )
-            create_resolver_lines.append("    if override is not NOT_SET_:")
-            create_resolver_lines.append("        return override")
+        if with_override:
+            self._add_override_check(create_resolver_lines, include_not_set=True)
 
-        if scope == "singleton":
-            if is_async:
-                create_resolver_lines.append(
-                    "    return await "
-                    "_create_instance(container, context, False, defaults)"
-                )
-            else:
-                create_resolver_lines.append(
-                    "    return _create_instance(container, context, False, defaults)"
-                )
-        elif scope == "request":
-            if is_async:
-                create_resolver_lines.append(
-                    "    return await "
-                    "_create_instance(container, context, False, defaults)"
-                )
-            else:
-                create_resolver_lines.append(
-                    "    return _create_instance(container, context, False, defaults)"
-                )
-        else:
-            if is_async:
-                create_resolver_lines.append(
-                    "    return await "
-                    "_create_instance(container, None, False, defaults)"
-                )
-            else:
-                create_resolver_lines.append(
-                    "    return _create_instance(container, None, False, defaults)"
-                )
+        # Determine context for create call
+        context_arg = "context" if scope in ("singleton", "request") else ""
+
+        self._add_create_call(
+            create_resolver_lines,
+            is_async=is_async,
+            with_override=with_override,
+            context=context_arg,
+            store=False,
+            defaults="defaults",
+        )
 
         lines = create_lines + [""] + resolver_lines + [""] + create_resolver_lines
 
@@ -552,8 +594,13 @@ class Resolver:
             "_NOT_SET": NOT_SET,
             "_contextmanager": contextlib.contextmanager,
             "_is_cm": is_context_manager,
-            "_cache": self._async_cache if is_async else self._cache,
+            "_cache": (
+                (self._async_override_cache if is_async else self._override_cache)
+                if with_override
+                else (self._async_cache if is_async else self._cache)
+            ),
             "_compile": self._compile_resolver,
+            "resolver": self,
         }
 
         # Add async-specific namespace entries
@@ -569,3 +616,59 @@ class Resolver:
         creator = ns["_resolver_create"]
 
         return CompiledResolver(resolver, creator)
+
+    def _get_override_for(self, interface: Any) -> Any:
+        """Hook for checking if an interface has an override."""
+        return self._override_instances.get(interface, NOT_SET)
+
+    def _wrap_for_override(self, annotation: Any, value: Any) -> Any:
+        """Hook for wrapping dependencies to enable override patching."""
+        return InstanceProxy(value, interface=annotation)
+
+    def _post_resolve_override(self, interface: Any, instance: Any) -> Any:  # noqa: C901
+        """Hook for patching resolved instances to support override."""
+        if interface in self._override_instances:
+            return self._override_instances[interface]
+
+        if not hasattr(instance, "__dict__") or hasattr(
+            instance, "__resolver_getter__"
+        ):
+            return instance
+
+        wrapped = {
+            name: value.interface
+            for name, value in instance.__dict__.items()
+            if isinstance(value, InstanceProxy)
+        }
+
+        def __resolver_getter__(name: str) -> Any:
+            if name in wrapped:
+                _interface = wrapped[name]
+                # Resolve the dependency if it's wrapped
+                return self._container.resolve(_interface)
+            raise LookupError
+
+        # Attach the resolver getter to the instance
+        instance.__resolver_getter__ = __resolver_getter__
+
+        if not hasattr(instance.__class__, "__getattribute_patched__"):
+
+            def __getattribute__(_self: Any, name: str) -> Any:
+                # Skip the resolver getter
+                if name in {"__resolver_getter__", "__class__"}:
+                    return object.__getattribute__(_self, name)
+
+                if hasattr(_self, "__resolver_getter__"):
+                    try:
+                        return _self.__resolver_getter__(name)
+                    except LookupError:
+                        pass
+
+                # Fall back to default behavior
+                return object.__getattribute__(_self, name)
+
+            # Apply the patched resolver if wrapped attributes exist
+            instance.__class__.__getattribute__ = __getattribute__
+            instance.__class__.__getattribute_patched__ = True
+
+        return instance

anydi/testing.py

@@ -1,125 +1,46 @@
-import contextlib
-import logging
-from collections.abc import Iterable, Iterator, Sequence
-from typing import Any
+"""Testing utilities for AnyDI.
 
-import wrapt  # type: ignore
-from typing_extensions import Self, type_repr
+.. deprecated:: 0.56.0
+    TestContainer is deprecated. Use Container with override() instead.
+"""
+
+from __future__ import annotations
+
+import warnings
 
 from ._container import Container
-from ._module import ModuleDef
-from ._provider import ProviderDef
-from ._types import NOT_SET
 
 
 class TestContainer(Container):
+    """Test container for dependency injection.
+
+    .. deprecated:: 0.56.0
+        TestContainer is deprecated and will be removed in a future version.
+        Use regular Container with override() method instead.
+    """
+
     __test__ = False
 
-    def __init__(
-        self,
-        *,
-        providers: Sequence[ProviderDef] | None = None,
-        modules: Iterable[ModuleDef] | None = None,
-        logger: logging.Logger | None = None,
-    ) -> None:
-        super().__init__(providers=providers, modules=modules, logger=logger)
-        self._override_instances: dict[Any, Any] = {}
-        self._revisions: dict[Any, int] = {}
+    def __init__(self, *args, **kwargs):  # type: ignore
+        warnings.warn(
+            "TestContainer is deprecated and will be removed in a future version. "
+            "Use regular Container with override() method instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        super().__init__(*args, **kwargs)
 
     @classmethod
-    def from_container(cls, container: Container) -> Self:
-        return cls(
-            providers=[
-                ProviderDef(
-                    interface=provider.interface,
-                    call=provider.call,
-                    scope=provider.scope,
-                )
-                for provider in container.providers.values()
-            ],
-            logger=container.logger,
-        )
+    def from_container(cls, container: Container) -> Container:
+        """Create a test container from an existing container.
 
-    @contextlib.contextmanager
-    def override(self, interface: Any, instance: Any) -> Iterator[None]:
-        """
-        Override the provider for the specified interface with a specific instance.
+        .. deprecated:: 0.56.0
+            This method is deprecated. Just use the container directly.
         """
-        if not self.has_provider_for(interface):
-            raise LookupError(
-                f"The provider interface `{type_repr(interface)}` not registered."
-            )
-        self._override_instances[interface] = instance
-        self._touch_revision(interface)
-        try:
-            yield
-        finally:
-            self._override_instances.pop(interface, None)
-            self._touch_revision(interface)
-
-    def _touch_revision(self, interface: Any) -> None:
-        self._revisions[interface] = self._revisions.get(interface, 0) + 1
-
-    def _hook_override_for(self, interface: Any) -> Any:
-        return self._override_instances.get(interface, NOT_SET)
-
-    def _hook_wrap_dependency(self, annotation: Any, value: Any) -> Any:
-        return InstanceProxy(value, interface=annotation)
-
-    def _hook_post_resolve(self, interface: Any, instance: Any) -> Any:  # noqa: C901
-        """Patch the test resolver for the instance."""
-        if interface in self._override_instances:
-            return self._override_instances[interface]
-
-        if not hasattr(instance, "__dict__") or hasattr(
-            instance, "__resolver_getter__"
-        ):
-            return instance
-
-        wrapped = {
-            name: value.interface
-            for name, value in instance.__dict__.items()
-            if isinstance(value, InstanceProxy)
-        }
-
-        def __resolver_getter__(name: str) -> Any:
-            if name in wrapped:
-                _interface = wrapped[name]
-                # Resolve the dependency if it's wrapped
-                return self.resolve(_interface)
-            raise LookupError
-
-        # Attach the resolver getter to the instance
-        instance.__resolver_getter__ = __resolver_getter__
-
-        if not hasattr(instance.__class__, "__getattribute_patched__"):
-
-            def __getattribute__(_self: Any, name: str) -> Any:
-                # Skip the resolver getter
-                if name in {"__resolver_getter__", "__class__"}:
-                    return object.__getattribute__(_self, name)
-
-                if hasattr(_self, "__resolver_getter__"):
-                    try:
-                        return _self.__resolver_getter__(name)
-                    except LookupError:
-                        pass
-
-                # Fall back to default behavior
-                return object.__getattribute__(_self, name)
-
-            # Apply the patched resolver if wrapped attributes exist
-            instance.__class__.__getattribute__ = __getattribute__
-            instance.__class__.__getattribute_patched__ = True
-
-        return instance
-
-
-class InstanceProxy(wrapt.ObjectProxy):  # type: ignore
-    def __init__(self, wrapped: Any, *, interface: type[Any]) -> None:
-        super().__init__(wrapped)  # type: ignore
-        self._self_interface = interface
-
-    @property
-    def interface(self) -> type[Any]:
-        return self._self_interface
+        warnings.warn(
+            "TestContainer.from_container() is deprecated. "
+            "Use the container directly with override() method.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return container

anydi-0.56.0.dist-info/METADATA

@@ -0,0 +1,267 @@
+Metadata-Version: 2.4
+Name: anydi
+Version: 0.56.0
+Summary: Dependency Injection library
+Keywords: dependency injection,dependencies,di,async,asyncio,application
+Author: Anton Ruhlov
+Author-email: Anton Ruhlov <antonruhlov@gmail.com>
+License-Expression: MIT
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Dist: typing-extensions>=4.15.0,<5
+Requires-Dist: anyio>=3.7.1
+Requires-Dist: wrapt>=1.17.0
+Requires-Python: >=3.10.0, <3.15
+Project-URL: Repository, https://github.com/antonrh/anydi
+Description-Content-Type: text/markdown
+
+# AnyDI
+
+<div style="text-align: center;">
+
+Modern, lightweight Dependency Injection library using type annotations.
+
+[![CI](https://github.com/antonrh/anydi/actions/workflows/ci.yml/badge.svg)](https://github.com/antonrh/anydi/actions/workflows/ci.yml)
+[![Coverage](https://codecov.io/gh/antonrh/anydi/branch/main/graph/badge.svg)](https://codecov.io/gh/antonrh/anydi)
+[![Documentation](https://readthedocs.org/projects/anydi/badge/?version=latest)](https://anydi.readthedocs.io/en/latest/)
+
+</div>
+
+---
+Documentation
+
+http://anydi.readthedocs.io/
+
+---
+
+`AnyDI` is a modern, lightweight Dependency Injection library suitable for any synchronous or asynchronous applications with Python 3.10+, based on type annotations ([PEP 484](https://peps.python.org/pep-0484/)).
+
+The key features are:
+
+* **Type-safe**: Dependency resolution is driven by type hints.
+* **Async-ready**: Works the same for sync and async providers or injections.
+* **Scoped**: Built-in singleton, transient, and request lifetimes.
+* **Simple**: Small surface area keeps boilerplate low.
+* **Fast**: Resolver still adds only microseconds of overhead.
+* **Named**: `Annotated[...]` makes multiple bindings per type simple.
+* **Managed**: Providers can open/close resources via context managers.
+* **Modular**: Compose containers or modules for large apps.
+* **Scanning**: Auto-discovers injectable callables.
+* **Integrated**: Extensions for popular frameworks.
+* **Testable**: Override providers directly in tests.
+
+## Installation
+
+```shell
+pip install anydi
+```
+
+## Comprehensive Example
+
+### Define a Service (`app/services.py`)
+
+```python
+class GreetingService:
+    def greet(self, name: str) -> str:
+        return f"Hello, {name}!"
+```
+
+### Create the Container and Providers (`app/container.py`)
+
+```python
+from anydi import Container
+
+from app.services import GreetingService
+
+
+container = Container()
+
+
+@container.provider(scope="singleton")
+def service() -> GreetingService:
+    return GreetingService()
+```
+
+### Resolve Dependencies Directly
+
+```python
+from app.container import container
+from app.services import GreetingService
+
+
+service = container.resolve(GreetingService)
+
+if __name__ == "__main__":
+    print(service.greet("World"))
+```
+
+### Inject Into Functions (`app/main.py`)
+
+```python
+from anydi import Inject
+
+from app.container import container
+from app.services import GreetingService
+
+
+@container.inject
+def greet(service: GreetingService = Inject()) -> str:
+    return service.greet("World")
+
+
+if __name__ == "__main__":
+    print(greet())
+```
+
+### Test with Overrides (`tests/test_app.py`)
+
+```python
+from unittest import mock
+
+from app.container import container
+from app.services import GreetingService
+from app.main import greet
+
+
+def test_greet() -> None:
+    service_mock = mock.Mock(spec=GreetingService)
+    service_mock.greet.return_value = "Mocked"
+
+    with container.override(GreetingService, service_mock):
+        result = greet()
+
+    assert result == "Mocked"
+```
+
+### Integrate with FastAPI (`app/api.py`)
+
+```python
+from typing import Annotated
+
+import anydi.ext.fastapi
+from fastapi import FastAPI
+from anydi.ext.fastapi import Inject
+
+from app.container import container
+from app.services import GreetingService
+
+
+app = FastAPI()
+
+
+@app.get("/greeting")
+async def greet(
+    service: Annotated[GreetingService, Inject()]
+) -> dict[str, str]:
+    return {"greeting": service.greet("World")}
+
+
+anydi.ext.fastapi.install(app, container)
+```
+
+### Test the FastAPI Integration (`test_api.py`)
+
+```python
+from unittest import mock
+
+from fastapi.testclient import TestClient
+
+from app.api import app
+from app.container import container
+from app.services import GreetingService
+
+
+client = TestClient(app)
+
+
+def test_api_greeting() -> None:
+    service_mock = mock.Mock(spec=GreetingService)
+    service_mock.greet.return_value = "Mocked"
+
+    with container.override(GreetingService, service_mock):
+        response = client.get("/greeting")
+
+    assert response.json() == {"greeting": "Mocked"}
+```
+
+### Integrate with Django Ninja
+
+Install the Django integration extras:
+
+```sh
+pip install 'anydi-django[ninja]'
+```
+
+Expose the container factory (`app/container.py`):
+
+```python
+from anydi import Container
+
+from app.services import GreetingService
+
+
+container = Container()
+
+
+@container.provider(scope="singleton")
+def service() -> GreetingService:
+    return GreetingService()
+```
+
+Configure Django (`settings.py`):
+
+```python
+INSTALLED_APPS = [
+    ...
+    "anydi_django",
+]
+
+ANYDI = {
+    "CONTAINER_FACTORY": "app.container.container",
+    "PATCH_NINJA": True,
+}
+```
+
+Wire Django Ninja (`urls.py`):
+
+```python
+from typing import Annotated, Any
+
+from anydi import Inject
+from django.http import HttpRequest
+from django.urls import path
+from ninja import NinjaAPI
+
+from app.services import GreetingService
+
+
+api = NinjaAPI()
+
+
+@api.get("/greeting")
+def greet(request: HttpRequest, service: Annotated[GreetingService, Inject()]) -> Any:
+    return {"greeting": service.greet("World")}
+
+
+urlpatterns = [
+    path("api/", api.urls),
+]
+```

{anydi-0.55.1.dist-info → anydi-0.56.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
 anydi/__init__.py,sha256=Cz-beqReX0d05SFDmYcrzIs3FqQkWAwpy1Aqzd5db34,547
 anydi/_async_lock.py,sha256=3dwZr0KthXFYha0XKMyXf8jMmGb1lYoNC0O5w29V9ic,1104
-anydi/_container.py,sha256=6C8LM9PxMahKnu7YLMGJ50dPzYLRknZ9G9RKwyB18wE,24853
+anydi/_container.py,sha256=dKRT4FB0ONyEt2-MRz4T0MZziwZAMb0XyulV6lVn04g,24997
 anydi/_context.py,sha256=-9QqeMWo9OpZVXZxZCQgIsswggl3Ch7lgx1KiFX_ezc,3752
 anydi/_decorators.py,sha256=J3W261ZAG7q4XKm4tbAv1wsWr9ysx9_5MUbUvSJB_MQ,2809
 anydi/_module.py,sha256=2kN5uEXLd2Dsc58gz5IWK43wJewr_QgIVGSO3iWp798,2609
 anydi/_provider.py,sha256=OV1WFHTYv7W2U0XDk_Kql1r551Vhq8o-pUV5ep1HQcU,1574
-anydi/_resolver.py,sha256=olWUYp0PfsWUt7hp2MW69734T29ck6fu3s7Nk4-U7rU,25183
+anydi/_resolver.py,sha256=-MF2KsERF5qzU6uqYPF1fI58isgsjxXPLERylzFFDHE,28787
 anydi/_scanner.py,sha256=oycIC9kw9fsIG9qgtRHeBkj3HjmcLK0FTqWLXTLLSWE,3636
 anydi/_types.py,sha256=l3xQ0Zn15gRAwvBoQ9PRfCBigi2rrtSqGV-C50xXrLw,1780
 anydi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -17,8 +17,8 @@ anydi/ext/pytest_plugin.py,sha256=Es1K1S6_2gIdTUYkbw2d1aZcHnjJutGFafVsLPGcVJc,46
 anydi/ext/starlette/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/ext/starlette/middleware.py,sha256=MxnzshAs-CMvjJp0r457k52MzBL8O4KAuClnF6exBdU,803
 anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anydi/testing.py,sha256=JNXA-XGjkU7PMturkzDzumDcLlnYOLzCtBUQ9HyQMLM,4309
-anydi-0.55.1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
-anydi-0.55.1.dist-info/entry_points.txt,sha256=AgOcQYM5KyS4D37QcYb00tiid0QA-pD1VrjHHq4QAps,44
-anydi-0.55.1.dist-info/METADATA,sha256=TEL8yqko7Et9BJW8uiUq8r-Hjjj5PcYYXBS91eHTuPE,4799
-anydi-0.55.1.dist-info/RECORD,,
+anydi/testing.py,sha256=cHg3mMScZbEep9smRqSNQ81BZMQOkyugHe8TvKdPnEg,1347
+anydi-0.56.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+anydi-0.56.0.dist-info/entry_points.txt,sha256=AgOcQYM5KyS4D37QcYb00tiid0QA-pD1VrjHHq4QAps,44
+anydi-0.56.0.dist-info/METADATA,sha256=JkjqRSFZ-Vu22IYLnWS2uRTZA7uUbX41o2b-51yp0dA,6561
+anydi-0.56.0.dist-info/RECORD,,

anydi-0.55.1.dist-info/METADATA

@@ -1,193 +0,0 @@
-Metadata-Version: 2.4
-Name: anydi
-Version: 0.55.1
-Summary: Dependency Injection library
-Keywords: dependency injection,dependencies,di,async,asyncio,application
-Author: Anton Ruhlov
-Author-email: Anton Ruhlov <antonruhlov@gmail.com>
-License-Expression: MIT
-Classifier: Intended Audience :: Information Technology
-Classifier: Intended Audience :: System Administrators
-Classifier: Operating System :: OS Independent
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Topic :: Internet
-Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Topic :: Software Development
-Classifier: Typing :: Typed
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Dist: typing-extensions>=4.15.0,<5
-Requires-Dist: anyio>=3.7.1
-Requires-Dist: wrapt>=1.17.0,<2
-Requires-Python: >=3.10.0, <3.15
-Project-URL: Repository, https://github.com/antonrh/anydi
-Description-Content-Type: text/markdown
-
-# AnyDI
-
-<div style="text-align: center;">
-
-Modern, lightweight Dependency Injection library using type annotations.
-
-[![CI](https://github.com/antonrh/anydi/actions/workflows/ci.yml/badge.svg)](https://github.com/antonrh/anydi/actions/workflows/ci.yml)
-[![Coverage](https://codecov.io/gh/antonrh/anydi/branch/main/graph/badge.svg)](https://codecov.io/gh/antonrh/anydi)
-[![Documentation](https://readthedocs.org/projects/anydi/badge/?version=latest)](https://anydi.readthedocs.io/en/latest/)
-
-</div>
-
----
-Documentation
-
-http://anydi.readthedocs.io/
-
----
-
-`AnyDI` is a modern, lightweight Dependency Injection library suitable for any synchronous or asynchronous applications with Python 3.10+, based on type annotations ([PEP 484](https://peps.python.org/pep-0484/)).
-
-The key features are:
-
-* **Type-safe**: Resolves dependencies using type annotations.
-* **Async Support**: Compatible with both synchronous and asynchronous providers and injections.
-* **Scoping**: Supports singleton, transient, and request scopes.
-* **Easy to Use**: Designed for simplicity and minimal boilerplate.
-* **Named Dependencies**: Supports named dependencies using `Annotated` type.
-* **Resource Management**: Manages resources using context managers.
-* **Modular: Facilitates** a modular design with support for multiple modules.
-* **Scanning**: Automatically scans for injectable functions and classes.
-* **Integrations**: Provides easy integration with popular frameworks and libraries.
-* **Testing**: Simplifies testing by allowing provider overrides.
-
-## Installation
-
-```shell
-pip install anydi
-```
-
-## Quick Example
-
-*app.py*
-
-```python
-from anydi import auto, Container
-
-container = Container()
-
-
-@container.provider(scope="singleton")
-def message() -> str:
-    return "Hello, World!"
-
-
-@container.inject
-def say_hello(message: str = auto) -> None:
-    print(message)
-
-
-if __name__ == "__main__":
-    say_hello()
-```
-
-## FastAPI Example
-
-*app.py*
-
-```python
-from typing import Annotated
-
-from fastapi import FastAPI
-
-import anydi.ext.fastapi
-from anydi import Container
-from anydi.ext.fastapi import Inject
-
-container = Container()
-
-
-@container.provider(scope="singleton")
-def message() -> str:
-    return "Hello, World!"
-
-
-app = FastAPI()
-
-
-@app.get("/hello")
-def say_hello(message: Annotated[str, Inject()]) -> dict[str, str]:
-    return {"message": message}
-
-
-# Install the container into the FastAPI app
-anydi.ext.fastapi.install(app, container)
-```
-
-
-
-## Django Ninja Example
-
-### Install
-
-```sh
-pip install 'anydi-django[ninja]'
-```
-
-*container.py*
-
-```python
-from anydi import Container
-
-
-def get_container() -> Container:
-    container = Container()
-
-    @container.provider(scope="singleton")
-    def message() -> str:
-        return "Hello, World!"
-
-    return container
-```
-
-*settings.py*
-
-```python
-INSTALLED_APPS = [
-    ...
-    "anydi_django",
-]
-
-ANYDI = {
-    "CONTAINER_FACTORY": "myapp.container.get_container",
-    "PATCH_NINJA": True,
-}
-```
-
-*urls.py*
-
-```python
-from django.http import HttpRequest
-from django.urls import path
-from ninja import NinjaAPI
-
-from anydi import auto
-
-api = NinjaAPI()
-
-
-@api.get("/hello")
-def say_hello(request: HttpRequest, message: str = auto) -> dict[str, str]:
-    return {"message": message}
-
-
-urlpatterns = [
-    path("api/", api.urls),
-]
-```