sycommon-python-lib 0.1.32__py3-none-any.whl → 0.1.34__py3-none-any.whl

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
 
@@ -103,6 +98,8 @@ class RabbitMQClient:
 
         # 消息处理跟踪
         self._tracking_messages: Dict[str, Dict[str, Any]] = {}
+        # 状态保护锁
+        self._state_lock = asyncio.Lock()
 
     @property
     def is_connected(self) -> bool:
@@ -120,19 +117,24 @@ class RabbitMQClient:
         """更新最后消息处理时间戳"""
         self._last_message_processed = asyncio.get_event_loop().time()
 
+    async def _set_is_consuming(self, value: bool) -> None:
+        """安全更新消费状态并记录日志（带锁保护）"""
+        async with self._state_lock:
+            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 +152,6 @@ class RabbitMQClient:
         if not self.queue_name:
             return False
         try:
-            # 使用被动模式检查队列
             await asyncio.wait_for(
                 channel.declare_queue(
                     name=self.queue_name,
@@ -186,19 +187,15 @@ class RabbitMQClient:
         return False
 
     async def connect(self, force_reconnect: bool = False, declare_queue: bool = True) -> None:
-        """
-        从连接池获取资源并初始化（交换机、队列）
-        """
+        """从连接池获取资源并初始化（交换机、队列）"""
         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 +203,13 @@ class RabbitMQClient:
         self._exchange_exists = False
         self._queue_exists = False
         self._queue_bound = False
+        await 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 +217,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 +231,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 +243,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 +255,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 +265,30 @@ class RabbitMQClient:
                         if not bound:
                             raise Exception(f"队列 '{self.queue_name}' 绑定到交换机失败")
                 else:
-                    # 不声明队列时的状态处理
                     self.queue = None
                     self.actual_queue_name = None
                     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,63 +312,75 @@ class RabbitMQClient:
                         await self._recreate_channel()
                         continue
 
-                    # 清理已确认的消息记录
+                    current_time = asyncio.get_event_loop().time()
+                    # 清理消息跟踪记录
                     if self._tracking_messages:
-                        # 收集所有已确认的消息ID
-                        acked_message_ids = [
-                            msg_id for msg_id, msg_info in self._tracking_messages.items()
-                            if msg_info.get('acked', False)
+                        acked_ids = [
+                            msg_id for msg_id, info in self._tracking_messages.items()
+                            if info.get('acked', False)
                         ]
-                        # 移除已确认的消息
-                        for msg_id in acked_message_ids:
+                        for msg_id in acked_ids:
                             del self._tracking_messages[msg_id]
-                        if acked_message_ids:
-                            logger.info(
-                                f"清理了 {len(acked_message_ids)} 条已确认的消息跟踪记录")
+                        if acked_ids:
+                            logger.info(f"清理了 {len(acked_ids)} 条已确认消息记录")
 
-                    # 检查消费停滞
+                    # 检查消费停滞（仅当消费状态为 True 时才处理）
                     if self._is_consuming:
-                        current_time = asyncio.get_event_loop().time()
                         if current_time - self._last_message_processed > self.consumption_stall_threshold:
                             if self._tracking_messages:
-                                logger.info(
+                                logger.warning(
                                     f"消费停滞，但有 {len(self._tracking_messages)} 个消息正在处理，暂不重启")
                             else:
-                                # 确实无消息处理，再重启
-                                await self.stop_consuming()
-                                await asyncio.sleep(1)
-                                await self.start_consuming()
+                                logger.info("消费停滞且无消息处理，重启消费")
+                                # 重启消费时增加异常捕获，确保状态回滚
+                                try:
+                                    await self.stop_consuming()
+                                    await asyncio.sleep(1)
+                                    # 重启前检查处理器是否存在
+                                    if self.message_handler:
+                                        await self.start_consuming()
+                                    else:
+                                        logger.error("消费处理器已丢失，无法重启消费")
+                                except Exception as e:
+                                    logger.error(
+                                        f"重启消费失败: {str(e)}", exc_info=True)
+                                    # 回滚状态：标记为未消费，避免一直拒绝消息
+                                    await self._set_is_consuming(False)
                 except Exception as e:
-                    logger.error(f"监控任务出错: {str(e)}")
-                    await asyncio.sleep(1)
+                    logger.error(f"监控任务出错: {str(e)}", exc_info=True)
 
                 await asyncio.sleep(60)
 
         self._monitor_task = asyncio.create_task(monitor())
 
     async def _recreate_channel(self) -> None:
+        # 重建前先标记为未消费
+        await self._set_is_consuming(False)
         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:
+                    bound = await self._bind_queue(self.channel, self.queue, self.exchange)
+                    if not bound:
+                        raise Exception("队列绑定失败，通道重建不完整")
+
+            # 重新开始消费（确保状态正确恢复）
+            async with self._state_lock:
+                has_handler = self.message_handler is not None
+            if has_handler:
                 await self.start_consuming()
 
             logger.info("通道已重建并恢复服务")
             self._update_activity_timestamp()
         except Exception as e:
-            logger.error(f"通道重建失败: {str(e)}，触发重连")
+            logger.error(f"通道重建失败: {str(e)}，触发重连", exc_info=True)
+            # 重建失败时，确保消费状态为 False
+            await self._set_is_consuming(False)
             await self.connect(force_reconnect=True)
 
     def _start_keepalive(self) -> None:
@@ -387,10 +391,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:
+                if current_time - self._last_activity_timestamp > self.connection_pool.heartbeat * 2:
                     logger.info(
-                        f"连接 {self.connection_pool.heartbeat*1.5}s 无活动，执行保活检查")
+                        f"连接 {self.connection_pool.heartbeat*2}s 无活动，执行保活检查")
                     try:
                         if self.channel.is_closed:
                             logger.warning("连接已关闭，触发重连")
@@ -411,7 +414,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())
 
@@ -437,7 +440,7 @@ class RabbitMQClient:
     async def close(self) -> None:
         """关闭客户端并释放资源"""
         self._closed = True
-        self._is_consuming = False
+        await self._set_is_consuming(False)
 
         # 取消所有任务
         for task in [self._keepalive_task, self._reconnect_task,
@@ -495,14 +498,13 @@ 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=5.0
+                        timeout=5
                     )
                     if not confirmed:
                         raise Exception("消息未被服务器确认接收")
@@ -510,9 +512,11 @@ class RabbitMQClient:
                 self._update_activity_timestamp()
                 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
@@ -522,18 +526,18 @@ class RabbitMQClient:
 
         raise Exception(f"消息发布失败，经过{retry_count}次重试仍未成功")
 
-    # 以下方法（消息消费相关）逻辑与原有保持一致，仅适配连接池
-    def set_message_handler(self, handler):
-        self.message_handler = handler
+    async def set_message_handler(self, handler):
+        async with self._state_lock:
+            self.message_handler = handler
 
     async def start_consuming(self) -> ConsumerTag:
-        if self._is_consuming:
-            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  # 重置状态
+        async with self._state_lock:
+            if self._is_consuming:
+                logger.info("已经在消费中，返回现有consumer_tag")
+                if self._consumer_tag:
+                    return self._consumer_tag
+                logger.warning("检测到消费状态异常（无consumer_tag），重置状态后重试")
+                self._is_consuming = False
 
         if not self.is_connected:
             await self.connect()
@@ -541,28 +545,26 @@ class RabbitMQClient:
         if not self.queue:
             raise Exception("队列未初始化，无法开始消费")
 
-        if not self.message_handler:
-            raise Exception("未设置消息处理函数")
-
-        self._is_consuming = True
-        logger.info(f"开始消费队列: {self.actual_queue_name}")
+        async with self._state_lock:
+            if not self.message_handler:
+                raise Exception("未设置消息处理函数")
 
         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")
 
+            await 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  # 异常时重置状态
+            # 异常时强制设置为未消费
+            await self._set_is_consuming(False)
             logger.error(f"启动消费失败: {str(e)}", exc_info=True)
             raise
 
@@ -585,22 +587,25 @@ class RabbitMQClient:
         if not self._is_consuming:
             return
 
-        self._is_consuming = False
+        await self._set_is_consuming(False)
 
         if self._consumer_tag and self.queue:
             await self._safe_cancel_consumer()
 
         # 等待所有正在处理的消息完成
         if self._tracking_messages:
-            logger.info(
-                f"等待 {len(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._tracking_messages.clear()
-
         logger.info(f"已停止消费队列: {self.actual_queue_name}")
 
     async def _parse_message(self, message: AbstractIncomingMessage) -> Union[Dict[str, Any], str]:
@@ -619,11 +624,19 @@ class RabbitMQClient:
             return message.body.decode('utf-8')
 
     async def _message_wrapper(self, message: AbstractIncomingMessage) -> None:
-        if not self.message_handler or not self._is_consuming:
-            logger.warning("未设置消息处理器或已停止消费")
-            # await message.ack()
+        # 先通过锁获取当前状态，避免并发修改导致的判断错误
+        async with self._state_lock:
+            has_handler = self.message_handler is not None
+            is_consuming = self._is_consuming
+
+        if not has_handler or not is_consuming:
+            logger.warning(
+                f"拒绝消息: message_handler={'存在' if has_handler else '不存在'}, "
+                f"is_consuming={is_consuming}，消息ID: {message.message_id or str(id(message))}"
+            )
             try:
                 await message.reject(requeue=True)
+                await asyncio.sleep(3)
             except Exception as e:
                 logger.error(f"拒绝消息失败: {e}")
             return
@@ -634,21 +647,23 @@ class RabbitMQClient:
             await message.ack()
             return
 
-        # 记录消息跟踪信息
+        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
+            'channel_number': self.channel.number if self.channel else None,
+            'start_time': start_time
         }
 
         try:
             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  # 更新ACK状态
+            self._tracking_messages[message_id]['acked'] = True
             self._update_activity_timestamp()
             self._update_message_processed_timestamp()
             logger.info(f"消息 {message_id} 处理完成并确认")
@@ -665,9 +680,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  # 更新ACK状态
+                self._tracking_messages[message_id]['acked'] = True
                 self._update_activity_timestamp()
                 return
 
@@ -682,7 +697,7 @@ class RabbitMQClient:
             )
 
             await message.reject(requeue=False)
-            self._tracking_messages[message_id]['acked'] = True  # 拒绝也算处理完成
+            self._tracking_messages[message_id]['acked'] = True
 
             if self.exchange:
                 await self.exchange.publish(
@@ -696,6 +711,7 @@ class RabbitMQClient:
         finally:
             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/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:
@@ -443,7 +443,7 @@ class RabbitMQService:
             handler = cls.default_message_handler
 
         # 设置消息处理器
-        client.set_message_handler(handler)
+        await client.set_message_handler(handler)
 
         # 确保客户端已连接
         start_time = asyncio.get_event_loop().time()

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.32.dist-info → sycommon_python_lib-0.1.34.dist-info}/METADATA

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

{sycommon_python_lib-0.1.32.dist-info → sycommon_python_lib-0.1.34.dist-info}/RECORD

@@ -1,6 +1,6 @@
 command/cli.py,sha256=bP2LCLkRvfETIwWkVD70q5xFxMI4D3BpH09Ws1f-ENc,5849
 sycommon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sycommon/services.py,sha256=r631K2RWfQJL7ZP4eiipVEQ2DvRbOcSvf5rqc_ACV9o,9190
+sycommon/services.py,sha256=cPLqMtTHMhCrvdrYJWyVAMrl4G8Wc9w4vFkgYcTz7LQ,9463
 sycommon/config/Config.py,sha256=9yO5b8WfvEDvkyrGrlwrLFasgh_-MjcEvGF20Gz5Xo4,3041
 sycommon/config/DatabaseConfig.py,sha256=ILiUuYT9_xJZE2W-RYuC3JCt_YLKc1sbH13-MHIOPhg,804
 sycommon/config/EmbeddingConfig.py,sha256=gPKwiDYbeu1GpdIZXMmgqM7JqBIzCXi0yYuGRLZooMI,362
@@ -35,9 +35,9 @@ sycommon/models/mqlistener_config.py,sha256=vXp2uMmd0XQ5B9noSRXWHewTy-juQ2y7IsWt
 sycommon/models/mqmsg_model.py,sha256=cxn0M5b0utQK6crMYmL-1waeGYHvK3AlGaRy23clqTE,277
 sycommon/models/mqsend_config.py,sha256=NQX9dc8PpuquMG36GCVhJe8omAW1KVXXqr6lSRU6D7I,268
 sycommon/models/sso_user.py,sha256=i1WAN6k5sPcPApQEdtjpWDy7VrzWLpOrOQewGLGoGIw,2702
-sycommon/rabbitmq/rabbitmq_client.py,sha256=TSeUItuPLbCCkQhsc81Cz3qcGATiTaZhtkiRxdhi72o,28407
+sycommon/rabbitmq/rabbitmq_client.py,sha256=n3c1W31S1NAOkQO2UDpQYgE7Ex8N2hyZrqwPpyxEijU,29733
 sycommon/rabbitmq/rabbitmq_pool.py,sha256=_NMOO4CZy-I_anMqpzfYinz-8373_rg5FM9eqzdjGyU,3598
-sycommon/rabbitmq/rabbitmq_service.py,sha256=1htwoA27uRVU-Vzgezonq95iBE1tGVi4poRw8qX2-ls,30163
+sycommon/rabbitmq/rabbitmq_service.py,sha256=5BrqF_3PwEMbqs8AVhSqFpqzo3GrIftafMX_tCmFv8E,30199
 sycommon/sse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/sse/event.py,sha256=k_rBJy23R7crtzQeetT0Q73D8o5-5p-eESGSs_BPOj0,2797
 sycommon/sse/sse.py,sha256=__CfWEcYxOxQ-HpLor4LTZ5hLWqw9-2X7CngqbVHsfw,10128
@@ -52,8 +52,8 @@ sycommon/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/tools/docs.py,sha256=OPj2ETheuWjXLyaXtaZPbwmJKfJaYXV5s4XMVAUNrms,1607
 sycommon/tools/snowflake.py,sha256=DdEj3T5r5OEvikp3puxqmmmz6BrggxomoSlnsRFb5dM,1174
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
-sycommon_python_lib-0.1.32.dist-info/METADATA,sha256=0a2NR7XmC94hHtEK3o0ipLLcROts-tv4anODwKYUUrY,7037
-sycommon_python_lib-0.1.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sycommon_python_lib-0.1.32.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
-sycommon_python_lib-0.1.32.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
-sycommon_python_lib-0.1.32.dist-info/RECORD,,
+sycommon_python_lib-0.1.34.dist-info/METADATA,sha256=8m47X4r_A5oq9e1CjQaBkt5gdRTblwW7qyln8kQzC0c,7037
+sycommon_python_lib-0.1.34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.34.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.1.34.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.1.34.dist-info/RECORD,,