sycommon-python-lib 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

sycommon/middleware/docs.py

@@ -0,0 +1,30 @@
+from fastapi import FastAPI, APIRouter
+from fastapi.openapi.docs import get_redoc_html, get_swagger_ui_html
+
+
+def setup_docs_handler(app: FastAPI):
+    docs_router = APIRouter()
+
+    @docs_router.get("/docs", include_in_schema=False)
+    async def custom_swagger_ui_html():
+        return get_swagger_ui_html(
+            openapi_url=app.openapi_url,
+            title=f"{app.title}",
+            swagger_favicon_url="https://static.sytechnology.com/img/sylogopng.png",
+            swagger_js_url="https://cdn.bootcdn.net/ajax/libs/swagger-ui/5.27.1/swagger-ui-bundle.js",
+            swagger_css_url="https://cdn.bootcdn.net/ajax/libs/swagger-ui/5.27.1/swagger-ui.css",
+            swagger_ui_parameters={"defaultModelsExpandDepth": -1},
+        )
+
+    @docs_router.get("/redoc", include_in_schema=False)
+    async def custom_redoc_html():
+        return get_redoc_html(
+            openapi_url=app.openapi_url,
+            title=f"{app.title}",
+            redoc_favicon_url="https://static.sytechnology.com/img/sylogopng.png",
+            redoc_js_url="https://cdn.bootcdn.net/ajax/libs/redoc/2.1.5/redoc.standalone.js",
+        )
+
+    app.include_router(docs_router)
+
+    return app

sycommon/middleware/middleware.py

@@ -1,5 +1,6 @@
 from sycommon.health.ping import setup_ping_handler
 from sycommon.middleware.cors import setup_cors_handler
+from sycommon.middleware.docs import setup_docs_handler
 from sycommon.middleware.exception import setup_exception_handler
 from sycommon.middleware.monitor_memory import setup_monitor_memory_middleware
 from sycommon.middleware.mq import setup_mq_middleware
@@ -36,4 +37,7 @@ class Middleware:
         # 添加mq中间件
         # app = setup_mq_middleware(app)
 
+        # doc
+        # app = setup_docs_handler(app)
+
         return app

sycommon/middleware/traceid.py

@@ -78,13 +78,19 @@ def setup_trace_id_handler(app):
             response = await call_next(request)
 
             content_type = response.headers.get("Content-Type", "")
+
+            # 处理 SSE 响应 - 关键修复点
             if "text/event-stream" in content_type:
-                # 处理 SSE 响应
+                # 流式响应不能有Content-Length，移除它
+                if "Content-Length" in response.headers:
+                    del response.headers["Content-Length"]
                 response.headers["x-traceId-header"] = trace_id
                 return response
 
+            # 处理普通响应
             response_body = b""
             try:
+                # 收集所有响应块
                 async for chunk in response.body_iterator:
                     response_body += chunk
 
@@ -98,14 +104,36 @@ def setup_trace_id_handler(app):
                         data["traceId"] = trace_id
                         new_body = json.dumps(
                             data, ensure_ascii=False).encode()
+
+                        # 创建新响应，确保Content-Length正确
                         response = Response(
                             content=new_body,
                             status_code=response.status_code,
-                            headers=dict(response.headers)
+                            headers=dict(response.headers),
+                            media_type=response.media_type
                         )
+                        # 显式设置正确的Content-Length
                         response.headers["Content-Length"] = str(len(new_body))
                     except json.JSONDecodeError:
-                        pass
+                        # 如果不是JSON，恢复原始响应体并更新长度
+                        response = Response(
+                            content=response_body,
+                            status_code=response.status_code,
+                            headers=dict(response.headers),
+                            media_type=response.media_type
+                        )
+                        response.headers["Content-Length"] = str(
+                            len(response_body))
+                else:
+                    # 非JSON响应，恢复原始响应体
+                    response = Response(
+                        content=response_body,
+                        status_code=response.status_code,
+                        headers=dict(response.headers),
+                        media_type=response.media_type
+                    )
+                    response.headers["Content-Length"] = str(
+                        len(response_body))
             except StopAsyncIteration:
                 pass
 
@@ -129,7 +157,7 @@ def setup_trace_id_handler(app):
                 "uploaded_files": files_info if files_info else None
             }
             error_message_str = json.dumps(error_message, ensure_ascii=False)
-            SYLogger.error(error_message_str)  # 无需显式传递 trace_id
+            SYLogger.error(error_message_str)
             raise
         finally:
             # 清理上下文变量，防止泄漏

sycommon/models/base_http.py

@@ -3,14 +3,15 @@ from pydantic import BaseModel, Field
 from fastapi.responses import JSONResponse
 from fastapi import status
 
-# 修改泛型约束，支持任意类型（包括基础类型和BaseModel）
+# 支持任意类型的泛型约束
 T = TypeVar('T')
 
 
 class BaseResponseModel(BaseModel, Generic[T]):
-    """基础响应模型，支持多种数据类型（包括字符串、字典和Pydantic模型）"""
-    code: int = Field(default=0, description="业务响应码，成功0，失败非0")
-    message: str = Field(default="success", description="业务响应信息")
+    """基础响应模型，支持自定义状态码"""
+    code: int = Field(default=0, description="业务响应码，默认0成功，1失败，支持自定义")
+    message: str | None = Field(default=None, description="业务响应信息")
+    success: bool = Field(default=True, description="请求是否成功")
     data: T | None = Field(default=None, description="业务响应数据，支持任意类型")
     traceId: str | None = Field(default=None, description="请求链路追踪ID")
 
@@ -22,22 +23,22 @@ class BaseResponseModel(BaseModel, Generic[T]):
 def build_response_content(
     data: T | Any = None,
     code: int = 0,
-    message: str = "success"
+    message: str = None
 ) -> dict:
     """
-    只构建响应内容的字典部分
+    构建响应内容字典，自动根据code判断success
 
-    Args:
-        data: 响应数据（支持字符串、字典、Pydantic模型等）
-        code: 业务响应码
-        message: 响应信息
-
-    Returns:
-        响应内容字典，格式为{"code": int, "message": str, "data": Any}
+    规则：
+    - code为0时success=True（默认成功）
+    - 其他任何code值success=False（包括200等自定义状态码）
     """
+    # 成功状态仅当code为0时成立，其他任何code都视为失败
+    success = code == 0 or code == 200
+
     response = BaseResponseModel(
         code=code,
         message=message,
+        success=success,
         data=data
     )
 
@@ -45,6 +46,7 @@ def build_response_content(
         return {
             "code": response.code,
             "message": response.message,
+            "success": response.success,
             "data": response.data.model_dump()
         }
     else:
@@ -54,10 +56,10 @@ def build_response_content(
 def create_response(
     data: T | Any = None,
     code: int = 0,
-    message: str = "success",
+    message: str = None,
     status_code: int = status.HTTP_200_OK
 ) -> JSONResponse:
-    """创建完整的JSONResponse响应"""
+    """创建完整响应，支持自定义业务状态码"""
     content = build_response_content(data=data, code=code, message=message)
     return JSONResponse(
         content=content,
@@ -65,18 +67,18 @@ def create_response(
     )
 
 
-def success_response(data: T | Any = None, message: str = "success") -> JSONResponse:
-    """快捷创建成功响应"""
-    return create_response(data=data, message=message)
+def success_response(data: T | Any = None, code: int = 0) -> JSONResponse:
+    """快捷创建成功响应（code=0, success=True）"""
+    return create_response(data=data, code=code)
 
 
 def error_response(
-    message: str = "error",
+    message: str = None,
     code: int = 1,
     data: T | Any = None,
     status_code: int = status.HTTP_500_INTERNAL_SERVER_ERROR
 ) -> JSONResponse:
-    """快捷创建错误响应"""
+    """快捷创建错误响应，支持自定义错误码（如200）"""
     return create_response(
         data=data,
         code=code,
@@ -85,15 +87,15 @@ def error_response(
     )
 
 
-def success_content(data: T | Any = None, message: str = "success") -> dict:
-    """只构建成功响应的内容字典"""
-    return build_response_content(data=data, message=message)
+def success_content(data: T | Any = None) -> dict:
+    """构建成功响应内容字典"""
+    return build_response_content(data=data)
 
 
 def error_content(
-    message: str = "error",
+    message: str = None,
     code: int = 1,
     data: T | Any = None
 ) -> dict:
-    """只构建错误响应的内容字典"""
+    """构建错误响应内容字典，支持自定义错误码"""
     return build_response_content(data=data, code=code, message=message)

sycommon/rabbitmq/rabbitmq_client.py

@@ -183,8 +183,14 @@ class RabbitMQClient:
                 await asyncio.sleep(1)
         return False
 
-    async def connect(self, force_reconnect: bool = False, max_retries: int = 3) -> None:
-        """建立连接并检查/创建资源"""
+    async def connect(self, force_reconnect: bool = False, declare_queue: bool = True) -> None:
+        """建立连接并检查/创建资源，新增declare_queue参数控制是否声明队列"""
+        # 增加日志确认参数状态
+        logging.debug(
+            f"connect() 调用 - force_reconnect={force_reconnect}, "
+            f"declare_queue={declare_queue}, create_if_not_exists={self.create_if_not_exists}"
+        )
+
         if self.is_connected and not force_reconnect:
             return
 
@@ -196,7 +202,8 @@ class RabbitMQClient:
             f"尝试连接RabbitMQ - 主机: {self.host}:{self.port}, "
             f"虚拟主机: {self.virtualhost}, "
             f"队列: {self.queue_name}, "
-            f"心跳间隔: {self.heartbeat}s"
+            f"声明队列: {declare_queue}, "
+            f"允许创建: {self.create_if_not_exists}"
         )
 
         # 重置状态
@@ -207,13 +214,13 @@ class RabbitMQClient:
         retries = 0
         last_exception = None
 
-        while retries < max_retries:
+        while retries < 3:  # 使用固定重试次数
             try:
                 # 关闭旧连接
                 if self.connection and not self.connection.is_closed:
                     await self.connection.close()
 
-                # 建立新连接 - 配置更短的心跳间隔
+                # 建立新连接
                 self.connection = await asyncio.wait_for(
                     aio_pika.connect_robust(
                         host=self.host,
@@ -223,7 +230,7 @@ class RabbitMQClient:
                         virtualhost=self.virtualhost,
                         heartbeat=self.heartbeat,
                         client_properties={
-                            "connection_name": self.app_name or "rabbitmq-client"}  # 增加连接标识
+                            "connection_name": self.app_name or "rabbitmq-client"}
                     ),
                     timeout=self.connection_timeout
                 )
@@ -262,28 +269,29 @@ class RabbitMQClient:
                     )
                     logging.info(f"使用已存在的交换机 '{self.exchange_name}'")
 
-                # 2. 处理队列
-                if self.queue_name:
+                # 2. 处理队列 - 只有declare_queue为True时才处理
+                if declare_queue and self.queue_name:
                     queue_exists = await self._check_queue_exists()
 
                     if not queue_exists:
-                        if self.create_if_not_exists:
-                            # 创建队列
-                            self.queue = await asyncio.wait_for(
-                                self.channel.declare_queue(
-                                    name=self.queue_name,
-                                    durable=self.durable,
-                                    auto_delete=self.auto_delete,
-                                    exclusive=False,
-                                    passive=False
-                                ),
-                                timeout=self.rpc_timeout
-                            )
-                            self._queue_exists = True
-                            logging.info(f"已创建队列 '{self.queue_name}'")
-                        else:
+                        # 关键检查点：确保有权限创建队列
+                        if not self.create_if_not_exists:
                             raise Exception(
                                 f"队列 '{self.queue_name}' 不存在且不允许自动创建")
+
+                        # 创建队列
+                        self.queue = await asyncio.wait_for(
+                            self.channel.declare_queue(
+                                name=self.queue_name,
+                                durable=self.durable,
+                                auto_delete=self.auto_delete,
+                                exclusive=False,
+                                passive=False
+                            ),
+                            timeout=self.rpc_timeout
+                        )
+                        self._queue_exists = True
+                        logging.info(f"已创建队列 '{self.queue_name}'")
                     else:
                         # 获取已有队列
                         self.queue = await asyncio.wait_for(
@@ -292,12 +300,18 @@ class RabbitMQClient:
                         )
                         logging.info(f"使用已存在的队列 '{self.queue_name}'")
 
-                # 3. 绑定队列到交换机
-                if self.queue and self.exchange:
-                    bound = await self._bind_queue()
-                    if not bound:
-                        raise Exception(
-                            f"队列 '{self.queue_name}' 绑定到交换机 '{self.exchange_name}' 失败")
+                    # 3. 绑定队列到交换机
+                    if self.queue and self.exchange:
+                        bound = await self._bind_queue()
+                        if not bound:
+                            raise Exception(
+                                f"队列 '{self.queue_name}' 绑定到交换机 '{self.exchange_name}' 失败")
+                else:
+                    # 不声明队列时，将队列相关状态设为False
+                    self.queue = None
+                    self._queue_exists = False
+                    self._queue_bound = False
+                    logging.debug(f"跳过队列 '{self.queue_name}' 的声明和绑定")
 
                 # 如果之前在消费，重新开始消费
                 if self._is_consuming and self.message_handler:
@@ -308,23 +322,22 @@ class RabbitMQClient:
                 self._start_keepalive_task()
 
                 self._update_activity_timestamp()
-                logging.info(f"RabbitMQ客户端连接成功 (队列: {self.queue_name})")
+                logging.info(
+                    f"RabbitMQ客户端连接成功 (队列: {self.queue_name}, 声明队列: {declare_queue})")
                 return
 
             except Exception as e:
                 retries += 1
                 last_exception = e
                 logging.warning(
-                    f"连接失败（{retries}/{max_retries}）: {str(e)}，重试中...")
+                    f"连接失败（{retries}/3）: {str(e)}, create_if_not_exists={self.create_if_not_exists}, 重试中...")
 
-            if retries < max_retries:
+            if retries < 3:
                 await asyncio.sleep(self.reconnection_delay)
 
-        logging.error(f"最终连接失败: {str(last_exception)}", exc_info=True)
+        logging.error(f"最终连接失败: {str(last_exception)}")
         raise Exception(
-            f"经过{max_retries}次重试后仍无法完成连接和资源初始化。"
-            f"最后错误: {str(last_exception)}"
-        )
+            f"经过3次重试后仍无法完成连接和资源初始化。最后错误: {str(last_exception)}")
 
     def _start_connection_monitor(self):
         """启动连接监控任务，检测连接/通道关闭"""
@@ -534,16 +547,31 @@ class RabbitMQClient:
         self.message_handler = handler
 
     async def start_consuming(self, timeout: Optional[float] = None) -> str:
-        """开始消费消息并返回consumer_tag，支持超时控制"""
+        """开始消费消息并返回consumer_tag，支持超时控制和队列检查重试"""
         if self._is_consuming:
             logging.debug("已经在消费中，返回现有consumer_tag")
             return self._consumer_tag
 
-        if not self.is_connected:
-            await self.connect()
+        # 增加队列检查和连接确保逻辑
+        max_attempts = 5
+        attempt = 0
+        while attempt < max_attempts:
+            if not self.is_connected:
+                await self.connect()
+
+            if self.queue:
+                break
+
+            attempt += 1
+            logging.warning(f"队列尚未初始化，等待后重试（{attempt}/{max_attempts}）")
+            await asyncio.sleep(1)
 
         if not self.queue:
-            raise Exception("队列未初始化")
+            # 最后尝试一次显式连接并声明队列
+            logging.warning("最后尝试重新连接并声明队列")
+            await self.connect(force_reconnect=True, declare_queue=True)
+            if not self.queue:
+                raise Exception("队列未初始化，多次尝试后仍无法创建")
 
         if not self.message_handler:
             raise Exception("未设置消息处理函数")

sycommon/rabbitmq/rabbitmq_service.py

@@ -31,15 +31,22 @@ class RabbitMQService:
     _initialized_queues: Dict[str, Dict[str, bool]] = {}
     # 添加异步锁
     _init_lock: Dict[str, asyncio.Lock] = {}
+    _has_listeners: bool = False
+    _has_senders: bool = False
 
     @classmethod
-    def init(cls, config: dict) -> Type['RabbitMQService']:
-        """初始化RabbitMQ服务，保存配置"""
+    def init(cls, config: dict, has_listeners: bool = False, has_senders: bool = False) -> Type['RabbitMQService']:
+        """初始化RabbitMQ服务，保存配置和发送器/监听器状态"""
         from sycommon.synacos.nacos_service import NacosService
         # 获取 common 配置
         cls.config = NacosService(config).share_configs.get(
             "mq.yml", {}).get('spring', {}).get('rabbitmq', {})
         cls.config["APP_NAME"] = config.get("Name", "")
+
+        # 保存发送器和监听器存在状态
+        cls._has_listeners = has_listeners
+        cls._has_senders = has_senders
+
         return cls()
 
     @classmethod
@@ -56,21 +63,35 @@ class RabbitMQService:
 
     @classmethod
     def create_client(cls, mq_config: dict, queue_name: str, **kwargs):
-        """创建并返回新的RabbitMQClient实例"""
-        # 从kwargs中提取是否自动创建队列的参数，默认True
-        create_if_not_exists = kwargs.get('create_if_not_exists', True)
+        """创建并返回新的RabbitMQClient实例，遵循队列创建规则"""
+        # 获取当前项目名
+        app_name = kwargs.get('app_name', cls.config.get(
+            "APP_NAME", "")) if cls.config else kwargs.get('app_name', "")
 
         # 确保只在需要时处理一次队列名称
         processed_queue_name = queue_name
 
-        # 如果是监听器且需要自动创建队列，确保队列名拼接app-name（只拼接一次）
-        if create_if_not_exists and processed_queue_name and 'app_name' in kwargs and kwargs['app_name']:
-            app_name = kwargs['app_name']
-            # 只在队列名尚未包含app-name时进行拼接
+        # 通过上下文判断是否为发送器
+        # 发送器场景：当没有监听器时
+        is_sender = not cls._has_listeners
+
+        # 核心逻辑：根据组件存在状态决定是否允许创建队列
+        # 1. 只有发送器：不允许创建队列
+        # 2. 只有监听器：允许创建队列
+        # 3. 两者都存在：允许创建队列（由监听器负责）
+        create_if_not_exists = cls._has_listeners  # 只要有监听器就允许创建
+
+        # 当需要创建队列且是监听器时，拼接项目名
+        if create_if_not_exists and not is_sender 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}"
                 logging.debug(f"监听器队列名称自动拼接app-name: {processed_queue_name}")
 
+        logging.debug(
+            f"队列创建权限 - 监听器存在: {cls._has_listeners}, 发送器存在: {cls._has_senders}, "
+            f"是否发送器: {is_sender}, 允许创建: {create_if_not_exists}, 队列: {processed_queue_name}"
+        )
+
         return RabbitMQClient(
             host=mq_config.get('host', ""),
             port=mq_config.get('port', 0),
@@ -80,7 +101,7 @@ class RabbitMQService:
             exchange_name=mq_config.get(
                 'exchange_name', "system.topic.exchange"),
             exchange_type=kwargs.get('exchange_type', "topic"),
-            queue_name=processed_queue_name,  # 使用处理后的队列名
+            queue_name=processed_queue_name,
             routing_key=kwargs.get(
                 'routing_key', f"{processed_queue_name.split('.')[0]}.#" if processed_queue_name else "#"),
             durable=kwargs.get('durable', True),
@@ -89,7 +110,7 @@ class RabbitMQService:
             create_if_not_exists=create_if_not_exists,
             connection_timeout=kwargs.get('connection_timeout', 10),
             rpc_timeout=kwargs.get('rpc_timeout', 5),
-            app_name=kwargs.get('app_name', "")
+            app_name=app_name
         )
 
     @classmethod
@@ -105,52 +126,80 @@ class RabbitMQService:
         async with cls._init_lock[client_name]:
             if client_name in cls.clients:
                 client = cls.clients[client_name]
+                # 移除is_sender判断，通过上下文推断
+                is_sender = not cls._has_listeners or (
+                    not kwargs.get('create_if_not_exists', True))
+
                 if client.is_connected:
-                    logging.debug(f"客户端 '{client_name}' 已存在且连接有效，直接返回")
+                    if not is_sender and not client.queue:
+                        logging.debug(f"客户端 '{client_name}' 存在但队列未初始化，重新连接")
+                        client.create_if_not_exists = True
+                        await client.connect(force_reconnect=True, declare_queue=True)
+                    else:
+                        logging.debug(f"客户端 '{client_name}' 已存在且连接有效，直接返回")
                     return client
                 else:
                     logging.debug(f"客户端 '{client_name}' 存在但连接已关闭，重新连接")
-                    await client.connect()
+                    if not is_sender:
+                        client.create_if_not_exists = True
+                    await client.connect(declare_queue=not is_sender)
                     return client
 
             initial_queue_name = kwargs.pop('queue_name', '')
-            create_if_not_exists = kwargs.get('create_if_not_exists', True)
+            # 移除is_sender参数，通过上下文推断
+            is_sender = not cls._has_listeners or (
+                not kwargs.get('create_if_not_exists', True))
+
+            # 发送器特殊处理
+            if is_sender:
+                kwargs['create_if_not_exists'] = False
 
-            # 检查队列是否已初始化
-            if initial_queue_name in cls._initialized_queues:
-                logging.debug(f"队列 '{initial_queue_name}' 已初始化过，直接创建客户端")
                 client = RabbitMQService.create_client(
                     mq_config,
                     initial_queue_name,
                     app_name=cls.config.get("APP_NAME", ""),
-                    **kwargs
+                    **kwargs  # 不再传递is_sender参数
                 )
-                await client.connect()
+
+                await client.connect(declare_queue=False)
                 cls.clients[client_name] = client
                 return client
 
-            # 处理create_if_not_exists参数，避免重复传递
-            create_if_not_exists = kwargs.pop('create_if_not_exists', True)
+            # 监听器逻辑
+            kwargs['create_if_not_exists'] = True
 
-            # 对于监听器，确保create_if_not_exists为True
-            # 判断是否为监听器：客户端名称与队列名称相同通常是监听器
-            is_listener = client_name == initial_queue_name and initial_queue_name
-            if is_listener:
-                create_if_not_exists = True
-                logging.debug(f"监听器 '{client_name}' 将自动创建队列（如果不存在）")
+            if initial_queue_name in cls._initialized_queues:
+                logging.debug(f"队列 '{initial_queue_name}' 已初始化过，直接创建客户端")
+                client = RabbitMQService.create_client(
+                    mq_config,
+                    initial_queue_name,
+                    # 不再传递is_sender参数
+                    app_name=cls.config.get("APP_NAME", ""), ** kwargs
+                )
+                await client.connect(declare_queue=True)
+                cls.clients[client_name] = client
+                return client
 
-            # 创建客户端（这里会处理队列名称，添加app-name）
             client = RabbitMQService.create_client(
                 mq_config,
                 initial_queue_name,
                 app_name=cls.config.get("APP_NAME", ""),
-                create_if_not_exists=create_if_not_exists,
-                connection_timeout=mq_config.get('connection_timeout', 15),
-                rpc_timeout=mq_config.get('rpc_timeout', 5), ** kwargs
+                **kwargs  # 不再传递is_sender参数
             )
 
-            # 连接时不再处理队列名称，避免重复添加app-name
-            await client.connect()
+            client.create_if_not_exists = True
+            logging.debug(
+                f"监听器客户端创建 - create_if_not_exists={client.create_if_not_exists}")
+
+            await client.connect(declare_queue=True)
+
+            if not client.queue:
+                logging.error(f"队列 '{initial_queue_name}' 创建失败，尝试重新创建")
+                client.create_if_not_exists = True
+                await client.connect(force_reconnect=True, declare_queue=True)
+                if not client.queue:
+                    raise Exception(f"无法创建队列 '{initial_queue_name}'")
+
             final_queue_name = client.queue_name
 
             if final_queue_name not in cls._initialized_queues:
@@ -163,8 +212,11 @@ class RabbitMQService:
             return client
 
     @classmethod
-    async def setup_senders(cls, senders: List[RabbitMQSendConfig]):
-        """设置MQ发送客户端 - 保持不自动创建队列的行为"""
+    async def setup_senders(cls, senders: List[RabbitMQSendConfig], has_listeners: bool = False):
+        """设置MQ发送客户端"""
+        cls._has_listeners = has_listeners
+        cls._has_senders = True  # 明确标记存在发送器
+
         async def setup_sender_tasks():
             for idx, sender_config in enumerate(senders):
                 try:
@@ -173,20 +225,23 @@ class RabbitMQService:
 
                     normalized_name = sender_config.queue_name
                     app_name = cls.config.get("APP_NAME", "")
+
                     if app_name and normalized_name.endswith(f".{app_name}"):
                         normalized_name = normalized_name[:-
                                                           len(f".{app_name}")]
+                        logging.debug(
+                            f"发送器队列名称移除app-name后缀: {normalized_name}")
 
                     if normalized_name in cls.sender_client_names:
-                        logging.debug(f"发送客户端 '{normalized_name}' 已存在，跳过重复配置")
+                        logging.debug(f"发送客户端 '{normalized_name}' 已存在，跳过")
                         continue
 
                     if normalized_name in cls.clients:
                         client = cls.clients[normalized_name]
                         if not client.is_connected:
-                            await client.connect()
+                            await client.connect(declare_queue=False)
                     else:
-                        # 发送端明确设置不自动创建队列
+                        # 移除is_sender参数传递
                         client = await cls.setup_rabbitmq(
                             cls.config,
                             client_name=normalized_name,
@@ -195,12 +250,12 @@ class RabbitMQService:
                             auto_delete=sender_config.auto_delete,
                             auto_parse_json=sender_config.auto_parse_json,
                             queue_name=sender_config.queue_name,
-                            create_if_not_exists=False  # 发送端不自动创建队列
+                            create_if_not_exists=False  # 仅通过此参数控制
                         )
 
                     if normalized_name not in cls.clients:
                         cls.clients[normalized_name] = client
-                        logging.info(f"客户端 '{normalized_name}' 已添加到客户端列表")
+                        logging.info(f"发送客户端 '{normalized_name}' 已添加")
 
                     if normalized_name not in cls.sender_client_names:
                         cls.sender_client_names.append(normalized_name)
@@ -217,8 +272,11 @@ class RabbitMQService:
             raise
 
     @classmethod
-    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig]):
+    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False):
         """设置MQ监听器 - 确保自动创建队列"""
+        # 存在监听器，设置标志
+        cls._has_listeners = True
+
         for listener_config in listeners:
             # 将监听器配置转换为字典并添加到监听器
             # 强制设置create_if_not_exists为True
@@ -337,19 +395,17 @@ class RabbitMQService:
 
     @classmethod
     def get_sender(cls, client_name: Optional[str] = None) -> Optional[RabbitMQClient]:
-        """获取发送客户端（仅返回已注册的客户端，移除模糊匹配）"""
+        """获取发送客户端（仅返回已注册的客户端）"""
         if not client_name:
             logging.warning("发送器名称不能为空")
             return None
 
-        # 仅精确匹配已注册的客户端，不做模糊匹配
+        # 仅精确匹配已注册的客户端
         if client_name in cls.clients:
             return cls.clients[client_name]
 
-        # 不允许通过拼接app-name反向查找（避免绕过注册）
         app_name = cls.config.get("APP_NAME", "") if cls.config else ""
         if app_name and not client_name.endswith(f".{app_name}"):
-            # 不尝试拼接app-name查找，确保只有注册的名称可被找到
             return None
 
         logging.debug(f"发送器 '{client_name}' 不在已注册客户端列表中")
@@ -359,7 +415,7 @@ class RabbitMQService:
     async def send_message(
         cls,
         data: Union[BaseModel, str, Dict[str, Any], None],
-        queue_name: Optional[str] = None, ** kwargs
+        queue_name: Optional[str] = None, **kwargs
     ) -> None:
         """发送消息到RabbitMQ"""
         sender = cls.get_sender(queue_name)
@@ -472,5 +528,6 @@ class RabbitMQService:
         cls.clients.clear()
         cls.sender_client_names.clear()
         cls._init_lock.clear()
+        cls._has_listeners = False  # 重置标志
 
         logging.info("RabbitMQ服务已完全关闭")

sycommon/services.py

@@ -1,15 +1,14 @@
-from typing import Any, Callable, Dict, List, Tuple, Union, Optional, Awaitable
+from typing import Any, Callable, Dict, List, Tuple, Union, Optional, AsyncGenerator
 import asyncio
 import logging
 from contextlib import asynccontextmanager
-from dotenv import load_dotenv
-from fastapi import FastAPI
+from fastapi import FastAPI, applications
 from pydantic import BaseModel
-import yaml
 from sycommon.config.Config import SingletonMeta
 from sycommon.models.mqlistener_config import RabbitMQListenerConfig
 from sycommon.models.mqsend_config import RabbitMQSendConfig
 from sycommon.rabbitmq.rabbitmq_service import RabbitMQService
+from sycommon.tools.docs import custom_redoc_html, custom_swagger_ui_html
 
 
 class Services(metaclass=SingletonMeta):
@@ -18,187 +17,179 @@ class Services(metaclass=SingletonMeta):
     _initialized: bool = False
     _registered_senders: List[str] = []
     _mq_tasks: List[asyncio.Task] = []
-    _pending_setup: Optional[Callable[..., Awaitable[None]]] = None
     _instance: Optional['Services'] = None
+    _app: Optional[FastAPI] = None
 
-    def __init__(self, config):
+    def __init__(self, config: dict, app: FastAPI):
         if not Services._config:
             Services._config = config
         Services._instance = self
+        Services._app = app
+        self._init_event_loop()
 
-    @classmethod
-    def get_lifespan(cls, config):
-        """返回 FastAPI 的 lifespan 管理器"""
-        cls._config = config
-
-        @asynccontextmanager
-        async def lifespan(app):
-            # 应用启动时初始化
-            cls._loop = asyncio.get_running_loop()
-            cls._initialized = True
-            logging.info("Services initialized with FastAPI event loop")
-
-            # 执行之前缓存的MQ设置
-            if cls._pending_setup:
-                try:
-                    await cls._pending_setup()
-                except Exception as e:
-                    logging.error(f"执行MQ初始化失败: {str(e)}", exc_info=True)
-                finally:
-                    cls._pending_setup = None
-
+    def _init_event_loop(self):
+        """初始化事件循环，确保全局只有一个循环实例"""
+        if not Services._loop:
             try:
-                yield
-            finally:
-                # 应用关闭时清理
-                await cls.shutdown()
-                logging.info("Services shutdown completed")
-
-        return lifespan
+                Services._loop = asyncio.get_running_loop()
+            except RuntimeError:
+                Services._loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(Services._loop)
 
     @classmethod
-    def plugins(cls,
-                middleware: Optional[Tuple[Callable, FastAPI]] = None,
-                nacos_service: Optional[Callable] = None,
-                logging_service: Optional[Callable] = None,
-                database_service: Optional[Union[Tuple[Callable, str],
-                                                 List[Tuple[Callable, str]]]] = None,
-                rabbitmq_listeners: Optional[List[RabbitMQListenerConfig]] = None,
-                rabbitmq_senders: Optional[List[RabbitMQSendConfig]] = None
-                ) -> None:
-        """
-        类方法：注册各种服务插件
-        确保单例实例存在后调用实例方法的register_plugins
-        """
-        # 确保实例已创建
-        if not cls._instance:
-            if not cls._config:
-                raise ValueError("Services尚未初始化，请先提供配置")
-            cls._instance = Services(cls._config)
-
-        cls._instance.register_plugins(
-            middleware=middleware,
-            nacos_service=nacos_service,
-            logging_service=logging_service,
-            database_service=database_service,
-            rabbitmq_listeners=rabbitmq_listeners,
-            rabbitmq_senders=rabbitmq_senders
-        )
-
-    def register_plugins(
-        self,
-        middleware: Optional[Tuple[Callable, FastAPI]] = None,
-        nacos_service: Optional[Callable] = None,
-        logging_service: Optional[Callable] = None,
-        database_service: Optional[Union[Tuple[Callable,
-                                               str], List[Tuple[Callable, str]]]] = None,
+    def plugins(
+        cls,
+        app: FastAPI,
+        config: dict,
+        middleware: Optional[Callable[[FastAPI, dict], None]] = None,
+        nacos_service: Optional[Callable[[dict], None]] = None,
+        logging_service: Optional[Callable[[dict], None]] = None,
+        database_service: Optional[Union[
+            Tuple[Callable[[dict, str], None], str],
+            List[Tuple[Callable[[dict, str], None], str]]
+        ]] = None,
         rabbitmq_listeners: Optional[List[RabbitMQListenerConfig]] = None,
         rabbitmq_senders: Optional[List[RabbitMQSendConfig]] = None
-    ) -> None:
-        """实例方法：实际执行各种服务插件的注册逻辑"""
-        # 注册非异步服务
+    ) -> FastAPI:
+        # 保存应用实例和配置
+        cls._app = app
+        cls._config = config
+        # 设置文档
+        applications.get_swagger_ui_html = custom_swagger_ui_html
+        applications.get_redoc_html = custom_redoc_html
+
+        # 立即配置非异步服务（在应用启动前）
         if middleware:
-            self._setup_middleware(middleware)
+            middleware(app, config)
+
         if nacos_service:
-            nacos_service(self._config)
+            nacos_service(config)
+
         if logging_service:
-            logging_service(self._config)
+            logging_service(config)
+
         if database_service:
-            self._setup_database(database_service)
+            cls._setup_database_static(database_service, config)
+
+        # 创建生命周期管理器
+        @asynccontextmanager
+        async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
+            # 启动阶段 - 执行初始化
+            instance = cls(config, app)
+
+            # 检查是否存在监听器
+            has_listeners = bool(
+                rabbitmq_listeners and len(rabbitmq_listeners) > 0)
+            # 检查是否存在发送器
+            has_senders = bool(
+                rabbitmq_senders and len(rabbitmq_senders) > 0)
+
+            # 执行MQ异步初始化，传递是否有监听器的标志
+            try:
+                await instance._setup_mq_async(
+                    rabbitmq_listeners=rabbitmq_listeners,
+                    rabbitmq_senders=rabbitmq_senders,
+                    has_listeners=has_listeners,
+                    has_senders=has_senders
+                )
+                cls._initialized = True
+                logging.info("所有服务初始化完成")
+            except Exception as e:
+                logging.error(f"服务初始化失败: {str(e)}", exc_info=True)
+                raise
+
+            # 将实例挂载到app上
+            app.state.services = instance
 
-        RabbitMQService.init(self._config)
+            yield  # 应用运行阶段
 
-        # MQ设置异步函数
-        async def setup_mq_components():
-            if rabbitmq_senders:
-                self._setup_senders(rabbitmq_senders)
-            if rabbitmq_listeners:
-                self._setup_listeners(rabbitmq_listeners)
+            # 关闭阶段 - 清理资源
+            await cls.shutdown()
+            logging.info("所有服务已关闭")
 
-        # 存储到_pending_setup，等待lifespan异步执行
-        Services._pending_setup = setup_mq_components
+        # 设置生命周期
+        app.router.lifespan_context = lifespan
 
-    def _setup_database(self, database_service):
+        return app
+
+    @staticmethod
+    def _setup_database_static(database_service, config):
+        """静态方法：设置数据库服务"""
         if isinstance(database_service, tuple):
             db_setup, db_name = database_service
-            db_setup(self._config, db_name)
+            db_setup(config, db_name)
         elif isinstance(database_service, list):
             for db_setup, db_name in database_service:
-                db_setup(self._config, db_name)
+                db_setup(config, db_name)
 
-    def _setup_middleware(self, middleware):
-        if isinstance(middleware, tuple):
-            middleware_setup, app = middleware
-            middleware_setup(app, self._config)
-
-    def _setup_senders(self, rabbitmq_senders):
+    async def _setup_mq_async(
+        self,
+        rabbitmq_listeners: Optional[List[RabbitMQListenerConfig]] = None,
+        rabbitmq_senders: Optional[List[RabbitMQSendConfig]] = None,
+        has_listeners: bool = False,
+        has_senders: bool = False,
+    ):
+        """异步设置MQ相关服务，保存发送器和监听器存在状态"""
+        # 保存状态到类变量
+        Services._has_listeners = has_listeners
+        Services._has_senders = has_senders
+
+        # 初始化RabbitMQ服务，传递状态
+        RabbitMQService.init(self._config, has_listeners, has_senders)
+
+        # 设置发送器，传递是否有监听器的标志
+        if rabbitmq_senders:
+            await self._setup_senders_async(rabbitmq_senders, has_listeners)
+
+        # 设置监听器，传递是否有发送器的标志
+        if rabbitmq_listeners:
+            await self._setup_listeners_async(rabbitmq_listeners, has_senders)
+
+    async def _setup_senders_async(self, rabbitmq_senders, has_listeners: bool):
         Services._registered_senders = [
             sender.queue_name for sender in rabbitmq_senders]
-        if self._loop:  # 确保loop存在
-            task = self._loop.create_task(
-                self._setup_and_wait(
-                    RabbitMQService.setup_senders, rabbitmq_senders)
-            )
-            self._mq_tasks.append(task)
+
+        # 将是否有监听器的信息传递给RabbitMQService
+        await RabbitMQService.setup_senders(rabbitmq_senders, has_listeners)
         logging.info(f"已注册的RabbitMQ发送器: {Services._registered_senders}")
 
-    def _setup_listeners(self, rabbitmq_listeners):
-        if self._loop:  # 确保loop存在
-            task = self._loop.create_task(
-                self._setup_and_wait(
-                    RabbitMQService.setup_listeners, rabbitmq_listeners)
-            )
-            self._mq_tasks.append(task)
-
-    async def _setup_and_wait(self, setup_func, *args, **kwargs):
-        try:
-            await setup_func(*args, **kwargs)
-        except Exception as e:
-            logging.error(
-                f"Error in {setup_func.__name__}: {str(e)}", exc_info=True)
+    async def _setup_listeners_async(self, rabbitmq_listeners, has_senders: bool):
+        await RabbitMQService.setup_listeners(rabbitmq_listeners, has_senders)
 
     @classmethod
     async def send_message(
         cls,
         queue_name: str,
         data: Union[str, Dict[str, Any], BaseModel, None],
-        max_retries: int = 3,  # 最大重试次数
-        retry_delay: float = 1.0,  # 重试间隔（秒）
-        **kwargs
+        max_retries: int = 3,
+        retry_delay: float = 1.0, ** kwargs
     ) -> None:
-        """发送消息，添加重试机制处理发送器不存在的情况"""
+        """发送消息，添加重试机制"""
         if not cls._initialized or not cls._loop:
             logging.error("Services not properly initialized!")
             raise ValueError("服务未正确初始化")
 
-        # 重试逻辑
         for attempt in range(max_retries):
             try:
-                # 检查发送器是否已注册
                 if queue_name not in cls._registered_senders:
-                    # 可能是初始化尚未完成，尝试刷新注册列表
                     cls._registered_senders = RabbitMQService.sender_client_names
                     if queue_name not in cls._registered_senders:
                         raise ValueError(f"发送器 {queue_name} 未注册")
 
-                # 获取发送器
                 sender = RabbitMQService.get_sender(queue_name)
                 if not sender:
                     raise ValueError(f"发送器 '{queue_name}' 不存在")
 
-                # 发送消息
-                await RabbitMQService.send_message(data, queue_name, ** kwargs)
+                await RabbitMQService.send_message(data, queue_name, **kwargs)
                 logging.info(f"消息发送成功（尝试 {attempt+1}/{max_retries}）")
-                return  # 成功发送，退出函数
+                return
 
             except Exception as e:
-                # 最后一次尝试失败则抛出异常
                 if attempt == max_retries - 1:
                     logging.error(
                         f"消息发送失败（已尝试 {max_retries} 次）: {str(e)}", exc_info=True)
                     raise
 
-                # 非最后一次尝试，记录警告并等待重试
                 logging.warning(
                     f"消息发送失败（尝试 {attempt+1}/{max_retries}）: {str(e)}，"
                     f"{retry_delay}秒后重试..."
@@ -207,6 +198,8 @@ class Services(metaclass=SingletonMeta):
 
     @staticmethod
     async def shutdown():
+        """关闭所有服务"""
+        # 取消所有MQ任务
         for task in Services._mq_tasks:
             if not task.done():
                 task.cancel()
@@ -214,4 +207,6 @@ class Services(metaclass=SingletonMeta):
                     await task
                 except asyncio.CancelledError:
                     pass
+
+        # 关闭RabbitMQ服务
         await RabbitMQService.shutdown()

sycommon/tools/docs.py

@@ -0,0 +1,42 @@
+from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html, swagger_ui_default_parameters
+
+
+def custom_swagger_ui_html(*args, **kwargs):
+    custom_params = {
+        "dom_id": "#swagger-ui",
+        "layout": "BaseLayout",
+        "deepLinking": True,
+        "showExtensions": True,
+        "showCommonExtensionsExtensions": True,
+        "defaultModelsExpandDepth": -1,
+        "persistAuthorization": True,
+        "displayRequestDuration": True
+    }
+
+    # 初始化合并参数为默认参数的副本
+    merged_params = swagger_ui_default_parameters.copy()
+
+    # 安全地合并kwargs中的参数（处理可能为None的情况）
+    if "swagger_ui_parameters" in kwargs and kwargs["swagger_ui_parameters"] is not None:
+        merged_params.update(kwargs["swagger_ui_parameters"])
+
+    # 最后应用自定义参数
+    merged_params.update(custom_params)
+    kwargs["swagger_ui_parameters"] = merged_params
+
+    return get_swagger_ui_html(
+        *args, ** kwargs,
+        swagger_favicon_url="https://static.sytechnology.com/img/sylogopng.png",
+        swagger_js_url="https://cdn.bootcdn.net/ajax/libs/swagger-ui/5.27.1/swagger-ui-bundle.js",
+        swagger_css_url="https://cdn.bootcdn.net/ajax/libs/swagger-ui/5.27.1/swagger-ui.css",
+    )
+
+
+def custom_redoc_html(*args, **kwargs):
+    return get_redoc_html(
+        *args,
+        **kwargs,
+        redoc_favicon_url='https://static.sytechnology.com/img/sylogopng.png',
+        # redoc_js_url="https://cdn.jsdelivr.net/npm/@stardustai/redoc@2.0.0-rc.66/bundles/redoc.browser.lib.min.js",
+        with_google_fonts=False,
+    )

{sycommon_python_lib-0.1.8.dist-info → sycommon_python_lib-0.1.10.dist-info}/METADATA

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

{sycommon_python_lib-0.1.8.dist-info → sycommon_python_lib-0.1.10.dist-info}/RECORD

@@ -1,5 +1,5 @@
 sycommon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sycommon/services.py,sha256=Ow3BwiscQeX0k9fcr5t9ykpw6Oy-vcKkLR_UlFTb4WQ,8537
+sycommon/services.py,sha256=_XgQF72-NisNV2bQJcHPWSIDd_RG-g8RmGN_QxQ8noE,8104
 sycommon/config/Config.py,sha256=9yO5b8WfvEDvkyrGrlwrLFasgh_-MjcEvGF20Gz5Xo4,3041
 sycommon/config/DatabaseConfig.py,sha256=ILiUuYT9_xJZE2W-RYuC3JCt_YLKc1sbH13-MHIOPhg,804
 sycommon/config/EmbeddingConfig.py,sha256=gPKwiDYbeu1GpdIZXMmgqM7JqBIzCXi0yYuGRLZooMI,362
@@ -18,28 +18,30 @@ sycommon/logging/logger_wrapper.py,sha256=TiHsrIIHiQMzXgXK12-0KIpU9GhwQJOoHslakz
 sycommon/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/middleware/context.py,sha256=_5ghpv4u_yAvjkgM-XDx8OnO-YI1XtntHrXsHJHZkwo,88
 sycommon/middleware/cors.py,sha256=bGwDPI5Bfr0yH0hM-K7wK8mur5YqTy_XVZqlsdY_WdU,301
+sycommon/middleware/docs.py,sha256=bVdDBIHXGVBv562MQLSroa1DgHoObxR9gFzv71PIejg,1187
 sycommon/middleware/exception.py,sha256=Bk8IchNND1wg6tUX9hf4xWeEJhvA-E_zE9ysBpRZrqE,3010
-sycommon/middleware/middleware.py,sha256=z6osiDyKDxNKqErI29RVgijcjjl8e2wg-T9WN4xdbys,1220
+sycommon/middleware/middleware.py,sha256=KP7oM6rBowzF89wxBAUWArlC8GklrroP--gm4DtyAuo,1331
 sycommon/middleware/monitor_memory.py,sha256=pYRK-wRuDd6enSg9Pf8tQxPdYQS6S0AyjyXeKFRLKEs,628
 sycommon/middleware/mq.py,sha256=4wBqiT5wJGcrfjk2GSr0_U3TStBxoNpHTzcRxVlMEHE,183
 sycommon/middleware/timeout.py,sha256=fImlAPLm4Oa8N9goXtT_0os1GZPCi9F92OgXU81DgDU,656
-sycommon/middleware/traceid.py,sha256=24OAvsprq_LGT1zc5Jacd_lBIt8-eU6akm-gkgLTIEo,5469
+sycommon/middleware/traceid.py,sha256=oGTJ2jtdea_3NgaAwXLpUug5dGUYRQeM4r1n2icuvC8,6839
 sycommon/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sycommon/models/base_http.py,sha256=bbVvNnqi22DZavYKsYJN0Z1yJzfF9vzUzG_u2lFpNlc,2886
+sycommon/models/base_http.py,sha256=hcebQSPlGtx0GrLNK02VTDpviCBILaMrWijmlKEQu3I,3013
 sycommon/models/log.py,sha256=rZpj6VkDRxK3B6H7XSeWdYZshU8F0Sks8bq1p6pPlDw,500
 sycommon/models/mqlistener_config.py,sha256=PPwhAVJ2AWvVAvNox_1t0fuBKTyRH3Ui9cuuU-q7Byo,1590
 sycommon/models/mqmsg_model.py,sha256=cxn0M5b0utQK6crMYmL-1waeGYHvK3AlGaRy23clqTE,277
 sycommon/models/mqsend_config.py,sha256=NQX9dc8PpuquMG36GCVhJe8omAW1KVXXqr6lSRU6D7I,268
 sycommon/models/sso_user.py,sha256=i1WAN6k5sPcPApQEdtjpWDy7VrzWLpOrOQewGLGoGIw,2702
-sycommon/rabbitmq/rabbitmq_client.py,sha256=8QeshhkWliJ6ed2-0LmFUWQ9ZLXdDBwNsZrvRiDWMlc,29390
-sycommon/rabbitmq/rabbitmq_service.py,sha256=7Ol1jQ7glV5mrGLU6hORv-UTjJH_SeyDk3JgSIS45uA,20194
+sycommon/rabbitmq/rabbitmq_client.py,sha256=QLsn_jqWtBihmBXgrFRZx9S5AhtnvWIuolkfOHno0Wc,30782
+sycommon/rabbitmq/rabbitmq_service.py,sha256=Cl3zWa1PVv3kqpYWKtkP-SomXUSgVNDqzkhE8PuvCR0,22274
 sycommon/synacos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/synacos/feign.py,sha256=ghbI2_6g1C5P0EcU8y2DeDZ9E7Mv0T1iHwptLX1U6NA,12075
 sycommon/synacos/nacos_service.py,sha256=8l2qaVg5GQSTybGrcdmg0B5jRNAzbOPM3mjQ6T04A2I,30816
 sycommon/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sycommon/tools/docs.py,sha256=OPj2ETheuWjXLyaXtaZPbwmJKfJaYXV5s4XMVAUNrms,1607
 sycommon/tools/snowflake.py,sha256=rc-VUjBMMpdAvbnHroVwfVt1xzApJbTCthUy9mglAuw,237
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
-sycommon_python_lib-0.1.8.dist-info/METADATA,sha256=p4qDr-4b_hhuTHMi7JMrEyj3vzuITuMY0_IGrNgKSsw,7004
-sycommon_python_lib-0.1.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sycommon_python_lib-0.1.8.dist-info/top_level.txt,sha256=qb-vRf3lrmIaCLrGZxsv6k8Q8l3_lGuAeFtwjh0wYCQ,9
-sycommon_python_lib-0.1.8.dist-info/RECORD,,
+sycommon_python_lib-0.1.10.dist-info/METADATA,sha256=UteBh6HBuWlcC-6wGj2ro9zGDM0f1O5HM39o6yi2jMM,7005
+sycommon_python_lib-0.1.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.10.dist-info/top_level.txt,sha256=qb-vRf3lrmIaCLrGZxsv6k8Q8l3_lGuAeFtwjh0wYCQ,9
+sycommon_python_lib-0.1.10.dist-info/RECORD,,