sycommon-python-lib 0.2.0b6__tar.gz → 0.2.0b7__tar.gz

{sycommon_python_lib-0.2.0b6 → sycommon_python_lib-0.2.0b7}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.0b6
+Version: 0.2.0b7
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: aio-pika>=9.5.8
 Requires-Dist: aiohttp>=3.13.3
 Requires-Dist: aiomysql>=0.3.2
+Requires-Dist: anyio>=4.12.0
 Requires-Dist: decorator>=5.2.1
 Requires-Dist: fastapi>=0.128.0
 Requires-Dist: kafka-python>=2.3.0

{sycommon_python_lib-0.2.0b6 → sycommon_python_lib-0.2.0b7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.0b6"
+version = "0.2.0b7"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -8,6 +8,7 @@ dependencies = [
     "aio-pika>=9.5.8",
     "aiohttp>=3.13.3",
     "aiomysql>=0.3.2",
+    "anyio>=4.12.0",
     "decorator>=5.2.1",
     "fastapi>=0.128.0",
     "kafka-python>=2.3.0",

{sycommon_python_lib-0.2.0b6 → sycommon_python_lib-0.2.0b7}/src/sycommon/llm/embedding.py

@@ -22,7 +22,7 @@ class Embedding(metaclass=SingletonMeta):
         self.reranker_base_url = RerankerConfig.from_config(
             self.default_reranker_model).baseUrl
 
-        # [修复] 缓存配置URL，避免高并发下重复读取配置文件
+        # 缓存配置URL
         self._embedding_url_cache: Dict[str, str] = {
             self.default_embedding_model: self.embeddings_base_url
         }
@@ -30,25 +30,77 @@ class Embedding(metaclass=SingletonMeta):
             self.default_reranker_model: self.reranker_base_url
         }
 
-        # 并发信号量
-        self.semaphore = asyncio.Semaphore(self.max_concurrency)
+        # 不存储 Semaphore 实例，动态获取当前 Loop 的
         self.default_timeout = aiohttp.ClientTimeout(total=None)
-
-        # 核心优化：创建全局可复用的ClientSession（连接池复用）
         self.session = None
 
-        # [修复] 注册退出钩子，确保程序结束时关闭连接池
         atexit.register(self._sync_close_session)
 
+    def _get_loop_limiter(self):
+        """获取当前 Loop 的原生 Semaphore"""
+        loop = asyncio.get_running_loop()
+        storage_key = '_embedding_limiter'
+
+        if not hasattr(loop, storage_key):
+            setattr(loop, storage_key, asyncio.Semaphore(self.max_concurrency))
+        return getattr(loop, storage_key)
+
     async def init_session(self):
-        """初始化全局ClientSession（仅创建一次）"""
-        if self.session is None or self.session.closed:
-            # 配置连接池参数，适配高并发
+        """
+        【终极修复】初始化全局ClientSession
+        """
+        current_loop = asyncio.get_running_loop()
+        need_new = False
+
+        # 情况 1: Session 从未创建
+        if self.session is None:
+            need_new = True
+
+        # 情况 2: Session 已经被显式关闭
+        elif self.session.closed:
+            need_new = True
+
+        else:
+            # 情况 3: 【关键】检查 Session 绑定的 Loop 是否与当前 Loop 一致
+            # 这一步能捕获 "Loop 已关闭但对象还在" 的情况
+            try:
+                sess_loop = self.session._loop
+
+                # 如果 Loop 对象引用不同，说明跨线程了
+                if sess_loop is not current_loop:
+                    SYLogger.warning(
+                        f"⚠️ Session attached to a different loop "
+                        f"(Old: {id(sess_loop)}, New: {id(current_loop)}). Recreating..."
+                    )
+                    need_new = True
+
+                # 如果 Loop 引用相同，但 Loop 自身已关闭
+                # 注意：这里需要检查 sess_loop.is_closed()，而不是 session.closed
+                elif sess_loop.is_closed():
+                    SYLogger.warning(
+                        "⚠️ Session attached to a closed loop. Recreating...")
+                    need_new = True
+
+            except (AttributeError, RuntimeError) as e:
+                # 如果获取 _loop 失败，或者 Loop 已经完全不可用，重建
+                SYLogger.warning(
+                    f"⚠️ Failed to check session loop state ({e}), Recreating...")
+                need_new = True
+
+        if need_new:
+            # 关闭旧 Session（如果存在且未关）
+            if self.session and not self.session.closed:
+                try:
+                    await self.session.close()
+                except Exception:
+                    pass
+
+            # 创建新 Session
             connector = aiohttp.TCPConnector(
-                limit=self.max_concurrency,  # 连接池最大连接数
-                limit_per_host=self.max_concurrency,  # 每个域名的最大连接数
-                ttl_dns_cache=300,  # DNS缓存时间
-                enable_cleanup_closed=True  # 自动清理关闭的连接
+                limit=self.max_concurrency,
+                limit_per_host=self.max_concurrency,
+                ttl_dns_cache=300,
+                enable_cleanup_closed=True
             )
             self.session = aiohttp.ClientSession(
                 connector=connector,
@@ -56,7 +108,7 @@ class Embedding(metaclass=SingletonMeta):
             )
 
     async def close_session(self):
-        """关闭全局Session（程序退出时调用）"""
+        """关闭全局Session"""
         if self.session and not self.session.closed:
             await self.session.close()
 
@@ -65,7 +117,6 @@ class Embedding(metaclass=SingletonMeta):
         try:
             loop = asyncio.get_event_loop()
             if loop.is_running():
-                # [修复] 修正缩进，确保 create_task 的异常能被捕获
                 try:
                     loop.create_task(self.close_session())
                 except Exception:
@@ -76,18 +127,15 @@ class Embedding(metaclass=SingletonMeta):
                 except Exception:
                     pass
         except Exception:
-            # 捕获获取 loop 时的异常
             pass
 
     def _get_embedding_url(self, model: str) -> str:
-        """获取Embedding URL（带缓存）"""
         if model not in self._embedding_url_cache:
             self._embedding_url_cache[model] = EmbeddingConfig.from_config(
                 model).baseUrl
         return self._embedding_url_cache[model]
 
     def _get_reranker_url(self, model: str) -> str:
-        """获取Reranker URL（带缓存）"""
         if model not in self._reranker_url_cache:
             self._reranker_url_cache[model] = RerankerConfig.from_config(
                 model).baseUrl
@@ -102,12 +150,13 @@ class Embedding(metaclass=SingletonMeta):
         **kwargs
     ):
         """embedding请求核心逻辑"""
-        await self.init_session()  # 确保Session已初始化
-        async with self.semaphore:
+        await self.init_session()
+        limiter = self._get_loop_limiter()
+
+        async with limiter:
             request_timeout = timeout or self.default_timeout
             target_model = model or self.default_embedding_model
 
-            # [修复] 使用缓存获取URL
             target_base_url = self._get_embedding_url(target_model)
             url = f"{target_base_url}/v1/embeddings"
 
@@ -118,7 +167,6 @@ class Embedding(metaclass=SingletonMeta):
             }
             request_body.update(kwargs)
 
-            # 复用全局Session
             try:
                 async with self.session.post(
                     url,
@@ -127,7 +175,6 @@ class Embedding(metaclass=SingletonMeta):
                 ) as response:
                     if response.status != 200:
                         error_detail = await response.text()
-                        # [日志] 记录详细的HTTP错误响应
                         SYLogger.error(
                             f"Embedding request HTTP Error. Status: {response.status}, "
                             f"Model: {target_model}, URL: {url}. Detail: {error_detail}"
@@ -135,14 +182,12 @@ class Embedding(metaclass=SingletonMeta):
                         return None
                     return await response.json()
             except (aiohttp.ClientConnectionResetError, asyncio.TimeoutError, aiohttp.ClientError) as e:
-                # [日志] 记录网络错误
                 SYLogger.error(
                     f"Embedding request Network Error. Model: {target_model}, URL: {url}. "
                     f"Error: {e.__class__.__name__} - {str(e)}"
                 )
                 return None
             except Exception as e:
-                # 记录其他未预期的异常
                 SYLogger.error(
                     f"Unexpected error in _get_embeddings_http_core: {str(e)}", exc_info=True)
                 return None
@@ -171,12 +216,13 @@ class Embedding(metaclass=SingletonMeta):
         timeout: aiohttp.ClientTimeout = None, ** kwargs
     ):
         """reranker请求核心逻辑"""
-        await self.init_session()  # 确保Session已初始化
-        async with self.semaphore:
+        await self.init_session()
+        limiter = self._get_loop_limiter()
+
+        async with limiter:
             request_timeout = timeout or self.default_timeout
             target_model = model or self.default_reranker_model
 
-            # [修复] 使用缓存获取URL
             target_base_url = self._get_reranker_url(target_model)
             url = f"{target_base_url}/v1/rerank"
 
@@ -191,7 +237,6 @@ class Embedding(metaclass=SingletonMeta):
             }
             request_body.update(kwargs)
 
-            # 复用全局Session
             try:
                 async with self.session.post(
                     url,
@@ -200,7 +245,6 @@ class Embedding(metaclass=SingletonMeta):
                 ) as response:
                     if response.status != 200:
                         error_detail = await response.text()
-                        # [日志] 记录详细的HTTP错误响应
                         SYLogger.error(
                             f"Reranker request HTTP Error. Status: {response.status}, "
                             f"Model: {target_model}, URL: {url}. Detail: {error_detail}"
@@ -208,14 +252,12 @@ class Embedding(metaclass=SingletonMeta):
                         return None
                     return await response.json()
             except (aiohttp.ClientConnectionResetError, asyncio.TimeoutError, aiohttp.ClientError) as e:
-                # [日志] 记录网络错误
                 SYLogger.error(
                     f"Reranker request Network Error. Model: {target_model}, URL: {url}. "
                     f"Error: {e.__class__.__name__} - {str(e)}"
                 )
                 return None
             except Exception as e:
-                # 记录其他未预期的异常
                 SYLogger.error(
                     f"Unexpected error in _get_reranker_http_core: {str(e)}", exc_info=True)
                 return None
@@ -245,7 +287,6 @@ class Embedding(metaclass=SingletonMeta):
                 return int(config.dimension)
         except Exception:
             pass
-        # 默认兜底 1024
         return 1024
 
     async def get_embeddings(
@@ -254,16 +295,6 @@ class Embedding(metaclass=SingletonMeta):
         model: str = None,
         timeout: Optional[Union[int, float]] = None
     ):
-        """
-        获取语料库的嵌入向量，结果顺序与输入语料库顺序一致
-
-        Args:
-            corpus: 待生成嵌入向量的文本列表
-            model: 可选，指定使用的embedding模型名称，默认使用bge-large-zh-v1.5
-            timeout: 可选，超时时间（秒）：
-                     - 传int/float：表示总超时时间（秒）
-                     - 不传/None：使用默认永不超时配置
-        """
         request_timeout = None
         if timeout is not None:
             if isinstance(timeout, (int, float)):
@@ -278,18 +309,13 @@ class Embedding(metaclass=SingletonMeta):
             f"Requesting embeddings for corpus: {len(corpus)} items (model: {actual_model}, max_concurrency: {self.max_concurrency}, timeout: {timeout or 'None'})")
 
         all_vectors = []
-
-        # [修复] 增加 Chunk 处理逻辑，防止 corpus 过大导致内存溢出或协程过多
-        # 每次最多处理 max_concurrency * 2 个请求，避免一次性创建几十万个协程
         batch_size = self.max_concurrency * 2
 
         for i in range(0, len(corpus), batch_size):
             batch_texts = corpus[i: i + batch_size]
-
             SYLogger.info(
                 f"Requesting embeddings for text: {len(batch_texts)} items (model: {actual_model}, timeout: {timeout or 'None'})")
 
-            # 给每个异步任务传入模型名称和超时配置
             tasks = [self._get_embeddings_http_async(
                 text, model=actual_model, timeout=request_timeout) for text in batch_texts]
             results = await asyncio.gather(*tasks)
@@ -297,15 +323,12 @@ class Embedding(metaclass=SingletonMeta):
             for result in results:
                 if result is None:
                     dim = self._get_dimension(actual_model)
-
                     zero_vector = [0.0] * dim
                     all_vectors.append(zero_vector)
-                    # [日志] 补充日志，明确是补零操作
                     SYLogger.warning(
                         f"Embedding request failed (returned None), appending zero vector ({dim}D) for model {actual_model}")
                     continue
 
-                # 从返回结果中提取向量
                 try:
                     for item in result["data"]:
                         embedding = item["embedding"]
@@ -326,17 +349,6 @@ class Embedding(metaclass=SingletonMeta):
         model: str = None,
         timeout: Optional[Union[int, float]] = None
     ):
-        """
-        对搜索结果进行重排序
-
-        Args:
-            top_results: 待重排序的文本列表
-            query: 排序参考的查询语句
-            model: 可选，指定使用的reranker模型名称，默认使用bge-reranker-large
-            timeout: 可选，超时时间（秒）：
-                     - 传int/float：表示总超时时间（秒）
-                     - 不传/None：使用默认永不超时配置
-        """
         request_timeout = None
         if timeout is not None:
             if isinstance(timeout, (int, float)):
@@ -348,7 +360,6 @@ class Embedding(metaclass=SingletonMeta):
         actual_model = model or self.default_reranker_model
         SYLogger.info(
             f"Requesting reranker for top_results: {top_results} (model: {actual_model}, max_concurrency: {self.max_concurrency}, timeout: {timeout or 'None'})")
-        # 打印请求参数
         SYLogger.info(
             f"Requesting reranker for top_results: {top_results} (model: {actual_model}) (query: {query}) (timeout: {timeout or 'None'})")
         data = await self._get_reranker_http_async(

{sycommon_python_lib-0.2.0b6 → sycommon_python_lib-0.2.0b7}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -1,5 +1,5 @@
 import asyncio
-import functools
+import anyio
 import json
 from typing import Optional, Callable, Coroutine, Dict, Any, Union
 from aio_pika import Channel, Message, DeliveryMode, ExchangeType
@@ -20,6 +20,8 @@ logger = SYLogger
 class RabbitMQClient:
     """
     RabbitMQ 客户端
+
+    【架构升级】全面使用 anyio 替代 asyncio 原语，以支持跨线程/跨 Loop 调用。
     """
 
     def __init__(
@@ -65,37 +67,30 @@ class RabbitMQClient:
             MQMsgModel, AbstractIncomingMessage], Coroutine[Any, Any, None]]] = None
         self._closed = False
 
-        # 并发控制
-        self._consume_lock = asyncio.Lock()
-        self._connect_lock = asyncio.Lock()
-        self._reconnect_lock = asyncio.Lock()
+        # 【修改】使用 anyio 锁，支持跨线程调用
+        self._consume_lock = anyio.Lock()
+        self._connect_lock = anyio.Lock()
+        self._reconnect_lock = anyio.Lock()
 
         # 防止并发重连覆盖
         self._connecting = False
-        self._connect_condition = asyncio.Condition()
+        self._connect_condition = anyio.Condition()  # anyio Condition
 
         self._conn_close_callback: Optional[Callable] = None
-        self._reconnect_semaphore = asyncio.Semaphore(1)
+        self._reconnect_semaphore = anyio.Semaphore(1)
         self._current_reconnect_task: Optional[asyncio.Task] = None
         self._RECONNECT_INTERVAL = 15
 
     @property
     def is_connected(self) -> bool:
-        """
-        同步检查连接状态
-        【修复】改为同步属性，避免异步调用错误和布尔上下文误判
-        """
+        """同步检查连接状态"""
         if self._closed:
             return False
         try:
-            # 检查通道是否有效
             if not self._channel or self._channel.is_closed:
                 return False
-
-            # 检查连接是否有效
             if self._channel_conn and self._channel_conn.is_closed:
                 return False
-
             return (
                 self._exchange is not None
                 and (not self.queue_name or self._queue is not None)
@@ -108,7 +103,6 @@ class RabbitMQClient:
         if not self._channel or self._channel.is_closed:
             raise RuntimeError("无有效通道，无法重建资源")
 
-        # 1. 无条件声明交换机
         exchange_inst = await self._channel.declare_exchange(
             name=self.exchange_name,
             type=self.exchange_type,
@@ -119,7 +113,6 @@ class RabbitMQClient:
         self._exchange = exchange_inst
         logger.info(f"交换机重建成功: {self.exchange_name}")
 
-        # 2. 仅在有队列名且符合条件时声明队列
         if self.queue_name and self.queue_name.endswith(f".{self.app_name}"):
             self._queue = await self._channel.declare_queue(
                 name=self.queue_name,
@@ -131,72 +124,58 @@ class RabbitMQClient:
             logger.info(f"队列重建成功: {self.queue_name}")
 
     async def _ensure_connection_alive(self) -> AbstractRobustConnection:
-        """
-        【新增安全辅助方法】
-        动态获取当前有效的连接对象，避免引用池中已过期的连接。
-        如果连接无效，会抛出异常，交由上层逻辑处理重连。
-        """
         if not self.connection_pool or not self.connection_pool._initialized:
             raise RuntimeError("连接池未初始化")
-
         conn = self.connection_pool._connection
         if not conn or conn.is_closed:
             raise RuntimeError("连接池底层连接已关闭")
         return conn
 
     async def connect(self) -> None:
-        """连接方法（终极防御版：防并发风暴、防死锁、防资源泄漏）"""
+        """连接方法"""
         if self._closed:
             raise RuntimeError("客户端已关闭，无法重新连接")
 
-        # === 阶段 A: 并发控制循环 ===
+        # === 阶段 A: 并发控制循环 (使用 anyio.Condition) ===
         while True:
             await self._connect_condition.acquire()
             try:
-                # 1. 检查是否已连接
                 if self.is_connected:
                     if self._connect_condition.locked():
                         self._connect_condition.release()
                     return
 
-                # 2. 检查是否已有协程在连接
                 if self._connecting:
                     try:
                         logger.debug("连接正在进行中，等待现有连接完成...")
-                        # 等待其他协程完成
-                        await asyncio.wait_for(self._connect_condition.wait(), timeout=60.0)
-                    except asyncio.TimeoutError:
+                        # anyio Condition 支持 wait
+                        with anyio.fail_after(60.0):
+                            await self._connect_condition.wait()
+                    except TimeoutError:
                         logger.warning("⚠️ 等待前序连接超时，重新竞争连接权...")
 
-                    # 【核心修复】
-                    # 无论是因为超时还是被唤醒，都 continue 重新循环
-                    # 这样确保不会出现“所有协程同时醒来”的羊群效应
-                    # 只有抢到锁的那个协程会进入连接逻辑，其他继续 wait
                     if self._connect_condition.locked():
                         self._connect_condition.release()
                     continue
 
-                # 3. 抢到连接权，标记开始
                 self._connecting = True
                 self._connect_condition.release()
-                break  # <--- 跳出循环，去执行连接逻辑
+                break
 
             except Exception as e:
                 if self._connect_condition.locked():
                     self._connect_condition.release()
                 raise
 
-        # === 阶段 C: 执行耗时的连接逻辑 (无锁状态) ===
+        # === 阶段 C: 执行连接逻辑 ===
         connection_failed = False
         was_consuming = False
         is_consumer = self._message_handler is not None
         old_channel = self._channel
 
         try:
-            # --- 步骤 1: 清理旧资源 ---
             was_consuming = self._consumer_tag is not None
 
-            # 清理旧连接的回调
             if self._channel_conn:
                 try:
                     if self._channel_conn.close_callbacks:
@@ -210,14 +189,13 @@ class RabbitMQClient:
                 except Exception:
                     pass
 
-            # 强制重置
             self._channel = None
             self._channel_conn = None
             self._exchange = None
             self._queue = None
             self._consumer_tag = None
 
-            # --- 步骤 2: 获取新通道 ---
+            # 获取通道
             if is_consumer:
                 logger.debug("获取消费者独立通道...")
                 self._channel = await self.connection_pool.acquire_consumer_channel()
@@ -225,36 +203,29 @@ class RabbitMQClient:
                 logger.debug("获取生产者主通道...")
                 self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
 
-            # --- 步骤 3: 统一获取并注册连接回调 ---
             if not self._channel_conn:
-                # 消费者路径需要手动获取连接引用
-                # 直接引用连接池的连接对象，确保引用时效性
                 self._channel_conn = self.connection_pool._connection
 
             loop = asyncio.get_running_loop()
 
             def on_conn_closed(conn, exc):
-                # 【核心修复】不再判断 _connecting，直接委托给 _safe_reconnect
-                # _safe_reconnect 内部有锁，会自动处理并发问题
                 if not self._closed:
                     logger.warning(f"⚠️ 检测到底层连接关闭: {exc}")
+                    # anyio 会自动处理 loop 线程问题，这里依然使用 asyncio 的调用方式即可
                     asyncio.run_coroutine_threadsafe(
                         self._safe_reconnect(), loop)
 
-            # 注册回调前，再次防御性清理
             if self._channel_conn.close_callbacks:
                 self._channel_conn.close_callbacks.clear()
 
             self._channel_conn.close_callbacks.add(on_conn_closed)
 
-            # --- 步骤 4: 重建基础资源 ---
             await self._rebuild_resources()
 
         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()
 
@@ -262,7 +233,6 @@ class RabbitMQClient:
             self._channel_conn = None
             self._exchange = None
             self._queue = None
-            self._consumer_tag = None
             raise
 
         finally:
@@ -270,7 +240,6 @@ class RabbitMQClient:
             try:
                 await self._connect_condition.acquire()
             except Exception:
-                # 如果 acquire 本身失败，确保状态复位，防止死锁
                 self._connecting = False
                 self._connect_condition.notify_all()
                 raise
@@ -289,13 +258,11 @@ class RabbitMQClient:
                                 passive=not self.create_if_not_exists,
                             )
 
-                            # 确保绑定
                             if self._exchange:
                                 await self._queue.bind(exchange=self._exchange, routing_key=self.routing_key)
                                 logger.info(
                                     f"✅ 重连绑定成功: {self.queue_name} -> {self.routing_key}")
                             else:
-                                # 防御性编程
                                 logger.error(
                                     "🔥 Exchange missing, forcing declare...")
                                 temp_ex = await self._channel.declare_exchange(
@@ -316,18 +283,12 @@ class RabbitMQClient:
                             logger.error(f"❌ 自动恢复消费失败: {e}")
                             self._consumer_tag = None
             finally:
-                # 无论恢复逻辑成功与否，必须解锁
                 self._connecting = False
                 self._connect_condition.notify_all()
                 if self._connect_condition.locked():
                     self._connect_condition.release()
 
     async def _safe_reconnect(self):
-        """
-        安全重连入口
-        【核心修复】使用锁防止并发风暴，确保同一时间只有一个重连任务在执行。
-        """
-        # 如果锁已经被占用，说明已经有重连任务在进行中，直接忽略，防止无限递归
         if self._reconnect_lock.locked():
             logger.debug("⏳ 重连任务已在执行中，忽略本次触发，避免并发风暴")
             return
@@ -339,10 +300,8 @@ class RabbitMQClient:
                     return
 
                 logger.warning("🔄 触发底层连接重连...")
-                # 调用实际的 connect 方法
                 await self.connect()
             except Exception as e:
-                # 即使重连失败，也不要在这里递归调用自己，而是依赖外部的定时任务或下一次网络事件
                 logger.error(f"❌ 安全重连执行失败: {str(e)}", exc_info=True)
 
     async def set_message_handler(self, handler: Callable[..., Coroutine]) -> None:
@@ -353,28 +312,21 @@ class RabbitMQClient:
 
     async def _process_message_callback(self, message: AbstractIncomingMessage):
         """
-        消息处理回调
-
-        【架构原理】
-        1. 优先尝试：
-           - 在子线程中构建完全独立的 asyncio 运行环境。
-           - XX.Semaphore 绑定到子线程 Loop，彻底隔离 CPU 压力。
+        消息处理回调 (Anyio 兼容版)
 
-        2. 自动降级【混合模式】：
-           - 如果捕获到 Loop 冲突错误，说明 XX 是顽固的主线程单例。
-           - 此时直接在主线程 await 执行，利用异步 I/O 特性保持心跳响应。
+        既然使用了 anyio，大部分跨 Loop 问题已解决。
+        保留 asyncio.to_thread 用于在子线程中隔离 CPU 密集型或阻塞型任务。
         """
-        msg_obj = None  # 预声明防止 UnboundLocalError
+        msg_obj = None
         trace_id = "unknown"
 
         try:
-            # === 阶段 1: 消息解析与 TraceId 准备 (主线程) ===
             try:
                 body_dict = json.loads(message.body.decode("utf-8"))
                 msg_obj: MQMsgModel = MQMsgModel(**body_dict)
             except Exception as e:
                 logger.error(f"❌ 消息解析失败: {str(e)}")
-                await message.ack()  # 解析失败直接丢弃
+                await message.ack()
                 return
 
             if not msg_obj.traceId:
@@ -384,52 +336,36 @@ class RabbitMQClient:
             trace_id = msg_obj.traceId
             SYLogger.set_trace_id(trace_id)
 
-            # === 阶段 2: 智能执行 ===
             if self._message_handler:
-
-                # --- 模式 A: 终极隔离方案 (默认首选) ---
+                # 定义子线程运行函数
                 def run_in_isolated_thread(current_trace_id):
-                    # 【关键修复】通过参数传递 TraceId，防止闭包捕获导致并发 ID 错乱
                     SYLogger.set_trace_id(current_trace_id)
-
                     try:
                         return asyncio.run(self._message_handler(msg_obj, message))
                     except Exception as e:
-                        # 捕获异常并抛出，避免在子线程中崩溃导致主线程无法感知
                         raise e
 
+                # 【关键】使用 to_thread 在子线程运行，避免阻塞主线程心跳
+                # anyio 兼容 asyncio 的线程池接口
                 try:
-                    # 1. 扔进线程池执行 (主线程等待子线程完成)
                     await asyncio.to_thread(run_in_isolated_thread, trace_id)
-
                 except RuntimeError as e:
-                    # --- 捕获特定错误，进入降级模式 ---
+                    # 保留这个防御性检查，以防万一
                     if "bound to a different event loop" in str(e):
                         logger.warning(
                             f"⚠️ 检测到跨 Loop 冲突 (TraceId: {trace_id})，"
-                            f"自动切换至【混合模式】。业务逻辑将在主线程运行。"
+                            f"自动切换至【混合模式】。"
                         )
-
-                        # --- 模式 B: 混合模式 (降级方案) ---
-                        # 既然 Semaphore 绑定了主 Loop，且必须保证流控 (Ack 在最后)，
-                        # 那么直接在主线程 await 执行是唯一正确的解法。
-                        # 只要业务逻辑是异步 I/O，主线程会在 await 期间处理心跳。
                         await self._message_handler(msg_obj, message)
-
                     else:
-                        # 其他 RuntimeError 直接抛出
                         raise
 
-            # === 阶段 3: 消息确认 ===
-            # 只有代码执行到这里，说明业务已成功处理 (或已处理完异常)
-            # 此时 Ack 才能正确触发 MQ 的流控机制
             await message.ack()
 
         except Exception as e:
             logger.error(
                 f"❌ 消息处理异常 (TraceId: {trace_id}): {str(e)}", exc_info=True)
             try:
-                # 即使异常也 Ack，避免死信循环（根据业务需求也可改为 Nack/Requeue）
                 await message.ack()
             except Exception:
                 pass
@@ -473,7 +409,6 @@ class RabbitMQClient:
             self._consumer_tag = None
 
     async def _handle_publish_failure(self):
-        # 如果当前正在重连，或者已经关闭，直接返回，避免冲突
         if self._connecting or self._closed:
             logger.warning("⚠️ 正在重连或已关闭，跳过故障转移触发")
             return
@@ -481,7 +416,6 @@ class RabbitMQClient:
         try:
             logger.info("检测到发布异常，强制连接池切换节点...")
             await self.connection_pool.force_reconnect()
-            # 连接池切换后，必须刷新客户端资源
             await self.connect()
             logger.info("故障转移完成，资源已刷新")
         except Exception as e:
@@ -552,12 +486,9 @@ class RabbitMQClient:
         raise RuntimeError(f"消息发布最终失败: {last_exception}")
 
     async def close(self) -> None:
-        """关闭客户端（支持独立通道的清理与死锁修复）"""
-        # 1. 先标记关闭
         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:
@@ -565,17 +496,17 @@ class RabbitMQClient:
             except asyncio.CancelledError:
                 pass
 
-        # 3. 停止消费
         await self.stop_consuming()
 
-        # 4. 处理 _connect_condition 锁
+        # 【修改】使用 anyio 处理锁超时和释放
         try:
-            await asyncio.wait_for(self._connect_condition.acquire(), timeout=2.0)
-        except asyncio.TimeoutError:
+            # anyio 没有直接的 wait_for，使用 fail_after
+            with anyio.fail_after(2.0):
+                await self._connect_condition.acquire()
+        except TimeoutError:
             logger.warning("获取连接锁超时，强制清理资源...")
 
         try:
-            # 清理回调
             if self._channel_conn:
                 try:
                     if self._channel_conn.close_callbacks:
@@ -583,22 +514,13 @@ class RabbitMQClient:
                 except Exception:
                     pass
 
-            # 【关键修改】显式关闭持有的通道
-            # 无论是生产者（主通道，但 Client 只是持有者，通常不关 Pool 管理的主通道），
-            # 还是消费者（独立通道，必须显式关闭），这里都需要处理。
-            # 由于我们引入了独立消费者通道，这里必须显式关闭 self._channel
             if self._channel and not self._channel.is_closed:
                 try:
-                    # 注意：如果是主通道，这里关闭可能会影响其他 Producer。
-                    # 但由于我们的架构中，Consumer 用独立通道，这里大概率是 Consumer 关闭。
-                    # 为了安全，可以增加判断：如果 shared_channel 标志为 False 才关？
-                    # 简化策略：统一关闭，因为 Client 被销毁意味着不再需要该通道。
                     await self._channel.close()
                     logger.debug("客户端通道已关闭")
                 except Exception as e:
                     logger.warning(f"关闭客户端通道异常: {e}")
 
-            # 置空资源引用
             self._channel = None
             self._channel_conn = None
             self._exchange = None
@@ -607,7 +529,6 @@ class RabbitMQClient:
             self._conn_close_callback = None
 
         finally:
-            # 强制重置状态并唤醒所有等待者
             self._connecting = False
             self._connect_condition.notify_all()
 

{sycommon_python_lib-0.2.0b6 → sycommon_python_lib-0.2.0b7}/src/sycommon_python_lib.egg-info/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.2.0b6
+Version: 0.2.0b7
 Summary: Add your description here
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: aio-pika>=9.5.8
 Requires-Dist: aiohttp>=3.13.3
 Requires-Dist: aiomysql>=0.3.2
+Requires-Dist: anyio>=4.12.0
 Requires-Dist: decorator>=5.2.1
 Requires-Dist: fastapi>=0.128.0
 Requires-Dist: kafka-python>=2.3.0

{sycommon_python_lib-0.2.0b6 → sycommon_python_lib-0.2.0b7}/src/sycommon_python_lib.egg-info/requires.txt

@@ -1,6 +1,7 @@
 aio-pika>=9.5.8
 aiohttp>=3.13.3
 aiomysql>=0.3.2
+anyio>=4.12.0
 decorator>=5.2.1
 fastapi>=0.128.0
 kafka-python>=2.3.0