python-socketio 5.11.2__tar.gz → 5.11.3__tar.gz

{python-socketio-5.11.2/src/python_socketio.egg-info → python_socketio-5.11.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-socketio
-Version: 5.11.2
+Version: 5.11.3
 Summary: Socket.IO server and client for Python
 Author-email: Miguel Grinberg <miguel.grinberg@gmail.com>
 Project-URL: Homepage, https://github.com/miguelgrinberg/python-socketio

{python-socketio-5.11.2 → python_socketio-5.11.3}/docs/intro.rst

@@ -101,9 +101,8 @@ Client Features
 ---------------
 
 - Can connect to other Socket.IO servers that are compatible with the
-  JavaScript Socket.IO 1.x and 2.x releases. Work to support release 3.x is in
-  progress.
-- Compatible with Python 3.6+.
+  JavaScript Socket.IO reference server.
+- Compatible with Python 3.8+.
 - Two versions of the client, one for standard Python and another for
   asyncio.
 - Uses an event-based architecture implemented with decorators that
@@ -181,9 +180,8 @@ Server Features
 ---------------
 
 - Can connect to servers running other Socket.IO clients that are compatible
-  with the JavaScript client versions 1.x and 2.x. Work to support the 3.x
-  release is in progress.
-- Compatible with Python 3.6+.
+  with the JavaScript reference client.
+- Compatible with Python 3.8+.
 - Two versions of the server, one for standard Python and another for
   asyncio.
 - Supports large number of clients even on modest hardware due to being
@@ -195,8 +193,8 @@ Server Features
 - Can be integrated with WSGI applications written in frameworks such as Flask, Django,
   etc.
 - Can be integrated with `aiohttp <http://aiohttp.readthedocs.io/>`_,
-  `sanic <http://sanic.readthedocs.io/>`_ and `tornado <http://www.tornadoweb.org/>`_
-  ``asyncio`` applications.
+  `FastAPI <https://fastapi.tiangolo.com/>`_, `sanic <http://sanic.readthedocs.io/>`_
+  and `tornado <http://www.tornadoweb.org/>`_ ``asyncio`` applications.
 - Broadcasting of messages to all connected clients, or to subsets of them
   assigned to "rooms".
 - Optional support for multiple servers, connected through a messaging queue

{python-socketio-5.11.2 → python_socketio-5.11.3}/docs/server.rst

@@ -722,7 +722,7 @@ ASGI web application and the Socket.IO server as a bundle::
    sio = socketio.AsyncServer(async_mode='asgi')
    app = socketio.ASGIApp(sio, other_app)
 
-The ``ASGIApp`` instance is a fully complaint ASGI instance that can be
+The ``ASGIApp`` instance is a fully compliant ASGI instance that can be
 deployed with an ASGI compatible web server.
 
 Aiohttp
@@ -947,7 +947,7 @@ constructor::
     sio = socketio.Server(async_mode='threading')
 
 A server configured for threading is deployed as a regular web application,
-using any WSGI complaint multi-threaded server. The example below deploys an
+using any WSGI compliant multi-threaded server. The example below deploys an
 Socket.IO application combined with a Flask web application, using Flask's
 development web server based on Werkzeug::
 

{python-socketio-5.11.2 → python_socketio-5.11.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-socketio"
-version = "5.11.2"
+version = "5.11.3"
 authors = [
     { name = "Miguel Grinberg", email = "miguel.grinberg@gmail.com" },
 ]

{python-socketio-5.11.2 → python_socketio-5.11.3/src/python_socketio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-socketio
-Version: 5.11.2
+Version: 5.11.3
 Summary: Socket.IO server and client for Python
 Author-email: Miguel Grinberg <miguel.grinberg@gmail.com>
 Project-URL: Homepage, https://github.com/miguelgrinberg/python-socketio

{python-socketio-5.11.2 → python_socketio-5.11.3}/src/socketio/async_client.py

@@ -53,11 +53,14 @@ 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.
                        The default is ``True``.
+    :param websocket_extra_options: Dictionary containing additional keyword
+                                    arguments passed to
+                                    ``websocket.create_connection()``.
     :param engineio_logger: To enable Engine.IO logging set to ``True`` or pass
                             a logger object to use. To disable logging set to
                             ``False``. The default is ``False``. Note that
@@ -128,6 +131,8 @@ class AsyncClient(base_client.BaseClient):
         if namespaces is None:
             namespaces = list(set(self.handlers.keys()).union(
                 set(self.namespace_handlers.keys())))
+            if '*' in namespaces:
+                namespaces.remove('*')
             if len(namespaces) == 0:
                 namespaces = ['/']
         elif isinstance(namespaces, str):
@@ -318,6 +323,21 @@ class AsyncClient(base_client.BaseClient):
                                     namespace=n))
         await self.eio.disconnect(abort=True)
 
+    async def shutdown(self):
+        """Stop the client.
+
+        If the client is connected to a server, it is disconnected. If the
+        client is attempting to reconnect to server, the reconnection attempts
+        are stopped. If the client is not connected to a server and is not
+        attempting to reconnect, then this function does nothing.
+        """
+        if self.connected:
+            await self.disconnect()
+        elif self._reconnect_task:  # pragma: no branch
+            self._reconnect_abort.set()
+            print(self._reconnect_task)
+            await self._reconnect_task
+
     def start_background_task(self, target, *args, **kwargs):
         """Start a background task using the appropriate async model.
 
@@ -467,15 +487,20 @@ class AsyncClient(base_client.BaseClient):
             self.logger.info(
                 'Connection failed, new attempt in {:.02f} seconds'.format(
                     delay))
+            abort = False
             try:
                 await asyncio.wait_for(self._reconnect_abort.wait(), delay)
+                abort = True
+            except asyncio.TimeoutError:
+                pass
+            except asyncio.CancelledError:  # pragma: no cover
+                abort = True
+            if abort:
                 self.logger.info('Reconnect task aborted')
                 for n in self.connection_namespaces:
                     await self._trigger_event('__disconnect_final',
                                               namespace=n)
                 break
-            except (asyncio.TimeoutError, asyncio.CancelledError):
-                pass
             attempt_count += 1
             try:
                 await self.connect(self.connection_url,

{python-socketio-5.11.2 → python_socketio-5.11.3}/src/socketio/async_server.py

@@ -102,6 +102,9 @@ class AsyncServer(base_server.BaseServer):
                             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']``.
     :param engineio_logger: To enable Engine.IO logging set to ``True`` or pass
                             a logger object to use. To disable logging set to
                             ``False``. The default is ``False``. Note that

{python-socketio-5.11.2 → python_socketio-5.11.3}/src/socketio/client.py

@@ -56,11 +56,14 @@ class Client(base_client.BaseClient):
     :param http_session: an initialized ``requests.Session`` object to be used
                          when sending requests to the server. Use it if you
                          need to add special client options such as proxy
-                         servers, SSL certificates, etc.
+                         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.
                        The default is ``True``.
+    :param websocket_extra_options: Dictionary containing additional keyword
+                                    arguments passed to
+                                    ``websocket.create_connection()``.
     :param engineio_logger: To enable Engine.IO logging set to ``True`` or pass
                             a logger object to use. To disable logging set to
                             ``False``. The default is ``False``. Note that
@@ -126,6 +129,8 @@ class Client(base_client.BaseClient):
         if namespaces is None:
             namespaces = list(set(self.handlers.keys()).union(
                 set(self.namespace_handlers.keys())))
+            if '*' in namespaces:
+                namespaces.remove('*')
             if len(namespaces) == 0:
                 namespaces = ['/']
         elif isinstance(namespaces, str):
@@ -298,6 +303,20 @@ class Client(base_client.BaseClient):
                 packet.DISCONNECT, namespace=n))
         self.eio.disconnect(abort=True)
 
+    def shutdown(self):
+        """Stop the client.
+
+        If the client is connected to a server, it is disconnected. If the
+        client is attempting to reconnect to server, the reconnection attempts
+        are stopped. If the client is not connected to a server and is not
+        attempting to reconnect, then this function does nothing.
+        """
+        if self.connected:
+            self.disconnect()
+        elif self._reconnect_task:  # pragma: no branch
+            self._reconnect_abort.set()
+            self._reconnect_task.join()
+
     def start_background_task(self, target, *args, **kwargs):
         """Start a background task using the appropriate async model.
 

{python-socketio-5.11.2 → python_socketio-5.11.3}/src/socketio/packet.py

@@ -185,6 +185,6 @@ class Packet(object):
             'data': self.data,
             'nsp': self.namespace,
         }
-        if self.id:
+        if self.id is not None:
             d['id'] = self.id
         return d

{python-socketio-5.11.2 → python_socketio-5.11.3}/src/socketio/server.py

@@ -106,6 +106,9 @@ class Server(base_server.BaseServer):
                             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']``.
     :param engineio_logger: To enable Engine.IO logging set to ``True`` or pass
                             a logger object to use. To disable logging set to
                             ``False``. The default is ``False``. Note that

{python-socketio-5.11.2 → python_socketio-5.11.3}/tests/async/test_client.py

@@ -98,6 +98,7 @@ class TestAsyncClient(unittest.TestCase):
         c.eio.connect = AsyncMock()
         c.on('foo', mock.MagicMock(), namespace='/foo')
         c.on('bar', mock.MagicMock(), namespace='/')
+        c.on('baz', mock.MagicMock(), namespace='*')
         _run(
             c.connect(
                 'url',
@@ -990,6 +991,66 @@ class TestAsyncClient(unittest.TestCase):
         c._trigger_event.mock.assert_called_once_with('__disconnect_final',
                                                       namespace='/')
 
+    def test_shutdown_disconnect(self):
+        c = async_client.AsyncClient()
+        c.connected = True
+        c.namespaces = {'/': '1'}
+        c._trigger_event = AsyncMock()
+        c._send_packet = AsyncMock()
+        c.eio = mock.MagicMock()
+        c.eio.disconnect = AsyncMock()
+        c.eio.state = 'connected'
+        _run(c.shutdown())
+        assert c._trigger_event.mock.call_count == 0
+        assert c._send_packet.mock.call_count == 1
+        expected_packet = packet.Packet(packet.DISCONNECT, namespace='/')
+        assert (
+            c._send_packet.mock.call_args_list[0][0][0].encode()
+            == expected_packet.encode()
+        )
+        c.eio.disconnect.mock.assert_called_once_with(abort=True)
+
+    def test_shutdown_disconnect_namespaces(self):
+        c = async_client.AsyncClient()
+        c.connected = True
+        c.namespaces = {'/foo': '1', '/bar': '2'}
+        c._trigger_event = AsyncMock()
+        c._send_packet = AsyncMock()
+        c.eio = mock.MagicMock()
+        c.eio.disconnect = AsyncMock()
+        c.eio.state = 'connected'
+        _run(c.shutdown())
+        assert c._trigger_event.mock.call_count == 0
+        assert c._send_packet.mock.call_count == 2
+        expected_packet = packet.Packet(packet.DISCONNECT, namespace='/foo')
+        assert (
+            c._send_packet.mock.call_args_list[0][0][0].encode()
+            == expected_packet.encode()
+        )
+        expected_packet = packet.Packet(packet.DISCONNECT, namespace='/bar')
+        assert (
+            c._send_packet.mock.call_args_list[1][0][0].encode()
+            == expected_packet.encode()
+        )
+
+    @mock.patch('socketio.client.random.random', side_effect=[1, 0, 0.5])
+    def test_shutdown_reconnect(self, random):
+        c = async_client.AsyncClient()
+        c.connection_namespaces = ['/']
+        c._reconnect_task = AsyncMock()()
+        c._trigger_event = AsyncMock()
+        c.connect = AsyncMock(side_effect=exceptions.ConnectionError)
+
+        async def r():
+            task = c.start_background_task(c._handle_reconnect)
+            await asyncio.sleep(0.1)
+            await c.shutdown()
+            await task
+
+        _run(r())
+        c._trigger_event.mock.assert_called_once_with('__disconnect_final',
+                                                      namespace='/')
+
     def test_handle_eio_connect(self):
         c = async_client.AsyncClient()
         c.connection_namespaces = ['/', '/foo']

{python-socketio-5.11.2 → python_socketio-5.11.3}/tests/common/test_client.py

@@ -1,4 +1,5 @@
 import logging
+import time
 import unittest
 from unittest import mock
 
@@ -235,6 +236,7 @@ class TestClient(unittest.TestCase):
         c.eio.connect = mock.MagicMock()
         c.on('foo', mock.MagicMock(), namespace='/foo')
         c.on('bar', mock.MagicMock(), namespace='/')
+        c.on('baz', mock.MagicMock(), namespace='*')
         c.connect(
             'url',
             headers='headers',
@@ -636,6 +638,7 @@ class TestClient(unittest.TestCase):
 
     def test_disconnect_namespaces(self):
         c = client.Client()
+        c.connected = True
         c.namespaces = {'/foo': '1', '/bar': '2'}
         c._trigger_event = mock.MagicMock()
         c._send_packet = mock.MagicMock()
@@ -1128,6 +1131,61 @@ class TestClient(unittest.TestCase):
         c._trigger_event.assert_called_once_with('__disconnect_final',
                                                  namespace='/')
 
+    def test_shutdown_disconnect(self):
+        c = client.Client()
+        c.connected = True
+        c.namespaces = {'/': '1'}
+        c._trigger_event = mock.MagicMock()
+        c._send_packet = mock.MagicMock()
+        c.eio = mock.MagicMock()
+        c.eio.state = 'connected'
+        c.shutdown()
+        assert c._trigger_event.call_count == 0
+        assert c._send_packet.call_count == 1
+        expected_packet = packet.Packet(packet.DISCONNECT, namespace='/')
+        assert (
+            c._send_packet.call_args_list[0][0][0].encode()
+            == expected_packet.encode()
+        )
+        c.eio.disconnect.assert_called_once_with(abort=True)
+
+    def test_shutdown_disconnect_namespaces(self):
+        c = client.Client()
+        c.connected = True
+        c.namespaces = {'/foo': '1', '/bar': '2'}
+        c._trigger_event = mock.MagicMock()
+        c._send_packet = mock.MagicMock()
+        c.eio = mock.MagicMock()
+        c.eio.state = 'connected'
+        c.shutdown()
+        assert c._trigger_event.call_count == 0
+        assert c._send_packet.call_count == 2
+        expected_packet = packet.Packet(packet.DISCONNECT, namespace='/foo')
+        assert (
+            c._send_packet.call_args_list[0][0][0].encode()
+            == expected_packet.encode()
+        )
+        expected_packet = packet.Packet(packet.DISCONNECT, namespace='/bar')
+        assert (
+            c._send_packet.call_args_list[1][0][0].encode()
+            == expected_packet.encode()
+        )
+
+    @mock.patch('socketio.client.random.random', side_effect=[1, 0, 0.5])
+    def test_shutdown_reconnect(self, random):
+        c = client.Client()
+        c.connection_namespaces = ['/']
+        c._reconnect_task = mock.MagicMock()
+        c._trigger_event = mock.MagicMock()
+        c.connect = mock.MagicMock(side_effect=exceptions.ConnectionError)
+        task = c.start_background_task(c._handle_reconnect)
+        time.sleep(0.1)
+        c.shutdown()
+        task.join()
+        c._trigger_event.assert_called_once_with('__disconnect_final',
+                                                 namespace='/')
+        c._reconnect_task.join.assert_called_once_with()
+
     def test_handle_eio_connect(self):
         c = client.Client()
         c.connection_namespaces = ['/', '/foo']