anydi 0.33.1__py3-none-any.whl → 0.34.1__py3-none-any.whl

anydi/_context.py

@@ -1,224 +1,54 @@
 from __future__ import annotations
 
-import abc
 import contextlib
-import inspect
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Callable, ClassVar
+from typing import Any
 
-from typing_extensions import Self, final
+from typing_extensions import Self
 
-from ._provider import CallableKind, Provider
-from ._types import AnyInterface, DependencyWrapper, Scope, is_event_type
-from ._utils import get_full_qualname, run_async
+from ._utils import run_async
 
-if TYPE_CHECKING:
-    from ._container import Container
 
+class InstanceContext:
+    """A context to store instances."""
 
-class ScopedContext(abc.ABC):
-    """ScopedContext base class."""
+    __slots__ = ("_instances", "_stack", "_async_stack")
 
-    scope: ClassVar[Scope]
-
-    def __init__(self, container: Container) -> None:
-        self.container = container
-        self._instances: dict[Any, Any] = {}
-
-    def set(self, interface: AnyInterface, instance: Any) -> None:
-        """Set an instance of a dependency in the scoped context."""
-        self._instances[interface] = instance
-
-    @abc.abstractmethod
-    def get_or_create(self, provider: Provider) -> tuple[Any, bool]:
-        """Get or create an instance of a dependency from the scoped context."""
-
-    @abc.abstractmethod
-    async def aget_or_create(self, provider: Provider) -> tuple[Any, bool]:
-        """Get or create an async instance of a dependency from the scoped context."""
-
-    def _create_instance(self, provider: Provider) -> Any:
-        """Create an instance using the provider."""
-        if provider.kind == CallableKind.COROUTINE:
-            raise TypeError(
-                f"The instance for the coroutine provider `{provider}` cannot be "
-                "created in synchronous mode."
-            )
-        args, kwargs = self._get_provided_args(provider)
-        return provider.call(*args, **kwargs)
-
-    async def _acreate_instance(self, provider: Provider) -> Any:
-        """Create an instance asynchronously using the provider."""
-        args, kwargs = await self._aget_provided_args(provider)
-        if provider.kind == CallableKind.COROUTINE:
-            return await provider.call(*args, **kwargs)
-        return await run_async(provider.call, *args, **kwargs)
-
-    def _resolve_parameter(
-        self, provider: Provider, parameter: inspect.Parameter
-    ) -> Any:
-        self._validate_resolvable_parameter(parameter, call=provider.call)
-        return self.container.resolve(parameter.annotation)
-
-    async def _aresolve_parameter(
-        self, provider: Provider, parameter: inspect.Parameter
-    ) -> Any:
-        self._validate_resolvable_parameter(parameter, call=provider.call)
-        return await self.container.aresolve(parameter.annotation)
-
-    def _validate_resolvable_parameter(
-        self, parameter: inspect.Parameter, call: Callable[..., Any]
-    ) -> None:
-        """Ensure that the specified interface is resolved."""
-        if parameter.annotation in self.container._unresolved_interfaces:  # noqa
-            raise LookupError(
-                f"You are attempting to get the parameter `{parameter.name}` with the "
-                f"annotation `{get_full_qualname(parameter.annotation)}` as a "
-                f"dependency into `{get_full_qualname(call)}` which is not registered "
-                "or set in the scoped context."
-            )
-
-    def _get_provided_args(
-        self, provider: Provider
-    ) -> tuple[list[Any], dict[str, Any]]:
-        """Retrieve the arguments for a provider."""
-        args: list[Any] = []
-        kwargs: dict[str, Any] = {}
-
-        for parameter in provider.parameters:
-            if parameter.annotation in self.container._override_instances:  # noqa
-                instance = self.container._override_instances[parameter.annotation]  # noqa
-            elif parameter.annotation in self._instances:
-                instance = self._instances[parameter.annotation]
-            else:
-                try:
-                    instance = self._resolve_parameter(provider, parameter)
-                except LookupError:
-                    if parameter.default is inspect.Parameter.empty:
-                        raise
-                    instance = parameter.default
-                else:
-                    if self.container.testing:
-                        instance = DependencyWrapper(
-                            interface=parameter.annotation, instance=instance
-                        )
-            if parameter.kind == parameter.POSITIONAL_ONLY:
-                args.append(instance)
-            else:
-                kwargs[parameter.name] = instance
-        return args, kwargs
-
-    async def _aget_provided_args(
-        self, provider: Provider
-    ) -> tuple[list[Any], dict[str, Any]]:
-        """Asynchronously retrieve the arguments for a provider."""
-        args: list[Any] = []
-        kwargs: dict[str, Any] = {}
-
-        for parameter in provider.parameters:
-            if parameter.annotation in self.container._override_instances:  # noqa
-                instance = self.container._override_instances[parameter.annotation]  # noqa
-            elif parameter.annotation in self._instances:
-                instance = self._instances[parameter.annotation]
-            else:
-                try:
-                    instance = await self._aresolve_parameter(provider, parameter)
-                except LookupError:
-                    if parameter.default is inspect.Parameter.empty:
-                        raise
-                    instance = parameter.default
-                else:
-                    if self.container.testing:
-                        instance = DependencyWrapper(
-                            interface=parameter.annotation, instance=instance
-                        )
-            if parameter.kind == parameter.POSITIONAL_ONLY:
-                args.append(instance)
-            else:
-                kwargs[parameter.name] = instance
-        return args, kwargs
-
-
-class ResourceScopedContext(ScopedContext):
-    """ScopedContext with closable resources support."""
-
-    def __init__(self, container: Container) -> None:
-        """Initialize the ScopedContext."""
-        super().__init__(container)
+    def __init__(self) -> None:
+        self._instances: dict[type[Any], Any] = {}
         self._stack = contextlib.ExitStack()
         self._async_stack = contextlib.AsyncExitStack()
 
-    def get_or_create(self, provider: Provider) -> tuple[Any, bool]:
-        """Get an instance of a dependency from the scoped context."""
-        instance = self._instances.get(provider.interface)
-        if instance is None:
-            if provider.kind == CallableKind.GENERATOR:
-                instance = self._create_resource(provider)
-            elif provider.kind == CallableKind.ASYNC_GENERATOR:
-                raise TypeError(
-                    f"The provider `{provider}` cannot be started in synchronous mode "
-                    "because it is an asynchronous provider. Please start the provider "
-                    "in asynchronous mode before using it."
-                )
-            else:
-                instance = self._create_instance(provider)
-            self._instances[provider.interface] = instance
-            return instance, True
-        return instance, False
+    def get(self, interface: type[Any]) -> Any | None:
+        """Get an instance from the context."""
+        return self._instances.get(interface)
 
-    async def aget_or_create(self, provider: Provider) -> tuple[Any, bool]:
-        """Get an async instance of a dependency from the scoped context."""
-        instance = self._instances.get(provider.interface)
-        if instance is None:
-            if provider.kind == CallableKind.GENERATOR:
-                instance = await run_async(self._create_resource, provider)
-            elif provider.kind == CallableKind.ASYNC_GENERATOR:
-                instance = await self._acreate_resource(provider)
-            else:
-                instance = await self._acreate_instance(provider)
-            self._instances[provider.interface] = instance
-            return instance, True
-        return instance, False
+    def set(self, interface: type[Any], value: Any) -> None:
+        """Set an instance in the context."""
+        self._instances[interface] = value
 
-    def has(self, interface: AnyInterface) -> bool:
-        """Check if the scoped context has an instance of the dependency."""
-        return interface in self._instances
+    def enter(self, cm: contextlib.AbstractContextManager[Any]) -> Any:
+        """Enter the context."""
+        return self._stack.enter_context(cm)
 
-    def _create_instance(self, provider: Provider) -> Any:
-        """Create an instance using the provider."""
-        instance = super()._create_instance(provider)
-        # Enter the context manager if the instance is closable.
-        if hasattr(instance, "__enter__") and hasattr(instance, "__exit__"):
-            self._stack.enter_context(instance)
-        return instance
+    async def aenter(self, cm: contextlib.AbstractAsyncContextManager[Any]) -> Any:
+        """Enter the context asynchronously."""
+        return await self._async_stack.enter_async_context(cm)
 
-    def _create_resource(self, provider: Provider) -> Any:
-        """Create a resource using the provider."""
-        args, kwargs = self._get_provided_args(provider)
-        cm = contextlib.contextmanager(provider.call)(*args, **kwargs)
-        return self._stack.enter_context(cm)
+    def __setitem__(self, interface: type[Any], value: Any) -> None:
+        self._instances[interface] = value
 
-    async def _acreate_instance(self, provider: Provider) -> Any:
-        """Create an instance asynchronously using the provider."""
-        instance = await super()._acreate_instance(provider)
-        # Enter the context manager if the instance is closable.
-        if hasattr(instance, "__aenter__") and hasattr(instance, "__aexit__"):
-            await self._async_stack.enter_async_context(instance)
-        return instance
+    def __getitem__(self, interface: type[Any]) -> Any:
+        return self._instances[interface]
 
-    async def _acreate_resource(self, provider: Provider) -> Any:
-        """Create a resource asynchronously using the provider."""
-        args, kwargs = await self._aget_provided_args(provider)
-        cm = contextlib.asynccontextmanager(provider.call)(*args, **kwargs)
-        return await self._async_stack.enter_async_context(cm)
+    def __contains__(self, interface: type[Any]) -> bool:
+        return interface in self._instances
 
-    def delete(self, interface: AnyInterface) -> None:
-        """Delete a dependency instance from the scoped context."""
+    def __delitem__(self, interface: type[Any]) -> None:
         self._instances.pop(interface, None)
 
     def __enter__(self) -> Self:
         """Enter the context."""
-        self.start()
         return self
 
     def __exit__(
@@ -226,15 +56,9 @@ class ResourceScopedContext(ScopedContext):
         exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
-    ) -> bool:
+    ) -> Any:
         """Exit the context."""
-        return self._stack.__exit__(exc_type, exc_val, exc_tb)  # type: ignore[return-value]
-
-    @abc.abstractmethod
-    def start(self) -> None:
-        """Start the scoped context."""
-        for interface in self.container._resource_cache.get(self.scope, []):  # noqa
-            self.container.resolve(interface)
+        return self._stack.__exit__(exc_type, exc_val, exc_tb)
 
     def close(self) -> None:
         """Close the scoped context."""
@@ -242,7 +66,6 @@ class ResourceScopedContext(ScopedContext):
 
     async def __aenter__(self) -> Self:
         """Enter the context asynchronously."""
-        await self.astart()
         return self
 
     async def __aexit__(
@@ -256,65 +79,6 @@ class ResourceScopedContext(ScopedContext):
             self.__exit__, exc_type, exc_val, exc_tb
         ) or await self._async_stack.__aexit__(exc_type, exc_val, exc_tb)
 
-    @abc.abstractmethod
-    async def astart(self) -> None:
-        """Start the scoped context asynchronously."""
-
     async def aclose(self) -> None:
         """Close the scoped context asynchronously."""
         await self.__aexit__(None, None, None)
-
-
-@final
-class SingletonContext(ResourceScopedContext):
-    """A scoped context representing the "singleton" scope."""
-
-    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):
-    """A scoped context representing the "request" scope."""
-
-    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):
-    """A scoped context representing the "transient" scope."""
-
-    scope = "transient"
-
-    def get_or_create(self, provider: Provider) -> tuple[Any, bool]:
-        """Get or create an instance of a dependency from the transient context."""
-        return self._create_instance(provider), True
-
-    async def aget_or_create(self, provider: Provider) -> tuple[Any, bool]:
-        """
-        Get or create an async instance of a dependency from the transient context.
-        """
-        return await self._acreate_instance(provider), True

anydi/_provider.py

@@ -38,6 +38,11 @@ class Provider:
         "_kind",
         "_interface",
         "_parameters",
+        "_is_coroutine",
+        "_is_generator",
+        "_is_async_generator",
+        "_is_async",
+        "_is_resource",
     )
 
     def __init__(
@@ -52,6 +57,12 @@ class Provider:
         # Detect the kind of callable provider
         self._detect_kind()
 
+        self._is_coroutine = self._kind == CallableKind.COROUTINE
+        self._is_generator = self._kind == CallableKind.GENERATOR
+        self._is_async_generator = self._kind == CallableKind.ASYNC_GENERATOR
+        self._is_async = self._is_coroutine or self._is_async_generator
+        self._is_resource = self._is_generator or self._is_async_generator
+
         # Validate the scope of the provider
         self._validate_scope()
 
@@ -96,13 +107,30 @@ class Provider:
     def parameters(self) -> list[inspect.Parameter]:
         return self._parameters
 
+    @property
+    def is_coroutine(self) -> bool:
+        """Check if the provider is a coroutine."""
+        return self._is_coroutine
+
+    @property
+    def is_generator(self) -> bool:
+        """Check if the provider is a generator."""
+        return self._is_generator
+
+    @property
+    def is_async_generator(self) -> bool:
+        """Check if the provider is an async generator."""
+        return self._is_async_generator
+
+    @property
+    def is_async(self) -> bool:
+        """Check if the provider is an async callable."""
+        return self._is_async
+
     @property
     def is_resource(self) -> bool:
         """Check if the provider is a resource."""
-        return self._kind in {
-            CallableKind.GENERATOR,
-            CallableKind.ASYNC_GENERATOR,
-        }
+        return self._is_resource
 
     def _validate_scope(self) -> None:
         """Validate the scope of the provider."""

anydi/_types.py

@@ -1,16 +1,16 @@
 from __future__ import annotations
 
 import inspect
+from collections.abc import Iterable
 from dataclasses import dataclass
-from typing import Annotated, Any, TypeVar, Union
+from types import ModuleType
+from typing import Annotated, Any, NamedTuple, Union
 
 from typing_extensions import Literal, Self, TypeAlias
 
 Scope = Literal["transient", "singleton", "request"]
 
-T = TypeVar("T")
 AnyInterface: TypeAlias = Union[type[Any], Annotated[Any, ...]]
-Interface: TypeAlias = type[T]
 
 
 class Marker:
@@ -47,3 +47,19 @@ class DependencyWrapper:
         if name in {"interface", "instance"}:
             return object.__getattribute__(self, name)
         return getattr(self.instance, name)
+
+
+class ProviderDecoratorArgs(NamedTuple):
+    scope: Scope
+    override: bool
+
+
+@dataclass(frozen=True)
+class Dependency:
+    member: Any
+    module: ModuleType
+
+
+class InjectableDecoratorArgs(NamedTuple):
+    wrapped: bool
+    tags: Iterable[str] | None

anydi/_utils.py

@@ -8,15 +8,11 @@ import importlib
 import inspect
 import re
 import sys
+from types import TracebackType
 from typing import Any, Callable, ForwardRef, TypeVar
 
-from typing_extensions import ParamSpec, get_args, get_origin
-
-try:
-    import anyio  # noqa
-except ImportError:
-    anyio = None  # type: ignore[assignment]
-
+import anyio
+from typing_extensions import ParamSpec, Self, get_args, get_origin
 
 T = TypeVar("T")
 P = ParamSpec("P")
@@ -48,6 +44,16 @@ def is_builtin_type(tp: type[Any]) -> bool:
     return tp.__module__ == builtins.__name__
 
 
+def is_context_manager(obj: Any) -> bool:
+    """Check if the given object is a context manager."""
+    return hasattr(obj, "__enter__") and hasattr(obj, "__exit__")
+
+
+def is_async_context_manager(obj: Any) -> bool:
+    """Check if the given object is an async context manager."""
+    return hasattr(obj, "__aenter__") and hasattr(obj, "__aexit__")
+
+
 def get_typed_annotation(
     annotation: Any, globalns: dict[str, Any], module: Any = None
 ) -> Any:
@@ -82,11 +88,6 @@ async def run_async(
     **kwargs: P.kwargs,
 ) -> T:
     """Runs the given function asynchronously using the `anyio` library."""
-    if not anyio:
-        raise ImportError(
-            "`anyio` library is not currently installed. Please make sure to install "
-            "it first, or consider using `anydi[full]` instead."
-        )
     return await anyio.to_thread.run_sync(functools.partial(func, *args, **kwargs))
 
 
@@ -103,3 +104,39 @@ def import_string(dotted_path: str) -> Any:
             return importlib.import_module(attribute_name)
     except (ImportError, AttributeError) as exc:
         raise ImportError(f"Cannot import '{dotted_path}': {exc}") from exc
+
+
+class AsyncRLock:
+    def __init__(self) -> None:
+        self._lock = anyio.Lock()
+        self._owner: anyio.TaskInfo | None = None
+        self._count = 0
+
+    async def acquire(self) -> None:
+        current_task = anyio.get_current_task()
+        if self._owner == current_task:
+            self._count += 1
+        else:
+            await self._lock.acquire()
+            self._owner = current_task
+            self._count = 1
+
+    def release(self) -> None:
+        if self._owner != anyio.get_current_task():
+            raise RuntimeError("Lock can only be released by the owner")
+        self._count -= 1
+        if self._count == 0:
+            self._owner = None
+            self._lock.release()
+
+    async def __aenter__(self) -> Self:
+        await self.acquire()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> Any:
+        self.release()

anydi/ext/django/middleware.py

@@ -14,15 +14,15 @@ def request_scoped_middleware(
     if iscoroutinefunction(get_response):
 
         async def async_middleware(request: HttpRequest) -> Any:
-            async with container.arequest_context() as ctx:
-                ctx.set(HttpRequest, instance=request)
+            async with container.arequest_context() as context:
+                context.set(HttpRequest, request)
                 return await get_response(request)
 
         return async_middleware
 
     def middleware(request: HttpRequest) -> Any:
-        with container.request_context() as ctx:
-            ctx.set(HttpRequest, instance=request)
+        with container.request_context() as context:
+            context.set(HttpRequest, request)
             return get_response(request)
 
     return middleware

anydi/ext/starlette/middleware.py

@@ -18,6 +18,6 @@ class RequestScopedMiddleware(BaseHTTPMiddleware):
     async def dispatch(
         self, request: Request, call_next: RequestResponseEndpoint
     ) -> Response:
-        async with self.container.arequest_context() as ctx:
-            ctx.set(Request, instance=request)
+        async with self.container.arequest_context() as context:
+            context.set(Request, request)
             return await call_next(request)

{anydi-0.33.1.dist-info → anydi-0.34.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: anydi
-Version: 0.33.1
+Version: 0.34.1
 Summary: Dependency Injection library
 Home-page: https://github.com/antonrh/anydi
 License: MIT
@@ -28,9 +28,8 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Provides-Extra: async
 Provides-Extra: docs
-Requires-Dist: anyio (>=3.6.2,<4.0.0) ; extra == "async"
+Requires-Dist: anyio (>=3.7.1)
 Requires-Dist: mkdocs (>=1.4.2,<2.0.0) ; extra == "docs"
 Requires-Dist: mkdocs-material (>=9.5.29,<10.0.0) ; extra == "docs"
 Requires-Dist: typing-extensions (>=4.12.1,<5.0.0)

{anydi-0.33.1.dist-info → anydi-0.34.1.dist-info}/RECORD

@@ -1,12 +1,10 @@
-anydi/__init__.py,sha256=EsR-HiMe8cWS9PQbY23ibc91STK1WTn02DFMPV-TNU4,509
-anydi/_container.py,sha256=shefN3SuhmPBzU6gxV-YRGJlz-m8Nv5RJ-T93veSxgE,21389
-anydi/_context.py,sha256=6Veqt15Tp4DfOzppUOIBaymosicYUWMeSa1b7ZAdtxw,12866
+anydi/__init__.py,sha256=OfRg2EfXD65pHTGQKhfkABMwUhw5LvsuTQV_Tv4V4wk,501
+anydi/_container.py,sha256=RyP0k8MXZfDr3mjjMo86auidKrlAGstEgY2AxpAHEAg,35346
+anydi/_context.py,sha256=7LV_SL4QWkJeiG7_4D9PZ5lmU-MPzhofxC95zCgY9Gc,2651
 anydi/_logger.py,sha256=UpubJUnW83kffFxkhUlObm2DmZX1Pjqoz9YFKS-JOPg,52
-anydi/_module.py,sha256=cgojC7Z7oMtsUnkfSc65cRYOfZ8Q6KwjusNJzx_VSbk,2729
-anydi/_provider.py,sha256=w_GnRo324aqNORRJwuURexA54c1M3smj34Q8EaV0QGE,6213
-anydi/_scanner.py,sha256=F2sHgJvkRYXYnu4F5iSrnIPVzwnNeS7tRPXziirh4NI,4898
-anydi/_types.py,sha256=90xdbH2NrFXbridFf9mjOknhcXMW5L0jm92zP_LvKrg,1120
-anydi/_utils.py,sha256=guw4sFCvsisJmneKWlZi18YDYll_CjlO_f2cH97rDFQ,3280
+anydi/_provider.py,sha256=fcfzYOlpJ1fMqbMPAd6uI9_lap8n2ljJ9e10OEQpI4s,7176
+anydi/_types.py,sha256=55Wvaxcs2DPpVXrMqhHebT_ZeGDnH-H_zhND306vaoU,1397
+anydi/_utils.py,sha256=INI0jNIXrJ6LS4zqJymMO2yUEobpxmBGASf4G_vR6AU,4378
 anydi/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 anydi/ext/_utils.py,sha256=U6sRqWzccWUu7eMhbXX1NrwcaxitQF9cO1KxnKF37gw,2566
 anydi/ext/django/__init__.py,sha256=QI1IABCVgSDTUoh7M9WMECKXwB3xvh04HfQ9TOWw1Mk,223
@@ -14,7 +12,7 @@ anydi/ext/django/_container.py,sha256=cxVoYQG16WP0S_Yv4TnLwuaaT7NVEOhLWO-YdALJUb
 anydi/ext/django/_settings.py,sha256=Z0RlAuXoO73oahWeMkK10w8c-4uCBde-DBpeKTV5USY,853
 anydi/ext/django/_utils.py,sha256=q6X6GApBm0oBK8DnoRZhTq2m4tAdKRYL__gVgKn3idg,3977
 anydi/ext/django/apps.py,sha256=mjbf_mDCpNSriGnILzhRIr8wFHLMEK8sUerbmRku6i0,2844
-anydi/ext/django/middleware.py,sha256=tryIaBVmfPmilGrnKpLNlLCOPN5rw4_pXY3ojFXv3O0,856
+anydi/ext/django/middleware.py,sha256=5OUdp0OWRozyW338Sq04BDhacaFlyUTTOduS_7EwCTA,854
 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
@@ -23,10 +21,10 @@ anydi/ext/faststream.py,sha256=qXnNGvAqWWp9kbhbQUE6EF_OPUiYQmtOH211_O7BI_0,1898
 anydi/ext/pydantic_settings.py,sha256=8IXXLuG_OvKbvKlBkBRQUHcXgbTpgQUxeWyoMcRIUQM,1488
 anydi/ext/pytest_plugin.py,sha256=3x_ZYFcLp4ZCRrs7neoohmWz56O9ydm92jxi_LnyD7w,4298
 anydi/ext/starlette/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anydi/ext/starlette/middleware.py,sha256=PKip_omFZDgg7h2OY-nnV2OIS1MbbmrrOJBwG7_Peuw,793
+anydi/ext/starlette/middleware.py,sha256=9CQtGg5ZzUz2gFSzJr8U4BWzwNjK8XMctm3n52M77Z0,792
 anydi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-anydi-0.33.1.dist-info/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
-anydi-0.33.1.dist-info/METADATA,sha256=u-YkBHTqAbah4ytfw7CXHEUNDVyjhBFUwD2dV8z84Jc,5112
-anydi-0.33.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-anydi-0.33.1.dist-info/entry_points.txt,sha256=GmQblwzxFg42zva1HyBYJJ7TvrTIcSAGBHmyi3bvsi4,42
-anydi-0.33.1.dist-info/RECORD,,
+anydi-0.34.1.dist-info/LICENSE,sha256=V6rU8a8fv6o2jQ-7ODHs0XfDFimot8Q6Km6CylRIDTo,1069
+anydi-0.34.1.dist-info/METADATA,sha256=aeIeJl8UmjLDk5vhQfgIJedZH7UCFUrAXtHdcJZx1gI,5064
+anydi-0.34.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+anydi-0.34.1.dist-info/entry_points.txt,sha256=GmQblwzxFg42zva1HyBYJJ7TvrTIcSAGBHmyi3bvsi4,42
+anydi-0.34.1.dist-info/RECORD,,