anydi 0.67.2__py3-none-any.whl → 0.69.0__py3-none-any.whl

anydi/ext/pytest_plugin.py

@@ -3,34 +3,24 @@ from __future__ import annotations
 import importlib.util
 import inspect
 import logging
-from collections.abc import Callable, Iterator
-from typing import Any, cast
+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
 
-logger = logging.getLogger(__name__)
+if TYPE_CHECKING:
+    from _pytest.fixtures import SubRequest
 
-# Storage for fixtures with inject markers
-_INJECTED_FIXTURES: dict[str, dict[str, Any]] = {}
+logger = logging.getLogger(__name__)
 
 
 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=(
@@ -41,144 +31,30 @@ def pytest_addoption(parser: pytest.Parser) -> None:
         default=None,
     )
     parser.addini(
-        "anydi_fixture_inject_enabled",
-        help=(
-            "Enable dependency injection into fixtures marked with @pytest.mark.inject"
-        ),
+        "anydi_autoinject",
+        help="Automatically inject dependencies into all test functions",
         type="bool",
-        default=False,
+        default=True,
     )
 
 
 def pytest_configure(config: pytest.Config) -> None:
     config.addinivalue_line(
         "markers",
-        "inject: mark test as needing dependency injection",
+        "inject: mark test as needing dependency injection (deprecated)",
     )
 
-    # 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
+def pytest_fixture_setup(
+    fixturedef: pytest.FixtureDef[Any], request: SubRequest
+) -> Generator[None]:
+    """Automatically enable test mode on the container fixture."""
     yield
-
-    # Restore the original function
-    fixturedef.func = original_fixture_func  # type: ignore[misc]
+    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")
@@ -187,118 +63,133 @@ def container(request: pytest.FixtureRequest) -> Container:
     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"))
-    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:
+def _anydi_inject(request: pytest.FixtureRequest) -> None:
+    """Inject dependencies into sync test functions."""
+    if inspect.iscoroutinefunction(request.function):
         return
 
-    parameters = list(_anydi_injected_parameter_iterator())
+    parameters, uses_deprecated = _get_injectable_params(request)
     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
+    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,
-    _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
-    ):
+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
 
-    # Skip if the anyio backend is not available
     if "anyio_backend" not in request.fixturenames:
-        msg = (
+        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"
+            "See: https://anyio.readthedocs.io/en/stable/testing.html",
+            pytrace=False,
         )
-        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
+    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(_awrapper, {})
+        runner.run_fixture(_resolve, {})
 
 
-def _find_container(request: pytest.FixtureRequest) -> Container:
-    """Find container."""
+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
 
-    # Look for 'anydi_container' defined in pytest.ini (highest priority)
+
+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:
@@ -309,12 +200,10 @@ def _find_container(request: pytest.FixtureRequest) -> Container:
                 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,
@@ -324,154 +213,10 @@ def _find_container(request: pytest.FixtureRequest) -> Container:
     )
 
 
-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
+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/ext/typer.py

@@ -91,17 +91,17 @@ def _process_callback(callback: Callable[..., Any], container: Container) -> Any
 
     # Validate parameters and collect which ones need injection
     for parameter in sig.parameters.values():
-        interface, should_inject, _ = container.validate_injected_parameter(
+        dependency_type, should_inject, _ = container.validate_injected_parameter(
             parameter, call=callback
         )
         processed_parameter = container._injector.unwrap_parameter(parameter)
         if should_inject:
             injected_param_names.add(parameter.name)
             try:
-                scopes.add(container.providers[interface].scope)
+                scopes.add(container.providers[dependency_type].scope)
             except KeyError:
-                if inspect.isclass(interface) and is_provided(interface):
-                    scopes.add(interface.__provided__["scope"])
+                if inspect.isclass(dependency_type) and is_provided(dependency_type):
+                    scopes.add(dependency_type.__provided__["scope"])
         else:
             non_injected_params.append(processed_parameter)
 

{anydi-0.67.2.dist-info → anydi-0.69.0.dist-info}/METADATA

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

anydi-0.69.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+anydi/__init__.py,sha256=KFX8OthKXwBuYDPCV61t-044DpJ88tAOzIxeUWRC5OA,633
+anydi/_async_lock.py,sha256=3dwZr0KthXFYha0XKMyXf8jMmGb1lYoNC0O5w29V9ic,1104
+anydi/_cli.py,sha256=0BhNvWPyuIGzUkDELIBm_nsEMWk7MtLi3oTvgXj5oko,2072
+anydi/_container.py,sha256=lxUkRYU35qSiwTZYXfydElD28n2imzS81qRAAIhiHZU,46677
+anydi/_context.py,sha256=ZQWxtBXWkrMsCk_L7K_A7-e09v5Mv9HApPH3LZ6ZF9k,3648
+anydi/_decorators.py,sha256=7FvgmBDruv1w_iVqwloPzZwQQgyzQCklM6r9f6UVn-E,5728
+anydi/_graph.py,sha256=X7AYsTMcGZtnIUJD5CVc1t8-t54fSI8CY_xh6ijODWk,7945
+anydi/_injector.py,sha256=RvnPEYOgkg-WOIW1ItvVsoAZaSC9wmCnWQrfXad_86A,4507
+anydi/_marker.py,sha256=yXSPbIVU-X-jMSawtCHWFMKke5VpWMiBRZlEH8PlUqE,3373
+anydi/_module.py,sha256=2kN5uEXLd2Dsc58gz5IWK43wJewr_QgIVGSO3iWp798,2609
+anydi/_provider.py,sha256=5pMXyiGwBo2j6OHaoOktLQfiX2rkCf5aYXFlFi65JlQ,2898
+anydi/_resolver.py,sha256=CTYCjYkUXX35o2VMwvVwXyF8Kqp7h2tXituCNq6oydM,32746
+anydi/_scanner.py,sha256=rCPbpW_5OV9MwYQdwTfceV_MlwSMPfpTTKuxdcMmV98,5804
+anydi/_types.py,sha256=lsShY_-_CM2EFajeknAYXvLl-rHfopBT8udnK5_BtS4,1161
+anydi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anydi/ext/django/__init__.py,sha256=Ve8lncLU9dPY_Vjt4zihPgsSxwAtFHACn0XvBM5JG8k,367
+anydi/ext/fastapi.py,sha256=NowHc-z_Sw069YDv9vP98Mehum5vHsIIcqvDkRmicmc,2964
+anydi/ext/faststream.py,sha256=_3FZ8vlgl1GVizVv_6ippvwSWu_Zor4qm6HaiAp24o4,2744
+anydi/ext/pydantic_settings.py,sha256=y6uz0MiLtqPvRO186bIdRZVQfezLvRUfT3KvvB5fCWk,1524
+anydi/ext/pytest_plugin.py,sha256=rLZ6NZUYklSg1rYx0FPdSvVmEY-faZTYqEY5qUWqZXk,7336
+anydi/ext/starlette/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anydi/ext/starlette/middleware.py,sha256=n_JJ7BcG2Mg2M5HwM_SBboxZ-mnnD6WWJn4khq7Bgbs,1860
+anydi/ext/typer.py,sha256=c7HapXQfKhnLJQcHNncJAGd8jZ3crX5it6-MRCJjyPM,6268
+anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anydi/testing.py,sha256=cHg3mMScZbEep9smRqSNQ81BZMQOkyugHe8TvKdPnEg,1347
+anydi-0.69.0.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+anydi-0.69.0.dist-info/entry_points.txt,sha256=oDl_yEX12KlWcDzsZBTg85GG1Jl1rpiYOG4C7EJvebs,87
+anydi-0.69.0.dist-info/METADATA,sha256=h8I4S5WOovGNeSInAJUV_9ASebz1FClByn1Ds4DcNRg,8061
+anydi-0.69.0.dist-info/RECORD,,

{anydi-0.67.2.dist-info → anydi-0.69.0.dist-info}/entry_points.txt

@@ -1,3 +1,6 @@
+[console_scripts]
+anydi = anydi._cli:main
+
 [pytest11]
 anydi = anydi.ext.pytest_plugin