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

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

anydi/ext/starlette/middleware.py

@@ -5,7 +5,7 @@ from starlette.requests import Request
 from starlette.responses import Response
 from starlette.types import ASGIApp
 
-from anydi._container import Container
+from anydi import Container
 
 
 class RequestScopedMiddleware(BaseHTTPMiddleware):

{anydi-0.56.0.dist-info → anydi-0.58.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anydi
-Version: 0.56.0
+Version: 0.58.0
 Summary: Dependency Injection library
 Keywords: dependency injection,dependencies,di,async,asyncio,application
 Author: Anton Ruhlov
@@ -58,9 +58,9 @@ 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.
+* **Scoped**: Built-in singleton, transient, and request scopes, plus custom scopes.
 * **Simple**: Small surface area keeps boilerplate low.
-* **Fast**: Resolver still adds only microseconds of overhead.
+* **Fast**: Has minimal overhead and resolves dependencies quickly.
 * **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.
@@ -74,7 +74,7 @@ The key features are:
 pip install anydi
 ```
 
-## Comprehensive Example
+## Quick Example
 
 ### Define a Service (`app/services.py`)
 
@@ -116,19 +116,18 @@ if __name__ == "__main__":
 ### Inject Into Functions (`app/main.py`)
 
 ```python
-from anydi import Inject
+from anydi import Provide
 
 from app.container import container
 from app.services import GreetingService
 
 
-@container.inject
-def greet(service: GreetingService = Inject()) -> str:
+def greet(service: Provide[GreetingService]) -> str:
     return service.greet("World")
 
 
 if __name__ == "__main__":
-    print(greet())
+    print(container.run(greet))
 ```
 
 ### Test with Overrides (`tests/test_app.py`)
@@ -146,7 +145,7 @@ def test_greet() -> None:
     service_mock.greet.return_value = "Mocked"
 
     with container.override(GreetingService, service_mock):
-        result = greet()
+        result = container.run(greet)
 
     assert result == "Mocked"
 ```
@@ -158,8 +157,8 @@ from typing import Annotated
 
 import anydi.ext.fastapi
 from fastapi import FastAPI
-from anydi.ext.fastapi import Inject
 
+from anydi import Provide
 from app.container import container
 from app.services import GreetingService
 
@@ -169,7 +168,7 @@ app = FastAPI()
 
 @app.get("/greeting")
 async def greet(
-    service: Annotated[GreetingService, Inject()]
+    service: Provide[GreetingService]
 ) -> dict[str, str]:
     return {"greeting": service.greet("World")}
 
@@ -245,7 +244,7 @@ Wire Django Ninja (`urls.py`):
 ```python
 from typing import Annotated, Any
 
-from anydi import Inject
+from anydi import Provide
 from django.http import HttpRequest
 from django.urls import path
 from ninja import NinjaAPI
@@ -257,7 +256,7 @@ api = NinjaAPI()
 
 
 @api.get("/greeting")
-def greet(request: HttpRequest, service: Annotated[GreetingService, Inject()]) -> Any:
+def greet(request: HttpRequest, service: Provide[GreetingService]) -> Any:
     return {"greeting": service.greet("World")}
 
 
@@ -265,3 +264,23 @@ urlpatterns = [
     path("api/", api.urls),
 ]
 ```
+
+## What's Next?
+
+Ready to learn more? Check out these resources:
+
+**Core Documentation:**
+- [Core Concepts](https://anydi.readthedocs.io/en/latest/concepts/) - Understand containers, providers, scopes, and dependency injection
+- [Providers](https://anydi.readthedocs.io/en/latest/usage/providers/) - Learn about registration, named providers, and resource management
+- [Scopes](https://anydi.readthedocs.io/en/latest/usage/scopes/) - Master lifecycle management with built-in and custom scopes
+- [Dependency Injection](https://anydi.readthedocs.io/en/latest/usage/injection/) - Explore injection patterns and techniques
+- [Testing](https://anydi.readthedocs.io/en/latest/usage/testing/) - Write testable code with provider overrides
+
+**Framework Integrations:**
+- [FastAPI](https://anydi.readthedocs.io/en/latest/extensions/fastapi/) - Build modern APIs with automatic dependency injection
+- [Django](https://anydi.readthedocs.io/en/latest/extensions/django/) - Integrate with Django and Django Ninja
+- [FastStream](https://anydi.readthedocs.io/en/latest/extensions/faststream/) - Message broker applications
+- [Pydantic Settings](https://anydi.readthedocs.io/en/latest/extensions/pydantic_settings/) - Configuration management
+
+**Full Documentation:**
+- [Read the Docs](https://anydi.readthedocs.io/) - Complete documentation with examples and guides

anydi-0.58.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+anydi/__init__.py,sha256=bQKzn9qfNnIMi1m3J-DdSknSDwNg8j08fdQg_-Edkto,613
+anydi/_async_lock.py,sha256=3dwZr0KthXFYha0XKMyXf8jMmGb1lYoNC0O5w29V9ic,1104
+anydi/_container.py,sha256=j8XM5UYw3PVwPq92TMtEwLwqcMObs-9ZTGAEsTj4caE,26023
+anydi/_context.py,sha256=-9QqeMWo9OpZVXZxZCQgIsswggl3Ch7lgx1KiFX_ezc,3752
+anydi/_decorators.py,sha256=J3W261ZAG7q4XKm4tbAv1wsWr9ysx9_5MUbUvSJB_MQ,2809
+anydi/_injector.py,sha256=IxKTh2rzMHrsW554tbiJl33Hb5sRGKYY_NU1rC4UvxE,4378
+anydi/_module.py,sha256=2kN5uEXLd2Dsc58gz5IWK43wJewr_QgIVGSO3iWp798,2609
+anydi/_provider.py,sha256=OV1WFHTYv7W2U0XDk_Kql1r551Vhq8o-pUV5ep1HQcU,1574
+anydi/_resolver.py,sha256=dMtWU4OHWMYP7J2Rks0sdwyjLHF1uKo77lnvTGhhtBo,30222
+anydi/_scanner.py,sha256=rbRkHzyd2zMu7AFLffN6_tZJcMaW9gy7E-lVdHLHYrs,4294
+anydi/_types.py,sha256=tLJS27j0lWJFd4fIIGlGbbfKBVTPTnWgPYqZlenktis,2939
+anydi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anydi/ext/django/__init__.py,sha256=Ve8lncLU9dPY_Vjt4zihPgsSxwAtFHACn0XvBM5JG8k,367
+anydi/ext/fastapi.py,sha256=TQoS1Vh9chV0Tj0qyxjgqoGTYEMC3jp0il9CDZCZLcc,2326
+anydi/ext/faststream.py,sha256=XT80r1FGL-xlU7r8urm9sNpUfl4OPMJseW4dade_fR4,1836
+anydi/ext/pydantic_settings.py,sha256=jVJZ1wPaPpsxdNPlJj9yq282ebqLZ9tckWpZ0eIwWLg,1533
+anydi/ext/pytest_plugin.py,sha256=M54DkA-KxD9GqLnXdoCyn-Qur2c44MB6d0AgJuYCZ5w,16171
+anydi/ext/starlette/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anydi/ext/starlette/middleware.py,sha256=9CQtGg5ZzUz2gFSzJr8U4BWzwNjK8XMctm3n52M77Z0,792
+anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anydi/testing.py,sha256=cHg3mMScZbEep9smRqSNQ81BZMQOkyugHe8TvKdPnEg,1347
+anydi-0.58.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+anydi-0.58.0.dist-info/entry_points.txt,sha256=AgOcQYM5KyS4D37QcYb00tiid0QA-pD1VrjHHq4QAps,44
+anydi-0.58.0.dist-info/METADATA,sha256=KE1cG2fc8ZyuoUBMhGP0pUqcUkr2z8ZOGjPVy3-ILV0,7901
+anydi-0.58.0.dist-info/RECORD,,

anydi-0.56.0.dist-info/RECORD

@@ -1,24 +0,0 @@
-anydi/__init__.py,sha256=Cz-beqReX0d05SFDmYcrzIs3FqQkWAwpy1Aqzd5db34,547
-anydi/_async_lock.py,sha256=3dwZr0KthXFYha0XKMyXf8jMmGb1lYoNC0O5w29V9ic,1104
-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=-MF2KsERF5qzU6uqYPF1fI58isgsjxXPLERylzFFDHE,28787
-anydi/_scanner.py,sha256=oycIC9kw9fsIG9qgtRHeBkj3HjmcLK0FTqWLXTLLSWE,3636
-anydi/_types.py,sha256=l3xQ0Zn15gRAwvBoQ9PRfCBigi2rrtSqGV-C50xXrLw,1780
-anydi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anydi/ext/django/__init__.py,sha256=Ve8lncLU9dPY_Vjt4zihPgsSxwAtFHACn0XvBM5JG8k,367
-anydi/ext/fastapi.py,sha256=FflFBdK-moyv9Vsfem4NyNt8jgPwFLweeCl5cfU0Iks,2348
-anydi/ext/faststream.py,sha256=dJPInvi0JUx-SS8H4aBRl3u-PAW6S_TqqfxVOl3D1L0,1929
-anydi/ext/pydantic_settings.py,sha256=0GQjw7QpQlT5p6GxFClXYdtc6J42PClmAnRWPEzMjvY,1488
-anydi/ext/pytest_plugin.py,sha256=Es1K1S6_2gIdTUYkbw2d1aZcHnjJutGFafVsLPGcVJc,4684
-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=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,,