tests versuch 2

venv/lib/python3.11/site-packages/socketio/__init__.py

@@ -0,0 +1,36 @@
+import sys
+
+from .client import Client
+from .base_manager import BaseManager
+from .pubsub_manager import PubSubManager
+from .kombu_manager import KombuManager
+from .redis_manager import RedisManager
+from .kafka_manager import KafkaManager
+from .zmq_manager import ZmqManager
+from .server import Server
+from .namespace import Namespace, ClientNamespace
+from .middleware import WSGIApp, Middleware
+from .tornado import get_tornado_handler
+if sys.version_info >= (3, 5):  # pragma: no cover
+    from .asyncio_client import AsyncClient
+    from .asyncio_server import AsyncServer
+    from .asyncio_manager import AsyncManager
+    from .asyncio_namespace import AsyncNamespace, AsyncClientNamespace
+    from .asyncio_redis_manager import AsyncRedisManager
+    from .asyncio_aiopika_manager import AsyncAioPikaManager
+    from .asgi import ASGIApp
+else:  # pragma: no cover
+    AsyncClient = None
+    AsyncServer = None
+    AsyncManager = None
+    AsyncNamespace = None
+    AsyncRedisManager = None
+    AsyncAioPikaManager = None
+
+__all__ = ['Client', 'Server', 'BaseManager', 'PubSubManager',
+           'KombuManager', 'RedisManager', 'ZmqManager', 'KafkaManager',
+           'Namespace', 'ClientNamespace', 'WSGIApp', 'Middleware']
+if AsyncServer is not None:  # pragma: no cover
+    __all__ += ['AsyncClient', 'AsyncServer', 'AsyncNamespace',
+                'AsyncClientNamespace', 'AsyncManager', 'AsyncRedisManager',
+                'ASGIApp', 'get_tornado_handler', 'AsyncAioPikaManager']

venv/lib/python3.11/site-packages/socketio/asgi.py

@@ -0,0 +1,42 @@
+import engineio
+
+
+class ASGIApp(engineio.ASGIApp):  # pragma: no cover
+    """ASGI application middleware for Socket.IO.
+
+    This middleware dispatches traffic to an Socket.IO application. It can
+    also serve a list of static files to the client, or forward unrelated
+    HTTP traffic to another ASGI application.
+
+    :param socketio_server: The Socket.IO server. Must be an instance of the
+                            ``socketio.AsyncServer`` class.
+    :param static_files: A dictionary with static file mapping rules. See the
+                         documentation for details on this argument.
+    :param other_asgi_app: A separate ASGI app that receives all other traffic.
+    :param socketio_path: The endpoint where the Socket.IO application should
+                          be installed. The default value is appropriate for
+                          most cases.
+    :param on_startup: function to be called on application startup; can be
+                       coroutine
+    :param on_shutdown: function to be called on application shutdown; can be
+                        coroutine
+
+    Example usage::
+
+        import socketio
+        import uvicorn
+
+        sio = socketio.AsyncServer()
+        app = engineio.ASGIApp(sio, static_files={
+            '/': 'index.html',
+            '/static': './public',
+        })
+        uvicorn.run(app, host='127.0.0.1', port=5000)
+    """
+    def __init__(self, socketio_server, other_asgi_app=None,
+                 static_files=None, socketio_path='socket.io',
+                 on_startup=None, on_shutdown=None):
+        super().__init__(socketio_server, other_asgi_app,
+                         static_files=static_files,
+                         engineio_path=socketio_path, on_startup=on_startup,
+                         on_shutdown=on_shutdown)

venv/lib/python3.11/site-packages/socketio/asyncio_aiopika_manager.py

@@ -0,0 +1,126 @@
+import asyncio
+import pickle
+
+from socketio.asyncio_pubsub_manager import AsyncPubSubManager
+
+try:
+    import aio_pika
+except ImportError:
+    aio_pika = None
+
+
+class AsyncAioPikaManager(AsyncPubSubManager):  # pragma: no cover
+    """Client manager that uses aio_pika for inter-process messaging under
+    asyncio.
+
+    This class implements a client manager backend for event sharing across
+    multiple processes, using RabbitMQ
+
+    To use a aio_pika backend, initialize the :class:`Server` instance as
+    follows::
+
+        url = 'amqp://user:password@hostname:port//'
+        server = socketio.Server(client_manager=socketio.AsyncAioPikaManager(
+            url))
+
+    :param url: The connection URL for the backend messaging queue. Example
+                connection URLs are ``'amqp://guest:guest@localhost:5672//'``
+                for RabbitMQ.
+    :param channel: The channel name on which the server sends and receives
+                    notifications. Must be the same in all the servers.
+                    With this manager, the channel name is the exchange name
+                    in rabbitmq
+    :param write_only: If set to ``True``, only initialize to emit events. The
+                       default of ``False`` initializes the class for emitting
+                       and receiving.
+    """
+
+    name = 'asyncaiopika'
+
+    def __init__(self, url='amqp://guest:guest@localhost:5672//',
+                 channel='socketio', write_only=False, logger=None):
+        if aio_pika is None:
+            raise RuntimeError('aio_pika package is not installed '
+                               '(Run "pip install aio_pika" in your '
+                               'virtualenv).')
+        self.url = url
+        self._lock = asyncio.Lock()
+        self.publisher_connection = None
+        self.publisher_channel = None
+        self.publisher_exchange = None
+        super().__init__(channel=channel, write_only=write_only, logger=logger)
+
+    async def _connection(self):
+        return await aio_pika.connect_robust(self.url)
+
+    async def _channel(self, connection):
+        return await connection.channel()
+
+    async def _exchange(self, channel):
+        return await channel.declare_exchange(self.channel,
+                                              aio_pika.ExchangeType.FANOUT)
+
+    async def _queue(self, channel, exchange):
+        queue = await channel.declare_queue(durable=False,
+                                            arguments={'x-expires': 300000})
+        await queue.bind(exchange)
+        return queue
+
+    async def _publish(self, data):
+        if self.publisher_connection is None:
+            async with self._lock:
+                if self.publisher_connection is None:
+                    self.publisher_connection = await self._connection()
+                    self.publisher_channel = await self._channel(
+                        self.publisher_connection
+                    )
+                    self.publisher_exchange = await self._exchange(
+                        self.publisher_channel
+                    )
+        retry = True
+        while True:
+            try:
+                await self.publisher_exchange.publish(
+                    aio_pika.Message(
+                        body=pickle.dumps(data),
+                        delivery_mode=aio_pika.DeliveryMode.PERSISTENT
+                    ), routing_key='*',
+                )
+                break
+            except aio_pika.AMQPException:
+                if retry:
+                    self._get_logger().error('Cannot publish to rabbitmq... '
+                                             'retrying')
+                    retry = False
+                else:
+                    self._get_logger().error(
+                        'Cannot publish to rabbitmq... giving up')
+                    break
+            except aio_pika.exceptions.ChannelInvalidStateError:
+                # aio_pika raises this exception when the task is cancelled
+                raise asyncio.CancelledError()
+
+    async def _listen(self):
+        async with (await self._connection()) as connection:
+            channel = await self._channel(connection)
+            await channel.set_qos(prefetch_count=1)
+            exchange = await self._exchange(channel)
+            queue = await self._queue(channel, exchange)
+
+            retry_sleep = 1
+            while True:
+                try:
+                    async with queue.iterator() as queue_iter:
+                        async for message in queue_iter:
+                            async with message.process():
+                                yield pickle.loads(message.body)
+                                retry_sleep = 1
+                except aio_pika.AMQPException:
+                    self._get_logger().error(
+                        'Cannot receive from rabbitmq... '
+                        'retrying in {} secs'.format(retry_sleep))
+                    await asyncio.sleep(retry_sleep)
+                    retry_sleep = min(retry_sleep * 2, 60)
+                except aio_pika.exceptions.ChannelInvalidStateError:
+                    # aio_pika raises this exception when the task is cancelled
+                    raise asyncio.CancelledError()

venv/lib/python3.11/site-packages/socketio/asyncio_client.py

@@ -0,0 +1,549 @@
+import asyncio
+import logging
+import random
+
+import engineio
+
+from . import client
+from . import exceptions
+from . import packet
+
+default_logger = logging.getLogger('socketio.client')
+
+
+class AsyncClient(client.Client):
+    """A Socket.IO client for asyncio.
+
+    This class implements a fully compliant Socket.IO web client with support
+    for websocket and long-polling transports.
+
+    :param reconnection: ``True`` if the client should automatically attempt to
+                         reconnect to the server after an interruption, or
+                         ``False`` to not reconnect. The default is ``True``.
+    :param reconnection_attempts: How many reconnection attempts to issue
+                                  before giving up, or 0 for infinite attempts.
+                                  The default is 0.
+    :param reconnection_delay: How long to wait in seconds before the first
+                               reconnection attempt. Each successive attempt
+                               doubles this delay.
+    :param reconnection_delay_max: The maximum delay between reconnection
+                                   attempts.
+    :param randomization_factor: Randomization amount for each delay between
+                                 reconnection attempts. The default is 0.5,
+                                 which means that each delay is randomly
+                                 adjusted by +/- 50%.
+    :param logger: To enable logging set to ``True`` or pass a logger object to
+                   use. To disable logging set to ``False``. The default is
+                   ``False``. Note that fatal errors are logged even when
+                   ``logger`` is ``False``.
+    :param json: An alternative json module to use for encoding and decoding
+                 packets. Custom json modules must have ``dumps`` and ``loads``
+                 functions that are compatible with the standard library
+                 versions.
+    :param handle_sigint: Set to ``True`` to automatically handle disconnection
+                          when the process is interrupted, or to ``False`` to
+                          leave interrupt handling to the calling application.
+                          Interrupt handling can only be enabled when the
+                          client instance is created in the main thread.
+
+    The Engine.IO configuration supports the following settings:
+
+    :param request_timeout: A timeout in seconds for requests. The default is
+                            5 seconds.
+    :param http_session: an initialized ``aiohttp.ClientSession`` object to be
+                         used when sending requests to the server. Use it if
+                         you need to add special client options such as proxy
+                         servers, SSL certificates, etc.
+    :param ssl_verify: ``True`` to verify SSL certificates, or ``False`` to
+                       skip SSL certificate verification, allowing
+                       connections to servers with self signed certificates.
+                       The default is ``True``.
+    :param engineio_logger: To enable Engine.IO logging set to ``True`` or pass
+                            a logger object to use. To disable logging set to
+                            ``False``. The default is ``False``. Note that
+                            fatal errors are logged even when
+                            ``engineio_logger`` is ``False``.
+    """
+    def is_asyncio_based(self):
+        return True
+
+    async def connect(self, url, headers={}, auth=None, transports=None,
+                      namespaces=None, socketio_path='socket.io', wait=True,
+                      wait_timeout=1):
+        """Connect to a Socket.IO server.
+
+        :param url: The URL of the Socket.IO server. It can include custom
+                    query string parameters if required by the server. If a
+                    function is provided, the client will invoke it to obtain
+                    the URL each time a connection or reconnection is
+                    attempted.
+        :param headers: A dictionary with custom headers to send with the
+                        connection request. If a function is provided, the
+                        client will invoke it to obtain the headers dictionary
+                        each time a connection or reconnection is attempted.
+        :param auth: Authentication data passed to the server with the
+                     connection request, normally a dictionary with one or
+                     more string key/value pairs. If a function is provided,
+                     the client will invoke it to obtain the authentication
+                     data each time a connection or reconnection is attempted.
+        :param transports: The list of allowed transports. Valid transports
+                           are ``'polling'`` and ``'websocket'``. If not
+                           given, the polling transport is connected first,
+                           then an upgrade to websocket is attempted.
+        :param namespaces: The namespaces to connect as a string or list of
+                           strings. If not given, the namespaces that have
+                           registered event handlers are connected.
+        :param socketio_path: The endpoint where the Socket.IO server is
+                              installed. The default value is appropriate for
+                              most cases.
+        :param wait: if set to ``True`` (the default) the call only returns
+                     when all the namespaces are connected. If set to
+                     ``False``, the call returns as soon as the Engine.IO
+                     transport is connected, and the namespaces will connect
+                     in the background.
+        :param wait_timeout: How long the client should wait for the
+                             connection. The default is 1 second. This
+                             argument is only considered when ``wait`` is set
+                             to ``True``.
+
+        Note: this method is a coroutine.
+
+        Example usage::
+
+            sio = socketio.AsyncClient()
+            sio.connect('http://localhost:5000')
+        """
+        if self.connected:
+            raise exceptions.ConnectionError('Already connected')
+
+        self.connection_url = url
+        self.connection_headers = headers
+        self.connection_auth = auth
+        self.connection_transports = transports
+        self.connection_namespaces = namespaces
+        self.socketio_path = socketio_path
+
+        if namespaces is None:
+            namespaces = list(set(self.handlers.keys()).union(
+                set(self.namespace_handlers.keys())))
+            if len(namespaces) == 0:
+                namespaces = ['/']
+        elif isinstance(namespaces, str):
+            namespaces = [namespaces]
+        self.connection_namespaces = namespaces
+        self.namespaces = {}
+        if self._connect_event is None:
+            self._connect_event = self.eio.create_event()
+        else:
+            self._connect_event.clear()
+        real_url = await self._get_real_value(self.connection_url)
+        real_headers = await self._get_real_value(self.connection_headers)
+        try:
+            await self.eio.connect(real_url, headers=real_headers,
+                                   transports=transports,
+                                   engineio_path=socketio_path)
+        except engineio.exceptions.ConnectionError as exc:
+            await self._trigger_event(
+                'connect_error', '/',
+                exc.args[1] if len(exc.args) > 1 else exc.args[0])
+            raise exceptions.ConnectionError(exc.args[0]) from None
+
+        if wait:
+            try:
+                while True:
+                    await asyncio.wait_for(self._connect_event.wait(),
+                                           wait_timeout)
+                    self._connect_event.clear()
+                    if set(self.namespaces) == set(self.connection_namespaces):
+                        break
+            except asyncio.TimeoutError:
+                pass
+            if set(self.namespaces) != set(self.connection_namespaces):
+                await self.disconnect()
+                raise exceptions.ConnectionError(
+                    'One or more namespaces failed to connect')
+
+        self.connected = True
+
+    async def wait(self):
+        """Wait until the connection with the server ends.
+
+        Client applications can use this function to block the main thread
+        during the life of the connection.
+
+        Note: this method is a coroutine.
+        """
+        while True:
+            await self.eio.wait()
+            await self.sleep(1)  # give the reconnect task time to start up
+            if not self._reconnect_task:
+                break
+            await self._reconnect_task
+            if self.eio.state != 'connected':
+                break
+
+    async def emit(self, event, data=None, namespace=None, callback=None):
+        """Emit a custom event to one or more connected clients.
+
+        :param event: The event name. It can be any string. The event names
+                      ``'connect'``, ``'message'`` and ``'disconnect'`` are
+                      reserved and should not be used.
+        :param data: The data to send to the server. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. To send
+                     multiple arguments, use a tuple where each element is of
+                     one of the types indicated above.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param callback: If given, this function will be called to acknowledge
+                         the server has received the message. The arguments
+                         that will be passed to the function are those provided
+                         by the server.
+
+        Note: this method is not designed to be used concurrently. If multiple
+        tasks are emitting at the same time on the same client connection, then
+        messages composed of multiple packets may end up being sent in an
+        incorrect sequence. Use standard concurrency solutions (such as a Lock
+        object) to prevent this situation.
+
+        Note 2: this method is a coroutine.
+        """
+        namespace = namespace or '/'
+        if namespace not in self.namespaces:
+            raise exceptions.BadNamespaceError(
+                namespace + ' is not a connected namespace.')
+        self.logger.info('Emitting event "%s" [%s]', event, namespace)
+        if callback is not None:
+            id = self._generate_ack_id(namespace, callback)
+        else:
+            id = None
+        # tuples are expanded to multiple arguments, everything else is sent
+        # as a single argument
+        if isinstance(data, tuple):
+            data = list(data)
+        elif data is not None:
+            data = [data]
+        else:
+            data = []
+        await self._send_packet(self.packet_class(
+            packet.EVENT, namespace=namespace, data=[event] + data, id=id))
+
+    async def send(self, data, namespace=None, callback=None):
+        """Send a message to one or more connected clients.
+
+        This function emits an event with the name ``'message'``. Use
+        :func:`emit` to issue custom event names.
+
+        :param data: The data to send to the server. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. To send
+                     multiple arguments, use a tuple where each element is of
+                     one of the types indicated above.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param callback: If given, this function will be called to acknowledge
+                         the server has received the message. The arguments
+                         that will be passed to the function are those provided
+                         by the server.
+
+        Note: this method is a coroutine.
+        """
+        await self.emit('message', data=data, namespace=namespace,
+                        callback=callback)
+
+    async def call(self, event, data=None, namespace=None, timeout=60):
+        """Emit a custom event to a client and wait for the response.
+
+        This method issues an emit with a callback and waits for the callback
+        to be invoked before returning. If the callback isn't invoked before
+        the timeout, then a ``TimeoutError`` exception is raised. If the
+        Socket.IO connection drops during the wait, this method still waits
+        until the specified timeout.
+
+        :param event: The event name. It can be any string. The event names
+                      ``'connect'``, ``'message'`` and ``'disconnect'`` are
+                      reserved and should not be used.
+        :param data: The data to send to the server. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. To send
+                     multiple arguments, use a tuple where each element is of
+                     one of the types indicated above.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param timeout: The waiting timeout. If the timeout is reached before
+                        the client acknowledges the event, then a
+                        ``TimeoutError`` exception is raised.
+
+        Note: this method is not designed to be used concurrently. If multiple
+        tasks are emitting at the same time on the same client connection, then
+        messages composed of multiple packets may end up being sent in an
+        incorrect sequence. Use standard concurrency solutions (such as a Lock
+        object) to prevent this situation.
+
+        Note 2: this method is a coroutine.
+        """
+        callback_event = self.eio.create_event()
+        callback_args = []
+
+        def event_callback(*args):
+            callback_args.append(args)
+            callback_event.set()
+
+        await self.emit(event, data=data, namespace=namespace,
+                        callback=event_callback)
+        try:
+            await asyncio.wait_for(callback_event.wait(), timeout)
+        except asyncio.TimeoutError:
+            raise exceptions.TimeoutError() from None
+        return callback_args[0] if len(callback_args[0]) > 1 \
+            else callback_args[0][0] if len(callback_args[0]) == 1 \
+            else None
+
+    async def disconnect(self):
+        """Disconnect from the server.
+
+        Note: this method is a coroutine.
+        """
+        # here we just request the disconnection
+        # later in _handle_eio_disconnect we invoke the disconnect handler
+        for n in self.namespaces:
+            await self._send_packet(self.packet_class(packet.DISCONNECT,
+                                    namespace=n))
+        await self.eio.disconnect(abort=True)
+
+    def start_background_task(self, target, *args, **kwargs):
+        """Start a background task using the appropriate async model.
+
+        This is a utility function that applications can use to start a
+        background task using the method that is compatible with the
+        selected async mode.
+
+        :param target: the target function to execute.
+        :param args: arguments to pass to the function.
+        :param kwargs: keyword arguments to pass to the function.
+
+        The return value is a ``asyncio.Task`` object.
+        """
+        return self.eio.start_background_task(target, *args, **kwargs)
+
+    async def sleep(self, seconds=0):
+        """Sleep for the requested amount of time using the appropriate async
+        model.
+
+        This is a utility function that applications can use to put a task to
+        sleep without having to worry about using the correct call for the
+        selected async mode.
+
+        Note: this method is a coroutine.
+        """
+        return await self.eio.sleep(seconds)
+
+    async def _get_real_value(self, value):
+        """Return the actual value, for parameters that can also be given as
+        callables."""
+        if not callable(value):
+            return value
+        if asyncio.iscoroutinefunction(value):
+            return await value()
+        return value()
+
+    async def _send_packet(self, pkt):
+        """Send a Socket.IO packet to the server."""
+        encoded_packet = pkt.encode()
+        if isinstance(encoded_packet, list):
+            for ep in encoded_packet:
+                await self.eio.send(ep)
+        else:
+            await self.eio.send(encoded_packet)
+
+    async def _handle_connect(self, namespace, data):
+        namespace = namespace or '/'
+        if namespace not in self.namespaces:
+            self.logger.info('Namespace {} is connected'.format(namespace))
+            self.namespaces[namespace] = (data or {}).get('sid', self.sid)
+            await self._trigger_event('connect', namespace=namespace)
+            self._connect_event.set()
+
+    async def _handle_disconnect(self, namespace):
+        if not self.connected:
+            return
+        namespace = namespace or '/'
+        await self._trigger_event('disconnect', namespace=namespace)
+        if namespace in self.namespaces:
+            del self.namespaces[namespace]
+        if not self.namespaces:
+            self.connected = False
+            await self.eio.disconnect(abort=True)
+
+    async def _handle_event(self, namespace, id, data):
+        namespace = namespace or '/'
+        self.logger.info('Received event "%s" [%s]', data[0], namespace)
+        r = await self._trigger_event(data[0], namespace, *data[1:])
+        if id is not None:
+            # send ACK packet with the response returned by the handler
+            # tuples are expanded as multiple arguments
+            if r is None:
+                data = []
+            elif isinstance(r, tuple):
+                data = list(r)
+            else:
+                data = [r]
+            await self._send_packet(self.packet_class(
+                packet.ACK, namespace=namespace, id=id, data=data))
+
+    async def _handle_ack(self, namespace, id, data):
+        namespace = namespace or '/'
+        self.logger.info('Received ack [%s]', namespace)
+        callback = None
+        try:
+            callback = self.callbacks[namespace][id]
+        except KeyError:
+            # if we get an unknown callback we just ignore it
+            self.logger.warning('Unknown callback received, ignoring.')
+        else:
+            del self.callbacks[namespace][id]
+        if callback is not None:
+            if asyncio.iscoroutinefunction(callback):
+                await callback(*data)
+            else:
+                callback(*data)
+
+    async def _handle_error(self, namespace, data):
+        namespace = namespace or '/'
+        self.logger.info('Connection to namespace {} was rejected'.format(
+            namespace))
+        if data is None:
+            data = tuple()
+        elif not isinstance(data, (tuple, list)):
+            data = (data,)
+        await self._trigger_event('connect_error', namespace, *data)
+        self._connect_event.set()
+        if namespace in self.namespaces:
+            del self.namespaces[namespace]
+        if namespace == '/':
+            self.namespaces = {}
+            self.connected = False
+
+    async def _trigger_event(self, event, namespace, *args):
+        """Invoke an application event handler."""
+        # first see if we have an explicit handler for the event
+        if namespace in self.handlers:
+            handler = None
+            if event in self.handlers[namespace]:
+                handler = self.handlers[namespace][event]
+            elif event not in self.reserved_events and \
+                    '*' in self.handlers[namespace]:
+                handler = self.handlers[namespace]['*']
+                args = (event, *args)
+            if handler:
+                if asyncio.iscoroutinefunction(handler):
+                    try:
+                        ret = await handler(*args)
+                    except asyncio.CancelledError:  # pragma: no cover
+                        ret = None
+                else:
+                    ret = handler(*args)
+                return ret
+
+        # or else, forward the event to a namepsace handler if one exists
+        elif namespace in self.namespace_handlers:
+            return await self.namespace_handlers[namespace].trigger_event(
+                event, *args)
+
+    async def _handle_reconnect(self):
+        if self._reconnect_abort is None:  # pragma: no cover
+            self._reconnect_abort = self.eio.create_event()
+        self._reconnect_abort.clear()
+        client.reconnecting_clients.append(self)
+        attempt_count = 0
+        current_delay = self.reconnection_delay
+        while True:
+            delay = current_delay
+            current_delay *= 2
+            if delay > self.reconnection_delay_max:
+                delay = self.reconnection_delay_max
+            delay += self.randomization_factor * (2 * random.random() - 1)
+            self.logger.info(
+                'Connection failed, new attempt in {:.02f} seconds'.format(
+                    delay))
+            try:
+                await asyncio.wait_for(self._reconnect_abort.wait(), delay)
+                self.logger.info('Reconnect task aborted')
+                break
+            except (asyncio.TimeoutError, asyncio.CancelledError):
+                pass
+            attempt_count += 1
+            try:
+                await self.connect(self.connection_url,
+                                   headers=self.connection_headers,
+                                   auth=self.connection_auth,
+                                   transports=self.connection_transports,
+                                   namespaces=self.connection_namespaces,
+                                   socketio_path=self.socketio_path)
+            except (exceptions.ConnectionError, ValueError):
+                pass
+            else:
+                self.logger.info('Reconnection successful')
+                self._reconnect_task = None
+                break
+            if self.reconnection_attempts and \
+                    attempt_count >= self.reconnection_attempts:
+                self.logger.info(
+                    'Maximum reconnection attempts reached, giving up')
+                break
+        client.reconnecting_clients.remove(self)
+
+    async def _handle_eio_connect(self):
+        """Handle the Engine.IO connection event."""
+        self.logger.info('Engine.IO connection established')
+        self.sid = self.eio.sid
+        real_auth = await self._get_real_value(self.connection_auth) or {}
+        for n in self.connection_namespaces:
+            await self._send_packet(self.packet_class(
+                packet.CONNECT, data=real_auth, namespace=n))
+
+    async def _handle_eio_message(self, data):
+        """Dispatch Engine.IO messages."""
+        if self._binary_packet:
+            pkt = self._binary_packet
+            if pkt.add_attachment(data):
+                self._binary_packet = None
+                if pkt.packet_type == packet.BINARY_EVENT:
+                    await self._handle_event(pkt.namespace, pkt.id, pkt.data)
+                else:
+                    await self._handle_ack(pkt.namespace, pkt.id, pkt.data)
+        else:
+            pkt = self.packet_class(encoded_packet=data)
+            if pkt.packet_type == packet.CONNECT:
+                await self._handle_connect(pkt.namespace, pkt.data)
+            elif pkt.packet_type == packet.DISCONNECT:
+                await self._handle_disconnect(pkt.namespace)
+            elif pkt.packet_type == packet.EVENT:
+                await self._handle_event(pkt.namespace, pkt.id, pkt.data)
+            elif pkt.packet_type == packet.ACK:
+                await self._handle_ack(pkt.namespace, pkt.id, pkt.data)
+            elif pkt.packet_type == packet.BINARY_EVENT or \
+                    pkt.packet_type == packet.BINARY_ACK:
+                self._binary_packet = pkt
+            elif pkt.packet_type == packet.CONNECT_ERROR:
+                await self._handle_error(pkt.namespace, pkt.data)
+            else:
+                raise ValueError('Unknown packet type.')
+
+    async def _handle_eio_disconnect(self):
+        """Handle the Engine.IO disconnection event."""
+        self.logger.info('Engine.IO connection dropped')
+        if self.connected:
+            for n in self.namespaces:
+                await self._trigger_event('disconnect', namespace=n)
+            self.namespaces = {}
+            self.connected = False
+        self.callbacks = {}
+        self._binary_packet = None
+        self.sid = None
+        if self.eio.state == 'connected' and self.reconnection:
+            self._reconnect_task = self.start_background_task(
+                self._handle_reconnect)
+
+    def _engineio_client_class(self):
+        return engineio.AsyncClient

venv/lib/python3.11/site-packages/socketio/asyncio_manager.py

@@ -0,0 +1,69 @@
+import asyncio
+
+from .base_manager import BaseManager
+
+
+class AsyncManager(BaseManager):
+    """Manage a client list for an asyncio server."""
+    async def can_disconnect(self, sid, namespace):
+        return self.is_connected(sid, namespace)
+
+    async def emit(self, event, data, namespace, room=None, skip_sid=None,
+                   callback=None, **kwargs):
+        """Emit a message to a single client, a room, or all the clients
+        connected to the namespace.
+
+        Note: this method is a coroutine.
+        """
+        if namespace not in self.rooms:
+            return
+        tasks = []
+        if not isinstance(skip_sid, list):
+            skip_sid = [skip_sid]
+        for sid, eio_sid in self.get_participants(namespace, room):
+            if sid not in skip_sid:
+                if callback is not None:
+                    id = self._generate_ack_id(sid, callback)
+                else:
+                    id = None
+                tasks.append(asyncio.create_task(
+                    self.server._emit_internal(eio_sid, event, data,
+                                               namespace, id)))
+        if tasks == []:  # pragma: no cover
+            return
+        await asyncio.wait(tasks)
+
+    async def disconnect(self, sid, namespace, **kwargs):
+        """Disconnect a client.
+
+        Note: this method is a coroutine.
+        """
+        return super().disconnect(sid, namespace, **kwargs)
+
+    async def close_room(self, room, namespace):
+        """Remove all participants from a room.
+
+        Note: this method is a coroutine.
+        """
+        return super().close_room(room, namespace)
+
+    async def trigger_callback(self, sid, id, data):
+        """Invoke an application callback.
+
+        Note: this method is a coroutine.
+        """
+        callback = None
+        try:
+            callback = self.callbacks[sid][id]
+        except KeyError:
+            # if we get an unknown callback we just ignore it
+            self._get_logger().warning('Unknown callback received, ignoring.')
+        else:
+            del self.callbacks[sid][id]
+        if callback is not None:
+            ret = callback(*data)
+            if asyncio.iscoroutine(ret):
+                try:
+                    await ret
+                except asyncio.CancelledError:  # pragma: no cover
+                    pass

venv/lib/python3.11/site-packages/socketio/asyncio_namespace.py

@@ -0,0 +1,231 @@
+import asyncio
+
+from socketio import namespace
+
+
+class AsyncNamespace(namespace.Namespace):
+    """Base class for asyncio server-side class-based namespaces.
+
+    A class-based namespace is a class that contains all the event handlers
+    for a Socket.IO namespace. The event handlers are methods of the class
+    with the prefix ``on_``, such as ``on_connect``, ``on_disconnect``,
+    ``on_message``, ``on_json``, and so on. These can be regular functions or
+    coroutines.
+
+    :param namespace: The Socket.IO namespace to be used with all the event
+                      handlers defined in this class. If this argument is
+                      omitted, the default namespace is used.
+    """
+    def is_asyncio_based(self):
+        return True
+
+    async def trigger_event(self, event, *args):
+        """Dispatch an event to the proper handler method.
+
+        In the most common usage, this method is not overloaded by subclasses,
+        as it performs the routing of events to methods. However, this
+        method can be overridden if special dispatching rules are needed, or if
+        having a single method that catches all events is desired.
+
+        Note: this method is a coroutine.
+        """
+        handler_name = 'on_' + event
+        if hasattr(self, handler_name):
+            handler = getattr(self, handler_name)
+            if asyncio.iscoroutinefunction(handler) is True:
+                try:
+                    ret = await handler(*args)
+                except asyncio.CancelledError:  # pragma: no cover
+                    ret = None
+            else:
+                ret = handler(*args)
+            return ret
+
+    async def emit(self, event, data=None, to=None, room=None, skip_sid=None,
+                   namespace=None, callback=None, ignore_queue=False):
+        """Emit a custom event to one or more connected clients.
+
+        The only difference with the :func:`socketio.Server.emit` method is
+        that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+
+        Note: this method is a coroutine.
+        """
+        return await self.server.emit(event, data=data, to=to, room=room,
+                                      skip_sid=skip_sid,
+                                      namespace=namespace or self.namespace,
+                                      callback=callback,
+                                      ignore_queue=ignore_queue)
+
+    async def send(self, data, to=None, room=None, skip_sid=None,
+                   namespace=None, callback=None, ignore_queue=False):
+        """Send a message to one or more connected clients.
+
+        The only difference with the :func:`socketio.Server.send` method is
+        that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+
+        Note: this method is a coroutine.
+        """
+        return await self.server.send(data, to=to, room=room,
+                                      skip_sid=skip_sid,
+                                      namespace=namespace or self.namespace,
+                                      callback=callback,
+                                      ignore_queue=ignore_queue)
+
+    async def call(self, event, data=None, to=None, sid=None, namespace=None,
+                   timeout=None, ignore_queue=False):
+        """Emit a custom event to a client and wait for the response.
+
+        The only difference with the :func:`socketio.Server.call` method is
+        that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return await self.server.call(event, data=data, to=to, sid=sid,
+                                      namespace=namespace or self.namespace,
+                                      timeout=timeout,
+                                      ignore_queue=ignore_queue)
+
+    async def close_room(self, room, namespace=None):
+        """Close a room.
+
+        The only difference with the :func:`socketio.Server.close_room` method
+        is that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+
+        Note: this method is a coroutine.
+        """
+        return await self.server.close_room(
+            room, namespace=namespace or self.namespace)
+
+    async def get_session(self, sid, namespace=None):
+        """Return the user session for a client.
+
+        The only difference with the :func:`socketio.Server.get_session`
+        method is that when the ``namespace`` argument is not given the
+        namespace associated with the class is used.
+
+        Note: this method is a coroutine.
+        """
+        return await self.server.get_session(
+            sid, namespace=namespace or self.namespace)
+
+    async def save_session(self, sid, session, namespace=None):
+        """Store the user session for a client.
+
+        The only difference with the :func:`socketio.Server.save_session`
+        method is that when the ``namespace`` argument is not given the
+        namespace associated with the class is used.
+
+        Note: this method is a coroutine.
+        """
+        return await self.server.save_session(
+            sid, session, namespace=namespace or self.namespace)
+
+    def session(self, sid, namespace=None):
+        """Return the user session for a client with context manager syntax.
+
+        The only difference with the :func:`socketio.Server.session` method is
+        that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return self.server.session(sid, namespace=namespace or self.namespace)
+
+    async def disconnect(self, sid, namespace=None):
+        """Disconnect a client.
+
+        The only difference with the :func:`socketio.Server.disconnect` method
+        is that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+
+        Note: this method is a coroutine.
+        """
+        return await self.server.disconnect(
+            sid, namespace=namespace or self.namespace)
+
+
+class AsyncClientNamespace(namespace.ClientNamespace):
+    """Base class for asyncio client-side class-based namespaces.
+
+    A class-based namespace is a class that contains all the event handlers
+    for a Socket.IO namespace. The event handlers are methods of the class
+    with the prefix ``on_``, such as ``on_connect``, ``on_disconnect``,
+    ``on_message``, ``on_json``, and so on. These can be regular functions or
+    coroutines.
+
+    :param namespace: The Socket.IO namespace to be used with all the event
+                      handlers defined in this class. If this argument is
+                      omitted, the default namespace is used.
+    """
+    def is_asyncio_based(self):
+        return True
+
+    async def trigger_event(self, event, *args):
+        """Dispatch an event to the proper handler method.
+
+        In the most common usage, this method is not overloaded by subclasses,
+        as it performs the routing of events to methods. However, this
+        method can be overridden if special dispatching rules are needed, or if
+        having a single method that catches all events is desired.
+
+        Note: this method is a coroutine.
+        """
+        handler_name = 'on_' + event
+        if hasattr(self, handler_name):
+            handler = getattr(self, handler_name)
+            if asyncio.iscoroutinefunction(handler) is True:
+                try:
+                    ret = await handler(*args)
+                except asyncio.CancelledError:  # pragma: no cover
+                    ret = None
+            else:
+                ret = handler(*args)
+            return ret
+
+    async def emit(self, event, data=None, namespace=None, callback=None):
+        """Emit a custom event to the server.
+
+        The only difference with the :func:`socketio.Client.emit` method is
+        that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+
+        Note: this method is a coroutine.
+        """
+        return await self.client.emit(event, data=data,
+                                      namespace=namespace or self.namespace,
+                                      callback=callback)
+
+    async def send(self, data, namespace=None, callback=None):
+        """Send a message to the server.
+
+        The only difference with the :func:`socketio.Client.send` method is
+        that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+
+        Note: this method is a coroutine.
+        """
+        return await self.client.send(data,
+                                      namespace=namespace or self.namespace,
+                                      callback=callback)
+
+    async def call(self, event, data=None, namespace=None, timeout=None):
+        """Emit a custom event to the server and wait for the response.
+
+        The only difference with the :func:`socketio.Client.call` method is
+        that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return await self.client.call(event, data=data,
+                                      namespace=namespace or self.namespace,
+                                      timeout=timeout)
+
+    async def disconnect(self):
+        """Disconnect a client.
+
+        The only difference with the :func:`socketio.Client.disconnect` method
+        is that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+
+        Note: this method is a coroutine.
+        """
+        return await self.client.disconnect()

venv/lib/python3.11/site-packages/socketio/asyncio_pubsub_manager.py

@@ -0,0 +1,194 @@
+import asyncio
+from functools import partial
+import uuid
+
+from engineio import json
+import pickle
+
+from .asyncio_manager import AsyncManager
+
+
+class AsyncPubSubManager(AsyncManager):
+    """Manage a client list attached to a pub/sub backend under asyncio.
+
+    This is a base class that enables multiple servers to share the list of
+    clients, with the servers communicating events through a pub/sub backend.
+    The use of a pub/sub backend also allows any client connected to the
+    backend to emit events addressed to Socket.IO clients.
+
+    The actual backends must be implemented by subclasses, this class only
+    provides a pub/sub generic framework for asyncio applications.
+
+    :param channel: The channel name on which the server sends and receives
+                    notifications.
+    """
+    name = 'asyncpubsub'
+
+    def __init__(self, channel='socketio', write_only=False, logger=None):
+        super().__init__()
+        self.channel = channel
+        self.write_only = write_only
+        self.host_id = uuid.uuid4().hex
+        self.logger = logger
+
+    def initialize(self):
+        super().initialize()
+        if not self.write_only:
+            self.thread = self.server.start_background_task(self._thread)
+        self._get_logger().info(self.name + ' backend initialized.')
+
+    async def emit(self, event, data, namespace=None, room=None, skip_sid=None,
+                   callback=None, **kwargs):
+        """Emit a message to a single client, a room, or all the clients
+        connected to the namespace.
+
+        This method takes care or propagating the message to all the servers
+        that are connected through the message queue.
+
+        The parameters are the same as in :meth:`.Server.emit`.
+
+        Note: this method is a coroutine.
+        """
+        if kwargs.get('ignore_queue'):
+            return await super().emit(
+                event, data, namespace=namespace, room=room, skip_sid=skip_sid,
+                callback=callback)
+        namespace = namespace or '/'
+        if callback is not None:
+            if self.server is None:
+                raise RuntimeError('Callbacks can only be issued from the '
+                                   'context of a server.')
+            if room is None:
+                raise ValueError('Cannot use callback without a room set.')
+            id = self._generate_ack_id(room, callback)
+            callback = (room, namespace, id)
+        else:
+            callback = None
+        await self._publish({'method': 'emit', 'event': event, 'data': data,
+                             'namespace': namespace, 'room': room,
+                             'skip_sid': skip_sid, 'callback': callback,
+                             'host_id': self.host_id})
+
+    async def can_disconnect(self, sid, namespace):
+        if self.is_connected(sid, namespace):
+            # client is in this server, so we can disconnect directly
+            return await super().can_disconnect(sid, namespace)
+        else:
+            # client is in another server, so we post request to the queue
+            await self._publish({'method': 'disconnect', 'sid': sid,
+                                 'namespace': namespace or '/'})
+
+    async def disconnect(self, sid, namespace, **kwargs):
+        if kwargs.get('ignore_queue'):
+            return await super(AsyncPubSubManager, self).disconnect(
+                sid, namespace=namespace)
+        await self._publish({'method': 'disconnect', 'sid': sid,
+                             'namespace': namespace or '/'})
+
+    async def close_room(self, room, namespace=None):
+        await self._publish({'method': 'close_room', 'room': room,
+                             'namespace': namespace or '/'})
+
+    async def _publish(self, data):
+        """Publish a message on the Socket.IO channel.
+
+        This method needs to be implemented by the different subclasses that
+        support pub/sub backends.
+        """
+        raise NotImplementedError('This method must be implemented in a '
+                                  'subclass.')  # pragma: no cover
+
+    async def _listen(self):
+        """Return the next message published on the Socket.IO channel,
+        blocking until a message is available.
+
+        This method needs to be implemented by the different subclasses that
+        support pub/sub backends.
+        """
+        raise NotImplementedError('This method must be implemented in a '
+                                  'subclass.')  # pragma: no cover
+
+    async def _handle_emit(self, message):
+        # Events with callbacks are very tricky to handle across hosts
+        # Here in the receiving end we set up a local callback that preserves
+        # the callback host and id from the sender
+        remote_callback = message.get('callback')
+        remote_host_id = message.get('host_id')
+        if remote_callback is not None and len(remote_callback) == 3:
+            callback = partial(self._return_callback, remote_host_id,
+                               *remote_callback)
+        else:
+            callback = None
+        await super().emit(message['event'], message['data'],
+                           namespace=message.get('namespace'),
+                           room=message.get('room'),
+                           skip_sid=message.get('skip_sid'),
+                           callback=callback)
+
+    async def _handle_callback(self, message):
+        if self.host_id == message.get('host_id'):
+            try:
+                sid = message['sid']
+                id = message['id']
+                args = message['args']
+            except KeyError:
+                return
+            await self.trigger_callback(sid, id, args)
+
+    async def _return_callback(self, host_id, sid, namespace, callback_id,
+                               *args):
+        # When an event callback is received, the callback is returned back
+        # the sender, which is identified by the host_id
+        await self._publish({'method': 'callback', 'host_id': host_id,
+                             'sid': sid, 'namespace': namespace,
+                             'id': callback_id, 'args': args})
+
+    async def _handle_disconnect(self, message):
+        await self.server.disconnect(sid=message.get('sid'),
+                                     namespace=message.get('namespace'),
+                                     ignore_queue=True)
+
+    async def _handle_close_room(self, message):
+        await super().close_room(
+            room=message.get('room'), namespace=message.get('namespace'))
+
+    async def _thread(self):
+        while True:
+            try:
+                async for message in self._listen():  # pragma: no branch
+                    data = None
+                    if isinstance(message, dict):
+                        data = message
+                    else:
+                        if isinstance(message, bytes):  # pragma: no cover
+                            try:
+                                data = pickle.loads(message)
+                            except:
+                                pass
+                        if data is None:
+                            try:
+                                data = json.loads(message)
+                            except:
+                                pass
+                    if data and 'method' in data:
+                        self._get_logger().info('pubsub message: {}'.format(
+                            data['method']))
+                        try:
+                            if data['method'] == 'emit':
+                                await self._handle_emit(data)
+                            elif data['method'] == 'callback':
+                                await self._handle_callback(data)
+                            elif data['method'] == 'disconnect':
+                                await self._handle_disconnect(data)
+                            elif data['method'] == 'close_room':
+                                await self._handle_close_room(data)
+                        except asyncio.CancelledError:
+                            raise  # let the outer try/except handle it
+                        except:
+                            self.server.logger.exception(
+                                'Unknown error in pubsub listening task')
+            except asyncio.CancelledError:  # pragma: no cover
+                break
+            except:  # pragma: no cover
+                import traceback
+                traceback.print_exc()

venv/lib/python3.11/site-packages/socketio/asyncio_redis_manager.py

@@ -0,0 +1,107 @@
+import asyncio
+import pickle
+
+try:  # pragma: no cover
+    from redis import asyncio as aioredis
+    from redis.exceptions import RedisError
+except ImportError:  # pragma: no cover
+    try:
+        import aioredis
+        from aioredis.exceptions import RedisError
+    except ImportError:
+        aioredis = None
+        RedisError = None
+
+from .asyncio_pubsub_manager import AsyncPubSubManager
+
+
+class AsyncRedisManager(AsyncPubSubManager):  # pragma: no cover
+    """Redis based client manager for asyncio servers.
+
+    This class implements a Redis backend for event sharing across multiple
+    processes.
+
+    To use a Redis backend, initialize the :class:`AsyncServer` instance as
+    follows::
+
+        url = 'redis://hostname:port/0'
+        server = socketio.AsyncServer(
+            client_manager=socketio.AsyncRedisManager(url))
+
+    :param url: The connection URL for the Redis server. For a default Redis
+                store running on the same host, use ``redis://``.  To use an
+                SSL connection, use ``rediss://``.
+    :param channel: The channel name on which the server sends and receives
+                    notifications. Must be the same in all the servers.
+    :param write_only: If set to ``True``, only initialize to emit events. The
+                       default of ``False`` initializes the class for emitting
+                       and receiving.
+    :param redis_options: additional keyword arguments to be passed to
+                          ``aioredis.from_url()``.
+    """
+    name = 'aioredis'
+
+    def __init__(self, url='redis://localhost:6379/0', channel='socketio',
+                 write_only=False, logger=None, redis_options=None):
+        if aioredis is None:
+            raise RuntimeError('Redis package is not installed '
+                               '(Run "pip install redis" in your virtualenv).')
+        if not hasattr(aioredis.Redis, 'from_url'):
+            raise RuntimeError('Version 2 of aioredis package is required.')
+        self.redis_url = url
+        self.redis_options = redis_options or {}
+        self._redis_connect()
+        super().__init__(channel=channel, write_only=write_only, logger=logger)
+
+    def _redis_connect(self):
+        self.redis = aioredis.Redis.from_url(self.redis_url,
+                                             **self.redis_options)
+        self.pubsub = self.redis.pubsub(ignore_subscribe_messages=True)
+
+    async def _publish(self, data):
+        retry = True
+        while True:
+            try:
+                if not retry:
+                    self._redis_connect()
+                return await self.redis.publish(
+                    self.channel, pickle.dumps(data))
+            except RedisError:
+                if retry:
+                    self._get_logger().error('Cannot publish to redis... '
+                                             'retrying')
+                    retry = False
+                else:
+                    self._get_logger().error('Cannot publish to redis... '
+                                             'giving up')
+                    break
+
+    async def _redis_listen_with_retries(self):
+        retry_sleep = 1
+        connect = False
+        while True:
+            try:
+                if connect:
+                    self._redis_connect()
+                    await self.pubsub.subscribe(self.channel)
+                    retry_sleep = 1
+                async for message in self.pubsub.listen():
+                    yield message
+            except RedisError:
+                self._get_logger().error('Cannot receive from redis... '
+                                         'retrying in '
+                                         '{} secs'.format(retry_sleep))
+                connect = True
+                await asyncio.sleep(retry_sleep)
+                retry_sleep *= 2
+                if retry_sleep > 60:
+                    retry_sleep = 60
+
+    async def _listen(self):
+        channel = self.channel.encode('utf-8')
+        await self.pubsub.subscribe(self.channel)
+        async for message in self._redis_listen_with_retries():
+            if message['channel'] == channel and \
+                    message['type'] == 'message' and 'data' in message:
+                yield message['data']
+        await self.pubsub.unsubscribe(self.channel)

venv/lib/python3.11/site-packages/socketio/asyncio_server.py

@@ -0,0 +1,619 @@
+import asyncio
+
+import engineio
+
+from . import asyncio_manager
+from . import exceptions
+from . import packet
+from . import server
+
+
+class AsyncServer(server.Server):
+    """A Socket.IO server for asyncio.
+
+    This class implements a fully compliant Socket.IO web server with support
+    for websocket and long-polling transports, compatible with the asyncio
+    framework.
+
+    :param client_manager: The client manager instance that will manage the
+                           client list. When this is omitted, the client list
+                           is stored in an in-memory structure, so the use of
+                           multiple connected servers is not possible.
+    :param logger: To enable logging set to ``True`` or pass a logger object to
+                   use. To disable logging set to ``False``. Note that fatal
+                   errors are logged even when ``logger`` is ``False``.
+    :param json: An alternative json module to use for encoding and decoding
+                 packets. Custom json modules must have ``dumps`` and ``loads``
+                 functions that are compatible with the standard library
+                 versions.
+    :param async_handlers: If set to ``True``, event handlers for a client are
+                           executed in separate threads. To run handlers for a
+                           client synchronously, set to ``False``. The default
+                           is ``True``.
+    :param always_connect: When set to ``False``, new connections are
+                           provisory until the connect handler returns
+                           something other than ``False``, at which point they
+                           are accepted. When set to ``True``, connections are
+                           immediately accepted, and then if the connect
+                           handler returns ``False`` a disconnect is issued.
+                           Set to ``True`` if you need to emit events from the
+                           connect handler and your client is confused when it
+                           receives events before the connection acceptance.
+                           In any other case use the default of ``False``.
+    :param namespaces: a list of namespaces that are accepted, in addition to
+                       any namespaces for which handlers have been defined. The
+                       default is `['/']`, which always accepts connections to
+                       the default namespace. Set to `'*'` to accept all
+                       namespaces.
+    :param kwargs: Connection parameters for the underlying Engine.IO server.
+
+    The Engine.IO configuration supports the following settings:
+
+    :param async_mode: The asynchronous model to use. See the Deployment
+                       section in the documentation for a description of the
+                       available options. Valid async modes are "aiohttp",
+                       "sanic", "tornado" and "asgi". If this argument is not
+                       given, "aiohttp" is tried first, followed by "sanic",
+                       "tornado", and finally "asgi". The first async mode that
+                       has all its dependencies installed is the one that is
+                       chosen.
+    :param ping_interval: The interval in seconds at which the server pings
+                          the client. The default is 25 seconds. For advanced
+                          control, a two element tuple can be given, where
+                          the first number is the ping interval and the second
+                          is a grace period added by the server.
+    :param ping_timeout: The time in seconds that the client waits for the
+                         server to respond before disconnecting. The default
+                         is 5 seconds.
+    :param max_http_buffer_size: The maximum size of a message when using the
+                                 polling transport. The default is 1,000,000
+                                 bytes.
+    :param allow_upgrades: Whether to allow transport upgrades or not. The
+                           default is ``True``.
+    :param http_compression: Whether to compress packages when using the
+                             polling transport. The default is ``True``.
+    :param compression_threshold: Only compress messages when their byte size
+                                  is greater than this value. The default is
+                                  1024 bytes.
+    :param cookie: If set to a string, it is the name of the HTTP cookie the
+                   server sends back to the client containing the client
+                   session id. If set to a dictionary, the ``'name'`` key
+                   contains the cookie name and other keys define cookie
+                   attributes, where the value of each attribute can be a
+                   string, a callable with no arguments, or a boolean. If set
+                   to ``None`` (the default), a cookie is not sent to the
+                   client.
+    :param cors_allowed_origins: Origin or list of origins that are allowed to
+                                 connect to this server. Only the same origin
+                                 is allowed by default. Set this argument to
+                                 ``'*'`` to allow all origins, or to ``[]`` to
+                                 disable CORS handling.
+    :param cors_credentials: Whether credentials (cookies, authentication) are
+                             allowed in requests to this server. The default is
+                             ``True``.
+    :param monitor_clients: If set to ``True``, a background task will ensure
+                            inactive clients are closed. Set to ``False`` to
+                            disable the monitoring task (not recommended). The
+                            default is ``True``.
+    :param engineio_logger: To enable Engine.IO logging set to ``True`` or pass
+                            a logger object to use. To disable logging set to
+                            ``False``. The default is ``False``. Note that
+                            fatal errors are logged even when
+                            ``engineio_logger`` is ``False``.
+    """
+    def __init__(self, client_manager=None, logger=False, json=None,
+                 async_handlers=True, namespaces=None, **kwargs):
+        if client_manager is None:
+            client_manager = asyncio_manager.AsyncManager()
+        super().__init__(client_manager=client_manager, logger=logger,
+                         json=json, async_handlers=async_handlers,
+                         namespaces=namespaces, **kwargs)
+
+    def is_asyncio_based(self):
+        return True
+
+    def attach(self, app, socketio_path='socket.io'):
+        """Attach the Socket.IO server to an application."""
+        self.eio.attach(app, socketio_path)
+
+    async def emit(self, event, data=None, to=None, room=None, skip_sid=None,
+                   namespace=None, callback=None, ignore_queue=False):
+        """Emit a custom event to one or more connected clients.
+
+        :param event: The event name. It can be any string. The event names
+                      ``'connect'``, ``'message'`` and ``'disconnect'`` are
+                      reserved and should not be used.
+        :param data: The data to send to the client or clients. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. To send
+                     multiple arguments, use a tuple where each element is of
+                     one of the types indicated above.
+        :param to: The recipient of the message. This can be set to the
+                   session ID of a client to address only that client, to any
+                   any custom room created by the application to address all
+                   the clients in that room, or to a list of custom room
+                   names. If this argument is omitted the event is broadcasted
+                   to all connected clients.
+        :param room: Alias for the ``to`` parameter.
+        :param skip_sid: The session ID of a client to skip when broadcasting
+                         to a room or to all clients. This can be used to
+                         prevent a message from being sent to the sender.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param callback: If given, this function will be called to acknowledge
+                         the client has received the message. The arguments
+                         that will be passed to the function are those provided
+                         by the client. Callback functions can only be used
+                         when addressing an individual client.
+        :param ignore_queue: Only used when a message queue is configured. If
+                             set to ``True``, the event is emitted to the
+                             clients directly, without going through the queue.
+                             This is more efficient, but only works when a
+                             single server process is used. It is recommended
+                             to always leave this parameter with its default
+                             value of ``False``.
+
+        Note: this method is not designed to be used concurrently. If multiple
+        tasks are emitting at the same time to the same client connection, then
+        messages composed of multiple packets may end up being sent in an
+        incorrect sequence. Use standard concurrency solutions (such as a Lock
+        object) to prevent this situation.
+
+        Note 2: this method is a coroutine.
+        """
+        namespace = namespace or '/'
+        room = to or room
+        self.logger.info('emitting event "%s" to %s [%s]', event,
+                         room or 'all', namespace)
+        await self.manager.emit(event, data, namespace, room=room,
+                                skip_sid=skip_sid, callback=callback,
+                                ignore_queue=ignore_queue)
+
+    async def send(self, data, to=None, room=None, skip_sid=None,
+                   namespace=None, callback=None, ignore_queue=False):
+        """Send a message to one or more connected clients.
+
+        This function emits an event with the name ``'message'``. Use
+        :func:`emit` to issue custom event names.
+
+        :param data: The data to send to the client or clients. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. To send
+                     multiple arguments, use a tuple where each element is of
+                     one of the types indicated above.
+        :param to: The recipient of the message. This can be set to the
+                   session ID of a client to address only that client, to any
+                   any custom room created by the application to address all
+                   the clients in that room, or to a list of custom room
+                   names. If this argument is omitted the event is broadcasted
+                   to all connected clients.
+        :param room: Alias for the ``to`` parameter.
+        :param skip_sid: The session ID of a client to skip when broadcasting
+                         to a room or to all clients. This can be used to
+                         prevent a message from being sent to the sender.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param callback: If given, this function will be called to acknowledge
+                         the client has received the message. The arguments
+                         that will be passed to the function are those provided
+                         by the client. Callback functions can only be used
+                         when addressing an individual client.
+        :param ignore_queue: Only used when a message queue is configured. If
+                             set to ``True``, the event is emitted to the
+                             clients directly, without going through the queue.
+                             This is more efficient, but only works when a
+                             single server process is used. It is recommended
+                             to always leave this parameter with its default
+                             value of ``False``.
+
+        Note: this method is a coroutine.
+        """
+        await self.emit('message', data=data, to=to, room=room,
+                        skip_sid=skip_sid, namespace=namespace,
+                        callback=callback, ignore_queue=ignore_queue)
+
+    async def call(self, event, data=None, to=None, sid=None, namespace=None,
+                   timeout=60, ignore_queue=False):
+        """Emit a custom event to a client and wait for the response.
+
+        This method issues an emit with a callback and waits for the callback
+        to be invoked before returning. If the callback isn't invoked before
+        the timeout, then a ``TimeoutError`` exception is raised. If the
+        Socket.IO connection drops during the wait, this method still waits
+        until the specified timeout.
+
+        :param event: The event name. It can be any string. The event names
+                      ``'connect'``, ``'message'`` and ``'disconnect'`` are
+                      reserved and should not be used.
+        :param data: The data to send to the client or clients. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. To send
+                     multiple arguments, use a tuple where each element is of
+                     one of the types indicated above.
+        :param to: The session ID of the recipient client.
+        :param sid: Alias for the ``to`` parameter.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param timeout: The waiting timeout. If the timeout is reached before
+                        the client acknowledges the event, then a
+                        ``TimeoutError`` exception is raised.
+        :param ignore_queue: Only used when a message queue is configured. If
+                             set to ``True``, the event is emitted to the
+                             client directly, without going through the queue.
+                             This is more efficient, but only works when a
+                             single server process is used. It is recommended
+                             to always leave this parameter with its default
+                             value of ``False``.
+
+        Note: this method is not designed to be used concurrently. If multiple
+        tasks are emitting at the same time to the same client connection, then
+        messages composed of multiple packets may end up being sent in an
+        incorrect sequence. Use standard concurrency solutions (such as a Lock
+        object) to prevent this situation.
+
+        Note 2: this method is a coroutine.
+        """
+        if to is None and sid is None:
+            raise ValueError('Cannot use call() to broadcast.')
+        if not self.async_handlers:
+            raise RuntimeError(
+                'Cannot use call() when async_handlers is False.')
+        callback_event = self.eio.create_event()
+        callback_args = []
+
+        def event_callback(*args):
+            callback_args.append(args)
+            callback_event.set()
+
+        await self.emit(event, data=data, room=to or sid, namespace=namespace,
+                        callback=event_callback, ignore_queue=ignore_queue)
+        try:
+            await asyncio.wait_for(callback_event.wait(), timeout)
+        except asyncio.TimeoutError:
+            raise exceptions.TimeoutError() from None
+        return callback_args[0] if len(callback_args[0]) > 1 \
+            else callback_args[0][0] if len(callback_args[0]) == 1 \
+            else None
+
+    async def close_room(self, room, namespace=None):
+        """Close a room.
+
+        This function removes all the clients from the given room.
+
+        :param room: Room name.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the default namespace is used.
+
+        Note: this method is a coroutine.
+        """
+        namespace = namespace or '/'
+        self.logger.info('room %s is closing [%s]', room, namespace)
+        await self.manager.close_room(room, namespace)
+
+    async def get_session(self, sid, namespace=None):
+        """Return the user session for a client.
+
+        :param sid: The session id of the client.
+        :param namespace: The Socket.IO namespace. If this argument is omitted
+                          the default namespace is used.
+
+        The return value is a dictionary. Modifications made to this
+        dictionary are not guaranteed to be preserved. If you want to modify
+        the user session, use the ``session`` context manager instead.
+        """
+        namespace = namespace or '/'
+        eio_sid = self.manager.eio_sid_from_sid(sid, namespace)
+        eio_session = await self.eio.get_session(eio_sid)
+        return eio_session.setdefault(namespace, {})
+
+    async def save_session(self, sid, session, namespace=None):
+        """Store the user session for a client.
+
+        :param sid: The session id of the client.
+        :param session: The session dictionary.
+        :param namespace: The Socket.IO namespace. If this argument is omitted
+                          the default namespace is used.
+        """
+        namespace = namespace or '/'
+        eio_sid = self.manager.eio_sid_from_sid(sid, namespace)
+        eio_session = await self.eio.get_session(eio_sid)
+        eio_session[namespace] = session
+
+    def session(self, sid, namespace=None):
+        """Return the user session for a client with context manager syntax.
+
+        :param sid: The session id of the client.
+
+        This is a context manager that returns the user session dictionary for
+        the client. Any changes that are made to this dictionary inside the
+        context manager block are saved back to the session. Example usage::
+
+            @eio.on('connect')
+            def on_connect(sid, environ):
+                username = authenticate_user(environ)
+                if not username:
+                    return False
+                with eio.session(sid) as session:
+                    session['username'] = username
+
+            @eio.on('message')
+            def on_message(sid, msg):
+                async with eio.session(sid) as session:
+                    print('received message from ', session['username'])
+        """
+        class _session_context_manager(object):
+            def __init__(self, server, sid, namespace):
+                self.server = server
+                self.sid = sid
+                self.namespace = namespace
+                self.session = None
+
+            async def __aenter__(self):
+                self.session = await self.server.get_session(
+                    sid, namespace=self.namespace)
+                return self.session
+
+            async def __aexit__(self, *args):
+                await self.server.save_session(sid, self.session,
+                                               namespace=self.namespace)
+
+        return _session_context_manager(self, sid, namespace)
+
+    async def disconnect(self, sid, namespace=None, ignore_queue=False):
+        """Disconnect a client.
+
+        :param sid: Session ID of the client.
+        :param namespace: The Socket.IO namespace to disconnect. If this
+                          argument is omitted the default namespace is used.
+        :param ignore_queue: Only used when a message queue is configured. If
+                             set to ``True``, the disconnect is processed
+                             locally, without broadcasting on the queue. It is
+                             recommended to always leave this parameter with
+                             its default value of ``False``.
+
+        Note: this method is a coroutine.
+        """
+        namespace = namespace or '/'
+        if ignore_queue:
+            delete_it = self.manager.is_connected(sid, namespace)
+        else:
+            delete_it = await self.manager.can_disconnect(sid, namespace)
+        if delete_it:
+            self.logger.info('Disconnecting %s [%s]', sid, namespace)
+            eio_sid = self.manager.pre_disconnect(sid, namespace=namespace)
+            await self._send_packet(eio_sid, self.packet_class(
+                packet.DISCONNECT, namespace=namespace))
+            await self._trigger_event('disconnect', namespace, sid)
+            await self.manager.disconnect(sid, namespace=namespace,
+                                          ignore_queue=True)
+
+    async def handle_request(self, *args, **kwargs):
+        """Handle an HTTP request from the client.
+
+        This is the entry point of the Socket.IO application. This function
+        returns the HTTP response body to deliver to the client.
+
+        Note: this method is a coroutine.
+        """
+        return await self.eio.handle_request(*args, **kwargs)
+
+    def start_background_task(self, target, *args, **kwargs):
+        """Start a background task using the appropriate async model.
+
+        This is a utility function that applications can use to start a
+        background task using the method that is compatible with the
+        selected async mode.
+
+        :param target: the target function to execute. Must be a coroutine.
+        :param args: arguments to pass to the function.
+        :param kwargs: keyword arguments to pass to the function.
+
+        The return value is a ``asyncio.Task`` object.
+        """
+        return self.eio.start_background_task(target, *args, **kwargs)
+
+    async def sleep(self, seconds=0):
+        """Sleep for the requested amount of time using the appropriate async
+        model.
+
+        This is a utility function that applications can use to put a task to
+        sleep without having to worry about using the correct call for the
+        selected async mode.
+
+        Note: this method is a coroutine.
+        """
+        return await self.eio.sleep(seconds)
+
+    async def _emit_internal(self, sid, event, data, namespace=None, id=None):
+        """Send a message to a client."""
+        # tuples are expanded to multiple arguments, everything else is sent
+        # as a single argument
+        if isinstance(data, tuple):
+            data = list(data)
+        elif data is not None:
+            data = [data]
+        else:
+            data = []
+        await self._send_packet(sid, self.packet_class(
+            packet.EVENT, namespace=namespace, data=[event] + data, id=id))
+
+    async def _send_packet(self, eio_sid, pkt):
+        """Send a Socket.IO packet to a client."""
+        encoded_packet = pkt.encode()
+        if isinstance(encoded_packet, list):
+            for ep in encoded_packet:
+                await self.eio.send(eio_sid, ep)
+        else:
+            await self.eio.send(eio_sid, encoded_packet)
+
+    async def _handle_connect(self, eio_sid, namespace, data):
+        """Handle a client connection request."""
+        namespace = namespace or '/'
+        sid = None
+        if namespace in self.handlers or namespace in self.namespace_handlers \
+                or self.namespaces == '*' or namespace in self.namespaces:
+            sid = self.manager.connect(eio_sid, namespace)
+        if sid is None:
+            await self._send_packet(eio_sid, self.packet_class(
+                packet.CONNECT_ERROR, data='Unable to connect',
+                namespace=namespace))
+            return
+
+        if self.always_connect:
+            await self._send_packet(eio_sid, self.packet_class(
+                packet.CONNECT, {'sid': sid}, namespace=namespace))
+        fail_reason = exceptions.ConnectionRefusedError().error_args
+        try:
+            if data:
+                success = await self._trigger_event(
+                    'connect', namespace, sid, self.environ[eio_sid], data)
+            else:
+                try:
+                    success = await self._trigger_event(
+                        'connect', namespace, sid, self.environ[eio_sid])
+                except TypeError:
+                    success = await self._trigger_event(
+                        'connect', namespace, sid, self.environ[eio_sid], None)
+        except exceptions.ConnectionRefusedError as exc:
+            fail_reason = exc.error_args
+            success = False
+
+        if success is False:
+            if self.always_connect:
+                self.manager.pre_disconnect(sid, namespace)
+                await self._send_packet(eio_sid, self.packet_class(
+                    packet.DISCONNECT, data=fail_reason, namespace=namespace))
+            else:
+                await self._send_packet(eio_sid, self.packet_class(
+                    packet.CONNECT_ERROR, data=fail_reason,
+                    namespace=namespace))
+            await self.manager.disconnect(sid, namespace, ignore_queue=True)
+        elif not self.always_connect:
+            await self._send_packet(eio_sid, self.packet_class(
+                packet.CONNECT, {'sid': sid}, namespace=namespace))
+
+    async def _handle_disconnect(self, eio_sid, namespace):
+        """Handle a client disconnect."""
+        namespace = namespace or '/'
+        sid = self.manager.sid_from_eio_sid(eio_sid, namespace)
+        if not self.manager.is_connected(sid, namespace):  # pragma: no cover
+            return
+        self.manager.pre_disconnect(sid, namespace=namespace)
+        await self._trigger_event('disconnect', namespace, sid)
+        await self.manager.disconnect(sid, namespace, ignore_queue=True)
+
+    async def _handle_event(self, eio_sid, namespace, id, data):
+        """Handle an incoming client event."""
+        namespace = namespace or '/'
+        sid = self.manager.sid_from_eio_sid(eio_sid, namespace)
+        self.logger.info('received event "%s" from %s [%s]', data[0], sid,
+                         namespace)
+        if not self.manager.is_connected(sid, namespace):
+            self.logger.warning('%s is not connected to namespace %s',
+                                sid, namespace)
+            return
+        if self.async_handlers:
+            self.start_background_task(self._handle_event_internal, self, sid,
+                                       eio_sid, data, namespace, id)
+        else:
+            await self._handle_event_internal(self, sid, eio_sid, data,
+                                              namespace, id)
+
+    async def _handle_event_internal(self, server, sid, eio_sid, data,
+                                     namespace, id):
+        r = await server._trigger_event(data[0], namespace, sid, *data[1:])
+        if r != self.not_handled and id is not None:
+            # send ACK packet with the response returned by the handler
+            # tuples are expanded as multiple arguments
+            if r is None:
+                data = []
+            elif isinstance(r, tuple):
+                data = list(r)
+            else:
+                data = [r]
+            await server._send_packet(eio_sid, self.packet_class(
+                packet.ACK, namespace=namespace, id=id, data=data))
+
+    async def _handle_ack(self, eio_sid, namespace, id, data):
+        """Handle ACK packets from the client."""
+        namespace = namespace or '/'
+        sid = self.manager.sid_from_eio_sid(eio_sid, namespace)
+        self.logger.info('received ack from %s [%s]', sid, namespace)
+        await self.manager.trigger_callback(sid, id, data)
+
+    async def _trigger_event(self, event, namespace, *args):
+        """Invoke an application event handler."""
+        # first see if we have an explicit handler for the event
+        if namespace in self.handlers:
+            handler = None
+            if event in self.handlers[namespace]:
+                handler = self.handlers[namespace][event]
+            elif event not in self.reserved_events and \
+                    '*' in self.handlers[namespace]:
+                handler = self.handlers[namespace]['*']
+                args = (event, *args)
+            if handler:
+                if asyncio.iscoroutinefunction(handler):
+                    try:
+                        ret = await handler(*args)
+                    except asyncio.CancelledError:  # pragma: no cover
+                        ret = None
+                else:
+                    ret = handler(*args)
+                return ret
+            else:
+                return self.not_handled
+
+        # or else, forward the event to a namepsace handler if one exists
+        elif namespace in self.namespace_handlers:  # pragma: no branch
+            return await self.namespace_handlers[namespace].trigger_event(
+                event, *args)
+
+    async def _handle_eio_connect(self, eio_sid, environ):
+        """Handle the Engine.IO connection event."""
+        if not self.manager_initialized:
+            self.manager_initialized = True
+            self.manager.initialize()
+        self.environ[eio_sid] = environ
+
+    async def _handle_eio_message(self, eio_sid, data):
+        """Dispatch Engine.IO messages."""
+        if eio_sid in self._binary_packet:
+            pkt = self._binary_packet[eio_sid]
+            if pkt.add_attachment(data):
+                del self._binary_packet[eio_sid]
+                if pkt.packet_type == packet.BINARY_EVENT:
+                    await self._handle_event(eio_sid, pkt.namespace, pkt.id,
+                                             pkt.data)
+                else:
+                    await self._handle_ack(eio_sid, pkt.namespace, pkt.id,
+                                           pkt.data)
+        else:
+            pkt = self.packet_class(encoded_packet=data)
+            if pkt.packet_type == packet.CONNECT:
+                await self._handle_connect(eio_sid, pkt.namespace, pkt.data)
+            elif pkt.packet_type == packet.DISCONNECT:
+                await self._handle_disconnect(eio_sid, pkt.namespace)
+            elif pkt.packet_type == packet.EVENT:
+                await self._handle_event(eio_sid, pkt.namespace, pkt.id,
+                                         pkt.data)
+            elif pkt.packet_type == packet.ACK:
+                await self._handle_ack(eio_sid, pkt.namespace, pkt.id,
+                                       pkt.data)
+            elif pkt.packet_type == packet.BINARY_EVENT or \
+                    pkt.packet_type == packet.BINARY_ACK:
+                self._binary_packet[eio_sid] = pkt
+            elif pkt.packet_type == packet.CONNECT_ERROR:
+                raise ValueError('Unexpected CONNECT_ERROR packet.')
+            else:
+                raise ValueError('Unknown packet type.')
+
+    async def _handle_eio_disconnect(self, eio_sid):
+        """Handle Engine.IO disconnect event."""
+        for n in list(self.manager.get_namespaces()).copy():
+            await self._handle_disconnect(eio_sid, n)
+        if eio_sid in self.environ:
+            del self.environ[eio_sid]
+
+    def _engineio_server_class(self):
+        return engineio.AsyncServer

venv/lib/python3.11/site-packages/socketio/base_manager.py

@@ -0,0 +1,206 @@
+import itertools
+import logging
+
+from bidict import bidict, ValueDuplicationError
+
+default_logger = logging.getLogger('socketio')
+
+
+class BaseManager(object):
+    """Manage client connections.
+
+    This class keeps track of all the clients and the rooms they are in, to
+    support the broadcasting of messages. The data used by this class is
+    stored in a memory structure, making it appropriate only for single process
+    services. More sophisticated storage backends can be implemented by
+    subclasses.
+    """
+    def __init__(self):
+        self.logger = None
+        self.server = None
+        self.rooms = {}  # self.rooms[namespace][room][sio_sid] = eio_sid
+        self.eio_to_sid = {}
+        self.callbacks = {}
+        self.pending_disconnect = {}
+
+    def set_server(self, server):
+        self.server = server
+
+    def initialize(self):
+        """Invoked before the first request is received. Subclasses can add
+        their initialization code here.
+        """
+        pass
+
+    def get_namespaces(self):
+        """Return an iterable with the active namespace names."""
+        return self.rooms.keys()
+
+    def get_participants(self, namespace, room):
+        """Return an iterable with the active participants in a room."""
+        ns = self.rooms[namespace]
+        if hasattr(room, '__len__') and not isinstance(room, str):
+            participants = ns[room[0]]._fwdm.copy() if room[0] in ns else {}
+            for r in room[1:]:
+                participants.update(ns[r]._fwdm if r in ns else {})
+        else:
+            participants = ns[room]._fwdm.copy() if room in ns else {}
+        for sid, eio_sid in participants.items():
+            yield sid, eio_sid
+
+    def connect(self, eio_sid, namespace):
+        """Register a client connection to a namespace."""
+        sid = self.server.eio.generate_id()
+        try:
+            self.enter_room(sid, namespace, None, eio_sid=eio_sid)
+        except ValueDuplicationError:
+            # already connected
+            return None
+        self.enter_room(sid, namespace, sid, eio_sid=eio_sid)
+        return sid
+
+    def is_connected(self, sid, namespace):
+        if namespace in self.pending_disconnect and \
+                sid in self.pending_disconnect[namespace]:
+            # the client is in the process of being disconnected
+            return False
+        try:
+            return self.rooms[namespace][None][sid] is not None
+        except KeyError:
+            pass
+        return False
+
+    def sid_from_eio_sid(self, eio_sid, namespace):
+        try:
+            return self.rooms[namespace][None]._invm[eio_sid]
+        except KeyError:
+            pass
+
+    def eio_sid_from_sid(self, sid, namespace):
+        if namespace in self.rooms:
+            return self.rooms[namespace][None].get(sid)
+
+    def can_disconnect(self, sid, namespace):
+        return self.is_connected(sid, namespace)
+
+    def pre_disconnect(self, sid, namespace):
+        """Put the client in the to-be-disconnected list.
+
+        This allows the client data structures to be present while the
+        disconnect handler is invoked, but still recognize the fact that the
+        client is soon going away.
+        """
+        if namespace not in self.pending_disconnect:
+            self.pending_disconnect[namespace] = []
+        self.pending_disconnect[namespace].append(sid)
+        return self.rooms[namespace][None].get(sid)
+
+    def disconnect(self, sid, namespace, **kwargs):
+        """Register a client disconnect from a namespace."""
+        if namespace not in self.rooms:
+            return
+        rooms = []
+        for room_name, room in self.rooms[namespace].copy().items():
+            if sid in room:
+                rooms.append(room_name)
+        for room in rooms:
+            self.leave_room(sid, namespace, room)
+        if sid in self.callbacks:
+            del self.callbacks[sid]
+        if namespace in self.pending_disconnect and \
+                sid in self.pending_disconnect[namespace]:
+            self.pending_disconnect[namespace].remove(sid)
+            if len(self.pending_disconnect[namespace]) == 0:
+                del self.pending_disconnect[namespace]
+
+    def enter_room(self, sid, namespace, room, eio_sid=None):
+        """Add a client to a room."""
+        if eio_sid is None and namespace not in self.rooms:
+            raise ValueError('sid is not connected to requested namespace')
+        if namespace not in self.rooms:
+            self.rooms[namespace] = {}
+        if room not in self.rooms[namespace]:
+            self.rooms[namespace][room] = bidict()
+        if eio_sid is None:
+            eio_sid = self.rooms[namespace][None][sid]
+        self.rooms[namespace][room][sid] = eio_sid
+
+    def leave_room(self, sid, namespace, room):
+        """Remove a client from a room."""
+        try:
+            del self.rooms[namespace][room][sid]
+            if len(self.rooms[namespace][room]) == 0:
+                del self.rooms[namespace][room]
+                if len(self.rooms[namespace]) == 0:
+                    del self.rooms[namespace]
+        except KeyError:
+            pass
+
+    def close_room(self, room, namespace):
+        """Remove all participants from a room."""
+        try:
+            for sid, _ in self.get_participants(namespace, room):
+                self.leave_room(sid, namespace, room)
+        except KeyError:
+            pass
+
+    def get_rooms(self, sid, namespace):
+        """Return the rooms a client is in."""
+        r = []
+        try:
+            for room_name, room in self.rooms[namespace].items():
+                if room_name is not None and sid in room:
+                    r.append(room_name)
+        except KeyError:
+            pass
+        return r
+
+    def emit(self, event, data, namespace, room=None, skip_sid=None,
+             callback=None, **kwargs):
+        """Emit a message to a single client, a room, or all the clients
+        connected to the namespace."""
+        if namespace not in self.rooms:
+            return
+        if not isinstance(skip_sid, list):
+            skip_sid = [skip_sid]
+        for sid, eio_sid in self.get_participants(namespace, room):
+            if sid not in skip_sid:
+                if callback is not None:
+                    id = self._generate_ack_id(sid, callback)
+                else:
+                    id = None
+                self.server._emit_internal(eio_sid, event, data, namespace, id)
+
+    def trigger_callback(self, sid, id, data):
+        """Invoke an application callback."""
+        callback = None
+        try:
+            callback = self.callbacks[sid][id]
+        except KeyError:
+            # if we get an unknown callback we just ignore it
+            self._get_logger().warning('Unknown callback received, ignoring.')
+        else:
+            del self.callbacks[sid][id]
+        if callback is not None:
+            callback(*data)
+
+    def _generate_ack_id(self, sid, callback):
+        """Generate a unique identifier for an ACK packet."""
+        if sid not in self.callbacks:
+            self.callbacks[sid] = {0: itertools.count(1)}
+        id = next(self.callbacks[sid][0])
+        self.callbacks[sid][id] = callback
+        return id
+
+    def _get_logger(self):
+        """Get the appropriate logger
+
+        Prevents uninitialized servers in write-only mode from failing.
+        """
+
+        if self.logger:
+            return self.logger
+        elif self.server:
+            return self.server.logger
+        else:
+            return default_logger

venv/lib/python3.11/site-packages/socketio/client.py

@@ -0,0 +1,732 @@
+import itertools
+import logging
+import random
+import signal
+import threading
+
+import engineio
+
+from . import exceptions
+from . import namespace
+from . import packet
+
+default_logger = logging.getLogger('socketio.client')
+reconnecting_clients = []
+
+
+def signal_handler(sig, frame):  # pragma: no cover
+    """SIGINT handler.
+
+    Notify any clients that are in a reconnect loop to abort. Other
+    disconnection tasks are handled at the engine.io level.
+    """
+    for client in reconnecting_clients[:]:
+        client._reconnect_abort.set()
+    if callable(original_signal_handler):
+        return original_signal_handler(sig, frame)
+    else:  # pragma: no cover
+        # Handle case where no original SIGINT handler was present.
+        return signal.default_int_handler(sig, frame)
+
+
+original_signal_handler = None
+
+
+class Client(object):
+    """A Socket.IO client.
+
+    This class implements a fully compliant Socket.IO web client with support
+    for websocket and long-polling transports.
+
+    :param reconnection: ``True`` if the client should automatically attempt to
+                         reconnect to the server after an interruption, or
+                         ``False`` to not reconnect. The default is ``True``.
+    :param reconnection_attempts: How many reconnection attempts to issue
+                                  before giving up, or 0 for infinite attempts.
+                                  The default is 0.
+    :param reconnection_delay: How long to wait in seconds before the first
+                               reconnection attempt. Each successive attempt
+                               doubles this delay.
+    :param reconnection_delay_max: The maximum delay between reconnection
+                                   attempts.
+    :param randomization_factor: Randomization amount for each delay between
+                                 reconnection attempts. The default is 0.5,
+                                 which means that each delay is randomly
+                                 adjusted by +/- 50%.
+    :param logger: To enable logging set to ``True`` or pass a logger object to
+                   use. To disable logging set to ``False``. The default is
+                   ``False``. Note that fatal errors are logged even when
+                   ``logger`` is ``False``.
+    :param serializer: The serialization method to use when transmitting
+                       packets. Valid values are ``'default'``, ``'pickle'``,
+                       ``'msgpack'`` and ``'cbor'``. Alternatively, a subclass
+                       of the :class:`Packet` class with custom implementations
+                       of the ``encode()`` and ``decode()`` methods can be
+                       provided. Client and server must use compatible
+                       serializers.
+    :param json: An alternative json module to use for encoding and decoding
+                 packets. Custom json modules must have ``dumps`` and ``loads``
+                 functions that are compatible with the standard library
+                 versions.
+    :param handle_sigint: Set to ``True`` to automatically handle disconnection
+                          when the process is interrupted, or to ``False`` to
+                          leave interrupt handling to the calling application.
+                          Interrupt handling can only be enabled when the
+                          client instance is created in the main thread.
+
+    The Engine.IO configuration supports the following settings:
+
+    :param request_timeout: A timeout in seconds for requests. The default is
+                            5 seconds.
+    :param http_session: an initialized ``requests.Session`` object to be used
+                         when sending requests to the server. Use it if you
+                         need to add special client options such as proxy
+                         servers, SSL certificates, etc.
+    :param ssl_verify: ``True`` to verify SSL certificates, or ``False`` to
+                       skip SSL certificate verification, allowing
+                       connections to servers with self signed certificates.
+                       The default is ``True``.
+    :param engineio_logger: To enable Engine.IO logging set to ``True`` or pass
+                            a logger object to use. To disable logging set to
+                            ``False``. The default is ``False``. Note that
+                            fatal errors are logged even when
+                            ``engineio_logger`` is ``False``.
+    """
+    reserved_events = ['connect', 'connect_error', 'disconnect']
+
+    def __init__(self, reconnection=True, reconnection_attempts=0,
+                 reconnection_delay=1, reconnection_delay_max=5,
+                 randomization_factor=0.5, logger=False, serializer='default',
+                 json=None, handle_sigint=True, **kwargs):
+        global original_signal_handler
+        if handle_sigint and original_signal_handler is None and \
+                threading.current_thread() == threading.main_thread():
+            original_signal_handler = signal.signal(signal.SIGINT,
+                                                    signal_handler)
+        self.reconnection = reconnection
+        self.reconnection_attempts = reconnection_attempts
+        self.reconnection_delay = reconnection_delay
+        self.reconnection_delay_max = reconnection_delay_max
+        self.randomization_factor = randomization_factor
+        self.handle_sigint = handle_sigint
+
+        engineio_options = kwargs
+        engineio_options['handle_sigint'] = handle_sigint
+        engineio_logger = engineio_options.pop('engineio_logger', None)
+        if engineio_logger is not None:
+            engineio_options['logger'] = engineio_logger
+        if serializer == 'default':
+            self.packet_class = packet.Packet
+        elif serializer == 'msgpack':
+            from . import msgpack_packet
+            self.packet_class = msgpack_packet.MsgPackPacket
+        else:
+            self.packet_class = serializer
+        if json is not None:
+            self.packet_class.json = json
+            engineio_options['json'] = json
+
+        self.eio = self._engineio_client_class()(**engineio_options)
+        self.eio.on('connect', self._handle_eio_connect)
+        self.eio.on('message', self._handle_eio_message)
+        self.eio.on('disconnect', self._handle_eio_disconnect)
+
+        if not isinstance(logger, bool):
+            self.logger = logger
+        else:
+            self.logger = default_logger
+            if self.logger.level == logging.NOTSET:
+                if logger:
+                    self.logger.setLevel(logging.INFO)
+                else:
+                    self.logger.setLevel(logging.ERROR)
+                self.logger.addHandler(logging.StreamHandler())
+
+        self.connection_url = None
+        self.connection_headers = None
+        self.connection_auth = None
+        self.connection_transports = None
+        self.connection_namespaces = []
+        self.socketio_path = None
+        self.sid = None
+
+        self.connected = False  #: Indicates if the client is connected or not.
+        self.namespaces = {}  #: set of connected namespaces.
+        self.handlers = {}
+        self.namespace_handlers = {}
+        self.callbacks = {}
+        self._binary_packet = None
+        self._connect_event = None
+        self._reconnect_task = None
+        self._reconnect_abort = None
+
+    def is_asyncio_based(self):
+        return False
+
+    def on(self, event, handler=None, namespace=None):
+        """Register an event handler.
+
+        :param event: The event name. It can be any string. The event names
+                      ``'connect'``, ``'message'`` and ``'disconnect'`` are
+                      reserved and should not be used.
+        :param handler: The function that should be invoked to handle the
+                        event. When this parameter is not given, the method
+                        acts as a decorator for the handler function.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the handler is associated with
+                          the default namespace.
+
+        Example usage::
+
+            # as a decorator:
+            @sio.on('connect')
+            def connect_handler():
+                print('Connected!')
+
+            # as a method:
+            def message_handler(msg):
+                print('Received message: ', msg)
+                sio.send( 'response')
+            sio.on('message', message_handler)
+
+        The ``'connect'`` event handler receives no arguments. The
+        ``'message'`` handler and handlers for custom event names receive the
+        message payload as only argument. Any values returned from a message
+        handler will be passed to the client's acknowledgement callback
+        function if it exists. The ``'disconnect'`` handler does not take
+        arguments.
+        """
+        namespace = namespace or '/'
+
+        def set_handler(handler):
+            if namespace not in self.handlers:
+                self.handlers[namespace] = {}
+            self.handlers[namespace][event] = handler
+            return handler
+
+        if handler is None:
+            return set_handler
+        set_handler(handler)
+
+    def event(self, *args, **kwargs):
+        """Decorator to register an event handler.
+
+        This is a simplified version of the ``on()`` method that takes the
+        event name from the decorated function.
+
+        Example usage::
+
+            @sio.event
+            def my_event(data):
+                print('Received data: ', data)
+
+        The above example is equivalent to::
+
+            @sio.on('my_event')
+            def my_event(data):
+                print('Received data: ', data)
+
+        A custom namespace can be given as an argument to the decorator::
+
+            @sio.event(namespace='/test')
+            def my_event(data):
+                print('Received data: ', data)
+        """
+        if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+            # the decorator was invoked without arguments
+            # args[0] is the decorated function
+            return self.on(args[0].__name__)(args[0])
+        else:
+            # the decorator was invoked with arguments
+            def set_handler(handler):
+                return self.on(handler.__name__, *args, **kwargs)(handler)
+
+            return set_handler
+
+    def register_namespace(self, namespace_handler):
+        """Register a namespace handler object.
+
+        :param namespace_handler: An instance of a :class:`Namespace`
+                                  subclass that handles all the event traffic
+                                  for a namespace.
+        """
+        if not isinstance(namespace_handler, namespace.ClientNamespace):
+            raise ValueError('Not a namespace instance')
+        if self.is_asyncio_based() != namespace_handler.is_asyncio_based():
+            raise ValueError('Not a valid namespace class for this client')
+        namespace_handler._set_client(self)
+        self.namespace_handlers[namespace_handler.namespace] = \
+            namespace_handler
+
+    def connect(self, url, headers={}, auth=None, transports=None,
+                namespaces=None, socketio_path='socket.io', wait=True,
+                wait_timeout=1):
+        """Connect to a Socket.IO server.
+
+        :param url: The URL of the Socket.IO server. It can include custom
+                    query string parameters if required by the server. If a
+                    function is provided, the client will invoke it to obtain
+                    the URL each time a connection or reconnection is
+                    attempted.
+        :param headers: A dictionary with custom headers to send with the
+                        connection request. If a function is provided, the
+                        client will invoke it to obtain the headers dictionary
+                        each time a connection or reconnection is attempted.
+        :param auth: Authentication data passed to the server with the
+                     connection request, normally a dictionary with one or
+                     more string key/value pairs. If a function is provided,
+                     the client will invoke it to obtain the authentication
+                     data each time a connection or reconnection is attempted.
+        :param transports: The list of allowed transports. Valid transports
+                           are ``'polling'`` and ``'websocket'``. If not
+                           given, the polling transport is connected first,
+                           then an upgrade to websocket is attempted.
+        :param namespaces: The namespaces to connect as a string or list of
+                           strings. If not given, the namespaces that have
+                           registered event handlers are connected.
+        :param socketio_path: The endpoint where the Socket.IO server is
+                              installed. The default value is appropriate for
+                              most cases.
+        :param wait: if set to ``True`` (the default) the call only returns
+                     when all the namespaces are connected. If set to
+                     ``False``, the call returns as soon as the Engine.IO
+                     transport is connected, and the namespaces will connect
+                     in the background.
+        :param wait_timeout: How long the client should wait for the
+                             connection. The default is 1 second. This
+                             argument is only considered when ``wait`` is set
+                             to ``True``.
+
+        Example usage::
+
+            sio = socketio.Client()
+            sio.connect('http://localhost:5000')
+        """
+        if self.connected:
+            raise exceptions.ConnectionError('Already connected')
+
+        self.connection_url = url
+        self.connection_headers = headers
+        self.connection_auth = auth
+        self.connection_transports = transports
+        self.connection_namespaces = namespaces
+        self.socketio_path = socketio_path
+
+        if namespaces is None:
+            namespaces = list(set(self.handlers.keys()).union(
+                set(self.namespace_handlers.keys())))
+            if len(namespaces) == 0:
+                namespaces = ['/']
+        elif isinstance(namespaces, str):
+            namespaces = [namespaces]
+        self.connection_namespaces = namespaces
+        self.namespaces = {}
+        if self._connect_event is None:
+            self._connect_event = self.eio.create_event()
+        else:
+            self._connect_event.clear()
+        real_url = self._get_real_value(self.connection_url)
+        real_headers = self._get_real_value(self.connection_headers)
+        try:
+            self.eio.connect(real_url, headers=real_headers,
+                             transports=transports,
+                             engineio_path=socketio_path)
+        except engineio.exceptions.ConnectionError as exc:
+            self._trigger_event(
+                'connect_error', '/',
+                exc.args[1] if len(exc.args) > 1 else exc.args[0])
+            raise exceptions.ConnectionError(exc.args[0]) from None
+
+        if wait:
+            while self._connect_event.wait(timeout=wait_timeout):
+                self._connect_event.clear()
+                if set(self.namespaces) == set(self.connection_namespaces):
+                    break
+            if set(self.namespaces) != set(self.connection_namespaces):
+                self.disconnect()
+                raise exceptions.ConnectionError(
+                    'One or more namespaces failed to connect')
+
+        self.connected = True
+
+    def wait(self):
+        """Wait until the connection with the server ends.
+
+        Client applications can use this function to block the main thread
+        during the life of the connection.
+        """
+        while True:
+            self.eio.wait()
+            self.sleep(1)  # give the reconnect task time to start up
+            if not self._reconnect_task:
+                break
+            self._reconnect_task.join()
+            if self.eio.state != 'connected':
+                break
+
+    def emit(self, event, data=None, namespace=None, callback=None):
+        """Emit a custom event to one or more connected clients.
+
+        :param event: The event name. It can be any string. The event names
+                      ``'connect'``, ``'message'`` and ``'disconnect'`` are
+                      reserved and should not be used.
+        :param data: The data to send to the server. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. To send
+                     multiple arguments, use a tuple where each element is of
+                     one of the types indicated above.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param callback: If given, this function will be called to acknowledge
+                         the server has received the message. The arguments
+                         that will be passed to the function are those provided
+                         by the server.
+
+        Note: this method is not thread safe. If multiple threads are emitting
+        at the same time on the same client connection, messages composed of
+        multiple packets may end up being sent in an incorrect sequence. Use
+        standard concurrency solutions (such as a Lock object) to prevent this
+        situation.
+        """
+        namespace = namespace or '/'
+        if namespace not in self.namespaces:
+            raise exceptions.BadNamespaceError(
+                namespace + ' is not a connected namespace.')
+        self.logger.info('Emitting event "%s" [%s]', event, namespace)
+        if callback is not None:
+            id = self._generate_ack_id(namespace, callback)
+        else:
+            id = None
+        # tuples are expanded to multiple arguments, everything else is sent
+        # as a single argument
+        if isinstance(data, tuple):
+            data = list(data)
+        elif data is not None:
+            data = [data]
+        else:
+            data = []
+        self._send_packet(self.packet_class(packet.EVENT, namespace=namespace,
+                                            data=[event] + data, id=id))
+
+    def send(self, data, namespace=None, callback=None):
+        """Send a message to one or more connected clients.
+
+        This function emits an event with the name ``'message'``. Use
+        :func:`emit` to issue custom event names.
+
+        :param data: The data to send to the server. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. To send
+                     multiple arguments, use a tuple where each element is of
+                     one of the types indicated above.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param callback: If given, this function will be called to acknowledge
+                         the server has received the message. The arguments
+                         that will be passed to the function are those provided
+                         by the server.
+        """
+        self.emit('message', data=data, namespace=namespace,
+                  callback=callback)
+
+    def call(self, event, data=None, namespace=None, timeout=60):
+        """Emit a custom event to a client and wait for the response.
+
+        This method issues an emit with a callback and waits for the callback
+        to be invoked before returning. If the callback isn't invoked before
+        the timeout, then a ``TimeoutError`` exception is raised. If the
+        Socket.IO connection drops during the wait, this method still waits
+        until the specified timeout.
+
+        :param event: The event name. It can be any string. The event names
+                      ``'connect'``, ``'message'`` and ``'disconnect'`` are
+                      reserved and should not be used.
+        :param data: The data to send to the server. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. To send
+                     multiple arguments, use a tuple where each element is of
+                     one of the types indicated above.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param timeout: The waiting timeout. If the timeout is reached before
+                        the client acknowledges the event, then a
+                        ``TimeoutError`` exception is raised.
+
+        Note: this method is not thread safe. If multiple threads are emitting
+        at the same time on the same client connection, messages composed of
+        multiple packets may end up being sent in an incorrect sequence. Use
+        standard concurrency solutions (such as a Lock object) to prevent this
+        situation.
+        """
+        callback_event = self.eio.create_event()
+        callback_args = []
+
+        def event_callback(*args):
+            callback_args.append(args)
+            callback_event.set()
+
+        self.emit(event, data=data, namespace=namespace,
+                  callback=event_callback)
+        if not callback_event.wait(timeout=timeout):
+            raise exceptions.TimeoutError()
+        return callback_args[0] if len(callback_args[0]) > 1 \
+            else callback_args[0][0] if len(callback_args[0]) == 1 \
+            else None
+
+    def disconnect(self):
+        """Disconnect from the server."""
+        # here we just request the disconnection
+        # later in _handle_eio_disconnect we invoke the disconnect handler
+        for n in self.namespaces:
+            self._send_packet(self.packet_class(
+                packet.DISCONNECT, namespace=n))
+        self.eio.disconnect(abort=True)
+
+    def get_sid(self, namespace=None):
+        """Return the ``sid`` associated with a connection.
+
+        :param namespace: The Socket.IO namespace. If this argument is omitted
+                          the handler is associated with the default
+                          namespace. Note that unlike previous versions, the
+                          current version of the Socket.IO protocol uses
+                          different ``sid`` values per namespace.
+
+        This method returns the ``sid`` for the requested namespace as a
+        string.
+        """
+        return self.namespaces.get(namespace or '/')
+
+    def transport(self):
+        """Return the name of the transport used by the client.
+
+        The two possible values returned by this function are ``'polling'``
+        and ``'websocket'``.
+        """
+        return self.eio.transport()
+
+    def start_background_task(self, target, *args, **kwargs):
+        """Start a background task using the appropriate async model.
+
+        This is a utility function that applications can use to start a
+        background task using the method that is compatible with the
+        selected async mode.
+
+        :param target: the target function to execute.
+        :param args: arguments to pass to the function.
+        :param kwargs: keyword arguments to pass to the function.
+
+        This function returns an object that represents the background task,
+        on which the ``join()`` methond can be invoked to wait for the task to
+        complete.
+        """
+        return self.eio.start_background_task(target, *args, **kwargs)
+
+    def sleep(self, seconds=0):
+        """Sleep for the requested amount of time using the appropriate async
+        model.
+
+        This is a utility function that applications can use to put a task to
+        sleep without having to worry about using the correct call for the
+        selected async mode.
+        """
+        return self.eio.sleep(seconds)
+
+    def _get_real_value(self, value):
+        """Return the actual value, for parameters that can also be given as
+        callables."""
+        if not callable(value):
+            return value
+        return value()
+
+    def _send_packet(self, pkt):
+        """Send a Socket.IO packet to the server."""
+        encoded_packet = pkt.encode()
+        if isinstance(encoded_packet, list):
+            for ep in encoded_packet:
+                self.eio.send(ep)
+        else:
+            self.eio.send(encoded_packet)
+
+    def _generate_ack_id(self, namespace, callback):
+        """Generate a unique identifier for an ACK packet."""
+        namespace = namespace or '/'
+        if namespace not in self.callbacks:
+            self.callbacks[namespace] = {0: itertools.count(1)}
+        id = next(self.callbacks[namespace][0])
+        self.callbacks[namespace][id] = callback
+        return id
+
+    def _handle_connect(self, namespace, data):
+        namespace = namespace or '/'
+        if namespace not in self.namespaces:
+            self.logger.info('Namespace {} is connected'.format(namespace))
+            self.namespaces[namespace] = (data or {}).get('sid', self.sid)
+            self._trigger_event('connect', namespace=namespace)
+            self._connect_event.set()
+
+    def _handle_disconnect(self, namespace):
+        if not self.connected:
+            return
+        namespace = namespace or '/'
+        self._trigger_event('disconnect', namespace=namespace)
+        if namespace in self.namespaces:
+            del self.namespaces[namespace]
+        if not self.namespaces:
+            self.connected = False
+            self.eio.disconnect(abort=True)
+
+    def _handle_event(self, namespace, id, data):
+        namespace = namespace or '/'
+        self.logger.info('Received event "%s" [%s]', data[0], namespace)
+        r = self._trigger_event(data[0], namespace, *data[1:])
+        if id is not None:
+            # send ACK packet with the response returned by the handler
+            # tuples are expanded as multiple arguments
+            if r is None:
+                data = []
+            elif isinstance(r, tuple):
+                data = list(r)
+            else:
+                data = [r]
+            self._send_packet(self.packet_class(
+                packet.ACK, namespace=namespace, id=id, data=data))
+
+    def _handle_ack(self, namespace, id, data):
+        namespace = namespace or '/'
+        self.logger.info('Received ack [%s]', namespace)
+        callback = None
+        try:
+            callback = self.callbacks[namespace][id]
+        except KeyError:
+            # if we get an unknown callback we just ignore it
+            self.logger.warning('Unknown callback received, ignoring.')
+        else:
+            del self.callbacks[namespace][id]
+        if callback is not None:
+            callback(*data)
+
+    def _handle_error(self, namespace, data):
+        namespace = namespace or '/'
+        self.logger.info('Connection to namespace {} was rejected'.format(
+            namespace))
+        if data is None:
+            data = tuple()
+        elif not isinstance(data, (tuple, list)):
+            data = (data,)
+        self._trigger_event('connect_error', namespace, *data)
+        self._connect_event.set()
+        if namespace in self.namespaces:
+            del self.namespaces[namespace]
+        if namespace == '/':
+            self.namespaces = {}
+            self.connected = False
+
+    def _trigger_event(self, event, namespace, *args):
+        """Invoke an application event handler."""
+        # first see if we have an explicit handler for the event
+        if namespace in self.handlers:
+            if event in self.handlers[namespace]:
+                return self.handlers[namespace][event](*args)
+            elif event not in self.reserved_events and \
+                    '*' in self.handlers[namespace]:
+                return self.handlers[namespace]['*'](event, *args)
+
+        # or else, forward the event to a namespace handler if one exists
+        elif namespace in self.namespace_handlers:
+            return self.namespace_handlers[namespace].trigger_event(
+                event, *args)
+
+    def _handle_reconnect(self):
+        if self._reconnect_abort is None:  # pragma: no cover
+            self._reconnect_abort = self.eio.create_event()
+        self._reconnect_abort.clear()
+        reconnecting_clients.append(self)
+        attempt_count = 0
+        current_delay = self.reconnection_delay
+        while True:
+            delay = current_delay
+            current_delay *= 2
+            if delay > self.reconnection_delay_max:
+                delay = self.reconnection_delay_max
+            delay += self.randomization_factor * (2 * random.random() - 1)
+            self.logger.info(
+                'Connection failed, new attempt in {:.02f} seconds'.format(
+                    delay))
+            if self._reconnect_abort.wait(delay):
+                self.logger.info('Reconnect task aborted')
+                break
+            attempt_count += 1
+            try:
+                self.connect(self.connection_url,
+                             headers=self.connection_headers,
+                             auth=self.connection_auth,
+                             transports=self.connection_transports,
+                             namespaces=self.connection_namespaces,
+                             socketio_path=self.socketio_path)
+            except (exceptions.ConnectionError, ValueError):
+                pass
+            else:
+                self.logger.info('Reconnection successful')
+                self._reconnect_task = None
+                break
+            if self.reconnection_attempts and \
+                    attempt_count >= self.reconnection_attempts:
+                self.logger.info(
+                    'Maximum reconnection attempts reached, giving up')
+                break
+        reconnecting_clients.remove(self)
+
+    def _handle_eio_connect(self):
+        """Handle the Engine.IO connection event."""
+        self.logger.info('Engine.IO connection established')
+        self.sid = self.eio.sid
+        real_auth = self._get_real_value(self.connection_auth) or {}
+        for n in self.connection_namespaces:
+            self._send_packet(self.packet_class(
+                packet.CONNECT, data=real_auth, namespace=n))
+
+    def _handle_eio_message(self, data):
+        """Dispatch Engine.IO messages."""
+        if self._binary_packet:
+            pkt = self._binary_packet
+            if pkt.add_attachment(data):
+                self._binary_packet = None
+                if pkt.packet_type == packet.BINARY_EVENT:
+                    self._handle_event(pkt.namespace, pkt.id, pkt.data)
+                else:
+                    self._handle_ack(pkt.namespace, pkt.id, pkt.data)
+        else:
+            pkt = self.packet_class(encoded_packet=data)
+            if pkt.packet_type == packet.CONNECT:
+                self._handle_connect(pkt.namespace, pkt.data)
+            elif pkt.packet_type == packet.DISCONNECT:
+                self._handle_disconnect(pkt.namespace)
+            elif pkt.packet_type == packet.EVENT:
+                self._handle_event(pkt.namespace, pkt.id, pkt.data)
+            elif pkt.packet_type == packet.ACK:
+                self._handle_ack(pkt.namespace, pkt.id, pkt.data)
+            elif pkt.packet_type == packet.BINARY_EVENT or \
+                    pkt.packet_type == packet.BINARY_ACK:
+                self._binary_packet = pkt
+            elif pkt.packet_type == packet.CONNECT_ERROR:
+                self._handle_error(pkt.namespace, pkt.data)
+            else:
+                raise ValueError('Unknown packet type.')
+
+    def _handle_eio_disconnect(self):
+        """Handle the Engine.IO disconnection event."""
+        self.logger.info('Engine.IO connection dropped')
+        if self.connected:
+            for n in self.namespaces:
+                self._trigger_event('disconnect', namespace=n)
+            self.namespaces = {}
+            self.connected = False
+        self.callbacks = {}
+        self._binary_packet = None
+        self.sid = None
+        if self.eio.state == 'connected' and self.reconnection:
+            self._reconnect_task = self.start_background_task(
+                self._handle_reconnect)
+
+    def _engineio_client_class(self):
+        return engineio.Client

venv/lib/python3.11/site-packages/socketio/exceptions.py

@@ -0,0 +1,34 @@
+class SocketIOError(Exception):
+    pass
+
+
+class ConnectionError(SocketIOError):
+    pass
+
+
+class ConnectionRefusedError(ConnectionError):
+    """Connection refused exception.
+
+    This exception can be raised from a connect handler when the connection
+    is not accepted. The positional arguments provided with the exception are
+    returned with the error packet to the client.
+    """
+    def __init__(self, *args):
+        if len(args) == 0:
+            self.error_args = {'message': 'Connection rejected by server'}
+        elif len(args) == 1:
+            self.error_args = {'message': str(args[0])}
+        else:
+            self.error_args = {'message': str(args[0])}
+            if len(args) == 2:
+                self.error_args['data'] = args[1]
+            else:
+                self.error_args['data'] = args[1:]
+
+
+class TimeoutError(SocketIOError):
+    pass
+
+
+class BadNamespaceError(SocketIOError):
+    pass

venv/lib/python3.11/site-packages/socketio/kafka_manager.py

@@ -0,0 +1,67 @@
+import logging
+import pickle
+
+try:
+    import kafka
+except ImportError:
+    kafka = None
+
+from .pubsub_manager import PubSubManager
+
+logger = logging.getLogger('socketio')
+
+
+class KafkaManager(PubSubManager):  # pragma: no cover
+    """Kafka based client manager.
+
+    This class implements a Kafka backend for event sharing across multiple
+    processes.
+
+    To use a Kafka backend, initialize the :class:`Server` instance as
+    follows::
+
+        url = 'kafka://hostname:port'
+        server = socketio.Server(client_manager=socketio.KafkaManager(url))
+
+    :param url: The connection URL for the Kafka server. For a default Kafka
+                store running on the same host, use ``kafka://``. For a highly
+                available deployment of Kafka, pass a list with all the
+                connection URLs available in your cluster.
+    :param channel: The channel name (topic) on which the server sends and
+                    receives notifications. Must be the same in all the
+                    servers.
+    :param write_only: If set to ``True``, only initialize to emit events. The
+                       default of ``False`` initializes the class for emitting
+                       and receiving.
+    """
+    name = 'kafka'
+
+    def __init__(self, url='kafka://localhost:9092', channel='socketio',
+                 write_only=False):
+        if kafka is None:
+            raise RuntimeError('kafka-python package is not installed '
+                               '(Run "pip install kafka-python" in your '
+                               'virtualenv).')
+
+        super(KafkaManager, self).__init__(channel=channel,
+                                           write_only=write_only)
+
+        urls = [url] if isinstance(url, str) else url
+        self.kafka_urls = [url[8:] if url != 'kafka://' else 'localhost:9092'
+                           for url in urls]
+        self.producer = kafka.KafkaProducer(bootstrap_servers=self.kafka_urls)
+        self.consumer = kafka.KafkaConsumer(self.channel,
+                                            bootstrap_servers=self.kafka_urls)
+
+    def _publish(self, data):
+        self.producer.send(self.channel, value=pickle.dumps(data))
+        self.producer.flush()
+
+    def _kafka_listen(self):
+        for message in self.consumer:
+            yield message
+
+    def _listen(self):
+        for message in self._kafka_listen():
+            if message.topic == self.channel:
+                yield pickle.loads(message.value)

venv/lib/python3.11/site-packages/socketio/kombu_manager.py

@@ -0,0 +1,136 @@
+import pickle
+import time
+import uuid
+
+try:
+    import kombu
+except ImportError:
+    kombu = None
+
+from .pubsub_manager import PubSubManager
+
+
+class KombuManager(PubSubManager):  # pragma: no cover
+    """Client manager that uses kombu for inter-process messaging.
+
+    This class implements a client manager backend for event sharing across
+    multiple processes, using RabbitMQ, Redis or any other messaging mechanism
+    supported by `kombu <http://kombu.readthedocs.org/en/latest/>`_.
+
+    To use a kombu backend, initialize the :class:`Server` instance as
+    follows::
+
+        url = 'amqp://user:password@hostname:port//'
+        server = socketio.Server(client_manager=socketio.KombuManager(url))
+
+    :param url: The connection URL for the backend messaging queue. Example
+                connection URLs are ``'amqp://guest:guest@localhost:5672//'``
+                and ``'redis://localhost:6379/'`` for RabbitMQ and Redis
+                respectively. Consult the `kombu documentation
+                <http://kombu.readthedocs.org/en/latest/userguide\
+                /connections.html#urls>`_ for more on how to construct
+                connection URLs.
+    :param channel: The channel name on which the server sends and receives
+                    notifications. Must be the same in all the servers.
+    :param write_only: If set to ``True``, only initialize to emit events. The
+                       default of ``False`` initializes the class for emitting
+                       and receiving.
+    :param connection_options: additional keyword arguments to be passed to
+                               ``kombu.Connection()``.
+    :param exchange_options: additional keyword arguments to be passed to
+                             ``kombu.Exchange()``.
+    :param queue_options: additional keyword arguments to be passed to
+                          ``kombu.Queue()``.
+    :param producer_options: additional keyword arguments to be passed to
+                             ``kombu.Producer()``.
+    """
+    name = 'kombu'
+
+    def __init__(self, url='amqp://guest:guest@localhost:5672//',
+                 channel='socketio', write_only=False, logger=None,
+                 connection_options=None, exchange_options=None,
+                 queue_options=None, producer_options=None):
+        if kombu is None:
+            raise RuntimeError('Kombu package is not installed '
+                               '(Run "pip install kombu" in your '
+                               'virtualenv).')
+        super(KombuManager, self).__init__(channel=channel,
+                                           write_only=write_only,
+                                           logger=logger)
+        self.url = url
+        self.connection_options = connection_options or {}
+        self.exchange_options = exchange_options or {}
+        self.queue_options = queue_options or {}
+        self.producer_options = producer_options or {}
+        self.publisher_connection = self._connection()
+
+    def initialize(self):
+        super(KombuManager, self).initialize()
+
+        monkey_patched = True
+        if self.server.async_mode == 'eventlet':
+            from eventlet.patcher import is_monkey_patched
+            monkey_patched = is_monkey_patched('socket')
+        elif 'gevent' in self.server.async_mode:
+            from gevent.monkey import is_module_patched
+            monkey_patched = is_module_patched('socket')
+        if not monkey_patched:
+            raise RuntimeError(
+                'Kombu requires a monkey patched socket library to work '
+                'with ' + self.server.async_mode)
+
+    def _connection(self):
+        return kombu.Connection(self.url, **self.connection_options)
+
+    def _exchange(self):
+        options = {'type': 'fanout', 'durable': False}
+        options.update(self.exchange_options)
+        return kombu.Exchange(self.channel, **options)
+
+    def _queue(self):
+        queue_name = 'flask-socketio.' + str(uuid.uuid4())
+        options = {'durable': False, 'queue_arguments': {'x-expires': 300000}}
+        options.update(self.queue_options)
+        return kombu.Queue(queue_name, self._exchange(), **options)
+
+    def _producer_publish(self, connection):
+        producer = connection.Producer(exchange=self._exchange(),
+                                       **self.producer_options)
+        return connection.ensure(producer, producer.publish)
+
+    def _publish(self, data):
+        retry = True
+        while True:
+            try:
+                producer_publish = self._producer_publish(
+                    self.publisher_connection)
+                producer_publish(pickle.dumps(data))
+                break
+            except (OSError, kombu.exceptions.KombuError):
+                if retry:
+                    self._get_logger().error('Cannot publish to rabbitmq... '
+                                             'retrying')
+                    retry = False
+                else:
+                    self._get_logger().error(
+                        'Cannot publish to rabbitmq... giving up')
+                    break
+
+    def _listen(self):
+        reader_queue = self._queue()
+        retry_sleep = 1
+        while True:
+            try:
+                with self._connection() as connection:
+                    with connection.SimpleQueue(reader_queue) as queue:
+                        while True:
+                            message = queue.get(block=True)
+                            message.ack()
+                            yield message.payload
+                            retry_sleep = 1
+            except (OSError, kombu.exceptions.KombuError):
+                self._get_logger().error(
+                    'Cannot receive from rabbitmq... '
+                    'retrying in {} secs'.format(retry_sleep))
+                time.sleep(retry_sleep)
+                retry_sleep = min(retry_sleep * 2, 60)

venv/lib/python3.11/site-packages/socketio/middleware.py

@@ -0,0 +1,42 @@
+import engineio
+
+
+class WSGIApp(engineio.WSGIApp):
+    """WSGI middleware for Socket.IO.
+
+    This middleware dispatches traffic to a Socket.IO application. It can also
+    serve a list of static files to the client, or forward unrelated HTTP
+    traffic to another WSGI application.
+
+    :param socketio_app: The Socket.IO server. Must be an instance of the
+                         ``socketio.Server`` class.
+    :param wsgi_app: The WSGI app that receives all other traffic.
+    :param static_files: A dictionary with static file mapping rules. See the
+                         documentation for details on this argument.
+    :param socketio_path: The endpoint where the Socket.IO application should
+                          be installed. The default value is appropriate for
+                          most cases.
+
+    Example usage::
+
+        import socketio
+        import eventlet
+        from . import wsgi_app
+
+        sio = socketio.Server()
+        app = socketio.WSGIApp(sio, wsgi_app)
+        eventlet.wsgi.server(eventlet.listen(('', 8000)), app)
+    """
+    def __init__(self, socketio_app, wsgi_app=None, static_files=None,
+                 socketio_path='socket.io'):
+        super(WSGIApp, self).__init__(socketio_app, wsgi_app,
+                                      static_files=static_files,
+                                      engineio_path=socketio_path)
+
+
+class Middleware(WSGIApp):
+    """This class has been renamed to WSGIApp and is now deprecated."""
+    def __init__(self, socketio_app, wsgi_app=None,
+                 socketio_path='socket.io'):
+        super(Middleware, self).__init__(socketio_app, wsgi_app,
+                                         socketio_path=socketio_path)

venv/lib/python3.11/site-packages/socketio/msgpack_packet.py

@@ -0,0 +1,18 @@
+import msgpack
+from . import packet
+
+
+class MsgPackPacket(packet.Packet):
+    uses_binary_events = False
+
+    def encode(self):
+        """Encode the packet for transmission."""
+        return msgpack.dumps(self._to_dict())
+
+    def decode(self, encoded_packet):
+        """Decode a transmitted package."""
+        decoded = msgpack.loads(encoded_packet)
+        self.packet_type = decoded['type']
+        self.data = decoded.get('data')
+        self.id = decoded.get('id')
+        self.namespace = decoded['nsp']

venv/lib/python3.11/site-packages/socketio/namespace.py

@@ -0,0 +1,214 @@
+class BaseNamespace(object):
+    def __init__(self, namespace=None):
+        self.namespace = namespace or '/'
+
+    def is_asyncio_based(self):
+        return False
+
+    def trigger_event(self, event, *args):
+        """Dispatch an event to the proper handler method.
+
+        In the most common usage, this method is not overloaded by subclasses,
+        as it performs the routing of events to methods. However, this
+        method can be overridden if special dispatching rules are needed, or if
+        having a single method that catches all events is desired.
+        """
+        handler_name = 'on_' + event
+        if hasattr(self, handler_name):
+            return getattr(self, handler_name)(*args)
+
+
+class Namespace(BaseNamespace):
+    """Base class for server-side class-based namespaces.
+
+    A class-based namespace is a class that contains all the event handlers
+    for a Socket.IO namespace. The event handlers are methods of the class
+    with the prefix ``on_``, such as ``on_connect``, ``on_disconnect``,
+    ``on_message``, ``on_json``, and so on.
+
+    :param namespace: The Socket.IO namespace to be used with all the event
+                      handlers defined in this class. If this argument is
+                      omitted, the default namespace is used.
+    """
+    def __init__(self, namespace=None):
+        super(Namespace, self).__init__(namespace=namespace)
+        self.server = None
+
+    def _set_server(self, server):
+        self.server = server
+
+    def emit(self, event, data=None, to=None, room=None, skip_sid=None,
+             namespace=None, callback=None, ignore_queue=False):
+        """Emit a custom event to one or more connected clients.
+
+        The only difference with the :func:`socketio.Server.emit` method is
+        that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return self.server.emit(event, data=data, to=to, room=room,
+                                skip_sid=skip_sid,
+                                namespace=namespace or self.namespace,
+                                callback=callback, ignore_queue=ignore_queue)
+
+    def send(self, data, to=None, room=None, skip_sid=None, namespace=None,
+             callback=None, ignore_queue=False):
+        """Send a message to one or more connected clients.
+
+        The only difference with the :func:`socketio.Server.send` method is
+        that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return self.server.send(data, to=to, room=room, skip_sid=skip_sid,
+                                namespace=namespace or self.namespace,
+                                callback=callback, ignore_queue=ignore_queue)
+
+    def call(self, event, data=None, to=None, sid=None, namespace=None,
+             timeout=None, ignore_queue=False):
+        """Emit a custom event to a client and wait for the response.
+
+        The only difference with the :func:`socketio.Server.call` method is
+        that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return self.server.call(event, data=data, to=to, sid=sid,
+                                namespace=namespace or self.namespace,
+                                timeout=timeout, ignore_queue=ignore_queue)
+
+    def enter_room(self, sid, room, namespace=None):
+        """Enter a room.
+
+        The only difference with the :func:`socketio.Server.enter_room` method
+        is that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return self.server.enter_room(sid, room,
+                                      namespace=namespace or self.namespace)
+
+    def leave_room(self, sid, room, namespace=None):
+        """Leave a room.
+
+        The only difference with the :func:`socketio.Server.leave_room` method
+        is that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return self.server.leave_room(sid, room,
+                                      namespace=namespace or self.namespace)
+
+    def close_room(self, room, namespace=None):
+        """Close a room.
+
+        The only difference with the :func:`socketio.Server.close_room` method
+        is that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return self.server.close_room(room,
+                                      namespace=namespace or self.namespace)
+
+    def rooms(self, sid, namespace=None):
+        """Return the rooms a client is in.
+
+        The only difference with the :func:`socketio.Server.rooms` method is
+        that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return self.server.rooms(sid, namespace=namespace or self.namespace)
+
+    def get_session(self, sid, namespace=None):
+        """Return the user session for a client.
+
+        The only difference with the :func:`socketio.Server.get_session`
+        method is that when the ``namespace`` argument is not given the
+        namespace associated with the class is used.
+        """
+        return self.server.get_session(
+            sid, namespace=namespace or self.namespace)
+
+    def save_session(self, sid, session, namespace=None):
+        """Store the user session for a client.
+
+        The only difference with the :func:`socketio.Server.save_session`
+        method is that when the ``namespace`` argument is not given the
+        namespace associated with the class is used.
+        """
+        return self.server.save_session(
+            sid, session, namespace=namespace or self.namespace)
+
+    def session(self, sid, namespace=None):
+        """Return the user session for a client with context manager syntax.
+
+        The only difference with the :func:`socketio.Server.session` method is
+        that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return self.server.session(sid, namespace=namespace or self.namespace)
+
+    def disconnect(self, sid, namespace=None):
+        """Disconnect a client.
+
+        The only difference with the :func:`socketio.Server.disconnect` method
+        is that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return self.server.disconnect(sid,
+                                      namespace=namespace or self.namespace)
+
+
+class ClientNamespace(BaseNamespace):
+    """Base class for client-side class-based namespaces.
+
+    A class-based namespace is a class that contains all the event handlers
+    for a Socket.IO namespace. The event handlers are methods of the class
+    with the prefix ``on_``, such as ``on_connect``, ``on_disconnect``,
+    ``on_message``, ``on_json``, and so on.
+
+    :param namespace: The Socket.IO namespace to be used with all the event
+                      handlers defined in this class. If this argument is
+                      omitted, the default namespace is used.
+    """
+    def __init__(self, namespace=None):
+        super(ClientNamespace, self).__init__(namespace=namespace)
+        self.client = None
+
+    def _set_client(self, client):
+        self.client = client
+
+    def emit(self, event, data=None, namespace=None, callback=None):
+        """Emit a custom event to the server.
+
+        The only difference with the :func:`socketio.Client.emit` method is
+        that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return self.client.emit(event, data=data,
+                                namespace=namespace or self.namespace,
+                                callback=callback)
+
+    def send(self, data, room=None, namespace=None, callback=None):
+        """Send a message to the server.
+
+        The only difference with the :func:`socketio.Client.send` method is
+        that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return self.client.send(data, namespace=namespace or self.namespace,
+                                callback=callback)
+
+    def call(self, event, data=None, namespace=None, timeout=None):
+        """Emit a custom event to the server and wait for the response.
+
+        The only difference with the :func:`socketio.Client.call` method is
+        that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return self.client.call(event, data=data,
+                                namespace=namespace or self.namespace,
+                                timeout=timeout)
+
+    def disconnect(self):
+        """Disconnect from the server.
+
+        The only difference with the :func:`socketio.Client.disconnect` method
+        is that when the ``namespace`` argument is not given the namespace
+        associated with the class is used.
+        """
+        return self.client.disconnect()

venv/lib/python3.11/site-packages/socketio/packet.py

@@ -0,0 +1,190 @@
+import functools
+from engineio import json as _json
+
+(CONNECT, DISCONNECT, EVENT, ACK, CONNECT_ERROR, BINARY_EVENT, BINARY_ACK) = \
+    (0, 1, 2, 3, 4, 5, 6)
+packet_names = ['CONNECT', 'DISCONNECT', 'EVENT', 'ACK', 'CONNECT_ERROR',
+                'BINARY_EVENT', 'BINARY_ACK']
+
+
+class Packet(object):
+    """Socket.IO packet."""
+
+    # the format of the Socket.IO packet is as follows:
+    #
+    # packet type: 1 byte, values 0-6
+    # num_attachments: ASCII encoded, only if num_attachments != 0
+    # '-': only if num_attachments != 0
+    # namespace, followed by a ',': only if namespace != '/'
+    # id: ASCII encoded, only if id is not None
+    # data: JSON dump of data payload
+
+    uses_binary_events = True
+    json = _json
+
+    def __init__(self, packet_type=EVENT, data=None, namespace=None, id=None,
+                 binary=None, encoded_packet=None):
+        self.packet_type = packet_type
+        self.data = data
+        self.namespace = namespace
+        self.id = id
+        if self.uses_binary_events and \
+                (binary or (binary is None and self._data_is_binary(
+                    self.data))):
+            if self.packet_type == EVENT:
+                self.packet_type = BINARY_EVENT
+            elif self.packet_type == ACK:
+                self.packet_type = BINARY_ACK
+            else:
+                raise ValueError('Packet does not support binary payload.')
+        self.attachment_count = 0
+        self.attachments = []
+        if encoded_packet:
+            self.attachment_count = self.decode(encoded_packet) or 0
+
+    def encode(self):
+        """Encode the packet for transmission.
+
+        If the packet contains binary elements, this function returns a list
+        of packets where the first is the original packet with placeholders for
+        the binary components and the remaining ones the binary attachments.
+        """
+        encoded_packet = str(self.packet_type)
+        if self.packet_type == BINARY_EVENT or self.packet_type == BINARY_ACK:
+            data, attachments = self._deconstruct_binary(self.data)
+            encoded_packet += str(len(attachments)) + '-'
+        else:
+            data = self.data
+            attachments = None
+        if self.namespace is not None and self.namespace != '/':
+            encoded_packet += self.namespace + ','
+        if self.id is not None:
+            encoded_packet += str(self.id)
+        if data is not None:
+            encoded_packet += self.json.dumps(data, separators=(',', ':'))
+        if attachments is not None:
+            encoded_packet = [encoded_packet] + attachments
+        return encoded_packet
+
+    def decode(self, encoded_packet):
+        """Decode a transmitted package.
+
+        The return value indicates how many binary attachment packets are
+        necessary to fully decode the packet.
+        """
+        ep = encoded_packet
+        try:
+            self.packet_type = int(ep[0:1])
+        except TypeError:
+            self.packet_type = ep
+            ep = ''
+        self.namespace = None
+        self.data = None
+        ep = ep[1:]
+        dash = ep.find('-')
+        attachment_count = 0
+        if dash > 0 and ep[0:dash].isdigit():
+            if dash > 10:
+                raise ValueError('too many attachments')
+            attachment_count = int(ep[0:dash])
+            ep = ep[dash + 1:]
+        if ep and ep[0:1] == '/':
+            sep = ep.find(',')
+            if sep == -1:
+                self.namespace = ep
+                ep = ''
+            else:
+                self.namespace = ep[0:sep]
+                ep = ep[sep + 1:]
+            q = self.namespace.find('?')
+            if q != -1:
+                self.namespace = self.namespace[0:q]
+        if ep and ep[0].isdigit():
+            i = 1
+            end = len(ep)
+            while i < end:
+                if not ep[i].isdigit() or i >= 100:
+                    break
+                i += 1
+            self.id = int(ep[:i])
+            ep = ep[i:]
+            if len(ep) > 0 and ep[0].isdigit():
+                raise ValueError('id field is too long')
+        if ep:
+            self.data = self.json.loads(ep)
+        return attachment_count
+
+    def add_attachment(self, attachment):
+        if self.attachment_count <= len(self.attachments):
+            raise ValueError('Unexpected binary attachment')
+        self.attachments.append(attachment)
+        if self.attachment_count == len(self.attachments):
+            self.reconstruct_binary(self.attachments)
+            return True
+        return False
+
+    def reconstruct_binary(self, attachments):
+        """Reconstruct a decoded packet using the given list of binary
+        attachments.
+        """
+        self.data = self._reconstruct_binary_internal(self.data,
+                                                      self.attachments)
+
+    def _reconstruct_binary_internal(self, data, attachments):
+        if isinstance(data, list):
+            return [self._reconstruct_binary_internal(item, attachments)
+                    for item in data]
+        elif isinstance(data, dict):
+            if data.get('_placeholder') and 'num' in data:
+                return attachments[data['num']]
+            else:
+                return {key: self._reconstruct_binary_internal(value,
+                                                               attachments)
+                        for key, value in data.items()}
+        else:
+            return data
+
+    def _deconstruct_binary(self, data):
+        """Extract binary components in the packet."""
+        attachments = []
+        data = self._deconstruct_binary_internal(data, attachments)
+        return data, attachments
+
+    def _deconstruct_binary_internal(self, data, attachments):
+        if isinstance(data, bytes):
+            attachments.append(data)
+            return {'_placeholder': True, 'num': len(attachments) - 1}
+        elif isinstance(data, list):
+            return [self._deconstruct_binary_internal(item, attachments)
+                    for item in data]
+        elif isinstance(data, dict):
+            return {key: self._deconstruct_binary_internal(value, attachments)
+                    for key, value in data.items()}
+        else:
+            return data
+
+    def _data_is_binary(self, data):
+        """Check if the data contains binary components."""
+        if isinstance(data, bytes):
+            return True
+        elif isinstance(data, list):
+            return functools.reduce(
+                lambda a, b: a or b, [self._data_is_binary(item)
+                                      for item in data], False)
+        elif isinstance(data, dict):
+            return functools.reduce(
+                lambda a, b: a or b, [self._data_is_binary(item)
+                                      for item in data.values()],
+                False)
+        else:
+            return False
+
+    def _to_dict(self):
+        d = {
+            'type': self.packet_type,
+            'data': self.data,
+            'nsp': self.namespace,
+        }
+        if self.id:
+            d['id'] = self.id
+        return d

venv/lib/python3.11/site-packages/socketio/pubsub_manager.py

@@ -0,0 +1,181 @@
+from functools import partial
+import uuid
+
+from engineio import json
+import pickle
+
+from .base_manager import BaseManager
+
+
+class PubSubManager(BaseManager):
+    """Manage a client list attached to a pub/sub backend.
+
+    This is a base class that enables multiple servers to share the list of
+    clients, with the servers communicating events through a pub/sub backend.
+    The use of a pub/sub backend also allows any client connected to the
+    backend to emit events addressed to Socket.IO clients.
+
+    The actual backends must be implemented by subclasses, this class only
+    provides a pub/sub generic framework.
+
+    :param channel: The channel name on which the server sends and receives
+                    notifications.
+    """
+    name = 'pubsub'
+
+    def __init__(self, channel='socketio', write_only=False, logger=None):
+        super(PubSubManager, self).__init__()
+        self.channel = channel
+        self.write_only = write_only
+        self.host_id = uuid.uuid4().hex
+        self.logger = logger
+
+    def initialize(self):
+        super(PubSubManager, self).initialize()
+        if not self.write_only:
+            self.thread = self.server.start_background_task(self._thread)
+        self._get_logger().info(self.name + ' backend initialized.')
+
+    def emit(self, event, data, namespace=None, room=None, skip_sid=None,
+             callback=None, **kwargs):
+        """Emit a message to a single client, a room, or all the clients
+        connected to the namespace.
+
+        This method takes care or propagating the message to all the servers
+        that are connected through the message queue.
+
+        The parameters are the same as in :meth:`.Server.emit`.
+        """
+        if kwargs.get('ignore_queue'):
+            return super(PubSubManager, self).emit(
+                event, data, namespace=namespace, room=room, skip_sid=skip_sid,
+                callback=callback)
+        namespace = namespace or '/'
+        if callback is not None:
+            if self.server is None:
+                raise RuntimeError('Callbacks can only be issued from the '
+                                   'context of a server.')
+            if room is None:
+                raise ValueError('Cannot use callback without a room set.')
+            id = self._generate_ack_id(room, callback)
+            callback = (room, namespace, id)
+        else:
+            callback = None
+        self._publish({'method': 'emit', 'event': event, 'data': data,
+                       'namespace': namespace, 'room': room,
+                       'skip_sid': skip_sid, 'callback': callback,
+                       'host_id': self.host_id})
+
+    def can_disconnect(self, sid, namespace):
+        if self.is_connected(sid, namespace):
+            # client is in this server, so we can disconnect directly
+            return super().can_disconnect(sid, namespace)
+        else:
+            # client is in another server, so we post request to the queue
+            self._publish({'method': 'disconnect', 'sid': sid,
+                           'namespace': namespace or '/'})
+
+    def disconnect(self, sid, namespace=None, **kwargs):
+        if kwargs.get('ignore_queue'):
+            return super(PubSubManager, self).disconnect(
+                sid, namespace=namespace)
+        self._publish({'method': 'disconnect', 'sid': sid,
+                       'namespace': namespace or '/'})
+
+    def close_room(self, room, namespace=None):
+        self._publish({'method': 'close_room', 'room': room,
+                       'namespace': namespace or '/'})
+
+    def _publish(self, data):
+        """Publish a message on the Socket.IO channel.
+
+        This method needs to be implemented by the different subclasses that
+        support pub/sub backends.
+        """
+        raise NotImplementedError('This method must be implemented in a '
+                                  'subclass.')  # pragma: no cover
+
+    def _listen(self):
+        """Return the next message published on the Socket.IO channel,
+        blocking until a message is available.
+
+        This method needs to be implemented by the different subclasses that
+        support pub/sub backends.
+        """
+        raise NotImplementedError('This method must be implemented in a '
+                                  'subclass.')  # pragma: no cover
+
+    def _handle_emit(self, message):
+        # Events with callbacks are very tricky to handle across hosts
+        # Here in the receiving end we set up a local callback that preserves
+        # the callback host and id from the sender
+        remote_callback = message.get('callback')
+        remote_host_id = message.get('host_id')
+        if remote_callback is not None and len(remote_callback) == 3:
+            callback = partial(self._return_callback, remote_host_id,
+                               *remote_callback)
+        else:
+            callback = None
+        super(PubSubManager, self).emit(message['event'], message['data'],
+                                        namespace=message.get('namespace'),
+                                        room=message.get('room'),
+                                        skip_sid=message.get('skip_sid'),
+                                        callback=callback)
+
+    def _handle_callback(self, message):
+        if self.host_id == message.get('host_id'):
+            try:
+                sid = message['sid']
+                id = message['id']
+                args = message['args']
+            except KeyError:
+                return
+            self.trigger_callback(sid, id, args)
+
+    def _return_callback(self, host_id, sid, namespace, callback_id, *args):
+        # When an event callback is received, the callback is returned back
+        # to the sender, which is identified by the host_id
+        self._publish({'method': 'callback', 'host_id': host_id,
+                       'sid': sid, 'namespace': namespace, 'id': callback_id,
+                       'args': args})
+
+    def _handle_disconnect(self, message):
+        self.server.disconnect(sid=message.get('sid'),
+                               namespace=message.get('namespace'),
+                               ignore_queue=True)
+
+    def _handle_close_room(self, message):
+        super(PubSubManager, self).close_room(
+            room=message.get('room'), namespace=message.get('namespace'))
+
+    def _thread(self):
+        for message in self._listen():
+            data = None
+            if isinstance(message, dict):
+                data = message
+            else:
+                if isinstance(message, bytes):  # pragma: no cover
+                    try:
+                        data = pickle.loads(message)
+                    except:
+                        pass
+                if data is None:
+                    try:
+                        data = json.loads(message)
+                    except:
+                        pass
+            if data and 'method' in data:
+                self._get_logger().info('pubsub message: {}'.format(
+                    data['method']))
+                try:
+                    if data['method'] == 'emit':
+                        self._handle_emit(data)
+                    elif data['method'] == 'callback':
+                        self._handle_callback(data)
+                    elif data['method'] == 'disconnect':
+                        self._handle_disconnect(data)
+                    elif data['method'] == 'close_room':
+                        self._handle_close_room(data)
+                except:
+                    self.server.logger.exception(
+                        'Unknown error in pubsub listening thread')

venv/lib/python3.11/site-packages/socketio/redis_manager.py

@@ -0,0 +1,117 @@
+import logging
+import pickle
+import time
+
+try:
+    import redis
+except ImportError:
+    redis = None
+
+from .pubsub_manager import PubSubManager
+
+logger = logging.getLogger('socketio')
+
+
+class RedisManager(PubSubManager):  # pragma: no cover
+    """Redis based client manager.
+
+    This class implements a Redis backend for event sharing across multiple
+    processes. Only kept here as one more example of how to build a custom
+    backend, since the kombu backend is perfectly adequate to support a Redis
+    message queue.
+
+    To use a Redis backend, initialize the :class:`Server` instance as
+    follows::
+
+        url = 'redis://hostname:port/0'
+        server = socketio.Server(client_manager=socketio.RedisManager(url))
+
+    :param url: The connection URL for the Redis server. For a default Redis
+                store running on the same host, use ``redis://``.  To use an
+                SSL connection, use ``rediss://``.
+    :param channel: The channel name on which the server sends and receives
+                    notifications. Must be the same in all the servers.
+    :param write_only: If set to ``True``, only initialize to emit events. The
+                       default of ``False`` initializes the class for emitting
+                       and receiving.
+    :param redis_options: additional keyword arguments to be passed to
+                          ``Redis.from_url()``.
+    """
+    name = 'redis'
+
+    def __init__(self, url='redis://localhost:6379/0', channel='socketio',
+                 write_only=False, logger=None, redis_options=None):
+        if redis is None:
+            raise RuntimeError('Redis package is not installed '
+                               '(Run "pip install redis" in your '
+                               'virtualenv).')
+        self.redis_url = url
+        self.redis_options = redis_options or {}
+        self._redis_connect()
+        super(RedisManager, self).__init__(channel=channel,
+                                           write_only=write_only,
+                                           logger=logger)
+
+    def initialize(self):
+        super(RedisManager, self).initialize()
+
+        monkey_patched = True
+        if self.server.async_mode == 'eventlet':
+            from eventlet.patcher import is_monkey_patched
+            monkey_patched = is_monkey_patched('socket')
+        elif 'gevent' in self.server.async_mode:
+            from gevent.monkey import is_module_patched
+            monkey_patched = is_module_patched('socket')
+        if not monkey_patched:
+            raise RuntimeError(
+                'Redis requires a monkey patched socket library to work '
+                'with ' + self.server.async_mode)
+
+    def _redis_connect(self):
+        self.redis = redis.Redis.from_url(self.redis_url,
+                                          **self.redis_options)
+        self.pubsub = self.redis.pubsub(ignore_subscribe_messages=True)
+
+    def _publish(self, data):
+        retry = True
+        while True:
+            try:
+                if not retry:
+                    self._redis_connect()
+                return self.redis.publish(self.channel, pickle.dumps(data))
+            except redis.exceptions.RedisError:
+                if retry:
+                    logger.error('Cannot publish to redis... retrying')
+                    retry = False
+                else:
+                    logger.error('Cannot publish to redis... giving up')
+                    break
+
+    def _redis_listen_with_retries(self):
+        retry_sleep = 1
+        connect = False
+        while True:
+            try:
+                if connect:
+                    self._redis_connect()
+                    self.pubsub.subscribe(self.channel)
+                    retry_sleep = 1
+                for message in self.pubsub.listen():
+                    yield message
+            except redis.exceptions.RedisError:
+                logger.error('Cannot receive from redis... '
+                             'retrying in {} secs'.format(retry_sleep))
+                connect = True
+                time.sleep(retry_sleep)
+                retry_sleep *= 2
+                if retry_sleep > 60:
+                    retry_sleep = 60
+
+    def _listen(self):
+        channel = self.channel.encode('utf-8')
+        self.pubsub.subscribe(self.channel)
+        for message in self._redis_listen_with_retries():
+            if message['channel'] == channel and \
+                    message['type'] == 'message' and 'data' in message:
+                yield message['data']
+        self.pubsub.unsubscribe(self.channel)

venv/lib/python3.11/site-packages/socketio/server.py

@@ -0,0 +1,814 @@
+import logging
+
+import engineio
+
+from . import base_manager
+from . import exceptions
+from . import namespace
+from . import packet
+
+default_logger = logging.getLogger('socketio.server')
+
+
+class Server(object):
+    """A Socket.IO server.
+
+    This class implements a fully compliant Socket.IO web server with support
+    for websocket and long-polling transports.
+
+    :param client_manager: The client manager instance that will manage the
+                           client list. When this is omitted, the client list
+                           is stored in an in-memory structure, so the use of
+                           multiple connected servers is not possible.
+    :param logger: To enable logging set to ``True`` or pass a logger object to
+                   use. To disable logging set to ``False``. The default is
+                   ``False``. Note that fatal errors are logged even when
+                   ``logger`` is ``False``.
+    :param serializer: The serialization method to use when transmitting
+                       packets. Valid values are ``'default'``, ``'pickle'``,
+                       ``'msgpack'`` and ``'cbor'``. Alternatively, a subclass
+                       of the :class:`Packet` class with custom implementations
+                       of the ``encode()`` and ``decode()`` methods can be
+                       provided. Client and server must use compatible
+                       serializers.
+    :param json: An alternative json module to use for encoding and decoding
+                 packets. Custom json modules must have ``dumps`` and ``loads``
+                 functions that are compatible with the standard library
+                 versions.
+    :param async_handlers: If set to ``True``, event handlers for a client are
+                           executed in separate threads. To run handlers for a
+                           client synchronously, set to ``False``. The default
+                           is ``True``.
+    :param always_connect: When set to ``False``, new connections are
+                           provisory until the connect handler returns
+                           something other than ``False``, at which point they
+                           are accepted. When set to ``True``, connections are
+                           immediately accepted, and then if the connect
+                           handler returns ``False`` a disconnect is issued.
+                           Set to ``True`` if you need to emit events from the
+                           connect handler and your client is confused when it
+                           receives events before the connection acceptance.
+                           In any other case use the default of ``False``.
+    :param namespaces: a list of namespaces that are accepted, in addition to
+                       any namespaces for which handlers have been defined. The
+                       default is `['/']`, which always accepts connections to
+                       the default namespace. Set to `'*'` to accept all
+                       namespaces.
+    :param kwargs: Connection parameters for the underlying Engine.IO server.
+
+    The Engine.IO configuration supports the following settings:
+
+    :param async_mode: The asynchronous model to use. See the Deployment
+                       section in the documentation for a description of the
+                       available options. Valid async modes are
+                       ``'threading'``, ``'eventlet'``, ``'gevent'`` and
+                       ``'gevent_uwsgi'``. If this argument is not given,
+                       ``'eventlet'`` is tried first, then ``'gevent_uwsgi'``,
+                       then ``'gevent'``, and finally ``'threading'``.
+                       The first async mode that has all its dependencies
+                       installed is then one that is chosen.
+    :param ping_interval: The interval in seconds at which the server pings
+                          the client. The default is 25 seconds. For advanced
+                          control, a two element tuple can be given, where
+                          the first number is the ping interval and the second
+                          is a grace period added by the server.
+    :param ping_timeout: The time in seconds that the client waits for the
+                         server to respond before disconnecting. The default
+                         is 5 seconds.
+    :param max_http_buffer_size: The maximum size of a message when using the
+                                 polling transport. The default is 1,000,000
+                                 bytes.
+    :param allow_upgrades: Whether to allow transport upgrades or not. The
+                           default is ``True``.
+    :param http_compression: Whether to compress packages when using the
+                             polling transport. The default is ``True``.
+    :param compression_threshold: Only compress messages when their byte size
+                                  is greater than this value. The default is
+                                  1024 bytes.
+    :param cookie: If set to a string, it is the name of the HTTP cookie the
+                   server sends back tot he client containing the client
+                   session id. If set to a dictionary, the ``'name'`` key
+                   contains the cookie name and other keys define cookie
+                   attributes, where the value of each attribute can be a
+                   string, a callable with no arguments, or a boolean. If set
+                   to ``None`` (the default), a cookie is not sent to the
+                   client.
+    :param cors_allowed_origins: Origin or list of origins that are allowed to
+                                 connect to this server. Only the same origin
+                                 is allowed by default. Set this argument to
+                                 ``'*'`` to allow all origins, or to ``[]`` to
+                                 disable CORS handling.
+    :param cors_credentials: Whether credentials (cookies, authentication) are
+                             allowed in requests to this server. The default is
+                             ``True``.
+    :param monitor_clients: If set to ``True``, a background task will ensure
+                            inactive clients are closed. Set to ``False`` to
+                            disable the monitoring task (not recommended). The
+                            default is ``True``.
+    :param engineio_logger: To enable Engine.IO logging set to ``True`` or pass
+                            a logger object to use. To disable logging set to
+                            ``False``. The default is ``False``. Note that
+                            fatal errors are logged even when
+                            ``engineio_logger`` is ``False``.
+    """
+    reserved_events = ['connect', 'disconnect']
+
+    def __init__(self, client_manager=None, logger=False, serializer='default',
+                 json=None, async_handlers=True, always_connect=False,
+                 namespaces=None, **kwargs):
+        engineio_options = kwargs
+        engineio_logger = engineio_options.pop('engineio_logger', None)
+        if engineio_logger is not None:
+            engineio_options['logger'] = engineio_logger
+        if serializer == 'default':
+            self.packet_class = packet.Packet
+        elif serializer == 'msgpack':
+            from . import msgpack_packet
+            self.packet_class = msgpack_packet.MsgPackPacket
+        else:
+            self.packet_class = serializer
+        if json is not None:
+            self.packet_class.json = json
+            engineio_options['json'] = json
+        engineio_options['async_handlers'] = False
+        self.eio = self._engineio_server_class()(**engineio_options)
+        self.eio.on('connect', self._handle_eio_connect)
+        self.eio.on('message', self._handle_eio_message)
+        self.eio.on('disconnect', self._handle_eio_disconnect)
+
+        self.environ = {}
+        self.handlers = {}
+        self.namespace_handlers = {}
+        self.not_handled = object()
+
+        self._binary_packet = {}
+
+        if not isinstance(logger, bool):
+            self.logger = logger
+        else:
+            self.logger = default_logger
+            if self.logger.level == logging.NOTSET:
+                if logger:
+                    self.logger.setLevel(logging.INFO)
+                else:
+                    self.logger.setLevel(logging.ERROR)
+                self.logger.addHandler(logging.StreamHandler())
+
+        if client_manager is None:
+            client_manager = base_manager.BaseManager()
+        self.manager = client_manager
+        self.manager.set_server(self)
+        self.manager_initialized = False
+
+        self.async_handlers = async_handlers
+        self.always_connect = always_connect
+        self.namespaces = namespaces or ['/']
+
+        self.async_mode = self.eio.async_mode
+
+    def is_asyncio_based(self):
+        return False
+
+    def on(self, event, handler=None, namespace=None):
+        """Register an event handler.
+
+        :param event: The event name. It can be any string. The event names
+                      ``'connect'``, ``'message'`` and ``'disconnect'`` are
+                      reserved and should not be used.
+        :param handler: The function that should be invoked to handle the
+                        event. When this parameter is not given, the method
+                        acts as a decorator for the handler function.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the handler is associated with
+                          the default namespace.
+
+        Example usage::
+
+            # as a decorator:
+            @socket_io.on('connect', namespace='/chat')
+            def connect_handler(sid, environ):
+                print('Connection request')
+                if environ['REMOTE_ADDR'] in blacklisted:
+                    return False  # reject
+
+            # as a method:
+            def message_handler(sid, msg):
+                print('Received message: ', msg)
+                eio.send(sid, 'response')
+            socket_io.on('message', namespace='/chat', handler=message_handler)
+
+        The handler function receives the ``sid`` (session ID) for the
+        client as first argument. The ``'connect'`` event handler receives the
+        WSGI environment as a second argument, and can return ``False`` to
+        reject the connection. The ``'message'`` handler and handlers for
+        custom event names receive the message payload as a second argument.
+        Any values returned from a message handler will be passed to the
+        client's acknowledgement callback function if it exists. The
+        ``'disconnect'`` handler does not take a second argument.
+        """
+        namespace = namespace or '/'
+
+        def set_handler(handler):
+            if namespace not in self.handlers:
+                self.handlers[namespace] = {}
+            self.handlers[namespace][event] = handler
+            return handler
+
+        if handler is None:
+            return set_handler
+        set_handler(handler)
+
+    def event(self, *args, **kwargs):
+        """Decorator to register an event handler.
+
+        This is a simplified version of the ``on()`` method that takes the
+        event name from the decorated function.
+
+        Example usage::
+
+            @sio.event
+            def my_event(data):
+                print('Received data: ', data)
+
+        The above example is equivalent to::
+
+            @sio.on('my_event')
+            def my_event(data):
+                print('Received data: ', data)
+
+        A custom namespace can be given as an argument to the decorator::
+
+            @sio.event(namespace='/test')
+            def my_event(data):
+                print('Received data: ', data)
+        """
+        if len(args) == 1 and len(kwargs) == 0 and callable(args[0]):
+            # the decorator was invoked without arguments
+            # args[0] is the decorated function
+            return self.on(args[0].__name__)(args[0])
+        else:
+            # the decorator was invoked with arguments
+            def set_handler(handler):
+                return self.on(handler.__name__, *args, **kwargs)(handler)
+
+            return set_handler
+
+    def register_namespace(self, namespace_handler):
+        """Register a namespace handler object.
+
+        :param namespace_handler: An instance of a :class:`Namespace`
+                                  subclass that handles all the event traffic
+                                  for a namespace.
+        """
+        if not isinstance(namespace_handler, namespace.Namespace):
+            raise ValueError('Not a namespace instance')
+        if self.is_asyncio_based() != namespace_handler.is_asyncio_based():
+            raise ValueError('Not a valid namespace class for this server')
+        namespace_handler._set_server(self)
+        self.namespace_handlers[namespace_handler.namespace] = \
+            namespace_handler
+
+    def emit(self, event, data=None, to=None, room=None, skip_sid=None,
+             namespace=None, callback=None, ignore_queue=False):
+        """Emit a custom event to one or more connected clients.
+
+        :param event: The event name. It can be any string. The event names
+                      ``'connect'``, ``'message'`` and ``'disconnect'`` are
+                      reserved and should not be used.
+        :param data: The data to send to the client or clients. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. To send
+                     multiple arguments, use a tuple where each element is of
+                     one of the types indicated above.
+        :param to: The recipient of the message. This can be set to the
+                   session ID of a client to address only that client, to any
+                   custom room created by the application to address all
+                   the clients in that room, or to a list of custom room
+                   names. If this argument is omitted the event is broadcasted
+                   to all connected clients.
+        :param room: Alias for the ``to`` parameter.
+        :param skip_sid: The session ID of a client to skip when broadcasting
+                         to a room or to all clients. This can be used to
+                         prevent a message from being sent to the sender. To
+                         skip multiple sids, pass a list.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param callback: If given, this function will be called to acknowledge
+                         the client has received the message. The arguments
+                         that will be passed to the function are those provided
+                         by the client. Callback functions can only be used
+                         when addressing an individual client.
+        :param ignore_queue: Only used when a message queue is configured. If
+                             set to ``True``, the event is emitted to the
+                             clients directly, without going through the queue.
+                             This is more efficient, but only works when a
+                             single server process is used. It is recommended
+                             to always leave this parameter with its default
+                             value of ``False``.
+
+        Note: this method is not thread safe. If multiple threads are emitting
+        at the same time to the same client, then messages composed of
+        multiple packets may end up being sent in an incorrect sequence. Use
+        standard concurrency solutions (such as a Lock object) to prevent this
+        situation.
+        """
+        namespace = namespace or '/'
+        room = to or room
+        self.logger.info('emitting event "%s" to %s [%s]', event,
+                         room or 'all', namespace)
+        self.manager.emit(event, data, namespace, room=room,
+                          skip_sid=skip_sid, callback=callback,
+                          ignore_queue=ignore_queue)
+
+    def send(self, data, to=None, room=None, skip_sid=None, namespace=None,
+             callback=None, ignore_queue=False):
+        """Send a message to one or more connected clients.
+
+        This function emits an event with the name ``'message'``. Use
+        :func:`emit` to issue custom event names.
+
+        :param data: The data to send to the client or clients. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. To send
+                     multiple arguments, use a tuple where each element is of
+                     one of the types indicated above.
+        :param to: The recipient of the message. This can be set to the
+                   session ID of a client to address only that client, to any
+                   any custom room created by the application to address all
+                   the clients in that room, or to a list of custom room
+                   names. If this argument is omitted the event is broadcasted
+                   to all connected clients.
+        :param room: Alias for the ``to`` parameter.
+        :param skip_sid: The session ID of a client to skip when broadcasting
+                         to a room or to all clients. This can be used to
+                         prevent a message from being sent to the sender. To
+                         skip multiple sids, pass a list.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param callback: If given, this function will be called to acknowledge
+                         the client has received the message. The arguments
+                         that will be passed to the function are those provided
+                         by the client. Callback functions can only be used
+                         when addressing an individual client.
+        :param ignore_queue: Only used when a message queue is configured. If
+                             set to ``True``, the event is emitted to the
+                             clients directly, without going through the queue.
+                             This is more efficient, but only works when a
+                             single server process is used. It is recommended
+                             to always leave this parameter with its default
+                             value of ``False``.
+        """
+        self.emit('message', data=data, to=to, room=room, skip_sid=skip_sid,
+                  namespace=namespace, callback=callback,
+                  ignore_queue=ignore_queue)
+
+    def call(self, event, data=None, to=None, sid=None, namespace=None,
+             timeout=60, ignore_queue=False):
+        """Emit a custom event to a client and wait for the response.
+
+        This method issues an emit with a callback and waits for the callback
+        to be invoked before returning. If the callback isn't invoked before
+        the timeout, then a ``TimeoutError`` exception is raised. If the
+        Socket.IO connection drops during the wait, this method still waits
+        until the specified timeout.
+
+        :param event: The event name. It can be any string. The event names
+                      ``'connect'``, ``'message'`` and ``'disconnect'`` are
+                      reserved and should not be used.
+        :param data: The data to send to the client or clients. Data can be of
+                     type ``str``, ``bytes``, ``list`` or ``dict``. To send
+                     multiple arguments, use a tuple where each element is of
+                     one of the types indicated above.
+        :param to: The session ID of the recipient client.
+        :param sid: Alias for the ``to`` parameter.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the event is emitted to the
+                          default namespace.
+        :param timeout: The waiting timeout. If the timeout is reached before
+                        the client acknowledges the event, then a
+                        ``TimeoutError`` exception is raised.
+        :param ignore_queue: Only used when a message queue is configured. If
+                             set to ``True``, the event is emitted to the
+                             client directly, without going through the queue.
+                             This is more efficient, but only works when a
+                             single server process is used. It is recommended
+                             to always leave this parameter with its default
+                             value of ``False``.
+
+        Note: this method is not thread safe. If multiple threads are emitting
+        at the same time to the same client, then messages composed of
+        multiple packets may end up being sent in an incorrect sequence. Use
+        standard concurrency solutions (such as a Lock object) to prevent this
+        situation.
+        """
+        if to is None and sid is None:
+            raise ValueError('Cannot use call() to broadcast.')
+        if not self.async_handlers:
+            raise RuntimeError(
+                'Cannot use call() when async_handlers is False.')
+        callback_event = self.eio.create_event()
+        callback_args = []
+
+        def event_callback(*args):
+            callback_args.append(args)
+            callback_event.set()
+
+        self.emit(event, data=data, room=to or sid, namespace=namespace,
+                  callback=event_callback, ignore_queue=ignore_queue)
+        if not callback_event.wait(timeout=timeout):
+            raise exceptions.TimeoutError()
+        return callback_args[0] if len(callback_args[0]) > 1 \
+            else callback_args[0][0] if len(callback_args[0]) == 1 \
+            else None
+
+    def enter_room(self, sid, room, namespace=None):
+        """Enter a room.
+
+        This function adds the client to a room. The :func:`emit` and
+        :func:`send` functions can optionally broadcast events to all the
+        clients in a room.
+
+        :param sid: Session ID of the client.
+        :param room: Room name. If the room does not exist it is created.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the default namespace is used.
+        """
+        namespace = namespace or '/'
+        self.logger.info('%s is entering room %s [%s]', sid, room, namespace)
+        self.manager.enter_room(sid, namespace, room)
+
+    def leave_room(self, sid, room, namespace=None):
+        """Leave a room.
+
+        This function removes the client from a room.
+
+        :param sid: Session ID of the client.
+        :param room: Room name.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the default namespace is used.
+        """
+        namespace = namespace or '/'
+        self.logger.info('%s is leaving room %s [%s]', sid, room, namespace)
+        self.manager.leave_room(sid, namespace, room)
+
+    def close_room(self, room, namespace=None):
+        """Close a room.
+
+        This function removes all the clients from the given room.
+
+        :param room: Room name.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the default namespace is used.
+        """
+        namespace = namespace or '/'
+        self.logger.info('room %s is closing [%s]', room, namespace)
+        self.manager.close_room(room, namespace)
+
+    def rooms(self, sid, namespace=None):
+        """Return the rooms a client is in.
+
+        :param sid: Session ID of the client.
+        :param namespace: The Socket.IO namespace for the event. If this
+                          argument is omitted the default namespace is used.
+        """
+        namespace = namespace or '/'
+        return self.manager.get_rooms(sid, namespace)
+
+    def get_session(self, sid, namespace=None):
+        """Return the user session for a client.
+
+        :param sid: The session id of the client.
+        :param namespace: The Socket.IO namespace. If this argument is omitted
+                          the default namespace is used.
+
+        The return value is a dictionary. Modifications made to this
+        dictionary are not guaranteed to be preserved unless
+        ``save_session()`` is called, or when the ``session`` context manager
+        is used.
+        """
+        namespace = namespace or '/'
+        eio_sid = self.manager.eio_sid_from_sid(sid, namespace)
+        eio_session = self.eio.get_session(eio_sid)
+        return eio_session.setdefault(namespace, {})
+
+    def save_session(self, sid, session, namespace=None):
+        """Store the user session for a client.
+
+        :param sid: The session id of the client.
+        :param session: The session dictionary.
+        :param namespace: The Socket.IO namespace. If this argument is omitted
+                          the default namespace is used.
+        """
+        namespace = namespace or '/'
+        eio_sid = self.manager.eio_sid_from_sid(sid, namespace)
+        eio_session = self.eio.get_session(eio_sid)
+        eio_session[namespace] = session
+
+    def session(self, sid, namespace=None):
+        """Return the user session for a client with context manager syntax.
+
+        :param sid: The session id of the client.
+
+        This is a context manager that returns the user session dictionary for
+        the client. Any changes that are made to this dictionary inside the
+        context manager block are saved back to the session. Example usage::
+
+            @sio.on('connect')
+            def on_connect(sid, environ):
+                username = authenticate_user(environ)
+                if not username:
+                    return False
+                with sio.session(sid) as session:
+                    session['username'] = username
+
+            @sio.on('message')
+            def on_message(sid, msg):
+                with sio.session(sid) as session:
+                    print('received message from ', session['username'])
+        """
+        class _session_context_manager(object):
+            def __init__(self, server, sid, namespace):
+                self.server = server
+                self.sid = sid
+                self.namespace = namespace
+                self.session = None
+
+            def __enter__(self):
+                self.session = self.server.get_session(sid,
+                                                       namespace=namespace)
+                return self.session
+
+            def __exit__(self, *args):
+                self.server.save_session(sid, self.session,
+                                         namespace=namespace)
+
+        return _session_context_manager(self, sid, namespace)
+
+    def disconnect(self, sid, namespace=None, ignore_queue=False):
+        """Disconnect a client.
+
+        :param sid: Session ID of the client.
+        :param namespace: The Socket.IO namespace to disconnect. If this
+                          argument is omitted the default namespace is used.
+        :param ignore_queue: Only used when a message queue is configured. If
+                             set to ``True``, the disconnect is processed
+                             locally, without broadcasting on the queue. It is
+                             recommended to always leave this parameter with
+                             its default value of ``False``.
+        """
+        namespace = namespace or '/'
+        if ignore_queue:
+            delete_it = self.manager.is_connected(sid, namespace)
+        else:
+            delete_it = self.manager.can_disconnect(sid, namespace)
+        if delete_it:
+            self.logger.info('Disconnecting %s [%s]', sid, namespace)
+            eio_sid = self.manager.pre_disconnect(sid, namespace=namespace)
+            self._send_packet(eio_sid, self.packet_class(
+                packet.DISCONNECT, namespace=namespace))
+            self._trigger_event('disconnect', namespace, sid)
+            self.manager.disconnect(sid, namespace=namespace,
+                                    ignore_queue=True)
+
+    def transport(self, sid):
+        """Return the name of the transport used by the client.
+
+        The two possible values returned by this function are ``'polling'``
+        and ``'websocket'``.
+
+        :param sid: The session of the client.
+        """
+        return self.eio.transport(sid)
+
+    def get_environ(self, sid, namespace=None):
+        """Return the WSGI environ dictionary for a client.
+
+        :param sid: The session of the client.
+        :param namespace: The Socket.IO namespace. If this argument is omitted
+                          the default namespace is used.
+        """
+        eio_sid = self.manager.eio_sid_from_sid(sid, namespace or '/')
+        return self.environ.get(eio_sid)
+
+    def handle_request(self, environ, start_response):
+        """Handle an HTTP request from the client.
+
+        This is the entry point of the Socket.IO application, using the same
+        interface as a WSGI application. For the typical usage, this function
+        is invoked by the :class:`Middleware` instance, but it can be invoked
+        directly when the middleware is not used.
+
+        :param environ: The WSGI environment.
+        :param start_response: The WSGI ``start_response`` function.
+
+        This function returns the HTTP response body to deliver to the client
+        as a byte sequence.
+        """
+        return self.eio.handle_request(environ, start_response)
+
+    def start_background_task(self, target, *args, **kwargs):
+        """Start a background task using the appropriate async model.
+
+        This is a utility function that applications can use to start a
+        background task using the method that is compatible with the
+        selected async mode.
+
+        :param target: the target function to execute.
+        :param args: arguments to pass to the function.
+        :param kwargs: keyword arguments to pass to the function.
+
+        This function returns an object that represents the background task,
+        on which the ``join()`` methond can be invoked to wait for the task to
+        complete.
+        """
+        return self.eio.start_background_task(target, *args, **kwargs)
+
+    def sleep(self, seconds=0):
+        """Sleep for the requested amount of time using the appropriate async
+        model.
+
+        This is a utility function that applications can use to put a task to
+        sleep without having to worry about using the correct call for the
+        selected async mode.
+        """
+        return self.eio.sleep(seconds)
+
+    def _emit_internal(self, eio_sid, event, data, namespace=None, id=None):
+        """Send a message to a client."""
+        # tuples are expanded to multiple arguments, everything else is sent
+        # as a single argument
+        if isinstance(data, tuple):
+            data = list(data)
+        elif data is not None:
+            data = [data]
+        else:
+            data = []
+        self._send_packet(eio_sid, self.packet_class(
+            packet.EVENT, namespace=namespace, data=[event] + data, id=id))
+
+    def _send_packet(self, eio_sid, pkt):
+        """Send a Socket.IO packet to a client."""
+        encoded_packet = pkt.encode()
+        if isinstance(encoded_packet, list):
+            for ep in encoded_packet:
+                self.eio.send(eio_sid, ep)
+        else:
+            self.eio.send(eio_sid, encoded_packet)
+
+    def _handle_connect(self, eio_sid, namespace, data):
+        """Handle a client connection request."""
+        namespace = namespace or '/'
+        sid = None
+        if namespace in self.handlers or namespace in self.namespace_handlers \
+                or self.namespaces == '*' or namespace in self.namespaces:
+            sid = self.manager.connect(eio_sid, namespace)
+        if sid is None:
+            self._send_packet(eio_sid, self.packet_class(
+                packet.CONNECT_ERROR, data='Unable to connect',
+                namespace=namespace))
+            return
+
+        if self.always_connect:
+            self._send_packet(eio_sid, self.packet_class(
+                packet.CONNECT, {'sid': sid}, namespace=namespace))
+        fail_reason = exceptions.ConnectionRefusedError().error_args
+        try:
+            if data:
+                success = self._trigger_event(
+                    'connect', namespace, sid, self.environ[eio_sid], data)
+            else:
+                try:
+                    success = self._trigger_event(
+                        'connect', namespace, sid, self.environ[eio_sid])
+                except TypeError:
+                    success = self._trigger_event(
+                        'connect', namespace, sid, self.environ[eio_sid], None)
+        except exceptions.ConnectionRefusedError as exc:
+            fail_reason = exc.error_args
+            success = False
+
+        if success is False:
+            if self.always_connect:
+                self.manager.pre_disconnect(sid, namespace)
+                self._send_packet(eio_sid, self.packet_class(
+                    packet.DISCONNECT, data=fail_reason, namespace=namespace))
+            else:
+                self._send_packet(eio_sid, self.packet_class(
+                    packet.CONNECT_ERROR, data=fail_reason,
+                    namespace=namespace))
+            self.manager.disconnect(sid, namespace, ignore_queue=True)
+        elif not self.always_connect:
+            self._send_packet(eio_sid, self.packet_class(
+                packet.CONNECT, {'sid': sid}, namespace=namespace))
+
+    def _handle_disconnect(self, eio_sid, namespace):
+        """Handle a client disconnect."""
+        namespace = namespace or '/'
+        sid = self.manager.sid_from_eio_sid(eio_sid, namespace)
+        if not self.manager.is_connected(sid, namespace):  # pragma: no cover
+            return
+        self.manager.pre_disconnect(sid, namespace=namespace)
+        self._trigger_event('disconnect', namespace, sid)
+        self.manager.disconnect(sid, namespace, ignore_queue=True)
+
+    def _handle_event(self, eio_sid, namespace, id, data):
+        """Handle an incoming client event."""
+        namespace = namespace or '/'
+        sid = self.manager.sid_from_eio_sid(eio_sid, namespace)
+        self.logger.info('received event "%s" from %s [%s]', data[0], sid,
+                         namespace)
+        if not self.manager.is_connected(sid, namespace):
+            self.logger.warning('%s is not connected to namespace %s',
+                                sid, namespace)
+            return
+        if self.async_handlers:
+            self.start_background_task(self._handle_event_internal, self, sid,
+                                       eio_sid, data, namespace, id)
+        else:
+            self._handle_event_internal(self, sid, eio_sid, data, namespace,
+                                        id)
+
+    def _handle_event_internal(self, server, sid, eio_sid, data, namespace,
+                               id):
+        r = server._trigger_event(data[0], namespace, sid, *data[1:])
+        if r != self.not_handled and id is not None:
+            # send ACK packet with the response returned by the handler
+            # tuples are expanded as multiple arguments
+            if r is None:
+                data = []
+            elif isinstance(r, tuple):
+                data = list(r)
+            else:
+                data = [r]
+            server._send_packet(eio_sid, self.packet_class(
+                packet.ACK, namespace=namespace, id=id, data=data))
+
+    def _handle_ack(self, eio_sid, namespace, id, data):
+        """Handle ACK packets from the client."""
+        namespace = namespace or '/'
+        sid = self.manager.sid_from_eio_sid(eio_sid, namespace)
+        self.logger.info('received ack from %s [%s]', sid, namespace)
+        self.manager.trigger_callback(sid, id, data)
+
+    def _trigger_event(self, event, namespace, *args):
+        """Invoke an application event handler."""
+        # first see if we have an explicit handler for the event
+        if namespace in self.handlers:
+            if event in self.handlers[namespace]:
+                return self.handlers[namespace][event](*args)
+            elif event not in self.reserved_events and \
+                    '*' in self.handlers[namespace]:
+                return self.handlers[namespace]['*'](event, *args)
+            else:
+                return self.not_handled
+
+        # or else, forward the event to a namespace handler if one exists
+        elif namespace in self.namespace_handlers:  # pragma: no branch
+            return self.namespace_handlers[namespace].trigger_event(
+                event, *args)
+
+    def _handle_eio_connect(self, eio_sid, environ):
+        """Handle the Engine.IO connection event."""
+        if not self.manager_initialized:
+            self.manager_initialized = True
+            self.manager.initialize()
+        self.environ[eio_sid] = environ
+
+    def _handle_eio_message(self, eio_sid, data):
+        """Dispatch Engine.IO messages."""
+        if eio_sid in self._binary_packet:
+            pkt = self._binary_packet[eio_sid]
+            if pkt.add_attachment(data):
+                del self._binary_packet[eio_sid]
+                if pkt.packet_type == packet.BINARY_EVENT:
+                    self._handle_event(eio_sid, pkt.namespace, pkt.id,
+                                       pkt.data)
+                else:
+                    self._handle_ack(eio_sid, pkt.namespace, pkt.id, pkt.data)
+        else:
+            pkt = self.packet_class(encoded_packet=data)
+            if pkt.packet_type == packet.CONNECT:
+                self._handle_connect(eio_sid, pkt.namespace, pkt.data)
+            elif pkt.packet_type == packet.DISCONNECT:
+                self._handle_disconnect(eio_sid, pkt.namespace)
+            elif pkt.packet_type == packet.EVENT:
+                self._handle_event(eio_sid, pkt.namespace, pkt.id, pkt.data)
+            elif pkt.packet_type == packet.ACK:
+                self._handle_ack(eio_sid, pkt.namespace, pkt.id, pkt.data)
+            elif pkt.packet_type == packet.BINARY_EVENT or \
+                    pkt.packet_type == packet.BINARY_ACK:
+                self._binary_packet[eio_sid] = pkt
+            elif pkt.packet_type == packet.CONNECT_ERROR:
+                raise ValueError('Unexpected CONNECT_ERROR packet.')
+            else:
+                raise ValueError('Unknown packet type.')
+
+    def _handle_eio_disconnect(self, eio_sid):
+        """Handle Engine.IO disconnect event."""
+        for n in list(self.manager.get_namespaces()).copy():
+            self._handle_disconnect(eio_sid, n)
+        if eio_sid in self.environ:
+            del self.environ[eio_sid]
+
+    def _engineio_server_class(self):
+        return engineio.Server

venv/lib/python3.11/site-packages/socketio/tornado.py

@@ -0,0 +1,11 @@
+import sys
+if sys.version_info >= (3, 5):
+    try:
+        from engineio.async_drivers.tornado import get_tornado_handler as \
+            get_engineio_handler
+    except ImportError:  # pragma: no cover
+        get_engineio_handler = None
+
+
+def get_tornado_handler(socketio_server):  # pragma: no cover
+    return get_engineio_handler(socketio_server.eio)

venv/lib/python3.11/site-packages/socketio/zmq_manager.py

@@ -0,0 +1,107 @@
+import pickle
+import re
+
+from .pubsub_manager import PubSubManager
+
+
+class ZmqManager(PubSubManager):  # pragma: no cover
+    """zmq based client manager.
+
+    NOTE: this zmq implementation should be considered experimental at this
+    time. At this time, eventlet is required to use zmq.
+
+    This class implements a zmq backend for event sharing across multiple
+    processes. To use a zmq backend, initialize the :class:`Server` instance as
+    follows::
+
+        url = 'zmq+tcp://hostname:port1+port2'
+        server = socketio.Server(client_manager=socketio.ZmqManager(url))
+
+    :param url: The connection URL for the zmq message broker,
+                which will need to be provided and running.
+    :param channel: The channel name on which the server sends and receives
+                    notifications. Must be the same in all the servers.
+    :param write_only: If set to ``True``, only initialize to emit events. The
+                       default of ``False`` initializes the class for emitting
+                       and receiving.
+
+    A zmq message broker must be running for the zmq_manager to work.
+    you can write your own or adapt one from the following simple broker
+    below::
+
+        import zmq
+
+        receiver = zmq.Context().socket(zmq.PULL)
+        receiver.bind("tcp://*:5555")
+
+        publisher = zmq.Context().socket(zmq.PUB)
+        publisher.bind("tcp://*:5556")
+
+        while True:
+            publisher.send(receiver.recv())
+    """
+    name = 'zmq'
+
+    def __init__(self, url='zmq+tcp://localhost:5555+5556',
+                 channel='socketio',
+                 write_only=False,
+                 logger=None):
+        try:
+            from eventlet.green import zmq
+        except ImportError:
+            raise RuntimeError('zmq package is not installed '
+                               '(Run "pip install pyzmq" in your '
+                               'virtualenv).')
+
+        r = re.compile(r':\d+\+\d+$')
+        if not (url.startswith('zmq+tcp://') and r.search(url)):
+            raise RuntimeError('unexpected connection string: ' + url)
+
+        url = url.replace('zmq+', '')
+        (sink_url, sub_port) = url.split('+')
+        sink_port = sink_url.split(':')[-1]
+        sub_url = sink_url.replace(sink_port, sub_port)
+
+        sink = zmq.Context().socket(zmq.PUSH)
+        sink.connect(sink_url)
+
+        sub = zmq.Context().socket(zmq.SUB)
+        sub.setsockopt_string(zmq.SUBSCRIBE, u'')
+        sub.connect(sub_url)
+
+        self.sink = sink
+        self.sub = sub
+        self.channel = channel
+        super(ZmqManager, self).__init__(channel=channel,
+                                         write_only=write_only,
+                                         logger=logger)
+
+    def _publish(self, data):
+        pickled_data = pickle.dumps(
+            {
+                'type': 'message',
+                'channel': self.channel,
+                'data': data
+            }
+        )
+        return self.sink.send(pickled_data)
+
+    def zmq_listen(self):
+        while True:
+            response = self.sub.recv()
+            if response is not None:
+                yield response
+
+    def _listen(self):
+        for message in self.zmq_listen():
+            if isinstance(message, bytes):
+                try:
+                    message = pickle.loads(message)
+                except Exception:
+                    pass
+            if isinstance(message, dict) and \
+                    message['type'] == 'message' and \
+                    message['channel'] == self.channel and \
+                    'data' in message:
+                yield message['data']
+        return