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.

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)

@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?

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

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