python-socketio 5.12.0__tar.gz → 5.13.0__tar.gz

{python_socketio-5.12.0/src/python_socketio.egg-info → python_socketio-5.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-socketio
-Version: 5.12.0
+Version: 5.13.0
 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
@@ -22,6 +22,7 @@ Provides-Extra: asyncio-client
 Requires-Dist: aiohttp>=3.4; extra == "asyncio-client"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
+Dynamic: license-file
 
 python-socketio
 ===============

{python_socketio-5.12.0 → python_socketio-5.13.0}/docs/intro.rst

@@ -189,7 +189,7 @@ Server Features
 - Can be hosted on any `WSGI <https://wsgi.readthedocs.io/en/latest/index.html>`_ or
   `ASGI <https://asgi.readthedocs.io/en/latest/>`_ web server including
   `Gunicorn <https://gunicorn.org/>`_, `Uvicorn <https://github.com/encode/uvicorn>`_,
-  `eventlet <http://eventlet.net/>`_ and `gevent <http://gevent.org>`_.
+  `eventlet <http://eventlet.net/>`_ and `gevent <http://www.gevent.org>`_.
 - Can be integrated with WSGI applications written in frameworks such as Flask, Django,
   etc.
 - Can be integrated with `aiohttp <http://aiohttp.readthedocs.io/>`_,

{python_socketio-5.12.0 → python_socketio-5.13.0}/docs/server.rst

@@ -19,12 +19,6 @@ command::
 
     pip install python-socketio
 
-If you plan to build an asynchronous web server based on the ``asyncio``
-package, then you can install this package and some additional dependencies
-that are needed with::
-
-    pip install "python-socketio[asyncio]"
-
 Creating a Server Instance
 --------------------------
 
@@ -838,7 +832,7 @@ Gevent
 
 When a multi-threaded web server is unable to satisfy the concurrency and
 scalability requirements of the application, an option to try is
-`Gevent <http://gevent.org>`_. Gevent is a coroutine-based concurrency library
+`Gevent <http://www.gevent.org>`_. Gevent is a coroutine-based concurrency library
 based on greenlets, which are significantly lighter than threads.
 
 Instances of class ``socketio.Server`` will automatically use Gevent if the

{python_socketio-5.12.0 → python_socketio-5.13.0}/pyproject.toml

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

{python_socketio-5.12.0 → python_socketio-5.13.0/src/python_socketio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: python-socketio
-Version: 5.12.0
+Version: 5.13.0
 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
@@ -22,6 +22,7 @@ Provides-Extra: asyncio-client
 Requires-Dist: aiohttp>=3.4; extra == "asyncio-client"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
+Dynamic: license-file
 
 python-socketio
 ===============

{python_socketio-5.12.0 → python_socketio-5.13.0}/src/python_socketio.egg-info/SOURCES.txt

@@ -70,6 +70,7 @@ tests/common/test_msgpack_packet.py
 tests/common/test_namespace.py
 tests/common/test_packet.py
 tests/common/test_pubsub_manager.py
+tests/common/test_redis_manager.py
 tests/common/test_server.py
 tests/common/test_simple_client.py
 tests/performance/README.md

{python_socketio-5.12.0 → python_socketio-5.13.0}/src/socketio/admin.py

@@ -1,4 +1,4 @@
-from datetime import datetime
+from datetime import datetime, timezone
 import functools
 import os
 import socket
@@ -77,13 +77,9 @@ class InstrumentedServer:
             # track socket connection times
             self.sio.manager._timestamps = {}
 
-            # report socket.io connections
-            self.sio.manager.__connect = self.sio.manager.connect
-            self.sio.manager.connect = self._connect
-
-            # report socket.io disconnection
-            self.sio.manager.__disconnect = self.sio.manager.disconnect
-            self.sio.manager.disconnect = self._disconnect
+            # report socket.io connections, disconnections and received events
+            self.sio.__trigger_event = self.sio._trigger_event
+            self.sio._trigger_event = self._trigger_event
 
             # report join rooms
             self.sio.manager.__basic_enter_room = \
@@ -99,10 +95,6 @@ class InstrumentedServer:
             self.sio.manager.__emit = self.sio.manager.emit
             self.sio.manager.emit = self._emit
 
-            # report receive events
-            self.sio.__handle_event_internal = self.sio._handle_event_internal
-            self.sio._handle_event_internal = self._handle_event_internal
-
         # report engine.io connections
         self.sio.eio.on('connect', self._handle_eio_connect)
         self.sio.eio.on('disconnect', self._handle_eio_disconnect)
@@ -128,14 +120,12 @@ class InstrumentedServer:
 
     def uninstrument(self):  # pragma: no cover
         if self.mode == 'development':
-            self.sio.manager.connect = self.sio.manager.__connect
-            self.sio.manager.disconnect = self.sio.manager.__disconnect
+            self.sio._trigger_event = self.sio.__trigger_event
             self.sio.manager.basic_enter_room = \
                 self.sio.manager.__basic_enter_room
             self.sio.manager.basic_leave_room = \
                 self.sio.manager.__basic_leave_room
             self.sio.manager.emit = self.sio.manager.__emit
-            self.sio._handle_event_internal = self.sio.__handle_event_internal
         self.sio.eio._ok = self.sio.eio.__ok
 
         from engineio.socket import Socket
@@ -205,26 +195,34 @@ class InstrumentedServer:
             self.stop_stats_event.set()
             self.stats_task.join()
 
-    def _connect(self, eio_sid, namespace):
-        sid = self.sio.manager.__connect(eio_sid, namespace)
+    def _trigger_event(self, event, namespace, *args):
         t = time.time()
-        self.sio.manager._timestamps[sid] = t
-        serialized_socket = self.serialize_socket(sid, namespace, eio_sid)
-        self.sio.emit('socket_connected', (
-            serialized_socket,
-            datetime.utcfromtimestamp(t).isoformat() + 'Z',
-        ), namespace=self.admin_namespace)
-        return sid
-
-    def _disconnect(self, sid, namespace, **kwargs):
-        del self.sio.manager._timestamps[sid]
-        self.sio.emit('socket_disconnected', (
-            namespace,
-            sid,
-            'N/A',
-            datetime.utcnow().isoformat() + 'Z',
-        ), namespace=self.admin_namespace)
-        return self.sio.manager.__disconnect(sid, namespace, **kwargs)
+        sid = args[0]
+        if event == 'connect':
+            eio_sid = self.sio.manager.eio_sid_from_sid(sid, namespace)
+            self.sio.manager._timestamps[sid] = t
+            serialized_socket = self.serialize_socket(sid, namespace, eio_sid)
+            self.sio.emit('socket_connected', (
+                serialized_socket,
+                datetime.fromtimestamp(t, timezone.utc).isoformat(),
+            ), namespace=self.admin_namespace)
+        elif event == 'disconnect':
+            del self.sio.manager._timestamps[sid]
+            reason = args[1]
+            self.sio.emit('socket_disconnected', (
+                namespace,
+                sid,
+                reason,
+                datetime.fromtimestamp(t, timezone.utc).isoformat(),
+            ), namespace=self.admin_namespace)
+        else:
+            self.sio.emit('event_received', (
+                namespace,
+                sid,
+                (event, *args[1:]),
+                datetime.fromtimestamp(t, timezone.utc).isoformat(),
+            ), namespace=self.admin_namespace)
+        return self.sio.__trigger_event(event, namespace, *args)
 
     def _check_for_upgrade(self, eio_sid, sid, namespace):  # pragma: no cover
         for _ in range(5):
@@ -248,7 +246,7 @@ class InstrumentedServer:
                 namespace,
                 room,
                 sid,
-                datetime.utcnow().isoformat() + 'Z',
+                datetime.now(timezone.utc).isoformat(),
             ), namespace=self.admin_namespace)
         return ret
 
@@ -258,7 +256,7 @@ class InstrumentedServer:
                 namespace,
                 room,
                 sid,
-                datetime.utcnow().isoformat() + 'Z',
+                datetime.now(timezone.utc).isoformat(),
             ), namespace=self.admin_namespace)
         return self.sio.manager.__basic_leave_room(sid, namespace, room)
 
@@ -269,7 +267,7 @@ class InstrumentedServer:
                                       **kwargs)
         if namespace != self.admin_namespace:
             event_data = [event] + list(data) if isinstance(data, tuple) \
-                else [data]
+                else [event, data]
             if not isinstance(skip_sid, list):  # pragma: no branch
                 skip_sid = [skip_sid]
             for sid, _ in self.sio.manager.get_participants(namespace, room):
@@ -278,22 +276,10 @@ class InstrumentedServer:
                         namespace,
                         sid,
                         event_data,
-                        datetime.utcnow().isoformat() + 'Z',
+                        datetime.now(timezone.utc).isoformat(),
                     ), namespace=self.admin_namespace)
         return ret
 
-    def _handle_event_internal(self, server, sid, eio_sid, data, namespace,
-                               id):
-        ret = self.sio.__handle_event_internal(server, sid, eio_sid, data,
-                                               namespace, id)
-        self.sio.emit('event_received', (
-            namespace,
-            sid,
-            data,
-            datetime.utcnow().isoformat() + 'Z',
-        ), namespace=self.admin_namespace)
-        return ret
-
     def _handle_eio_connect(self, eio_sid, environ):
         if self.stop_stats_event is None:
             self.stop_stats_event = self.sio.eio.create_event()
@@ -303,9 +289,9 @@ class InstrumentedServer:
         self.event_buffer.push('rawConnection')
         return self.sio._handle_eio_connect(eio_sid, environ)
 
-    def _handle_eio_disconnect(self, eio_sid):
+    def _handle_eio_disconnect(self, eio_sid, reason):
         self.event_buffer.push('rawDisconnection')
-        return self.sio._handle_eio_disconnect(eio_sid)
+        return self.sio._handle_eio_disconnect(eio_sid, reason)
 
     def _eio_http_response(self, packets=None, headers=None, jsonp_index=None):
         ret = self.sio.eio.__ok(packets=packets, headers=headers,
@@ -349,7 +335,7 @@ class InstrumentedServer:
                                                           eio_sid)
                 self.sio.emit('socket_connected', (
                     serialized_socket,
-                    datetime.utcfromtimestamp(t).isoformat() + 'Z',
+                    datetime.fromtimestamp(t, timezone.utc).isoformat(),
                 ), namespace=self.admin_namespace)
         return socket.__send_ping()
 
@@ -398,7 +384,7 @@ class InstrumentedServer:
                 'secure': environ.get('wsgi.url_scheme', '') == 'https',
                 'url': environ.get('PATH_INFO', ''),
                 'issued': tm * 1000,
-                'time': datetime.utcfromtimestamp(tm).isoformat() + 'Z'
+                'time': datetime.fromtimestamp(tm, timezone.utc).isoformat()
                 if tm else '',
             },
             'rooms': self.sio.manager.get_rooms(sid, namespace),

{python_socketio-5.12.0 → python_socketio-5.13.0}/src/socketio/async_admin.py

@@ -1,5 +1,5 @@
 import asyncio
-from datetime import datetime
+from datetime import datetime, timezone
 import functools
 import os
 import socket
@@ -58,13 +58,9 @@ class InstrumentedAsyncServer:
             # track socket connection times
             self.sio.manager._timestamps = {}
 
-            # report socket.io connections
-            self.sio.manager.__connect = self.sio.manager.connect
-            self.sio.manager.connect = self._connect
-
-            # report socket.io disconnection
-            self.sio.manager.__disconnect = self.sio.manager.disconnect
-            self.sio.manager.disconnect = self._disconnect
+            # report socket.io connections, disconnections and received events
+            self.sio.__trigger_event = self.sio._trigger_event
+            self.sio._trigger_event = self._trigger_event
 
             # report join rooms
             self.sio.manager.__basic_enter_room = \
@@ -80,10 +76,6 @@ class InstrumentedAsyncServer:
             self.sio.manager.__emit = self.sio.manager.emit
             self.sio.manager.emit = self._emit
 
-            # report receive events
-            self.sio.__handle_event_internal = self.sio._handle_event_internal
-            self.sio._handle_event_internal = self._handle_event_internal
-
         # report engine.io connections
         self.sio.eio.on('connect', self._handle_eio_connect)
         self.sio.eio.on('disconnect', self._handle_eio_disconnect)
@@ -109,14 +101,12 @@ class InstrumentedAsyncServer:
 
     def uninstrument(self):  # pragma: no cover
         if self.mode == 'development':
-            self.sio.manager.connect = self.sio.manager.__connect
-            self.sio.manager.disconnect = self.sio.manager.__disconnect
+            self.sio._trigger_event = self.sio.__trigger_event
             self.sio.manager.basic_enter_room = \
                 self.sio.manager.__basic_enter_room
             self.sio.manager.basic_leave_room = \
                 self.sio.manager.__basic_leave_room
             self.sio.manager.emit = self.sio.manager.__emit
-            self.sio._handle_event_internal = self.sio.__handle_event_internal
         self.sio.eio._ok = self.sio.eio.__ok
 
         from engineio.async_socket import AsyncSocket
@@ -193,26 +183,34 @@ class InstrumentedAsyncServer:
             self.stop_stats_event.set()
             await asyncio.gather(self.stats_task)
 
-    async def _connect(self, eio_sid, namespace):
-        sid = await self.sio.manager.__connect(eio_sid, namespace)
+    async def _trigger_event(self, event, namespace, *args):
         t = time.time()
-        self.sio.manager._timestamps[sid] = t
-        serialized_socket = self.serialize_socket(sid, namespace, eio_sid)
-        await self.sio.emit('socket_connected', (
-            serialized_socket,
-            datetime.utcfromtimestamp(t).isoformat() + 'Z',
-        ), namespace=self.admin_namespace)
-        return sid
-
-    async def _disconnect(self, sid, namespace, **kwargs):
-        del self.sio.manager._timestamps[sid]
-        await self.sio.emit('socket_disconnected', (
-            namespace,
-            sid,
-            'N/A',
-            datetime.utcnow().isoformat() + 'Z',
-        ), namespace=self.admin_namespace)
-        return await self.sio.manager.__disconnect(sid, namespace, **kwargs)
+        sid = args[0]
+        if event == 'connect':
+            eio_sid = self.sio.manager.eio_sid_from_sid(sid, namespace)
+            self.sio.manager._timestamps[sid] = t
+            serialized_socket = self.serialize_socket(sid, namespace, eio_sid)
+            await self.sio.emit('socket_connected', (
+                serialized_socket,
+                datetime.fromtimestamp(t, timezone.utc).isoformat(),
+            ), namespace=self.admin_namespace)
+        elif event == 'disconnect':
+            del self.sio.manager._timestamps[sid]
+            reason = args[1]
+            await self.sio.emit('socket_disconnected', (
+                namespace,
+                sid,
+                reason,
+                datetime.fromtimestamp(t, timezone.utc).isoformat(),
+            ), namespace=self.admin_namespace)
+        else:
+            await self.sio.emit('event_received', (
+                namespace,
+                sid,
+                (event, *args[1:]),
+                datetime.fromtimestamp(t, timezone.utc).isoformat(),
+            ), namespace=self.admin_namespace)
+        return await self.sio.__trigger_event(event, namespace, *args)
 
     async def _check_for_upgrade(self, eio_sid, sid,
                                  namespace):  # pragma: no cover
@@ -237,7 +235,7 @@ class InstrumentedAsyncServer:
                 namespace,
                 room,
                 sid,
-                datetime.utcnow().isoformat() + 'Z',
+                datetime.now(timezone.utc).isoformat(),
             )))
         return ret
 
@@ -247,7 +245,7 @@ class InstrumentedAsyncServer:
                 namespace,
                 room,
                 sid,
-                datetime.utcnow().isoformat() + 'Z',
+                datetime.now(timezone.utc).isoformat(),
             )))
         return self.sio.manager.__basic_leave_room(sid, namespace, room)
 
@@ -258,7 +256,7 @@ class InstrumentedAsyncServer:
             callback=callback, **kwargs)
         if namespace != self.admin_namespace:
             event_data = [event] + list(data) if isinstance(data, tuple) \
-                else [data]
+                else [event, data]
             if not isinstance(skip_sid, list):  # pragma: no branch
                 skip_sid = [skip_sid]
             for sid, _ in self.sio.manager.get_participants(namespace, room):
@@ -267,22 +265,10 @@ class InstrumentedAsyncServer:
                         namespace,
                         sid,
                         event_data,
-                        datetime.utcnow().isoformat() + 'Z',
+                        datetime.now(timezone.utc).isoformat(),
                     ), namespace=self.admin_namespace)
         return ret
 
-    async def _handle_event_internal(self, server, sid, eio_sid, data,
-                                     namespace, id):
-        ret = await self.sio.__handle_event_internal(server, sid, eio_sid,
-                                                     data, namespace, id)
-        await self.sio.emit('event_received', (
-            namespace,
-            sid,
-            data,
-            datetime.utcnow().isoformat() + 'Z',
-        ), namespace=self.admin_namespace)
-        return ret
-
     async def _handle_eio_connect(self, eio_sid, environ):
         if self.stop_stats_event is None:
             self.stop_stats_event = self.sio.eio.create_event()
@@ -292,9 +278,9 @@ class InstrumentedAsyncServer:
         self.event_buffer.push('rawConnection')
         return await self.sio._handle_eio_connect(eio_sid, environ)
 
-    async def _handle_eio_disconnect(self, eio_sid):
+    async def _handle_eio_disconnect(self, eio_sid, reason):
         self.event_buffer.push('rawDisconnection')
-        return await self.sio._handle_eio_disconnect(eio_sid)
+        return await self.sio._handle_eio_disconnect(eio_sid, reason)
 
     def _eio_http_response(self, packets=None, headers=None, jsonp_index=None):
         ret = self.sio.eio.__ok(packets=packets, headers=headers,
@@ -338,7 +324,7 @@ class InstrumentedAsyncServer:
                                                           eio_sid)
                 await self.sio.emit('socket_connected', (
                     serialized_socket,
-                    datetime.utcfromtimestamp(t).isoformat() + 'Z',
+                    datetime.fromtimestamp(t, timezone.utc).isoformat(),
                 ), namespace=self.admin_namespace)
         return await socket.__send_ping()
 
@@ -391,7 +377,7 @@ class InstrumentedAsyncServer:
                 'secure': environ.get('wsgi.url_scheme', '') == 'https',
                 'url': environ.get('PATH_INFO', ''),
                 'issued': tm * 1000,
-                'time': datetime.utcfromtimestamp(tm).isoformat() + 'Z'
+                'time': datetime.fromtimestamp(tm, timezone.utc).isoformat()
                 if tm else '',
             },
             'rooms': self.sio.manager.get_rooms(sid, namespace),

{python_socketio-5.12.0 → python_socketio-5.13.0}/src/socketio/async_client.py

@@ -158,7 +158,7 @@ class AsyncClient(base_client.BaseClient):
                 await self._handle_reconnect()
                 if self.eio.state == 'connected':
                     return
-            raise exceptions.ConnectionError(exc.args[0]) from None
+            raise exceptions.ConnectionError(exc.args[0]) from exc
 
         if wait:
             try:
@@ -191,6 +191,7 @@ class AsyncClient(base_client.BaseClient):
             if not self._reconnect_task:
                 if self.eio.state == 'connected':  # pragma: no cover
                     # connected while sleeping above
+                    print('oops')
                     continue
                 break
             await self._reconnect_task
@@ -324,7 +325,7 @@ class AsyncClient(base_client.BaseClient):
         for n in self.namespaces:
             await self._send_packet(self.packet_class(packet.DISCONNECT,
                                     namespace=n))
-        await self.eio.disconnect(abort=True)
+        await self.eio.disconnect()
 
     async def shutdown(self):
         """Stop the client.

{python_socketio-5.12.0 → python_socketio-5.13.0}/src/socketio/async_redis_manager.py

@@ -13,6 +13,7 @@ except ImportError:  # pragma: no cover
         RedisError = None
 
 from .async_pubsub_manager import AsyncPubSubManager
+from .redis_manager import parse_redis_sentinel_url
 
 
 class AsyncRedisManager(AsyncPubSubManager):  # pragma: no cover
@@ -29,15 +30,18 @@ class AsyncRedisManager(AsyncPubSubManager):  # pragma: no cover
             client_manager=socketio.AsyncRedisManager(url))
 
     :param url: The connection URL for the Redis server. For a default Redis
-                store running on the same host, use ``redis://``.  To use an
-                SSL connection, use ``rediss://``.
+                store running on the same host, use ``redis://``.  To use a
+                TLS connection, use ``rediss://``. To use Redis Sentinel, use
+                ``redis+sentinel://`` with a comma-separated list of hosts
+                and the service name after the db in the URL path. Example:
+                ``redis+sentinel://user:pw@host1:1234,host2:2345/0/myredis``.
     :param channel: The channel name on which the server sends and receives
                     notifications. Must be the same in all the servers.
     :param write_only: If set to ``True``, only initialize to emit events. The
                        default of ``False`` initializes the class for emitting
                        and receiving.
     :param redis_options: additional keyword arguments to be passed to
-                          ``aioredis.from_url()``.
+                          ``Redis.from_url()`` or ``Sentinel()``.
     """
     name = 'aioredis'
 
@@ -54,8 +58,16 @@ class AsyncRedisManager(AsyncPubSubManager):  # pragma: no cover
         super().__init__(channel=channel, write_only=write_only, logger=logger)
 
     def _redis_connect(self):
-        self.redis = aioredis.Redis.from_url(self.redis_url,
-                                             **self.redis_options)
+        if not self.redis_url.startswith('redis+sentinel://'):
+            self.redis = aioredis.Redis.from_url(self.redis_url,
+                                                 **self.redis_options)
+        else:
+            sentinels, service_name, connection_kwargs = \
+                parse_redis_sentinel_url(self.redis_url)
+            kwargs = self.redis_options
+            kwargs.update(connection_kwargs)
+            sentinel = aioredis.sentinel.Sentinel(sentinels, **kwargs)
+            self.redis = sentinel.master_for(service_name or self.channel)
         self.pubsub = self.redis.pubsub(ignore_subscribe_messages=True)
 
     async def _publish(self, data):

{python_socketio-5.12.0 → python_socketio-5.13.0}/src/socketio/async_simple_client.py

@@ -12,6 +12,8 @@ class AsyncSimpleClient:
     The positional and keyword arguments given in the constructor are passed
     to the underlying :func:`socketio.AsyncClient` object.
     """
+    client_class = AsyncClient
+
     def __init__(self, *args, **kwargs):
         self.client_args = args
         self.client_kwargs = kwargs
@@ -60,7 +62,8 @@ class AsyncSimpleClient:
         self.namespace = namespace
         self.input_buffer = []
         self.input_event.clear()
-        self.client = AsyncClient(*self.client_args, **self.client_kwargs)
+        self.client = self.client_class(
+            *self.client_args, **self.client_kwargs)
 
         @self.client.event(namespace=self.namespace)
         def connect():  # pragma: no cover

{python_socketio-5.12.0 → python_socketio-5.13.0}/src/socketio/client.py

@@ -156,7 +156,7 @@ class Client(base_client.BaseClient):
                 self._handle_reconnect()
                 if self.eio.state == 'connected':
                     return
-            raise exceptions.ConnectionError(exc.args[0]) from None
+            raise exceptions.ConnectionError(exc.args[0]) from exc
 
         if wait:
             while self._connect_event.wait(timeout=wait_timeout):
@@ -306,7 +306,7 @@ class Client(base_client.BaseClient):
         for n in self.namespaces:
             self._send_packet(self.packet_class(
                 packet.DISCONNECT, namespace=n))
-        self.eio.disconnect(abort=True)
+        self.eio.disconnect()
 
     def shutdown(self):
         """Stop the client.

{python_socketio-5.12.0 → python_socketio-5.13.0}/src/socketio/redis_manager.py

@@ -1,6 +1,7 @@
 import logging
 import pickle
 import time
+from urllib.parse import urlparse
 
 try:
     import redis
@@ -12,6 +13,32 @@ from .pubsub_manager import PubSubManager
 logger = logging.getLogger('socketio')
 
 
+def parse_redis_sentinel_url(url):
+    """Parse a Redis Sentinel URL with the format:
+    redis+sentinel://[:password]@host1:port1,host2:port2,.../db/service_name
+    """
+    parsed_url = urlparse(url)
+    if parsed_url.scheme != 'redis+sentinel':
+        raise ValueError('Invalid Redis Sentinel URL')
+    sentinels = []
+    for host_port in parsed_url.netloc.split('@')[-1].split(','):
+        host, port = host_port.rsplit(':', 1)
+        sentinels.append((host, int(port)))
+    kwargs = {}
+    if parsed_url.username:
+        kwargs['username'] = parsed_url.username
+    if parsed_url.password:
+        kwargs['password'] = parsed_url.password
+    service_name = None
+    if parsed_url.path:
+        parts = parsed_url.path.split('/')
+        if len(parts) >= 2 and parts[1] != '':
+            kwargs['db'] = int(parts[1])
+        if len(parts) >= 3 and parts[2] != '':
+            service_name = parts[2]
+    return sentinels, service_name, kwargs
+
+
 class RedisManager(PubSubManager):  # pragma: no cover
     """Redis based client manager.
 
@@ -27,15 +54,18 @@ class RedisManager(PubSubManager):  # pragma: no cover
         server = socketio.Server(client_manager=socketio.RedisManager(url))
 
     :param url: The connection URL for the Redis server. For a default Redis
-                store running on the same host, use ``redis://``.  To use an
-                SSL connection, use ``rediss://``.
+                store running on the same host, use ``redis://``.  To use a
+                TLS connection, use ``rediss://``. To use Redis Sentinel, use
+                ``redis+sentinel://`` with a comma-separated list of hosts
+                and the service name after the db in the URL path. Example:
+                ``redis+sentinel://user:pw@host1:1234,host2:2345/0/myredis``.
     :param channel: The channel name on which the server sends and receives
                     notifications. Must be the same in all the servers.
     :param write_only: If set to ``True``, only initialize to emit events. The
                        default of ``False`` initializes the class for emitting
                        and receiving.
     :param redis_options: additional keyword arguments to be passed to
-                          ``Redis.from_url()``.
+                          ``Redis.from_url()`` or ``Sentinel()``.
     """
     name = 'redis'
 
@@ -66,8 +96,16 @@ class RedisManager(PubSubManager):  # pragma: no cover
                 'with ' + self.server.async_mode)
 
     def _redis_connect(self):
-        self.redis = redis.Redis.from_url(self.redis_url,
-                                          **self.redis_options)
+        if not self.redis_url.startswith('redis+sentinel://'):
+            self.redis = redis.Redis.from_url(self.redis_url,
+                                              **self.redis_options)
+        else:
+            sentinels, service_name, connection_kwargs = \
+                parse_redis_sentinel_url(self.redis_url)
+            kwargs = self.redis_options
+            kwargs.update(connection_kwargs)
+            sentinel = redis.sentinel.Sentinel(sentinels, **kwargs)
+            self.redis = sentinel.master_for(service_name or self.channel)
         self.pubsub = self.redis.pubsub(ignore_subscribe_messages=True)
 
     def _publish(self, data):

{python_socketio-5.12.0 → python_socketio-5.13.0}/src/socketio/simple_client.py

@@ -12,6 +12,8 @@ class SimpleClient:
     The positional and keyword arguments given in the constructor are passed
     to the underlying :func:`socketio.Client` object.
     """
+    client_class = Client
+
     def __init__(self, *args, **kwargs):
         self.client_args = args
         self.client_kwargs = kwargs
@@ -58,7 +60,8 @@ class SimpleClient:
         self.namespace = namespace
         self.input_buffer = []
         self.input_event.clear()
-        self.client = Client(*self.client_args, **self.client_kwargs)
+        self.client = self.client_class(
+            *self.client_args, **self.client_kwargs)
 
         @self.client.event(namespace=self.namespace)
         def connect():  # pragma: no cover

{python_socketio-5.12.0 → python_socketio-5.13.0}/tests/async/test_client.py

@@ -475,7 +475,7 @@ class TestAsyncClient:
             c._send_packet.await_args_list[0][0][0].encode()
             == expected_packet.encode()
         )
-        c.eio.disconnect.assert_awaited_once_with(abort=True)
+        c.eio.disconnect.assert_awaited_once_with()
 
     async def test_disconnect_namespaces(self):
         c = async_client.AsyncClient()
@@ -993,7 +993,7 @@ class TestAsyncClient:
             c._send_packet.await_args_list[0][0][0].encode()
             == expected_packet.encode()
         )
-        c.eio.disconnect.assert_awaited_once_with(abort=True)
+        c.eio.disconnect.assert_awaited_once_with()
 
     async def test_shutdown_disconnect_namespaces(self):
         c = async_client.AsyncClient()

{python_socketio-5.12.0 → python_socketio-5.13.0}/tests/async/test_simple_client.py

@@ -16,46 +16,51 @@ class TestAsyncAsyncSimpleClient:
         assert not client.connected
 
     async def test_connect(self):
+        mock_client = mock.MagicMock()
+        original_client_class = AsyncSimpleClient.client_class
+        AsyncSimpleClient.client_class = mock_client
+
         client = AsyncSimpleClient(123, a='b')
-        with mock.patch('socketio.async_simple_client.AsyncClient') \
-                as mock_client:
+        mock_client.return_value.connect = mock.AsyncMock()
+
+        await client.connect('url', headers='h', auth='a', transports='t',
+                             namespace='n', socketio_path='s',
+                             wait_timeout='w')
+        mock_client.assert_called_once_with(123, a='b')
+        assert client.client == mock_client()
+        mock_client().connect.assert_awaited_once_with(
+            'url', headers='h', auth='a', transports='t',
+            namespaces=['n'], socketio_path='s', wait_timeout='w')
+        mock_client().event.call_count == 3
+        mock_client().on.assert_called_once_with('*', namespace='n')
+        assert client.namespace == 'n'
+        assert not client.input_event.is_set()
+
+        AsyncSimpleClient.client_class = original_client_class
+
+    async def test_connect_context_manager(self):
+        mock_client = mock.MagicMock()
+        original_client_class = AsyncSimpleClient.client_class
+        AsyncSimpleClient.client_class = mock_client
+
+        async with AsyncSimpleClient(123, a='b') as client:
             mock_client.return_value.connect = mock.AsyncMock()
 
-            await client.connect('url', headers='h', auth='a', transports='t',
-                                 namespace='n', socketio_path='s',
-                                 wait_timeout='w')
+            await client.connect('url', headers='h', auth='a',
+                                 transports='t', namespace='n',
+                                 socketio_path='s', wait_timeout='w')
             mock_client.assert_called_once_with(123, a='b')
             assert client.client == mock_client()
             mock_client().connect.assert_awaited_once_with(
                 'url', headers='h', auth='a', transports='t',
                 namespaces=['n'], socketio_path='s', wait_timeout='w')
             mock_client().event.call_count == 3
-            mock_client().on.assert_called_once_with('*', namespace='n')
+            mock_client().on.assert_called_once_with(
+                '*', namespace='n')
             assert client.namespace == 'n'
             assert not client.input_event.is_set()
 
-    async def test_connect_context_manager(self):
-        async def _t():
-            async with AsyncSimpleClient(123, a='b') as client:
-                with mock.patch('socketio.async_simple_client.AsyncClient') \
-                        as mock_client:
-                    mock_client.return_value.connect = mock.AsyncMock()
-
-                    await client.connect('url', headers='h', auth='a',
-                                         transports='t', namespace='n',
-                                         socketio_path='s', wait_timeout='w')
-                    mock_client.assert_called_once_with(123, a='b')
-                    assert client.client == mock_client()
-                    mock_client().connect.assert_awaited_once_with(
-                        'url', headers='h', auth='a', transports='t',
-                        namespaces=['n'], socketio_path='s', wait_timeout='w')
-                    mock_client().event.call_count == 3
-                    mock_client().on.assert_called_once_with(
-                        '*', namespace='n')
-                    assert client.namespace == 'n'
-                    assert not client.input_event.is_set()
-
-        await _t()
+        AsyncSimpleClient.client_class = original_client_class
 
     async def test_connect_twice(self):
         client = AsyncSimpleClient(123, a='b')

{python_socketio-5.12.0 → python_socketio-5.13.0}/tests/common/test_client.py

@@ -633,7 +633,7 @@ class TestClient:
             c._send_packet.call_args_list[0][0][0].encode()
             == expected_packet.encode()
         )
-        c.eio.disconnect.assert_called_once_with(abort=True)
+        c.eio.disconnect.assert_called_once_with()
 
     def test_disconnect_namespaces(self):
         c = client.Client()
@@ -1138,7 +1138,7 @@ class TestClient:
             c._send_packet.call_args_list[0][0][0].encode()
             == expected_packet.encode()
         )
-        c.eio.disconnect.assert_called_once_with(abort=True)
+        c.eio.disconnect.assert_called_once_with()
 
     def test_shutdown_disconnect_namespaces(self):
         c = client.Client()

python_socketio-5.13.0/tests/common/test_redis_manager.py

@@ -0,0 +1,38 @@
+import pytest
+
+from socketio.redis_manager import parse_redis_sentinel_url
+
+
+class TestPubSubManager:
+    def test_sentinel_url_parser(self):
+        with pytest.raises(ValueError):
+            parse_redis_sentinel_url('redis://localhost:6379/0')
+
+        assert parse_redis_sentinel_url(
+            'redis+sentinel://localhost:6379'
+        ) == (
+            [('localhost', 6379)],
+            None,
+            {}
+        )
+        assert parse_redis_sentinel_url(
+            'redis+sentinel://192.168.0.1:6379,192.168.0.2:6379/'
+        ) == (
+            [('192.168.0.1', 6379), ('192.168.0.2', 6379)],
+            None,
+            {}
+        )
+        assert parse_redis_sentinel_url(
+            'redis+sentinel://h1:6379,h2:6379/0'
+        ) == (
+            [('h1', 6379), ('h2', 6379)],
+            None,
+            {'db': 0}
+        )
+        assert parse_redis_sentinel_url(
+            'redis+sentinel://user:password@h1:6379,h2:6379,h1:6380/0/myredis'
+        ) == (
+            [('h1', 6379), ('h2', 6379), ('h1', 6380)],
+            'myredis',
+            {'username': 'user', 'password': 'password', 'db': 0}
+        )

{python_socketio-5.12.0 → python_socketio-5.13.0}/tests/common/test_simple_client.py

@@ -14,10 +14,34 @@ class TestSimpleClient:
         assert not client.connected
 
     def test_connect(self):
+        mock_client = mock.MagicMock()
+        original_client_class = SimpleClient.client_class
+        SimpleClient.client_class = mock_client
+
         client = SimpleClient(123, a='b')
-        with mock.patch('socketio.simple_client.Client') as mock_client:
+        client.connect('url', headers='h', auth='a', transports='t',
+                       namespace='n', socketio_path='s', wait_timeout='w')
+        mock_client.assert_called_once_with(123, a='b')
+        assert client.client == mock_client()
+        mock_client().connect.assert_called_once_with(
+            'url', headers='h', auth='a', transports='t',
+            namespaces=['n'], socketio_path='s', wait_timeout='w')
+        mock_client().event.call_count == 3
+        mock_client().on.assert_called_once_with('*', namespace='n')
+        assert client.namespace == 'n'
+        assert not client.input_event.is_set()
+
+        SimpleClient.client_class = original_client_class
+
+    def test_connect_context_manager(self):
+        mock_client = mock.MagicMock()
+        original_client_class = SimpleClient.client_class
+        SimpleClient.client_class = mock_client
+
+        with SimpleClient(123, a='b') as client:
             client.connect('url', headers='h', auth='a', transports='t',
-                           namespace='n', socketio_path='s', wait_timeout='w')
+                           namespace='n', socketio_path='s',
+                           wait_timeout='w')
             mock_client.assert_called_once_with(123, a='b')
             assert client.client == mock_client()
             mock_client().connect.assert_called_once_with(
@@ -28,21 +52,7 @@ class TestSimpleClient:
             assert client.namespace == 'n'
             assert not client.input_event.is_set()
 
-    def test_connect_context_manager(self):
-        with SimpleClient(123, a='b') as client:
-            with mock.patch('socketio.simple_client.Client') as mock_client:
-                client.connect('url', headers='h', auth='a', transports='t',
-                               namespace='n', socketio_path='s',
-                               wait_timeout='w')
-                mock_client.assert_called_once_with(123, a='b')
-                assert client.client == mock_client()
-                mock_client().connect.assert_called_once_with(
-                    'url', headers='h', auth='a', transports='t',
-                    namespaces=['n'], socketio_path='s', wait_timeout='w')
-                mock_client().event.call_count == 3
-                mock_client().on.assert_called_once_with('*', namespace='n')
-                assert client.namespace == 'n'
-                assert not client.input_event.is_set()
+        SimpleClient.client_class = original_client_class
 
     def test_connect_twice(self):
         client = SimpleClient(123, a='b')