python-engineio 4.10.0__py3-none-any.whl → 4.11.0__py3-none-any.whl

engineio/async_client.py

@@ -37,7 +37,7 @@ def async_signal_handler():
         for task in tasks:
             task.cancel()
         await asyncio.gather(*tasks, return_exceptions=True)
-        asyncio.get_event_loop().stop()
+        asyncio.get_running_loop().stop()
 
     asyncio.ensure_future(_handler())
 
@@ -75,6 +75,9 @@ class AsyncClient(base_client.BaseClient):
     :param websocket_extra_options: Dictionary containing additional keyword
                                     arguments passed to
                                     ``aiohttp.ws_connect()``.
+    :param timestamp_requests: If ``True`` a timestamp is added to the query
+                               string of Socket.IO requests as a cache-busting
+                               measure. Set to ``False`` to disable.
     """
     def is_asyncio_based(self):
         return True
@@ -106,7 +109,7 @@ class AsyncClient(base_client.BaseClient):
         if self.handle_sigint and not async_signal_handler_set and \
                 threading.current_thread() == threading.main_thread():
             try:
-                asyncio.get_event_loop().add_signal_handler(
+                asyncio.get_running_loop().add_signal_handler(
                     signal.SIGINT, async_signal_handler)
             except NotImplementedError:  # pragma: no cover
                 self.logger.warning('Signal handler is unsupported')
@@ -149,7 +152,7 @@ class AsyncClient(base_client.BaseClient):
         """
         await self._send_packet(packet.Packet(packet.MESSAGE, data=data))
 
-    async def disconnect(self, abort=False):
+    async def disconnect(self, abort=False, reason=None):
         """Disconnect from the server.
 
         :param abort: If set to ``True``, do not wait for background tasks
@@ -161,7 +164,9 @@ class AsyncClient(base_client.BaseClient):
             await self._send_packet(packet.Packet(packet.CLOSE))
             await self.queue.put(None)
             self.state = 'disconnecting'
-            await self._trigger_event('disconnect', run_async=False)
+            await self._trigger_event('disconnect',
+                                      reason or self.reason.CLIENT_DISCONNECT,
+                                      run_async=False)
             if self.current_transport == 'websocket':
                 await self.ws.close()
             if not abort:
@@ -409,7 +414,8 @@ class AsyncClient(base_client.BaseClient):
         elif pkt.packet_type == packet.PING:
             await self._send_packet(packet.Packet(packet.PONG, pkt.data))
         elif pkt.packet_type == packet.CLOSE:
-            await self.disconnect(abort=True)
+            await self.disconnect(abort=True,
+                                  reason=self.reason.SERVER_DISCONNECT)
         elif pkt.packet_type == packet.NOOP:
             pass
         else:
@@ -462,7 +468,17 @@ class AsyncClient(base_client.BaseClient):
                     return task
                 else:
                     try:
-                        ret = await self.handlers[event](*args)
+                        try:
+                            ret = await self.handlers[event](*args)
+                        except TypeError:
+                            print(args, len(args))
+                            if event == 'disconnect' and \
+                                    len(args) == 1:  # pragma: no branch
+                                # legacy disconnect events do not have a reason
+                                # argument
+                                return await self.handlers[event]()
+                            else:  # pragma: no cover
+                                raise
                     except asyncio.CancelledError:  # pragma: no cover
                         pass
                     except:
@@ -482,7 +498,17 @@ class AsyncClient(base_client.BaseClient):
                     return task
                 else:
                     try:
-                        ret = self.handlers[event](*args)
+                        try:
+                            ret = self.handlers[event](*args)
+                        except TypeError:
+                            print(args, len(args))
+                            if event == 'disconnect' and \
+                                    len(args) == 1:  # pragma: no branch
+                                # legacy disconnect events do not have a reason
+                                # argument
+                                ret = self.handlers[event]()
+                            else:  # pragma: no cover
+                                raise
                     except:
                         self.logger.exception(event + ' handler error')
                         if event == 'connect':
@@ -524,7 +550,8 @@ class AsyncClient(base_client.BaseClient):
             self.logger.info('Waiting for write loop task to end')
             await self.write_loop_task
         if self.state == 'connected':
-            await self._trigger_event('disconnect', run_async=False)
+            await self._trigger_event(
+                'disconnect', self.reason.TRANSPORT_ERROR, run_async=False)
             try:
                 base_client.connected_clients.remove(self)
             except ValueError:  # pragma: no cover
@@ -578,7 +605,8 @@ class AsyncClient(base_client.BaseClient):
             self.logger.info('Waiting for write loop task to end')
             await self.write_loop_task
         if self.state == 'connected':
-            await self._trigger_event('disconnect', run_async=False)
+            await self._trigger_event(
+                'disconnect', self.reason.TRANSPORT_ERROR, run_async=False)
             try:
                 base_client.connected_clients.remove(self)
             except ValueError:  # pragma: no cover

engineio/async_drivers/_websocket_wsgi.py

@@ -25,7 +25,7 @@ class SimpleWebSocketWSGI:  # pragma: no cover
         try:
             return self.ws.send(message)
         except simple_websocket.ConnectionClosed:
-            raise IOError()
+            raise OSError()
 
     def wait(self):
         try:

engineio/async_drivers/aiohttp.py

@@ -57,7 +57,7 @@ def translate_request(request):
 
         key = 'HTTP_%s' % hdr_name.replace('-', '_')
         if key in environ:
-            hdr_value = '%s,%s' % (environ[key], hdr_value)
+            hdr_value = f'{environ[key]},{hdr_value}'
 
         environ[key] = hdr_value
 
@@ -79,7 +79,7 @@ def make_response(status, headers, payload, environ):
                     headers=headers)
 
 
-class WebSocket(object):  # pragma: no cover
+class WebSocket:  # pragma: no cover
     """
     This wrapper class provides a aiohttp WebSocket interface that is
     somewhat compatible with eventlet's implementation.
@@ -114,7 +114,7 @@ class WebSocket(object):  # pragma: no cover
         msg = await self._sock.receive()
         if not isinstance(msg.data, bytes) and \
                 not isinstance(msg.data, str):
-            raise IOError()
+            raise OSError()
         return msg.data
 
 

engineio/async_drivers/asgi.py

@@ -135,7 +135,7 @@ class ASGIApp:
 
 
 async def translate_request(scope, receive, send):
-    class AwaitablePayload(object):  # pragma: no cover
+    class AwaitablePayload:  # pragma: no cover
         def __init__(self, payload):
             self.payload = payload or b''
 
@@ -161,9 +161,15 @@ async def translate_request(scope, receive, send):
     else:
         return {}
 
-    raw_uri = scope['path'].encode('utf-8')
+    raw_uri = scope['path']
+    query_string = ''
     if 'query_string' in scope and scope['query_string']:
-        raw_uri += b'?' + 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,
@@ -175,8 +181,8 @@ async def translate_request(scope, receive, send):
         'SERVER_SOFTWARE': 'asgi',
         'REQUEST_METHOD': scope.get('method', 'GET'),
         'PATH_INFO': scope['path'],
-        'QUERY_STRING': scope.get('query_string', b'').decode('utf-8'),
-        'RAW_URI': raw_uri.decode('utf-8'),
+        'QUERY_STRING': query_string,
+        'RAW_URI': raw_uri,
         'SCRIPT_NAME': '',
         'SERVER_PROTOCOL': 'HTTP/1.1',
         'REMOTE_ADDR': '127.0.0.1',
@@ -189,8 +195,12 @@ async def translate_request(scope, receive, send):
     }
 
     for hdr_name, hdr_value in scope['headers']:
-        hdr_name = hdr_name.upper().decode('utf-8')
-        hdr_value = hdr_value.decode('utf-8')
+        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
@@ -200,7 +210,7 @@ async def translate_request(scope, receive, send):
 
         key = 'HTTP_%s' % hdr_name.replace('-', '_')
         if key in environ:
-            hdr_value = '%s,%s' % (environ[key], hdr_value)
+            hdr_value = f'{environ[key]},{hdr_value}'
 
         environ[key] = hdr_value
 
@@ -231,7 +241,7 @@ async def make_response(status, headers, payload, environ):
                                 'body': payload})
 
 
-class WebSocket(object):  # pragma: no cover
+class WebSocket:  # pragma: no cover
     """
     This wrapper class provides an asgi WebSocket interface that is
     somewhat compatible with eventlet's implementation.
@@ -269,7 +279,7 @@ class WebSocket(object):  # pragma: no cover
     async def wait(self):
         event = await self.asgi_receive()
         if event['type'] != 'websocket.receive':
-            raise IOError()
+            raise OSError()
         return event.get('bytes') or event.get('text')
 
 

engineio/async_drivers/eventlet.py

@@ -1,5 +1,3 @@
-from __future__ import absolute_import
-
 from eventlet.green.threading import Event
 from eventlet import queue, sleep, spawn
 from eventlet.websocket import WebSocketWSGI as _WebSocketWSGI

engineio/async_drivers/gevent_uwsgi.py

@@ -18,7 +18,7 @@ class Thread(gevent.Greenlet):  # pragma: no cover
         return self.run()
 
 
-class uWSGIWebSocket(object):  # pragma: no cover
+class uWSGIWebSocket:  # pragma: no cover
     """
     This wrapper class provides a uWSGI WebSocket interface that is
     compatible with eventlet's implementation.
@@ -115,7 +115,7 @@ class uWSGIWebSocket(object):  # pragma: no cover
             if self._req_ctx is not None:
                 try:
                     msg = uwsgi.websocket_recv(request_context=self._req_ctx)
-                except IOError:  # connection closed
+                except OSError:  # connection closed
                     self.close()
                     return None
                 return self._decode_received(msg)
@@ -138,7 +138,7 @@ class uWSGIWebSocket(object):  # pragma: no cover
                     for msg in msgs:
                         try:
                             self._send(msg)
-                        except IOError:
+                        except OSError:
                             self.close()
                             return None
                 # maybe there is something to receive, if not, at least
@@ -146,7 +146,7 @@ class uWSGIWebSocket(object):  # pragma: no cover
                 while True:
                     try:
                         msg = uwsgi.websocket_recv_nb()
-                    except IOError:  # connection closed
+                    except OSError:  # connection closed
                         self.close()
                         return None
                     if msg:  # message available

engineio/async_drivers/sanic.py

@@ -33,7 +33,7 @@ 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(object):
+    class AwaitablePayload:
         def __init__(self, payload):
             self.payload = payload or b''
 
@@ -78,7 +78,7 @@ def translate_request(request):  # pragma: no cover
 
         key = 'HTTP_%s' % hdr_name.replace('-', '_')
         if key in environ:
-            hdr_value = '%s,%s' % (environ[key], hdr_value)
+            hdr_value = f'{environ[key]},{hdr_value}'
 
         environ[key] = hdr_value
 
@@ -107,7 +107,7 @@ def make_response(status, headers, payload, environ):  # pragma: no cover
                         status=int(status.split()[0]), headers=headers_dict)
 
 
-class WebSocket(object):  # pragma: no cover
+class WebSocket:  # pragma: no cover
     """
     This wrapper class provides a sanic WebSocket interface that is
     somewhat compatible with eventlet's implementation.
@@ -136,7 +136,7 @@ class WebSocket(object):  # pragma: no cover
         data = await self._sock.recv()
         if not isinstance(data, bytes) and \
                 not isinstance(data, str):
-            raise IOError()
+            raise OSError()
         return data
 
 

engineio/async_drivers/tornado.py

@@ -64,7 +64,7 @@ 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(object):
+    class AwaitablePayload:
         def __init__(self, payload):
             self.payload = payload or b''
 
@@ -142,7 +142,7 @@ def make_response(status, headers, payload, environ):
     tornado_handler.finish()
 
 
-class WebSocket(object):  # pragma: no cover
+class WebSocket:  # pragma: no cover
     """
     This wrapper class provides a tornado WebSocket interface that is
     somewhat compatible with eventlet's implementation.
@@ -170,7 +170,7 @@ class WebSocket(object):  # pragma: no cover
         msg = await self.tornado_handler.get_next_message()
         if not isinstance(msg, bytes) and \
                 not isinstance(msg, str):
-            raise IOError()
+            raise OSError()
         return msg
 
 

engineio/async_server.py

@@ -89,7 +89,7 @@ class AsyncServer(base_server.BaseServer):
     def attach(self, app, engineio_path='engine.io'):
         """Attach the Engine.IO server to an application."""
         engineio_path = engineio_path.strip('/')
-        self._async['create_route'](app, self, '/{}/'.format(engineio_path))
+        self._async['create_route'](app, self, f'/{engineio_path}/')
 
     async def send(self, sid, data):
         """Send a message to a client.
@@ -162,7 +162,7 @@ class AsyncServer(base_server.BaseServer):
                 async with eio.session(sid) as session:
                     print('received message from ', session['username'])
         """
-        class _session_context_manager(object):
+        class _session_context_manager:
             def __init__(self, server, sid):
                 self.server = server
                 self.sid = sid
@@ -192,12 +192,15 @@ class AsyncServer(base_server.BaseServer):
                 # the socket was already closed or gone
                 pass
             else:
-                await socket.close()
+                await socket.close(reason=self.reason.SERVER_DISCONNECT)
                 if sid in self.sockets:  # pragma: no cover
                     del self.sockets[sid]
         else:
-            await asyncio.wait([asyncio.create_task(client.close())
-                                for client in self.sockets.values()])
+            await asyncio.wait([
+                asyncio.create_task(client.close(
+                    reason=self.reason.SERVER_DISCONNECT))
+                for client in self.sockets.values()
+            ])
             self.sockets = {}
 
     async def handle_request(self, *args, **kwargs):
@@ -269,11 +272,11 @@ class AsyncServer(base_server.BaseServer):
                                  'bad-jsonp-index')
             r = self._bad_request('Invalid JSONP index number')
         elif method == 'GET':
+            upgrade_header = environ.get('HTTP_UPGRADE').lower() \
+                if 'HTTP_UPGRADE' in environ else None
             if sid is None:
                 # transport must be one of 'polling' or 'websocket'.
                 # if 'websocket', the HTTP_UPGRADE header must match.
-                upgrade_header = environ.get('HTTP_UPGRADE').lower() \
-                    if 'HTTP_UPGRADE' in environ else None
                 if transport == 'polling' \
                         or transport == upgrade_header == 'websocket':
                     r = await self._handle_connect(environ, transport,
@@ -284,32 +287,41 @@ class AsyncServer(base_server.BaseServer):
                     r = self._bad_request('Invalid websocket upgrade')
             else:
                 if sid not in self.sockets:
-                    self._log_error_once('Invalid session ' + sid, 'bad-sid')
-                    r = self._bad_request('Invalid session ' + sid)
+                    self._log_error_once(f'Invalid session {sid}', 'bad-sid')
+                    r = self._bad_request(f'Invalid session {sid}')
                 else:
-                    socket = self._get_socket(sid)
-                    if self.transport(sid) != transport:
-                        self._log_error_once(
-                            'Invalid transport for session ' + sid,
-                            'bad-transport')
-                        r = self._bad_request('Invalid transport')
+                    try:
+                        socket = self._get_socket(sid)
+                    except KeyError as e:  # pragma: no cover
+                        self._log_error_once(f'{e} {sid}', 'bad-sid')
+                        r = self._bad_request(f'{e} {sid}')
                     else:
-                        try:
-                            packets = await socket.handle_get_request(environ)
-                            if isinstance(packets, list):
-                                r = self._ok(packets, jsonp_index=jsonp_index)
-                            else:
-                                r = packets
-                        except exceptions.EngineIOError:
-                            if sid in self.sockets:  # pragma: no cover
-                                await self.disconnect(sid)
-                            r = self._bad_request()
-                        if sid in self.sockets and self.sockets[sid].closed:
-                            del self.sockets[sid]
+                        if self.transport(sid) != transport and \
+                                transport != upgrade_header:
+                            self._log_error_once(
+                                f'Invalid transport for session {sid}',
+                                'bad-transport')
+                            r = self._bad_request('Invalid transport')
+                        else:
+                            try:
+                                packets = await socket.handle_get_request(
+                                    environ)
+                                if isinstance(packets, list):
+                                    r = self._ok(packets,
+                                                 jsonp_index=jsonp_index)
+                                else:
+                                    r = packets
+                            except exceptions.EngineIOError:
+                                if sid in self.sockets:  # pragma: no cover
+                                    await self.disconnect(sid)
+                                r = self._bad_request()
+                            if sid in self.sockets and \
+                                    self.sockets[sid].closed:
+                                del self.sockets[sid]
         elif method == 'POST':
             if sid is None or sid not in self.sockets:
-                self._log_error_once('Invalid session ' + sid, 'bad-sid')
-                r = self._bad_request('Invalid session ' + sid)
+                self._log_error_once(f'Invalid session {sid}', 'bad-sid')
+                r = self._bad_request(f'Invalid session {sid}')
             else:
                 socket = self._get_socket(sid)
                 try:
@@ -439,11 +451,14 @@ class AsyncServer(base_server.BaseServer):
         s = async_socket.AsyncSocket(self, sid)
         self.sockets[sid] = s
 
-        pkt = packet.Packet(
-            packet.OPEN, {'sid': sid,
-                          'upgrades': self._upgrades(sid, transport),
-                          'pingTimeout': int(self.ping_timeout * 1000),
-                          'pingInterval': int(self.ping_interval * 1000)})
+        pkt = packet.Packet(packet.OPEN, {
+            'sid': sid,
+            'upgrades': self._upgrades(sid, transport),
+            'pingTimeout': int(self.ping_timeout * 1000),
+            'pingInterval': int(
+                self.ping_interval + self.ping_interval_grace_period) * 1000,
+            'maxPayload': self.max_http_buffer_size,
+        })
         await s.send(pkt)
         s.schedule_ping()
 
@@ -490,7 +505,16 @@ class AsyncServer(base_server.BaseServer):
             if asyncio.iscoroutinefunction(self.handlers[event]):
                 async def run_async_handler():
                     try:
-                        return await self.handlers[event](*args)
+                        try:
+                            return await self.handlers[event](*args)
+                        except TypeError:
+                            if event == 'disconnect' and \
+                                    len(args) == 2:  # pragma: no branch
+                                # legacy disconnect events do not have a reason
+                                # argument
+                                return await self.handlers[event](args[0])
+                            else:  # pragma: no cover
+                                raise
                     except asyncio.CancelledError:  # pragma: no cover
                         pass
                     except:
@@ -509,7 +533,16 @@ class AsyncServer(base_server.BaseServer):
             else:
                 async def run_sync_handler():
                     try:
-                        return self.handlers[event](*args)
+                        try:
+                            return self.handlers[event](*args)
+                        except TypeError:
+                            if event == 'disconnect' and \
+                                    len(args) == 2:  # pragma: no branch
+                                # legacy disconnect events do not have a reason
+                                # argument
+                                return self.handlers[event](args[0])
+                            else:  # pragma: no cover
+                                raise
                     except:
                         self.logger.exception(event + ' handler error')
                         if event == 'connect':
@@ -527,6 +560,7 @@ class AsyncServer(base_server.BaseServer):
 
     async def _service_task(self):  # pragma: no cover
         """Monitor connected clients and clean up those that time out."""
+        loop = asyncio.get_running_loop()
         self.service_task_event = self.create_event()
         while not self.service_task_event.is_set():
             if len(self.sockets) == 0:
@@ -568,7 +602,7 @@ class AsyncServer(base_server.BaseServer):
                 self.logger.info('service task canceled')
                 break
             except:
-                if asyncio.get_event_loop().is_closed():
+                if loop.is_closed():
                     self.logger.info('event loop is closed, exiting service '
                                      'task')
                     break

engineio/async_socket.py

@@ -47,7 +47,8 @@ class AsyncSocket(base_socket.BaseSocket):
         elif pkt.packet_type == packet.UPGRADE:
             await self.send(packet.Packet(packet.NOOP))
         elif pkt.packet_type == packet.CLOSE:
-            await self.close(wait=False, abort=True)
+            await self.close(wait=False, abort=True,
+                             reason=self.server.reason.CLIENT_DISCONNECT)
         else:
             raise exceptions.UnknownPacketError()
 
@@ -62,7 +63,8 @@ class AsyncSocket(base_socket.BaseSocket):
             # Passing abort=False here will cause close() to write a
             # CLOSE packet. This has the effect of updating half-open sockets
             # to their correct state of disconnected
-            await self.close(wait=False, abort=False)
+            await self.close(wait=False, abort=False,
+                             reason=self.server.reason.PING_TIMEOUT)
             return False
         return True
 
@@ -95,7 +97,8 @@ class AsyncSocket(base_socket.BaseSocket):
             packets = await self.poll()
         except exceptions.QueueEmpty:
             exc = sys.exc_info()
-            await self.close(wait=False)
+            await self.close(wait=False,
+                             reason=self.server.reason.TRANSPORT_ERROR)
             raise exc[1].with_traceback(exc[2])
         return packets
 
@@ -110,11 +113,14 @@ class AsyncSocket(base_socket.BaseSocket):
             for pkt in p.packets:
                 await self.receive(pkt)
 
-    async def close(self, wait=True, abort=False):
+    async def close(self, wait=True, abort=False, reason=None):
         """Close the socket connection."""
         if not self.closed and not self.closing:
             self.closing = True
-            await self.server._trigger_event('disconnect', self.sid)
+            await self.server._trigger_event(
+                'disconnect', self.sid,
+                reason or self.server.reason.SERVER_DISCONNECT,
+                run_async=False)
             if not abort:
                 await self.send(packet.Packet(packet.CLOSE))
             self.closed = True
@@ -134,7 +140,7 @@ class AsyncSocket(base_socket.BaseSocket):
     async def _upgrade_websocket(self, environ):
         """Upgrade the connection from polling to websocket."""
         if self.upgraded:
-            raise IOError('Socket has been upgraded already')
+            raise OSError('Socket has been upgraded already')
         if self.server._async['websocket'] is None:
             # the selected async mode does not support websocket
             return self.server._bad_request()
@@ -156,7 +162,7 @@ class AsyncSocket(base_socket.BaseSocket):
 
             try:
                 pkt = await websocket_wait()
-            except IOError:  # pragma: no cover
+            except OSError:  # pragma: no cover
                 return
             decoded_pkt = packet.Packet(encoded_packet=pkt)
             if decoded_pkt.packet_type != packet.PING or \
@@ -170,7 +176,7 @@ class AsyncSocket(base_socket.BaseSocket):
 
             try:
                 pkt = await websocket_wait()
-            except IOError:  # pragma: no cover
+            except OSError:  # pragma: no cover
                 self.upgrading = False
                 return
             decoded_pkt = packet.Packet(encoded_packet=pkt)
@@ -251,4 +257,5 @@ class AsyncSocket(base_socket.BaseSocket):
 
         await self.queue.put(None)  # unlock the writer task so it can exit
         await asyncio.wait_for(writer_task, timeout=None)
-        await self.close(wait=False, abort=True)
+        await self.close(wait=False, abort=True,
+                         reason=self.server.reason.TRANSPORT_CLOSE)

engineio/base_client.py

@@ -30,9 +30,18 @@ original_signal_handler = None
 class BaseClient:
     event_names = ['connect', 'disconnect', 'message']
 
+    class reason:
+        """Disconnection reasons."""
+        #: Client-initiated disconnection.
+        CLIENT_DISCONNECT = 'client disconnect'
+        #: Server-initiated disconnection.
+        SERVER_DISCONNECT = 'server disconnect'
+        #: Transport error.
+        TRANSPORT_ERROR = 'transport error'
+
     def __init__(self, logger=False, json=None, request_timeout=5,
                  http_session=None, ssl_verify=True, handle_sigint=True,
-                 websocket_extra_options=None):
+                 websocket_extra_options=None, timestamp_requests=True):
         global original_signal_handler
         if handle_sigint and original_signal_handler is None and \
                 threading.current_thread() == threading.main_thread():
@@ -56,6 +65,7 @@ class BaseClient:
         self.state = 'disconnected'
         self.ssl_verify = ssl_verify
         self.websocket_extra_options = websocket_extra_options or {}
+        self.timestamp_requests = timestamp_requests
 
         if json is not None:
             packet.Packet.json = json
@@ -143,4 +153,6 @@ class BaseClient:
 
     def _get_url_timestamp(self):
         """Generate the Engine.IO query string timestamp."""
+        if not self.timestamp_requests:
+            return ''
         return '&t=' + str(time.time())

engineio/base_server.py

@@ -19,6 +19,19 @@ class BaseServer:
     _default_monitor_clients = True
     sequence_number = 0
 
+    class reason:
+        """Disconnection reasons."""
+        #: Server-initiated disconnection.
+        SERVER_DISCONNECT = 'server disconnect'
+        #: Client-initiated disconnection.
+        CLIENT_DISCONNECT = 'client disconnect'
+        #: Ping timeout.
+        PING_TIMEOUT = 'ping timeout'
+        #: Transport close.
+        TRANSPORT_CLOSE = 'transport close'
+        #: Transport error.
+        TRANSPORT_ERROR = 'transport error'
+
     def __init__(self, async_mode=None, ping_interval=25, ping_timeout=20,
                  max_http_buffer_size=1000000, allow_upgrades=True,
                  http_compression=True, compression_threshold=1024,

engineio/base_socket.py

@@ -1,4 +1,3 @@
-
 class BaseSocket:
     upgrade_protocols = ['websocket']
 

engineio/client.py

@@ -55,6 +55,9 @@ class Client(base_client.BaseClient):
     :param websocket_extra_options: Dictionary containing additional keyword
                                     arguments passed to
                                     ``websocket.create_connection()``.
+    :param timestamp_requests: If ``True`` a timestamp is added to the query
+                               string of Socket.IO requests as a cache-busting
+                               measure. Set to ``False`` to disable.
     """
     def connect(self, url, headers=None, transports=None,
                 engineio_path='engine.io'):
@@ -110,7 +113,7 @@ class Client(base_client.BaseClient):
         """
         self._send_packet(packet.Packet(packet.MESSAGE, data=data))
 
-    def disconnect(self, abort=False):
+    def disconnect(self, abort=False, reason=None):
         """Disconnect from the server.
 
         :param abort: If set to ``True``, do not wait for background tasks
@@ -120,7 +123,9 @@ class Client(base_client.BaseClient):
             self._send_packet(packet.Packet(packet.CLOSE))
             self.queue.put(None)
             self.state = 'disconnecting'
-            self._trigger_event('disconnect', run_async=False)
+            self._trigger_event('disconnect',
+                                reason or self.reason.CLIENT_DISCONNECT,
+                                run_async=False)
             if self.current_transport == 'websocket':
                 self.ws.close()
             if not abort:
@@ -251,7 +256,7 @@ class Client(base_client.BaseClient):
         extra_options = {}
         if self.http:
             # cookies
-            cookies = '; '.join(["{}={}".format(cookie.name, cookie.value)
+            cookies = '; '.join([f"{cookie.name}={cookie.value}"
                                  for cookie in self.http.cookies])
             for header, value in headers.items():
                 if header.lower() == 'cookie':
@@ -325,7 +330,7 @@ class Client(base_client.BaseClient):
         try:
             ws = websocket.create_connection(
                 websocket_url + self._get_url_timestamp(), **extra_options)
-        except (ConnectionError, IOError, websocket.WebSocketException):
+        except (ConnectionError, OSError, websocket.WebSocketException):
             if upgrade:
                 self.logger.warning(
                     'WebSocket upgrade failed: connection error')
@@ -404,7 +409,7 @@ class Client(base_client.BaseClient):
         elif pkt.packet_type == packet.PING:
             self._send_packet(packet.Packet(packet.PONG, pkt.data))
         elif pkt.packet_type == packet.CLOSE:
-            self.disconnect(abort=True)
+            self.disconnect(abort=True, reason=self.reason.SERVER_DISCONNECT)
         elif pkt.packet_type == packet.NOOP:
             pass
         else:
@@ -444,7 +449,16 @@ class Client(base_client.BaseClient):
                 return self.start_background_task(self.handlers[event], *args)
             else:
                 try:
-                    return self.handlers[event](*args)
+                    try:
+                        return self.handlers[event](*args)
+                    except TypeError:
+                        if event == 'disconnect' and \
+                                len(args) == 1:  # pragma: no branch
+                            # legacy disconnect events do  not have a reason
+                            # argument
+                            return self.handlers[event]()
+                        else:  # pragma: no cover
+                            raise
                 except:
                     self.logger.exception(event + ' handler error')
 
@@ -480,7 +494,8 @@ class Client(base_client.BaseClient):
             self.logger.info('Waiting for write loop task to end')
             self.write_loop_task.join()
         if self.state == 'connected':
-            self._trigger_event('disconnect', run_async=False)
+            self._trigger_event('disconnect', self.reason.TRANSPORT_ERROR,
+                                run_async=False)
             try:
                 base_client.connected_clients.remove(self)
             except ValueError:  # pragma: no cover
@@ -530,7 +545,8 @@ class Client(base_client.BaseClient):
             self.logger.info('Waiting for write loop task to end')
             self.write_loop_task.join()
         if self.state == 'connected':
-            self._trigger_event('disconnect', run_async=False)
+            self._trigger_event('disconnect', self.reason.TRANSPORT_ERROR,
+                                run_async=False)
             try:
                 base_client.connected_clients.remove(self)
             except ValueError:  # pragma: no cover

engineio/middleware.py

@@ -2,7 +2,7 @@ import os
 from engineio.static_files import get_static_file
 
 
-class WSGIApp(object):
+class WSGIApp:
     """WSGI application middleware for Engine.IO.
 
     This middleware dispatches traffic to an Engine.IO application. It can
@@ -50,7 +50,7 @@ class WSGIApp(object):
             # directly into the environment. To give eventlet's WebSocket
             # module access to this socket when running under gunicorn, here we
             # copy the socket to the eventlet format.
-            class Input(object):
+            class Input:
                 def __init__(self, socket):
                     self.socket = socket
 

engineio/packet.py

@@ -7,7 +7,7 @@ packet_names = ['OPEN', 'CLOSE', 'PING', 'PONG', 'MESSAGE', 'UPGRADE', 'NOOP']
 binary_types = (bytes, bytearray)
 
 
-class Packet(object):
+class Packet:
     """Engine.IO packet."""
 
     json = _json

engineio/payload.py

@@ -3,7 +3,7 @@ import urllib
 from . import packet
 
 
-class Payload(object):
+class Payload:
     """Engine.IO payload."""
     max_decode_packets = 16
 

engineio/server.py

@@ -148,7 +148,7 @@ class Server(base_server.BaseServer):
                 with eio.session(sid) as session:
                     print('received message from ', session['username'])
         """
-        class _session_context_manager(object):
+        class _session_context_manager:
             def __init__(self, server, sid):
                 self.server = server
                 self.sid = sid
@@ -176,12 +176,12 @@ class Server(base_server.BaseServer):
                 # the socket was already closed or gone
                 pass
             else:
-                socket.close()
+                socket.close(reason=self.reason.SERVER_DISCONNECT)
                 if sid in self.sockets:  # pragma: no cover
                     del self.sockets[sid]
         else:
             for client in self.sockets.copy().values():
-                client.close()
+                client.close(reason=self.reason.SERVER_DISCONNECT)
             self.sockets = {}
 
     def handle_request(self, environ, start_response):
@@ -251,11 +251,11 @@ class Server(base_server.BaseServer):
                                  'bad-jsonp-index')
             r = self._bad_request('Invalid JSONP index number')
         elif method == 'GET':
+            upgrade_header = environ.get('HTTP_UPGRADE').lower() \
+                if 'HTTP_UPGRADE' in environ else None
             if sid is None:
                 # transport must be one of 'polling' or 'websocket'.
                 # if 'websocket', the HTTP_UPGRADE header must match.
-                upgrade_header = environ.get('HTTP_UPGRADE').lower() \
-                    if 'HTTP_UPGRADE' in environ else None
                 if transport == 'polling' \
                         or transport == upgrade_header == 'websocket':
                     r = self._handle_connect(environ, start_response,
@@ -266,34 +266,41 @@ class Server(base_server.BaseServer):
                     r = self._bad_request('Invalid websocket upgrade')
             else:
                 if sid not in self.sockets:
-                    self._log_error_once('Invalid session ' + sid, 'bad-sid')
-                    r = self._bad_request('Invalid session')
+                    self._log_error_once(f'Invalid session {sid}', 'bad-sid')
+                    r = self._bad_request(f'Invalid session {sid}')
                 else:
-                    socket = self._get_socket(sid)
-                    if self.transport(sid) != transport:
-                        self._log_error_once(
-                            'Invalid transport for session ' + sid,
-                            'bad-transport')
-                        r = self._bad_request('Invalid transport')
+                    try:
+                        socket = self._get_socket(sid)
+                    except KeyError as e:  # pragma: no cover
+                        self._log_error_once(f'{e} {sid}', 'bad-sid')
+                        r = self._bad_request(f'{e} {sid}')
                     else:
-                        try:
-                            packets = socket.handle_get_request(
-                                environ, start_response)
-                            if isinstance(packets, list):
-                                r = self._ok(packets, jsonp_index=jsonp_index)
-                            else:
-                                r = packets
-                        except exceptions.EngineIOError:
-                            if sid in self.sockets:  # pragma: no cover
-                                self.disconnect(sid)
-                            r = self._bad_request()
-                        if sid in self.sockets and self.sockets[sid].closed:
-                            del self.sockets[sid]
+                        if self.transport(sid) != transport and \
+                                transport != upgrade_header:
+                            self._log_error_once(
+                                f'Invalid transport for session {sid}',
+                                'bad-transport')
+                            r = self._bad_request('Invalid transport')
+                        else:
+                            try:
+                                packets = socket.handle_get_request(
+                                    environ, start_response)
+                                if isinstance(packets, list):
+                                    r = self._ok(packets,
+                                                 jsonp_index=jsonp_index)
+                                else:
+                                    r = packets
+                            except exceptions.EngineIOError:
+                                if sid in self.sockets:  # pragma: no cover
+                                    self.disconnect(sid)
+                                r = self._bad_request()
+                            if sid in self.sockets and \
+                                    self.sockets[sid].closed:
+                                del self.sockets[sid]
         elif method == 'POST':
             if sid is None or sid not in self.sockets:
-                self._log_error_once(
-                    'Invalid session ' + (sid or 'None'), 'bad-sid')
-                r = self._bad_request('Invalid session')
+                self._log_error_once(f'Invalid session {sid}', 'bad-sid')
+                r = self._bad_request(f'Invalid session {sid}')
             else:
                 socket = self._get_socket(sid)
                 try:
@@ -389,7 +396,9 @@ class Server(base_server.BaseServer):
             'upgrades': self._upgrades(sid, transport),
             'pingTimeout': int(self.ping_timeout * 1000),
             'pingInterval': int(
-                self.ping_interval + self.ping_interval_grace_period) * 1000})
+                self.ping_interval + self.ping_interval_grace_period) * 1000,
+            'maxPayload': self.max_http_buffer_size,
+        })
         s.send(pkt)
         s.schedule_ping()
 
@@ -437,7 +446,16 @@ class Server(base_server.BaseServer):
         if event in self.handlers:
             def run_handler():
                 try:
-                    return self.handlers[event](*args)
+                    try:
+                        return self.handlers[event](*args)
+                    except TypeError:
+                        if event == 'disconnect' and \
+                                len(args) == 2:  # pragma: no branch
+                            # legacy disconnect events do not have a reason
+                            # argument
+                            return self.handlers[event](args[0])
+                        else:  # pragma: no cover
+                            raise
                 except:
                     self.logger.exception(event + ' handler error')
                     if event == 'connect':

engineio/socket.py

@@ -48,7 +48,8 @@ class Socket(base_socket.BaseSocket):
         elif pkt.packet_type == packet.UPGRADE:
             self.send(packet.Packet(packet.NOOP))
         elif pkt.packet_type == packet.CLOSE:
-            self.close(wait=False, abort=True)
+            self.close(wait=False, abort=True,
+                       reason=self.server.reason.CLIENT_DISCONNECT)
         else:
             raise exceptions.UnknownPacketError()
 
@@ -63,7 +64,8 @@ class Socket(base_socket.BaseSocket):
             # Passing abort=False here will cause close() to write a
             # CLOSE packet. This has the effect of updating half-open sockets
             # to their correct state of disconnected
-            self.close(wait=False, abort=False)
+            self.close(wait=False, abort=False,
+                       reason=self.server.reason.PING_TIMEOUT)
             return False
         return True
 
@@ -97,7 +99,7 @@ class Socket(base_socket.BaseSocket):
             packets = self.poll()
         except exceptions.QueueEmpty:
             exc = sys.exc_info()
-            self.close(wait=False)
+            self.close(wait=False, reason=self.server.reason.TRANSPORT_ERROR)
             raise exc[1].with_traceback(exc[2])
         return packets
 
@@ -112,11 +114,14 @@ class Socket(base_socket.BaseSocket):
             for pkt in p.packets:
                 self.receive(pkt)
 
-    def close(self, wait=True, abort=False):
+    def close(self, wait=True, abort=False, reason=None):
         """Close the socket connection."""
         if not self.closed and not self.closing:
             self.closing = True
-            self.server._trigger_event('disconnect', self.sid, run_async=False)
+            self.server._trigger_event(
+                'disconnect', self.sid,
+                reason or self.server.reason.SERVER_DISCONNECT,
+                run_async=False)
             if not abort:
                 self.send(packet.Packet(packet.CLOSE))
             self.closed = True
@@ -137,7 +142,7 @@ class Socket(base_socket.BaseSocket):
     def _upgrade_websocket(self, environ, start_response):
         """Upgrade the connection from polling to websocket."""
         if self.upgraded:
-            raise IOError('Socket has been upgraded already')
+            raise OSError('Socket has been upgraded already')
         if self.server._async['websocket'] is None:
             # the selected async mode does not support websocket
             return self.server._bad_request()

{python_engineio-4.10.0.dist-info → python_engineio-4.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-engineio
-Version: 4.10.0
+Version: 4.11.0
 Summary: Engine.IO server and client for Python
 Author-email: Miguel Grinberg <miguel.grinberg@gmail.com>
 Project-URL: Homepage, https://github.com/miguelgrinberg/python-engineio
@@ -13,14 +13,14 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: simple-websocket >=0.10.0
-Provides-Extra: asyncio_client
-Requires-Dist: aiohttp >=3.4 ; extra == 'asyncio_client'
+Requires-Dist: simple-websocket>=0.10.0
 Provides-Extra: client
-Requires-Dist: requests >=2.21.0 ; extra == 'client'
-Requires-Dist: websocket-client >=0.54.0 ; extra == 'client'
+Requires-Dist: requests>=2.21.0; extra == "client"
+Requires-Dist: websocket-client>=0.54.0; extra == "client"
+Provides-Extra: asyncio-client
+Requires-Dist: aiohttp>=3.4; extra == "asyncio-client"
 Provides-Extra: docs
-Requires-Dist: sphinx ; extra == 'docs'
+Requires-Dist: sphinx; extra == "docs"
 
 python-engineio
 ===============

python_engineio-4.11.0.dist-info/RECORD

@@ -0,0 +1,31 @@
+engineio/__init__.py,sha256=0R2PY1EXu3sicP7mkA0_QxEVGRlFlgvsxfhByqREE1A,481
+engineio/async_client.py,sha256=jBy7ytWawPpP3b_52U7YU7G85wbWjMsdw_29y3e_BqA,29548
+engineio/async_server.py,sha256=8Af_uwf8mKOCJGqVKa3QN0kz7_B2K1cdpSmsvkAoBR4,27412
+engineio/async_socket.py,sha256=nHY0DPPk0FtI9djUnQWtzZ3ce2OD184Tu-Dop7JLg9I,10715
+engineio/base_client.py,sha256=uEI6OglvhdIGD1DAZuptbn0KXQMk_o3w0AH4wJvPwZ0,5322
+engineio/base_server.py,sha256=H-aKQ9hMQjiIrjDaqbw_edw9yUVIbCQMzyIy9egLv-g,14458
+engineio/base_socket.py,sha256=sQqbNSfGhMQG3xzwar6IXMal28C7Q5TIAQRGp74Wt2o,399
+engineio/client.py,sha256=wfgB_MrpEh-v4dBt6W2eW6i0CRNEP0CIJ6d4Ap4CnZE,27227
+engineio/exceptions.py,sha256=FyuMb5qhX9CUYP3fEoe1m-faU96ApdQTSbblaaoo8LA,292
+engineio/json.py,sha256=SG5FTojqd1ix6u0dKXJsZVqqdYioZLO4S2GPL7BKl3U,405
+engineio/middleware.py,sha256=5NKBXz-ftuFErUB_V9IDvRHaSOsjhtW-NnuJtquB1nc,3750
+engineio/packet.py,sha256=Tejm9U5JcYs5LwZ_n_Xh0PIRv-U_JbHwGEivNXQN4eg,3181
+engineio/payload.py,sha256=GIWu0Vnay4WNZlDxHqVgP34tKTBXX58OArJ-mO5zD3E,1539
+engineio/server.py,sha256=4_xdtH0tyusigQurwOeDFrHtodthFTOIbOVZ-_ckh5U,22957
+engineio/socket.py,sha256=K5gSY5PTi6rZy4meP9CtTYsNlEU2JmsonYDDHfJVFI4,10280
+engineio/static_files.py,sha256=pwez9LQFaSQXMbtI0vLyD6UDiokQ4rNfmRYgVLKOthc,2064
+engineio/async_drivers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+engineio/async_drivers/_websocket_wsgi.py,sha256=LuOEfKhbAw8SplB5PMpYKIUqfCPEadQEpqeiq_leOIA,949
+engineio/async_drivers/aiohttp.py,sha256=OBDGhaNXWHxQkwhzZT2vlTAOqWReGS6Sjk9u3BEh_Mc,3754
+engineio/async_drivers/asgi.py,sha256=mBu109j7R6esH-wI62jvTnfVAEjWvw2YNp0dZ74NyHg,11210
+engineio/async_drivers/eventlet.py,sha256=n1y4OjPdj4J2GIep5N56O29oa5NQgFJVcTBjyO1C-Gs,1735
+engineio/async_drivers/gevent.py,sha256=hnJHeWdDQE2jfoLCP5DnwVPzsQlcTLJUMA5EVf1UL-k,2962
+engineio/async_drivers/gevent_uwsgi.py,sha256=m6ay5dov9FDQl0fbeiKeE-Orh5LiF6zLlYQ64Oa3T5g,5954
+engineio/async_drivers/sanic.py,sha256=VvHZlkOBdHPkA620-Z9EdzpPp-O-KhMgS-h7RCuw_a4,4516
+engineio/async_drivers/threading.py,sha256=ywmG59d4H6OHZjKarBN97-9BHEsRxFEz9YN-E9QAu_I,463
+engineio/async_drivers/tornado.py,sha256=mbVHs1mECfzFSNv33uigkpTBtNPT0u49k5zaybewdIo,5893
+python_engineio-4.11.0.dist-info/LICENSE,sha256=yel9Pbwfu82094CLKCzWRtuIev9PUxP-a76NTDFAWpw,1082
+python_engineio-4.11.0.dist-info/METADATA,sha256=ptID9L-diLLf_PVNRydyfripogmQvTtlqerR9yURhMA,2237
+python_engineio-4.11.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+python_engineio-4.11.0.dist-info/top_level.txt,sha256=u8PmNisCZLwRYcWrNLe9wutQ2tt4zNi8IH362c-HWuA,9
+python_engineio-4.11.0.dist-info/RECORD,,

{python_engineio-4.10.0.dist-info → python_engineio-4.11.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

python_engineio-4.10.0.dist-info/RECORD

@@ -1,31 +0,0 @@
-engineio/__init__.py,sha256=0R2PY1EXu3sicP7mkA0_QxEVGRlFlgvsxfhByqREE1A,481
-engineio/async_client.py,sha256=jC7T6r_ya9LV46q4OdIQ041-3uLlRr6aUt__YmHNPEM,27950
-engineio/async_server.py,sha256=q29JCvIpCriUXZoqHwjJUwV2bK2MRypMQptROGw6imI,25738
-engineio/async_socket.py,sha256=P8OZW1N5y7jr2hW1qLLK2y_Clt7aHdv2ucYW69mbU4Q,10305
-engineio/base_client.py,sha256=Q_w0Stvy89wPHwWk7411dRxpGjxNPypm4xy_4XMPZ9M,4872
-engineio/base_server.py,sha256=Em2RRpbohulKjmYTWHnf_lALKvTT_jHr442Rr2g_BEQ,14013
-engineio/base_socket.py,sha256=Bw6TWv1pnlXcDdqT59C5CyTaBi7l-_mkykIUuZLjz-g,400
-engineio/client.py,sha256=m_eLSes3b-mE5MYajELquSktkAWceCNGZOtUU78as50,26285
-engineio/exceptions.py,sha256=FyuMb5qhX9CUYP3fEoe1m-faU96ApdQTSbblaaoo8LA,292
-engineio/json.py,sha256=SG5FTojqd1ix6u0dKXJsZVqqdYioZLO4S2GPL7BKl3U,405
-engineio/middleware.py,sha256=BF_qHAIZZnIbfiP256SD1CX3kzNWbSuto1cpih8oIFg,3766
-engineio/packet.py,sha256=ETMeLgdpZghXK9fth93IZO8pIft6Sg3d1QGpyTx4xBE,3189
-engineio/payload.py,sha256=2iLIFgIweTWkLok_UZ5zCgELmRSGyUUI5eeYcEerFSs,1547
-engineio/server.py,sha256=v0QnoLCD1ReVAhzQRn5keHmjZ61jEJXNQeikfXaELl0,21926
-engineio/socket.py,sha256=dasec3jXoV2eR1jmIrhEIfHzyUuuv8FwvxLB3DpyjeY,9996
-engineio/static_files.py,sha256=pwez9LQFaSQXMbtI0vLyD6UDiokQ4rNfmRYgVLKOthc,2064
-engineio/async_drivers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-engineio/async_drivers/_websocket_wsgi.py,sha256=FGoRBGOUsEtlfklYNylR0o3oLOGmXIR8QzaCsGLgr3I,949
-engineio/async_drivers/aiohttp.py,sha256=zJdujjO6dSL_oKDDr4xfO4ID_Vd8faEp1AOIW4ogKME,3768
-engineio/async_drivers/asgi.py,sha256=mvCErNpYw1T7XE_1Ixb0YQN0YqJkKMpWqNV5_tZQYMg,11011
-engineio/async_drivers/eventlet.py,sha256=_ZgPg0HTx_yhSm5iBcd3ez01yMg3KRFmb2ycKD8o8pY,1775
-engineio/async_drivers/gevent.py,sha256=hnJHeWdDQE2jfoLCP5DnwVPzsQlcTLJUMA5EVf1UL-k,2962
-engineio/async_drivers/gevent_uwsgi.py,sha256=cnjCsnDHTa6rKgwDKD6rLvIw1Yun-g4c1QbujOC_bMY,5962
-engineio/async_drivers/sanic.py,sha256=SY0HIp5DUHF7B55tJCBB_8qDjrRTD_FyNQ2cIwRIGR8,4538
-engineio/async_drivers/threading.py,sha256=ywmG59d4H6OHZjKarBN97-9BHEsRxFEz9YN-E9QAu_I,463
-engineio/async_drivers/tornado.py,sha256=9bB7FvY47Snx_h4rsNwRk5wIINf2ju7hXWTAqF3intA,5909
-python_engineio-4.10.0.dist-info/LICENSE,sha256=yel9Pbwfu82094CLKCzWRtuIev9PUxP-a76NTDFAWpw,1082
-python_engineio-4.10.0.dist-info/METADATA,sha256=SaBVFlF_cqRa2i_sQ3Fdiaz6GdxT1qASxZpSugLD57A,2245
-python_engineio-4.10.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-python_engineio-4.10.0.dist-info/top_level.txt,sha256=u8PmNisCZLwRYcWrNLe9wutQ2tt4zNi8IH362c-HWuA,9
-python_engineio-4.10.0.dist-info/RECORD,,