sycommon-python-lib 0.1.8__tar.gz → 0.1.10__tar.gz

{sycommon_python_lib-0.1.8 → sycommon_python_lib-0.1.10}/PKG-INFO

@@ -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 → sycommon_python_lib-0.1.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.1.8"
+version = "0.1.10"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.10"

sycommon_python_lib-0.1.10/src/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_python_lib-0.1.8 → sycommon_python_lib-0.1.10}/src/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_python_lib-0.1.8 → sycommon_python_lib-0.1.10}/src/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_python_lib-0.1.8 → sycommon_python_lib-0.1.10}/src/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_python_lib-0.1.8 → sycommon_python_lib-0.1.10}/src/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("未设置消息处理函数")