sycommon-python-lib 0.1.29__tar.gz → 0.1.30__tar.gz

{sycommon_python_lib-0.1.29 → sycommon_python_lib-0.1.30}/PKG-INFO

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

{sycommon_python_lib-0.1.29 → sycommon_python_lib-0.1.30}/pyproject.toml

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

{sycommon_python_lib-0.1.29 → sycommon_python_lib-0.1.30}/src/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_python_lib-0.1.29 → sycommon_python_lib-0.1.30}/src/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_python_lib-0.1.29 → sycommon_python_lib-0.1.30}/src/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_python_lib-0.1.30/src/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_python_lib-0.1.30/src/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_python_lib-0.1.30/src/sycommon/synacos/feign.py

@@ -0,0 +1,137 @@
+import io
+import os
+import time
+
+import aiohttp
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.synacos.nacos_service import NacosService
+
+"""
+支持异步Feign客户端
+    方式一: 使用 @feign_client 和 @feign_request 装饰器
+    方式二: 使用 feign 函数
+"""
+
+
+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):
+    """
+    feign 函数，显式设置JSON请求的Content-Type头
+    """
+    session = aiohttp.ClientSession()
+    try:
+        # 初始化headers，确保是可修改的字典
+        headers = headers.copy() if headers else {}
+
+        # 处理JSON请求的Content-Type
+        is_json_request = method.upper() in ["POST", "PUT", "PATCH"] and not (
+            files or form_data or file_path)
+        if is_json_request and "Content-Type" not in headers:
+            headers["Content-Type"] = "application/json"
+
+        nacos_service = NacosService(None)
+        version = headers.get('s-y-version')
+
+        # 获取服务实例
+        instances = nacos_service.get_service_instances(
+            service_name, target_version=version)
+        if not instances:
+            SYLogger.error(f"nacos:未找到 {service_name} 的健康实例")
+            return None
+
+        # 简单轮询负载均衡
+        instance = instances[int(time.time()) % len(instances)]
+
+        SYLogger.info(f"nacos:开始调用服务: {service_name}")
+        SYLogger.info(f"nacos:请求头: {headers}")
+
+        ip = instance.get('ip')
+        port = instance.get('port')
+
+        # 处理path参数
+        if path_params:
+            for key, value in path_params.items():
+                api_path = api_path.replace(f"{{{key}}}", str(value))
+
+        url = f"http://{ip}:{port}{api_path}"
+        SYLogger.info(f"nacos:请求地址: {url}")
+
+        try:
+            # 处理文件上传
+            if files or form_data or file_path:
+                data = aiohttp.FormData()
+                if form_data:
+                    for key, value in form_data.items():
+                        data.add_field(key, value)
+                if files:
+                    # 兼容处理：同时支持字典（单文件）和列表（多文件）
+                    if isinstance(files, dict):
+                        # 处理原有字典格式（单文件）
+                        # 字典格式：{field_name: (filename, content)}
+                        for field_name, (filename, content) in files.items():
+                            data.add_field(field_name, content,
+                                           filename=filename)
+                    elif isinstance(files, list):
+                        # 处理新列表格式（多文件）
+                        # 列表格式：[(field_name, filename, content), ...]
+                        for item in files:
+                            if len(item) != 3:
+                                raise ValueError(
+                                    f"列表元素格式错误，需为 (field_name, filename, content)，实际为 {item}")
+                            field_name, filename, content = item
+                            data.add_field(field_name, content,
+                                           filename=filename)
+                    else:
+                        raise TypeError(f"files 参数必须是字典或列表，实际为 {type(files)}")
+                if file_path:
+                    filename = os.path.basename(file_path)
+                    with open(file_path, 'rb') as f:
+                        data.add_field('file', f, filename=filename)
+                # 移除Content-Type，让aiohttp自动处理
+                headers.pop('Content-Type', None)
+                async with session.request(
+                    method=method.upper(),
+                    url=url,
+                    headers=headers,
+                    params=params,
+                    data=data,
+                    timeout=timeout
+                ) as response:
+                    return await _handle_feign_response(response)
+            else:
+                # 普通JSON请求
+                async with session.request(
+                    method=method.upper(),
+                    url=url,
+                    headers=headers,
+                    params=params,
+                    json=body,
+                    timeout=timeout
+                ) as response:
+                    return await _handle_feign_response(response)
+        except aiohttp.ClientError as e:
+            SYLogger.error(
+                f"nacos:请求服务接口时出错ClientError path: {api_path} error:{e}")
+            return None
+    except Exception as e:
+        import traceback
+        SYLogger.error(
+            f"nacos:请求服务接口时出错 path: {api_path} error:{traceback.format_exc()}")
+        return None
+    finally:
+        await session.close()
+
+
+async def _handle_feign_response(response):
+    """处理Feign请求的响应"""
+    if response.status == 200:
+        content_type = response.headers.get('Content-Type')
+        if 'application/json' in content_type:
+            return await response.json()
+        else:
+            content = await response.read()
+            return io.BytesIO(content)
+    else:
+        error_msg = await response.text()
+        SYLogger.error(f"nacos:请求失败，状态码: {response.status}，响应内容: {error_msg}")
+        return None