python-socketio 5.16.2__py3-none-any.whl → 5.16.3__py3-none-any.whl

{python_socketio-5.16.2.dist-info → python_socketio-5.16.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-socketio
-Version: 5.16.2
+Version: 5.16.3
 Summary: Socket.IO server and client for Python
 Author-email: Miguel Grinberg <miguel.grinberg@gmail.com>
 License: MIT

{python_socketio-5.16.2.dist-info → python_socketio-5.16.3.dist-info}/RECORD

@@ -1,14 +1,14 @@
-python_socketio-5.16.2.dist-info/licenses/LICENSE,sha256=yel9Pbwfu82094CLKCzWRtuIev9PUxP-a76NTDFAWpw,1082
+python_socketio-5.16.3.dist-info/licenses/LICENSE,sha256=yel9Pbwfu82094CLKCzWRtuIev9PUxP-a76NTDFAWpw,1082
 socketio/__init__.py,sha256=DXxtwPIqHFIqV4BGTgJ86OvCXD6Mth3PxBYhFoJ1_7g,1269
 socketio/admin.py,sha256=Ag0fz2QRVq5mprjkBe9txNjGPvQEpBai6-VJ-rJsxmA,16260
 socketio/asgi.py,sha256=NaJtYhOswVVcwHU0zcMM5H5TrSzXq9K-CAYaeSNTZRY,2192
 socketio/async_admin.py,sha256=4DFriPI3lwjgV80a81x1tndmQcRuYJGIu0wwkNS9ayY,16471
-socketio/async_aiopika_manager.py,sha256=X3PQrPMpJdu0yF8EoqvjB7lTb1wyAe4-EI1ToSuHiaA,5892
+socketio/async_aiopika_manager.py,sha256=zvP5FqHMgp3PZEHmtjKQm_LzhP1DWle_1M1EmLYS-n8,6037
 socketio/async_client.py,sha256=Xa9R2LJz6enF94TbfzPl7m2BMikLcqZl6AAZDyIHlZo,28124
 socketio/async_manager.py,sha256=G7TLqCDVozbHt0ODG3jU09h1ku6ahk87_Sz4Cm5tL90,4518
 socketio/async_namespace.py,sha256=BxSUs_iQzPHFo6JyoRZm2Yy0uRyizvS2PMCIzsVzk_o,12043
 socketio/async_pubsub_manager.py,sha256=UwU_i_cDvJ4vRzB6RnefEFuWKoiL35WgXHR0y2-CXas,12474
-socketio/async_redis_manager.py,sha256=S_S09BCeyr8N_Ma6ickbDuKESvPaKSYTSXAjd73OMPo,7848
+socketio/async_redis_manager.py,sha256=E0w4gDgrZnEUu5jCatf-P5F-wQvjr2673viEf8zr3pQ,7555
 socketio/async_server.py,sha256=nU-QMFiTk1i2WrLaxiUGJuHmfFnXPvpxHhMFcqC2JuM,36968
 socketio/async_simple_client.py,sha256=eZUgU9fz7c9lXhsbm4Ln95dinM9zxT3Ps2sML4HtT6Y,9016
 socketio/base_client.py,sha256=LJzYynrxPuId7xbHAWiTPFlEAROQCLi8cOmiIDuc1Lk,11673
@@ -18,19 +18,19 @@ socketio/base_server.py,sha256=JtHtmxFjtclcdORg7FIBoMtMxiaCFnuwulXrpLUSjUE,10637
 socketio/client.py,sha256=ttcjNZ-Qb1yUKjb2Eiylw02wt6ghTXWalfw_y7ODNRo,26355
 socketio/exceptions.py,sha256=c8yKss_oJl-fkL52X_AagyJecL-9Mxlgb5xDRqSz5tA,975
 socketio/kafka_manager.py,sha256=QrgTh94Ft2YmQbJ_uVX9HMotKWZYBfWh6Y66RYrSwtM,3114
-socketio/kombu_manager.py,sha256=EAwW-_L-FCQTWeZjpjE0xqJt5RZSUBdQwU7ASORyaNg,6468
+socketio/kombu_manager.py,sha256=3nLyVPrJyeKLi0E2jp0I33W3EYXDkR89mCmW0FtrBmk,6581
 socketio/manager.py,sha256=RPYPcVBFAjN-fEtLfcsPlk6SOW_SBATvw0Tkq_PkGZw,3861
 socketio/middleware.py,sha256=P8wOgSzy3YKOcRVI-r3KNKsEejBz_f5p2wdV8ZqW12E,1591
 socketio/msgpack_packet.py,sha256=gSLKgYP88QAJ1J8sOmgGFvtRBmNH8QWPtHImWaXIqzs,1765
 socketio/namespace.py,sha256=80y8BN2FFlHK8JKF1TirWvvE4pn9FkGKk14IVFkCLEs,9488
 socketio/packet.py,sha256=N7jEjcqOUg2PPEooCoEglxVxhjRqJF-FZCPyDF-UDKQ,7120
 socketio/pubsub_manager.py,sha256=3xUqRnHiFVf_YI68OWRakJTa2LGHPpyMZNSAQN43GZY,11775
-socketio/redis_manager.py,sha256=_I8n5GJcYWlSnmYZnADDfvn4FP2BMfllHqN4JYuuYeE,8923
+socketio/redis_manager.py,sha256=5MhbV4DWJtazxvEgAF_fmAVj-a_F6xhFhq9cpX-_V2I,8734
 socketio/server.py,sha256=cNDOBJ8u01D0ttZmcrUM0vN-1rT8Z1D_-oMMOnEWGWU,35341
 socketio/simple_client.py,sha256=aSMTRO8LHBAWO2IV9uetL6_zwZgPGR-ts73x_4k3624,8434
 socketio/tornado.py,sha256=R82JCqz-E1ibZAQX708h7FX3sguCHQ1OLYpnMag-LY8,295
 socketio/zmq_manager.py,sha256=PkY5aP7-JesCJjumRht90pf3dqLGZV1WrGZ5lA8jQ-Y,4232
-python_socketio-5.16.2.dist-info/METADATA,sha256=HQPRrjFBGlBfPidsgpLOckqXI6rW4OhwoO5gIydq9Gs,3281
-python_socketio-5.16.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-python_socketio-5.16.2.dist-info/top_level.txt,sha256=xWd-HVUanhys_VzQQTRTRZBX8W448ayFytYf1Zffivs,9
-python_socketio-5.16.2.dist-info/RECORD,,
+python_socketio-5.16.3.dist-info/METADATA,sha256=Sh2h28lDLOA2zYOvS6I-_7Bn4hEFvMIfn1rPSrdyJ98,3281
+python_socketio-5.16.3.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+python_socketio-5.16.3.dist-info/top_level.txt,sha256=xWd-HVUanhys_VzQQTRTRZBX8W448ayFytYf1Zffivs,9
+python_socketio-5.16.3.dist-info/RECORD,,

socketio/async_aiopika_manager.py

@@ -97,18 +97,20 @@ class AsyncAioPikaManager(AsyncPubSubManager):  # pragma: no cover
                     ), routing_key='*',
                 )
                 break
-            except aio_pika.AMQPException:
+            except aio_pika.exceptions.ChannelInvalidStateError:
+                # aio_pika raises this exception when the task is cancelled
+                raise asyncio.CancelledError()
+            except Exception as exc:
                 if retry:
-                    self._get_logger().error('Cannot publish to rabbitmq... '
-                                             'retrying')
+                    self._get_logger().error(
+                        'Cannot publish to rabbitmq... retrying',
+                        extra={"rabbitmq_exception": str(exc)})
                     retry = False
                 else:
                     self._get_logger().error(
-                        'Cannot publish to rabbitmq... giving up')
+                        'Cannot publish to rabbitmq... giving up',
+                        extra={"rabbitmq_exception": str(exc)})
                     break
-            except aio_pika.exceptions.ChannelInvalidStateError:
-                # aio_pika raises this exception when the task is cancelled
-                raise asyncio.CancelledError()
 
     async def _listen(self):
         retry_sleep = 1
@@ -125,12 +127,13 @@ class AsyncAioPikaManager(AsyncPubSubManager):  # pragma: no cover
                             async with message.process():
                                 yield message.body
                                 retry_sleep = 1
-            except aio_pika.AMQPException:
-                self._get_logger().error(
-                    'Cannot receive from rabbitmq... '
-                    'retrying in {} secs'.format(retry_sleep))
-                await asyncio.sleep(retry_sleep)
-                retry_sleep = min(retry_sleep * 2, 60)
             except aio_pika.exceptions.ChannelInvalidStateError:
                 # aio_pika raises this exception when the task is cancelled
                 raise asyncio.CancelledError()
+            except Exception as exc:
+                self._get_logger().error(
+                    'Cannot receive from rabbotmq... retrying in '
+                    f'{retry_sleep} secs',
+                    extra={"rabbitmq_exception": str(exc)})
+                await asyncio.sleep(retry_sleep)
+                retry_sleep = min(retry_sleep * 2, 60)

socketio/async_redis_manager.py

@@ -75,7 +75,7 @@ class AsyncRedisManager(AsyncPubSubManager):
         self.redis = None
         self.pubsub = None
 
-    def _get_redis_module_and_error(self):
+    def _get_redis_module(self):
         parsed_url = urlparse(self.redis_url)
         scheme = parsed_url.scheme.split('+', 1)[0].lower()
         if scheme in ['redis', 'rediss']:
@@ -83,13 +83,13 @@ class AsyncRedisManager(AsyncPubSubManager):
                 raise RuntimeError('Redis package is not installed '
                                    '(Run "pip install redis" '
                                    'in your virtualenv).')
-            return aioredis, RedisError
+            return aioredis
         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 aiovalkey, ValkeyError
+            return aiovalkey
         if scheme == 'unix':
             if aioredis is None or RedisError is None:
                 if aiovalkey is None or ValkeyError is None:
@@ -98,14 +98,14 @@ class AsyncRedisManager(AsyncPubSubManager):
                                        'or "pip install valkey" '
                                        'in your virtualenv).')
                 else:
-                    return aiovalkey, ValkeyError
+                    return aiovalkey
             else:
-                return aioredis, RedisError
+                return aioredis
         error_msg = f'Unsupported Redis URL scheme: {scheme}'
         raise ValueError(error_msg)
 
     def _redis_connect(self):
-        module, _ = self._get_redis_module_and_error()
+        module = self._get_redis_module()
         parsed_url = urlparse(self.redis_url)
         if parsed_url.scheme in {"redis+sentinel", "valkey+sentinel"}:
             sentinels, service_name, connection_kwargs = \
@@ -121,30 +121,25 @@ class AsyncRedisManager(AsyncPubSubManager):
         self.connected = True
 
     async def _publish(self, data):  # pragma: no cover
-        _, error = self._get_redis_module_and_error()
         for retries_left in range(1, -1, -1):  # 2 attempts
             try:
                 if not self.connected:
                     self._redis_connect()
                 return await self.redis.publish(
                     self.channel, self.json.dumps(data))
-            except error as exc:
+            except Exception as exc:
                 if retries_left > 0:
                     self._get_logger().error(
-                        'Cannot publish to redis... '
-                        'retrying',
+                        'Cannot publish to redis... retrying',
                         extra={"redis_exception": str(exc)})
                     self.connected = False
                 else:
                     self._get_logger().error(
-                        'Cannot publish to redis... '
-                        'giving up',
+                        'Cannot publish to redis... giving up',
                         extra={"redis_exception": str(exc)})
-
                     break
 
     async def _redis_listen_with_retries(self):  # pragma: no cover
-        _, error = self._get_redis_module_and_error()
         retry_sleep = 1
         subscribed = False
         while True:
@@ -155,11 +150,11 @@ class AsyncRedisManager(AsyncPubSubManager):
                     retry_sleep = 1
                 async for message in self.pubsub.listen():
                     yield message
-            except error as exc:
-                self._get_logger().error('Cannot receive from redis... '
-                                         'retrying in '
-                                         f'{retry_sleep} secs',
-                                         extra={"redis_exception": str(exc)})
+            except Exception as exc:
+                self._get_logger().error(
+                    'Cannot receive from redis... retrying in '
+                    f'{retry_sleep} secs',
+                    extra={"redis_exception": str(exc)})
                 subscribed = False
                 await asyncio.sleep(retry_sleep)
                 retry_sleep *= 2

socketio/kombu_manager.py

@@ -114,14 +114,16 @@ class KombuManager(PubSubManager):  # pragma: no cover
                     self.publisher_connection)
                 producer_publish(self.json.dumps(data))
                 break
-            except (OSError, kombu.exceptions.KombuError):
+            except Exception as exc:
                 if retry:
-                    self._get_logger().error('Cannot publish to rabbitmq... '
-                                             'retrying')
+                    self._get_logger().error(
+                        'Cannot publish to rabbitmq... retrying',
+                        extra={"rabbitmq_exception": str(exc)})
                     retry = False
                 else:
                     self._get_logger().error(
-                        'Cannot publish to rabbitmq... giving up')
+                        'Cannot publish to rabbitmq... giving up',
+                        extra={"rabbitmq_exception": str(exc)})
                     break
 
     def _listen(self):
@@ -136,9 +138,10 @@ class KombuManager(PubSubManager):  # pragma: no cover
                             message.ack()
                             yield message.payload
                             retry_sleep = 1
-            except (OSError, kombu.exceptions.KombuError):
+            except Exception as exc:
                 self._get_logger().error(
-                    'Cannot receive from rabbitmq... '
-                    'retrying in {} secs'.format(retry_sleep))
+                    'Cannot receive from rabbotmq... retrying in '
+                    f'{retry_sleep} secs',
+                    extra={"rabbitmq_exception": str(exc)})
                 time.sleep(retry_sleep)
                 retry_sleep = min(retry_sleep * 2, 60)

socketio/redis_manager.py

@@ -1,4 +1,3 @@
-import logging
 import time
 from urllib.parse import urlparse
 
@@ -18,8 +17,6 @@ except ImportError:  # pragma: no cover
 
 from .pubsub_manager import PubSubManager
 
-logger = logging.getLogger('socketio')
-
 
 def parse_redis_sentinel_url(url):
     """Parse a Redis Sentinel URL with the format:
@@ -112,7 +109,7 @@ class RedisManager(PubSubManager):
                 'Redis requires a monkey patched socket library to work '
                 'with ' + self.server.async_mode)
 
-    def _get_redis_module_and_error(self):
+    def _get_redis_module(self):
         parsed_url = urlparse(self.redis_url)
         scheme = parsed_url.scheme.split('+', 1)[0].lower()
         if scheme in ['redis', 'rediss']:
@@ -120,13 +117,13 @@ class RedisManager(PubSubManager):
                 raise RuntimeError('Redis package is not installed '
                                    '(Run "pip install redis" '
                                    'in your virtualenv).')
-            return redis, RedisError
+            return redis
         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
+            return valkey
         if scheme == 'unix':
             if redis is None or RedisError is None:
                 if valkey is None or ValkeyError is None:
@@ -135,14 +132,14 @@ class RedisManager(PubSubManager):
                                        'or "pip install valkey" '
                                        'in your virtualenv).')
                 else:
-                    return valkey, ValkeyError
+                    return valkey
             else:
-                return redis, RedisError
+                return redis
         error_msg = f'Unsupported Redis URL scheme: {scheme}'
         raise ValueError(error_msg)
 
     def _redis_connect(self):
-        module, _ = self._get_redis_module_and_error()
+        module = self._get_redis_module()
         parsed_url = urlparse(self.redis_url)
         if parsed_url.scheme in {"redis+sentinel", "valkey+sentinel"}:
             sentinels, service_name, connection_kwargs = \
@@ -158,28 +155,26 @@ class RedisManager(PubSubManager):
         self.connected = True
 
     def _publish(self, data):  # pragma: no cover
-        _, error = self._get_redis_module_and_error()
         for retries_left in range(1, -1, -1):  # 2 attempts
             try:
                 if not self.connected:
                     self._redis_connect()
                 return self.redis.publish(self.channel, self.json.dumps(data))
-            except error as exc:
+            except Exception as exc:
                 if retries_left > 0:
-                    logger.error(
+                    self._get_logger().error(
                         'Cannot publish to redis... retrying',
                         extra={"redis_exception": str(exc)}
                     )
                     self.connected = False
                 else:
-                    logger.error(
+                    self._get_logger().error(
                         'Cannot publish to redis... giving up',
                         extra={"redis_exception": str(exc)}
                     )
                     break
 
     def _redis_listen_with_retries(self):  # pragma: no cover
-        _, error = self._get_redis_module_and_error()
         retry_sleep = 1
         subscribed = False
         while True:
@@ -189,10 +184,11 @@ class RedisManager(PubSubManager):
                     self.pubsub.subscribe(self.channel)
                     retry_sleep = 1
                 yield from self.pubsub.listen()
-            except error as exc:
-                logger.error('Cannot receive from redis... '
-                             f'retrying in {retry_sleep} secs',
-                             extra={"redis_exception": str(exc)})
+            except Exception as exc:
+                self._get_logger().error(
+                    'Cannot receive from redis... '
+                    f'retrying in {retry_sleep} secs',
+                    extra={"redis_exception": str(exc)})
                 subscribed = False
                 time.sleep(retry_sleep)
                 retry_sleep *= 2