sycommon-python-lib 0.1.29__py3-none-any.whl → 0.1.31__py3-none-any.whl

sycommon/models/mqlistener_config.py

@@ -31,6 +31,7 @@ class RabbitMQListenerConfig(BaseModel):
     durable: bool = Field(True, description="是否持久化")
     auto_delete: bool = Field(False, description="是否自动删除队列")
     auto_parse_json: bool = Field(True, description="是否自动解析JSON消息")
+    prefetch_count: int = Field(2, description="mq同时消费数量")
 
     class Config:
         """模型配置"""

sycommon/rabbitmq/rabbitmq_client.py

@@ -488,7 +488,7 @@ class RabbitMQClient:
                         message,
                         routing_key=routing_key or self.routing_key or '#',
                         mandatory=True,
-                        timeout=5.0
+                        timeout=15.0
                     )
                     if not confirmed:
                         raise Exception("消息未被服务器确认接收")

sycommon/rabbitmq/rabbitmq_service.py

@@ -167,7 +167,7 @@ class RabbitMQService:
                 'max_reconnection_attempts', 5),
             prefetch_count=kwargs.get('prefetch_count', 2),
             consumption_stall_threshold=kwargs.get(
-                'consumption_stall_threshold', 10)
+                'consumption_stall_threshold', 10),
         )
 
         # 使用declare_queue控制是否声明队列（发送器不声明，监听器声明）
@@ -276,7 +276,7 @@ class RabbitMQService:
 
     # 以下方法逻辑与原有保持一致（无需修改）
     @classmethod
-    async def setup_senders(cls, senders: List[RabbitMQSendConfig], has_listeners: bool = False) -> None:
+    async def setup_senders(cls, senders: List[RabbitMQSendConfig], has_listeners: bool = False, ** kwargs) -> None:
         """设置消息发送器"""
         cls._has_senders = True
         cls._has_listeners = has_listeners
@@ -287,6 +287,7 @@ class RabbitMQService:
                 if not sender_config.queue_name:
                     raise ValueError(f"发送器配置第{idx+1}项缺少queue_name")
 
+                prefetch_count = sender_config.prefetch_count
                 queue_name = sender_config.queue_name
                 app_name = cls._config.get(
                     "APP_NAME", "") if cls._config else ""
@@ -315,7 +316,9 @@ class RabbitMQService:
                         auto_delete=sender_config.auto_delete,
                         auto_parse_json=sender_config.auto_parse_json,
                         queue_name=queue_name,
-                        create_if_not_exists=False
+                        create_if_not_exists=False,
+                        prefetch_count=prefetch_count,
+                        ** kwargs
                     )
 
                 # 记录客户端
@@ -334,7 +337,7 @@ class RabbitMQService:
         logger.info(f"消息发送器设置完成，共 {len(cls._sender_client_names)} 个发送器")
 
     @classmethod
-    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False) -> None:
+    async def setup_listeners(cls, listeners: List[RabbitMQListenerConfig], has_senders: bool = False, ** kwargs) -> None:
         """设置消息监听器"""
         cls._has_listeners = True
         cls._has_senders = has_senders

sycommon/services.py

@@ -145,6 +145,12 @@ class Services(metaclass=SingletonMeta):
 
         # 设置发送器，传递是否有监听器的标志
         if rabbitmq_senders:
+            # 判断是否有监听器，如果有遍历监听器列表，队列名一样将prefetch_count属性设置到发送器对象中
+            if rabbitmq_listeners:
+                for sender in rabbitmq_senders:
+                    for listener in rabbitmq_listeners:
+                        if sender.queue_name == listener.queue_name:
+                            sender.prefetch_count = listener.prefetch_count
             await self._setup_senders_async(rabbitmq_senders, has_listeners)
 
         # 设置监听器，传递是否有发送器的标志

sycommon/synacos/example.py

@@ -0,0 +1,153 @@
+from typing import Dict, Any, Optional, List, Union
+
+from sycommon.synacos.param import Body, Cookie, File, Form, Header, Path, Query
+from sycommon.synacos.feign_client import feign_client, feign_request, feign_upload
+
+
+@feign_client(
+    service_name="product-service",
+    path_prefix="/api/v1",
+    default_headers={
+        "User-Agent": "Feign-Client/1.0",
+        "Accept": "application/json"
+    }
+)
+class ProductServiceClient:
+    """商品服务Feign客户端（优化版）"""
+
+    # ------------------------------
+    # 场景1: 基础参数 + 动态Header + Cookie
+    # ------------------------------
+    @feign_request(
+        "GET",
+        "/products/{product_id}/reviews",
+        headers={"X-Request-Source": "mobile"},  # 固定头
+        timeout=10  # 接口级超时（10秒）
+    )
+    async def get_product_reviews(
+        self,
+        product_id: int = Path(..., description="商品ID"),
+        status: Optional[str] = Query(None, description="评价状态"),
+        page: int = Query(1, description="页码"),
+        size: int = Query(10, description="每页条数"),
+        x_auth_token: str = Header(..., description="动态令牌头"),  # 动态头
+        session_id: str = Cookie(..., description="会话Cookie")  # Cookie
+    ) -> Dict[str, Any]:
+        """获取商品评价列表"""
+        pass
+
+    # ------------------------------
+    # 场景2: 仅Query参数（默认不超时）
+    # ------------------------------
+    @feign_request("GET", "/products")  # 未指定timeout，使用客户端默认（不超时）
+    async def search_products(
+        self,
+        category: str = Query(..., description="商品分类"),
+        min_price: Optional[float] = Query(None, description="最低价格"),
+        max_price: Optional[float] = Query(None, description="最高价格"),
+        sort: str = Query("created_desc", description="排序方式")
+    ) -> Dict[str, Any]:
+        """搜索商品"""
+        pass
+
+    # ------------------------------
+    # 场景3: JSON请求体 + 动态签名头
+    # （通过Header参数传递动态生成的签名）
+    # ------------------------------
+    @feign_request(
+        "POST",
+        "/products",
+        headers={"s-y-version": "2.1"},
+        timeout=15  # 15秒超时
+    )
+    async def create_product(
+        self,
+        product_data: Dict[str, Any] = Body(..., description="商品信息"),
+        x_signature: str = Header(..., description="动态生成的签名头")  # 签名头
+    ) -> Dict[str, Any]:
+        """创建商品（动态签名通过Header参数传递）"""
+        pass
+
+    # ------------------------------
+    # 场景4: 文件上传 + 分片上传头
+    # ------------------------------
+    @feign_upload(field_name="image_file")
+    @feign_request(
+        "POST",
+        "/products/{product_id}/images",
+        headers={"X-Upload-Type": "product-image"},
+        timeout=60  # 上传超时60秒
+    )
+    async def upload_product_image(
+        self,
+        product_id: int = Path(..., description="商品ID"),
+        file_paths: Union[str, List[str]] = File(..., description="文件路径"),
+        image_type: str = Form(..., description="图片类型"),
+        is_primary: bool = Form(False, description="是否主图"),
+        x_chunked: bool = Header(False, description="是否分片上传")  # 分片上传头
+    ) -> Dict[str, Any]:
+        """上传商品图片（支持分片上传标记）"""
+        pass
+
+    # ------------------------------
+    # 场景5: 表单提交 + 操作时间头
+    # ------------------------------
+    @feign_request(
+        "POST",
+        "/products/batch-status",
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        timeout=5
+    )
+    async def batch_update_status(
+        self,
+        product_ids: str = Form(..., description="商品ID列表"),
+        status: str = Form(..., description="目标状态"),
+        operator: str = Form(..., description="操作人"),
+        x_operate_time: str = Header(..., description="操作时间戳头")  # 动态时间头
+    ) -> Dict[str, Any]:
+        """批量更新商品状态"""
+        pass
+
+
+# ------------------------------
+# 2. 完整调用示例（含Session和Header用法）
+# ------------------------------
+async def feign_advanced_demo():
+    client = ProductServiceClient()
+
+    # 场景1: 动态Header和Cookie
+    reviews = await client.get_product_reviews(
+        product_id=10086,
+        status="APPROVED",
+        x_auth_token="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",  # 动态令牌
+        session_id="sid_123456"  # Cookie
+    )
+    print(f"场景1 - 评价数: {reviews.get('total', 0)}")
+
+    # 场景3: 动态生成签名头（直接通过Header参数传递）
+    import hashlib
+    product_data = {
+        "name": "无线蓝牙耳机",
+        "price": 299.99,
+        "stock": 500
+    }
+    # 生成签名（业务逻辑）
+    sign_str = f"{product_data['name']}_{product_data['price']}_secret"
+    signature = hashlib.md5(sign_str.encode()).hexdigest()
+    # 传递签名头
+    new_product = await client.create_product(
+        product_data=product_data,
+        x_signature=signature  # 动态签名通过Header参数传入
+    )
+    print(f"场景3 - 商品ID: {new_product.get('id')}")
+
+    # 场景4: 分片上传（通过x_chunked头控制）
+    product_id = new_product.get('id')
+    if product_id:
+        upload_result = await client.upload_product_image(
+            product_id=product_id,
+            file_paths=["/tmp/main.jpg", "/tmp/detail.jpg"],
+            image_type="detail",
+            x_chunked=True  # 启用分片上传
+        )
+        print(f"场景4 - 上传图片数: {len(upload_result.get('image_urls', []))}")

sycommon/synacos/example2.py

@@ -0,0 +1,129 @@
+from pydantic import BaseModel, Field
+from typing import Any, Optional, List, Dict
+
+from sycommon.synacos.feign_client import feign_client, feign_request
+from sycommon.synacos.param import Body, Form, Query
+
+
+# ------------------------------
+# 请求模型（req）
+# ------------------------------
+class ProductCreateReq(BaseModel):
+    """创建商品的请求模型"""
+    name: str = Field(..., description="商品名称")
+    category: str = Field(..., description="商品分类")
+    price: float = Field(..., gt=0, description="商品价格（必须>0）")
+    stock: int = Field(..., ge=0, description="库存（必须>=0）")
+    attributes: Optional[Dict[str, str]] = Field(None, description="商品属性")
+
+
+class BatchUpdateStatusReq(BaseModel):
+    """批量更新状态的请求模型（表单提交）"""
+    product_ids: str = Field(..., description="商品ID列表（逗号分隔）")
+    status: str = Field(..., description="目标状态（如ON_SALE/OFF_SALE）")
+    operator: str = Field(..., description="操作人")
+
+
+# ------------------------------
+# 响应模型（resp）
+# ------------------------------
+class ProductResp(BaseModel):
+    """商品详情响应模型"""
+    id: int = Field(..., description="商品ID")
+    name: str = Field(..., description="商品名称")
+    category: str = Field(..., description="分类")
+    price: float = Field(..., description="价格")
+    stock: int = Field(..., description="库存")
+    created_at: str = Field(..., description="创建时间")
+
+
+class PageResp(BaseModel):
+    """分页响应模型"""
+    total: int = Field(..., description="总条数")
+    items: List[ProductResp] = Field(..., description="商品列表")
+    page: int = Field(..., description="当前页码")
+    size: int = Field(..., description="每页条数")
+
+
+@feign_client(
+    service_name="product-service",
+    path_prefix="/api/v2",
+    default_headers={"Accept": "application/json"}
+)
+class ProductServiceClient:
+    # ------------------------------
+    # 场景1: Pydantic 作为请求体（Body）
+    # ------------------------------
+    @feign_request("POST", "/products", timeout=15)
+    async def create_product(
+        self,
+        # 使用 Pydantic 模型作为请求体
+        product: ProductCreateReq = Body(..., description="商品信息")
+    ) -> ProductResp:  # 响应自动解析为 ProductResp 模型
+        """创建商品（Pydantic请求体 + Pydantic响应）"""
+        pass
+
+    # ------------------------------
+    # 场景2: Pydantic 作为表单参数（Form）
+    # ------------------------------
+    @feign_request(
+        "POST",
+        "/products/batch-status",
+        headers={"Content-Type": "application/x-www-form-urlencoded"},
+        timeout=5
+    )
+    async def batch_update_status(
+        self,
+        # 使用 Pydantic 模型作为表单参数
+        update_data: BatchUpdateStatusReq = Form(..., description="批量更新信息")
+    ) -> Dict[str, Any]:  # 普通字典响应
+        """批量更新商品状态（Pydantic表单）"""
+        pass
+
+    # ------------------------------
+    # 场景3: 响应为分页模型（嵌套Pydantic）
+    # ------------------------------
+    @feign_request("GET", "/products", timeout=10)
+    async def search_products(
+        self,
+        category: str = Query(..., description="商品分类"),
+        page: int = Query(1, description="页码"),
+        size: int = Query(10, description="每页条数")
+    ) -> PageResp:  # 响应自动解析为 PageResp（嵌套 ProductResp）
+        """搜索商品（Pydantic分页响应）"""
+        pass
+
+
+async def pydantic_feign_demo():
+    client = ProductServiceClient()
+
+    # 场景1: 创建商品（Pydantic请求体 + 响应）
+    create_req = ProductCreateReq(
+        name="无线蓝牙耳机",
+        category="electronics",
+        price=299.99,
+        stock=500,
+        attributes={"brand": "Feign", "battery_life": "24h"}
+    )
+    product = await client.create_product(product=create_req)
+    # 直接使用 Pydantic 模型的属性
+    print(f"创建商品: ID={product.id}, 名称={product.name}, 价格={product.price}")
+
+    # 场景2: 批量更新（Pydantic表单）
+    batch_req = BatchUpdateStatusReq(
+        product_ids=f"{product.id},1002,1003",
+        status="ON_SALE",
+        operator="system"
+    )
+    batch_result = await client.batch_update_status(update_data=batch_req)
+    print(f"批量更新成功: {batch_result.get('success_count')}个")
+
+    # 场景3: 搜索商品（Pydantic分页响应）
+    page_resp = await client.search_products(
+        category="electronics",
+        page=1,
+        size=10
+    )
+    # 分页模型的属性和嵌套列表
+    print(
+        f"搜索结果: 共{page_resp.total}条，第1页商品: {[p.name for p in page_resp.items]}")

sycommon/synacos/feign.py

@@ -1,8 +1,6 @@
 import io
 import os
 import time
-import inspect
-from urllib.parse import urljoin
 
 import aiohttp
 from sycommon.logging.kafka_log import SYLogger
@@ -14,430 +12,6 @@ from sycommon.synacos.nacos_service import NacosService
     方式二: 使用 feign 函数
 """
 
-# 示例Feign客户端接口
-# 1. 定义完整的Feign客户端接口
-# @feign_client(service_name="product-service", path_prefix="/api/v2")
-# class ProductServiceClient:
-#     """商品服务Feign客户端示例，涵盖所有参数类型"""
-#
-#     # ------------------------------
-#     # 场景1: Path参数 + Query参数
-#     # 请求示例: GET /products/{product_id}/reviews?status=APPROVED&page=1&size=10
-#     # ------------------------------
-#     @feign_request("GET", "/products/{product_id}/reviews")
-#     async def get_product_reviews(
-#         self,
-#         product_id: int,  # Path参数 (URL路径中的占位符)
-#         status: Optional[str] = None,  # Query参数 (URL查询字符串)
-#         page: int = 1,  # Query参数 (默认值)
-#         size: int = 10  # Query参数 (默认值)
-#     ) -> Dict[str, Any]:
-#         """获取商品评价列表"""
-#         pass
-#
-#     # ------------------------------
-#     # 场景2: 仅Query参数
-#     # 请求示例: GET /products?category=electronics&min_price=100&max_price=500&sort=price_asc
-#     # ------------------------------
-#     @feign_request("GET", "/products")
-#     async def search_products(
-#         self,
-#         category: str,  # 必选Query参数
-#         min_price: Optional[float] = None,  # 可选Query参数
-#         max_price: Optional[float] = None,  # 可选Query参数
-#         sort: str = "created_desc"  # 带默认值的Query参数
-#     ) -> Dict[str, Any]:
-#         """搜索商品（仅查询参数）"""
-#         pass
-#
-#     # ------------------------------
-#     # 场景3: JSON Body参数 (POST)
-#     # 请求示例: POST /products (请求体为JSON)
-#     # ------------------------------
-#     @feign_request("POST", "/products", headers={"s-y-version": "2.1"})
-#     async def create_product(
-#         self,
-#         product_data: Dict[str, Any]  # JSON请求体
-#     ) -> Dict[str, Any]:
-#         """创建商品（JSON请求体）"""
-#         pass
-#
-#     # ------------------------------
-#     # 场景4: Path参数 + JSON Body (PUT)
-#     # 请求示例: PUT /products/{product_id} (请求体为JSON)
-#     # ------------------------------
-#     @feign_request("PUT", "/products/{product_id}")
-#     async def update_product(
-#         self,
-#         product_id: int,  # Path参数
-#         update_data: Dict[str, Any]  # JSON请求体
-#     ) -> Dict[str, Any]:
-#         """更新商品信息"""
-#         pass
-#
-#     # ------------------------------
-#     # 场景5: FormData表单提交 (x-www-form-urlencoded)
-#     # 请求示例: POST /products/batch-status (表单字段)
-#     # ------------------------------
-#     @feign_request(
-#         "POST",
-#         "/products/batch-status",
-#         headers={"Content-Type": "application/x-www-form-urlencoded"}
-#     )
-#     async def batch_update_status(
-#         self,
-#         product_ids: str,  # 表单字段 (多个ID用逗号分隔)
-#         status: str,  # 表单字段 (目标状态)
-#         operator: str  # 表单字段 (操作人)
-#     ) -> Dict[str, Any]:
-#         """批量更新商品状态（表单提交）"""
-#         pass
-#
-#     # ------------------------------
-#     # 场景6: 多文件上传 + 表单字段混合
-#     # 请求示例: POST /products/{product_id}/images (multipart/form-data)
-#     # 支持同时上传多个文件，共用字段名 "image_file"
-#     # ------------------------------
-#     @feign_upload(field_name="image_file")  # 指定所有文件的表单字段名
-#     @feign_request("POST", "/products/{product_id}/images")
-#     async def upload_product_image(
-#         self,
-#         product_id: int,  # Path参数（URL路径中的占位符）
-#         file_paths: str | list[str],  # 本地文件路径（单个路径字符串或多个路径列表）
-#         image_type: str,  # 表单字段（图片类型，如"main"、"detail"）
-#         is_primary: bool = False,  # 表单字段（是否主图）
-#         remark: Optional[str] = None  # 可选表单字段（备注信息）
-#     ) -> Dict[str, Any]:
-#         """上传商品图片（支持多文件 + 表单字段混合）"""
-#         pass
-#
-#     # ------------------------------
-#     # 场景7: 多Path参数 + DELETE请求
-#     # 请求示例: DELETE /products/{product_id}/skus/{sku_id}
-#     # ------------------------------
-#     @feign_request("DELETE", "/products/{product_id}/skus/{sku_id}")
-#     async def delete_product_sku(
-#         self,
-#         product_id: int,  # Path参数1
-#         sku_id: int  # Path参数2
-#     ) -> Dict[str, Any]:
-#         """删除商品SKU（多路径参数）"""
-#         pass
-#
-#     # ------------------------------
-#     # 场景8: 复杂JSON Body + Query参数
-#     # 请求示例: POST /products/filter?include_out_of_stock=false
-#     # ------------------------------
-#     @feign_request("POST", "/products/filter")
-#     async def advanced_filter(
-#         self,
-#         filter_condition: Dict[str, Any],  # JSON请求体（复杂筛选条件）
-#         include_out_of_stock: bool = False,  # Query参数
-#         page: int = 1,  # Query参数
-#         size: int = 20  # Query参数
-#     ) -> Dict[str, Any]:
-#         """高级筛选商品（JSON体+查询参数）"""
-#         pass
-#
-#
-# # 2. 完整调用示例
-# async def feign_complete_demo():
-#     # ------------------------------
-#     # 调用场景1: Path参数 + Query参数
-#     # ------------------------------
-#     reviews = await ProductServiceClient().get_product_reviews(
-#         product_id=10086,  # Path参数
-#         status="APPROVED",  # Query参数
-#         page=1,
-#         size=20
-#     )
-#     print(f"场景1 - 商品评价: {reviews.get('total', 0)}条评价")
-#
-#     # ------------------------------
-#     # 调用场景2: 仅Query参数
-#     # ------------------------------
-#     electronics = await ProductServiceClient().search_products(
-#         category="electronics",  # 必选Query
-#         min_price=1000,
-#         max_price=5000,
-#         sort="price_asc"
-#     )
-#     print(f"场景2 - 搜索结果: {len(electronics.get('items', []))}个商品")
-#
-#     # ------------------------------
-#     # 调用场景3: JSON Body参数 (POST)
-#     # ------------------------------
-#     new_product = await ProductServiceClient().create_product({
-#         "name": "无线蓝牙耳机",
-#         "category": "electronics",
-#         "price": 299.99,
-#         "stock": 500,
-#         "attributes": {
-#             "brand": "Feign",
-#             "battery_life": "24h"
-#         }
-#     })
-#     print(f"场景3 - 新建商品: ID={new_product.get('id')}")
-#     product_id = new_product.get('id')  # 用于后续示例
-#
-#     # ------------------------------
-#     # 调用场景4: Path参数 + JSON Body (PUT)
-#     # ------------------------------
-#     if product_id:
-#         updated = await ProductServiceClient().update_product(
-#             product_id=product_id,
-#             update_data={
-#                 "price": 279.99,  # 降价
-#                 "stock": 600
-#             }
-#         )
-#         print(f"场景4 - 商品更新: 状态={updated.get('success')}")
-#
-#     # ------------------------------
-#     # 调用场景5: FormData表单提交
-#     # ------------------------------
-#     batch_result = await ProductServiceClient().batch_update_status(
-#         product_ids="1001,1002,1003",  # 多个ID用逗号分隔
-#         status="ON_SALE",
-#         operator="system"
-#     )
-#     print(f"场景5 - 批量更新: 成功{batch_result.get('success_count')}个")
-#
-#     # ------------------------------
-#     # 调用场景6: 多文件上传 + 表单字段
-#     # 支持两种调用方式：单文件上传 / 多文件上传
-#     # ------------------------------
-#     if product_id:
-#         single_upload_result = await ProductServiceClient().upload_product_image(
-#             product_id=product_id,
-#             file_paths="/tmp/product_main.jpg",  # 单个文件路径或多个路径[""]
-#             image_type="main",
-#             is_primary=True,
-#             remark="商品主图（单文件）"
-#         )
-#         print(f"场景6 - 单文件上传: 主图URL={single_upload_result.get('image_urls')[0]}")
-#
-#     # ------------------------------
-#     # 调用场景7: 多Path参数 + DELETE
-#     # ------------------------------
-#     delete_result = await ProductServiceClient().delete_product_sku(
-#         product_id=10086,
-#         sku_id=5001
-#     )
-#     print(f"场景7 - 删除SKU: {delete_result.get('message')}")
-#
-#     # ------------------------------
-#     # 调用场景8: 复杂JSON Body + Query参数
-#     # ------------------------------
-#     filtered = await ProductServiceClient().advanced_filter(
-#         filter_condition={  # 复杂JSON条件
-#             "categories": ["electronics", "home"],
-#             "price_range": {"min": 500, "max": 3000},
-#             "tags": ["new", "promotion"]
-#         },
-#         include_out_of_stock=False,  # Query参数
-#         page=1,
-#         size=10
-#     )
-#     print(f"场景8 - 高级筛选: {filtered.get('total')}个匹配商品")
-
-
-def feign_client(service_name: str, path_prefix: str = "", default_timeout: float | None = None):
-    """Feign客户端装饰器，每次请求后自动关闭会话"""
-    def decorator(cls):
-        class FeignWrapper:
-            def __init__(self):
-                self.service_name = service_name
-                self.path_prefix = path_prefix
-                self.default_timeout = default_timeout
-                self.nacos_manager = None  # 延迟初始化Nacos
-                self.session = None  # 延迟初始化aiohttp会话
-
-            def __getattr__(self, name):
-                """动态获取方法并包装为Feign调用，请求后自动关闭会话"""
-                func = getattr(cls, name)
-
-                async def wrapper(*args, **kwargs):
-                    # 确保会话初始化
-                    if self.session is None:
-                        self.session = aiohttp.ClientSession()
-                    if self.nacos_manager is None:
-                        self.nacos_manager = NacosService(None)
-
-                    try:
-                        # 1. 解析参数
-                        sig = inspect.signature(func)
-                        param_names = list(sig.parameters.keys())
-                        try:
-                            if param_names and param_names[0] == 'self':
-                                bound_args = sig.bind(self, *args, **kwargs)
-                            else:
-                                bound_args = sig.bind(*args, **kwargs)
-                            bound_args.apply_defaults()
-                            params = dict(bound_args.arguments)
-                            params.pop('self', None)
-                            SYLogger.debug(f"解析参数: {params}")
-                        except TypeError as e:
-                            SYLogger.error(f"参数绑定失败: {str(e)}")
-                            raise
-
-                        # 2. 构建请求
-                        request_meta = getattr(func, "_feign_meta", {})
-                        method = request_meta.get("method", "GET")
-                        path = request_meta.get("path", "")
-                        headers = request_meta.get("headers", {}).copy()
-                        timeout = kwargs.pop('timeout', self.default_timeout)
-
-                        full_path = f"{self.path_prefix}{path}"
-                        for param_name, param_value in params.items():
-                            if param_value is not None:
-                                full_path = full_path.replace(
-                                    f"{{{param_name}}}", str(param_value))
-
-                        is_json_request = method.upper() in ["POST", "PUT", "PATCH"] and \
-                            not request_meta.get("is_upload", False)
-                        if is_json_request and "Content-Type" not in headers:
-                            headers["Content-Type"] = "application/json"
-
-                        # 3. 服务发现
-                        version = headers.get('s-y-version')
-                        instances = self.nacos_manager.get_service_instances(
-                            self.service_name, target_version=version)
-                        if not instances:
-                            raise RuntimeError(
-                                f"未找到服务 {self.service_name} 的健康实例")
-
-                        instance = instances[int(time.time()) % len(instances)]
-                        base_url = f"http://{instance['ip']}:{instance['port']}"
-                        url = urljoin(base_url, full_path)
-                        SYLogger.info(f"请求: {method} {url}")
-
-                        # 4. 准备请求参数
-                        query_params = {k: v for k, v in params.items()
-                                        if f"{{{k}}}" not in path and v is not None}
-                        request_data = None
-                        files = None
-
-                        if request_meta.get("is_upload", False):
-                            files = aiohttp.FormData()
-                            file_path = params.get('file_path')
-                            if file_path and os.path.exists(file_path):
-                                file_field = request_meta.get(
-                                    "upload_field", "file")
-                                with open(file_path, 'rb') as f:
-                                    files.add_field(
-                                        file_field,
-                                        f.read(),
-                                        filename=os.path.basename(file_path)
-                                    )
-                            for key, value in params.items():
-                                if key != 'file_path' and value is not None:
-                                    files.add_field(key, str(value))
-                            headers.pop('Content-Type', None)
-                        elif is_json_request:
-                            body_params = [k for k in params if k not in query_params
-                                           and f"{{{k}}}" not in path]
-                            if body_params:
-                                request_data = params[body_params[0]] if len(body_params) == 1 else \
-                                    {k: params[k] for k in body_params}
-
-                        # 5. 发送请求并获取响应
-                        async with self.session.request(
-                            method=method,
-                            url=url,
-                            headers=headers,
-                            params=query_params,
-                            json=request_data if not files else None,
-                            data=files,
-                            timeout=timeout
-                        ) as response:
-                            return await self._handle_response(response)
-
-                    finally:
-                        # 请求完成后自动关闭会话
-                        if self.session:
-                            await self.session.close()
-                            self.session = None  # 重置会话，下次调用重新创建
-                            SYLogger.info(
-                                f"自动关闭aiohttp会话: {self.service_name}")
-
-                return wrapper
-
-            async def _handle_response(self, response):
-                """处理响应结果（保持不变）"""
-                status = response.status
-                if 200 <= status < 300:
-                    content_type = response.headers.get('Content-Type', '')
-                    if 'application/json' in content_type:
-                        return await response.json()
-                    else:
-                        return await response.read()
-                else:
-                    error_msg = await response.text()
-                    SYLogger.error(f"响应错误: {status} - {error_msg}")
-                    raise RuntimeError(f"HTTP {status}: {error_msg}")
-
-        return FeignWrapper
-    return decorator
-
-
-def feign_request(method: str, path: str, headers: dict = None):
-    """定义请求元数据的装饰器"""
-    def decorator(func):
-        func._feign_meta = {
-            "method": method.upper(),
-            "path": path,
-            "headers": headers.copy() if headers else {}
-        }
-        return func
-    return decorator
-
-
-def feign_upload(field_name: str = "file"):
-    """处理多文件上传的装饰器（支持同字段名多文件 + 表单字段混合）"""
-    def decorator(func):
-        async def wrapper(*args, **kwargs):
-            # 获取文件路径列表（支持单个文件路径字符串或多个文件路径列表）
-            file_paths = kwargs.get('file_paths')
-            if not file_paths:
-                raise ValueError("缺少文件路径参数: file_paths（可为单个路径字符串或列表）")
-
-            # 统一转为列表格式（兼容单个文件的情况）
-            if isinstance(file_paths, str):
-                file_paths = [file_paths]
-            if not isinstance(file_paths, list):
-                raise ValueError("file_paths 必须是字符串或列表")
-
-            # 验证所有文件是否存在
-            for path in file_paths:
-                if not os.path.exists(path):
-                    raise FileNotFoundError(f"文件不存在: {path}")
-
-            # 构建 multipart/form-data 表单数据
-            form_data = aiohttp.FormData()
-
-            # 添加所有文件（共用同一个 field_name）
-            for file_path in file_paths:
-                with open(file_path, 'rb') as f:
-                    form_data.add_field(
-                        field_name,  # 所有文件使用相同的表单字段名
-                        f.read(),
-                        filename=os.path.basename(file_path)  # 保留原文件名
-                    )
-
-            # 添加其他表单字段（从 kwargs 中提取非文件参数）
-            form_fields = {k: v for k, v in kwargs.items() if k !=
-                           'file_paths'}
-            for key, value in form_fields.items():
-                if value is not None:
-                    form_data.add_field(key, str(value))  # 表单字段转为字符串
-
-            # 将构建好的表单数据传入原函数
-            kwargs['form_data'] = form_data
-            return await func(*args, **kwargs)
-        return wrapper
-    return decorator
-
 
 async def feign(service_name, api_path, method='GET', params=None, headers=None, file_path=None,
                 path_params=None, body=None, files=None, form_data=None, timeout=None):

sycommon/synacos/feign_client.py

@@ -0,0 +1,317 @@
+import io
+import os
+import time
+import inspect
+from typing import Any, Dict, Optional, Literal, Type, TypeVar
+from urllib.parse import urljoin
+
+import aiohttp
+from pydantic import BaseModel
+from sycommon.synacos.param import Body, Cookie, File, Form, Header, Param, Path, Query
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.synacos.nacos_service import NacosService
+
+# 定义 Pydantic 模型泛型（用于响应解析）
+T = TypeVar('T', bound=BaseModel)
+
+# ------------------------------
+# Feign客户端装饰器（支持Pydantic）
+# ------------------------------
+
+
+def feign_client(
+    service_name: str,
+    path_prefix: str = "",
+    default_timeout: Optional[float] = None,
+    default_headers: Optional[Dict[str, str]] = None
+):
+    default_headers = default_headers or {}
+
+    def decorator(cls):
+        class FeignClient:
+            def __init__(self):
+                self.service_name = service_name
+                self.path_prefix = path_prefix
+                self.default_timeout = default_timeout
+                self.default_headers = default_headers.copy()
+                self.nacos_manager: Optional[NacosService] = None
+                self.session: Optional[aiohttp.ClientSession] = None
+
+            def __getattr__(self, name: str):
+                if not hasattr(cls, name):
+                    raise AttributeError(f"类 {cls.__name__} 不存在方法 {name}")
+
+                func = getattr(cls, name)
+                sig = inspect.signature(func)
+                param_meta = self._parse_param_meta(sig)
+                # 获取响应模型（从返回类型注解中提取 Pydantic 模型）
+                resp_model = self._get_response_model(sig)
+
+                async def wrapper(*args, **kwargs) -> Any:
+                    if not self.session:
+                        self.session = aiohttp.ClientSession()
+                    if not self.nacos_manager:
+                        self.nacos_manager = NacosService(None)
+
+                    try:
+                        bound_args = self._bind_arguments(
+                            func, sig, args, kwargs)
+                        self._validate_required_params(param_meta, bound_args)
+
+                        request_meta = getattr(func, "_feign_meta", {})
+                        method = request_meta.get("method", "GET").upper()
+                        path = request_meta.get("path", "")
+                        is_upload = request_meta.get("is_upload", False)
+                        method_headers = request_meta.get("headers", {})
+                        timeout = request_meta.get(
+                            "timeout", self.default_timeout)
+
+                        headers = self._build_headers(
+                            param_meta, bound_args, method_headers)
+                        full_path = f"{self.path_prefix}{path}"
+                        full_path = self._replace_path_params(
+                            full_path, param_meta, bound_args)
+
+                        base_url = await self._get_service_base_url(headers)
+                        url = urljoin(base_url, full_path)
+                        SYLogger.info(f"请求: {method} {url}")
+
+                        query_params = self._get_query_params(
+                            param_meta, bound_args)
+                        cookies = self._get_cookies(param_meta, bound_args)
+                        # 处理请求数据（支持 Pydantic 模型转字典）
+                        request_data = await self._get_request_data(
+                            method, param_meta, bound_args, is_upload, method_headers
+                        )
+
+                        async with self.session.request(
+                            method=method,
+                            url=url,
+                            headers=headers,
+                            params=query_params,
+                            cookies=cookies,
+                            json=request_data if not (is_upload or isinstance(
+                                request_data, aiohttp.FormData)) else None,
+                            data=request_data if is_upload or isinstance(
+                                request_data, aiohttp.FormData) else None,
+                            timeout=timeout
+                        ) as response:
+                            # 处理响应（支持 Pydantic 模型解析）
+                            return await self._handle_response(response, resp_model)
+
+                    finally:
+                        if self.session:
+                            await self.session.close()
+                            self.session = None
+
+                return wrapper
+
+            def _parse_param_meta(self, sig: inspect.Signature) -> Dict[str, Param]:
+                param_meta = {}
+                for param in sig.parameters.values():
+                    if param.name == "self":
+                        continue
+                    if isinstance(param.default, Param):
+                        param_meta[param.name] = param.default
+                    else:
+                        if param.default == inspect.Parameter.empty:
+                            param_meta[param.name] = Query(..., description="")
+                        else:
+                            param_meta[param.name] = Query(
+                                param.default, description="")
+                return param_meta
+
+            def _get_response_model(self, sig: inspect.Signature) -> Optional[Type[BaseModel]]:
+                """从函数返回类型注解中提取 Pydantic 模型"""
+                return_annotation = sig.return_annotation
+                # 支持直接注解（如 -> ProductResp）或 Optional（如 -> Optional[ProductResp]）
+                if hasattr(return_annotation, '__origin__') and return_annotation.__origin__ is Optional:
+                    return_annotation = return_annotation.__args__[0]
+                # 检查是否为 Pydantic 模型
+                if inspect.isclass(return_annotation) and issubclass(return_annotation, BaseModel):
+                    return return_annotation
+                return None
+
+            def _bind_arguments(self, func, sig: inspect.Signature, args, kwargs) -> Dict[str, Any]:
+                try:
+                    bound_args = sig.bind(*args, **kwargs)
+                    bound_args.apply_defaults()
+                    return {k: v for k, v in bound_args.arguments.items() if k != "self"}
+                except TypeError as e:
+                    SYLogger.error(f"参数绑定失败 [{func.__name__}]: {str(e)}")
+                    raise
+
+            def _validate_required_params(self, param_meta: Dict[str, Param], bound_args: Dict[str, Any]):
+                missing = [
+                    meta.get_key(name) for name, meta in param_meta.items()
+                    if meta.is_required() and name not in bound_args
+                ]
+                if missing:
+                    raise ValueError(f"缺少必填参数: {', '.join(missing)}")
+
+            def _build_headers(self, param_meta: Dict[str, Param], bound_args: Dict[str, Any], method_headers: Dict[str, str]) -> Dict[str, str]:
+                headers = self.default_headers.copy()
+                headers.update(method_headers)
+                for name, meta in param_meta.items():
+                    if isinstance(meta, Header) and name in bound_args:
+                        value = bound_args[name]
+                        if value is not None:
+                            headers[meta.get_key(name)] = str(value)
+                return headers
+
+            def _replace_path_params(self, path: str, param_meta: Dict[str, Param], bound_args: Dict[str, Any]) -> str:
+                for name, meta in param_meta.items():
+                    if isinstance(meta, Path) and name in bound_args:
+                        path = path.replace(
+                            f"{{{meta.get_key(name)}}}", str(bound_args[name]))
+                return path
+
+            def _get_query_params(self, param_meta: Dict[str, Param], bound_args: Dict[str, Any]) -> Dict[str, str]:
+                return {
+                    param_meta[name].get_key(name): str(value)
+                    for name, value in bound_args.items()
+                    if isinstance(param_meta.get(name), Query) and value is not None
+                }
+
+            def _get_cookies(self, param_meta: Dict[str, Param], bound_args: Dict[str, Any]) -> Dict[str, str]:
+                return {
+                    param_meta[name].get_key(name): str(value)
+                    for name, value in bound_args.items()
+                    if isinstance(param_meta.get(name), Cookie) and value is not None
+                }
+
+            async def _get_request_data(
+                self,
+                method: str,
+                param_meta: Dict[str, Param],
+                bound_args: Dict[str, Any],
+                is_upload: bool,
+                method_headers: Dict[str, str]
+            ) -> Any:
+                """处理请求数据（支持 Pydantic 模型转字典）"""
+                if is_upload:
+                    form_data = aiohttp.FormData()
+                    # 处理文件
+                    file_params = {
+                        n: m for n, m in param_meta.items() if isinstance(m, File)}
+                    for name, meta in file_params.items():
+                        if name not in bound_args:
+                            continue
+                        file_paths = bound_args[name]
+                        file_paths = [file_paths] if isinstance(
+                            file_paths, str) else file_paths
+                        for path in file_paths:
+                            if not os.path.exists(path):
+                                raise FileNotFoundError(f"文件不存在: {path}")
+                            with open(path, "rb") as f:
+                                form_data.add_field(
+                                    meta.field_name, f.read(), filename=os.path.basename(path)
+                                )
+                    # 处理表单字段（支持 Pydantic 模型）
+                    form_params = {
+                        n: m for n, m in param_meta.items() if isinstance(m, Form)}
+                    for name, meta in form_params.items():
+                        if name not in bound_args or bound_args[name] is None:
+                            continue
+                        value = bound_args[name]
+                        # 若为 Pydantic 模型，转为字典
+                        if isinstance(value, BaseModel):
+                            value = value.dict()
+                        form_data.add_field(meta.get_key(name), str(
+                            value) if not isinstance(value, dict) else value)
+                    return form_data
+
+                # 处理表单提交（x-www-form-urlencoded）
+                content_type = self.default_headers.get(
+                    "Content-Type") or method_headers.get("Content-Type", "")
+                if "application/x-www-form-urlencoded" in content_type:
+                    form_data = {}
+                    for name, value in bound_args.items():
+                        meta = param_meta.get(name)
+                        if isinstance(meta, Form) and value is not None:
+                            # Pydantic 模型转字典
+                            if isinstance(value, BaseModel):
+                                value = value.dict()
+                            form_data[meta.get_key(name)] = str(
+                                value) if not isinstance(value, dict) else value
+                    return form_data
+
+                # 处理 JSON 请求体（支持 Pydantic 模型）
+                if method in ["POST", "PUT", "PATCH", "DELETE"]:
+                    body_params = [
+                        name for name, meta in param_meta.items() if isinstance(meta, Body)]
+                    if body_params:
+                        body_data = {}
+                        for name in body_params:
+                            meta = param_meta[name]
+                            value = bound_args.get(name)
+                            if value is None:
+                                continue
+                            # 若为 Pydantic 模型，转为字典
+                            if isinstance(value, BaseModel):
+                                value = value.dict()
+                            if meta.embed:
+                                body_data[meta.get_key(name)] = value
+                            else:
+                                body_data = value if not isinstance(value, dict) else {
+                                    ** body_data, **value}
+                        return body_data
+                return None
+
+            async def _get_service_base_url(self, headers: Dict[str, str]) -> str:
+                version = headers.get("s-y-version")
+                instances = self.nacos_manager.get_service_instances(
+                    self.service_name, target_version=version)
+                if not instances:
+                    raise RuntimeError(f"服务 [{self.service_name}] 无可用实例")
+                return f"http://{instances[int(time.time()) % len(instances)]['ip']}:{instances[0]['port']}"
+
+            async def _handle_response(self, response: aiohttp.ClientResponse, resp_model: Optional[Type[BaseModel]]) -> Any:
+                """处理响应（支持 Pydantic 模型解析）"""
+                status = response.status
+                if 200 <= status < 300:
+                    content_type = response.headers.get("Content-Type", "")
+                    if "application/json" in content_type:
+                        json_data = await response.json()
+                        # 若指定了 Pydantic 响应模型，自动解析
+                        if resp_model is not None:
+                            return resp_model(** json_data)  # 用响应数据初始化模型
+                        return json_data
+                    else:
+                        return io.BytesIO(await response.read())
+                else:
+                    error_msg = await response.text()
+                    SYLogger.error(f"请求失败 [{status}]: {error_msg}")
+                    raise RuntimeError(f"HTTP {status}: {error_msg}")
+
+        return FeignClient
+
+    return decorator
+
+
+def feign_request(
+    method: Literal["GET", "POST", "PUT", "DELETE", "PATCH"],
+    path: str,
+    headers: Optional[Dict[str, str]] = None,
+    timeout: Optional[float] = None
+):
+    def decorator(func):
+        func._feign_meta = {
+            "method": method.upper(),
+            "path": path,
+            "headers": headers.copy() if headers else {},
+            "is_upload": False,
+            "timeout": timeout
+        }
+        return func
+    return decorator
+
+
+def feign_upload(field_name: str = "file"):
+    def decorator(func):
+        if not hasattr(func, "_feign_meta"):
+            raise ValueError("feign_upload必须与feign_request一起使用")
+        func._feign_meta["is_upload"] = True
+        func._feign_meta["upload_field"] = field_name
+        return func
+    return decorator

sycommon/synacos/param.py

@@ -0,0 +1,75 @@
+from typing import Any, Optional
+
+# ------------------------------
+# 参数类型标记类（兼容 Pydantic）
+# ------------------------------
+
+
+class Param:
+    """基础参数元信息类"""
+
+    def __init__(
+        self,
+        default: Any = ...,
+        description: str = "",
+        alias: Optional[str] = None,
+        deprecated: bool = False
+    ):
+        self.default = default  # ... 表示必填
+        self.description = description
+        self.alias = alias
+        self.deprecated = deprecated
+
+    def is_required(self) -> bool:
+        return self.default is ...
+
+    def get_key(self, param_name: str) -> str:
+        return self.alias if self.alias is not None else param_name
+
+
+class Path(Param):
+    """路径参数"""
+    pass
+
+
+class Query(Param):
+    """查询参数"""
+    pass
+
+
+class Header(Param):
+    """请求头参数"""
+
+    def __init__(self, *args, convert_underscores: bool = True, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.convert_underscores = convert_underscores
+
+    def get_key(self, param_name: str) -> str:
+        key = super().get_key(param_name)
+        return key.replace("_", "-") if self.convert_underscores else key
+
+
+class Cookie(Param):
+    """Cookie参数"""
+    pass
+
+
+class Body(Param):
+    """JSON请求体参数（支持Pydantic模型）"""
+
+    def __init__(self, *args, embed: bool = False, ** kwargs):
+        super().__init__(*args, **kwargs)
+        self.embed = embed  # 是否包装在键中
+
+
+class Form(Param):
+    """表单参数（支持Pydantic模型）"""
+    pass
+
+
+class File(Param):
+    """文件上传参数"""
+
+    def __init__(self, *args, field_name: str = "file", ** kwargs):
+        super().__init__(*args, **kwargs)
+        self.field_name = field_name

{sycommon_python_lib-0.1.29.dist-info → sycommon_python_lib-0.1.31.dist-info}/METADATA

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

{sycommon_python_lib-0.1.29.dist-info → sycommon_python_lib-0.1.31.dist-info}/RECORD

@@ -1,6 +1,6 @@
 command/cli.py,sha256=bP2LCLkRvfETIwWkVD70q5xFxMI4D3BpH09Ws1f-ENc,5849
 sycommon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sycommon/services.py,sha256=s9xbXiwehZeO4ZnS_8UKFY-LBkdGwbmsK-BB3pmFZuo,8766
+sycommon/services.py,sha256=r631K2RWfQJL7ZP4eiipVEQ2DvRbOcSvf5rqc_ACV9o,9190
 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
@@ -31,25 +31,29 @@ sycommon/middleware/traceid.py,sha256=oGTJ2jtdea_3NgaAwXLpUug5dGUYRQeM4r1n2icuvC
 sycommon/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/models/base_http.py,sha256=EICAAibx3xhjBsLqm35Mi3DCqxp0FME4rD_3iQVjT_E,3051
 sycommon/models/log.py,sha256=rZpj6VkDRxK3B6H7XSeWdYZshU8F0Sks8bq1p6pPlDw,500
-sycommon/models/mqlistener_config.py,sha256=PPwhAVJ2AWvVAvNox_1t0fuBKTyRH3Ui9cuuU-q7Byo,1590
+sycommon/models/mqlistener_config.py,sha256=vXp2uMmd0XQ5B9noSRXWHewTy-juQ2y7IsWtISJD5aI,1661
 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=kiQBMwLJW1sx9llxHUMXHHKXY5SJdafIHyVrEOu6OO4,27259
+sycommon/rabbitmq/rabbitmq_client.py,sha256=a91aWJ1ttVmMrfXGTBkoSuNgpsTHbQvuEjozswBp_Yk,27260
 sycommon/rabbitmq/rabbitmq_pool.py,sha256=_NMOO4CZy-I_anMqpzfYinz-8373_rg5FM9eqzdjGyU,3598
-sycommon/rabbitmq/rabbitmq_service.py,sha256=NWoMtRhvLjEsIX3sMgaSkrguE3gT5wLYj0u7laWZh8c,29997
+sycommon/rabbitmq/rabbitmq_service.py,sha256=5a6F4RlzRYLbDm0qJSx9BMfvOIzwSQsiA7T-oAROZ5k,30172
 sycommon/sse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/sse/event.py,sha256=k_rBJy23R7crtzQeetT0Q73D8o5-5p-eESGSs_BPOj0,2797
 sycommon/sse/sse.py,sha256=__CfWEcYxOxQ-HpLor4LTZ5hLWqw9-2X7CngqbVHsfw,10128
 sycommon/synacos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sycommon/synacos/feign.py,sha256=g2Mt3Iyxrk8doQsuIRNYMoHi-TP-k6FO5SDMWAbyqTo,24208
+sycommon/synacos/example.py,sha256=61XL03tU8WTNOo3FUduf93F2fAwah1S0lbH1ufhRhRk,5739
+sycommon/synacos/example2.py,sha256=adUaru3Hy482KrOA17DfaC4nwvLj8etIDS_KrWLWmCU,4811
+sycommon/synacos/feign.py,sha256=i-e2TgzAho3HZosQnzNy8Xl-8Q8a4BWsGey1Y-Kr4_8,5518
+sycommon/synacos/feign_client.py,sha256=JxzxohrsscQNlAjRVo_3ZQrMQSfVHFOtRYyEnP6sDGk,15205
 sycommon/synacos/nacos_service.py,sha256=SO1s83Y8A5jyQNFhk7ZZ_BrGQyGZ8TXBKtzRYxI-uDQ,34661
+sycommon/synacos/param.py,sha256=KcfSkxnXOa0TGmCjY8hdzU9pzUsA8-4PeyBKWI2-568,1765
 sycommon/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/tools/docs.py,sha256=OPj2ETheuWjXLyaXtaZPbwmJKfJaYXV5s4XMVAUNrms,1607
 sycommon/tools/snowflake.py,sha256=DdEj3T5r5OEvikp3puxqmmmz6BrggxomoSlnsRFb5dM,1174
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
-sycommon_python_lib-0.1.29.dist-info/METADATA,sha256=iun0vsoi2Xdi4hRDNxwAldSoOhVsM8mEdqNIoQ0Vwg8,7037
-sycommon_python_lib-0.1.29.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sycommon_python_lib-0.1.29.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
-sycommon_python_lib-0.1.29.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
-sycommon_python_lib-0.1.29.dist-info/RECORD,,
+sycommon_python_lib-0.1.31.dist-info/METADATA,sha256=egvprkvuPRH0lVt9bM2SwWS-5dvTA_TrHXYvvSah4QY,7037
+sycommon_python_lib-0.1.31.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.31.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.1.31.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.1.31.dist-info/RECORD,,