anydi 0.26.8a0__py3-none-any.whl → 0.27.0a0__py3-none-any.whl

anydi/_container.py

@@ -11,9 +11,11 @@ from contextvars import ContextVar
 from functools import wraps
 from typing import (
     Any,
+    AsyncContextManager,
     AsyncIterator,
     Awaitable,
     Callable,
+    ContextManager,
     Iterable,
     Iterator,
     Mapping,
@@ -41,7 +43,7 @@ from ._context import (
 from ._logger import logger
 from ._module import Module, ModuleRegistry
 from ._scanner import Scanner
-from ._types import AnyInterface, Event, Interface, Provider, Scope, is_marker
+from ._types import AnyInterface, Interface, Provider, Scope, is_marker
 from ._utils import (
     get_full_qualname,
     get_typed_parameters,
@@ -84,7 +86,7 @@ class Container:
             strict: Whether to enable strict mode. Defaults to False.
         """
         self._providers: dict[type[Any], Provider] = {}
-        self._resource_cache: dict[Scope, list[type[Any]]] = defaultdict(list)
+        self._providers_cache: dict[Scope, list[type[Any]]] = defaultdict(list)
         self._singleton_context = SingletonContext(self)
         self._transient_context = TransientContext(self)
         self._request_context_var: ContextVar[RequestContext | None] = ContextVar(
@@ -170,7 +172,7 @@ class Container:
 
         # Create Event type
         if provider.is_resource and (interface is NoneType or interface is None):
-            interface = type(f"Event_{uuid.uuid4().hex}", (Event,), {})
+            interface = type(f"Event_{uuid.uuid4().hex}", (), {})
 
         if interface in self._providers:
             if override:
@@ -223,7 +225,7 @@ class Container:
                 scoped_context.delete(interface)
 
         # Cleanup provider references
-        self._delete_provider(interface)
+        self._providers.pop(interface, None)
 
     def _get_provider(self, interface: AnyInterface) -> Provider:
         """Get provider by interface.
@@ -284,17 +286,7 @@ class Container:
         """
         self._providers[interface] = provider
         if provider.is_resource:
-            self._resource_cache[provider.scope].append(interface)
-
-    def _delete_provider(self, interface: AnyInterface) -> None:
-        """Delete a provider by interface.
-
-        Args:
-            interface: The interface for which to delete the provider.
-        """
-        provider = self._providers.pop(interface, None)
-        if provider is not None and provider.is_resource:
-            self._resource_cache[provider.scope].remove(interface)
+            self._providers_cache[provider.scope].append(interface)
 
     def _validate_provider_scope(self, provider: Provider) -> None:
         """Validate the scope of a provider.
@@ -429,9 +421,9 @@ class Container:
         exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: types.TracebackType | None,
-    ) -> bool:
+    ) -> None:
         """Exit the singleton context."""
-        return self._singleton_context.__exit__(exc_type, exc_val, exc_tb)
+        self.close()
 
     def start(self) -> None:
         """Start the singleton context."""
@@ -441,13 +433,20 @@ class Container:
         """Close the singleton context."""
         self._singleton_context.close()
 
-    @contextlib.contextmanager
-    def request_context(self) -> Iterator[None]:
+    def request_context(self) -> ContextManager[None]:
         """Obtain a context manager for the request-scoped context.
 
         Returns:
             A context manager for the request-scoped context.
         """
+        return contextlib.contextmanager(self._request_context)()
+
+    def _request_context(self) -> Iterator[None]:
+        """Internal method that manages the request-scoped context.
+
+        Yields:
+            Yield control to the code block within the request context.
+        """
         context = RequestContext(self)
         token = self._request_context_var.set(context)
         with context:
@@ -464,25 +463,34 @@ class Container:
         exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: types.TracebackType | None,
-    ) -> bool:
+    ) -> None:
         """Exit the singleton context."""
-        return await self._singleton_context.__aexit__(exc_type, exc_val, exc_tb)
+        await self.aclose()
 
     async def astart(self) -> None:
         """Start the singleton context asynchronously."""
-        await self._singleton_context.astart()
+        for interface, provider in self._providers.items():
+            if provider.scope == "singleton":
+                await self.aresolve(interface)  # noqa
 
     async def aclose(self) -> None:
         """Close the singleton context asynchronously."""
         await self._singleton_context.aclose()
 
-    @contextlib.asynccontextmanager
-    async def arequest_context(self) -> AsyncIterator[None]:
+    def arequest_context(self) -> AsyncContextManager[None]:
         """Obtain an async context manager for the request-scoped context.
 
         Returns:
             An async context manager for the request-scoped context.
         """
+        return contextlib.asynccontextmanager(self._arequest_context)()
+
+    async def _arequest_context(self) -> AsyncIterator[None]:
+        """Internal method that manages the async request-scoped context.
+
+        Yields:
+            Yield control to the code block within the request context.
+        """
         context = RequestContext(self)
         token = self._request_context_var.set(context)
         async with context:

anydi/_context.py

@@ -7,7 +7,7 @@ from typing import TYPE_CHECKING, Any, ClassVar, TypeVar, cast
 
 from typing_extensions import Self, final
 
-from ._types import AnyInterface, Interface, Provider, Scope, is_event_type
+from ._types import AnyInterface, Interface, Provider, Scope
 from ._utils import run_async
 
 if TYPE_CHECKING:
@@ -243,7 +243,7 @@ class ResourceScopedContext(ScopedContext):
         exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
-    ) -> bool:
+    ) -> None:
         """Exit the context.
 
         Args:
@@ -251,17 +251,17 @@ class ResourceScopedContext(ScopedContext):
             exc_val: The exception instance, if any.
             exc_tb: The traceback, if any.
         """
-        return self._stack.__exit__(exc_type, exc_val, exc_tb)
+        self.close()
+        return
 
-    @abc.abstractmethod
     def start(self) -> None:
         """Start the scoped context."""
-        for interface in self.container._resource_cache.get(self.scope, []):  # noqa
+        for interface in self.container._providers_cache.get(self.scope, []):  # noqa
             self.container.resolve(interface)
 
     def close(self) -> None:
         """Close the scoped context."""
-        self._stack.__exit__(None, None, None)
+        self._stack.close()
 
     async def __aenter__(self) -> Self:
         """Enter the context asynchronously.
@@ -277,7 +277,7 @@ class ResourceScopedContext(ScopedContext):
         exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
-    ) -> bool:
+    ) -> None:
         """Exit the context asynchronously.
 
         Args:
@@ -285,17 +285,18 @@ class ResourceScopedContext(ScopedContext):
             exc_val: The exception instance, if any.
             exc_tb: The traceback, if any.
         """
-        return await run_async(
-            self.__exit__, exc_type, exc_val, exc_tb
-        ) or await self._async_stack.__aexit__(exc_type, exc_val, exc_tb)
+        await self.aclose()
+        return
 
-    @abc.abstractmethod
     async def astart(self) -> None:
         """Start the scoped context asynchronously."""
+        for interface in self.container._providers_cache.get(self.scope, []):  # noqa
+            await self.container.aresolve(interface)
 
     async def aclose(self) -> None:
         """Close the scoped context asynchronously."""
-        await self.__aexit__(None, None, None)
+        await run_async(self._stack.close)
+        await self._async_stack.aclose()
 
 
 @final
@@ -304,16 +305,6 @@ class SingletonContext(ResourceScopedContext):
 
     scope = "singleton"
 
-    def start(self) -> None:
-        """Start the scoped context."""
-        for interface in self.container._resource_cache.get(self.scope, []):  # noqa
-            self.container.resolve(interface)
-
-    async def astart(self) -> None:
-        """Start the scoped context asynchronously."""
-        for interface in self.container._resource_cache.get(self.scope, []):  # noqa
-            await self.container.aresolve(interface)
-
 
 @final
 class RequestContext(ResourceScopedContext):
@@ -321,20 +312,6 @@ class RequestContext(ResourceScopedContext):
 
     scope = "request"
 
-    def start(self) -> None:
-        """Start the scoped context."""
-        for interface in self.container._resource_cache.get(self.scope, []):  # noqa
-            if not is_event_type(interface):
-                continue
-            self.container.resolve(interface)
-
-    async def astart(self) -> None:
-        """Start the scoped context asynchronously."""
-        for interface in self.container._resource_cache.get(self.scope, []):  # noqa
-            if not is_event_type(interface):
-                continue
-            await self.container.aresolve(interface)
-
 
 @final
 class TransientContext(ScopedContext):

anydi/_types.py

@@ -30,17 +30,6 @@ def is_marker(obj: Any) -> bool:
     return isinstance(obj, Marker)
 
 
-class Event:
-    """Represents an event object."""
-
-    __slots__ = ()
-
-
-def is_event_type(obj: Any) -> bool:
-    """Checks if an object is an event type."""
-    return inspect.isclass(obj) and issubclass(obj, Event)
-
-
 @dataclass(frozen=True)
 class Provider:
     """Represents a provider object.

anydi/_utils.py

@@ -6,7 +6,7 @@ import builtins
 import functools
 import inspect
 import sys
-from typing import Any, AsyncIterator, Callable, ForwardRef, Iterator, TypeVar
+from typing import Any, AsyncIterator, Callable, ForwardRef, Iterator, TypeVar, cast
 
 from typing_extensions import ParamSpec, get_args, get_origin
 
@@ -16,18 +16,19 @@ except ImportError:
     anyio = None  # type: ignore[assignment]
 
 
-T = TypeVar("T")
-P = ParamSpec("P")
+if sys.version_info < (3, 9):  # pragma: nocover
 
-
-def evaluate_forwardref(type_: ForwardRef, globalns: Any, localns: Any) -> Any:
-    if sys.version_info < (3, 9):
+    def evaluate_forwardref(type_: ForwardRef, globalns: Any, localns: Any) -> Any:
         return type_._evaluate(globalns, localns)  # noqa
-    elif sys.version_info >= (3, 12):
-        return type_._evaluate(  # noqa
-            globalns, localns, frozenset(), recursive_guard=frozenset()
-        )
-    return type_._evaluate(globalns, localns, frozenset())  # noqa
+
+else:
+
+    def evaluate_forwardref(type_: ForwardRef, globalns: Any, localns: Any) -> Any:
+        return cast(Any, type_)._evaluate(globalns, localns, set())  # noqa
+
+
+T = TypeVar("T")
+P = ParamSpec("P")
 
 
 def get_full_qualname(obj: Any) -> str:
@@ -69,12 +70,10 @@ def get_typed_annotation(
 ) -> Any:
     """Get the typed annotation of a parameter."""
     if isinstance(annotation, str):
-        if sys.version_info >= (3, 10, 2):
-            annotation = ForwardRef(annotation, module=module, is_class=is_class)
-        elif sys.version_info >= (3, 10, 0):
-            annotation = ForwardRef(annotation, module=module)
-        else:
+        if sys.version_info < (3, 9):
             annotation = ForwardRef(annotation)
+        else:
+            annotation = ForwardRef(annotation, module=module, is_class=is_class)
         annotation = evaluate_forwardref(annotation, globalns, {})
     return annotation
 

anydi/ext/_utils.py

@@ -0,0 +1,89 @@
+"""AnyDI FastAPI extension."""
+
+from __future__ import annotations
+
+import inspect
+import logging
+from typing import Any, Callable
+
+from typing_extensions import Annotated, get_args, get_origin
+
+from anydi import Container
+from anydi._utils import get_full_qualname
+
+logger = logging.getLogger(__name__)
+
+
+class HasInterface:
+    _interface: Any = None
+
+    @property
+    def interface(self) -> Any:
+        if self._interface is None:
+            raise TypeError("Interface is not set.")
+        return self._interface
+
+    @interface.setter
+    def interface(self, interface: Any) -> None:
+        self._interface = interface
+
+
+def patch_annotated_parameter(parameter: inspect.Parameter) -> inspect.Parameter:
+    """Patch an annotated parameter to resolve the default value."""
+    if not (
+        get_origin(parameter.annotation) is Annotated
+        and parameter.default is parameter.empty
+    ):
+        return parameter
+
+    tp_origin, *tp_metadata = get_args(parameter.annotation)
+    default = tp_metadata[-1]
+
+    if not isinstance(default, HasInterface):
+        return parameter
+
+    if (num := len(tp_metadata[:-1])) == 0:
+        interface = tp_origin
+    elif num == 1:
+        interface = Annotated[tp_origin, tp_metadata[0]]
+    elif num == 2:
+        interface = Annotated[tp_origin, tp_metadata[0], tp_metadata[1]]
+    elif num == 3:
+        interface = Annotated[
+            tp_origin,
+            tp_metadata[0],
+            tp_metadata[1],
+            tp_metadata[2],
+        ]
+    else:
+        raise TypeError("Too many annotated arguments.")  # pragma: no cover
+    return parameter.replace(annotation=interface, default=default)
+
+
+def patch_call_parameter(
+    call: Callable[..., Any], parameter: inspect.Parameter, container: Container
+) -> None:
+    """Patch a parameter to inject dependencies using AnyDI.
+
+    Args:
+        call:  The call function.
+        parameter: The parameter to patch.
+        container: The AnyDI container.
+    """
+    parameter = patch_annotated_parameter(parameter)
+
+    if not isinstance(parameter.default, HasInterface):
+        return None
+
+    if not container.strict and not container.is_registered(parameter.annotation):
+        logger.debug(
+            f"Callable `{get_full_qualname(call)}` injected parameter "
+            f"`{parameter.name}` with an annotation of "
+            f"`{get_full_qualname(parameter.annotation)}` "
+            "is not registered. It will be registered at runtime with the "
+            "first call because it is running in non-strict mode."
+        )
+    else:
+        container._validate_injected_parameter(call, parameter)  # noqa
+
+    parameter.default.interface = parameter.annotation

anydi/ext/fastapi.py

@@ -2,19 +2,18 @@
 
 from __future__ import annotations
 
-import inspect
 import logging
-from typing import Any, Callable, Iterator, cast
+from typing import Any, Iterator, cast
 
 from fastapi import Depends, FastAPI, params
 from fastapi.dependencies.models import Dependant
 from fastapi.routing import APIRoute
 from starlette.requests import Request
-from typing_extensions import Annotated, get_args, get_origin
 
 from anydi import Container
-from anydi._utils import get_full_qualname, get_typed_parameters
+from anydi._utils import get_typed_parameters
 
+from ._utils import HasInterface, patch_call_parameter
 from .starlette.middleware import RequestScopedMiddleware
 
 __all__ = ["RequestScopedMiddleware", "install", "get_container", "Inject"]
@@ -48,7 +47,7 @@ def install(app: FastAPI, container: Container) -> None:
             if not call:
                 continue  # pragma: no cover
             for parameter in get_typed_parameters(call):
-                _patch_route_parameter(call, parameter, container)
+                patch_call_parameter(call, parameter, container)
 
 
 def get_container(request: Request) -> Container:
@@ -63,22 +62,11 @@ def get_container(request: Request) -> Container:
     return cast(Container, request.app.state.container)
 
 
-class Resolver(params.Depends):
+class Resolver(HasInterface, params.Depends):
     """Parameter dependency class for injecting dependencies using AnyDI."""
 
     def __init__(self) -> None:
         super().__init__(dependency=self._dependency, use_cache=True)
-        self._interface: Any = None
-
-    @property
-    def interface(self) -> Any:
-        if self._interface is None:
-            raise TypeError("Interface is not set.")
-        return self._interface
-
-    @interface.setter
-    def interface(self, interface: Any) -> None:
-        self._interface = interface
 
     async def _dependency(self, container: Container = Depends(get_container)) -> Any:
         return await container.aresolve(self.interface)
@@ -102,64 +90,3 @@ def _iter_dependencies(dependant: Dependant) -> Iterator[Dependant]:
     if dependant.dependencies:
         for sub_dependant in dependant.dependencies:
             yield from _iter_dependencies(sub_dependant)
-
-
-def _patch_route_parameter(
-    call: Callable[..., Any], parameter: inspect.Parameter, container: Container
-) -> None:
-    """Patch a parameter to inject dependencies using AnyDI.
-
-    Args:
-        call:  The call function.
-        parameter: The parameter to patch.
-        container: The AnyDI container.
-    """
-    parameter = _patch_annotated_parameter(parameter)
-
-    if not isinstance(parameter.default, Resolver):
-        return None
-
-    if not container.strict and not container.is_registered(parameter.annotation):
-        logger.debug(
-            f"Callable `{get_full_qualname(call)}` injected parameter "
-            f"`{parameter.name}` with an annotation of "
-            f"`{get_full_qualname(parameter.annotation)}` "
-            "is not registered. It will be registered at runtime with the "
-            "first call because it is running in non-strict mode."
-        )
-    else:
-        container._validate_injected_parameter(call, parameter)  # noqa
-
-    parameter.default.interface = parameter.annotation
-
-
-def _patch_annotated_parameter(parameter: inspect.Parameter) -> inspect.Parameter:
-    """Patch an annotated parameter to resolve the default value."""
-    if not (
-        get_origin(parameter.annotation) is Annotated
-        and parameter.default is parameter.empty
-    ):
-        return parameter
-
-    tp_origin, *tp_metadata = get_args(parameter.annotation)
-    default = tp_metadata[-1]
-
-    if not isinstance(default, Resolver):
-        return parameter
-
-    if (num := len(tp_metadata[:-1])) == 0:
-        interface = tp_origin
-    elif num == 1:
-        interface = Annotated[tp_origin, tp_metadata[0]]
-    elif num == 2:
-        interface = Annotated[tp_origin, tp_metadata[0], tp_metadata[1]]
-    elif num == 3:
-        interface = Annotated[
-            tp_origin,
-            tp_metadata[0],
-            tp_metadata[1],
-            tp_metadata[2],
-        ]
-    else:
-        raise TypeError("Too many annotated arguments.")  # pragma: no cover
-    return parameter.replace(annotation=interface, default=default)

anydi/ext/faststream.py

@@ -0,0 +1,50 @@
+import logging
+from typing import Any, cast
+
+from fast_depends.dependencies import Depends
+from faststream import ContextRepo
+from faststream.broker.core.usecase import BrokerUsecase
+
+from anydi import Container
+from anydi._utils import get_typed_parameters
+
+from ._utils import HasInterface, patch_call_parameter
+
+logger = logging.getLogger(__name__)
+
+
+def install(broker: BrokerUsecase[Any, Any], container: Container) -> None:
+    """Install AnyDI into a FastStream broker.
+
+    Args:
+        broker: The broker.
+        container: The container.
+
+    This function installs the AnyDI container into a FastStream broker by attaching
+    it to the broker. It also patches the broker handlers to inject the required
+    dependencies using AnyDI.
+    """
+    broker._container = container  # type: ignore[attr-defined]
+
+    for subscriber in broker._subscribers.values():  # noqa
+        call = subscriber.calls[0].handler._original_call  # noqa
+        for parameter in get_typed_parameters(call):
+            patch_call_parameter(call, parameter, container)
+
+
+def get_container(broker: BrokerUsecase[Any, Any]) -> Container:
+    return cast(Container, getattr(broker, "_container"))  # noqa
+
+
+class Resolver(HasInterface, Depends):
+    """Parameter dependency class for injecting dependencies using AnyDI."""
+
+    def __init__(self) -> None:
+        super().__init__(dependency=self._dependency, use_cache=True, cast=True)
+
+    async def _dependency(self, context: ContextRepo) -> Any:
+        return get_container(context.get("broker")).resolve(self.interface)
+
+
+def Inject() -> Any:  # noqa
+    return Resolver()

anydi/ext/pytest_plugin.py

@@ -63,15 +63,12 @@ def _anydi_injected_parameter_iterator(
     request: pytest.FixtureRequest,
     _anydi_unresolved: list[str],
 ) -> Callable[[], Iterator[tuple[str, Any]]]:
-    registered_fixtures = request.session._fixturemanager._arg2fixturedefs  # noqa
-
     def _iterator() -> Iterator[tuple[str, inspect.Parameter]]:
         for parameter in get_typed_parameters(request.function):
-            interface = parameter.annotation
             if (
-                interface is parameter.empty
+                ((interface := parameter.annotation) is parameter.empty)
                 or interface in _anydi_unresolved
-                or parameter.name in registered_fixtures
+                or parameter.name in request.node.funcargs
             ):
                 continue
             yield parameter.name, interface
@@ -95,14 +92,18 @@ def _anydi_inject(
     container = cast(Container, request.getfixturevalue("anydi_setup_container"))
 
     for argname, interface in _anydi_injected_parameter_iterator():
-        # Skip if the interface is not registered
-        if container.strict and not container.is_registered(interface):
-            continue
-
         try:
-            request.node.funcargs[argname] = container.resolve(interface)
-        except Exception:  # noqa
+            # Release the instance if it was already resolved
+            container.release(interface)
+        except LookupError:
+            pass
+        try:
+            # Resolve the instance
+            instance = container.resolve(interface)
+        except LookupError:
             _anydi_unresolved.append(interface)
+            continue
+        request.node.funcargs[argname] = instance
 
 
 @pytest.fixture(autouse=True)
@@ -120,11 +121,15 @@ async def _anydi_ainject(
     container = cast(Container, request.getfixturevalue("anydi_setup_container"))
 
     for argname, interface in _anydi_injected_parameter_iterator():
-        # Skip if the interface is not registered
-        if container.strict and not container.is_registered(interface):
-            continue
-
         try:
-            request.node.funcargs[argname] = await container.aresolve(interface)
-        except Exception:  # noqa
+            # Release the instance if it was already resolved
+            container.release(interface)
+        except LookupError:
+            pass
+        try:
+            # Resolve the instance
+            instance = await container.aresolve(interface)
+        except LookupError:
             _anydi_unresolved.append(interface)
+            continue
+        request.node.funcargs[argname] = instance

{anydi-0.26.8a0.dist-info → anydi-0.27.0a0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: anydi
-Version: 0.26.8a0
+Version: 0.27.0a0
 Summary: Dependency Injection library
 Home-page: https://github.com/antonrh/anydi
 License: MIT
@@ -22,6 +22,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
 Classifier: Topic :: Internet
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries

{anydi-0.26.8a0.dist-info → anydi-0.27.0a0.dist-info}/RECORD

@@ -1,12 +1,13 @@
 anydi/__init__.py,sha256=aeaBp5vq09sG-e9sqqs9qpUtUIDNfOdFPrlAfE5Ku9E,584
-anydi/_container.py,sha256=-vpiYl2Tx2QK9wl74DiF5qLFRudJ3e78TqEyuyOrthE,29055
-anydi/_context.py,sha256=qqaPVv-nnpHQL5R9wFL6-709eyAt9ZnzZov79NPEHIc,11865
+anydi/_container.py,sha256=IhfucOoAPYpMY9A0uHcqa1EOzE3_0TsExR-ZehZrZ6U,29246
+anydi/_context.py,sha256=e0VX0fiflzW_2O9w3HvUH3YRCwXHsruQjf3Lu-zXgDw,10815
 anydi/_logger.py,sha256=UpubJUnW83kffFxkhUlObm2DmZX1Pjqoz9YFKS-JOPg,52
 anydi/_module.py,sha256=E1TfLud_Af-MPB83PxIzHVA1jlDW2FGaRP_il1a6y3Y,3675
 anydi/_scanner.py,sha256=cyEk-K2Q8ssZStq8GrxMeEcCuAZMw-RXrjlgWEevKCs,6667
-anydi/_types.py,sha256=i8xFxz8pmFj7SGqwOwae_P9VtiRie6DVLwfaLibLwhc,3653
-anydi/_utils.py,sha256=TzUZRTNaXu78Uzv9NCNLSM5s9TgEIiXtXgr1HhsfHac,4017
+anydi/_types.py,sha256=vQTrFjsYhlMxfo1nOFem05x2QUJMQkVh4ZaC7W0XZJY,3434
+anydi/_utils.py,sha256=zP4UvO1aVQJTB8pFNUWAcncvSiuhcg4xNdRU7CoLrqw,3871
 anydi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anydi/ext/_utils.py,sha256=2kxLPTMM9Ro3s6-knbqYzONlqRB3hMcwZFFRQGHcFUg,2691
 anydi/ext/django/__init__.py,sha256=QI1IABCVgSDTUoh7M9WMECKXwB3xvh04HfQ9TOWw1Mk,223
 anydi/ext/django/_container.py,sha256=cxVoYQG16WP0S_Yv4TnLwuaaT7NVEOhLWO-YdALJUb4,418
 anydi/ext/django/_settings.py,sha256=cKzFBGtPCsexZ2ZcInubBukIebhxzNfa3F0KuwoZYaA,844
@@ -16,13 +17,14 @@ anydi/ext/django/middleware.py,sha256=iVHWtE829khMY-BXbNNt0g2FrIApKprna7dCG9ObEi
 anydi/ext/django/ninja/__init__.py,sha256=kW3grUgWp_nkWSG_-39ADHMrZLGNcj9TsJ9OW8iWWrk,546
 anydi/ext/django/ninja/_operation.py,sha256=wSWa7D73XTVlOibmOciv2l6JHPe1ERZcXrqI8W-oO2w,2696
 anydi/ext/django/ninja/_signature.py,sha256=2cSzKxBIxXLqtwNuH6GSlmjVJFftoGmleWfyk_NVEWw,2207
-anydi/ext/fastapi.py,sha256=kVUKVKtqCx1Nfnm1oh2BMyB0G7qQKPw6OGfxFlqUqtc,5305
-anydi/ext/pytest_plugin.py,sha256=3OWphc4nEzla46_8KR7LXtwGns5eol_YlUWfTf4Cr2Q,3952
+anydi/ext/fastapi.py,sha256=vhfSyovXuCjvSkx6AiLOTNU975i8wDg72C5fqXQiFLw,2896
+anydi/ext/faststream.py,sha256=svMtqFVSRTpuf4H5yeozHWmrBXi_F8cevb5d2mo3m-E,1617
+anydi/ext/pytest_plugin.py,sha256=nDNqjblVQufLha6P8J8hZw4Q0EuwC71bOI_bdaGm-OQ,4043
 anydi/ext/starlette/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/ext/starlette/middleware.py,sha256=Ni0BQaPjs_Ha6zcLZYYJ3-XkslTCnL9aCSa06rnRDMI,1139
 anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anydi-0.26.8a0.dist-info/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
-anydi-0.26.8a0.dist-info/METADATA,sha256=S3mIlHTg2I5Oy4kQm8wKb-iQRgFHa9wbdmLadWQPAes,5112
-anydi-0.26.8a0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-anydi-0.26.8a0.dist-info/entry_points.txt,sha256=GmQblwzxFg42zva1HyBYJJ7TvrTIcSAGBHmyi3bvsi4,42
-anydi-0.26.8a0.dist-info/RECORD,,
+anydi-0.27.0a0.dist-info/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
+anydi-0.27.0a0.dist-info/METADATA,sha256=sVLcw-YRcQ7PD1C39knmNRgN0gbvoQlqzfU2pF7NpkM,5162
+anydi-0.27.0a0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+anydi-0.27.0a0.dist-info/entry_points.txt,sha256=GmQblwzxFg42zva1HyBYJJ7TvrTIcSAGBHmyi3bvsi4,42
+anydi-0.27.0a0.dist-info/RECORD,,

{anydi-0.26.8a0.dist-info → anydi-0.27.0a0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 1.8.1
 Root-Is-Purelib: true
 Tag: py3-none-any