fastapi-injected 0.3.3__tar.gz → 0.3.4__tar.gz

{fastapi_injected-0.3.3 → fastapi_injected-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: fastapi-injected
-Version: 0.3.3
+Version: 0.3.4
 Summary: Yet another library to reuse fastapi dependency injection
 Project-URL: Repository, https://github.com/uriyyo/fastapi-injected
 Author-email: Yurii Karabas <1998uriyyo@gmail.com>
@@ -351,6 +351,21 @@ async def route(service: Dep[Service]) -> str:
 
 Anything called from the handler — including `@inject`-ed helpers — resolves against the request's cache, so a per-request dependency like a DB session stays a single instance for the whole request.
 
+WebSocket routes work the same way: the scope is bound to the `WebSocket` instead of a `Request`, and dependencies that ask for one get it. A websocket handed to a dependency shares its handshake with the one the route received, so it can be talked through after the route has called `accept()`:
+
+```python
+async def notify(websocket: WebSocket) -> None:
+    await websocket.send_json({"ready": True})
+
+
+@app.websocket("/ws")
+async def ws_route(websocket: WebSocket, service: Dep[Service]) -> None:
+    await websocket.accept()
+    await resolve(notify)  # sends through the connection the route accepted
+```
+
+`push_inject_scope(request=...)` accepts either a `Request` or a `WebSocket`, and so does everything that reads `InjectScope.request` — the union is `fastapi_injected.types.BoundConnection`.
+
 ## What is public
 
 Everything the package supports is importable from `fastapi_injected` itself, and that is the surface a release keeps:

{fastapi_injected-0.3.3 → fastapi_injected-0.3.4}/README.md

@@ -330,6 +330,21 @@ async def route(service: Dep[Service]) -> str:
 
 Anything called from the handler — including `@inject`-ed helpers — resolves against the request's cache, so a per-request dependency like a DB session stays a single instance for the whole request.
 
+WebSocket routes work the same way: the scope is bound to the `WebSocket` instead of a `Request`, and dependencies that ask for one get it. A websocket handed to a dependency shares its handshake with the one the route received, so it can be talked through after the route has called `accept()`:
+
+```python
+async def notify(websocket: WebSocket) -> None:
+    await websocket.send_json({"ready": True})
+
+
+@app.websocket("/ws")
+async def ws_route(websocket: WebSocket, service: Dep[Service]) -> None:
+    await websocket.accept()
+    await resolve(notify)  # sends through the connection the route accepted
+```
+
+`push_inject_scope(request=...)` accepts either a `Request` or a `WebSocket`, and so does everything that reads `InjectScope.request` — the union is `fastapi_injected.types.BoundConnection`.
+
 ## What is public
 
 Everything the package supports is importable from `fastapi_injected` itself, and that is the surface a release keeps:

{fastapi_injected-0.3.3 → fastapi_injected-0.3.4}/fastapi_injected/_fastapi_lifecycle.py

@@ -4,10 +4,11 @@ from typing import TYPE_CHECKING, Any
 
 from fastapi import Depends, FastAPI, Request, WebSocket, routing
 from fastapi.dependencies import utils
+from starlette.requests import HTTPConnection
 
 from ._cache import ScopeCache
 from .scope import push_inject_scope
-from .types import DependencyCache
+from .types import DependencyCache, HasDependencyOverrides
 
 _DEPENDENCY_CACHE_KEY = "__fastapi_injected_dependency_cache__"
 
@@ -46,18 +47,34 @@ if not TYPE_CHECKING:
     routing.solve_dependencies = _solve_dependencies
 
 
-def _get_dependency_cache(request: Request) -> DependencyCache:
+def _get_dependency_cache(connection: HTTPConnection) -> DependencyCache:
     try:
-        return request.scope[_DEPENDENCY_CACHE_KEY]
+        return connection.scope[_DEPENDENCY_CACHE_KEY]
     except KeyError:
         raise MissingDependencyCacheError("Dependency cache not found") from None
 
 
-async def init_inject_scope(request: Request) -> AsyncGenerator[None]:
+def _get_overrides_provider(connection: HTTPConnection) -> HasDependencyOverrides | None:
+    route = connection.scope.get("route")
+
+    if (provider := getattr(route, "dependency_overrides_provider", None)) is not None:
+        return provider
+
+    # a websocket route does not keep the provider it was given - but it is the app
+    # the route was added to, which is what the scope of the connection holds
+    return connection.scope.get("app")
+
+
+# annotated as the base class so FastAPI hands over whichever the route has -
+# a `Request` in an HTTP route, a `WebSocket` in a websocket one
+async def init_inject_scope(connection: HTTPConnection) -> AsyncGenerator[None]:
+    if not isinstance(connection, Request | WebSocket):  # pragma: no cover
+        raise TypeError(f"expected a Request or a WebSocket, got {type(connection).__name__}")
+
     async with push_inject_scope(
-        dependency_cache=_get_dependency_cache(request),
-        request=request,
-        provider=request.scope["route"].dependency_overrides_provider,
+        dependency_cache=_get_dependency_cache(connection),
+        request=connection,
+        provider=_get_overrides_provider(connection),
     ):
         yield
 

{fastapi_injected-0.3.3 → fastapi_injected-0.3.4}/fastapi_injected/scope.py

@@ -10,16 +10,18 @@ from contextvars import ContextVar
 from dataclasses import field, replace
 from typing import Any, Self, cast
 
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, Request, WebSocket
 from fastapi.dependencies.models import Dependant
 from fastapi.routing import APIRoute, APIWebSocketRoute
+from starlette.requests import HTTPConnection
 from starlette.types import Message, Scope
+from starlette.websockets import WebSocketState
 
 from ._cache import ScopeCache, overridden_calls
 from ._dataclass import MakeDataclass
 from ._overrides import Overrides, normalize_overrides
 from ._rlock import RLock
-from .types import DependencyCache, HasDependencyOverrides
+from .types import BoundConnection, DependencyCache, HasDependencyOverrides
 
 
 class UnboundScopeError(Exception):
@@ -87,14 +89,42 @@ def _dummy_request(
     )
 
 
+class _ReboundWebSocket(WebSocket):
+    def __init__(self, origin: WebSocket, /, *, scope: Scope) -> None:
+        HTTPConnection.__init__(self, scope)
+
+        self._origin = origin
+        self._receive = origin._receive  # noqa: SLF001
+        self._send = origin._send  # noqa: SLF001
+
+    @property
+    def client_state(self) -> WebSocketState:
+        return self._origin.client_state
+
+    @client_state.setter
+    def client_state(self, state: WebSocketState) -> None:
+        self._origin.client_state = state
+
+    @property
+    def application_state(self) -> WebSocketState:
+        return self._origin.application_state
+
+    @application_state.setter
+    def application_state(self, state: WebSocketState) -> None:
+        self._origin.application_state = state
+
+
 def _rebind_request(
-    request: Request,
+    request: BoundConnection,
     /,
     *,
     extra_scope: Scope,
-) -> Request:
+) -> BoundConnection:
     scope = {**request.scope, **extra_scope}
 
+    if isinstance(request, WebSocket):
+        return _ReboundWebSocket(request, scope=scope)
+
     return Request(
         scope,
         receive=request.receive,
@@ -104,7 +134,7 @@ def _rebind_request(
 
 class InjectScope(MakeDataclass):
     dependency_cache: DependencyCache = field(default_factory=dict)
-    request: Request | None = None
+    request: BoundConnection | None = None
 
     parent: Self | None = field(default=None, repr=False)
     overrides: MutableMapping[Any, Any] = field(default_factory=dict, repr=False)
@@ -120,7 +150,7 @@ class InjectScope(MakeDataclass):
         return self.request is not None
 
     @property
-    def bound_request(self) -> Request:
+    def bound_request(self) -> BoundConnection:
         if self.request is None:
             raise UnboundScopeError
 
@@ -214,7 +244,7 @@ async def push_inject_scope(
     /,
     *,
     dependency_cache: DependencyCache | None = None,
-    request: Request | None = None,
+    request: BoundConnection | None = None,
     app: FastAPI | None = None,
     provider: HasDependencyOverrides | None = None,
 ) -> AsyncIterator[InjectScope]:

{fastapi_injected-0.3.3 → fastapi_injected-0.3.4}/fastapi_injected/types.py

@@ -2,7 +2,7 @@ import inspect
 from collections.abc import AsyncIterator, Callable, Coroutine, Iterator, Mapping
 from typing import TYPE_CHECKING, Annotated, Any, Protocol, TypeVar, runtime_checkable
 
-from fastapi import Depends
+from fastapi import Depends, Request, WebSocket
 from fastapi.types import DependencyCacheKey
 from typing_extensions import TypeForm, sentinel
 
@@ -56,6 +56,8 @@ type AsyncDecorator[**P, R] = Callable[
     AsyncFunc[P, R],
 ]
 
+type BoundConnection = Request | WebSocket
+
 type DependencyCache = dict[DependencyCacheKey, Any]
 
 
@@ -82,6 +84,7 @@ __all__ = [
     "ArgMarker",
     "AsyncDecorator",
     "AsyncFunc",
+    "BoundConnection",
     "Coro",
     "Decorator",
     "Dep",

{fastapi_injected-0.3.3 → fastapi_injected-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "fastapi-injected"
-version = "0.3.3"
+version = "0.3.4"
 description = "Yet another library to reuse fastapi dependency injection"
 authors = [
     { name = "Yurii Karabas", email = "1998uriyyo@gmail.com" },

{fastapi_injected-0.3.3 → fastapi_injected-0.3.4}/tests/_typing/integration.py

@@ -1,6 +1,6 @@
 from collections.abc import AsyncGenerator
 
-from fastapi import Depends, FastAPI, Request
+from fastapi import Depends, FastAPI, Request, WebSocket
 
 from fastapi_injected import Dep, add_injected_scope, init_inject_scope
 
@@ -17,8 +17,9 @@ app = FastAPI(dependencies=[Depends(init_inject_scope)])
 static_assert(is_equivalent_to(TypeOf[add_injected_scope(app)], None))
 
 
-def _init_scope_is_a_generator_dependency(request: Request) -> None:
+def _init_scope_is_a_generator_dependency(request: Request, websocket: WebSocket) -> None:
     static_assert(is_equivalent_to(TypeOf[init_inject_scope(request)], AsyncGenerator[None]))
+    static_assert(is_equivalent_to(TypeOf[init_inject_scope(websocket)], AsyncGenerator[None]))
 
 
 @app.get("/")

{fastapi_injected-0.3.3 → fastapi_injected-0.3.4}/tests/_typing/scope.py

@@ -1,11 +1,11 @@
 from collections.abc import MutableMapping
 from typing import Any
 
-from fastapi import Request
+from fastapi import Request, WebSocket
 
 from fastapi_injected import push_inject_scope
 from fastapi_injected.scope import InjectScope, inside_inject_scope
-from fastapi_injected.types import DependencyCache
+from fastapi_injected.types import BoundConnection, DependencyCache
 
 from .deps import (
     TypeOf,
@@ -19,8 +19,9 @@ async def _scope() -> None:
         static_assert(is_equivalent_to(TypeOf[scope], InjectScope))
         static_assert(is_equivalent_to(TypeOf[scope.dependency_cache], DependencyCache))
         # a scope pushed by `push_inject_scope` is always bound, but the field is optional
-        static_assert(is_equivalent_to(TypeOf[scope.request], Request | None))
-        static_assert(is_equivalent_to(TypeOf[scope.bound_request], Request))
+        static_assert(is_equivalent_to(TypeOf[scope.request], BoundConnection | None))
+        static_assert(is_equivalent_to(TypeOf[scope.bound_request], BoundConnection))
+        static_assert(is_equivalent_to(TypeOf[scope.bound_request], Request | WebSocket))
         static_assert(is_equivalent_to(TypeOf[scope.bound], bool))
         static_assert(is_equivalent_to(TypeOf[scope.path_format], str | None))
         static_assert(is_equivalent_to(TypeOf[scope.synthetic], bool))
@@ -42,6 +43,15 @@ async def _scope() -> None:
             static_assert(is_equivalent_to(TypeOf[nested], InjectScope))
 
 
+async def _bound_to(request: Request, websocket: WebSocket) -> None:
+    # a scope is bound to whichever the route has - a request or a websocket
+    async with push_inject_scope(request=request):
+        pass
+
+    async with push_inject_scope(request=websocket):
+        pass
+
+
 def _current_scope() -> None:
     # outside of any scope there is none, so the result is optional
     static_assert(is_equivalent_to(TypeOf[InjectScope.current()], InjectScope | None))
@@ -52,3 +62,6 @@ async def _negatives() -> None:
         pass
 
     _ = InjectScope.current().dependency_cache  # type: ignore[ty:unresolved-attribute]
+
+    async with push_inject_scope(request=object()):  # type: ignore[ty:invalid-argument-type]
+        pass

{fastapi_injected-0.3.3 → fastapi_injected-0.3.4}/tests/test_fastapi.py

@@ -1,7 +1,10 @@
 from typing import Annotated
 
-from fastapi import Depends, FastAPI, Header, Request, status
+import pytest
+from fastapi import Depends, FastAPI, Header, Request, WebSocket, WebSocketDisconnect, status
 from fastapi.testclient import TestClient
+from starlette.requests import HTTPConnection
+from starlette.websockets import WebSocketState
 
 from fastapi_injected import Dep, Injected, init_inject_scope, inject, push_inject_scope, resolve
 from fastapi_injected._fastapi_lifecycle import add_injected_scope
@@ -178,6 +181,23 @@ def test_app_dependency_overrides_are_used() -> None:
     assert result.status_code == status.HTTP_200_OK
 
 
+@overridden_app.websocket("/ws")
+async def overridden_ws_route(websocket: WebSocket, child: Dep[Child]) -> None:
+    await websocket.accept()
+    await websocket.send_json({"overridden": child is _overridden_child and await resolve(Child) is child})
+    await websocket.close()
+
+
+def test_app_dependency_overrides_are_used_in_websocket() -> None:
+    overridden_app.dependency_overrides[Child] = _override_child
+
+    try:
+        with overridden_client.websocket_connect("/ws") as ws:
+            assert ws.receive_json() == {"overridden": True}
+    finally:
+        overridden_app.dependency_overrides.clear()
+
+
 async def _header_dep(x_trace: Annotated[str, Header()] = "missing") -> str:
     return x_trace
 
@@ -211,3 +231,150 @@ def test_new_scope_is_fresh_and_keeps_the_request() -> None:
 
     assert result.status_code == status.HTTP_200_OK
     assert result.json() == {"is_fresh": True, "keeps_request": True}
+
+
+@inject
+async def _ws_func(
+    *,
+    container: Dep[Container] = Injected,
+) -> Container:
+    return container
+
+
+@app.websocket("/ws")
+async def ws_route(websocket: WebSocket, container: Dep[Container]) -> None:
+    await websocket.accept()
+
+    same = await resolve(Container) is container and await _ws_func() is container
+
+    await websocket.send_json({"same": same})
+    await websocket.close()
+
+
+def test_websocket_cache_is_working() -> None:
+    with client.websocket_connect("/ws") as ws:
+        assert ws.receive_json() == {"same": True}
+
+
+@app.websocket("/ws/items/{item_id}")
+async def ws_item_route(websocket: WebSocket, item_id: ItemID) -> None:
+    await websocket.accept()
+    await websocket.send_json({"item_id": await resolve(ItemID) == item_id, "value": item_id})
+    await websocket.close()
+
+
+def test_websocket_resolve_uses_route_path() -> None:
+    with client.websocket_connect("/ws/items/42") as ws:
+        assert ws.receive_json() == {"item_id": True, "value": 42}
+
+
+async def _ws_dep(websocket: WebSocket) -> WebSocket:
+    return websocket
+
+
+async def _connection_dep(connection: HTTPConnection) -> HTTPConnection:
+    return connection
+
+
+type WS = Annotated[WebSocket, Depends(_ws_dep)]
+type Connection = Annotated[HTTPConnection, Depends(_connection_dep)]
+
+
+@app.websocket("/ws/send")
+async def ws_send_route(websocket: WebSocket) -> None:
+    await websocket.accept()
+
+    scope = InjectScope.current()
+    assert scope is not None
+    assert scope.request is not websocket
+
+    async with push_inject_scope(request=websocket) as nested:
+        assert nested.request is not websocket
+        assert not nested.synthetic
+
+        resolved = await resolve(WS)
+        connection = await resolve(Connection)
+
+        assert isinstance(connection, WebSocket)
+        assert resolved.scope["path"] == websocket.scope["path"]
+
+        await resolved.send_json({"from": "dependency"})
+
+    await websocket.send_json({"from": "route"})
+    await websocket.close()
+
+
+def test_websocket_dependency_shares_the_handshake() -> None:
+    with client.websocket_connect("/ws/send") as ws:
+        assert ws.receive_json() == {"from": "dependency"}
+        assert ws.receive_json() == {"from": "route"}
+
+
+@app.websocket("/ws/close")
+async def ws_close_route(websocket: WebSocket) -> None:
+    await websocket.accept()
+
+    resolved = await resolve(WS)
+    await resolved.close()
+
+    # closing through the bound websocket closed the one the route holds too
+    assert websocket.application_state is WebSocketState.DISCONNECTED
+
+
+def test_websocket_close_through_dependency_is_seen_by_the_route() -> None:
+    with client.websocket_connect("/ws/close") as ws, pytest.raises(WebSocketDisconnect):
+        ws.receive_json()
+
+
+@app.websocket("/ws/state")
+async def ws_state_route(websocket: WebSocket) -> None:
+    await websocket.accept()
+    websocket.state.value = 42
+
+    async with push_inject_scope(request=websocket) as scope:
+        assert scope.request.state.value == 42
+        scope.request.state.value = 43
+
+    await websocket.send_json({"value": websocket.state.value})
+    await websocket.close()
+
+
+def test_websocket_nested_scope_shares_state() -> None:
+    with client.websocket_connect("/ws/state") as ws:
+        assert ws.receive_json() == {"value": 43}
+
+
+_ws_states: list[ContextState] = []
+
+
+@app.websocket("/ws/teardown")
+async def ws_teardown_route(websocket: WebSocket) -> None:
+    await websocket.accept()
+
+    _ws_states.append(await resolve(ctx_dep))
+    await websocket.send_json({"closed": _ws_states[-1].closed})
+    await websocket.close()
+
+
+def test_websocket_dependencies_are_torn_down_with_the_connection() -> None:
+    _ws_states.clear()
+
+    with client.websocket_connect("/ws/teardown") as ws:
+        assert ws.receive_json() == {"closed": False}
+
+    assert [state.closed for state in _ws_states] == [True]
+
+
+@app.websocket("/ws/new-scope")
+async def ws_new_scope_route(websocket: WebSocket, container: Dep[Container]) -> None:
+    await websocket.accept()
+
+    fresh, _ = await _in_new_scope()
+
+    await websocket.send_json({"is_fresh": fresh is not container})
+    await websocket.close()
+
+
+def test_websocket_new_scope_is_fresh() -> None:
+    with client.websocket_connect("/ws/new-scope") as ws:
+        assert ws.receive_json() == {"is_fresh": True}