sycommon-python-lib 0.1.59__py3-none-any.whl → 0.2.0b0__py3-none-any.whl

sycommon/notice/uvicorn_monitor.py

@@ -1,10 +1,9 @@
-from datetime import datetime
 import sys
 import traceback
 import aiohttp
 import asyncio
-import json
 from typing import Optional
+from datetime import datetime
 from urllib.parse import urlparse, parse_qs, urlencode, urlunparse
 from sycommon.config.Config import Config
 from sycommon.logging.kafka_log import SYLogger
@@ -16,19 +15,7 @@ async def send_wechat_markdown_msg(
 ) -> Optional[dict]:
     """
     异步发送企业微信Markdown格式的WebHook消息
-
-    Args:
-        content: Markdown格式的消息内容（支持企业微信支持的markdown语法）
-        webhook: 完整的企业微信WebHook URL（默认值包含key）
-
-    Returns:
-        接口返回的JSON数据（dict），失败返回None
     """
-    # 设置请求头
-    headers = {
-        "Content-Type": "application/json; charset=utf-8"
-    }
-
     # 构造请求体（Markdown格式）
     payload = {
         "msgtype": "markdown",
@@ -38,54 +25,54 @@ async def send_wechat_markdown_msg(
     }
 
     try:
+        # 使用 json 参数自动处理序列化和 Content-Type
         async with aiohttp.ClientSession() as session:
             async with session.post(
                 url=webhook,
-                data=json.dumps(payload, ensure_ascii=False),
-                headers=headers,
+                json=payload,
                 timeout=aiohttp.ClientTimeout(total=10)
             ) as response:
-                status = response.status
-                response_text = await response.text()
-                response_data = json.loads(
-                    response_text) if response_text else {}
+                response_data = await response.json()
 
-                if status == 200 and response_data.get("errcode") == 0:
+                if response.status == 200 and response_data.get("errcode") == 0:
                     SYLogger.info(f"消息发送成功: {response_data}")
                     return response_data
                 else:
-                    SYLogger.info(
-                        f"消息发送失败 - 状态码: {status}, 响应: {response_data}")
+                    SYLogger.warning(
+                        f"消息发送失败 - 状态码: {response.status}, 响应: {response_data}")
                     return None
     except Exception as e:
-        SYLogger.info(f"错误：未知异常 - {str(e)}")
+        SYLogger.error(f"发送企业微信消息异常: {str(e)}")
         return None
 
 
 async def send_webhook(error_info: dict = None, webhook: str = None):
     """
     发送服务启动结果的企业微信通知
-    Args:
-        error_info: 错误信息字典（启动失败时必填），包含：error_type, error_msg, stack_trace, elapsed_time
-        webhook: 完整的企业微信WebHook URL（覆盖默认值）
     """
-    # 获取服务名和环境（兼容配置读取失败）
+    # 获取服务名和环境（增加默认值保护）
     try:
-        service_name = Config().config.get('Name', "未知服务")
-        env = Config().config.get('Nacos', {}).get('namespaceId', '未知环境')
-        webHook = Config().config.get('llm', {}).get('WebHook', '未知环境')
+        config = Config().config
+        service_name = config.get('Name', "未知服务")
+        env = config.get('Nacos', {}).get('namespaceId', '未知环境')
+        # 注意：这里使用了大写开头的 WebHook，请确保配置文件中键名一致
+        webHook = config.get('llm', {}).get('WebHook')
     except Exception as e:
         service_name = "未知服务"
         env = "未知环境"
         webHook = None
-        SYLogger.info(f"读取配置失败: {str(e)}")
+        SYLogger.warning(f"读取配置失败: {str(e)}")
 
     start_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
 
+    # 如果没有错误信息，就不发送失败告警
+    if not error_info:
+        return
+
     # 启动失败的通知内容（包含详细错误信息）
     error_type = error_info.get("error_type", "未知错误")
     error_msg = error_info.get("error_msg", "无错误信息")
-    stack_trace = error_info.get("stack_trace", "无堆栈信息")[:500]  # 限制长度避免超限
+    stack_trace = error_info.get("stack_trace", "无堆栈信息")[:1000]  # 适当增加长度限制
     elapsed_time = error_info.get("elapsed_time", 0)
 
     markdown_content = f"""### {service_name}服务启动失败告警 ⚠️
@@ -103,22 +90,20 @@ async def send_webhook(error_info: dict = None, webhook: str = None):
         )
         SYLogger.info(f"通知发送结果: {result}")
     else:
-        SYLogger.info("未设置企业微信WebHook")
+        SYLogger.info("未设置企业微信WebHook，跳过告警发送")
 
 
 def run(*args, webhook: str = None, **kwargs):
     """
     带企业微信告警的Uvicorn启动监控
-    调用方式1（默认配置）：uvicorn_monitor.run("app:app", **app.state.config)
-    调用方式2（自定义webhook）：uvicorn_monitor.run("app:app", webhook="完整URL", **app.state.config)
-
-    Args:
-        *args: 传递给uvicorn.run的位置参数（如"app:app"）
-        webhook: 完整的企业微信WebHook URL（可选，覆盖默认值）
-        **kwargs: 传递给uvicorn.run的关键字参数（如app.state.config）
     """
     # 判断环境
-    env = Config().config.get('Nacos', {}).get('namespaceId', '未知环境')
+    try:
+        env = Config().config.get('Nacos', {}).get('namespaceId', 'dev')
+    except:
+        env = 'dev'
+
+    # 如果是生产环境，通常不需要这种启动脚本进行告警干扰，或者你需要根据实际情况调整
     if env == "prod":
         import uvicorn
         uvicorn.run(*args, **kwargs)
@@ -128,42 +113,44 @@ def run(*args, webhook: str = None, **kwargs):
     start_time = datetime.now()
 
     if webhook:
-        # 脱敏展示webhook（隐藏key的后半部分）
-        parsed = urlparse(webhook)
-        query = parse_qs(parsed.query)
-        if 'key' in query and query['key'][0]:
-            key = query['key'][0]
-            masked_key = key[:8] + "****" if len(key) > 8 else key + "****"
-            query['key'] = [masked_key]
-            masked_query = urlencode(query, doseq=True)
-            masked_webhook = urlunparse(
-                (parsed.scheme, parsed.netloc, parsed.path, parsed.params, masked_query, parsed.fragment))
-            SYLogger.info(f"自定义企业微信WebHook: {masked_webhook}")
+        # 脱敏展示webhook
+        try:
+            parsed = urlparse(webhook)
+            query = parse_qs(parsed.query)
+            if 'key' in query and query['key'][0]:
+                key = query['key'][0]
+                masked_key = key[:8] + "****" if len(key) > 8 else key + "****"
+                query['key'] = [masked_key]
+                masked_query = urlencode(query, doseq=True)
+                masked_webhook = urlunparse(
+                    (parsed.scheme, parsed.netloc, parsed.path, parsed.params, masked_query, parsed.fragment))
+                SYLogger.info(f"自定义企业微信WebHook: {masked_webhook}")
+        except Exception:
+            SYLogger.info("自定义Webhook格式解析失败，但会尝试使用")
 
     # 初始化错误信息
     error_info = None
 
     try:
         import uvicorn
-        # 执行启动（如果启动成功，此方法会阻塞，不会执行后续except）
+        # 执行启动
         uvicorn.run(*args, **kwargs)
 
     except KeyboardInterrupt:
-        # 处理用户手动中断（不算启动失败）
+        # 处理用户手动中断
         elapsed = (datetime.now() - start_time).total_seconds()
         SYLogger.info(f"\n{'='*50}")
         SYLogger.info(f"ℹ️  应用被用户手动中断")
         SYLogger.info(f"启动耗时: {elapsed:.2f} 秒")
         SYLogger.info(f"{'='*50}\n")
+        # 手动中断不需要错误告警，也不需要 sys.exit(1)
         sys.exit(0)
 
     except Exception as e:
-        # 捕获启动失败异常，收集错误信息
+        # 捕获启动失败异常
         elapsed = (datetime.now() - start_time).total_seconds()
-        # 捕获堆栈信息
         stack_trace = traceback.format_exc()
 
-        # 构造错误信息字典
         error_info = {
             "error_type": type(e).__name__,
             "error_msg": str(e),
@@ -171,30 +158,31 @@ def run(*args, webhook: str = None, **kwargs):
             "elapsed_time": elapsed
         }
 
-        # 打印错误信息
-        SYLogger.info(f"\n{'='*50}")
-        SYLogger.info(f"🚨 应用启动失败！")
-        SYLogger.info(f"失败时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-        SYLogger.info(f"错误类型: {type(e).__name__}")
-        SYLogger.info(f"错误信息: {str(e)}")
-        SYLogger.info(f"\n📝 错误堆栈（关键）:")
-        SYLogger.info(f"-"*50)
+        # 打印详细错误
+        SYLogger.error(f"\n{'='*50}")
+        SYLogger.error(f"🚨 应用启动失败！")
+        SYLogger.error(f"失败时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        SYLogger.error(f"错误类型: {type(e).__name__}")
+        SYLogger.error(f"错误信息: {str(e)}")
+        SYLogger.error(f"\n📝 错误堆栈:")
+        SYLogger.error(f"-"*50)
         traceback.print_exc(file=sys.stdout)
-        SYLogger.info(f"\n⏱️  启动耗时: {elapsed:.2f} 秒")
-        SYLogger.info(f"{'='*50}\n")
+        SYLogger.error(f"\n⏱️  启动耗时: {elapsed:.2f} 秒")
+        SYLogger.error(f"{'='*50}\n")
 
     finally:
-        # 运行异步通知函数，传递自定义的webhook参数
-        try:
-            asyncio.run(send_webhook(
-                error_info=error_info,
-                webhook=webhook
-            ))
-        except Exception as e:
-            SYLogger.info(f"错误：异步通知失败 - {str(e)}")
-        # 启动失败时退出程序
-        sys.exit(1)
-
-
-# 兼容旧调用方式（可选）
-run_uvicorn_with_monitor = run
+        # 创建新的事件循环来发送通知，防止与 Uvicorn 的循环冲突
+        if error_info:
+            try:
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                loop.run_until_complete(send_webhook(
+                    error_info=error_info,
+                    webhook=webhook
+                ))
+                loop.close()
+            except Exception as e:
+                SYLogger.error(f"错误：异步通知发送失败 - {str(e)}")
+
+            # 只有确实有错误时才以状态码 1 退出
+            sys.exit(1)

sycommon/rabbitmq/rabbitmq_client.py

@@ -117,7 +117,7 @@ class RabbitMQClient:
             logger.info(f"队列重建成功: {self.queue_name}")
 
     async def connect(self) -> None:
-        """连接方法（修复恢复消费失效问题）"""
+        """连接方法"""
         if self._closed:
             raise RuntimeError("客户端已关闭，无法重新连接")
 
@@ -125,9 +125,10 @@ class RabbitMQClient:
         await self._connect_condition.acquire()
 
         try:
-            # ===== 阶段 A: 快速检查与等待 =====
+            # ===== 阶段 A: 检查状态与排队 =====
             if await self.is_connected:
-                self._connect_condition.release()
+                if self._connect_condition.locked():
+                    self._connect_condition.release()
                 return
 
             if self._connecting:
@@ -135,19 +136,16 @@ class RabbitMQClient:
                     logger.debug("连接正在进行中，等待现有连接完成...")
                     await asyncio.wait_for(self._connect_condition.wait(), timeout=60.0)
                 except asyncio.TimeoutError:
-                    self._connect_condition.release()
-                    raise RuntimeError("等待连接超时")
+                    logger.warning("等待前序连接超时，当前协程将尝试强制接管并重连...")
 
+                # 唤醒后再次检查
                 if await self.is_connected:
-                    self._connect_condition.release()
+                    if self._connect_condition.locked():
+                        self._connect_condition.release()
                     return
-                else:
-                    self._connect_condition.release()
-                    raise RuntimeError("等待重连后，连接状态依然无效")
 
-            # ===== 阶段 B: 标记开始连接 =====
+            # ===== 阶段 B: 标记开始连接并释放锁 =====
             self._connecting = True
-            # 【关键】释放锁，允许其他协程进入等待逻辑
             self._connect_condition.release()
 
         except Exception as e:
@@ -155,13 +153,18 @@ class RabbitMQClient:
                 self._connect_condition.release()
             raise
 
-        # === 阶段 C: 执行耗时的连接逻辑 (此时已释放锁，不阻塞其他协程) ===
+        # === 阶段 C: 执行耗时的连接逻辑 (无锁状态) ===
+        connection_failed = False
+        was_consuming = False
+
+        # 用于追踪状态，避免在 except 中访问 self._x 导致的竞态
+        old_channel = self._channel
+
         try:
-            # --- 步骤 1: 记录旧状态并清理资源 ---
-            # 必须在清理前记录状态
+            # --- 步骤 1: 记录状态并清理旧资源 ---
             was_consuming = self._consumer_tag is not None
 
-            # 清理连接回调，防止旧的连接关闭触发新的重连
+            # 清理旧连接回调
             if self._channel_conn:
                 try:
                     if self._channel_conn.close_callbacks:
@@ -169,7 +172,14 @@ class RabbitMQClient:
                 except Exception:
                     pass
 
-            # 统一重置资源状态
+            # 显式关闭旧 Channel（这是 Client 自己创建的资源，必须关）
+            if old_channel and not old_channel.is_closed:
+                try:
+                    await old_channel.close()
+                except Exception:
+                    pass
+
+            # 重置引用
             self._channel = None
             self._channel_conn = None
             self._exchange = None
@@ -177,52 +187,68 @@ class RabbitMQClient:
             self._consumer_tag = None
 
             # --- 步骤 2: 获取新连接 ---
+            # 注意：如果这里抛出异常，说明 Pool 层面连接失败
             self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
 
-            # 设置连接关闭回调
+            # --- 步骤 3: 设置回调 ---
+            loop = asyncio.get_running_loop()
+
             def on_conn_closed(conn, exc):
+                if self._closed:
+                    return
                 logger.warning(f"检测到底层连接关闭: {exc}")
-                if not self._closed and not self._connecting:
-                    asyncio.create_task(self._safe_reconnect())
+                asyncio.run_coroutine_threadsafe(self._safe_reconnect(), loop)
 
             if self._channel_conn:
                 self._channel_conn.close_callbacks.add(on_conn_closed)
 
-            # --- 步骤 3: 重建基础资源 (交换机和队列) ---
+            # --- 步骤 4: 重建基础资源 ---
             await self._rebuild_resources()
 
-            # --- 步骤 4: 恢复消费 ---
-            if was_consuming and self._message_handler:
-                logger.info("🔄 检测到重连前处于消费状态，尝试自动恢复消费...")
-                try:
-                    # 直接调用 start_consuming 来恢复，它内部包含了完整的队列检查和绑定逻辑
-                    self._consumer_tag = await self.start_consuming()
-                    logger.info(f"✅ 消费已自动恢复: {self._consumer_tag}")
-                except Exception as e:
-                    logger.error(f"❌ 自动恢复消费失败: {e}")
-                    self._consumer_tag = None
-
-            logger.info("客户端连接初始化完成")
-
         except Exception as e:
+            connection_failed = True
             logger.error(f"客户端连接失败: {str(e)}", exc_info=True)
-            # 异常时彻底清理
+
+            # 清理引用
             if self._channel_conn and self._channel_conn.close_callbacks:
                 self._channel_conn.close_callbacks.clear()
+
             self._channel = None
             self._channel_conn = None
+            self._exchange = None
             self._queue = None
             self._consumer_tag = None
+
+            # 不要手动关闭 Pool 返回的连接，只置空引用。
             raise
 
         finally:
-            # === 阶段 D: 恢复状态并通知 ===
-            await self._connect_condition.acquire()
+            # === 阶段 D: 恢复消费与收尾 (重新加锁) ===
+            # 确保一定会获取锁
             try:
+                await self._connect_condition.acquire()
+            except Exception:
+                pass
+
+            try:
+                # 只有连接完全成功，且之前在消费，才尝试恢复消费
+                if not connection_failed and was_consuming and self._message_handler:
+                    logger.info("🔄 检测到重连前处于消费状态，尝试自动恢复消费...")
+                    try:
+                        self._consumer_tag = await self.start_consuming()
+                        logger.info(f"✅ 消费已自动恢复: {self._consumer_tag}")
+                    except Exception as e:
+                        logger.error(f"❌ 自动恢复消费失败: {e}")
+                        # 如果消费恢复失败，视为连接状态不完整，置空 Exchange
+                        self._consumer_tag = None
+                        self._exchange = None
+            finally:
+                # 最终状态复位
                 self._connecting = False
                 self._connect_condition.notify_all()
-            finally:
-                self._connect_condition.release()
+
+                if self._connect_condition.locked():
+                    self._connect_condition.release()
 
     async def _safe_reconnect(self):
         """安全重连任务（仅用于被动监听连接关闭）"""
@@ -313,6 +339,11 @@ class RabbitMQClient:
             self._consumer_tag = None
 
     async def _handle_publish_failure(self):
+        # 如果当前正在重连，或者已经关闭，直接返回，避免冲突
+        if self._connecting or self._closed:
+            logger.warning("⚠️ 正在重连或已关闭，跳过故障转移触发")
+            return
+
         try:
             logger.info("检测到发布异常，强制连接池切换节点...")
             await self.connection_pool.force_reconnect()
@@ -387,9 +418,12 @@ class RabbitMQClient:
         raise RuntimeError(f"消息发布最终失败: {last_exception}")
 
     async def close(self) -> None:
+        """关闭客户端（整合版：修复连接泄漏与死锁）"""
+        # 1. 先标记关闭，这会阻止 _safe_reconnect 和后续的 connect 逻辑
         self._closed = True
         logger.info("开始关闭RabbitMQ客户端...")
 
+        # 2. 取消可能存在的后台重连任务
         if self._current_reconnect_task and not self._current_reconnect_task.done():
             self._current_reconnect_task.cancel()
             try:
@@ -397,21 +431,43 @@ class RabbitMQClient:
             except asyncio.CancelledError:
                 pass
 
+        # 3. 停止消费
         await self.stop_consuming()
 
-        async with self._connect_lock:
-            if self._conn_close_callback and self._channel_conn:
-                self._channel_conn.close_callbacks.discard(
-                    self._conn_close_callback)
+        # 4. 【关键步骤】处理 _connect_condition 锁
+        # 我们必须获取这个锁，以防止正在进行的 connect() 在我们清理资源时还在操作
+        # 但如果 connect 卡在 wait()，我们需要强制唤醒它
+        try:
+            # 尝试获取锁，设置超时防止死锁（虽然理论上我们即将 notify_all，但为了保险）
+            await asyncio.wait_for(self._connect_condition.acquire(), timeout=2.0)
+        except asyncio.TimeoutError:
+            logger.warning("获取连接锁超时，强制清理资源...")
+
+        try:
+            # 清理回调，防止在关闭过程中触发重连
+            if self._channel_conn:
+                try:
+                    if self._channel_conn.close_callbacks:
+                        self._channel_conn.close_callbacks.clear()
+                except Exception:
+                    pass
 
+            # 置空资源引用
             self._channel = None
             self._channel_conn = None
             self._exchange = None
             self._queue = None
             self._message_handler = None
+            self._conn_close_callback = None
 
-            # 确保唤醒可能正在等待 connect 的任务
+        finally:
+            # 【核心修复】无论是否成功获取锁，都要强制重置状态并唤醒所有等待者
+            # 这会让卡在 connect() 阶段 A 的 wait() 的协程醒来，发现 _closed=True 后抛出异常退出
             self._connecting = False
             self._connect_condition.notify_all()
 
+            # 确保锁被释放（如果持有）
+            if self._connect_condition.locked():
+                self._connect_condition.release()
+
         logger.info("客户端已关闭")

sycommon/rabbitmq/rabbitmq_pool.py

@@ -141,21 +141,43 @@ class RabbitMQConnectionPool:
 
     async def _ensure_main_channel(self) -> RobustChannel:
         """
-        确保主通道有效
-        修复逻辑：
-        1. 如果连接对象不存在或已关闭 -> 重建连接
-        2. 如果连接对象存在但处于重连中 -> 等待其 ready
-        3. 如果通道不存在或已关闭 -> 重建通道
+        确保主通道有效 (Channel 创建失败时的自动重连)
         """
         async with self._lock:
             if self._is_shutdown:
                 raise RuntimeError("客户端已关闭")
 
-            # --- 阶段A：连接恢复逻辑 ---
-            if self._connection is None or self._connection.is_closed:
-                # 情况1：连接对象不存在，或已显式关闭 -> 走清理重连流程
+            # --- 阶段 A: 连接检查与重建 ---
+            # 1. 显式检查连接对象状态
+            connection_is_dead = False
+            if self._connection is None:
+                connection_is_dead = True
+            else:
+                try:
+                    if self._connection.is_closed:
+                        logger.info("🔌 连接已关闭，准备重连...")
+                        connection_is_dead = True
+                    else:
+                        # 2. 核心修复：针对 fail_fast=1 的预防性检查
+                        # 尝试调用 connect() 进行探活。
+                        # 在 fail_fast=1 模式下，如果底层连接已死，connect() 会迅速抛出异常
+                        try:
+                            # 设置较短超时，避免阻塞太久
+                            await asyncio.wait_for(self._connection.connect(timeout=1), timeout=15)
+                            # 如果走到这里，说明连接是好的（或者是它成功恢复了）
+                        except Exception as e:
+                            # 捕获 RuntimeError (Connection closed) 或其他异常
+                            logger.warning(f"⚠️ 连接探活失败 ({e})，判定为死连接，强制重建...")
+                            connection_is_dead = True
+                except Exception as e:
+                    logger.warning(f"⚠️ 检查连接状态异常 ({e})，判定为死连接")
+                    connection_is_dead = True
+
+            # 3. 如果连接判定为死亡，执行彻底的清理和重建
+            if connection_is_dead:
                 await self._cleanup_resources()
 
+                # 重建连接逻辑
                 retry_hosts = self.hosts.copy()
                 random.shuffle(retry_hosts)
                 last_error = None
@@ -170,15 +192,29 @@ class RabbitMQConnectionPool:
                     temp_conn = None
 
                     try:
-                        temp_conn = await self._create_connection_impl(host)
+                        # 使用 connect_robust 创建新连接
+                        conn_url = (
+                            f"amqp://{self.username}:{self.password}@{host}:{self.port}/"
+                            f"{self.virtualhost}?name={self.app_name}&heartbeat={self.heartbeat}"
+                            f"&reconnect_interval={self.reconnect_interval}&fail_fast=1"
+                        )
+                        # 这里必须创建新对象，不能复用旧对象
+                        temp_conn = await asyncio.wait_for(
+                            connect_robust(conn_url),
+                            timeout=self.connection_timeout + 5
+                        )
+
+                        # 新连接建立成功
                         self._connection = temp_conn
                         temp_conn = None
                         self._initialized = True
                         last_error = None
-                        logger.info(f"🔗 [RECONNECT_OK] 切换到节点: {host}")
+                        logger.info(f"✅ [CONNECT_OK] 新连接建立成功: {host}")
                         break
+
                     except Exception as e:
-                        logger.warning(f"⚠️ [RECONNECT_RETRY] 节点 {host} 不可用")
+                        logger.warning(
+                            f"⚠️ [RECONNECT_RETRY] 节点 {host} 连接失败: {e}")
                         if temp_conn is not None:
                             try:
                                 await temp_conn.close()
@@ -190,84 +226,99 @@ class RabbitMQConnectionPool:
                 if last_error:
                     self._connection = None
                     self._initialized = False
-                    logger.error("💥 [RECONNECT_FATAL] 所有节点重试失败")
+                    logger.error("💥 [FATAL] 所有节点连接尝试均失败")
                     raise ConnectionError("所有 RabbitMQ 节点连接失败") from last_error
-            else:
-                # 情况2：连接对象存在，但可能处于“连接丢失，正在重连”的状态
-                # 【关键修复】显式调用 connect() 确保连接真正就绪
-                # 如果连接已经好，这会立即返回；如果正在重连，这会等待完成
-                try:
-                    logger.debug(f"⏳ [WAIT_CONN] 等待连接就绪...")
-                    await self._connection.connect(timeout=5)  # 设置一个短暂超时避免卡死太久
-                    logger.debug(f"✅ [WAIT_CONN_OK] 连接已就绪")
-                except asyncio.TimeoutError:
-                    logger.warning("⚠️ [WAIT_CONN_TIMEOUT] 等待连接就绪超时，强制重连")
-                    await self._cleanup_resources()
-                    raise
-                except Exception as e:
-                    logger.error(f"❌ [WAIT_CONN_FAIL] 连接不可用: {e}")
-                    await self._cleanup_resources()
-                    raise
 
-            # --- 阶段B：通道恢复逻辑 ---
+            # --- 阶段 B: 通道恢复逻辑 (包含关键的自愈逻辑) ---
+            # 此时 self._connection 必须是有效的（新创建的，或者验证通过的）
             if self._channel is None or self._channel.is_closed:
-                try:
-                    # 只有在确保连接有效后，才创建通道
-                    self._channel = await self._connection.channel()
-                    await self._channel.set_qos(prefetch_count=self.prefetch_count)
-                    logger.info(f"✅ [CHANNEL_OK] 主通道已恢复")
-                except Exception as e:
-                    logger.error(f"❌ [CHANNEL_FAIL] 通道创建失败: {e}")
-                    # 如果连通道都创建不了，说明连接状态有问题，回滚清理
-                    await self._cleanup_resources()
-                    raise
+
+                # [修复 3] 使用 while 循环来应对“连接创建瞬间又断开”或“探活漏网”的极端情况
+                max_channel_attempts = 2
+                for attempt in range(max_channel_attempts):
+                    try:
+                        # 尝试创建通道 (这是你报错的地方)
+                        self._channel = await self._connection.channel()
+                        await self._channel.set_qos(prefetch_count=self.prefetch_count)
+                        logger.info(f"✅ [CHANNEL_OK] 主通道已就绪")
+                        break  # 成功则跳出循环
+
+                    except Exception as e:
+                        logger.warning(
+                            f"⚠️ [CHANNEL_RETRY] 第 {attempt + 1} 次尝试创建通道失败: {e}")
+
+                        # 只有第一次尝试失败时才尝试重建连接，避免无限循环
+                        if attempt < max_channel_attempts - 1:
+                            logger.warning("🔄 检测到通道创建异常（可能是死连接），触发连接重建...")
+                            try:
+                                await self._cleanup_resources()
+                                # 这里我们不通过外部循环重建，而是直接强制重建一次
+                                # 简化的重建逻辑：使用当前 host 重试
+                                conn_url = (
+                                    f"amqp://{self.username}:{self.password}@{self._current_host}:{self.port}/"
+                                    f"{self.virtualhost}?name={self.app_name}&heartbeat={self.heartbeat}"
+                                    f"&reconnect_interval={self.reconnect_interval}&fail_fast=1"
+                                )
+                                self._connection = await asyncio.wait_for(
+                                    connect_robust(conn_url),
+                                    timeout=self.connection_timeout + 5
+                                )
+                                self._initialized = True
+                                logger.info("✅ [RECOVER] 连接已重建，将再次尝试创建通道...")
+                                # continue 进入下一次循环，再次尝试创建 channel
+                            except Exception as reconnect_err:
+                                logger.error(
+                                    f"❌ [RECOVER_FAIL] 连接重建失败: {reconnect_err}")
+                                # 重建失败，抛出原始异常
+                                raise e
+                        else:
+                            # 最后一次尝试也失败了，抛出异常
+                            logger.error("❌ [CHANNEL_FAIL] 经过重试后仍然无法创建通道")
+                            raise e
 
             return self._channel
 
     async def init_pools(self):
         """初始化入口"""
-        async with self._lock:
-            if self._is_shutdown:
-                raise RuntimeError("客户端已关闭")
-            if self._initialized:
-                return
+        # 快速检查
+        if self._initialized:
+            return
 
-        # 在 try 之前声明变量，确保 except 块能访问
         conn_created_in_this_try = None
 
         try:
             # 锁外创建连接，减少锁持有时间
             init_host = random.choice(self.hosts)
             conn = await self._create_connection_impl(init_host)
-
-            # 记录本次创建的连接
             conn_created_in_this_try = conn
 
             async with self._lock:
                 if self._is_shutdown:
                     raise RuntimeError("客户端已关闭")
 
+                # 双重检查：防止在锁外等待时，状态已改变或被其他协程初始化
+                if self._initialized:
+                    logger.info("🚀 [INIT_SKIP] 其他协程已完成初始化")
+                    if conn_created_in_this_try:
+                        await conn_created_in_this_try.close()
+                    return
+
                 # 提交新资源
                 self._connection = conn
                 self._channel = await self._connection.channel()
                 await self._channel.set_qos(prefetch_count=self.prefetch_count)
                 self._initialized = True
 
-                # 所有权转移成功，清空临时引用，防止 finally 重复关闭
                 conn_created_in_this_try = None
-
                 logger.info(f"🚀 [INIT_OK] 连接池初始化完成: {init_host}")
 
         except Exception as e:
             logger.error(f"💥 [INIT_FAIL] 初始化异常: {str(e)}")
-
-            # 这里现在可以合法访问 conn_created_in_this_try
             if conn_created_in_this_try is not None:
                 try:
                     await conn_created_in_this_try.close()
                 except Exception:
                     pass
-
             if not self._is_shutdown:
                 await self.close()
             raise
@@ -383,18 +434,28 @@ class RabbitMQConnectionPool:
 
     async def close(self):
         """资源销毁"""
-        async with self._lock:
+        try:
+            # 设置超时，防止因锁异常导致无法关闭
+            await asyncio.wait_for(self._lock.acquire(), timeout=5.0)
+        except asyncio.TimeoutError:
+            logger.error("⚠️ [CLOSE_TIMEOUT] 获取锁超时，强制标记关闭")
+            # 如果拿不到锁，我们只能标记状态，无法安全清理连接
+            self._is_shutdown = True
+            self._initialized = False
+            return
+
+        try:
             if self._is_shutdown:
                 return
             self._is_shutdown = True
             self._initialized = False
 
-        logger.info("🛑 [CLOSE] 开始关闭连接池...")
-
-        # 1. 清理所有资源
-        await self._cleanup_resources()
-
-        logger.info("🏁 [CLOSE] 连接池已关闭")
+            logger.info("🛑 [CLOSE] 开始关闭连接池...")
+            await self._cleanup_resources()
+            logger.info("🏁 [CLOSE] 连接池已关闭")
+        finally:
+            if self._lock.locked():
+                self._lock.release()
 
     async def declare_queue(self, queue_name: str, **kwargs) -> AbstractQueue:
         channel, _ = await self.acquire_channel()

sycommon/synacos/nacos_service_discovery.py

@@ -53,20 +53,23 @@ class NacosServiceDiscovery:
                 instance for instance in all_instances
                 if instance.get('enabled', True)
             ]
+
+            if not all_instances:
+                SYLogger.info(f"nacos:筛选后 {service_name} 无可用实例")
+                return []
+
             SYLogger.info(
                 f"nacos:共发现 {len(all_instances)} 个 {service_name} 服务实例")
 
-            version_to_use = target_version
-
-            if version_to_use:
+            if target_version:
                 same_version_instances = [
                     instance for instance in all_instances
-                    if instance.get('metadata', {}).get('version') == version_to_use
+                    if instance.get('metadata', {}).get('version') == target_version
                 ]
 
                 if same_version_instances:
                     SYLogger.info(
-                        f"nacos:筛选出 {len(same_version_instances)} 个与当前版本({version_to_use})匹配的实例")
+                        f"nacos:筛选出 {len(same_version_instances)} 个与当前版本({target_version})匹配的实例")
                     return same_version_instances
 
                 no_version_instances = [
@@ -76,7 +79,7 @@ class NacosServiceDiscovery:
 
                 if no_version_instances:
                     SYLogger.info(
-                        f"nacos:未找到相同版本({version_to_use})的实例，筛选出 {len(no_version_instances)} 个无版本号的实例")
+                        f"nacos:未找到相同版本({target_version})的实例，筛选出 {len(no_version_instances)} 个无版本号的实例")
                     return no_version_instances
             else:
                 no_version_instances = [

sycommon/tests/test_email.py

@@ -0,0 +1,172 @@
+import os
+import smtplib
+import asyncio
+from typing import List, Optional
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from email.header import Header
+from email.mime.base import MIMEBase
+from email import encoders
+from src.sycommon.config.Config import Config
+
+
+class SYEmail:
+    """盛业邮件发送工具类"""
+
+    @staticmethod
+    def _get_config() -> dict:
+        """获取邮件配置"""
+        return Config().config.get("AIEmailConfig", {})
+
+    @staticmethod
+    async def send(
+        to: List[str],
+        subject: str,
+        content: str,
+        attachments: Optional[List[str]] = None,
+        verbose: bool = False
+    ) -> bool:
+        """
+        异步发送邮件
+
+        :param to: 收件人列表
+        :param subject: 邮件主题
+        :param content: 邮件正文
+        :param attachments: 附件路径列表 (可选)
+        :param verbose: 是否打印详细日志
+        :return: 是否发送成功
+        """
+        try:
+            # 1. 构建邮件对象
+            message = SYEmail._build_message(
+                to, subject, content, attachments
+            )
+
+            # 2. 发送邮件 (网络阻塞型，扔到线程池运行)
+            loop = asyncio.get_running_loop()
+            success = await loop.run_in_executor(
+                None,
+                SYEmail._send_smtp,
+                message,
+                to,
+                verbose
+            )
+            return success
+
+        except Exception as e:
+            print(f"❌ 异步邮件调度异常: {e}")
+            return False
+
+    @staticmethod
+    def _build_message(to: List[str], subject: str, content: str, attachments: Optional[List[str]] = None):
+        """构建邮件对象"""
+        config = SYEmail._get_config()
+
+        message = MIMEMultipart()
+        message['From'] = Header(config.get('sender_name', ''), 'utf-8')
+        message['To'] = Header(", ".join(to), 'utf-8')
+        message['Subject'] = Header(subject, 'utf-8')
+        message.attach(MIMEText(content, 'plain', 'utf-8'))
+
+        if attachments:
+            for file_path in attachments:
+                if os.path.exists(file_path):
+                    try:
+                        with open(file_path, 'rb') as f:
+                            # 使用 octet-stream 通用流类型
+                            attachment = MIMEBase(
+                                'application', 'octet-stream')
+                            attachment.set_payload(f.read())
+                            encoders.encode_base64(attachment)
+
+                            # 解决文件名中文乱码问题
+                            filename = os.path.basename(file_path)
+                            attachment.add_header(
+                                'Content-Disposition',
+                                'attachment',
+                                filename=('utf-8', '', filename)
+                            )
+                            message.attach(attachment)
+                    except Exception as e:
+                        print(f"⚠️ 读取附件失败 [{file_path}]: {e}")
+                else:
+                    print(f"⚠️ 附件文件不存在: {file_path}")
+        return message
+
+    @staticmethod
+    def _send_smtp(message, to_list: List[str], verbose: bool) -> bool:
+        """执行 SMTP 发送 (在线程池中运行)"""
+        config = SYEmail._get_config()
+        smtp_obj = None
+
+        try:
+            if verbose:
+                print(
+                    f"正在连接 {config.get('smtp_server')}:{config.get('smtp_port')} ...")
+
+            # 1. 创建连接
+            smtp_obj = smtplib.SMTP(
+                config.get('smtp_server'),
+                config.get('smtp_port'),
+                timeout=10
+            )
+
+            if verbose:
+                smtp_obj.set_debuglevel(1)
+
+            # 2. 直接进行登录认证
+            if verbose:
+                print(f"正在使用账号 {config.get('smtp_user')} 登录...")
+
+            smtp_obj.login(config.get('smtp_user'), config.get('smtp_pass'))
+
+            if verbose:
+                print("✅ 登录成功")
+
+            # 3. 发送邮件
+            smtp_obj.sendmail(
+                config.get('sender_email'),
+                to_list,
+                message.as_string()
+            )
+
+            if verbose:
+                print("✅ 邮件发送成功！")
+            return True
+
+        except smtplib.SMTPAuthenticationError:
+            print("❌ 认证失败：请检查账号密码。")
+        except smtplib.SMTPException as e:
+            print(f"❌ SMTP 协议错误: {e}")
+        except Exception as e:
+            print(f"❌ 发送邮件时发生未知错误: {e}")
+        finally:
+            if smtp_obj:
+                try:
+                    smtp_obj.quit()
+                except:
+                    pass
+        return False
+
+
+# 使用示例
+async def main():
+    """异步主函数测试"""
+    print("开始发送邮件...")
+
+    success = await SYEmail.send(
+        to=["Osulcode.xiao@syholdings.com"],
+        subject="异步邮件测试",
+        content="这是一封通过异步方式发送的测试邮件。",
+        attachments=["test_file.txt"],
+        verbose=True
+    )
+
+    if success:
+        print("\n🎉 任务完成")
+    else:
+        print("\n⚠️ 任务失败")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

sycommon/tools/syemail.py

@@ -0,0 +1,173 @@
+import os
+import smtplib
+import asyncio
+from typing import List, Optional
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from email.header import Header
+from email.mime.base import MIMEBase
+from email import encoders
+from src.sycommon.config.Config import Config
+from src.sycommon.logging.kafka_log import SYLogger
+
+
+class SYEmail:
+    """盛业邮件发送工具类"""
+
+    @staticmethod
+    def _get_config() -> dict:
+        """获取邮件配置"""
+        return Config().config.get("AIEmailConfig", {})
+
+    @staticmethod
+    async def send(
+        to: List[str],
+        subject: str,
+        content: str,
+        attachments: Optional[List[str]] = None,
+        verbose: bool = False
+    ) -> bool:
+        """
+        异步发送邮件
+
+        :param to: 收件人列表
+        :param subject: 邮件主题
+        :param content: 邮件正文
+        :param attachments: 附件路径列表 (可选)
+        :param verbose: 是否打印详细日志
+        :return: 是否发送成功
+        """
+        try:
+            # 1. 构建邮件对象
+            message = SYEmail._build_message(
+                to, subject, content, attachments
+            )
+
+            # 2. 发送邮件 (网络阻塞型，扔到线程池运行)
+            loop = asyncio.get_running_loop()
+            success = await loop.run_in_executor(
+                None,
+                SYEmail._send_smtp,
+                message,
+                to,
+                verbose
+            )
+            return success
+
+        except Exception as e:
+            SYLogger.error(f"❌ 异步邮件调度异常: {e}")
+            return False
+
+    @staticmethod
+    def _build_message(to: List[str], subject: str, content: str, attachments: Optional[List[str]] = None):
+        """构建邮件对象"""
+        config = SYEmail._get_config()
+
+        message = MIMEMultipart()
+        message['From'] = Header(config.get('sender_name', ''), 'utf-8')
+        message['To'] = Header(", ".join(to), 'utf-8')
+        message['Subject'] = Header(subject, 'utf-8')
+        message.attach(MIMEText(content, 'plain', 'utf-8'))
+
+        if attachments:
+            for file_path in attachments:
+                if os.path.exists(file_path):
+                    try:
+                        with open(file_path, 'rb') as f:
+                            # 使用 octet-stream 通用流类型
+                            attachment = MIMEBase(
+                                'application', 'octet-stream')
+                            attachment.set_payload(f.read())
+                            encoders.encode_base64(attachment)
+
+                            # 解决文件名中文乱码问题
+                            filename = os.path.basename(file_path)
+                            attachment.add_header(
+                                'Content-Disposition',
+                                'attachment',
+                                filename=('utf-8', '', filename)
+                            )
+                            message.attach(attachment)
+                    except Exception as e:
+                        SYLogger.error(f"⚠️ 读取附件失败 [{file_path}]: {e}")
+                else:
+                    SYLogger.error(f"⚠️ 附件文件不存在: {file_path}")
+        return message
+
+    @staticmethod
+    def _send_smtp(message, to_list: List[str], verbose: bool) -> bool:
+        """执行 SMTP 发送 (在线程池中运行)"""
+        config = SYEmail._get_config()
+        smtp_obj = None
+
+        try:
+            if verbose:
+                SYLogger.info(
+                    f"正在连接 {config.get('smtp_server')}:{config.get('smtp_port')} ...")
+
+            # 1. 创建连接
+            smtp_obj = smtplib.SMTP(
+                config.get('smtp_server'),
+                config.get('smtp_port'),
+                timeout=10
+            )
+
+            if verbose:
+                smtp_obj.set_debuglevel(1)
+
+            # 2. 直接进行登录认证
+            if verbose:
+                SYLogger.info(f"正在使用账号 {config.get('smtp_user')} 登录...")
+
+            smtp_obj.login(config.get('smtp_user'), config.get('smtp_pass'))
+
+            if verbose:
+                SYLogger.info("✅ 登录成功")
+
+            # 3. 发送邮件
+            smtp_obj.sendmail(
+                config.get('sender_email'),
+                to_list,
+                message.as_string()
+            )
+
+            if verbose:
+                SYLogger.info("✅ 邮件发送成功！")
+            return True
+
+        except smtplib.SMTPAuthenticationError:
+            SYLogger.error("❌ 认证失败：请检查账号密码。")
+        except smtplib.SMTPException as e:
+            SYLogger.error(f"❌ SMTP 协议错误: {e}")
+        except Exception as e:
+            SYLogger.error(f"❌ 发送邮件时发生未知错误: {e}")
+        finally:
+            if smtp_obj:
+                try:
+                    smtp_obj.quit()
+                except:
+                    pass
+        return False
+
+
+# 使用示例
+# async def main():
+#     """异步主函数测试"""
+#     print("开始发送邮件...")
+
+#     success = await SYEmail.send(
+#         to=["Osulcode.xiao@syholdings.com"],
+#         subject="异步邮件测试",
+#         content="这是一封通过异步方式发送的测试邮件。",
+#         attachments=["test_file.txt"],
+#         verbose=True
+#     )
+
+#     if success:
+#         print("\n🎉 任务完成")
+#     else:
+#         print("\n⚠️ 任务失败")
+
+
+# if __name__ == "__main__":
+#     asyncio.run(main())

{sycommon_python_lib-0.1.59.dist-info → sycommon_python_lib-0.2.0b0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.59
+Version: 0.2.0b0
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -21,6 +21,7 @@ Requires-Dist: nacos-sdk-python<3.0,>=2.0.9
 Requires-Dist: psutil>=7.2.1
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: python-dotenv>=1.2.1
+Requires-Dist: python-multipart>=0.0.21
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: sentry-sdk[fastapi]>=2.49.0
 Requires-Dist: sqlalchemy[asyncio]>=2.0.45

{sycommon_python_lib-0.1.59.dist-info → sycommon_python_lib-0.2.0b0.dist-info}/RECORD

@@ -50,9 +50,9 @@ sycommon/models/mqmsg_model.py,sha256=Zo-LsDMFuF1Vkx9ZmwBC9E7TrCw-7nAQD2TE4v9-6F
 sycommon/models/mqsend_config.py,sha256=NQX9dc8PpuquMG36GCVhJe8omAW1KVXXqr6lSRU6D7I,268
 sycommon/models/sso_user.py,sha256=i1WAN6k5sPcPApQEdtjpWDy7VrzWLpOrOQewGLGoGIw,2702
 sycommon/notice/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sycommon/notice/uvicorn_monitor.py,sha256=VryQYcAtjijJuGDBimbVurgwxlsLaLtkNnABPDY5Tao,7332
-sycommon/rabbitmq/rabbitmq_client.py,sha256=mLdggb_Jv_gDLWXL8nrkKahjsiLNooNgEmPAgWKwHLc,16136
-sycommon/rabbitmq/rabbitmq_pool.py,sha256=EzM3j3MCLgoy6VW8tLONtcZB3VmYQI7CWi_X1kOdqF8,16194
+sycommon/notice/uvicorn_monitor.py,sha256=PrC-OFRE71mL8TcbfdkJRKbjwGAbgsWtyBPWIw1qs08,6753
+sycommon/rabbitmq/rabbitmq_client.py,sha256=qmdBFzoyxd1or_FKwQo255OZa3Li2-ariN6ibrbrcvw,18496
+sycommon/rabbitmq/rabbitmq_pool.py,sha256=uzuYwVMrghLmJb2uaqP3RKOVmjiVDFhgUTGKU7puLOY,19997
 sycommon/rabbitmq/rabbitmq_service.py,sha256=XSHo9HuIJ_lq-vizRh4xJVdZr_2zLqeLhot09qb0euA,2025
 sycommon/rabbitmq/rabbitmq_service_client_manager.py,sha256=IP9TMFeG5LSrwFPEmOy1ce4baPxBUZnWJZR3nN_-XR4,8009
 sycommon/rabbitmq/rabbitmq_service_connection_monitor.py,sha256=uvoMuJDzJ9i63uVRq1NKFV10CvkbGnTMyEoq2rgjQx8,3013
@@ -73,17 +73,19 @@ sycommon/synacos/nacos_client_base.py,sha256=KZgQAg9Imfr_TfM-4LXdtrnTdJ-beu6bcNJ
 sycommon/synacos/nacos_config_manager.py,sha256=Cff-4gpp0aD7sQVi-nEvDO4BWqK9abEDDDJ9qXKFQgs,4399
 sycommon/synacos/nacos_heartbeat_manager.py,sha256=G80_pOn37WdO_HpYUiAfpwMqAxW0ff0Bnw0NEuge9v0,5568
 sycommon/synacos/nacos_service.py,sha256=BezQ1eDIYwBPE567Po_Qh1Ki_z9WmhZy1J1NiTPbdHY,6118
-sycommon/synacos/nacos_service_discovery.py,sha256=O0M4facMa3I9YDFaovrfiTnCMtJWTuewbt9ce4a2-CA,6828
+sycommon/synacos/nacos_service_discovery.py,sha256=rcnMTX8e6VJmu2LwW5lrubt2UQNpu4e8P7GVcOi79Cg,6926
 sycommon/synacos/nacos_service_registration.py,sha256=plg2PmH8CWgmVnPtiIXBxtj-3BpyMdSzKr1wyWRdzh4,10968
 sycommon/synacos/param.py,sha256=KcfSkxnXOa0TGmCjY8hdzU9pzUsA8-4PeyBKWI2-568,1765
+sycommon/tests/test_email.py,sha256=-oPtYVGQzJ3Cv-op3ZNRMeyYOF-UNidGJC35CHRgjGQ,5442
 sycommon/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/tools/docs.py,sha256=OPj2ETheuWjXLyaXtaZPbwmJKfJaYXV5s4XMVAUNrms,1607
 sycommon/tools/env.py,sha256=Ah-tBwG2C0_hwLGFebVQgKdWWXCjTzBuF23gCkLHYy4,2437
 sycommon/tools/merge_headers.py,sha256=u9u8_1ZIuGIminWsw45YJ5qnsx9MB-Fot0VPge7itPw,4941
 sycommon/tools/snowflake.py,sha256=xQlYXwYnI85kSJ1rZ89gMVBhzemP03xrMPVX9vVa3MY,9228
+sycommon/tools/syemail.py,sha256=BDFhgf7WDOQeTcjxJEQdu0dQhnHFPO_p3eI0-Ni3LhQ,5612
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
-sycommon_python_lib-0.1.59.dist-info/METADATA,sha256=sZT5EhFuzDcvhX9Q68MmljOgn5A4irjOxC0RI29X7gw,7331
-sycommon_python_lib-0.1.59.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sycommon_python_lib-0.1.59.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
-sycommon_python_lib-0.1.59.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
-sycommon_python_lib-0.1.59.dist-info/RECORD,,
+sycommon_python_lib-0.2.0b0.dist-info/METADATA,sha256=ZfRx2Yi36wFwxEhsycG6Pi53lzKkNXhjdP82hJjITr8,7372
+sycommon_python_lib-0.2.0b0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+sycommon_python_lib-0.2.0b0.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.2.0b0.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.2.0b0.dist-info/RECORD,,

{sycommon_python_lib-0.1.59.dist-info → sycommon_python_lib-0.2.0b0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any