Question: Using handler decorators on methods

[byte-bot-app[bot]]

Reported by @skewty in Discord: <#1212105750608871445>:

The following MCVE ish code works, but for reasons outlined in this (and surrounding messages) OP prefers to use a web socket handler that is a method.

Changing async def handler(socket: WebSocket) -> None: to async def handler(self, socket: WebSocket) -> None: causes a 403 connection closed error.

from litestar import Litestar, WebSocket, websocket

class Something:
    @websocket("/ws")
    async def handler(socket: WebSocket) -> None:
        await socket.accept()

app = Litestar([Something().handler])

As per docs

In difference to HTTP routes handlers, websocket handlers have the following requirements:

they must declare a socket kwarg.
they must have a return annotation of None.
they must be async functions.

These requirements are enforced using inspection, and if any of them is unfulfilled an informative exception will be raised.

Shouldn't an error be raised? Is this usage recommend?

[skewty]

So I tried to implement this as a stand-alone function and discovered that any dependency named "self" breaks the route.
Renaming the dependency / function parameter from "self" "self_" fixes the issue and the web socket route starts working again.

[skewty]

Also note the handler copies some code from: https://docs.litestar.dev/2/usage/channels.html#managing-history

But when running it:

RuntimeWarning: coroutine 'ChannelsPlugin.subscribe' was never awaited
  async with channels.subscribe(all_channels) as subscriber:

It appears the sample code in the documentation is no longer valid.

async with channels.subscribe(["some_channel"]) as subscriber:
# should be changed to
async with channels.start_subscription(["some_channel"]) as subscriber:

[provinzkraut]

The issue here is that at the time the @websocket decorator is passed Something.handler, the function is still unbound (i.e. the self argument won't receive the instance you created automatically, because it doesn't exist yet).

You can fix this by changing how you pass the handlers:

from litestar import Litestar, WebSocket, websocket

class Something:
    async def handler(socket: WebSocket) -> None:
        await socket.accept()

app = Litestar([websocket("/ws")(Something().handler)])

Litestar itself does something similar in the ChannelsPlugin:

litestar/litestar/channels/plugin.py

Lines 117 to 126 in 1332983

	if self._arbitrary_channels_allowed:
	path = self._handler_root_path + "{channel_name:str}"
	route_handlers = [WebsocketRouteHandler(path)(self._ws_handler_func)]
	else:
	route_handlers = [
	WebsocketRouteHandler(self._handler_root_path + channel_name)(
	self._create_ws_handler_func(channel_name)
	)
	for channel_name in self._channels
	]

---

Is this usage recommend?

No, I wouldn't recommend it, and I would advise you to change how you've set up your code that this is a requirement. Usually there are ways to work around this.

[aranvir]

You can also make the class a Controller, then self is not a problem.

from litestar import Litestar, WebSocket, websocket, Controller

class Something(Controller):
    @websocket("/ws")
    async def handler(self, socket: WebSocket) -> None:
        await socket.accept()

app = Litestar([Something])