python-socketio 5.14.0__tar.gz → 5.14.2__tar.gz

{python_socketio-5.14.0/src/python_socketio.egg-info → python_socketio-5.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-socketio
-Version: 5.14.0
+Version: 5.14.2
 Summary: Socket.IO server and client for Python
 Author-email: Miguel Grinberg <miguel.grinberg@gmail.com>
 License: MIT
@@ -20,6 +20,8 @@ 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: dev
+Requires-Dist: tox; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Dynamic: license-file

{python_socketio-5.14.0 → python_socketio-5.14.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-socketio"
-version = "5.14.0"
+version = "5.14.2"
 license = {text = "MIT"}
 authors = [
     { name = "Miguel Grinberg", email = "miguel.grinberg@gmail.com" },
@@ -34,6 +34,9 @@ client = [
 asyncio_client = [
     "aiohttp >= 3.4",
 ]
+dev = [
+    "tox",
+]
 docs = [
     "sphinx",
 ]

{python_socketio-5.14.0 → python_socketio-5.14.2/src/python_socketio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-socketio
-Version: 5.14.0
+Version: 5.14.2
 Summary: Socket.IO server and client for Python
 Author-email: Miguel Grinberg <miguel.grinberg@gmail.com>
 License: MIT
@@ -20,6 +20,8 @@ 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: dev
+Requires-Dist: tox; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Dynamic: license-file

{python_socketio-5.14.0 → python_socketio-5.14.2}/src/python_socketio.egg-info/SOURCES.txt

@@ -59,6 +59,7 @@ tests/async/test_client.py
 tests/async/test_manager.py
 tests/async/test_namespace.py
 tests/async/test_pubsub_manager.py
+tests/async/test_redis_manager.py
 tests/async/test_server.py
 tests/async/test_simple_client.py
 tests/common/__init__.py

{python_socketio-5.14.0 → python_socketio-5.14.2}/src/python_socketio.egg-info/requires.txt

@@ -8,5 +8,8 @@ aiohttp>=3.4
 requests>=2.21.0
 websocket-client>=0.54.0
 
+[dev]
+tox
+
 [docs]
 sphinx

{python_socketio-5.14.0 → python_socketio-5.14.2}/src/socketio/async_client.py

@@ -175,8 +175,8 @@ class AsyncClient(base_client.BaseClient):
             if set(self.namespaces) != set(self.connection_namespaces):
                 await self.disconnect()
                 raise exceptions.ConnectionError(
-                    'One or more namespaces failed to connect'
-                    ', '.join(self.failed_namespaces))
+                    'One or more namespaces failed to connect: '
+                    + ', '.join(self.failed_namespaces))
 
         self.connected = True
 

{python_socketio-5.14.0 → python_socketio-5.14.2}/src/socketio/async_pubsub_manager.py

@@ -1,10 +1,12 @@
 import asyncio
+import base64
 from functools import partial
 import uuid
 
 from engineio import json
 
 from .async_manager import AsyncManager
+from .packet import Packet
 
 
 class AsyncPubSubManager(AsyncManager):
@@ -64,8 +66,12 @@ class AsyncPubSubManager(AsyncManager):
             callback = (room, namespace, id)
         else:
             callback = None
+        binary = Packet.data_is_binary(data)
+        if binary:
+            data, attachments = Packet.deconstruct_binary(data)
+            data = [data, *[base64.b64encode(a).decode() for a in attachments]]
         message = {'method': 'emit', 'event': event, 'data': data,
-                   'namespace': namespace, 'room': room,
+                   'binary': binary, 'namespace': namespace, 'room': room,
                    'skip_sid': skip_sid, 'callback': callback,
                    'host_id': self.host_id}
         await self._handle_emit(message)  # handle in this host
@@ -145,7 +151,11 @@ class AsyncPubSubManager(AsyncManager):
                                *remote_callback)
         else:
             callback = None
-        await super().emit(message['event'], message['data'],
+        data = message['data']
+        if message.get('binary'):
+            attachments = [base64.b64decode(a) for a in data[1:]]
+            data = Packet.reconstruct_binary(data[0], attachments)
+        await super().emit(message['event'], data,
                            namespace=message.get('namespace'),
                            room=message.get('room'),
                            skip_sid=message.get('skip_sid'),

{python_socketio-5.14.0 → python_socketio-5.14.2}/src/socketio/async_redis_manager.py

@@ -1,7 +1,7 @@
 import asyncio
 from urllib.parse import urlparse
 
-try:  # pragma: no cover
+try:
     from redis import asyncio as aioredis
     from redis.exceptions import RedisError
 except ImportError:  # pragma: no cover
@@ -12,11 +12,11 @@ except ImportError:  # pragma: no cover
         aioredis = None
         RedisError = None
 
-try:  # pragma: no cover
-    from valkey import asyncio as valkey
+try:
+    from valkey import asyncio as aiovalkey
     from valkey.exceptions import ValkeyError
 except ImportError:  # pragma: no cover
-    valkey = None
+    aiovalkey = None
     ValkeyError = None
 
 from engineio import json
@@ -24,7 +24,7 @@ from .async_pubsub_manager import AsyncPubSubManager
 from .redis_manager import parse_redis_sentinel_url
 
 
-class AsyncRedisManager(AsyncPubSubManager):  # pragma: no cover
+class AsyncRedisManager(AsyncPubSubManager):
     """Redis based client manager for asyncio servers.
 
     This class implements a Redis backend for event sharing across multiple
@@ -55,12 +55,8 @@ class AsyncRedisManager(AsyncPubSubManager):  # pragma: no cover
 
     def __init__(self, url='redis://localhost:6379/0', channel='socketio',
                  write_only=False, logger=None, redis_options=None):
-        if aioredis is None and valkey is None:
-            raise RuntimeError('Redis package is not installed '
-                               '(Run "pip install redis" or '
-                               '"pip install valkey" '
-                               'in your virtualenv).')
-        if aioredis and not hasattr(aioredis.Redis, 'from_url'):
+        if aioredis and \
+                not hasattr(aioredis.Redis, 'from_url'):  # pragma: no cover
             raise RuntimeError('Version 2 of aioredis package is required.')
         super().__init__(channel=channel, write_only=write_only, logger=logger)
         self.redis_url = url
@@ -69,20 +65,31 @@ class AsyncRedisManager(AsyncPubSubManager):  # pragma: no cover
 
     def _get_redis_module_and_error(self):
         parsed_url = urlparse(self.redis_url)
-        schema = parsed_url.scheme.split('+', 1)[0].lower()
-        if schema == 'redis':
+        scheme = parsed_url.scheme.split('+', 1)[0].lower()
+        if scheme in ['redis', 'rediss']:
             if aioredis is None or RedisError is None:
                 raise RuntimeError('Redis package is not installed '
                                    '(Run "pip install redis" '
                                    'in your virtualenv).')
             return aioredis, RedisError
-        if schema == 'valkey':
-            if valkey is None or ValkeyError is None:
+        if scheme in ['valkey', 'valkeys']:
+            if aiovalkey is None or ValkeyError is None:
                 raise RuntimeError('Valkey package is not installed '
                                    '(Run "pip install valkey" '
                                    'in your virtualenv).')
-            return valkey, ValkeyError
-        error_msg = f'Unsupported Redis URL schema: {schema}'
+            return aiovalkey, ValkeyError
+        if scheme == 'unix':
+            if aioredis is None or RedisError is None:
+                if aiovalkey is None or ValkeyError is None:
+                    raise RuntimeError('Redis package is not installed '
+                                       '(Run "pip install redis" '
+                                       'or "pip install valkey" '
+                                       'in your virtualenv).')
+                else:
+                    return aiovalkey, ValkeyError
+            else:
+                return aioredis, RedisError
+        error_msg = f'Unsupported Redis URL scheme: {scheme}'
         raise ValueError(error_msg)
 
     def _redis_connect(self):
@@ -100,7 +107,7 @@ class AsyncRedisManager(AsyncPubSubManager):  # pragma: no cover
                                                **self.redis_options)
         self.pubsub = self.redis.pubsub(ignore_subscribe_messages=True)
 
-    async def _publish(self, data):
+    async def _publish(self, data):  # pragma: no cover
         retry = True
         _, error = self._get_redis_module_and_error()
         while True:
@@ -124,7 +131,7 @@ class AsyncRedisManager(AsyncPubSubManager):  # pragma: no cover
 
                     break
 
-    async def _redis_listen_with_retries(self):
+    async def _redis_listen_with_retries(self):  # pragma: no cover
         retry_sleep = 1
         connect = False
         _, error = self._get_redis_module_and_error()
@@ -147,7 +154,7 @@ class AsyncRedisManager(AsyncPubSubManager):  # pragma: no cover
                 if retry_sleep > 60:
                     retry_sleep = 60
 
-    async def _listen(self):
+    async def _listen(self):  # pragma: no cover
         channel = self.channel.encode('utf-8')
         await self.pubsub.subscribe(self.channel)
         async for message in self._redis_listen_with_retries():

{python_socketio-5.14.0 → python_socketio-5.14.2}/src/socketio/base_manager.py

@@ -29,7 +29,13 @@ class BaseManager:
         return self.rooms.keys()
 
     def get_participants(self, namespace, room):
-        """Return an iterable with the active participants in a room."""
+        """Return an iterable with the active participants in a room.
+
+        Note that in a multi-server scenario this method only returns the
+        participants connect to the server in which the method is called. There
+        is currently no functionality to assemble a complete list of users
+        across multiple servers.
+        """
         ns = self.rooms.get(namespace, {})
         if hasattr(room, '__len__') and not isinstance(room, str):
             participants = ns[room[0]]._fwdm.copy() if room[0] in ns else {}

{python_socketio-5.14.0 → python_socketio-5.14.2}/src/socketio/client.py

@@ -169,7 +169,7 @@ class Client(base_client.BaseClient):
                 self.disconnect()
                 raise exceptions.ConnectionError(
                     'One or more namespaces failed to connect: '
-                    ', '.join(self.failed_namespaces))
+                    + ', '.join(self.failed_namespaces))
 
         self.connected = True
 

{python_socketio-5.14.0 → python_socketio-5.14.2}/src/socketio/packet.py

@@ -29,7 +29,7 @@ class Packet:
         self.namespace = namespace
         self.id = id
         if self.uses_binary_events and \
-                (binary or (binary is None and self._data_is_binary(
+                (binary or (binary is None and self.data_is_binary(
                     self.data))):
             if self.packet_type == EVENT:
                 self.packet_type = BINARY_EVENT
@@ -51,7 +51,7 @@ class Packet:
         """
         encoded_packet = str(self.packet_type)
         if self.packet_type == BINARY_EVENT or self.packet_type == BINARY_ACK:
-            data, attachments = self._deconstruct_binary(self.data)
+            data, attachments = self.deconstruct_binary(self.data)
             encoded_packet += str(len(attachments)) + '-'
         else:
             data = self.data
@@ -119,61 +119,65 @@ class Packet:
             raise ValueError('Unexpected binary attachment')
         self.attachments.append(attachment)
         if self.attachment_count == len(self.attachments):
-            self.reconstruct_binary(self.attachments)
+            self.data = self.reconstruct_binary(self.data, self.attachments)
             return True
         return False
 
-    def reconstruct_binary(self, attachments):
+    @classmethod
+    def reconstruct_binary(cls, data, attachments):
         """Reconstruct a decoded packet using the given list of binary
         attachments.
         """
-        self.data = self._reconstruct_binary_internal(self.data,
-                                                      self.attachments)
+        return cls._reconstruct_binary_internal(data, attachments)
 
-    def _reconstruct_binary_internal(self, data, attachments):
+    @classmethod
+    def _reconstruct_binary_internal(cls, data, attachments):
         if isinstance(data, list):
-            return [self._reconstruct_binary_internal(item, attachments)
+            return [cls._reconstruct_binary_internal(item, attachments)
                     for item in data]
         elif isinstance(data, dict):
             if data.get('_placeholder') and 'num' in data:
                 return attachments[data['num']]
             else:
-                return {key: self._reconstruct_binary_internal(value,
-                                                               attachments)
+                return {key: cls._reconstruct_binary_internal(value,
+                                                              attachments)
                         for key, value in data.items()}
         else:
             return data
 
-    def _deconstruct_binary(self, data):
+    @classmethod
+    def deconstruct_binary(cls, data):
         """Extract binary components in the packet."""
         attachments = []
-        data = self._deconstruct_binary_internal(data, attachments)
+        data = cls._deconstruct_binary_internal(data, attachments)
         return data, attachments
 
-    def _deconstruct_binary_internal(self, data, attachments):
+    @classmethod
+    def _deconstruct_binary_internal(cls, data, attachments):
         if isinstance(data, bytes):
             attachments.append(data)
             return {'_placeholder': True, 'num': len(attachments) - 1}
         elif isinstance(data, list):
-            return [self._deconstruct_binary_internal(item, attachments)
+            return [cls._deconstruct_binary_internal(item, attachments)
                     for item in data]
         elif isinstance(data, dict):
-            return {key: self._deconstruct_binary_internal(value, attachments)
+            return {key: cls._deconstruct_binary_internal(value, attachments)
                     for key, value in data.items()}
         else:
             return data
 
-    def _data_is_binary(self, data):
+    @classmethod
+    def data_is_binary(cls, data):
         """Check if the data contains binary components."""
         if isinstance(data, bytes):
             return True
         elif isinstance(data, list):
             return functools.reduce(
-                lambda a, b: a or b, [self._data_is_binary(item)
+                lambda a, b: a or b, [cls.data_is_binary(item)
                                       for item in data], False)
         elif isinstance(data, dict):
             return functools.reduce(
-                lambda a, b: a or b, [self._data_is_binary(item)
+                lambda a, b: a or b, [cls.data_is_binary(item)
                                       for item in data.values()],
                 False)
         else:

{python_socketio-5.14.0 → python_socketio-5.14.2}/src/socketio/pubsub_manager.py

@@ -1,9 +1,11 @@
+import base64
 from functools import partial
 import uuid
 
 from engineio import json
 
 from .manager import Manager
+from .packet import Packet
 
 
 class PubSubManager(Manager):
@@ -61,8 +63,12 @@ class PubSubManager(Manager):
             callback = (room, namespace, id)
         else:
             callback = None
+        binary = Packet.data_is_binary(data)
+        if binary:
+            data, attachments = Packet.deconstruct_binary(data)
+            data = [data, *[base64.b64encode(a).decode() for a in attachments]]
         message = {'method': 'emit', 'event': event, 'data': data,
-                   'namespace': namespace, 'room': room,
+                   'binary': binary, 'namespace': namespace, 'room': room,
                    'skip_sid': skip_sid, 'callback': callback,
                    'host_id': self.host_id}
         self._handle_emit(message)  # handle in this host
@@ -141,7 +147,11 @@ class PubSubManager(Manager):
                                *remote_callback)
         else:
             callback = None
-        super().emit(message['event'], message['data'],
+        data = message['data']
+        if message.get('binary'):
+            attachments = [base64.b64decode(a) for a in data[1:]]
+            data = Packet.reconstruct_binary(data[0], attachments)
+        super().emit(message['event'], data,
                      namespace=message.get('namespace'),
                      room=message.get('room'),
                      skip_sid=message.get('skip_sid'), callback=callback)

{python_socketio-5.14.0 → python_socketio-5.14.2}/src/socketio/redis_manager.py

@@ -2,17 +2,17 @@ import logging
 import time
 from urllib.parse import urlparse
 
-try:  # pragma: no cover
+try:
     import redis
     from redis.exceptions import RedisError
-except ImportError:
+except ImportError:  # pragma: no cover
     redis = None
     RedisError = None
 
-try:  # pragma: no cover
+try:
     import valkey
     from valkey.exceptions import ValkeyError
-except ImportError:
+except ImportError:  # pragma: no cover
     valkey = None
     ValkeyError = None
 
@@ -48,7 +48,7 @@ def parse_redis_sentinel_url(url):
     return sentinels, service_name, kwargs
 
 
-class RedisManager(PubSubManager):  # pragma: no cover
+class RedisManager(PubSubManager):
     """Redis based client manager.
 
     This class implements a Redis backend for event sharing across multiple
@@ -80,17 +80,12 @@ class RedisManager(PubSubManager):  # pragma: no cover
 
     def __init__(self, url='redis://localhost:6379/0', channel='socketio',
                  write_only=False, logger=None, redis_options=None):
-        if redis is None and valkey is None:
-            raise RuntimeError('Redis package is not installed '
-                               '(Run "pip install redis" '
-                               'or "pip install valkey" '
-                               'in your virtualenv).')
         super().__init__(channel=channel, write_only=write_only, logger=logger)
         self.redis_url = url
         self.redis_options = redis_options or {}
         self._redis_connect()
 
-    def initialize(self):
+    def initialize(self):  # pragma: no cover
         super().initialize()
 
         monkey_patched = True
@@ -107,20 +102,31 @@ class RedisManager(PubSubManager):  # pragma: no cover
 
     def _get_redis_module_and_error(self):
         parsed_url = urlparse(self.redis_url)
-        schema = parsed_url.scheme.split('+', 1)[0].lower()
-        if schema == 'redis':
+        scheme = parsed_url.scheme.split('+', 1)[0].lower()
+        if scheme in ['redis', 'rediss']:
             if redis is None or RedisError is None:
                 raise RuntimeError('Redis package is not installed '
                                    '(Run "pip install redis" '
                                    'in your virtualenv).')
             return redis, RedisError
-        if schema == 'valkey':
+        if scheme in ['valkey', 'valkeys']:
             if valkey is None or ValkeyError is None:
                 raise RuntimeError('Valkey package is not installed '
                                    '(Run "pip install valkey" '
                                    'in your virtualenv).')
             return valkey, ValkeyError
-        error_msg = f'Unsupported Redis URL schema: {schema}'
+        if scheme == 'unix':
+            if redis is None or RedisError is None:
+                if valkey is None or ValkeyError is None:
+                    raise RuntimeError('Redis package is not installed '
+                                       '(Run "pip install redis" '
+                                       'or "pip install valkey" '
+                                       'in your virtualenv).')
+                else:
+                    return valkey, ValkeyError
+            else:
+                return redis, RedisError
+        error_msg = f'Unsupported Redis URL scheme: {scheme}'
         raise ValueError(error_msg)
 
     def _redis_connect(self):
@@ -138,7 +144,7 @@ class RedisManager(PubSubManager):  # pragma: no cover
                                                **self.redis_options)
         self.pubsub = self.redis.pubsub(ignore_subscribe_messages=True)
 
-    def _publish(self, data):
+    def _publish(self, data):  # pragma: no cover
         retry = True
         _, error = self._get_redis_module_and_error()
         while True:
@@ -160,7 +166,7 @@ class RedisManager(PubSubManager):  # pragma: no cover
                     )
                     break
 
-    def _redis_listen_with_retries(self):
+    def _redis_listen_with_retries(self):  # pragma: no cover
         retry_sleep = 1
         connect = False
         _, error = self._get_redis_module_and_error()
@@ -181,7 +187,7 @@ class RedisManager(PubSubManager):  # pragma: no cover
                 if retry_sleep > 60:
                     retry_sleep = 60
 
-    def _listen(self):
+    def _listen(self):  # pragma: no cover
         channel = self.channel.encode('utf-8')
         self.pubsub.subscribe(self.channel)
         for message in self._redis_listen_with_retries():

{python_socketio-5.14.0 → python_socketio-5.14.2}/tests/async/test_client.py

@@ -203,6 +203,60 @@ class TestAsyncClient:
         assert c.connected is True
         assert c.namespaces == {'/bar': '123', '/foo': '456'}
 
+    async def test_connect_wait_one_namespaces_error(self):
+        c = async_client.AsyncClient()
+        c.eio.connect = mock.AsyncMock()
+        c._connect_event = mock.MagicMock()
+
+        async def mock_connect():
+            if c.failed_namespaces == []:
+                c.failed_namespaces = ['/foo']
+                return True
+            return False
+
+        c._connect_event.wait = mock_connect
+        with pytest.raises(exceptions.ConnectionError,
+                           match='failed to connect: /foo'):
+            await c.connect(
+                'url',
+                namespaces=['/foo'],
+                wait=True,
+                wait_timeout=0.01,
+            )
+        assert c.connected is False
+        assert c.namespaces == {}
+        assert c.failed_namespaces == ['/foo']
+
+    async def test_connect_wait_three_namespaces_error(self):
+        c = async_client.AsyncClient()
+        c.eio.connect = mock.AsyncMock()
+        c._connect_event = mock.MagicMock()
+
+        async def mock_connect():
+            if c.namespaces == {}:
+                c.namespaces = {'/bar': '123'}
+                return True
+            elif c.namespaces == {'/bar': '123'} and c.failed_namespaces == []:
+                c.failed_namespaces = ['/baz']
+                return True
+            elif c.failed_namespaces == ['/baz']:
+                c.failed_namespaces = ['/baz', '/foo']
+                return True
+            return False
+
+        c._connect_event.wait = mock_connect
+        with pytest.raises(exceptions.ConnectionError,
+                           match='failed to connect: /baz, /foo'):
+            await c.connect(
+                'url',
+                namespaces=['/foo', '/bar', '/baz'],
+                wait=True,
+                wait_timeout=0.01,
+            )
+        assert c.connected is False
+        assert c.namespaces == {'/bar': '123'}
+        assert c.failed_namespaces == ['/baz', '/foo']
+
     async def test_connect_timeout(self):
         c = async_client.AsyncClient()
         c.eio.connect = mock.AsyncMock()