sycommon-python-lib 0.1.56b7__tar.gz → 0.1.56b9__tar.gz

{sycommon_python_lib-0.1.56b7 → sycommon_python_lib-0.1.56b9}/PKG-INFO

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

{sycommon_python_lib-0.1.56b7 → sycommon_python_lib-0.1.56b9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.1.56-beta7"
+version = "0.1.56-beta9"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"

{sycommon_python_lib-0.1.56b7 → sycommon_python_lib-0.1.56b9}/src/sycommon/config/Config.py

@@ -15,10 +15,8 @@ class Config(metaclass=SingletonMeta):
         with open(config_file, 'r', encoding='utf-8') as f:
             self.config = yaml.safe_load(f)
         self.MaxBytes = self.config.get('MaxBytes', 209715200)
-        self.Timeout = self.config.get('Timeout', 300000)
+        self.Timeout = self.config.get('Timeout', 600000)
         self.MaxRetries = self.config.get('MaxRetries', 3)
-        self.OCR = self.config.get('OCR', None)
-        self.INVOICE_OCR = self.config.get('INVOICE_OCR', None)
         self.llm_configs = []
         self.embedding_configs = []
         self.reranker_configs = []

{sycommon_python_lib-0.1.56b7 → sycommon_python_lib-0.1.56b9}/src/sycommon/middleware/traceid.py

@@ -11,8 +11,7 @@ def setup_trace_id_handler(app):
     @app.middleware("http")
     async def trace_id_and_log_middleware(request: Request, call_next):
         # ========== 1. 请求阶段：获取/生成 TraceID ==========
-        trace_id = request.headers.get(
-            "x-traceId-header") or request.headers.get("x-traceid-header")
+        trace_id = request.headers.get("x-traceid-header")
         if not trace_id:
             trace_id = Snowflake.id
 
@@ -101,15 +100,15 @@ def setup_trace_id_handler(app):
             # 处理 SSE (Server-Sent Events)
             if "text/event-stream" in response_content_type:
                 try:
-                    response.headers["x-traceId-header"] = trace_id
+                    response.headers["x-traceid-header"] = trace_id
                     expose_headers = response.headers.get(
                         "access-control-expose-headers", "")
                     if expose_headers:
-                        if "x-traceId-header" not in expose_headers.lower():
+                        if "x-traceid-header" not in expose_headers.lower():
                             response.headers[
-                                "access-control-expose-headers"] = f"{expose_headers}, x-traceId-header"
+                                "access-control-expose-headers"] = f"{expose_headers}, x-traceid-header"
                     else:
-                        response.headers["access-control-expose-headers"] = "x-traceId-header"
+                        response.headers["access-control-expose-headers"] = "x-traceid-header"
 
                     # SSE 必须移除 Content-Length
                     headers_lower = {
@@ -120,12 +119,12 @@ def setup_trace_id_handler(app):
                     # 流式响应头只读处理
                     new_headers = dict(response.headers) if hasattr(
                         response.headers, 'items') else {}
-                    new_headers["x-traceId-header"] = trace_id
+                    new_headers["x-traceid-header"] = trace_id
                     if "access-control-expose-headers" in new_headers:
-                        if "x-traceId-header" not in new_headers["access-control-expose-headers"].lower():
-                            new_headers["access-control-expose-headers"] += ", x-traceId-header"
+                        if "x-traceid-header" not in new_headers["access-control-expose-headers"].lower():
+                            new_headers["access-control-expose-headers"] += ", x-traceid-header"
                     else:
-                        new_headers["access-control-expose-headers"] = "x-traceId-header"
+                        new_headers["access-control-expose-headers"] = "x-traceid-header"
                     new_headers.pop("content-length", None)
                     response.init_headers(new_headers)
 
@@ -158,18 +157,18 @@ def setup_trace_id_handler(app):
                 delete_keys={'content-length', 'accept', 'content-type'}
             )
 
-            # 强制加入 x-traceId-header
-            merged_headers["x-traceId-header"] = trace_id
+            # 强制加入 x-traceid-header
+            merged_headers["x-traceid-header"] = trace_id
             merged_headers.update(cors_headers)
 
             # 更新暴露头
             expose_headers = merged_headers.get(
                 "access-control-expose-headers", "")
             if expose_headers:
-                if "x-traceId-header" not in expose_headers.lower():
-                    merged_headers["access-control-expose-headers"] = f"{expose_headers}, x-traceId-header"
+                if "x-traceid-header" not in expose_headers.lower():
+                    merged_headers["access-control-expose-headers"] = f"{expose_headers}, x-traceid-header"
             else:
-                merged_headers["access-control-expose-headers"] = "x-traceId-header"
+                merged_headers["access-control-expose-headers"] = "x-traceid-header"
 
             # 应用 Headers
             if hasattr(response.headers, 'clear'):
@@ -212,7 +211,7 @@ def setup_trace_id_handler(app):
                             media_type=response.media_type
                         )
                         response.headers["content-length"] = str(len(new_body))
-                        response.headers["x-traceId-header"] = trace_id
+                        response.headers["x-traceid-header"] = trace_id
                         # 恢复 CORS
                         for k, v in cors_headers.items():
                             response.headers[k] = v
@@ -226,7 +225,7 @@ def setup_trace_id_handler(app):
                         )
                         response.headers["content-length"] = str(
                             len(response_body))
-                        response.headers["x-traceId-header"] = trace_id
+                        response.headers["x-traceid-header"] = trace_id
                         for k, v in cors_headers.items():
                             response.headers[k] = v
                 else:
@@ -239,7 +238,7 @@ def setup_trace_id_handler(app):
                     )
                     response.headers["content-length"] = str(
                         len(response_body))
-                    response.headers["x-traceId-header"] = trace_id
+                    response.headers["x-traceid-header"] = trace_id
                     for k, v in cors_headers.items():
                         response.headers[k] = v
             except StopAsyncIteration:
@@ -255,11 +254,11 @@ def setup_trace_id_handler(app):
 
             # 兜底：确保 Header 必有 TraceId
             try:
-                response.headers["x-traceId-header"] = trace_id
+                response.headers["x-traceid-header"] = trace_id
             except AttributeError:
                 new_headers = dict(response.headers) if hasattr(
                     response.headers, 'items') else {}
-                new_headers["x-traceId-header"] = trace_id
+                new_headers["x-traceid-header"] = trace_id
                 if hasattr(response, "init_headers"):
                     response.init_headers(new_headers)
 

sycommon_python_lib-0.1.56b9/src/sycommon/rabbitmq/rabbitmq_service.py

@@ -0,0 +1,59 @@
+from typing import Type
+import asyncio
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.rabbitmq.rabbitmq_service_connection_monitor import RabbitMQConnectionMonitor
+from sycommon.rabbitmq.rabbitmq_service_consumer_manager import RabbitMQConsumerManager
+from sycommon.rabbitmq.rabbitmq_service_producer_manager import RabbitMQProducerManager
+
+logger = SYLogger
+
+
+class RabbitMQService(RabbitMQConnectionMonitor, RabbitMQProducerManager, RabbitMQConsumerManager):
+    """
+    RabbitMQ服务对外统一接口 - 保持原有API兼容
+    """
+    @classmethod
+    def init(cls, config: dict, has_listeners: bool = False, has_senders: bool = False) -> Type['RabbitMQService']:
+        """初始化RabbitMQ服务（保持原有接口）"""
+        # 初始化配置
+        cls.init_config(config)
+
+        # 设置模式标记
+        cls.set_mode_flags(has_listeners=has_listeners,
+                           has_senders=has_senders)
+
+        # 初始化连接池
+        asyncio.create_task(cls.init_connection_pool())
+
+        # 启动连接监控
+        cls.start_connection_monitor()
+
+        return cls
+
+    @classmethod
+    async def shutdown(cls, timeout: float = 15.0) -> None:
+        """优雅关闭所有资源（保持原有接口）"""
+        async with cls._shutdown_lock:
+            if cls._is_shutdown:
+                logger.info("RabbitMQService已关闭，无需重复操作")
+                return
+
+            cls._is_shutdown = True
+            logger.info("开始关闭RabbitMQ服务...")
+
+            # 1. 停止连接监控任务
+            await cls.stop_connection_monitor(timeout)
+
+            # 2. 停止所有消费者任务
+            await cls.shutdown_consumers(timeout)
+
+            # 3. 关闭所有客户端
+            await cls.shutdown_clients(timeout)
+
+            # 4. 关闭连接池
+            await cls.shutdown_core_resources(timeout)
+
+            # 5. 清理剩余状态
+            cls.clear_senders()
+
+            logger.info("RabbitMQService已完全关闭")

sycommon_python_lib-0.1.56b9/src/sycommon/rabbitmq/rabbitmq_service_client_manager.py

@@ -0,0 +1,212 @@
+from typing import Dict
+import asyncio
+
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.rabbitmq.rabbitmq_client import RabbitMQClient
+from sycommon.rabbitmq.rabbitmq_service_core import RabbitMQCoreService
+
+logger = SYLogger
+
+
+class RabbitMQClientManager(RabbitMQCoreService):
+    """
+    RabbitMQ客户端管理类 - 负责客户端的创建、获取、重连、资源清理
+    """
+    # 客户端存储
+    _clients: Dict[str, RabbitMQClient] = {}
+    _init_locks: Dict[str, asyncio.Lock] = {}
+
+    # 模式标记
+    _has_listeners: bool = False
+    _has_senders: bool = False
+
+    @classmethod
+    def set_mode_flags(cls, has_listeners: bool = False, has_senders: bool = False) -> None:
+        """设置模式标记（是否有监听器/发送器）"""
+        cls._has_listeners = has_listeners
+        cls._has_senders = has_senders
+
+    @classmethod
+    async def _clean_client_resources(cls, client: RabbitMQClient) -> None:
+        """清理客户端无效资源"""
+        try:
+            # 先停止消费
+            if client._consumer_tag:
+                await client.stop_consuming()
+            logger.debug("客户端无效资源清理完成（单通道无需归还）")
+        except Exception as e:
+            logger.warning(f"释放客户端无效资源失败: {str(e)}")
+        finally:
+            # 强制重置客户端状态
+            client._channel = None
+            client._channel_conn = None
+            client._exchange = None
+            client._queue = None
+            client._consumer_tag = None
+
+    @classmethod
+    async def _reconnect_client(cls, client_name: str, client: RabbitMQClient) -> bool:
+        """客户端重连"""
+        if cls._is_shutdown or not (cls._connection_pool and await cls._connection_pool.is_alive):
+            return False
+
+        # 重连冷却
+        await asyncio.sleep(cls.RECONNECT_INTERVAL)
+
+        try:
+            # 清理旧资源
+            await cls._clean_client_resources(client)
+
+            # 执行重连
+            await client.connect()
+
+            # 验证重连结果
+            if await client.is_connected:
+                logger.info(f"客户端 '{client_name}' 重连成功")
+                return True
+            else:
+                logger.warning(f"客户端 '{client_name}' 重连失败：资源未完全初始化")
+                return False
+        except Exception as e:
+            logger.error(f"客户端 '{client_name}' 重连失败: {str(e)}", exc_info=True)
+            return False
+
+    @classmethod
+    async def _create_client(cls, queue_name: str, **kwargs) -> RabbitMQClient:
+        """创建客户端实例"""
+        if cls._is_shutdown:
+            raise RuntimeError("RabbitMQService已关闭，无法创建客户端")
+
+        # 等待连接池就绪
+        await cls.wait_for_pool_ready()
+
+        app_name = kwargs.get('app_name', cls._config.get(
+            "APP_NAME", "")) if cls._config else ""
+        # 纯发送器场景，强制不创建队列
+        is_sender_only = not cls._has_listeners and cls._has_senders
+
+        # 发送器场景下强制禁用队列创建
+        create_if_not_exists = False if is_sender_only else cls._has_listeners
+
+        processed_queue_name = queue_name
+        # 只有非纯发送器场景才处理队列名称拼接
+        if not is_sender_only and create_if_not_exists and processed_queue_name and app_name:
+            if not processed_queue_name.endswith(f".{app_name}"):
+                processed_queue_name = f"{processed_queue_name}.{app_name}"
+                logger.info(f"监听器队列名称自动拼接app-name: {processed_queue_name}")
+            else:
+                logger.info(f"监听器队列已包含app-name: {processed_queue_name}")
+
+        logger.info(
+            f"创建客户端 - 队列: {processed_queue_name if not is_sender_only else 'N/A'}, "
+            f"纯发送器模式: {is_sender_only}, "
+            f"允许创建队列: {create_if_not_exists}"
+        )
+
+        # 创建客户端实例
+        client = RabbitMQClient(
+            connection_pool=cls._connection_pool,
+            exchange_name=cls._config.get(
+                'exchange_name', "system.topic.exchange"),
+            exchange_type=kwargs.get('exchange_type', "topic"),
+            # 纯发送器场景下队列名称设为None
+            queue_name=None if is_sender_only else processed_queue_name,
+            routing_key=kwargs.get(
+                'routing_key',
+                f"{queue_name.split('.')[0]}.#" if queue_name and not is_sender_only else "#"
+            ),
+            durable=kwargs.get('durable', True),
+            auto_delete=kwargs.get('auto_delete', False),
+            auto_parse_json=kwargs.get('auto_parse_json', True),
+            create_if_not_exists=create_if_not_exists,
+            prefetch_count=kwargs.get('prefetch_count', 2),
+        )
+
+        # 连接客户端
+        await client.connect()
+
+        return client
+
+    @classmethod
+    async def get_client(
+        cls,
+        client_name: str = "default", **kwargs
+    ) -> RabbitMQClient:
+        """获取或创建RabbitMQ客户端"""
+        if cls._is_shutdown:
+            raise RuntimeError("RabbitMQService已关闭，无法获取客户端")
+
+        # 等待连接池就绪
+        await cls.wait_for_pool_ready()
+
+        # 确保锁存在
+        if client_name not in cls._init_locks:
+            cls._init_locks[client_name] = asyncio.Lock()
+
+        async with cls._init_locks[client_name]:
+            # 如果客户端已存在且连接有效，直接返回
+            if client_name in cls._clients:
+                client = cls._clients[client_name]
+                is_sender_only = not cls._has_listeners and cls._has_senders
+
+                if await client.is_connected:
+                    # 只有非纯发送器场景才检查队列初始化状态
+                    if not is_sender_only and not client._queue and cls._has_listeners:
+                        logger.info(f"客户端 '{client_name}' 队列未初始化，重新连接")
+                        client.create_if_not_exists = True
+                        await client.connect()
+                    return client
+                else:
+                    logger.info(f"客户端 '{client_name}' 连接已断开，重新连接")
+                    if not is_sender_only:
+                        client.create_if_not_exists = cls._has_listeners
+                    await client.connect()
+                    return client
+
+            # 创建新客户端
+            initial_queue_name = kwargs.pop('queue_name', '')
+            is_sender_only = not cls._has_listeners and cls._has_senders
+
+            # 发送器特殊处理
+            if is_sender_only:
+                kwargs['create_if_not_exists'] = False
+                client = await cls._create_client(
+                    "",  # 空队列名
+                    app_name=cls._config.get("APP_NAME", ""),
+                    **kwargs
+                )
+                cls._clients[client_name] = client
+                return client
+
+            # 监听器逻辑
+            kwargs['create_if_not_exists'] = True
+            client = await cls._create_client(
+                initial_queue_name,
+                app_name=cls._config.get("APP_NAME", ""),
+                **kwargs
+            )
+
+            # 验证队列创建
+            if not is_sender_only and not client._queue:
+                logger.error(f"队列 '{initial_queue_name}' 创建失败，尝试重新创建")
+                client.create_if_not_exists = True
+                await client.connect()
+                if not client._queue:
+                    raise Exception(f"无法创建队列 '{initial_queue_name}'")
+
+            cls._clients[client_name] = client
+            return client
+
+    @classmethod
+    async def shutdown_clients(cls, timeout: float = 15.0) -> None:
+        """关闭所有客户端"""
+        # 关闭所有客户端
+        for client in cls._clients.values():
+            try:
+                await client.close()
+            except Exception as e:
+                logger.error(f"关闭客户端失败: {str(e)}")
+
+        # 清理客户端状态
+        cls._clients.clear()
+        cls._init_locks.clear()

sycommon_python_lib-0.1.56b9/src/sycommon/rabbitmq/rabbitmq_service_connection_monitor.py

@@ -0,0 +1,73 @@
+import asyncio
+from typing import Optional
+from sycommon.rabbitmq.rabbitmq_service_client_manager import RabbitMQClientManager
+from sycommon.logging.kafka_log import SYLogger
+
+logger = SYLogger
+
+
+class RabbitMQConnectionMonitor(RabbitMQClientManager):
+    """
+    RabbitMQ连接监控类 - 负责连接状态监控、自动重连
+    """
+    _connection_monitor_task: Optional[asyncio.Task] = None
+
+    @classmethod
+    async def _monitor_connections(cls):
+        """连接监控任务：定期检查所有客户端连接状态"""
+        logger.info("RabbitMQ连接监控任务启动")
+        while not cls._is_shutdown:
+            try:
+                await asyncio.sleep(cls.RECONNECT_INTERVAL)
+
+                # 跳过未初始化的连接池
+                if not cls._connection_pool or not cls._connection_pool._initialized:
+                    continue
+
+                # 检查连接池本身状态
+                pool_alive = await cls._connection_pool.is_alive
+                if not pool_alive:
+                    logger.error("RabbitMQ连接池已断开，等待原生自动重连")
+                    continue
+
+                # 检查所有客户端连接
+                for client_name, client in list(cls._clients.items()):
+                    try:
+                        client_connected = await client.is_connected
+                        if not client_connected:
+                            logger.warning(
+                                f"客户端 '{client_name}' 连接异常，触发重连")
+                            asyncio.create_task(
+                                cls._reconnect_client(client_name, client))
+                    except Exception as e:
+                        logger.error(
+                            f"监控客户端 '{client_name}' 连接状态失败: {str(e)}", exc_info=True)
+
+            except Exception as e:
+                logger.error("RabbitMQ连接监控任务异常", exc_info=True)
+                await asyncio.sleep(cls.RECONNECT_INTERVAL)
+
+        logger.info("RabbitMQ连接监控任务停止")
+
+    @classmethod
+    def start_connection_monitor(cls) -> None:
+        """启动连接监控任务"""
+        if cls._connection_monitor_task and not cls._connection_monitor_task.done():
+            return
+
+        cls._connection_monitor_task = asyncio.create_task(
+            cls._monitor_connections())
+
+    @classmethod
+    async def stop_connection_monitor(cls, timeout: float = 15.0) -> None:
+        """停止连接监控任务"""
+        if cls._connection_monitor_task and not cls._connection_monitor_task.done():
+            cls._connection_monitor_task.cancel()
+            try:
+                await asyncio.wait_for(cls._connection_monitor_task, timeout=timeout)
+            except asyncio.TimeoutError:
+                logger.warning("连接监控任务关闭超时")
+            except Exception as e:
+                logger.error(f"关闭连接监控任务失败: {str(e)}")
+
+        cls._connection_monitor_task = None