sycommon-python-lib 0.1.31__tar.gz → 0.1.33__tar.gz

{sycommon_python_lib-0.1.31 → sycommon_python_lib-0.1.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.31
+Version: 0.1.33
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{sycommon_python_lib-0.1.31 → sycommon_python_lib-0.1.33}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.1.31"
+version = "0.1.33"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.10"

{sycommon_python_lib-0.1.31 → sycommon_python_lib-0.1.33}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -45,11 +45,6 @@ class RabbitMQClient:
         prefetch_count: int = 2,
         consumption_stall_threshold: int = 10
     ):
-        """
-        初始化RabbitMQ客户端（依赖连接池）
-
-        :param connection_pool: 连接池实例
-        """
         # 连接池依赖
         self.connection_pool = connection_pool
 
@@ -85,7 +80,7 @@ class RabbitMQClient:
         self._exchange_exists = False
         self._queue_exists = False
         self._queue_bound = False
-        self._is_consuming = False
+        self._is_consuming = False  # 核心消费状态标志
         self._closed = False
         self._consumer_tag: Optional[ConsumerTag] = None
         self._last_activity_timestamp = asyncio.get_event_loop().time()
@@ -102,7 +97,7 @@ class RabbitMQClient:
         self._monitor_task: Optional[asyncio.Task] = None
 
         # 消息处理跟踪
-        self._processing_message_ids: Set[str] = set()
+        self._tracking_messages: Dict[str, Dict[str, Any]] = {}
 
     @property
     def is_connected(self) -> bool:
@@ -120,19 +115,23 @@ class RabbitMQClient:
         """更新最后消息处理时间戳"""
         self._last_message_processed = asyncio.get_event_loop().time()
 
+    def _set_is_consuming(self, value: bool) -> None:
+        """安全更新消费状态并记录日志"""
+        if self._is_consuming != value:
+            logger.info(f"消费状态变更: {self._is_consuming} → {value}")
+            self._is_consuming = value
+
     async def _get_channel(self) -> AbstractChannel:
         """从通道池获取通道（使用上下文管理器）"""
         if not self.connection_pool.channel_pool:
             raise Exception("连接池未初始化，请先调用init_pools")
 
-        # 使用async with获取通道，并通过变量返回
         async with self.connection_pool.channel_pool.acquire() as channel:
             return channel
 
     async def _check_exchange_exists(self, channel: AbstractChannel) -> bool:
         """检查交换机是否存在"""
         try:
-            # 使用被动模式检查交换机
             await asyncio.wait_for(
                 channel.declare_exchange(
                     name=self.exchange_name,
@@ -150,7 +149,6 @@ class RabbitMQClient:
         if not self.queue_name:
             return False
         try:
-            # 使用被动模式检查队列
             await asyncio.wait_for(
                 channel.declare_queue(
                     name=self.queue_name,
@@ -186,19 +184,15 @@ class RabbitMQClient:
         return False
 
     async def connect(self, force_reconnect: bool = False, declare_queue: bool = True) -> None:
-        """
-        从连接池获取资源并初始化（交换机、队列）
-        """
-        logger.debug(
+        """从连接池获取资源并初始化（交换机、队列）"""
+        logger.info(
             f"连接参数 - force_reconnect={force_reconnect}, "
             f"declare_queue={declare_queue}, create_if_not_exists={self.create_if_not_exists}"
         )
 
-        # 如果已连接且不强制重连，则直接返回
         if self.is_connected and not force_reconnect:
             return
 
-        # 取消正在进行的重连任务
         if self._reconnect_task and not self._reconnect_task.done():
             self._reconnect_task.cancel()
 
@@ -206,13 +200,13 @@ class RabbitMQClient:
         self._exchange_exists = False
         self._queue_exists = False
         self._queue_bound = False
+        self._set_is_consuming(False)  # 连接时先停止消费
 
         retries = 0
         last_exception = None
 
         while retries < self.max_reconnection_attempts:
             try:
-                # 从池获取通道
                 self.channel = await self._get_channel()
                 await self.channel.set_qos(prefetch_count=self.prefetch_count)
 
@@ -220,7 +214,6 @@ class RabbitMQClient:
                 exchange_exists = await self._check_exchange_exists(self.channel)
                 if not exchange_exists:
                     if self.create_if_not_exists:
-                        # 创建交换机
                         self.exchange = await asyncio.wait_for(
                             self.channel.declare_exchange(
                                 name=self.exchange_name,
@@ -235,7 +228,6 @@ class RabbitMQClient:
                         raise Exception(
                             f"交换机 '{self.exchange_name}' 不存在且不允许自动创建")
                 else:
-                    # 获取已有交换机
                     self.exchange = await self.channel.get_exchange(self.exchange_name)
                     logger.info(f"使用已存在的交换机 '{self.exchange_name}'")
 
@@ -248,7 +240,6 @@ class RabbitMQClient:
                             raise Exception(
                                 f"队列 '{self.queue_name}' 不存在且不允许自动创建")
 
-                        # 创建队列
                         self.queue = await asyncio.wait_for(
                             self.channel.declare_queue(
                                 name=self.queue_name,
@@ -261,7 +252,6 @@ class RabbitMQClient:
                         self.actual_queue_name = self.queue_name
                         logger.info(f"已创建队列 '{self.queue_name}'")
                     else:
-                        # 获取已有队列
                         self.queue = await self.channel.get_queue(self.queue_name)
                         self.actual_queue_name = self.queue_name
                         logger.info(f"使用已存在的队列 '{self.queue_name}'")
@@ -272,31 +262,30 @@ class RabbitMQClient:
                         if not bound:
                             raise Exception(f"队列 '{self.queue_name}' 绑定到交换机失败")
                 else:
-                    # 不声明队列时的状态处理
                     self.queue = None
                     self.actual_queue_name = None
-                    logger.debug(f"跳过队列 '{self.queue_name}' 的声明和绑定")
+                    logger.info(f"跳过队列 '{self.queue_name}' 的声明和绑定")
 
-                # 验证连接状态
                 if not self.is_connected:
                     raise Exception("连接验证失败，状态异常")
 
-                # 如果之前在消费，重新开始消费
-                if self._is_consuming and self.message_handler:
+                # 重新开始消费（如果之前在消费）
+                if self.message_handler:
                     await self.start_consuming()
 
-                # 启动连接监控和保活任务
+                # 启动监控和保活任务
                 self._start_monitoring()
                 self._start_keepalive()
 
                 self._update_activity_timestamp()
+                # 清理可能残留的跟踪记录
+                self._tracking_messages.clear()
                 logger.info(f"RabbitMQ客户端初始化成功 (队列: {self.actual_queue_name})")
                 return
 
             except Exception as e:
                 last_exception = e
                 logger.warning(f"资源初始化失败: {str(e)}，重试中...")
-                # 释放当前通道（放回池并重新获取）
                 self.channel = None
                 retries += 1
                 if retries < self.max_reconnection_attempts:
@@ -320,43 +309,54 @@ class RabbitMQClient:
                         await self._recreate_channel()
                         continue
 
+                    current_time = asyncio.get_event_loop().time()
+                    # 清理消息跟踪记录
+                    if self._tracking_messages:
+                        # 1. 清理已确认的消息
+                        acked_ids = [
+                            msg_id for msg_id, info in self._tracking_messages.items()
+                            if info.get('acked', False)
+                        ]
+                        for msg_id in acked_ids:
+                            del self._tracking_messages[msg_id]
+                        if acked_ids:
+                            logger.info(f"清理了 {len(acked_ids)} 条已确认消息记录")
+
                     # 检查消费停滞
                     if self._is_consuming:
-                        current_time = asyncio.get_event_loop().time()
                         if current_time - self._last_message_processed > self.consumption_stall_threshold:
-                            if self._processing_message_ids:
+                            if self._tracking_messages:
                                 logger.warning(
-                                    f"消费停滞，但有 {len(self._processing_message_ids)} 个消息正在处理，暂不重启")
+                                    f"消费停滞，但有 {len(self._tracking_messages)} 个消息正在处理，暂不重启")
                             else:
-                                # 确实无消息处理，再重启
+                                # 无有效消息，重启消费
+                                logger.info("消费停滞且无消息处理，重启消费")
                                 await self.stop_consuming()
                                 await asyncio.sleep(1)
                                 await self.start_consuming()
+
                 except Exception as e:
                     logger.error(f"监控任务出错: {str(e)}")
                     await asyncio.sleep(1)
 
-                await asyncio.sleep(30)
+                await asyncio.sleep(60)
 
         self._monitor_task = asyncio.create_task(monitor())
 
     async def _recreate_channel(self) -> None:
         try:
-            # 无需手动释放，上下文管理器会自动处理
             self.channel = await self._get_channel()
             await self.channel.set_qos(prefetch_count=self.prefetch_count)
 
-            # 重新获取交换机
+            # 重新获取交换机和队列
             self.exchange = await self.channel.get_exchange(self.exchange_name)
-
-            # 重新绑定队列
             if self.queue_name:
                 self.queue = await self.channel.get_queue(self.queue_name)
                 if self.queue and self.exchange:
                     await self._bind_queue(self.channel, self.queue, self.exchange)
 
             # 重新开始消费
-            if self._is_consuming and self.message_handler:
+            if self.message_handler:
                 await self.start_consuming()
 
             logger.info("通道已重建并恢复服务")
@@ -373,10 +373,9 @@ class RabbitMQClient:
         async def keepalive():
             while not self._closed and self.is_connected:
                 current_time = asyncio.get_event_loop().time()
-                # 检查是否超过指定时间无活动
-                if current_time - self._last_activity_timestamp > self.connection_pool.heartbeat * 1.5:
-                    logger.debug(
-                        f"连接 {self.connection_pool.heartbeat*1.5}s 无活动，执行保活检查")
+                if current_time - self._last_activity_timestamp > self.connection_pool.heartbeat * 2:
+                    logger.info(
+                        f"连接 {self.connection_pool.heartbeat*2}s 无活动，执行保活检查")
                     try:
                         if self.channel.is_closed:
                             logger.warning("连接已关闭，触发重连")
@@ -397,7 +396,7 @@ class RabbitMQClient:
                         logger.warning(f"保活检查失败: {str(e)}，触发重连")
                         await self.connect(force_reconnect=True)
 
-                await asyncio.sleep(self.connection_pool.heartbeat / 2)
+                await asyncio.sleep(self.connection_pool.heartbeat)
 
         self._keepalive_task = asyncio.create_task(keepalive())
 
@@ -423,7 +422,7 @@ class RabbitMQClient:
     async def close(self) -> None:
         """关闭客户端并释放资源"""
         self._closed = True
-        self._is_consuming = False
+        self._set_is_consuming(False)
 
         # 取消所有任务
         for task in [self._keepalive_task, self._reconnect_task,
@@ -440,7 +439,7 @@ class RabbitMQClient:
         self.exchange = None
         self.queue = None
         self._consumer_tag = None
-        self._processing_message_ids.clear()
+        self._tracking_messages.clear()
 
         logger.info("RabbitMQ客户端已关闭")
 
@@ -481,24 +480,25 @@ class RabbitMQClient:
         max_retries = 2
         while retry_count < max_retries:
             try:
-                # 从池获取新通道用于发布（避免长时间占用消费通道）
                 async with self.connection_pool.channel_pool.acquire() as publish_channel:
                     exchange = await publish_channel.get_exchange(self.exchange_name)
                     confirmed = await exchange.publish(
                         message,
                         routing_key=routing_key or self.routing_key or '#',
                         mandatory=True,
-                        timeout=15.0
+                        timeout=5
                     )
                     if not confirmed:
                         raise Exception("消息未被服务器确认接收")
 
                 self._update_activity_timestamp()
-                logger.debug(f"消息已发布到交换机 '{self.exchange_name}'")
+                logger.info(f"消息已发布到交换机 '{self.exchange_name}'")
                 return
-            except (ConnectionClosed, ChannelInvalidStateError):
+            except (ConnectionClosed, ChannelInvalidStateError, asyncio.TimeoutError):
+                # 覆盖更多异常类型
                 retry_count += 1
-                logger.warning(f"连接已关闭，尝试重连后重新发布 (重试次数: {retry_count})")
+                logger.warning(f"连接异常，尝试重连后重新发布 (重试次数: {retry_count})")
+                # 主动刷新连接状态
                 await self.connect(force_reconnect=True)
             except Exception as e:
                 retry_count += 1
@@ -508,18 +508,16 @@ class RabbitMQClient:
 
         raise Exception(f"消息发布失败，经过{retry_count}次重试仍未成功")
 
-    # 以下方法（消息消费相关）逻辑与原有保持一致，仅适配连接池
     def set_message_handler(self, handler):
         self.message_handler = handler
 
     async def start_consuming(self) -> ConsumerTag:
         if self._is_consuming:
-            logger.debug("已经在消费中，返回现有consumer_tag")
+            logger.info("已经在消费中，返回现有consumer_tag")
             if self._consumer_tag:
                 return self._consumer_tag
-            # 如果_is_consuming为True但无consumer_tag，重置状态并重新启动
             logger.warning("检测到消费状态异常（无consumer_tag），重置状态后重试")
-            self._is_consuming = False  # 重置状态
+            self._set_is_consuming(False)
 
         if not self.is_connected:
             await self.connect()
@@ -530,25 +528,21 @@ class RabbitMQClient:
         if not self.message_handler:
             raise Exception("未设置消息处理函数")
 
-        self._is_consuming = True
-        logger.info(f"开始消费队列: {self.actual_queue_name}")
-
         try:
-            # 调用队列的consume方法，确保获取到consumer_tag
             self._consumer_tag = await self.queue.consume(
                 self._message_wrapper,
                 no_ack=False  # 手动确认消息
             )
 
-            # 确保consumer_tag有效
             if not self._consumer_tag:
                 raise Exception("未能获取到有效的consumer_tag")
 
+            self._set_is_consuming(True)
             logger.info(
                 f"消费者已启动，队列: {self.actual_queue_name}, tag: {self._consumer_tag}")
             return self._consumer_tag
         except Exception as e:
-            self._is_consuming = False  # 异常时重置状态
+            self._set_is_consuming(False)
             logger.error(f"启动消费失败: {str(e)}", exc_info=True)
             raise
 
@@ -571,22 +565,25 @@ class RabbitMQClient:
         if not self._is_consuming:
             return
 
-        self._is_consuming = False
+        self._set_is_consuming(False)
 
         if self._consumer_tag and self.queue:
             await self._safe_cancel_consumer()
 
         # 等待所有正在处理的消息完成
-        if self._processing_message_ids:
-            logger.info(
-                f"等待 {len(self._processing_message_ids)} 个正在处理的消息完成...")
-            while self._processing_message_ids and not self._closed:
-                await asyncio.sleep(0.1)
+        if self._tracking_messages:
+            logger.info(f"等待 {len(self._tracking_messages)} 个正在处理的消息完成...")
+            wait_start = asyncio.get_event_loop().time()
+            while self._tracking_messages and not self._closed:
+                if asyncio.get_event_loop().time() - wait_start > 30:  # 最多等30秒
+                    logger.warning("等待消息处理超时，强制清理跟踪记录")
+                    self._tracking_messages.clear()
+                    break
+                await asyncio.sleep(1)
 
         # 清理状态
         self._consumer_tag = None
-        self._processing_message_ids.clear()
-
+        self._tracking_messages.clear()
         logger.info(f"已停止消费队列: {self.actual_queue_name}")
 
     async def _parse_message(self, message: AbstractIncomingMessage) -> Union[Dict[str, Any], str]:
@@ -606,8 +603,7 @@ class RabbitMQClient:
 
     async def _message_wrapper(self, message: AbstractIncomingMessage) -> None:
         if not self.message_handler or not self._is_consuming:
-            logger.warning("未设置消息处理器或已停止消费")
-            # await message.ack()
+            logger.warning("未设置消息处理器或已停止消费，拒绝消息，重新放到队列")
             try:
                 await message.reject(requeue=True)
             except Exception as e:
@@ -615,23 +611,31 @@ class RabbitMQClient:
             return
 
         message_id = message.message_id or str(id(message))
-        if message_id in self._processing_message_ids:
+        if message_id in self._tracking_messages:
             logger.warning(f"检测到重复处理的消息ID: {message_id}，直接确认")
             await message.ack()
             return
 
-        self._processing_message_ids.add(message_id)
+        start_time = asyncio.get_event_loop().time()
+        self._tracking_messages[message_id] = {
+            'delivery_tag': message.delivery_tag,
+            'acked': False,
+            'channel_number': self.channel.number if self.channel else None,
+            'start_time': start_time
+        }
 
         try:
-            logger.debug(f"收到队列 {self.actual_queue_name} 的消息: {message_id}")
+            logger.info(f"收到队列 {self.actual_queue_name} 的消息: {message_id}")
+            print(f"收到队列 {self.actual_queue_name} 的消息: {message_id}")
 
             parsed_data = await self._parse_message(message)
             await self.message_handler(MQMsgModel(** parsed_data), message)
 
             await message.ack()
+            self._tracking_messages[message_id]['acked'] = True
             self._update_activity_timestamp()
             self._update_message_processed_timestamp()
-            logger.debug(f"消息 {message_id} 处理完成并确认")
+            logger.info(f"消息 {message_id} 处理完成并确认")
 
         except Exception as e:
             current_headers = message.headers or {}
@@ -645,8 +649,9 @@ class RabbitMQClient:
 
             if retry_count >= MAX_RETRY_COUNT:
                 logger.error(
-                    f"消息 {message_id} 已达到最大重试次数({MAX_RETRY_COUNT}次)，标记为失败")
+                    f"消息 {message_id} 已达到最大重试次数{MAX_RETRY_COUNT}，标记为失败")
                 await message.ack()
+                self._tracking_messages[message_id]['acked'] = True
                 self._update_activity_timestamp()
                 return
 
@@ -661,6 +666,7 @@ class RabbitMQClient:
             )
 
             await message.reject(requeue=False)
+            self._tracking_messages[message_id]['acked'] = True
 
             if self.exchange:
                 await self.exchange.publish(
@@ -672,8 +678,9 @@ class RabbitMQClient:
                 self._update_activity_timestamp()
                 logger.info(f"消息 {message_id} 已重新发布，当前重试次数: {retry_count}")
         finally:
-            if message_id in self._processing_message_ids:
-                self._processing_message_ids.remove(message_id)
+            if message_id in self._tracking_messages:
+                del self._tracking_messages[message_id]
+                logger.info(f"已删除消息跟踪信息: {message_id}")
 
     async def __aenter__(self):
         await self.connect()

{sycommon_python_lib-0.1.31 → sycommon_python_lib-0.1.33}/src/sycommon/rabbitmq/rabbitmq_service.py

@@ -105,7 +105,7 @@ class RabbitMQService:
             )
 
             # 初始化连接池
-            await cls._connection_pool.init_pools()
+            await asyncio.wait_for(cls._connection_pool.init_pools(), timeout=30)
             logger.info("RabbitMQ连接池初始化成功")
 
         except Exception as e:
@@ -142,7 +142,7 @@ class RabbitMQService:
             else:
                 logger.info(f"监听器队列已包含app-name: {processed_queue_name}")
 
-        logger.debug(
+        logger.info(
             f"创建客户端 - 队列: {processed_queue_name}, 发送器: {is_sender}, "
             f"允许创建: {create_if_not_exists}"
         )
@@ -161,7 +161,7 @@ class RabbitMQService:
             auto_parse_json=kwargs.get('auto_parse_json', True),
             create_if_not_exists=create_if_not_exists,
             connection_timeout=kwargs.get('connection_timeout', 10),
-            rpc_timeout=kwargs.get('rpc_timeout', 5),
+            rpc_timeout=kwargs.get('rpc_timeout', 10),
             reconnection_delay=kwargs.get('reconnection_delay', 1),
             max_reconnection_attempts=kwargs.get(
                 'max_reconnection_attempts', 5),
@@ -207,12 +207,12 @@ class RabbitMQService:
                 if client.is_connected:
                     # 如果是监听器但队列未初始化，重新连接
                     if not is_sender and not client.queue:
-                        logger.debug(f"客户端 '{client_name}' 队列未初始化，重新连接")
+                        logger.info(f"客户端 '{client_name}' 队列未初始化，重新连接")
                         client.create_if_not_exists = True
                         await client.connect(force_reconnect=True, declare_queue=True)
                     return client
                 else:
-                    logger.debug(f"客户端 '{client_name}' 连接已关闭，重新连接")
+                    logger.info(f"客户端 '{client_name}' 连接已关闭，重新连接")
                     if not is_sender:
                         client.create_if_not_exists = True
                     await client.connect(declare_queue=not is_sender)
@@ -240,7 +240,7 @@ class RabbitMQService:
 
             # 检查队列是否已初始化
             if initial_queue_name in cls._initialized_queues:
-                logger.debug(f"队列 '{initial_queue_name}' 已初始化，直接创建客户端")
+                logger.info(f"队列 '{initial_queue_name}' 已初始化，直接创建客户端")
                 client = await cls._create_client(
                     initial_queue_name, ** kwargs
                 )
@@ -296,11 +296,11 @@ class RabbitMQService:
                 normalized_name = queue_name
                 if app_name and normalized_name.endswith(f".{app_name}"):
                     normalized_name = normalized_name[:-len(f".{app_name}")]
-                    logger.debug(f"发送器队列名称移除app-name后缀: {normalized_name}")
+                    logger.info(f"发送器队列名称移除app-name后缀: {normalized_name}")
 
                 # 检查是否已初始化
                 if normalized_name in cls._sender_client_names:
-                    logger.debug(f"发送客户端 '{normalized_name}' 已存在，跳过")
+                    logger.info(f"发送客户端 '{normalized_name}' 已存在，跳过")
                     continue
 
                 # 获取或创建客户端
@@ -405,7 +405,7 @@ class RabbitMQService:
             raise ValueError("RabbitMQService尚未初始化，请先调用init方法")
 
         if queue_name in cls._message_handlers:
-            logger.debug(f"监听器 '{queue_name}' 已存在，跳过重复添加")
+            logger.info(f"监听器 '{queue_name}' 已存在，跳过重复添加")
             return
 
         # 创建并初始化客户端
@@ -429,7 +429,7 @@ class RabbitMQService:
     async def start_consumer(cls, client_name: str) -> None:
         """启动指定客户端的消费者"""
         if client_name in cls._consumer_tasks and not cls._consumer_tasks[client_name].done():
-            logger.debug(f"消费者 '{client_name}' 已在运行中，无需重复启动")
+            logger.info(f"消费者 '{client_name}' 已在运行中，无需重复启动")
             return
 
         if client_name not in cls._clients:
@@ -451,7 +451,7 @@ class RabbitMQService:
             if asyncio.get_event_loop().time() - start_time > cls.CONSUMER_START_TIMEOUT:
                 raise TimeoutError(f"等待客户端 '{client_name}' 连接超时")
 
-            logger.debug(f"等待客户端 '{client_name}' 连接就绪...")
+            logger.info(f"等待客户端 '{client_name}' 连接就绪...")
             await asyncio.sleep(1)
 
         # 创建停止事件
@@ -557,7 +557,7 @@ class RabbitMQService:
         if app_name and f"{queue_name}.{app_name}" in cls._sender_client_names:
             return cls._clients.get(f"{queue_name}.{app_name}")
 
-        logger.debug(f"未找到发送器 '{queue_name}'")
+        logger.info(f"未找到发送器 '{queue_name}'")
         return None
 
     @classmethod
@@ -651,7 +651,7 @@ class RabbitMQService:
             raise
 
     @classmethod
-    async def shutdown(cls, timeout: float = 10.0) -> None:
+    async def shutdown(cls, timeout: float = 15.0) -> None:
         """优雅关闭所有资源（新增连接池关闭逻辑）"""
         start_time = asyncio.get_event_loop().time()
         logger.info("开始关闭RabbitMQ服务...")

{sycommon_python_lib-0.1.31 → sycommon_python_lib-0.1.33}/src/sycommon/services.py

@@ -199,6 +199,10 @@ class Services(metaclass=SingletonMeta):
                 if not sender:
                     raise ValueError(f"发送器 '{queue_name}' 不存在")
 
+                if not (sender.is_connected and sender.channel and not sender.channel.is_closed):
+                    logging.info(f"发送器 '{queue_name}' 连接无效，强制重连")
+                    await sender.connect(force_reconnect=True, declare_queue=False)
+
                 await RabbitMQService.send_message(data, queue_name, ** kwargs)
                 logging.info(f"消息发送成功（尝试 {attempt+1}/{max_retries}）")
                 return

{sycommon_python_lib-0.1.31 → sycommon_python_lib-0.1.33}/src/sycommon_python_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.31
+Version: 0.1.33
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown