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

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

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: python-socketio
-Version: 5.13.0
+Version: 5.14.0
 Summary: Socket.IO server and client for Python
 Author-email: Miguel Grinberg <miguel.grinberg@gmail.com>
+License: MIT
 Project-URL: Homepage, https://github.com/miguelgrinberg/python-socketio
 Project-URL: Bug Tracker, https://github.com/miguelgrinberg/python-socketio/issues
 Classifier: Environment :: Web Environment
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown

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

@@ -1089,6 +1089,25 @@ The RabbitMQ queue is configured through the
     mgr = socketio.AsyncAioPikaManager('amqp://')
     sio = socketio.AsyncServer(client_manager=mgr)
 
+Deploying the Message Queue for Production
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+For a production deployment there are a few recommendations to keep your
+application secure.
+
+First of all, the message queue should never be listening on a public network
+interface, to ensure that external clients never connect to it. For a single
+node deployment, the queue should only listen on `localhost`. For a multi-node
+system the use of a private network (VPC), where the communication between
+servers can happen privately is highly recommended.
+
+In addition, all message queues support authentication and encryption, which
+can strenthen the security of the deployment. Authentication ensures that only
+the Socket.IO servers and related processes have access, while encryption
+prevents data from being collected by a third-party that is listening on the
+network. Access credentials can be included in the connection URLs that are
+passed to the client managers.
+
 Horizontal Scaling
 ~~~~~~~~~~~~~~~~~~
 

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

@@ -1,6 +1,7 @@
 [project]
 name = "python-socketio"
-version = "5.13.0"
+version = "5.14.0"
+license = {text = "MIT"}
 authors = [
     { name = "Miguel Grinberg", email = "miguel.grinberg@gmail.com" },
 ]
@@ -9,7 +10,6 @@ classifiers = [
     "Environment :: Web Environment",
     "Intended Audience :: Developers",
     "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
 requires-python = ">=3.8"

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

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: python-socketio
-Version: 5.13.0
+Version: 5.14.0
 Summary: Socket.IO server and client for Python
 Author-email: Miguel Grinberg <miguel.grinberg@gmail.com>
+License: MIT
 Project-URL: Homepage, https://github.com/miguelgrinberg/python-socketio
 Project-URL: Bug Tracker, https://github.com/miguelgrinberg/python-socketio/issues
 Classifier: Environment :: Web Environment
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown

{python_socketio-5.13.0 → python_socketio-5.14.0}/src/socketio/async_aiopika_manager.py

@@ -1,6 +1,6 @@
 import asyncio
-import pickle
 
+from engineio import json
 from .async_pubsub_manager import AsyncPubSubManager
 
 try:
@@ -43,12 +43,12 @@ class AsyncAioPikaManager(AsyncPubSubManager):  # pragma: no cover
             raise RuntimeError('aio_pika package is not installed '
                                '(Run "pip install aio_pika" in your '
                                'virtualenv).')
+        super().__init__(channel=channel, write_only=write_only, logger=logger)
         self.url = url
         self._lock = asyncio.Lock()
         self.publisher_connection = None
         self.publisher_channel = None
         self.publisher_exchange = None
-        super().__init__(channel=channel, write_only=write_only, logger=logger)
 
     async def _connection(self):
         return await aio_pika.connect_robust(self.url)
@@ -82,7 +82,7 @@ class AsyncAioPikaManager(AsyncPubSubManager):  # pragma: no cover
             try:
                 await self.publisher_exchange.publish(
                     aio_pika.Message(
-                        body=pickle.dumps(data),
+                        body=json.dumps(data),
                         delivery_mode=aio_pika.DeliveryMode.PERSISTENT
                     ), routing_key='*',
                 )
@@ -113,7 +113,7 @@ class AsyncAioPikaManager(AsyncPubSubManager):  # pragma: no cover
                     async with queue.iterator() as queue_iter:
                         async for message in queue_iter:
                             async with message.process():
-                                yield pickle.loads(message.body)
+                                yield message.body
                                 retry_sleep = 1
                 except aio_pika.AMQPException:
                     self._get_logger().error(

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

@@ -139,6 +139,7 @@ class AsyncClient(base_client.BaseClient):
             namespaces = [namespaces]
         self.connection_namespaces = namespaces
         self.namespaces = {}
+        self.failed_namespaces = []
         if self._connect_event is None:
             self._connect_event = self.eio.create_event()
         else:
@@ -166,14 +167,16 @@ class AsyncClient(base_client.BaseClient):
                     await asyncio.wait_for(self._connect_event.wait(),
                                            wait_timeout)
                     self._connect_event.clear()
-                    if set(self.namespaces) == set(self.connection_namespaces):
+                    if len(self.namespaces) + len(self.failed_namespaces) == \
+                            len(self.connection_namespaces):
                         break
             except asyncio.TimeoutError:
                 pass
             if set(self.namespaces) != set(self.connection_namespaces):
                 await self.disconnect()
                 raise exceptions.ConnectionError(
-                    'One or more namespaces failed to connect')
+                    'One or more namespaces failed to connect'
+                    ', '.join(self.failed_namespaces))
 
         self.connected = True
 
@@ -191,7 +194,6 @@ 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
@@ -405,7 +407,7 @@ class AsyncClient(base_client.BaseClient):
             del self.namespaces[namespace]
         if not self.namespaces:
             self.connected = False
-            await self.eio.disconnect(abort=True)
+            await self.eio.disconnect()
 
     async def _handle_event(self, namespace, id, data):
         namespace = namespace or '/'
@@ -449,6 +451,7 @@ class AsyncClient(base_client.BaseClient):
         elif not isinstance(data, (tuple, list)):
             data = (data,)
         await self._trigger_event('connect_error', namespace, *data)
+        self.failed_namespaces.append(namespace)
         self._connect_event.set()
         if namespace in self.namespaces:
             del self.namespaces[namespace]

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

@@ -3,7 +3,6 @@ from functools import partial
 import uuid
 
 from engineio import json
-import pickle
 
 from .async_manager import AsyncManager
 
@@ -202,16 +201,10 @@ class AsyncPubSubManager(AsyncManager):
                     if isinstance(message, dict):
                         data = message
                     else:
-                        if isinstance(message, bytes):  # pragma: no cover
-                            try:
-                                data = pickle.loads(message)
-                            except:
-                                pass
-                        if data is None:
-                            try:
-                                data = json.loads(message)
-                            except:
-                                pass
+                        try:
+                            data = json.loads(message)
+                        except:
+                            pass
                     if data and 'method' in data:
                         self._get_logger().debug('pubsub message: {}'.format(
                             data['method']))

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

@@ -1,5 +1,5 @@
 import asyncio
-import pickle
+from urllib.parse import urlparse
 
 try:  # pragma: no cover
     from redis import asyncio as aioredis
@@ -12,6 +12,14 @@ except ImportError:  # pragma: no cover
         aioredis = None
         RedisError = None
 
+try:  # pragma: no cover
+    from valkey import asyncio as valkey
+    from valkey.exceptions import ValkeyError
+except ImportError:  # pragma: no cover
+    valkey = None
+    ValkeyError = None
+
+from engineio import json
 from .async_pubsub_manager import AsyncPubSubManager
 from .redis_manager import parse_redis_sentinel_url
 
@@ -47,50 +55,79 @@ 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:
+        if aioredis is None and valkey is None:
             raise RuntimeError('Redis package is not installed '
-                               '(Run "pip install redis" in your virtualenv).')
-        if not hasattr(aioredis.Redis, 'from_url'):
+                               '(Run "pip install redis" or '
+                               '"pip install valkey" '
+                               'in your virtualenv).')
+        if aioredis and not hasattr(aioredis.Redis, 'from_url'):
             raise RuntimeError('Version 2 of aioredis package is required.')
+        super().__init__(channel=channel, write_only=write_only, logger=logger)
         self.redis_url = url
         self.redis_options = redis_options or {}
         self._redis_connect()
-        super().__init__(channel=channel, write_only=write_only, logger=logger)
+
+    def _get_redis_module_and_error(self):
+        parsed_url = urlparse(self.redis_url)
+        schema = parsed_url.scheme.split('+', 1)[0].lower()
+        if schema == 'redis':
+            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:
+                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}'
+        raise ValueError(error_msg)
 
     def _redis_connect(self):
-        if not self.redis_url.startswith('redis+sentinel://'):
-            self.redis = aioredis.Redis.from_url(self.redis_url,
-                                                 **self.redis_options)
-        else:
+        module, _ = self._get_redis_module_and_error()
+        parsed_url = urlparse(self.redis_url)
+        if parsed_url.scheme in {"redis+sentinel", "valkey+sentinel"}:
             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)
+            sentinel = module.sentinel.Sentinel(sentinels, **kwargs)
             self.redis = sentinel.master_for(service_name or self.channel)
+        else:
+            self.redis = module.Redis.from_url(self.redis_url,
+                                               **self.redis_options)
         self.pubsub = self.redis.pubsub(ignore_subscribe_messages=True)
 
     async def _publish(self, data):
         retry = True
+        _, error = self._get_redis_module_and_error()
         while True:
             try:
                 if not retry:
                     self._redis_connect()
                 return await self.redis.publish(
-                    self.channel, pickle.dumps(data))
-            except RedisError:
+                    self.channel, json.dumps(data))
+            except error as exc:
                 if retry:
-                    self._get_logger().error('Cannot publish to redis... '
-                                             'retrying')
+                    self._get_logger().error(
+                        'Cannot publish to redis... '
+                        'retrying',
+                        extra={"redis_exception": str(exc)})
                     retry = False
                 else:
-                    self._get_logger().error('Cannot publish to redis... '
-                                             'giving up')
+                    self._get_logger().error(
+                        'Cannot publish to redis... '
+                        'giving up',
+                        extra={"redis_exception": str(exc)})
+
                     break
 
     async def _redis_listen_with_retries(self):
         retry_sleep = 1
         connect = False
+        _, error = self._get_redis_module_and_error()
         while True:
             try:
                 if connect:
@@ -99,10 +136,11 @@ class AsyncRedisManager(AsyncPubSubManager):  # pragma: no cover
                     retry_sleep = 1
                 async for message in self.pubsub.listen():
                     yield message
-            except RedisError:
+            except error as exc:
                 self._get_logger().error('Cannot receive from redis... '
                                          'retrying in '
-                                         '{} secs'.format(retry_sleep))
+                                         f'{retry_sleep} secs',
+                                         extra={"redis_exception": str(exc)})
                 connect = True
                 await asyncio.sleep(retry_sleep)
                 retry_sleep *= 2

{python_socketio-5.13.0 → python_socketio-5.14.0}/src/socketio/async_server.py

@@ -373,15 +373,15 @@ class AsyncServer(base_server.BaseServer):
         context manager block are saved back to the session. Example usage::
 
             @eio.on('connect')
-            def on_connect(sid, environ):
+            async def on_connect(sid, environ):
                 username = authenticate_user(environ)
                 if not username:
                     return False
-                with eio.session(sid) as session:
+                async with eio.session(sid) as session:
                     session['username'] = username
 
             @eio.on('message')
-            def on_message(sid, msg):
+            async def on_message(sid, msg):
                 async with eio.session(sid) as session:
                     print('received message from ', session['username'])
         """

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

@@ -105,7 +105,7 @@ class AsyncSimpleClient:
         The transport is returned as a string and can be one of ``polling``
         and ``websocket``.
         """
-        return self.client.transport if self.client else ''
+        return self.client.transport() if self.client else ''
 
     async def emit(self, event, data=None):
         """Emit an event to the server.
@@ -163,6 +163,8 @@ class AsyncSimpleClient:
                 return await self.client.call(event, data,
                                               namespace=self.namespace,
                                               timeout=timeout)
+            except TimeoutError:
+                raise
             except SocketIOError:
                 pass
 

{python_socketio-5.13.0 → python_socketio-5.14.0}/src/socketio/base_client.py

@@ -93,6 +93,7 @@ class BaseClient:
 
         self.connected = False  #: Indicates if the client is connected or not.
         self.namespaces = {}  #: set of connected namespaces.
+        self.failed_namespaces = []
         self.handlers = {}
         self.namespace_handlers = {}
         self.callbacks = {}

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

@@ -137,6 +137,7 @@ class Client(base_client.BaseClient):
             namespaces = [namespaces]
         self.connection_namespaces = namespaces
         self.namespaces = {}
+        self.failed_namespaces = []
         if self._connect_event is None:
             self._connect_event = self.eio.create_event()
         else:
@@ -161,12 +162,14 @@ class Client(base_client.BaseClient):
         if wait:
             while self._connect_event.wait(timeout=wait_timeout):
                 self._connect_event.clear()
-                if set(self.namespaces) == set(self.connection_namespaces):
+                if len(self.namespaces) + len(self.failed_namespaces) == \
+                        len(self.connection_namespaces):
                     break
             if set(self.namespaces) != set(self.connection_namespaces):
                 self.disconnect()
                 raise exceptions.ConnectionError(
-                    'One or more namespaces failed to connect')
+                    'One or more namespaces failed to connect: '
+                    ', '.join(self.failed_namespaces))
 
         self.connected = True
 
@@ -384,7 +387,7 @@ class Client(base_client.BaseClient):
             del self.namespaces[namespace]
         if not self.namespaces:
             self.connected = False
-            self.eio.disconnect(abort=True)
+            self.eio.disconnect()
 
     def _handle_event(self, namespace, id, data):
         namespace = namespace or '/'
@@ -425,6 +428,7 @@ class Client(base_client.BaseClient):
         elif not isinstance(data, (tuple, list)):
             data = (data,)
         self._trigger_event('connect_error', namespace, *data)
+        self.failed_namespaces.append(namespace)
         self._connect_event.set()
         if namespace in self.namespaces:
             del self.namespaces[namespace]
@@ -439,7 +443,7 @@ class Client(base_client.BaseClient):
         if handler:
             try:
                 return handler(*args)
-            except TypeError:
+            except TypeError:  # pragma: no cover
                 # the legacy disconnect event does not take a reason argument
                 if event == 'disconnect':
                     return handler(*args[:-1])

{python_socketio-5.13.0 → python_socketio-5.14.0}/src/socketio/kafka_manager.py

@@ -1,11 +1,11 @@
 import logging
-import pickle
 
 try:
     import kafka
 except ImportError:
     kafka = None
 
+from engineio import json
 from .pubsub_manager import PubSubManager
 
 logger = logging.getLogger('socketio')
@@ -53,7 +53,7 @@ class KafkaManager(PubSubManager):  # pragma: no cover
                                             bootstrap_servers=self.kafka_urls)
 
     def _publish(self, data):
-        self.producer.send(self.channel, value=pickle.dumps(data))
+        self.producer.send(self.channel, value=json.dumps(data))
         self.producer.flush()
 
     def _kafka_listen(self):
@@ -62,4 +62,4 @@ class KafkaManager(PubSubManager):  # pragma: no cover
     def _listen(self):
         for message in self._kafka_listen():
             if message.topic == self.channel:
-                yield pickle.loads(message.value)
+                yield message.value

{python_socketio-5.13.0 → python_socketio-5.14.0}/src/socketio/kombu_manager.py

@@ -1,4 +1,3 @@
-import pickle
 import time
 import uuid
 
@@ -7,6 +6,7 @@ try:
 except ImportError:
     kombu = None
 
+from engineio import json
 from .pubsub_manager import PubSubManager
 
 
@@ -102,7 +102,7 @@ class KombuManager(PubSubManager):  # pragma: no cover
             try:
                 producer_publish = self._producer_publish(
                     self.publisher_connection)
-                producer_publish(pickle.dumps(data))
+                producer_publish(json.dumps(data))
                 break
             except (OSError, kombu.exceptions.KombuError):
                 if retry:

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

@@ -2,7 +2,6 @@ from functools import partial
 import uuid
 
 from engineio import json
-import pickle
 
 from .manager import Manager
 
@@ -196,16 +195,10 @@ class PubSubManager(Manager):
                     if isinstance(message, dict):
                         data = message
                     else:
-                        if isinstance(message, bytes):  # pragma: no cover
-                            try:
-                                data = pickle.loads(message)
-                            except:
-                                pass
-                        if data is None:
-                            try:
-                                data = json.loads(message)
-                            except:
-                                pass
+                        try:
+                            data = json.loads(message)
+                        except:
+                            pass
                     if data and 'method' in data:
                         self._get_logger().debug('pubsub message: {}'.format(
                             data['method']))

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

@@ -1,13 +1,22 @@
 import logging
-import pickle
 import time
 from urllib.parse import urlparse
 
-try:
+try:  # pragma: no cover
     import redis
+    from redis.exceptions import RedisError
 except ImportError:
     redis = None
+    RedisError = None
 
+try:  # pragma: no cover
+    import valkey
+    from valkey.exceptions import ValkeyError
+except ImportError:
+    valkey = None
+    ValkeyError = None
+
+from engineio import json
 from .pubsub_manager import PubSubManager
 
 logger = logging.getLogger('socketio')
@@ -18,7 +27,7 @@ def parse_redis_sentinel_url(url):
     redis+sentinel://[:password]@host1:port1,host2:port2,.../db/service_name
     """
     parsed_url = urlparse(url)
-    if parsed_url.scheme != 'redis+sentinel':
+    if parsed_url.scheme not in {'redis+sentinel', 'valkey+sentinel'}:
         raise ValueError('Invalid Redis Sentinel URL')
     sentinels = []
     for host_port in parsed_url.netloc.split('@')[-1].split(','):
@@ -71,14 +80,15 @@ 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:
+        if redis is None and valkey is None:
             raise RuntimeError('Redis package is not installed '
-                               '(Run "pip install redis" in your '
-                               'virtualenv).')
+                               '(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()
-        super().__init__(channel=channel, write_only=write_only, logger=logger)
 
     def initialize(self):
         super().initialize()
@@ -95,37 +105,65 @@ class RedisManager(PubSubManager):  # pragma: no cover
                 'Redis requires a monkey patched socket library to work '
                 'with ' + self.server.async_mode)
 
+    def _get_redis_module_and_error(self):
+        parsed_url = urlparse(self.redis_url)
+        schema = parsed_url.scheme.split('+', 1)[0].lower()
+        if schema == 'redis':
+            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 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}'
+        raise ValueError(error_msg)
+
     def _redis_connect(self):
-        if not self.redis_url.startswith('redis+sentinel://'):
-            self.redis = redis.Redis.from_url(self.redis_url,
-                                              **self.redis_options)
-        else:
+        module, _ = self._get_redis_module_and_error()
+        parsed_url = urlparse(self.redis_url)
+        if parsed_url.scheme in {"redis+sentinel", "valkey+sentinel"}:
             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)
+            sentinel = module.sentinel.Sentinel(sentinels, **kwargs)
             self.redis = sentinel.master_for(service_name or self.channel)
+        else:
+            self.redis = module.Redis.from_url(self.redis_url,
+                                               **self.redis_options)
         self.pubsub = self.redis.pubsub(ignore_subscribe_messages=True)
 
     def _publish(self, data):
         retry = True
+        _, error = self._get_redis_module_and_error()
         while True:
             try:
                 if not retry:
                     self._redis_connect()
-                return self.redis.publish(self.channel, pickle.dumps(data))
-            except redis.exceptions.RedisError:
+                return self.redis.publish(self.channel, json.dumps(data))
+            except error as exc:
                 if retry:
-                    logger.error('Cannot publish to redis... retrying')
+                    logger.error(
+                        'Cannot publish to redis... retrying',
+                        extra={"redis_exception": str(exc)}
+                    )
                     retry = False
                 else:
-                    logger.error('Cannot publish to redis... giving up')
+                    logger.error(
+                        'Cannot publish to redis... giving up',
+                        extra={"redis_exception": str(exc)}
+                    )
                     break
 
     def _redis_listen_with_retries(self):
         retry_sleep = 1
         connect = False
+        _, error = self._get_redis_module_and_error()
         while True:
             try:
                 if connect:
@@ -133,9 +171,10 @@ class RedisManager(PubSubManager):  # pragma: no cover
                     self.pubsub.subscribe(self.channel)
                     retry_sleep = 1
                 yield from self.pubsub.listen()
-            except redis.exceptions.RedisError:
+            except error as exc:
                 logger.error('Cannot receive from redis... '
-                             'retrying in {} secs'.format(retry_sleep))
+                             f'retrying in {retry_sleep} secs',
+                             extra={"redis_exception": str(exc)})
                 connect = True
                 time.sleep(retry_sleep)
                 retry_sleep *= 2