Dependencies not working on websocket connection

[bgorzsony]

First Check

• I added a very descriptive title to this issue.
• I used the GitHub search to find a similar issue and didn't find it.
• I searched the FastAPI documentation, with the integrated search.
• I already searched in Google "How to X in FastAPI" and didn't find any information.
• I already read and followed all the tutorial in the docs and didn't find an answer.
• I already checked if it is not related to FastAPI but to Pydantic.
• I already checked if it is not related to FastAPI but to Swagger UI.
• I already checked if it is not related to FastAPI but to ReDoc.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from fastapi import Depends, FastAPI,APIRouter,Request, WebSocket



def my_dependency(request: Request):
    print("called_my_dependency")
    request.state.my_var = "my_var"


app = FastAPI(
    dependencies=[Depends(my_dependency)]
)

def get_test(request: Request):
    print(request.state.my_var)
    return request.state.my_var

async def ws_test(websocket: WebSocket):
    print(websocket.state.my_var)



app.add_api_route('/get',get_test)
app.add_api_websocket_route('/ws',ws_test)

Description

Running the code above and sending a get request to /get yields:

$ curl 127.0.0.1:8000/get | jq
% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100     8  100     8    0     0   4672      0 --:--:-- --:--:-- --:--:--  8000
"my_var"

It works fine my_dependency function runs

Trying to connect to /ws endpoint on the other hand throws an error:

$ wscat --connect 127.0.0.1:8000/ws
error: Unexpected server response: 500

From the server's output it's visible my_var can't be found because my_dependency doesn't run.

AttributeError: 'State' object has no attribute 'my_var'

I don't know if it's intended or a bug but, I would expect it to run on the websocket connection as well and be able to access the state variables on the request.

I have also tried it with APIRouter and the results are the same.

Operating System

Linux

Operating System Details

No response

FastAPI Version

0.78.0

Python Version

Python 3.10.4

Additional Context

No response

[j-carson]

I don't see how a dependency that takes an HTML Request as an arg would be expected to run on a websocket connection? Just because the Websocket and Request objects both have an attribute called “state” does not mean they are interchangeable. I think you need a different dependency that takes a Websocket as the argument type.

[JarroVGIT]

Both Request and Websocket inherit from starlette.HTTPConnection. This base class has a state property, so your code should run fine (even though you technically wrong-typed the request parameter in my_dependency(). However, I was able to reproduce the described behaviour, in which its seems that the dependency is never executed when connecting to the websocket.

Did some digging on this behaviour. I don't know if it is a bug or intended, but at least I can explain why this is happening. It seems that global dependencies, that are set in the Fastapi() object, are not trickled down to the explicit websocket routes. In 'normal' routes (like your /get route), the route is added to the Fastapi application with the Fastapi.add_api_route. This adds the route of the default type APIRoute (with the path, the path operation function, and other elements such as dependencies, response codes etc.) to the Fastapi.routes list. For dependencies, it will actually extend any global dependencies with the route specific dependencies.

See routing.py -> APIRouter -> add_api_route(), line 532 onwards.

However, when adding a Websocket route, this behaviour is not the same! When adding a websocket route to the Fastapi() object as type APIWebSocketRoute, but it doesn't do anything with global dependencies. I cannot think of a reason why, so I am leaning towards that this is actually a bug. The weird thing is, that the class APIWebSocketRoute doesn't even have a property of dependencies like its sister class APIRoute has.

You can circumvent this by adding the dependency directly in the path operation function; this is working code:

from fastapi import Depends, FastAPI,APIRouter,Request, WebSocket
import uvicorn

def my_dependency(request: Request | WebSocket):
    print("called_my_dependency")
    
    request.state.my_var = "my_var"

app = FastAPI(
    dependencies=[Depends(my_dependency)]
)

def get_test(request: Request):
    print(request.state.my_var)
    return request.state.my_var

async def ws_test(websocket: WebSocket, _ = Depends(my_dependency)):
    print(websocket.state.my_var)

app.add_api_route('/get',get_test)
app.add_api_websocket_route('/ws',ws_test)

if __name__ == "__main__":
    uvicorn.run(app, host="127.0.0.1", port=8000)

[MichadeGroot]

@JarroVGIT I tried to run your snippet and I got a Pydantic error that a Uniont of a Request and a WebSocket is not allowed:
fastapi.exceptions.FastAPIError: Invalid args for response field! Hint: check that typing.Union[starlette.requests.Request, starlette.websockets.WebSocket] is a valid pydantic field type

Is there potentially another way to use the same dependency for both a Request and a WebSocket?

[JarroVGIT]

Interesting that this doesn’t work anymore, somewhere in the pas year a breaking change was introduced. I can see it has something to do with the new mechanics on the response model (it actually tries to create a response field for some strange reason).

I can’t think of any other way, sprry

[Nepich]

You can make an abstract class with abstractmethod __call__
something like

class MyDependency(ABC):
    @abstractclass
    def __call__(self, *args, **kwargs):
    pass
    
class WSDep(MyDependency):
    def __call__(self, request: WebSocket):
        # your logic

class HTTPDep((MyDependency):
    def __call__(self, request: Request, response: Response):
        # your logic

[alessandro-olivo]

In case anyone ends up here, this works [tested with fastapi 0.108.0]:

async def mydep(request: Request = None, websocket: WebSocket = None):
    if request:
        # http logic
    elif websocket:
        # ws logic
    else:
        # waat ??

[aemonge]

Wonderful !!! And just in case someone need the OAuth2PasswordBearer version:

async def dual_oauth2_password_bearer(
    request: Request = None,  # type: ignore
    websocket: WebSocket = None,  # type: ignore
) -> str | None:
    """
    Load oauth2 only if not a websocket request.

    Parameters
    ----------
    request: Request
        The request.
    websocket: WebSocket
        The websocket.

    Returns
    -------
    Optional[str]
        The token.
    """
    if request:
        return await OAuth2PasswordBearer(tokenUrl="token", auto_error=False)(request)
    _ = websocket  # TODO: Implement a websockets version of oauth2
    return None

[bhumkong]

As described in documentation:

When you want to define dependencies that should be compatible with both HTTP and WebSockets, you can define a parameter that takes an HTTPConnection instead of a Request or a WebSocket.

It works.

from starlette.requests import HTTPConnection

async def dependency(connection: HTTPConnection):
    ...