anydi 0.63.0__tar.gz → 0.65.0__tar.gz

{anydi-0.63.0 → anydi-0.65.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anydi
-Version: 0.63.0
+Version: 0.65.0
 Summary: Dependency Injection library
 Keywords: dependency injection,dependencies,di,async,asyncio,application
 Author: Anton Ruhlov
@@ -42,6 +42,7 @@ Modern, lightweight Dependency Injection library using type annotations.
 [![CI](https://github.com/antonrh/anydi/actions/workflows/ci.yml/badge.svg)](https://github.com/antonrh/anydi/actions/workflows/ci.yml)
 [![Coverage](https://codecov.io/gh/antonrh/anydi/branch/main/graph/badge.svg)](https://codecov.io/gh/antonrh/anydi)
 [![Documentation](https://readthedocs.org/projects/anydi/badge/?version=latest)](https://anydi.readthedocs.io/en/latest/)
+[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/antonrh/anydi?utm_source=badge)
 
 </div>
 
@@ -229,7 +230,7 @@ Configure Django (`settings.py`):
 
 ```python
 INSTALLED_APPS = [
-    ...
+    ...,
     "anydi_django",
 ]
 

{anydi-0.63.0 → anydi-0.65.0}/README.md

@@ -7,6 +7,7 @@ Modern, lightweight Dependency Injection library using type annotations.
 [![CI](https://github.com/antonrh/anydi/actions/workflows/ci.yml/badge.svg)](https://github.com/antonrh/anydi/actions/workflows/ci.yml)
 [![Coverage](https://codecov.io/gh/antonrh/anydi/branch/main/graph/badge.svg)](https://codecov.io/gh/antonrh/anydi)
 [![Documentation](https://readthedocs.org/projects/anydi/badge/?version=latest)](https://anydi.readthedocs.io/en/latest/)
+[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/antonrh/anydi?utm_source=badge)
 
 </div>
 
@@ -194,7 +195,7 @@ Configure Django (`settings.py`):
 
 ```python
 INSTALLED_APPS = [
-    ...
+    ...,
     "anydi_django",
 ]
 

{anydi-0.63.0 → anydi-0.65.0}/anydi/_container.py

@@ -272,6 +272,10 @@ class Container:
         # Register the scope
         self._scopes[scope] = tuple({scope, "singleton"} | set(parents))
 
+    def has_scope(self, scope: str) -> bool:
+        """Check if a scope is registered."""
+        return scope in self._scopes
+
     def get_context_scopes(self, scopes: set[Scope] | None = None) -> list[str]:  # noqa: C901
         """Return scopes that require context management in dependency order."""
         # Build execution order: singleton -> request -> custom (by depth)
@@ -549,6 +553,11 @@ class Container:
         )
 
         self._set_provider(provider)
+
+        # Clear cached resolvers when overriding
+        if override:
+            self._resolver.clear_caches()
+
         return provider
 
     def _validate_provider_scope(

{anydi-0.63.0 → anydi-0.65.0}/anydi/_resolver.py

@@ -62,6 +62,13 @@ class Resolver:
     def add_unresolved(self, interface: Any) -> None:
         self._unresolved_interfaces.add(interface)
 
+    def clear_caches(self) -> None:
+        """Clear all cached resolvers."""
+        self._cache.clear()
+        self._async_cache.clear()
+        self._override_cache.clear()
+        self._async_override_cache.clear()
+
     def get_cached(self, interface: Any, *, is_async: bool) -> CompiledResolver | None:
         """Get cached resolver if it exists."""
         if self.override_mode:
@@ -83,9 +90,14 @@ class Resolver:
             return cache[provider.interface]
 
         # Recursively compile dependencies first
-        for p in provider.parameters:
-            if p.provider is not None:
-                self.compile(p.provider, is_async=is_async)
+        for param in provider.parameters:
+            if param.provider is not None:
+                # Look up the current provider to handle overrides
+                current_provider = self._container.providers.get(param.annotation)
+                if current_provider is not None:
+                    self.compile(current_provider, is_async=is_async)
+                else:
+                    self.compile(param.provider, is_async=is_async)
 
         # Compile the resolver and creator functions
         compiled = self._compile_resolver(
@@ -155,23 +167,29 @@ class Resolver:
             else (self._async_cache if is_async else self._cache)
         )
 
-        for idx, p in enumerate(provider.parameters):
-            param_annotations[idx] = p.annotation
-            param_defaults[idx] = p.default
-            param_has_default[idx] = p.has_default
-            param_names[idx] = p.name
-            param_shared_scopes[idx] = p.shared_scope
-
-            if p.provider is not None:
-                compiled = cache.get(p.provider.interface)
+        for idx, param in enumerate(provider.parameters):
+            param_annotations[idx] = param.annotation
+            param_defaults[idx] = param.default
+            param_has_default[idx] = param.has_default
+            param_names[idx] = param.name
+            param_shared_scopes[idx] = param.shared_scope
+
+            if param.provider is not None:
+                # Look up the current provider from the container to handle overrides
+                current_provider = self._container.providers.get(param.annotation)
+                if current_provider is not None:
+                    compiled = cache.get(current_provider.interface)
+                else:
+                    # Fallback to the original provider if not in container
+                    compiled = cache.get(param.provider.interface)
                 if compiled is None:
-                    compiled = self.compile(p.provider, is_async=is_async)
-                    cache[p.provider.interface] = compiled
+                    compiled = self.compile(param.provider, is_async=is_async)
+                    cache[param.provider.interface] = compiled
                 param_resolvers[idx] = compiled.resolve
 
             unresolved_message = (
-                f"You are attempting to get the parameter `{p.name}` with the "
-                f"annotation `{type_repr(p.annotation)}` as a dependency into "
+                f"You are attempting to get the parameter `{param.name}` with the "
+                f"annotation `{type_repr(param.annotation)}` as a dependency into "
                 f"`{type_repr(provider.call)}` which is not registered or set in the "
                 "scoped context."
             )

{anydi-0.63.0 → anydi-0.65.0}/anydi/ext/fastapi.py

@@ -8,8 +8,8 @@ from typing import Annotated, Any, cast
 
 from fastapi import Depends, FastAPI, params
 from fastapi.dependencies.models import Dependant
-from fastapi.routing import APIRoute
-from starlette.requests import Request
+from fastapi.routing import APIRoute, APIWebSocketRoute
+from starlette.requests import HTTPConnection
 
 from anydi import Container, Inject
 from anydi._marker import Marker, extend_marker
@@ -19,9 +19,8 @@ from .starlette.middleware import RequestScopedMiddleware
 __all__ = ["install", "get_container", "Inject", "RequestScopedMiddleware"]
 
 
-def get_container(request: Request) -> Container:
-    """Get the AnyDI container from a FastAPI request."""
-    return cast(Container, request.app.state.container)
+def get_container(connection: HTTPConnection) -> Container:
+    return cast(Container, connection.app.state.container)
 
 
 class FastAPIMarker(params.Depends, Marker):
@@ -39,7 +38,9 @@ class FastAPIMarker(params.Depends, Marker):
         return await container.aresolve(self.interface)
 
 
-# Configure Inject() and Provide[T] to use FastAPI-specific marker
+# Configure Inject() and Provide[T] to use FastAPI-specific marker at import time
+# This is also called in install() to ensure it's set correctly even if other
+# extensions have overwritten it
 extend_marker(FastAPIMarker)
 
 
@@ -51,7 +52,9 @@ def _iter_dependencies(dependant: Dependant) -> Iterator[Dependant]:
 
 
 def _validate_route_dependencies(
-    route: APIRoute, container: Container, patched: set[tuple[Any, ...]]
+    route: APIRoute | APIWebSocketRoute,
+    container: Container,
+    patched: set[tuple[Any, ...]],
 ) -> None:
     for dependant in _iter_dependencies(route.dependant):
         if dependant.cache_key in patched:
@@ -71,8 +74,14 @@ def _validate_route_dependencies(
 def install(app: FastAPI, container: Container) -> None:
     """Install AnyDI into a FastAPI application."""
     app.state.container = container  # noqa
+
+    # Register websocket scope with request as parent if not already registered
+    if not container.has_scope("websocket"):
+        container.register_scope("websocket", parents=["request"])
+
+    # Validate routes (both HTTP and WebSocket)
     patched: set[tuple[Any, ...]] = set()
     for route in app.routes:
-        if not isinstance(route, APIRoute):
+        if not isinstance(route, APIRoute | APIWebSocketRoute):
             continue
         _validate_route_dependencies(route, container, patched)

anydi-0.65.0/anydi/ext/starlette/middleware.py

@@ -0,0 +1,49 @@
+"""Starlette middleware for AnyDI scoped contexts."""
+
+from __future__ import annotations
+
+from contextlib import AsyncExitStack
+
+from starlette.requests import Request
+from starlette.types import ASGIApp, Receive, Scope, Send
+from starlette.websockets import WebSocket
+
+from anydi import Container
+
+
+class RequestScopedMiddleware:
+    """ASGI middleware for managing request-scoped AnyDI context."""
+
+    def __init__(self, app: ASGIApp, container: Container) -> None:
+        self.app = app
+        self.container = container
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        # Only handle HTTP requests or WebSocket connections
+        if scope["type"] not in {"http", "websocket"}:
+            await self.app(scope, receive, send)
+            return
+
+        async with AsyncExitStack() as stack:
+            # Create request context first (parent scope)
+            request_context = await stack.enter_async_context(
+                self.container.arequest_context()
+            )
+
+            # For WebSocket connections, create websocket context (child scope)
+            websocket_context = None
+            if scope["type"] == "websocket" and self.container.has_scope("websocket"):
+                websocket_context = await stack.enter_async_context(
+                    self.container.ascoped_context("websocket")
+                )
+
+            if scope["type"] == "http":
+                request = Request(scope, receive=receive, send=send)
+                request_context.set(Request, request)
+            else:
+                websocket = WebSocket(scope, receive=receive, send=send)
+                request_context.set(WebSocket, websocket)
+                if websocket_context is not None:
+                    websocket_context.set(WebSocket, websocket)
+
+            await self.app(scope, receive, send)

{anydi-0.63.0 → anydi-0.65.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "anydi"
-version = "0.63.0"
+version = "0.65.0"
 description = "Dependency Injection library"
 authors = [{ name = "Anton Ruhlov", email = "antonruhlov@gmail.com" }]
 requires-python = ">=3.10.0, <3.15"
@@ -55,6 +55,7 @@ dev = [
     "pytest>=8.4.0,<9",
     "pytest-cov>=7.0.0",
     "pytest-mock>=3.14.1",
+    "pytest-codspeed>=4.2.0",
     "starlette>=0.37.2",
     "fastapi>=0.100.0",
     "httpx>=0.26.0",

anydi-0.63.0/anydi/ext/starlette/middleware.py

@@ -1,23 +0,0 @@
-"""Starlette RequestScopedMiddleware."""
-
-from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
-from starlette.requests import Request
-from starlette.responses import Response
-from starlette.types import ASGIApp
-
-from anydi import Container
-
-
-class RequestScopedMiddleware(BaseHTTPMiddleware):
-    """Starlette middleware for managing request-scoped AnyDI context."""
-
-    def __init__(self, app: ASGIApp, container: Container) -> None:
-        super().__init__(app)
-        self.container = container
-
-    async def dispatch(
-        self, request: Request, call_next: RequestResponseEndpoint
-    ) -> Response:
-        async with self.container.arequest_context() as context:
-            context.set(Request, request)
-            return await call_next(request)