Python websockets lib client persistent connection (with class implementation)

Question

I'm trying to implement a websocket client in python using websockets and the apparently mandatory asyncio which I never used before (and I have a hard time to understand...).

I've read a lot on the subject and saw (too) many examples here and everywhere, but I can't find a way to properly make a websocket client with a persistent connection.

I need to have a persistent connection because the commands need to be requested on the same connection, the first one being an authentication command.
The remote server is a 3rd party API I don't have any control over.
I suppose I could run an authentication request along with each command my program sends but that does not feel right to open > auth > request > close for each command instead of keeping one connection alive during the whole program's life
My implementation is a library using many classes and I need to wrap the websocket connector/handler in one of them

Here's what I have right now, based on examples I found here and there (with some obfuscated data) :

import json
import asyncio
from websockets import connect


URL = 'wss://server.com/endpoint'


class Websocket:
    async def __aenter__(self):
        self._conn = connect(URL)
        self.websocket = await self._conn.__aenter__()
        return self

    async def __aexit__(self, *args, **kwargs):
        await self._conn.__aexit__(*args, **kwargs)

    async def send(self, message):
        await self.websocket.send(message)

    async def receive(self):
        return await self.websocket.recv()


class Handler:
    def __init__(self):
        self.wws = Websocket()
        self.loop = asyncio.get_event_loop()

    def command(self, cmd):
        return self.loop.run_until_complete(self.__async__command(cmd))

    async def __async__command(self, cmd):
        async with self.wws as echo:
            await echo.send(json.dumps(cmd))
            return await echo.receive()


def main():
    handler = Handler()

    foo = handler.command('authentication command')
    print('auth: ', foo)

    bar = handler.command('another command to run depending on the first authentication')
    print('command: ', bar)


if __name__ == '__main__':
    main()

Basically right now I get these answers (simplified and obfuscated) :

auth: Ok, authenticated
command: Command refused, not authenticated

I suppose my problem is that the block async with self.wws as echo: kind of create the connection, runs its code then drop it instead of keeping the connection alive. Since we are not using a usual __init__ here but some asyncio voodoo I don't understand, I'm kind of stuck.

Darren Smith · Accepted Answer · 2019-12-05 09:21:16Z

4

I think your diagnosis is correct, the problem is that the async context manager it creating and closing a connection for each call of Handler.command ... really not want you want.

Instead you could just synchronously establish the websocket connection during the init of Handler and then store the connection websocket (instance of type WebSocketClientProtocol) as a class member for later use, as in this sample code:

import json
import asyncio
from websockets import connect

URL = 'ws://localhost:8000'

class Handler:

    def __init__(self):
        self.ws = None
        self.loop = asyncio.get_event_loop()
        # perform a synchronous connect
        self.loop.run_until_complete(self.__async__connect())

    async def __async__connect(self):
        print("attempting connection to {}".format(URL))
        # perform async connect, and store the connected WebSocketClientProtocol
        # object, for later reuse for send & recv
        self.ws = await connect(URL)
        print("connected")

    def command(self, cmd):
        return self.loop.run_until_complete(self.__async__command(cmd))

    async def __async__command(self, cmd):
        await self.ws.send(json.dumps(cmd))
        return await self.ws.recv()


def main():
    handler = Handler()

    foo = handler.command('authentication command')
    print('auth: ', foo)

    bar = handler.command('another command to run depending on the first authentication')
    print('command: ', bar)


if __name__ == '__main__':
    main()

edited Dec 5, 2019 at 9:21

answered Dec 5, 2019 at 8:42

Darren Smith

2,54821 silver badges18 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Frankie Drake Over a year ago

How did you make it work? I'm getting RuntimeError: There is no current event loop in thread 'MainThread'.

Darren Smith Over a year ago

I just tried the same code, on python 3.9, and does work.

RaviHara · Accepted Answer · 2024-05-16 04:58:17Z

0

The above answer from Darren Smith looks fine except that, we could use the following code to initiate the asyncio event loop properly.

def init_event_loop(self):
    try:
        self.loop = asyncio.get_event_loop()
    except RuntimeError:
        self.loop = asyncio.new_event_loop()
        asyncio.set_event_loop(self.loop)

Then in the __init__ method, use self.init_event_loop() instead of self.loop = asyncio.get_event_loop()

answered May 16, 2024 at 4:58

RaviHara

365 bronze badges

Collectives™ on Stack Overflow

Python websockets lib client persistent connection (with class implementation)

2 Answers 2

2 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related