hm

venv/lib/python3.12/site-packages/engineio/async_drivers/_websocket_wsgi.py

@@ -0,0 +1,34 @@
+import simple_websocket
+
+
+class SimpleWebSocketWSGI:  # pragma: no cover
+    """
+    This wrapper class provides a threading WebSocket interface that is
+    compatible with eventlet's implementation.
+    """
+    def __init__(self, handler, server, **kwargs):
+        self.app = handler
+        self.server_args = kwargs
+
+    def __call__(self, environ, start_response):
+        self.ws = simple_websocket.Server(environ, **self.server_args)
+        ret = self.app(self)
+        if self.ws.mode == 'gunicorn':
+            raise StopIteration()
+        return ret
+
+    def close(self):
+        if self.ws.connected:
+            self.ws.close()
+
+    def send(self, message):
+        try:
+            return self.ws.send(message)
+        except simple_websocket.ConnectionClosed:
+            raise OSError()
+
+    def wait(self):
+        try:
+            return self.ws.receive()
+        except simple_websocket.ConnectionClosed:
+            return None

venv/lib/python3.12/site-packages/engineio/async_drivers/aiohttp.py

@@ -0,0 +1,127 @@
+import asyncio
+import sys
+from urllib.parse import urlsplit
+
+from aiohttp.web import Response, WebSocketResponse
+
+
+def create_route(app, engineio_server, engineio_endpoint):
+    """This function sets up the engine.io endpoint as a route for the
+    application.
+
+    Note that both GET and POST requests must be hooked up on the engine.io
+    endpoint.
+    """
+    app.router.add_get(engineio_endpoint, engineio_server.handle_request)
+    app.router.add_post(engineio_endpoint, engineio_server.handle_request)
+    app.router.add_route('OPTIONS', engineio_endpoint,
+                         engineio_server.handle_request)
+
+
+def translate_request(request):
+    """This function takes the arguments passed to the request handler and
+    uses them to generate a WSGI compatible environ dictionary.
+    """
+    message = request._message
+    payload = request._payload
+
+    uri_parts = urlsplit(message.path)
+    environ = {
+        'wsgi.input': payload,
+        'wsgi.errors': sys.stderr,
+        'wsgi.version': (1, 0),
+        'wsgi.async': True,
+        'wsgi.multithread': False,
+        'wsgi.multiprocess': False,
+        'wsgi.run_once': False,
+        'SERVER_SOFTWARE': 'aiohttp',
+        'REQUEST_METHOD': message.method,
+        'QUERY_STRING': uri_parts.query or '',
+        'RAW_URI': message.path,
+        'SERVER_PROTOCOL': 'HTTP/%s.%s' % message.version,
+        'REMOTE_ADDR': '127.0.0.1',
+        'REMOTE_PORT': '0',
+        'SERVER_NAME': 'aiohttp',
+        'SERVER_PORT': '0',
+        'aiohttp.request': request
+    }
+
+    for hdr_name, hdr_value in message.headers.items():
+        hdr_name = hdr_name.upper()
+        if hdr_name == 'CONTENT-TYPE':
+            environ['CONTENT_TYPE'] = hdr_value
+            continue
+        elif hdr_name == 'CONTENT-LENGTH':
+            environ['CONTENT_LENGTH'] = hdr_value
+            continue
+
+        key = 'HTTP_%s' % hdr_name.replace('-', '_')
+        if key in environ:
+            hdr_value = f'{environ[key]},{hdr_value}'
+
+        environ[key] = hdr_value
+
+    environ['wsgi.url_scheme'] = environ.get('HTTP_X_FORWARDED_PROTO', 'http')
+
+    path_info = uri_parts.path
+
+    environ['PATH_INFO'] = path_info
+    environ['SCRIPT_NAME'] = ''
+
+    return environ
+
+
+def make_response(status, headers, payload, environ):
+    """This function generates an appropriate response object for this async
+    mode.
+    """
+    return Response(body=payload, status=int(status.split()[0]),
+                    headers=headers)
+
+
+class WebSocket:  # pragma: no cover
+    """
+    This wrapper class provides a aiohttp WebSocket interface that is
+    somewhat compatible with eventlet's implementation.
+    """
+    def __init__(self, handler, server):
+        self.handler = handler
+        self._sock = None
+
+    async def __call__(self, environ):
+        request = environ['aiohttp.request']
+        self._sock = WebSocketResponse(max_msg_size=0)
+        await self._sock.prepare(request)
+
+        self.environ = environ
+        await self.handler(self)
+        return self._sock
+
+    async def close(self):
+        await self._sock.close()
+
+    async def send(self, message):
+        if isinstance(message, bytes):
+            f = self._sock.send_bytes
+        else:
+            f = self._sock.send_str
+        if asyncio.iscoroutinefunction(f):
+            await f(message)
+        else:
+            f(message)
+
+    async def wait(self):
+        msg = await self._sock.receive()
+        if not isinstance(msg.data, bytes) and \
+                not isinstance(msg.data, str):
+            raise OSError()
+        return msg.data
+
+
+_async = {
+    'asyncio': True,
+    'create_route': create_route,
+    'translate_request': translate_request,
+    'make_response': make_response,
+    'websocket': WebSocket,
+}

venv/lib/python3.12/site-packages/engineio/async_drivers/asgi.py

@@ -0,0 +1,296 @@
+import os
+import sys
+import asyncio
+
+from engineio.static_files import get_static_file
+
+
+class ASGIApp:
+    """ASGI application middleware for Engine.IO.
+
+    This middleware dispatches traffic to an Engine.IO application. It can
+    also serve a list of static files to the client, or forward unrelated
+    HTTP traffic to another ASGI application.
+
+    :param engineio_server: The Engine.IO server. Must be an instance of the
+                            ``engineio.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 engineio_path: The endpoint where the Engine.IO application should
+                          be installed. The default value is appropriate for
+                          most cases. With a value of ``None``, all incoming
+                          traffic is directed to the Engine.IO server, with the
+                          assumption that routing, if necessary, is handled by
+                          a different layer. When this option is set to
+                          ``None``, ``static_files`` and ``other_asgi_app`` are
+                          ignored.
+    :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 engineio
+        import uvicorn
+
+        eio = engineio.AsyncServer()
+        app = engineio.ASGIApp(eio, static_files={
+            '/': {'content_type': 'text/html', 'filename': 'index.html'},
+            '/index.html': {'content_type': 'text/html',
+                            'filename': 'index.html'},
+        })
+        uvicorn.run(app, '127.0.0.1', 5000)
+    """
+    def __init__(self, engineio_server, other_asgi_app=None,
+                 static_files=None, engineio_path='engine.io',
+                 on_startup=None, on_shutdown=None):
+        self.engineio_server = engineio_server
+        self.other_asgi_app = other_asgi_app
+        self.engineio_path = engineio_path
+        if self.engineio_path is not None:
+            if not self.engineio_path.startswith('/'):
+                self.engineio_path = '/' + self.engineio_path
+            if not self.engineio_path.endswith('/'):
+                self.engineio_path += '/'
+        self.static_files = static_files or {}
+        self.on_startup = on_startup
+        self.on_shutdown = on_shutdown
+
+    async def __call__(self, scope, receive, send):
+        if scope['type'] == 'lifespan':
+            await self.lifespan(scope, receive, send)
+        elif scope['type'] in ['http', 'websocket'] and (
+                self.engineio_path is None
+                or self._ensure_trailing_slash(scope['path']).startswith(
+                    self.engineio_path)):
+            await self.engineio_server.handle_request(scope, receive, send)
+        else:
+            static_file = get_static_file(scope['path'], self.static_files) \
+                if scope['type'] == 'http' and self.static_files else None
+            if static_file and os.path.exists(static_file['filename']):
+                await self.serve_static_file(static_file, receive, send)
+            elif self.other_asgi_app is not None:
+                await self.other_asgi_app(scope, receive, send)
+            else:
+                await self.not_found(receive, send)
+
+    async def serve_static_file(self, static_file, receive,
+                                send):  # pragma: no cover
+        event = await receive()
+        if event['type'] == 'http.request':
+            with open(static_file['filename'], 'rb') as f:
+                payload = f.read()
+            await send({'type': 'http.response.start',
+                        'status': 200,
+                        'headers': [(b'Content-Type', static_file[
+                            'content_type'].encode('utf-8'))]})
+            await send({'type': 'http.response.body',
+                        'body': payload})
+
+    async def lifespan(self, scope, receive, send):
+        if self.other_asgi_app is not None and self.on_startup is None and \
+                self.on_shutdown is None:
+            # let the other ASGI app handle lifespan events
+            await self.other_asgi_app(scope, receive, send)
+            return
+
+        while True:
+            event = await receive()
+            if event['type'] == 'lifespan.startup':
+                if self.on_startup:
+                    try:
+                        await self.on_startup() \
+                            if asyncio.iscoroutinefunction(self.on_startup) \
+                            else self.on_startup()
+                    except:
+                        await send({'type': 'lifespan.startup.failed'})
+                        return
+                await send({'type': 'lifespan.startup.complete'})
+            elif event['type'] == 'lifespan.shutdown':
+                if self.on_shutdown:
+                    try:
+                        await self.on_shutdown() \
+                            if asyncio.iscoroutinefunction(self.on_shutdown) \
+                            else self.on_shutdown()
+                    except:
+                        await send({'type': 'lifespan.shutdown.failed'})
+                        return
+                await send({'type': 'lifespan.shutdown.complete'})
+                return
+
+    async def not_found(self, receive, send):
+        """Return a 404 Not Found error to the client."""
+        await send({'type': 'http.response.start',
+                    'status': 404,
+                    'headers': [(b'Content-Type', b'text/plain')]})
+        await send({'type': 'http.response.body',
+                    'body': b'Not Found'})
+
+    def _ensure_trailing_slash(self, path):
+        if not path.endswith('/'):
+            path += '/'
+        return path
+
+
+async def translate_request(scope, receive, send):
+    class AwaitablePayload:  # pragma: no cover
+        def __init__(self, payload):
+            self.payload = payload or b''
+
+        async def read(self, length=None):
+            if length is None:
+                r = self.payload
+                self.payload = b''
+            else:
+                r = self.payload[:length]
+                self.payload = self.payload[length:]
+            return r
+
+    event = await receive()
+    payload = b''
+    if event['type'] == 'http.request':
+        payload += event.get('body') or b''
+        while event.get('more_body'):
+            event = await receive()
+            if event['type'] == 'http.request':
+                payload += event.get('body') or b''
+    elif event['type'] == 'websocket.connect':
+        pass
+    else:
+        return {}
+
+    raw_uri = scope['path']
+    query_string = ''
+    if 'query_string' in scope and scope['query_string']:
+        try:
+            query_string = scope['query_string'].decode('utf-8')
+        except UnicodeDecodeError:
+            pass
+        else:
+            raw_uri += '?' + query_string
+    environ = {
+        'wsgi.input': AwaitablePayload(payload),
+        'wsgi.errors': sys.stderr,
+        'wsgi.version': (1, 0),
+        'wsgi.async': True,
+        'wsgi.multithread': False,
+        'wsgi.multiprocess': False,
+        'wsgi.run_once': False,
+        'SERVER_SOFTWARE': 'asgi',
+        'REQUEST_METHOD': scope.get('method', 'GET'),
+        'PATH_INFO': scope['path'],
+        'QUERY_STRING': query_string,
+        'RAW_URI': raw_uri,
+        'SCRIPT_NAME': '',
+        'SERVER_PROTOCOL': 'HTTP/1.1',
+        'REMOTE_ADDR': '127.0.0.1',
+        'REMOTE_PORT': '0',
+        'SERVER_NAME': 'asgi',
+        'SERVER_PORT': '0',
+        'asgi.receive': receive,
+        'asgi.send': send,
+        'asgi.scope': scope,
+    }
+
+    for hdr_name, hdr_value in scope['headers']:
+        try:
+            hdr_name = hdr_name.upper().decode('utf-8')
+            hdr_value = hdr_value.decode('utf-8')
+        except UnicodeDecodeError:
+            # skip header if it cannot be decoded
+            continue
+        if hdr_name == 'CONTENT-TYPE':
+            environ['CONTENT_TYPE'] = hdr_value
+            continue
+        elif hdr_name == 'CONTENT-LENGTH':
+            environ['CONTENT_LENGTH'] = hdr_value
+            continue
+
+        key = 'HTTP_%s' % hdr_name.replace('-', '_')
+        if key in environ:
+            hdr_value = f'{environ[key]},{hdr_value}'
+
+        environ[key] = hdr_value
+
+    environ['wsgi.url_scheme'] = environ.get('HTTP_X_FORWARDED_PROTO', 'http')
+    return environ
+
+
+async def make_response(status, headers, payload, environ):
+    headers = [(h[0].encode('utf-8'), h[1].encode('utf-8')) for h in headers]
+    if environ['asgi.scope']['type'] == 'websocket':
+        if status.startswith('200 '):
+            await environ['asgi.send']({'type': 'websocket.accept',
+                                        'headers': headers})
+        else:
+            if payload:
+                reason = payload.decode('utf-8') \
+                    if isinstance(payload, bytes) else str(payload)
+                await environ['asgi.send']({'type': 'websocket.close',
+                                            'reason': reason})
+            else:
+                await environ['asgi.send']({'type': 'websocket.close'})
+        return
+
+    await environ['asgi.send']({'type': 'http.response.start',
+                                'status': int(status.split(' ')[0]),
+                                'headers': headers})
+    await environ['asgi.send']({'type': 'http.response.body',
+                                'body': payload})
+
+
+class WebSocket:  # pragma: no cover
+    """
+    This wrapper class provides an asgi WebSocket interface that is
+    somewhat compatible with eventlet's implementation.
+    """
+    def __init__(self, handler, server):
+        self.handler = handler
+        self.asgi_receive = None
+        self.asgi_send = None
+
+    async def __call__(self, environ):
+        self.asgi_receive = environ['asgi.receive']
+        self.asgi_send = environ['asgi.send']
+        await self.asgi_send({'type': 'websocket.accept'})
+        await self.handler(self)
+        return ''  # send nothing as response
+
+    async def close(self):
+        try:
+            await self.asgi_send({'type': 'websocket.close'})
+        except Exception:
+            # if the socket is already close we don't care
+            pass
+
+    async def send(self, message):
+        msg_bytes = None
+        msg_text = None
+        if isinstance(message, bytes):
+            msg_bytes = message
+        else:
+            msg_text = message
+        await self.asgi_send({'type': 'websocket.send',
+                              'bytes': msg_bytes,
+                              'text': msg_text})
+
+    async def wait(self):
+        event = await self.asgi_receive()
+        if event['type'] != 'websocket.receive':
+            raise OSError()
+        if event.get('bytes', None) is not None:
+            return event['bytes']
+        elif event.get('text', None) is not None:
+            return event['text']
+        else:  # pragma: no cover
+            raise OSError()
+
+
+_async = {
+    'asyncio': True,
+    'translate_request': translate_request,
+    'make_response': make_response,
+    'websocket': WebSocket,
+}

venv/lib/python3.12/site-packages/engineio/async_drivers/eventlet.py

@@ -0,0 +1,52 @@
+from eventlet.green.threading import Event
+from eventlet import queue, sleep, spawn
+from eventlet.websocket import WebSocketWSGI as _WebSocketWSGI
+
+
+class EventletThread:  # pragma: no cover
+    """Thread class that uses eventlet green threads.
+
+    Eventlet's own Thread class has a strange bug that causes _DummyThread
+    objects to be created and leaked, since they are never garbage collected.
+    """
+    def __init__(self, target, args=None, kwargs=None):
+        self.target = target
+        self.args = args or ()
+        self.kwargs = kwargs or {}
+        self.g = None
+
+    def start(self):
+        self.g = spawn(self.target, *self.args, **self.kwargs)
+
+    def join(self):
+        if self.g:
+            return self.g.wait()
+
+
+class WebSocketWSGI(_WebSocketWSGI):  # pragma: no cover
+    def __init__(self, handler, server):
+        try:
+            super().__init__(
+                handler, max_frame_length=int(server.max_http_buffer_size))
+        except TypeError:  # pragma: no cover
+            # older versions of eventlet do not support a max frame size
+            super().__init__(handler)
+        self._sock = None
+
+    def __call__(self, environ, start_response):
+        if 'eventlet.input' not in environ:
+            raise RuntimeError('You need to use the eventlet server. '
+                               'See the Deployment section of the '
+                               'documentation for more information.')
+        self._sock = environ['eventlet.input'].get_socket()
+        return super().__call__(environ, start_response)
+
+
+_async = {
+    'thread': EventletThread,
+    'queue': queue.Queue,
+    'queue_empty': queue.Empty,
+    'event': Event,
+    'websocket': WebSocketWSGI,
+    'sleep': sleep,
+}

venv/lib/python3.12/site-packages/engineio/async_drivers/gevent.py

@@ -0,0 +1,83 @@
+import gevent
+from gevent import queue
+from gevent.event import Event
+try:
+    # use gevent-websocket if installed
+    import geventwebsocket  # noqa
+    SimpleWebSocketWSGI = None
+except ImportError:  # pragma: no cover
+    # fallback to simple_websocket when gevent-websocket is not installed
+    from engineio.async_drivers._websocket_wsgi import SimpleWebSocketWSGI
+
+
+class Thread(gevent.Greenlet):  # pragma: no cover
+    """
+    This wrapper class provides gevent Greenlet interface that is compatible
+    with the standard library's Thread class.
+    """
+    def __init__(self, target, args=[], kwargs={}):
+        super().__init__(target, *args, **kwargs)
+
+    def _run(self):
+        return self.run()
+
+
+if SimpleWebSocketWSGI is not None:
+    class WebSocketWSGI(SimpleWebSocketWSGI):  # pragma: no cover
+        """
+        This wrapper class provides a gevent WebSocket interface that is
+        compatible with eventlet's implementation, using the simple-websocket
+        package.
+        """
+        def __init__(self, handler, server):
+            # to avoid the requirement that the standard library is
+            # monkey-patched, here we pass the gevent versions of the
+            # concurrency and networking classes required by simple-websocket
+            import gevent.event
+            import gevent.selectors
+            super().__init__(handler, server,
+                             thread_class=Thread,
+                             event_class=gevent.event.Event,
+                             selector_class=gevent.selectors.DefaultSelector)
+else:
+    class WebSocketWSGI:  # pragma: no cover
+        """
+        This wrapper class provides a gevent WebSocket interface that is
+        compatible with eventlet's implementation, using the gevent-websocket
+        package.
+        """
+        def __init__(self, handler, server):
+            self.app = handler
+
+        def __call__(self, environ, start_response):
+            if 'wsgi.websocket' not in environ:
+                raise RuntimeError('The gevent-websocket server is not '
+                                   'configured appropriately. '
+                                   'See the Deployment section of the '
+                                   'documentation for more information.')
+            self._sock = environ['wsgi.websocket']
+            self.environ = environ
+            self.version = self._sock.version
+            self.path = self._sock.path
+            self.origin = self._sock.origin
+            self.protocol = self._sock.protocol
+            return self.app(self)
+
+        def close(self):
+            return self._sock.close()
+
+        def send(self, message):
+            return self._sock.send(message)
+
+        def wait(self):
+            return self._sock.receive()
+
+
+_async = {
+    'thread': Thread,
+    'queue': queue.JoinableQueue,
+    'queue_empty': queue.Empty,
+    'event': Event,
+    'websocket': WebSocketWSGI,
+    'sleep': gevent.sleep,
+}

venv/lib/python3.12/site-packages/engineio/async_drivers/gevent_uwsgi.py

@@ -0,0 +1,168 @@
+import gevent
+from gevent import queue
+from gevent.event import Event
+from gevent import selectors
+import uwsgi
+_websocket_available = hasattr(uwsgi, 'websocket_handshake')
+
+
+class Thread(gevent.Greenlet):  # pragma: no cover
+    """
+    This wrapper class provides gevent Greenlet interface that is compatible
+    with the standard library's Thread class.
+    """
+    def __init__(self, target, args=[], kwargs={}):
+        super().__init__(target, *args, **kwargs)
+
+    def _run(self):
+        return self.run()
+
+
+class uWSGIWebSocket:  # pragma: no cover
+    """
+    This wrapper class provides a uWSGI WebSocket interface that is
+    compatible with eventlet's implementation.
+    """
+    def __init__(self, handler, server):
+        self.app = handler
+        self._sock = None
+        self.received_messages = []
+
+    def __call__(self, environ, start_response):
+        self._sock = uwsgi.connection_fd()
+        self.environ = environ
+
+        uwsgi.websocket_handshake()
+
+        self._req_ctx = None
+        if hasattr(uwsgi, 'request_context'):
+            # uWSGI >= 2.1.x with support for api access across-greenlets
+            self._req_ctx = uwsgi.request_context()
+        else:
+            # use event and queue for sending messages
+            self._event = Event()
+            self._send_queue = queue.Queue()
+
+            # spawn a select greenlet
+            def select_greenlet_runner(fd, event):
+                """Sets event when data becomes available to read on fd."""
+                sel = selectors.DefaultSelector()
+                sel.register(fd, selectors.EVENT_READ)
+                try:
+                    while True:
+                        sel.select()
+                        event.set()
+                except gevent.GreenletExit:
+                    sel.unregister(fd)
+            self._select_greenlet = gevent.spawn(
+                select_greenlet_runner,
+                self._sock,
+                self._event)
+
+        self.app(self)
+        uwsgi.disconnect()
+        return ''  # send nothing as response
+
+    def close(self):
+        """Disconnects uWSGI from the client."""
+        if self._req_ctx is None:
+            # better kill it here in case wait() is not called again
+            self._select_greenlet.kill()
+            self._event.set()
+
+    def _send(self, msg):
+        """Transmits message either in binary or UTF-8 text mode,
+        depending on its type."""
+        if isinstance(msg, bytes):
+            method = uwsgi.websocket_send_binary
+        else:
+            method = uwsgi.websocket_send
+        if self._req_ctx is not None:
+            method(msg, request_context=self._req_ctx)
+        else:
+            method(msg)
+
+    def _decode_received(self, msg):
+        """Returns either bytes or str, depending on message type."""
+        if not isinstance(msg, bytes):
+            # already decoded - do nothing
+            return msg
+        # only decode from utf-8 if message is not binary data
+        type = ord(msg[0:1])
+        if type >= 48:  # no binary
+            return msg.decode('utf-8')
+        # binary message, don't try to decode
+        return msg
+
+    def send(self, msg):
+        """Queues a message for sending. Real transmission is done in
+        wait method.
+        Sends directly if uWSGI version is new enough."""
+        if self._req_ctx is not None:
+            self._send(msg)
+        else:
+            self._send_queue.put(msg)
+            self._event.set()
+
+    def wait(self):
+        """Waits and returns received messages.
+        If running in compatibility mode for older uWSGI versions,
+        it also sends messages that have been queued by send().
+        A return value of None means that connection was closed.
+        This must be called repeatedly. For uWSGI < 2.1.x it must
+        be called from the main greenlet."""
+        while True:
+            if self._req_ctx is not None:
+                try:
+                    msg = uwsgi.websocket_recv(request_context=self._req_ctx)
+                except OSError:  # connection closed
+                    self.close()
+                    return None
+                return self._decode_received(msg)
+            else:
+                if self.received_messages:
+                    return self.received_messages.pop(0)
+
+                # we wake up at least every 3 seconds to let uWSGI
+                # do its ping/ponging
+                event_set = self._event.wait(timeout=3)
+                if event_set:
+                    self._event.clear()
+                    # maybe there is something to send
+                    msgs = []
+                    while True:
+                        try:
+                            msgs.append(self._send_queue.get(block=False))
+                        except gevent.queue.Empty:
+                            break
+                    for msg in msgs:
+                        try:
+                            self._send(msg)
+                        except OSError:
+                            self.close()
+                            return None
+                # maybe there is something to receive, if not, at least
+                # ensure uWSGI does its ping/ponging
+                while True:
+                    try:
+                        msg = uwsgi.websocket_recv_nb()
+                    except OSError:  # connection closed
+                        self.close()
+                        return None
+                    if msg:  # message available
+                        self.received_messages.append(
+                            self._decode_received(msg))
+                    else:
+                        break
+                if self.received_messages:
+                    return self.received_messages.pop(0)
+
+
+_async = {
+    'thread': Thread,
+    'queue': queue.JoinableQueue,
+    'queue_empty': queue.Empty,
+    'event': Event,
+    'websocket': uWSGIWebSocket if _websocket_available else None,
+    'sleep': gevent.sleep,
+}

venv/lib/python3.12/site-packages/engineio/async_drivers/sanic.py

@@ -0,0 +1,148 @@
+import sys
+from urllib.parse import urlsplit
+
+try:  # pragma: no cover
+    from sanic.response import HTTPResponse
+    try:
+        from sanic.server.protocols.websocket_protocol import WebSocketProtocol
+    except ImportError:
+        from sanic.websocket import WebSocketProtocol
+except ImportError:
+    HTTPResponse = None
+    WebSocketProtocol = None
+
+
+def create_route(app, engineio_server, engineio_endpoint):  # pragma: no cover
+    """This function sets up the engine.io endpoint as a route for the
+    application.
+
+    Note that both GET and POST requests must be hooked up on the engine.io
+    endpoint.
+    """
+    app.add_route(engineio_server.handle_request, engineio_endpoint,
+                  methods=['GET', 'POST', 'OPTIONS'])
+    try:
+        app.enable_websocket()
+    except AttributeError:
+        # ignore, this version does not support websocket
+        pass
+
+
+def translate_request(request):  # pragma: no cover
+    """This function takes the arguments passed to the request handler and
+    uses them to generate a WSGI compatible environ dictionary.
+    """
+    class AwaitablePayload:
+        def __init__(self, payload):
+            self.payload = payload or b''
+
+        async def read(self, length=None):
+            if length is None:
+                r = self.payload
+                self.payload = b''
+            else:
+                r = self.payload[:length]
+                self.payload = self.payload[length:]
+            return r
+
+    uri_parts = urlsplit(request.url)
+    environ = {
+        'wsgi.input': AwaitablePayload(request.body),
+        'wsgi.errors': sys.stderr,
+        'wsgi.version': (1, 0),
+        'wsgi.async': True,
+        'wsgi.multithread': False,
+        'wsgi.multiprocess': False,
+        'wsgi.run_once': False,
+        'SERVER_SOFTWARE': 'sanic',
+        'REQUEST_METHOD': request.method,
+        'QUERY_STRING': uri_parts.query or '',
+        'RAW_URI': request.url,
+        'SERVER_PROTOCOL': 'HTTP/' + request.version,
+        'REMOTE_ADDR': '127.0.0.1',
+        'REMOTE_PORT': '0',
+        'SERVER_NAME': 'sanic',
+        'SERVER_PORT': '0',
+        'sanic.request': request
+    }
+
+    for hdr_name, hdr_value in request.headers.items():
+        hdr_name = hdr_name.upper()
+        if hdr_name == 'CONTENT-TYPE':
+            environ['CONTENT_TYPE'] = hdr_value
+            continue
+        elif hdr_name == 'CONTENT-LENGTH':
+            environ['CONTENT_LENGTH'] = hdr_value
+            continue
+
+        key = 'HTTP_%s' % hdr_name.replace('-', '_')
+        if key in environ:
+            hdr_value = f'{environ[key]},{hdr_value}'
+
+        environ[key] = hdr_value
+
+    environ['wsgi.url_scheme'] = environ.get('HTTP_X_FORWARDED_PROTO', 'http')
+
+    path_info = uri_parts.path
+
+    environ['PATH_INFO'] = path_info
+    environ['SCRIPT_NAME'] = ''
+
+    return environ
+
+
+def make_response(status, headers, payload, environ):  # pragma: no cover
+    """This function generates an appropriate response object for this async
+    mode.
+    """
+    headers_dict = {}
+    content_type = None
+    for h in headers:
+        if h[0].lower() == 'content-type':
+            content_type = h[1]
+        else:
+            headers_dict[h[0]] = h[1]
+    return HTTPResponse(body=payload, content_type=content_type,
+                        status=int(status.split()[0]), headers=headers_dict)
+
+
+class WebSocket:  # pragma: no cover
+    """
+    This wrapper class provides a sanic WebSocket interface that is
+    somewhat compatible with eventlet's implementation.
+    """
+    def __init__(self, handler, server):
+        self.handler = handler
+        self.server = server
+        self._sock = None
+
+    async def __call__(self, environ):
+        request = environ['sanic.request']
+        protocol = request.transport.get_protocol()
+        self._sock = await protocol.websocket_handshake(request)
+
+        self.environ = environ
+        await self.handler(self)
+        return self.server._ok()
+
+    async def close(self):
+        await self._sock.close()
+
+    async def send(self, message):
+        await self._sock.send(message)
+
+    async def wait(self):
+        data = await self._sock.recv()
+        if not isinstance(data, bytes) and \
+                not isinstance(data, str):
+            raise OSError()
+        return data
+
+
+_async = {
+    'asyncio': True,
+    'create_route': create_route,
+    'translate_request': translate_request,
+    'make_response': make_response,
+    'websocket': WebSocket if WebSocketProtocol else None,
+}

venv/lib/python3.12/site-packages/engineio/async_drivers/threading.py

@@ -0,0 +1,19 @@
+import queue
+import threading
+import time
+from engineio.async_drivers._websocket_wsgi import SimpleWebSocketWSGI
+
+
+class DaemonThread(threading.Thread):  # pragma: no cover
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs, daemon=True)
+
+
+_async = {
+    'thread': DaemonThread,
+    'queue': queue.Queue,
+    'queue_empty': queue.Empty,
+    'event': threading.Event,
+    'websocket': SimpleWebSocketWSGI,
+    'sleep': time.sleep,
+}

venv/lib/python3.12/site-packages/engineio/async_drivers/tornado.py

@@ -0,0 +1,182 @@
+import asyncio
+import sys
+from urllib.parse import urlsplit
+from .. import exceptions
+
+import tornado.web
+import tornado.websocket
+
+
+def get_tornado_handler(engineio_server):
+    class Handler(tornado.websocket.WebSocketHandler):  # pragma: no cover
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            if isinstance(engineio_server.cors_allowed_origins, str):
+                if engineio_server.cors_allowed_origins == '*':
+                    self.allowed_origins = None
+                else:
+                    self.allowed_origins = [
+                        engineio_server.cors_allowed_origins]
+            else:
+                self.allowed_origins = engineio_server.cors_allowed_origins
+            self.receive_queue = asyncio.Queue()
+
+        async def get(self, *args, **kwargs):
+            if self.request.headers.get('Upgrade', '').lower() == 'websocket':
+                ret = super().get(*args, **kwargs)
+                if asyncio.iscoroutine(ret):
+                    await ret
+            else:
+                await engineio_server.handle_request(self)
+
+        async def open(self, *args, **kwargs):
+            # this is the handler for the websocket request
+            asyncio.ensure_future(engineio_server.handle_request(self))
+
+        async def post(self, *args, **kwargs):
+            await engineio_server.handle_request(self)
+
+        async def options(self, *args, **kwargs):
+            await engineio_server.handle_request(self)
+
+        async def on_message(self, message):
+            await self.receive_queue.put(message)
+
+        async def get_next_message(self):
+            return await self.receive_queue.get()
+
+        def on_close(self):
+            self.receive_queue.put_nowait(None)
+
+        def check_origin(self, origin):
+            if self.allowed_origins is None or origin in self.allowed_origins:
+                return True
+            return super().check_origin(origin)
+
+        def get_compression_options(self):
+            # enable compression
+            return {}
+
+    return Handler
+
+
+def translate_request(handler):
+    """This function takes the arguments passed to the request handler and
+    uses them to generate a WSGI compatible environ dictionary.
+    """
+    class AwaitablePayload:
+        def __init__(self, payload):
+            self.payload = payload or b''
+
+        async def read(self, length=None):
+            if length is None:
+                r = self.payload
+                self.payload = b''
+            else:
+                r = self.payload[:length]
+                self.payload = self.payload[length:]
+            return r
+
+    payload = handler.request.body
+
+    uri_parts = urlsplit(handler.request.path)
+    full_uri = handler.request.path
+    if handler.request.query:  # pragma: no cover
+        full_uri += '?' + handler.request.query
+    environ = {
+        'wsgi.input': AwaitablePayload(payload),
+        'wsgi.errors': sys.stderr,
+        'wsgi.version': (1, 0),
+        'wsgi.async': True,
+        'wsgi.multithread': False,
+        'wsgi.multiprocess': False,
+        'wsgi.run_once': False,
+        'SERVER_SOFTWARE': 'aiohttp',
+        'REQUEST_METHOD': handler.request.method,
+        'QUERY_STRING': handler.request.query or '',
+        'RAW_URI': full_uri,
+        'SERVER_PROTOCOL': 'HTTP/%s' % handler.request.version,
+        'REMOTE_ADDR': '127.0.0.1',
+        'REMOTE_PORT': '0',
+        'SERVER_NAME': 'aiohttp',
+        'SERVER_PORT': '0',
+        'tornado.handler': handler
+    }
+
+    for hdr_name, hdr_value in handler.request.headers.items():
+        hdr_name = hdr_name.upper()
+        if hdr_name == 'CONTENT-TYPE':
+            environ['CONTENT_TYPE'] = hdr_value
+            continue
+        elif hdr_name == 'CONTENT-LENGTH':
+            environ['CONTENT_LENGTH'] = hdr_value
+            continue
+
+        key = 'HTTP_%s' % hdr_name.replace('-', '_')
+        environ[key] = hdr_value
+
+    environ['wsgi.url_scheme'] = environ.get('HTTP_X_FORWARDED_PROTO', 'http')
+
+    path_info = uri_parts.path
+
+    environ['PATH_INFO'] = path_info
+    environ['SCRIPT_NAME'] = ''
+
+    return environ
+
+
+def make_response(status, headers, payload, environ):
+    """This function generates an appropriate response object for this async
+    mode.
+    """
+    tornado_handler = environ['tornado.handler']
+    try:
+        tornado_handler.set_status(int(status.split()[0]))
+    except RuntimeError:  # pragma: no cover
+        # for websocket connections Tornado does not accept a response, since
+        # it already emitted the 101 status code
+        return
+    for header, value in headers:
+        tornado_handler.set_header(header, value)
+    tornado_handler.write(payload)
+    tornado_handler.finish()
+
+
+class WebSocket:  # pragma: no cover
+    """
+    This wrapper class provides a tornado WebSocket interface that is
+    somewhat compatible with eventlet's implementation.
+    """
+    def __init__(self, handler, server):
+        self.handler = handler
+        self.tornado_handler = None
+
+    async def __call__(self, environ):
+        self.tornado_handler = environ['tornado.handler']
+        self.environ = environ
+        await self.handler(self)
+
+    async def close(self):
+        self.tornado_handler.close()
+
+    async def send(self, message):
+        try:
+            self.tornado_handler.write_message(
+                message, binary=isinstance(message, bytes))
+        except tornado.websocket.WebSocketClosedError:
+            raise exceptions.EngineIOError()
+
+    async def wait(self):
+        msg = await self.tornado_handler.get_next_message()
+        if not isinstance(msg, bytes) and \
+                not isinstance(msg, str):
+            raise OSError()
+        return msg
+
+
+_async = {
+    'asyncio': True,
+    'translate_request': translate_request,
+    'make_response': make_response,
+    'websocket': WebSocket,
+}