sycommon-python-lib 0.1.37__tar.gz → 0.1.39__tar.gz

{sycommon_python_lib-0.1.37 → sycommon_python_lib-0.1.39}/PKG-INFO

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

{sycommon_python_lib-0.1.37 → sycommon_python_lib-0.1.39}/pyproject.toml

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

sycommon_python_lib-0.1.39/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -0,0 +1,300 @@
+from aio_pika import Channel
+from typing import Optional
+import asyncio
+import json
+from typing import Callable, Coroutine, Dict, Any, Union
+from aio_pika import Message, DeliveryMode, ExchangeType
+from aio_pika.abc import (
+    AbstractExchange,
+    AbstractQueue,
+    AbstractIncomingMessage,
+    ConsumerTag,
+)
+from src.sycommon.rabbitmq.rabbitmq_pool import RabbitMQConnectionPool
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.models.mqmsg_model import MQMsgModel
+
+
+# 最大重试次数限制
+MAX_RETRY_COUNT = 3
+
+logger = SYLogger
+
+
+class RabbitMQClient:
+    """
+    RabbitMQ客户端（基于连接池），支持集群、自动重连、消息发布/消费
+    依赖 aio_pika 的内置重连机制，移除手动重连逻辑
+    """
+
+    def __init__(
+        self,
+        connection_pool: RabbitMQConnectionPool,
+        exchange_name: str = "system.topic.exchange",
+        exchange_type: str = "topic",
+        queue_name: Optional[str] = None,
+        routing_key: str = "#",
+        durable: bool = True,
+        auto_delete: bool = False,
+        auto_parse_json: bool = True,
+        create_if_not_exists: bool = True,
+        rpc_timeout: int = 10,
+        prefetch_count: int = 2,
+        consumption_stall_threshold: int = 60,
+    ):
+        self.connection_pool = connection_pool
+        if not self.connection_pool._initialized:
+            raise RuntimeError("连接池未初始化，请先调用 connection_pool.init_pools()")
+
+        # 交换机配置
+        self.exchange_name = exchange_name
+        self.exchange_type = ExchangeType(exchange_type.lower())
+        # 队列配置
+        self.queue_name = queue_name
+        self.routing_key = routing_key
+        self.durable = durable
+        self.auto_delete = auto_delete
+        self.auto_parse_json = auto_parse_json
+        self.create_if_not_exists = create_if_not_exists
+
+        # 运行时配置
+        self.rpc_timeout = rpc_timeout
+        self.prefetch_count = prefetch_count
+        self.consumption_stall_threshold = consumption_stall_threshold
+
+        # 内部状态
+        self._channel: Optional[Channel] = None
+        self._exchange: Optional[AbstractExchange] = None
+        self._queue: Optional[AbstractQueue] = None
+        self._consumer_tag: Optional[ConsumerTag] = None
+        self._message_handler: Optional[Callable] = None
+        self._closed = False
+
+        # 细粒度锁
+        self._consume_lock = asyncio.Lock()
+        self._connect_lock = asyncio.Lock()
+
+    @property
+    async def is_connected(self) -> bool:
+        """异步检查客户端连接状态（属性，不是函数）"""
+        if self._closed:
+            return False
+        try:
+            # 检查通道是否有效
+            if self._channel and not self._channel.is_closed:
+                # 检查交换机和队列（如果需要）
+                if self.create_if_not_exists and self.queue_name:
+                    return bool(self._exchange and self._queue)
+                return True
+            return False
+        except Exception as e:
+            logger.warning(f"检查连接状态失败: {str(e)}")
+            return False
+
+    async def _get_connection_resources(self) -> tuple[Optional[Channel], Optional[AbstractExchange], Optional[AbstractQueue]]:
+        """原子获取连接资源（通道、交换机、队列）"""
+        async with self._connect_lock:
+            return self._channel, self._exchange, self._queue
+
+    async def connect(self) -> None:
+        """建立连接并初始化交换机/队列（使用新的通道获取方式）"""
+        if self._closed:
+            raise RuntimeError("客户端已关闭，无法重新连接")
+
+        async with self._connect_lock:
+            try:
+                # 关键修复：使用连接池的 acquire_channel 方法获取通道
+                self._channel = await self.connection_pool.acquire_channel()
+                # 设置预取计数
+                await self._channel.set_qos(prefetch_count=self.prefetch_count)
+
+                # 声明交换机
+                self._exchange = await self._channel.declare_exchange(
+                    name=self.exchange_name,
+                    type=self.exchange_type,
+                    durable=self.durable,
+                    auto_delete=self.auto_delete,
+                    passive=not self.create_if_not_exists  # 不创建时使用passive模式检查
+                )
+
+                # 声明队列（如果配置了队列名）
+                if self.queue_name:
+                    self._queue = await self._channel.declare_queue(
+                        name=self.queue_name,
+                        durable=self.durable,
+                        auto_delete=self.auto_delete,
+                        passive=not self.create_if_not_exists
+                    )
+                    # 绑定队列到交换机
+                    await self._queue.bind(
+                        exchange=self._exchange,
+                        routing_key=self.routing_key or self.queue_name
+                    )
+                    logger.info(
+                        f"队列 '{self.queue_name}' 已声明并绑定到交换机 '{self.exchange_name}' "
+                        f"(exchange_type: {self.exchange_type}, routing_key: {self.routing_key})"
+                    )
+                else:
+                    logger.info(
+                        f"未配置队列名，仅初始化交换机 '{self.exchange_name}' (exchange_type: {self.exchange_type})")
+
+                logger.info(f"RabbitMQ客户端连接成功（exchange: {self.exchange_name}）")
+            except Exception as e:
+                logger.error(f"客户端连接失败: {str(e)}", exc_info=True)
+                # 清理异常状态
+                if self._channel:
+                    await self.connection_pool.release_channel(self._channel)
+                self._channel = None
+                self._exchange = None
+                self._queue = None
+                raise
+
+    async def set_message_handler(self, handler: Callable[[MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]]):
+        """设置消息处理器（消费消息时使用）"""
+        async with self._consume_lock:
+            self._message_handler = handler
+            logger.info("消息处理器已设置")
+
+    async def start_consuming(self) -> Optional[ConsumerTag]:
+        """启动消费（返回消费者标签）"""
+        if self._closed:
+            logger.warning("客户端已关闭，无法启动消费")
+            return None
+
+        async with self._consume_lock:
+            # 检查前置条件
+            if not self._message_handler:
+                raise RuntimeError("未设置消息处理器，请先调用 set_message_handler")
+
+            # 确保连接已建立
+            if not await self.is_connected:
+                await self.connect()
+
+            # 确保队列已初始化
+            _, _, queue = await self._get_connection_resources()
+            if not queue:
+                raise RuntimeError("队列未初始化，无法启动消费")
+
+            # 定义消费回调
+            async def consume_callback(message: AbstractIncomingMessage):
+                try:
+                    # 解析消息
+                    if self.auto_parse_json:
+                        body = json.loads(message.body.decode('utf-8'))
+                        parsed_data = MQMsgModel(**body)
+                    else:
+                        parsed_data = MQMsgModel(
+                            msg=message.body.decode('utf-8'))
+
+                    # 调用处理器
+                    await self._message_handler(parsed_data, message)
+                    # 手动确认消息
+                    await message.ack()
+                except Exception as e:
+                    logger.error(
+                        f"处理消息失败 (delivery_tag: {message.delivery_tag}): {str(e)}", exc_info=True)
+                    # 消费失败时重新入队（最多重试3次）
+                    if message.redelivered:
+                        logger.warning(
+                            f"消息已重试过，拒绝入队 (delivery_tag: {message.delivery_tag})")
+                        await message.reject(requeue=False)
+                    else:
+                        await message.nack(requeue=True)
+
+            # 启动消费
+            self._consumer_tag = await queue.consume(consume_callback)
+            logger.info(
+                f"开始消费队列 '{queue.name}'，consumer_tag: {self._consumer_tag}")
+            return self._consumer_tag
+
+    async def stop_consuming(self) -> None:
+        """停止消费"""
+        async with self._consume_lock:
+            if self._consumer_tag and not self._closed:
+                _, _, queue = await self._get_connection_resources()
+                if queue and not queue.is_closed:
+                    try:
+                        await queue.cancel(self._consumer_tag)
+                        logger.info(f"停止消费，consumer_tag: {self._consumer_tag}")
+                    except Exception as e:
+                        logger.error(f"停止消费失败: {str(e)}")
+                self._consumer_tag = None
+
+    async def publish(
+        self,
+        message_body: Union[str, Dict[str, Any], MQMsgModel],
+        headers: Optional[Dict[str, Any]] = None,
+        content_type: str = "application/json",
+        delivery_mode: DeliveryMode = DeliveryMode.PERSISTENT
+    ) -> None:
+        """发布消息（修复 is_closed 问题）"""
+        if self._closed:
+            raise RuntimeError("客户端已关闭，无法发布消息")
+
+        # 确保连接已建立
+        if not await self.is_connected:
+            await self.connect()
+
+        # 处理消息体
+        if isinstance(message_body, MQMsgModel):
+            body = json.dumps(message_body.__dict__,
+                              ensure_ascii=False).encode('utf-8')
+        elif isinstance(message_body, dict):
+            body = json.dumps(message_body, ensure_ascii=False).encode('utf-8')
+        else:
+            body = str(message_body).encode('utf-8')
+
+        # 创建消息
+        message = Message(
+            body=body,
+            headers=headers or {},
+            content_type=content_type,
+            delivery_mode=delivery_mode
+        )
+
+        # 发布消息
+        try:
+            async with self._connect_lock:
+                if not self._exchange:
+                    # 交换机未初始化，重新声明
+                    logger.warning("交换机未初始化，重新声明")
+                    self._exchange = await self._channel.declare_exchange(
+                        name=self.exchange_name,
+                        type=self.exchange_type,
+                        durable=self.durable,
+                        auto_delete=self.auto_delete
+                    )
+                await self._exchange.publish(
+                    message=message,
+                    routing_key=self.routing_key or self.queue_name or "#"
+                )
+            logger.debug(f"消息发布成功（routing_key: {self.routing_key}）")
+        except Exception as e:
+            logger.error(f"发布消息失败: {str(e)}", exc_info=True)
+            # 发布失败时清理状态，下次自动重连
+            self._exchange = None
+            raise
+
+    async def close(self) -> None:
+        """关闭客户端（释放通道）"""
+        if self._closed:
+            return
+
+        self._closed = True
+        logger.info("开始关闭RabbitMQ客户端...")
+
+        # 先停止消费
+        await self.stop_consuming()
+
+        # 释放通道到连接池
+        async with self._connect_lock:
+            if self._channel and not self._channel.is_closed:
+                try:
+                    await self.connection_pool.release_channel(self._channel)
+                except Exception as e:
+                    logger.warning(f"释放通道失败: {str(e)}")
+            self._channel = None
+            self._exchange = None
+            self._queue = None
+
+        logger.info("RabbitMQ客户端已关闭")

sycommon_python_lib-0.1.39/src/sycommon/rabbitmq/rabbitmq_pool.py

@@ -0,0 +1,180 @@
+import asyncio
+from typing import List, Set
+from aio_pika import connect_robust, Channel
+from aio_pika.abc import AbstractRobustConnection
+
+from sycommon.logging.kafka_log import SYLogger
+
+logger = SYLogger
+
+
+class RabbitMQConnectionPool:
+    """RabbitMQ连接池管理（简化实现，避免上下文管理器冲突）"""
+
+    def __init__(
+        self,
+        hosts: List[str],
+        port: int,
+        username: str,
+        password: str,
+        virtualhost: str = "/",
+        connection_pool_size: int = 2,
+        channel_pool_size: int = 10,
+        heartbeat: int = 10,
+        app_name: str = ""
+    ):
+        self.hosts = [host.strip() for host in hosts if host.strip()]
+        if not self.hosts:
+            raise ValueError("至少需要提供一个RabbitMQ主机地址")
+        self.port = port
+        self.username = username
+        self.password = password
+        self.virtualhost = virtualhost
+        self.app_name = app_name or "rabbitmq-client"
+        self.heartbeat = heartbeat
+
+        # 连接池配置
+        self.connection_pool_size = connection_pool_size
+        self.channel_pool_size = channel_pool_size
+
+        # 实际存储的连接和通道
+        self._connections: List[AbstractRobustConnection] = []
+        self._free_channels: List[Channel] = []
+        self._used_channels: Set[Channel] = set()
+
+        # 锁用于线程安全
+        self._conn_lock = asyncio.Lock()
+        self._chan_lock = asyncio.Lock()
+
+        # 连接状态
+        self._initialized = False
+
+    async def init_pools(self):
+        """初始化连接池（创建指定数量的连接）"""
+        if self._initialized:
+            logger.warning("连接池已初始化，无需重复调用")
+            return
+
+        try:
+            # 创建核心连接（数量=connection_pool_size）
+            for i in range(self.connection_pool_size):
+                conn = await self._create_connection()
+                self._connections.append(conn)
+                # 为每个连接创建初始通道（数量=channel_pool_size//connection_pool_size）
+                chan_count_per_conn = self.channel_pool_size // self.connection_pool_size
+                for _ in range(chan_count_per_conn):
+                    chan = await conn.channel()
+                    self._free_channels.append(chan)
+
+            self._initialized = True
+            logger.info(
+                f"RabbitMQ连接池初始化成功 - 连接数: {len(self._connections)}, "
+                f"空闲通道数: {len(self._free_channels)}, 集群节点: {self.hosts}"
+            )
+        except Exception as e:
+            logger.error(f"连接池初始化失败: {str(e)}", exc_info=True)
+            # 清理异常状态
+            await self.close()
+            raise
+
+    async def _create_connection(self) -> AbstractRobustConnection:
+        """创建单个RabbitMQ连接（支持集群节点轮询）"""
+        hosts = self.hosts.copy()
+        while hosts:
+            host = hosts.pop(0)
+            try:
+                connection = await connect_robust(
+                    host=host,
+                    port=self.port,
+                    login=self.username,
+                    password=self.password,
+                    virtualhost=self.virtualhost,
+                    heartbeat=self.heartbeat,
+                    client_properties={
+                        "connection_name": f"{self.app_name}@{host}"
+                    },
+                    reconnect_interval=2  # aio_pika 内置重连间隔
+                )
+                logger.info(f"成功连接到 RabbitMQ 节点: {host}:{self.port}")
+                return connection
+            except Exception as e:
+                logger.warning(
+                    f"连接主机 {host}:{self.port} 失败，尝试下一个节点: {str(e)}")
+                if not hosts:
+                    raise  # 所有节点失败时抛出异常
+
+    async def acquire_channel(self) -> Channel:
+        """获取通道（从空闲通道池获取，无则创建新通道）"""
+        if not self._initialized:
+            raise RuntimeError("连接池未初始化，请先调用 init_pools()")
+
+        async with self._chan_lock:
+            # 优先从空闲通道池获取
+            if self._free_channels:
+                channel = self._free_channels.pop()
+                # 检查通道是否有效
+                if not channel.is_closed:
+                    self._used_channels.add(channel)
+                    return channel
+                else:
+                    logger.warning("发现无效通道，已自动清理")
+
+            # 空闲通道不足，创建新通道（不超过最大限制）
+            if len(self._used_channels) < self.channel_pool_size:
+                # 选择一个空闲连接创建通道
+                async with self._conn_lock:
+                    for conn in self._connections:
+                        if not conn.is_closed:
+                            try:
+                                channel = await conn.channel()
+                                self._used_channels.add(channel)
+                                logger.info(
+                                    f"创建新通道，当前通道数: {len(self._used_channels)}/{self.channel_pool_size}")
+                                return channel
+                            except Exception as e:
+                                logger.warning(f"使用连接创建通道失败: {str(e)}")
+                    # 所有连接都无效，尝试重新创建连接
+                    conn = await self._create_connection()
+                    self._connections.append(conn)
+                    channel = await conn.channel()
+                    self._used_channels.add(channel)
+                    return channel
+            else:
+                raise RuntimeError(f"通道池已达最大限制: {self.channel_pool_size}")
+
+    async def release_channel(self, channel: Channel):
+        """释放通道（归还到空闲通道池）"""
+        async with self._chan_lock:
+            if channel in self._used_channels:
+                self._used_channels.remove(channel)
+                # 通道有效则归还，无效则丢弃
+                if not channel.is_closed:
+                    self._free_channels.append(channel)
+                else:
+                    logger.warning("释放无效通道，已自动丢弃")
+
+    async def close(self):
+        """关闭连接池（释放所有连接和通道）"""
+        # 释放所有通道
+        async with self._chan_lock:
+            for channel in self._free_channels + list(self._used_channels):
+                try:
+                    if not channel.is_closed:
+                        await channel.close()
+                except Exception as e:
+                    logger.warning(f"关闭通道失败: {str(e)}")
+            self._free_channels.clear()
+            self._used_channels.clear()
+
+        # 关闭所有连接
+        async with self._conn_lock:
+            for conn in self._connections:
+                try:
+                    if not conn.is_closed:
+                        await conn.close()
+                except Exception as e:
+                    logger.warning(f"关闭连接失败: {str(e)}")
+            self._connections.clear()
+
+        self._initialized = False
+        logger.info("RabbitMQ连接池已完全关闭")

{sycommon_python_lib-0.1.37 → sycommon_python_lib-0.1.39}/src/sycommon/rabbitmq/rabbitmq_service.py

@@ -179,18 +179,21 @@ class RabbitMQService:
             auto_delete=kwargs.get('auto_delete', False),
             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', 10),
-            reconnection_delay=kwargs.get('reconnection_delay', 1),
-            max_reconnection_attempts=kwargs.get(
-                'max_reconnection_attempts', 5),
             prefetch_count=kwargs.get('prefetch_count', 2),
             consumption_stall_threshold=kwargs.get(
                 'consumption_stall_threshold', 60),  # 延长停滞阈值
         )
 
-        # 使用declare_queue控制是否声明队列（发送器不声明，监听器声明）
-        await client.connect(declare_queue=not is_sender)
+        # 新客户端connect无declare_queue参数，自动根据create_if_not_exists处理
+        await client.connect()
+
+        # 监听器客户端连接后延迟1秒，确保消费状态就绪（仅首次启动）
+        if not is_sender and create_if_not_exists:
+            logger.info(
+                f"监听器客户端 '{processed_queue_name}' 连接成功，延迟1秒启动消费（解决启动时序问题）")
+            await asyncio.sleep(1)
+
         return client
 
     @classmethod
@@ -238,13 +241,13 @@ class RabbitMQService:
                         if not queue:
                             logger.info(f"客户端 '{client_name}' 队列未初始化，重新连接")
                             client.create_if_not_exists = True
-                            await client.connect(force_reconnect=True, declare_queue=True)
+                            await client.connect()  # 移除force_reconnect和declare_queue
                     return client
                 else:
                     logger.info(f"客户端 '{client_name}' 连接已关闭，重新连接")
                     if not is_sender:
                         client.create_if_not_exists = True
-                    await client.connect(declare_queue=not is_sender)
+                    await client.connect()  # 移除force_reconnect和declare_queue
                     return client
 
             # 创建新客户端
@@ -260,7 +263,7 @@ class RabbitMQService:
                     app_name=cls._config.get("APP_NAME", ""),
                     **kwargs
                 )
-                await client.connect(declare_queue=False)
+                await client.connect()  # 移除declare_queue=False
                 cls._clients[client_name] = client
                 return client
 
@@ -273,7 +276,7 @@ class RabbitMQService:
                 client = await cls._create_client(
                     initial_queue_name, ** kwargs
                 )
-                await client.connect(declare_queue=True)
+                await client.connect()  # 移除declare_queue=True
                 cls._clients[client_name] = client
                 return client
 
@@ -285,14 +288,14 @@ class RabbitMQService:
             )
 
             client.create_if_not_exists = True
-            await client.connect(declare_queue=True)
+            await client.connect()  # 移除declare_queue=True
 
             # 验证队列是否创建成功（异步获取队列）
             _, _, queue = await client._get_connection_resources()
             if not queue:
                 logger.error(f"队列 '{initial_queue_name}' 创建失败，尝试重新创建")
                 client.create_if_not_exists = True
-                await client.connect(force_reconnect=True, declare_queue=True)
+                await client.connect()
                 _, _, queue = await client._get_connection_resources()
                 if not queue:
                     raise Exception(f"无法创建队列 '{initial_queue_name}'")
@@ -341,7 +344,7 @@ class RabbitMQService:
                 if normalized_name in cls._clients:
                     client = cls._clients[normalized_name]
                     if not await client.is_connected:
-                        await client.connect(declare_queue=False)
+                        await client.connect()  # 移除declare_queue=False
                 else:
                     client = await cls.get_client(
                         client_name=normalized_name,
@@ -508,6 +511,11 @@ class RabbitMQService:
             logger.info("服务关闭中，取消启动消费者")
             return
 
+        # 监听器启动消费前额外延迟1秒，确保consumer_tag完全生成（不删消息）
+        if cls._has_listeners and not client_name.startswith("sender-"):
+            logger.info(f"消费者 '{client_name}' 准备启动，延迟1秒等待消费状态就绪（不删除积压消息）")
+            await asyncio.sleep(1)
+
         # 创建停止事件
         stop_event = asyncio.Event()
         cls._consumer_events[client_name] = stop_event
@@ -522,6 +530,20 @@ class RabbitMQService:
 
                 while attempt < max_attempts and not stop_event.is_set() and not cls._is_shutdown:
                     try:
+                        # 启动消费前再次校验连接和队列状态
+                        if not await client.is_connected:  # 确保这里没有括号
+                            logger.info(f"消费者 '{client_name}' 连接断开，尝试重连")
+                            await client.connect()
+
+                        # 确保队列已就绪
+                        _, _, queue = await client._get_connection_resources()
+                        if not queue:
+                            raise Exception("队列未初始化完成")
+
+                        # 确保消息处理器已设置
+                        if not hasattr(client, '_message_handler') or not client._message_handler:
+                            raise Exception("消息处理器未设置")
+
                         consumer_tag = await client.start_consuming()
                         if consumer_tag:
                             break
@@ -530,7 +552,7 @@ class RabbitMQService:
                         logger.warning(
                             f"启动消费者尝试 {attempt}/{max_attempts} 失败: {str(e)}")
                         if attempt < max_attempts:
-                            await asyncio.sleep(1)
+                            await asyncio.sleep(2)  # 延长重试间隔
 
                 if cls._is_shutdown:
                     logger.info("服务关闭中，消费者启动中止")
@@ -541,7 +563,8 @@ class RabbitMQService:
 
                 # 记录消费者标签
                 cls._consumer_tags[client_name] = consumer_tag
-                logger.info(f"消费者 '{client_name}' 开始消费，tag: {consumer_tag}")
+                logger.info(
+                    f"消费者 '{client_name}' 开始消费，tag: {consumer_tag}（将处理队列中所有积压消息）")
 
                 # 等待停止事件
                 await stop_event.wait()
@@ -621,7 +644,7 @@ class RabbitMQService:
             else:
                 logger.info(f"发送器 '{queue_name}' 连接已断开，尝试重连")
                 try:
-                    await client.connect(declare_queue=False)
+                    await client.connect()  # 移除declare_queue=False
                     if await client.is_connected:
                         return client
                 except Exception as e:
@@ -639,7 +662,7 @@ class RabbitMQService:
                 else:
                     logger.info(f"发送器 '{suffixed_name}' 连接已断开，尝试重连")
                     try:
-                        await client.connect(declare_queue=False)
+                        await client.connect()  # 移除declare_queue=False
                         if await client.is_connected:
                             return client
                     except Exception as e:
@@ -675,7 +698,7 @@ class RabbitMQService:
             while retry_count < max_retry and not cls._is_shutdown:
                 try:
                     # 尝试重连，每次重试间隔1秒
-                    await sender.connect(force_reconnect=True, declare_queue=False)
+                    await sender.connect()  # 移除force_reconnect和declare_queue
                     if await sender.is_connected:
                         logger.info(
                             f"发送器 '{queue_name}' 第 {retry_count + 1} 次重连成功")

{sycommon_python_lib-0.1.37 → sycommon_python_lib-0.1.39}/src/sycommon_python_lib.egg-info/PKG-INFO

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