python-engineio 4.9.0__tar.gz → 4.10.0__tar.gz

{python-engineio-4.9.0/src/python_engineio.egg-info → python_engineio-4.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-engineio
-Version: 4.9.0
+Version: 4.10.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

{python-engineio-4.9.0 → python_engineio-4.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-engineio"
-version = "4.9.0"
+version = "4.10.0"
 authors = [{name = "Miguel Grinberg", email = "miguel.grinberg@gmail.com"}]
 description = "Engine.IO server and client for Python"
 classifiers = [

{python-engineio-4.9.0 → python_engineio-4.10.0}/src/engineio/async_client.py

@@ -62,7 +62,7 @@ class AsyncClient(base_client.BaseClient):
     :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.
+                         servers, SSL certificates, custom CA bundle, etc.
     :param ssl_verify: ``True`` to verify SSL certificates, or ``False`` to
                        skip SSL certificate verification, allowing
                        connections to servers with self signed certificates.

{python-engineio-4.9.0 → python_engineio-4.10.0}/src/engineio/async_drivers/asgi.py

@@ -19,7 +19,12 @@ class ASGIApp:
     :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.
+                          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
@@ -44,24 +49,27 @@ class ASGIApp:
         self.engineio_server = engineio_server
         self.other_asgi_app = other_asgi_app
         self.engineio_path = engineio_path
-        if not self.engineio_path.startswith('/'):
-            self.engineio_path = '/' + self.engineio_path
-        if not self.engineio_path.endswith('/'):
-            self.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'] in ['http', 'websocket'] and \
-                scope['path'].startswith(self.engineio_path):
+        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 scope['type'] == 'lifespan':
-                await self.lifespan(scope, receive, send)
-            elif static_file and os.path.exists(static_file['filename']):
+            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)
@@ -120,6 +128,11 @@ class ASGIApp:
         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(object):  # pragma: no cover

{python-engineio-4.9.0 → python_engineio-4.10.0}/src/engineio/async_drivers/eventlet.py

@@ -25,7 +25,7 @@ class EventletThread:  # pragma: no cover
             return self.g.wait()
 
 
-class WebSocketWSGI(_WebSocketWSGI):
+class WebSocketWSGI(_WebSocketWSGI):  # pragma: no cover
     def __init__(self, handler, server):
         try:
             super().__init__(

{python-engineio-4.9.0 → python_engineio-4.10.0}/src/engineio/async_server.py

@@ -70,6 +70,10 @@ class AsyncServer(base_server.BaseServer):
     :param async_handlers: If set to ``True``, run message event handlers in
                            non-blocking threads. To run handlers synchronously,
                            set to ``False``. 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 transports: The list of allowed transports. Valid transports
                        are ``'polling'`` and ``'websocket'``. Defaults to
                        ``['polling', 'websocket']``.
@@ -284,18 +288,24 @@ class AsyncServer(base_server.BaseServer):
                     r = self._bad_request('Invalid session ' + sid)
                 else:
                     socket = self._get_socket(sid)
-                    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:
+                        self._log_error_once(
+                            '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')
@@ -524,9 +534,9 @@ class AsyncServer(base_server.BaseServer):
                 try:
                     await asyncio.wait_for(self.service_task_event.wait(),
                                            timeout=self.ping_timeout)
-                except asyncio.TimeoutError:
                     break
-                continue
+                except asyncio.TimeoutError:
+                    continue
 
             # go through the entire client list in a ping interval cycle
             sleep_interval = self.ping_timeout / len(self.sockets)
@@ -546,8 +556,9 @@ class AsyncServer(base_server.BaseServer):
                     try:
                         await asyncio.wait_for(self.service_task_event.wait(),
                                                timeout=sleep_interval)
-                    except asyncio.TimeoutError:
                         raise KeyboardInterrupt()
+                    except asyncio.TimeoutError:
+                        continue
             except (
                 SystemExit,
                 KeyboardInterrupt,

{python-engineio-4.9.0 → python_engineio-4.10.0}/src/engineio/client.py

@@ -494,7 +494,7 @@ class Client(base_client.BaseClient):
             p = None
             try:
                 p = self.ws.recv()
-                if len(p) == 0:  # pragma: no cover
+                if len(p) == 0 and not self.ws.connected:  # pragma: no cover
                     # websocket client can return an empty string after close
                     raise websocket.WebSocketConnectionClosedException()
             except websocket.WebSocketTimeoutException:
@@ -510,8 +510,7 @@ class Client(base_client.BaseClient):
             except Exception as e:  # pragma: no cover
                 if type(e) is OSError and e.errno == 9:
                     self.logger.info(
-                        'WebSocket connection is closing, aborting',
-                        str(e))
+                        'WebSocket connection is closing, aborting')
                 else:
                     self.logger.info(
                         'Unexpected error receiving packet: "%s", aborting',

{python-engineio-4.9.0 → python_engineio-4.10.0}/src/engineio/server.py

@@ -180,7 +180,7 @@ class Server(base_server.BaseServer):
                 if sid in self.sockets:  # pragma: no cover
                     del self.sockets[sid]
         else:
-            for client in self.sockets.values():
+            for client in self.sockets.copy().values():
                 client.close()
             self.sockets = {}
 
@@ -270,19 +270,25 @@ class Server(base_server.BaseServer):
                     r = self._bad_request('Invalid session')
                 else:
                     socket = self._get_socket(sid)
-                    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:
+                        self._log_error_once(
+                            '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(

{python-engineio-4.9.0 → python_engineio-4.10.0/src/python_engineio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-engineio
-Version: 4.9.0
+Version: 4.10.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

{python-engineio-4.9.0 → python_engineio-4.10.0}/src/python_engineio.egg-info/SOURCES.txt

@@ -56,7 +56,6 @@ tests/async/test_socket.py
 tests/async/test_tornado.py
 tests/common/__init__.py
 tests/common/index.html
-tests/common/test_async_eventlet.py
 tests/common/test_client.py
 tests/common/test_middleware.py
 tests/common/test_packet.py

{python-engineio-4.9.0 → python_engineio-4.10.0}/tests/async/test_asgi.py

@@ -38,12 +38,55 @@ class AsgiTests(unittest.TestCase):
     def test_engineio_routing(self):
         mock_server = mock.MagicMock()
         mock_server.handle_request = AsyncMock()
+
         app = async_asgi.ASGIApp(mock_server)
         scope = {'type': 'http', 'path': '/engine.io/'}
         _run(app(scope, 'receive', 'send'))
         mock_server.handle_request.mock.assert_called_once_with(
             scope, 'receive', 'send'
         )
+        mock_server.handle_request.mock.reset_mock()
+        scope = {'type': 'http', 'path': '/engine.io/'}
+        _run(app(scope, 'receive', 'send'))
+        mock_server.handle_request.mock.assert_called_once_with(
+            scope, 'receive', 'send'
+        )
+        mock_server.handle_request.mock.reset_mock()
+        scope = {'type': 'http', 'path': '/engine.iofoo/'}
+        _run(app(scope, 'receive', AsyncMock()))
+        mock_server.handle_request.mock.assert_not_called()
+
+        app = async_asgi.ASGIApp(mock_server, engineio_path=None)
+        mock_server.handle_request.mock.reset_mock()
+        scope = {'type': 'http', 'path': '/foo'}
+        _run(app(scope, 'receive', 'send'))
+        mock_server.handle_request.mock.assert_called_once_with(
+            scope, 'receive', 'send'
+        )
+
+        app = async_asgi.ASGIApp(mock_server, engineio_path='mysocket.io')
+        mock_server.handle_request.mock.reset_mock()
+        scope = {'type': 'http', 'path': '/mysocket.io'}
+        _run(app(scope, 'receive', 'send'))
+        mock_server.handle_request.mock.assert_called_once_with(
+            scope, 'receive', 'send'
+        )
+        mock_server.handle_request.mock.reset_mock()
+        scope = {'type': 'http', 'path': '/mysocket.io/'}
+        _run(app(scope, 'receive', 'send'))
+        mock_server.handle_request.mock.assert_called_once_with(
+            scope, 'receive', 'send'
+        )
+        mock_server.handle_request.mock.reset_mock()
+        scope = {'type': 'http', 'path': '/mysocket.io/foo'}
+        _run(app(scope, 'receive', 'send'))
+        mock_server.handle_request.mock.assert_called_once_with(
+            scope, 'receive', 'send'
+        )
+        mock_server.handle_request.mock.reset_mock()
+        scope = {'type': 'http', 'path': '/mysocket.iofoo'}
+        _run(app(scope, 'receive', AsyncMock()))
+        mock_server.handle_request.mock.assert_not_called()
 
     def test_other_app_routing(self):
         other_app = AsyncMock()
@@ -514,3 +557,30 @@ class AsgiTests(unittest.TestCase):
         environ['asgi.send'].mock.assert_called_with(
             {'type': 'websocket.close'}
         )
+
+    def test_sub_app_routing(self):
+
+        class ASGIDispatcher:
+            def __init__(self, routes):
+                self.routes = routes
+
+            async def __call__(self, scope, receive, send):
+                path = scope['path']
+                for prefix, app in self.routes.items():
+                    if path.startswith(prefix):
+                        await app(scope, receive, send)
+                        return
+                assert False, 'No route found'
+
+        other_app = AsyncMock()
+        mock_server = mock.MagicMock()
+        mock_server.handle_request = AsyncMock()
+        eio_app = async_asgi.ASGIApp(mock_server, engineio_path=None)
+        root_app = ASGIDispatcher({'/foo': other_app, '/eio': eio_app})
+        scope = {'type': 'http', 'path': '/foo/bar'}
+        _run(root_app(scope, 'receive', 'send'))
+        other_app.mock.assert_called_once_with(scope, 'receive', 'send')
+        scope = {'type': 'http', 'path': '/eio/'}
+        _run(root_app(scope, 'receive', 'send'))
+        eio_app.engineio_server.handle_request.mock.assert_called_once_with(
+            scope, 'receive', 'send')

{python-engineio-4.9.0 → python_engineio-4.10.0}/tests/async/test_server.py

@@ -659,6 +659,32 @@ class TestAsyncServer(unittest.TestCase):
         assert len(s.sockets) == 0
         assert a._async['make_response'].call_args[0][0] == '400 BAD REQUEST'
 
+    @mock.patch('importlib.import_module')
+    def test_get_request_bad_websocket_transport(self, import_module):
+        a = self.get_async_mock(
+            {'REQUEST_METHOD': 'GET',
+             'QUERY_STRING': 'EIO=4&transport=websocket&sid=foo'}
+        )
+        import_module.side_effect = [a]
+        s = async_server.AsyncServer()
+        s.sockets['foo'] = mock_socket = self._get_mock_socket()
+        mock_socket.upgraded = False
+        _run(s.handle_request('request'))
+        assert a._async['make_response'].call_args[0][0] == '400 BAD REQUEST'
+
+    @mock.patch('importlib.import_module')
+    def test_get_request_bad_polling_transport(self, import_module):
+        a = self.get_async_mock(
+            {'REQUEST_METHOD': 'GET',
+             'QUERY_STRING': 'EIO=4&transport=polling&sid=foo'}
+        )
+        import_module.side_effect = [a]
+        s = async_server.AsyncServer()
+        s.sockets['foo'] = mock_socket = self._get_mock_socket()
+        mock_socket.upgraded = True
+        _run(s.handle_request('request'))
+        assert a._async['make_response'].call_args[0][0] == '400 BAD REQUEST'
+
     @mock.patch('importlib.import_module')
     def test_post_request_with_bad_sid(self, import_module):
         a = self.get_async_mock(

{python-engineio-4.9.0 → python_engineio-4.10.0}/tests/common/test_server.py

@@ -111,6 +111,14 @@ class TestServer(unittest.TestCase):
         del sys.modules['engineio.async_drivers.threading']
 
     def test_async_mode_eventlet(self):
+        sys.modules['eventlet'] = mock.MagicMock()
+        sys.modules['eventlet'].green = mock.MagicMock()
+        sys.modules['eventlet.green'] = sys.modules['eventlet'].green
+        sys.modules['eventlet.green'].threading = mock.MagicMock()
+        sys.modules['eventlet.green.threading'] = \
+            sys.modules['eventlet.green'].threading
+        sys.modules['eventlet'].websocket = mock.MagicMock()
+        sys.modules['eventlet.websocket'] = sys.modules['eventlet'].websocket
         s = server.Server(async_mode='eventlet')
         assert s.async_mode == 'eventlet'
 
@@ -120,6 +128,11 @@ class TestServer(unittest.TestCase):
         assert s._async['thread'] == async_eventlet.EventletThread
         assert s._async['queue'] == queue.Queue
         assert s._async['websocket'] == async_eventlet.WebSocketWSGI
+        del sys.modules['eventlet']
+        del sys.modules['eventlet.green']
+        del sys.modules['eventlet.green.threading']
+        del sys.modules['eventlet.websocket']
+        del sys.modules['engineio.async_drivers.eventlet']
 
     @mock.patch('importlib.import_module', side_effect=_mock_import)
     def test_async_mode_gevent_uwsgi(self, import_module):
@@ -228,7 +241,10 @@ class TestServer(unittest.TestCase):
         with pytest.raises(ValueError):
             server.Server(async_mode='foo')
 
-    @mock.patch('importlib.import_module', side_effect=[_mock_async])
+    @mock.patch(
+        'importlib.import_module',
+        side_effect=[_mock_async],
+    )
     def test_async_mode_auto_eventlet(self, import_module):
         s = server.Server()
         assert s.async_mode == 'eventlet'
@@ -867,6 +883,28 @@ class TestServer(unittest.TestCase):
         assert start_response.call_args[0][0] == '400 BAD REQUEST'
         assert len(s.sockets) == 0
 
+    def test_get_request_bad_websocket_transport(self):
+        s = server.Server()
+        mock_socket = self._get_mock_socket()
+        mock_socket.upgraded = False
+        s.sockets['foo'] = mock_socket
+        environ = {'REQUEST_METHOD': 'GET',
+                   'QUERY_STRING': 'EIO=4&transport=websocket&sid=foo'}
+        start_response = mock.MagicMock()
+        s.handle_request(environ, start_response)
+        assert start_response.call_args[0][0] == '400 BAD REQUEST'
+
+    def test_get_request_bad_polling_transport(self):
+        s = server.Server()
+        mock_socket = self._get_mock_socket()
+        mock_socket.upgraded = True
+        s.sockets['foo'] = mock_socket
+        environ = {'REQUEST_METHOD': 'GET',
+                   'QUERY_STRING': 'EIO=4&transport=polling&sid=foo'}
+        start_response = mock.MagicMock()
+        s.handle_request(environ, start_response)
+        assert start_response.call_args[0][0] == '400 BAD REQUEST'
+
     def test_post_request(self):
         s = server.Server()
         mock_socket = self._get_mock_socket()

{python-engineio-4.9.0 → python_engineio-4.10.0}/tox.ini

@@ -1,5 +1,5 @@
 [tox]
-envlist=flake8,py38,py39,py310,py311,py312,pypy3,docs
+envlist=flake8,py38,py39,py310,py311,py312,py313,pypy3,docs
 skip_missing_interpreters=True
 
 [gh-actions]
@@ -9,6 +9,7 @@ python =
     3.10: py310
     3.11: py311
     3.12: py312
+    3.13: py313
     pypy-3: pypy3
 
 [testenv]
@@ -18,7 +19,6 @@ commands=
 deps=
     pytest
     pytest-cov
-    eventlet
     aiohttp
     tornado
     requests

python-engineio-4.9.0/tests/common/test_async_eventlet.py

@@ -1,29 +0,0 @@
-import logging
-import unittest
-from unittest import mock
-
-from engineio.async_drivers import eventlet as async_eventlet
-import pytest
-
-
-class TestAsyncEventlet(unittest.TestCase):
-    def setUp(self):
-        logging.getLogger('engineio').setLevel(logging.NOTSET)
-
-    def test_bad_environ(self):
-        wsgi = async_eventlet.WebSocketWSGI(None, mock.MagicMock())
-        environ = {'foo': 'bar'}
-        start_response = 'bar'
-        with pytest.raises(RuntimeError):
-            wsgi(environ, start_response)
-
-    @mock.patch(
-        'engineio.async_drivers.eventlet._WebSocketWSGI.__call__',
-        return_value='data',
-    )
-    def test_wsgi_call(self, _WebSocketWSGI):
-        _WebSocketWSGI.__call__ = lambda e, s: 'data'
-        environ = {'eventlet.input': mock.MagicMock()}
-        start_response = 'bar'
-        wsgi = async_eventlet.WebSocketWSGI(None, mock.MagicMock())
-        assert wsgi(environ, start_response) == 'data'