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

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/nacos_service.py

@@ -47,7 +47,7 @@ class NacosService(metaclass=SingletonMeta):
             self.retry_backoff = self.nacos_config.get('retryBackoff', 1.5)
             self.max_retry_delay = self.nacos_config.get('maxRetryDelay', 30)
             self.heartbeat_interval = self.nacos_config.get(
-                'heartbeatInterval', 10)
+                'heartbeatInterval', 15)
             self.register_retry_interval = self.nacos_config.get(
                 'registerRetryInterval', 5)  # 注册重试间隔
 

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.40.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.29
+Version: 0.1.40
 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.40.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=e9odPBLUoAAUkFU4s8ITIQUbr1GH7dqb9qSHyUhN4A8,11258
 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_pool.py,sha256=_NMOO4CZy-I_anMqpzfYinz-8373_rg5FM9eqzdjGyU,3598
-sycommon/rabbitmq/rabbitmq_service.py,sha256=NWoMtRhvLjEsIX3sMgaSkrguE3gT5wLYj0u7laWZh8c,29997
+sycommon/rabbitmq/rabbitmq_client.py,sha256=vyyfIWJ0b7tXZSK1m8fKERW6D-LQCrDvmjKmsPvOG6M,12141
+sycommon/rabbitmq/rabbitmq_pool.py,sha256=YmvvFO8xP2pNnwuyZ0vp28XnfTzPScIPnBMih34f7Wc,7390
+sycommon/rabbitmq/rabbitmq_service.py,sha256=LXoL7zm-1_iTts6S9CreEMJ66ExwRm9y4zUmcOqI1YM,36597
 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/nacos_service.py,sha256=SO1s83Y8A5jyQNFhk7ZZ_BrGQyGZ8TXBKtzRYxI-uDQ,34661
+sycommon/synacos/example.py,sha256=61XL03tU8WTNOo3FUduf93F2fAwah1S0lbH1ufhRhRk,5739
+sycommon/synacos/example2.py,sha256=adUaru3Hy482KrOA17DfaC4nwvLj8etIDS_KrWLWmCU,4811
+sycommon/synacos/feign.py,sha256=0cmnyExXcr1qIV0B_POdQ-_u4-t5K3LjJD_8rDaXwSE,7467
+sycommon/synacos/feign_client.py,sha256=JxzxohrsscQNlAjRVo_3ZQrMQSfVHFOtRYyEnP6sDGk,15205
+sycommon/synacos/nacos_service.py,sha256=QG1lShrVZNKbExYV_IUwGXTHDnU09RYXooVy_llhW6c,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.40.dist-info/METADATA,sha256=-9GpbSobbSHJj66au2M-0ThPFN5ynZEALO69lvLOClY,7037
+sycommon_python_lib-0.1.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.40.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.1.40.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.1.40.dist-info/RECORD,,