sycommon-python-lib 0.1.55__py3-none-any.whl → 0.1.55b0__py3-none-any.whl

sycommon/synacos/feign_client.py

@@ -5,7 +5,6 @@ import inspect
 from typing import Any, Dict, Optional, Literal, Type, TypeVar
 from urllib.parse import urljoin
 
-from sycommon.tools.merge_headers import merge_headers
 from sycommon.tools.snowflake import Snowflake
 
 import aiohttp
@@ -29,8 +28,6 @@ def feign_client(
     default_headers: Optional[Dict[str, str]] = None
 ):
     default_headers = default_headers or {}
-    default_headers = {k.lower(): v for k, v in default_headers.items()}
-    default_headers = merge_headers(SYLogger.get_headers(), default_headers)
     default_headers["x-traceId-header"] = SYLogger.get_trace_id() or Snowflake.id
 
     def decorator(cls):
@@ -39,8 +36,7 @@ def feign_client(
                 self.service_name = service_name
                 self.path_prefix = path_prefix
                 self.default_timeout = default_timeout
-                self.default_headers = {
-                    k.lower(): v for k, v in default_headers.copy().items()}
+                self.default_headers = default_headers.copy()
                 self.nacos_manager: Optional[NacosService] = None
                 self.session: Optional[aiohttp.ClientSession] = None
 
@@ -69,8 +65,7 @@ def feign_client(
                         method = request_meta.get("method", "GET").upper()
                         path = request_meta.get("path", "")
                         is_upload = request_meta.get("is_upload", False)
-                        method_headers = {
-                            k.lower(): v for k, v in request_meta.get("headers", {}).items()}
+                        method_headers = request_meta.get("headers", {})
                         timeout = request_meta.get(
                             "timeout", self.default_timeout)
 
@@ -160,16 +155,12 @@ def feign_client(
             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)
-                headers = merge_headers(SYLogger.get_headers(), headers)
                 headers["x-traceId-header"] = SYLogger.get_trace_id() or Snowflake.id
-
-                # 处理参数中的Header类型
                 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:
-                            header_key = meta.get_key(name).lower()
-                            headers[header_key] = str(value)
+                            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:
@@ -234,14 +225,10 @@ def feign_client(
                             value) if not isinstance(value, dict) else value)
                     return form_data
 
-                # 从headers中获取Content-Type（已小写key）
-                content_type = self.default_headers.get(
-                    "content-type") or method_headers.get("content-type", "")
-                # 转为小写进行判断
-                content_type_lower = content_type.lower()
-
                 # 处理表单提交（x-www-form-urlencoded）
-                if "application/x-www-form-urlencoded" in content_type_lower:
+                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)
@@ -287,8 +274,7 @@ def feign_client(
                 """处理响应（支持 Pydantic 模型解析）"""
                 status = response.status
                 if 200 <= status < 300:
-                    content_type = response.headers.get(
-                        "content-type", "").lower()
+                    content_type = response.headers.get("Content-Type", "")
                     if "application/json" in content_type:
                         json_data = await response.json()
                         # 若指定了 Pydantic 响应模型，自动解析
@@ -317,7 +303,7 @@ def feign_request(
         func._feign_meta = {
             "method": method.upper(),
             "path": path,
-            "headers": {k.lower(): v for k, v in headers.items()} if headers else {},
+            "headers": headers.copy() if headers else {},
             "is_upload": False,
             "timeout": timeout
         }

sycommon/synacos/nacos_service.py

@@ -15,6 +15,8 @@ import random
 from sycommon.config.Config import SingletonMeta
 from sycommon.logging.kafka_log import SYLogger
 
+logging.getLogger("nacos.client").setLevel(logging.WARNING)
+
 
 class NacosService(metaclass=SingletonMeta):
     def __init__(self, config):

sycommon/tools/snowflake.py

@@ -3,10 +3,9 @@ import threading
 import socket
 import hashlib
 import random
-import os
 from typing import Optional, Type, Any
 from os import environ
-import psutil
+import netifaces
 
 
 class ClassProperty:
@@ -24,8 +23,7 @@ class ClassProperty:
 
 
 class Snowflake:
-    """雪花算法生成器（生产级优化版，无公网依赖，适配内网/K8s环境）"""
-    # 基础配置（可根据业务调整）
+    """雪花算法生成器（无公网依赖，适配内网环境）"""
     START_TIMESTAMP = 1388534400000  # 2014-01-01 00:00:00
     SEQUENCE_BITS = 12
     MACHINE_ID_BITS = 10
@@ -33,10 +31,8 @@ class Snowflake:
     MAX_SEQUENCE = (1 << SEQUENCE_BITS) - 1
     MACHINE_ID_SHIFT = SEQUENCE_BITS
     TIMESTAMP_SHIFT = SEQUENCE_BITS + MACHINE_ID_BITS
-    CLOCK_BACKWARD_THRESHOLD = 5  # 容忍的时钟回拨阈值（毫秒）
-    _MAX_JAVA_LONG = 9223372036854775807  # Java Long最大值
 
-    # 类级别的单例实例（线程安全）
+    # 类级别的单例实例
     _instance = None
     _instance_lock = threading.Lock()
 
@@ -45,38 +41,22 @@ class Snowflake:
         初始化：优先使用传入的machine_id，否则自动从K8s环境获取
         :param machine_id: 手动指定机器ID（None则自动计算）
         """
-        # 前置校验：确保雪花ID不会超过Java Long最大值
-        self._validate_timestamp_range()
-
         # 自动计算K8s环境下的machine_id
         if machine_id is None:
             machine_id = self._get_k8s_machine_id()
 
-        # 校验machine_id合法性
         if not (0 <= machine_id <= self.MAX_MACHINE_ID):
             raise ValueError(f"机器ID必须在0~{self.MAX_MACHINE_ID}之间")
 
-        # 初始化核心参数
         self.machine_id = machine_id
         self.last_timestamp = -1
         self.sequence = 0
         self.lock = threading.Lock()
 
-    def _validate_timestamp_range(self):
-        """校验当前时间戳是否在雪花ID支持的范围内，避免超过Java Long最大值"""
-        max_support_timestamp = self.START_TIMESTAMP + \
-            (1 << (64 - self.TIMESTAMP_SHIFT)) - 1
-        current_timestamp = self._get_current_timestamp()
-        if current_timestamp > max_support_timestamp:
-            raise RuntimeError(
-                f"当前时间戳({current_timestamp})超过雪花ID支持的最大时间戳({max_support_timestamp})，"
-                f"请调整START_TIMESTAMP或减少TIMESTAMP_SHIFT位数"
-            )
-
     def _get_k8s_machine_id(self) -> int:
         """
-        从K8s环境自动计算唯一machine_id（无公网依赖，多层兜底，降低重复风险）：
-        优先级：POD_NAME > POD_IP > 容器内网IP（psutil读取） > 容器主机名 > 进程+时间+随机数（最终兜底）
+        从K8s环境自动计算唯一machine_id（无公网依赖，多层兜底）：
+        优先级：POD_NAME > POD_IP > 容器内网IP（网卡读取） > 容器主机名 > 随机数（最终兜底）
         """
         # 1. 优先读取K8s内置的POD_NAME（默认注入，优先级最高）
         pod_name = environ.get("POD_NAME")
@@ -88,7 +68,7 @@ class Snowflake:
         if pod_ip:
             return self._hash_to_machine_id(pod_ip)
 
-        # 3. 兜底1：读取本机网卡获取内网IP（替换netifaces，使用psutil）
+        # 3. 兜底1：读取本机网卡获取内网IP（无公网依赖）
         try:
             local_ip = self._get_local_internal_ip()
             if local_ip:
@@ -101,60 +81,48 @@ class Snowflake:
         if hostname:
             return self._hash_to_machine_id(hostname)
 
-        # 5. 最终兜底：增加熵值（进程ID+毫秒时间戳+随机数），大幅降低重复概率
-        fallback_text = f"{os.getpid()}_{int(time.time()*1000)}_{random.randint(0, 100000)}"
-        return self._hash_to_machine_id(fallback_text)
+        # 5. 最终兜底：生成随机数（仅极端情况使用）
+        random_id = random.randint(0, self.MAX_MACHINE_ID)
+        return random_id
 
     def _get_local_internal_ip(self) -> Optional[str]:
         """
-        使用psutil读取本机网卡信息，获取非回环的内网IP（跨平台兼容，过滤lo/lo0等回环网卡）
+        读取本机网卡信息，获取非回环的内网IP（无公网依赖）
         :return: 内网IP字符串，失败返回None
         """
         try:
-            # 遍历所有网卡接口
-            net_if_addrs = psutil.net_if_addrs()
-            for interface_name, addrs in net_if_addrs.items():
-                # 过滤回环/虚拟网卡（兼容lo、lo0、lo1、Loopback、virtual等）
-                if (interface_name.lower().startswith("lo")
-                        or interface_name.lower() in ["loopback", "virtual"]):
-                    continue
-                # 遍历该网卡的所有地址，优先返回第一个非回环IPv4
-                for addr in addrs:
-                    if addr.family == psutil.AF_INET:
-                        ip = addr.address
+            # 遍历所有网卡
+            for interface in netifaces.interfaces():
+                # 获取网卡的IP地址信息
+                addrs = netifaces.ifaddresses(interface)
+                # 只取IPv4地址
+                if netifaces.AF_INET in addrs:
+                    for addr in addrs[netifaces.AF_INET]:
+                        ip = addr.get('addr')
+                        # 过滤回环地址（127.0.0.1）
                         if ip and not ip.startswith('127.'):
                             return ip
             return None
-        except Exception:
-            # psutil调用失败，降级到纯内置方法
+        except ImportError:
+            # 若未安装netifaces，降级为socket方式
             return self._get_local_ip_fallback()
 
     def _get_local_ip_fallback(self) -> Optional[str]:
         """
-        增强版降级方案：纯Python内置方法，多维度获取内网IP（无第三方依赖）
+        降级方案：不连接公网，仅通过本地socket获取IP（兼容无netifaces的场景）
         """
-        # 方案1：socket绑定内网地址（避免访问公网）
         try:
+            # 创建socket但不连接任何地址，仅绑定到本地
             s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            s.connect(("192.168.0.1", 80))
+            s.bind(('', 0))
             local_ip = s.getsockname()[0]
             s.close()
+            # 过滤回环地址
             if not local_ip.startswith('127.'):
                 return local_ip
+            return None
         except Exception:
-            pass
-
-        # 方案2：遍历所有本地IP（通过hostname解析）
-        try:
-            hostname = socket.gethostname()
-            ip_list = socket.gethostbyname_ex(hostname)[2]
-            for ip in ip_list:
-                if not ip.startswith('127.'):
-                    return ip
-        except Exception:
-            pass
-
-        return None
+            return None
 
     def _hash_to_machine_id(self, text: str) -> int:
         """将字符串哈希后取模，得到0~1023的machine_id（保证分布均匀）"""
@@ -163,60 +131,42 @@ class Snowflake:
         return hash_int % self.MAX_MACHINE_ID
 
     def _get_current_timestamp(self) -> int:
-        """获取当前毫秒级时间戳"""
         return int(time.time() * 1000)
 
     def _wait_next_millisecond(self, current_timestamp: int) -> int:
-        """等待直到下一个毫秒，避免序列耗尽"""
         while current_timestamp <= self.last_timestamp:
             current_timestamp = self._get_current_timestamp()
         return current_timestamp
 
     def generate_id(self) -> int:
-        """生成雪花ID（生产级优化：优化锁粒度，容忍轻微时钟回拨）"""
-        current_timestamp = self._get_current_timestamp()
+        with self.lock:
+            current_timestamp = self._get_current_timestamp()
 
-        # 1. 处理时钟回拨：容忍CLOCK_BACKWARD_THRESHOLD内的微调，超过则抛异常
-        time_diff = self.last_timestamp - current_timestamp
-        if time_diff > 0:
-            if time_diff > self.CLOCK_BACKWARD_THRESHOLD:
+            if current_timestamp < self.last_timestamp:
                 raise RuntimeError(
-                    f"时钟回拨检测：当前时间戳({current_timestamp}) < 上一次时间戳({self.last_timestamp})，"
-                    f"差值{time_diff}ms（阈值{self.CLOCK_BACKWARD_THRESHOLD}ms）"
+                    f"时钟回拨检测：当前时间戳({current_timestamp}) < 上一次时间戳({self.last_timestamp})"
                 )
-            # 轻微回拨：等待时钟追上
-            current_timestamp = self._wait_next_millisecond(current_timestamp)
 
-        # 2. 优化锁粒度：仅在同一毫秒内递增序列时加锁
-        if current_timestamp != self.last_timestamp:
-            with self.lock:
-                self.last_timestamp = current_timestamp
-                self.sequence = 0
-        else:
-            with self.lock:
+            if current_timestamp == self.last_timestamp:
                 self.sequence = (self.sequence + 1) & self.MAX_SEQUENCE
                 if self.sequence == 0:
                     current_timestamp = self._wait_next_millisecond(
                         current_timestamp)
-                    self.last_timestamp = current_timestamp
+            else:
+                self.sequence = 0
 
-        # 3. 计算最终雪花ID
-        snowflake_id = (
-            ((current_timestamp - self.START_TIMESTAMP) << self.TIMESTAMP_SHIFT)
-            | (self.machine_id << self.MACHINE_ID_SHIFT)
-            | self.sequence
-        )
+            self.last_timestamp = current_timestamp
 
-        # 最终校验：确保不超过Java Long最大值
-        if snowflake_id > self._MAX_JAVA_LONG:
-            raise RuntimeError(
-                f"生成的雪花ID({snowflake_id})超过Java Long最大值({self._MAX_JAVA_LONG})")
+            snowflake_id = (
+                ((current_timestamp - self.START_TIMESTAMP) << self.TIMESTAMP_SHIFT)
+                | (self.machine_id << self.MACHINE_ID_SHIFT)
+                | self.sequence
+            )
 
-        return snowflake_id
+            return snowflake_id
 
     @staticmethod
     def parse_id(snowflake_id: int) -> dict:
-        """解析雪花ID，返回生成时间、机器ID、序列等信息"""
         from datetime import datetime
         sequence = snowflake_id & Snowflake.MAX_SEQUENCE
         machine_id = (snowflake_id >>
@@ -230,21 +180,21 @@ class Snowflake:
             "snowflake_id": snowflake_id,
             "generate_time": generate_time,
             "machine_id": machine_id,
-            "sequence": sequence,
-            "is_java_long_safe": snowflake_id <= Snowflake._MAX_JAVA_LONG
+            "sequence": sequence
         }
 
     @classmethod
     def next_id(cls) -> str:
         """
-        生成雪花ID（线程安全单例模式，避免重复创建实例，锁内完成所有初始化）
+        生成雪花ID（单例模式，避免重复创建实例）
         :return: 雪花ID字符串
         """
+        # 单例模式创建实例
         if cls._instance is None:
             with cls._instance_lock:
                 if cls._instance is None:
-                    # 锁内初始化，避免多线程重复计算machine_id
                     cls._instance = cls()
+        # 生成ID并转为字符串返回
         return str(cls._instance.generate_id())
 
     @ClassProperty
@@ -257,8 +207,8 @@ class Snowflake:
 
 
 if __name__ == "__main__":
-    print("=== 生产级雪花算法ID生成测试 ===")
-    # 1. 基础生成测试
+    print("=== 兼容Python 3.11+的属性方式生成雪花ID ===")
+    # 直接访问 Snowflake.id 即可生成，无废弃警告
     id1 = Snowflake.id
     id2 = Snowflake.id
     id3 = Snowflake.id
@@ -267,34 +217,19 @@ if __name__ == "__main__":
     print(f"生成ID3: {id3}")
     print(f"ID是否唯一: {len({id1, id2, id3}) == 3}")
 
-    # 2. 解析ID信息
-    print("\n=== 雪花ID解析 ===")
-    parse_info = Snowflake.parse_id(int(id3))
-    for key, value in parse_info.items():
-        print(f"{key}: {value}")
+    # 原有方式仍可正常使用
+    print("\n=== 原有方法方式生成 ===")
+    id4 = Snowflake.next_id()
+    print(f"生成ID4: {id4}")
 
-    # 3. 批量唯一性验证（10000个ID）
-    print("\n=== 批量唯一性验证（10000个）===")
+    # 批量验证（1000个唯一ID）
     id_set = set()
-    duplicate_count = 0
-    for i in range(10000):
-        snow_id = Snowflake.id
-        if snow_id in id_set:
-            duplicate_count += 1
+    _MAX_JAVA_LONG = 9223372036854775807
+    for i in range(1000):
+        snow_id = Snowflake.id  # 全程使用兼容版属性方式
+        id_num = int(snow_id)
+        assert id_num <= _MAX_JAVA_LONG, f"ID超过Java long最大值: {id_num}"
+        assert snow_id not in id_set, f"重复生成ID: {snow_id}"
         id_set.add(snow_id)
-    print(f"总生成数量: 10000")
-    print(f"唯一ID数量: {len(id_set)}")
-    print(f"重复ID数量: {duplicate_count}")
-    print(f"机器ID: {Snowflake._instance.machine_id}")
-
-    # 4. 高并发测试
-    import concurrent.futures
-    print("\n=== 高并发测试（100线程）===")
-    id_set_concurrent = set()
-    with concurrent.futures.ThreadPoolExecutor(max_workers=100) as executor:
-        futures = [executor.submit(lambda: Snowflake.id) for _ in range(10000)]
-        for future in concurrent.futures.as_completed(futures):
-            id_set_concurrent.add(future.result())
-    print(f"高并发生成唯一ID数量: {len(id_set_concurrent)}")
-
-    print("\n=== 生产级雪花算法验证通过 ===")
+
+    print(f"\n成功生成{len(id_set)}个唯一雪花ID，兼容版属性访问方式验证通过！")

{sycommon_python_lib-0.1.55.dist-info → sycommon_python_lib-0.1.55b0.dist-info}/METADATA

@@ -1,23 +1,22 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.55
+Version: 0.1.55b0
 Summary: Add your description here
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: aio-pika>=9.5.8
 Requires-Dist: aiohttp>=3.13.2
-Requires-Dist: aiomysql>=0.3.2
 Requires-Dist: decorator>=5.2.1
 Requires-Dist: fastapi>=0.127.0
 Requires-Dist: kafka-python>=2.3.0
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: mysql-connector-python>=9.5.0
 Requires-Dist: nacos-sdk-python<3.0,>=2.0.9
-Requires-Dist: psutil>=7.1.3
+Requires-Dist: netifaces>=0.11.0
 Requires-Dist: pydantic>=2.12.5
 Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: pyyaml>=6.0.3
-Requires-Dist: sqlalchemy[asyncio]>=2.0.45
+Requires-Dist: sqlalchemy>=2.0.45
 Requires-Dist: starlette>=0.50.0
 Requires-Dist: uvicorn>=0.40.0
 

{sycommon_python_lib-0.1.55.dist-info → sycommon_python_lib-0.1.55b0.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=pioA4E2RrV6nyAY8EuETUt4mKzCYoxD1rTMYCcppqjE,11581
+sycommon/services.py,sha256=66YUddNJsbx8axuxUZ6ERr95yphlhLOUbBUJ_tgNseI,11851
 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
@@ -8,8 +8,6 @@ sycommon/config/LLMConfig.py,sha256=yU-aIqePIeF6msfRVEtGq7SXZVDfHyTi6JduKjhMO_4,
 sycommon/config/MQConfig.py,sha256=_RDcmIdyWKjmgM5ZnriOoI-DpaxgXs7CD0awdAD6z88,252
 sycommon/config/RerankerConfig.py,sha256=dohekaY_eTynmMimIuKHBYGXXQO6rJjSkm94OPLuMik,322
 sycommon/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sycommon/database/async_base_db_service.py,sha256=w6ONUiTtF4-bXRnkBt9QpL9BAy0XUDbQG7F9Hf2rfjw,1337
-sycommon/database/async_database_service.py,sha256=4Ag5PH6DFEcJOXR8MRF9V_Jho5uCoU9Ibo3PqulDsXw,3916
 sycommon/database/base_db_service.py,sha256=J5ELHMNeGfzA6zVcASPSPZ0XNKrRY3_gdGmVkZw3Mto,946
 sycommon/database/database_service.py,sha256=mun5vgM7nkuH6_UyHLHqQ2Qk_5gRgMxJu4_obIKLT6o,3253
 sycommon/health/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -17,13 +15,11 @@ sycommon/health/health_check.py,sha256=EhfbhspRpQiKJaxdtE-PzpKQO_ucaFKtQxIm16F5M
 sycommon/health/metrics.py,sha256=fHqO73JuhoZkNPR-xIlxieXiTCvttq-kG-tvxag1s1s,268
 sycommon/health/ping.py,sha256=FTlnIKk5y1mPfS1ZGOeT5IM_2udF5aqVLubEtuBp18M,250
 sycommon/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sycommon/logging/async_sql_logger.py,sha256=_OY36XkUm__U3NhMgiecy-qd-nptZ_0gpE3J8lGAr58,2619
-sycommon/logging/kafka_log.py,sha256=sVw-dFZKEgCosjSUqgTj7YrpK-ggXhleZFwMUVhl-K0,21416
-sycommon/logging/logger_levels.py,sha256=_-uQ_T1N8NkNgcAmLrMmJ83nHTDw5ZNvXFPvdk89XGY,1144
+sycommon/logging/kafka_log.py,sha256=viqJ2hDqnyX5eUKkhIhU__kytIwe6nLuHIAFGcaRpUI,21118
 sycommon/logging/logger_wrapper.py,sha256=TiHsrIIHiQMzXgXK12-0KIpU9GhwQJOoHslakzmq2zc,357
 sycommon/logging/sql_logger.py,sha256=aEU3OGnI_51Tjyuuf4FpUi9KPTceFRuKAOyQbPzGhzM,2021
 sycommon/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sycommon/middleware/context.py,sha256=sc1UjN55dYww2tT9KdFMJV8mgpGro67SnETzbVzty-s,155
+sycommon/middleware/context.py,sha256=_5ghpv4u_yAvjkgM-XDx8OnO-YI1XtntHrXsHJHZkwo,88
 sycommon/middleware/cors.py,sha256=0B5d_ovD56wcH9TfktRs88Q09R9f8Xx5h5ALWYvE8Iw,600
 sycommon/middleware/docs.py,sha256=bVdDBIHXGVBv562MQLSroa1DgHoObxR9gFzv71PIejg,1187
 sycommon/middleware/exception.py,sha256=Bk8IchNND1wg6tUX9hf4xWeEJhvA-E_zE9ysBpRZrqE,3010
@@ -31,7 +27,7 @@ sycommon/middleware/middleware.py,sha256=SzZ4wufSNdwC4Ppw99TE7a6AVGkrZRc55NHSrA3
 sycommon/middleware/monitor_memory.py,sha256=pYRK-wRuDd6enSg9Pf8tQxPdYQS6S0AyjyXeKFRLKEs,628
 sycommon/middleware/mq.py,sha256=4wBqiT5wJGcrfjk2GSr0_U3TStBxoNpHTzcRxVlMEHE,183
 sycommon/middleware/timeout.py,sha256=fImlAPLm4Oa8N9goXtT_0os1GZPCi9F92OgXU81DgDU,656
-sycommon/middleware/traceid.py,sha256=0WYLV5PR6sGeqhLdviHYW94UhUC7NJua2g5HWf2Zhbc,13447
+sycommon/middleware/traceid.py,sha256=FLZTxVAIboZvqK_S69eReeIzZGUDIVy6KTA1kZBoRyI,6908
 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
@@ -48,17 +44,16 @@ sycommon/sse/sse.py,sha256=__CfWEcYxOxQ-HpLor4LTZ5hLWqw9-2X7CngqbVHsfw,10128
 sycommon/synacos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/synacos/example.py,sha256=61XL03tU8WTNOo3FUduf93F2fAwah1S0lbH1ufhRhRk,5739
 sycommon/synacos/example2.py,sha256=adUaru3Hy482KrOA17DfaC4nwvLj8etIDS_KrWLWmCU,4811
-sycommon/synacos/feign.py,sha256=frB3D5LeFDtT3pJLFOwFzEOrNAJKeQNGk-BzUg9T3WM,8295
-sycommon/synacos/feign_client.py,sha256=ExO7Pd5B3eFKDjXqBRc260K1jkI49IYguLwJJaD2R-o,16166
-sycommon/synacos/nacos_service.py,sha256=jeg7Bd-SYb0nB1vpjN4sJdw_0nXuI8GjebdM7zu_Z8c,35404
+sycommon/synacos/feign.py,sha256=xvyH_1no6gsggO3YYB0_88NWNA26odbQ_G-2MjApif0,8016
+sycommon/synacos/feign_client.py,sha256=PYjTrnqMc_Jl6Wnpiz8-PFozCjPk6VGnPWv29JefL14,15421
+sycommon/synacos/nacos_service.py,sha256=tyh_JOjjoCGiKCr1xfU7MAmu7dDQCZmTzmYsSqNjiQY,35465
 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/merge_headers.py,sha256=HV_i52Q-9se3SP8qh7ZGYl8bP7Fxtal4CGVkyMwEdM8,4373
-sycommon/tools/snowflake.py,sha256=lVEe5mNCOgz5OqGQpf5_nXaGnRJlI2STX2s-ppTtanA,11947
+sycommon/tools/snowflake.py,sha256=wSATJzWGb6HcaZ1u_fdzF6I5seRviQQm2KS3Jf45nm4,8520
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
-sycommon_python_lib-0.1.55.dist-info/METADATA,sha256=P0jS9Alm326fol0Jzj_u7HcpJtsugkCpMyCv9z0OLzc,7084
-sycommon_python_lib-0.1.55.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sycommon_python_lib-0.1.55.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
-sycommon_python_lib-0.1.55.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
-sycommon_python_lib-0.1.55.dist-info/RECORD,,
+sycommon_python_lib-0.1.55b0.dist-info/METADATA,sha256=9K3VD62twbBtlxjoty9K0h96O74lp2NFfqtviimdqGM,7050
+sycommon_python_lib-0.1.55b0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.55b0.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.1.55b0.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.1.55b0.dist-info/RECORD,,

sycommon/database/async_base_db_service.py

@@ -1,36 +0,0 @@
-from contextlib import asynccontextmanager
-from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
-from sycommon.config.Config import SingletonMeta
-from sycommon.database.async_database_service import AsyncDatabaseService
-from sycommon.logging.kafka_log import SYLogger
-
-
-class AsyncBaseDBService(metaclass=SingletonMeta):
-    """数据库操作基础服务类，封装异步会话管理功能"""
-
-    def __init__(self):
-        # 获取异步引擎 (假设 DatabaseService.engine() 返回的是 AsyncEngine)
-        self.engine = AsyncDatabaseService.engine()
-
-        # 创建异步 Session 工厂
-        # class_=AsyncSession 是必须的，用于指定生成的是异步会话
-        self.Session = async_sessionmaker(
-            bind=self.engine,
-            class_=AsyncSession,
-            expire_on_commit=False
-        )
-
-    @asynccontextmanager
-    async def session(self):
-        """
-        异步数据库会话上下文管理器
-        自动处理会话的创建、提交、回滚和关闭
-        """
-        async with self.Session() as session:
-            try:
-                yield session
-                await session.commit()
-            except Exception as e:
-                await session.rollback()
-                SYLogger.error(f"Database operation failed: {str(e)}")
-                raise

sycommon/database/async_database_service.py

@@ -1,96 +0,0 @@
-from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
-from sqlalchemy import text
-
-from sycommon.config.Config import SingletonMeta
-from sycommon.config.DatabaseConfig import DatabaseConfig, convert_dict_keys
-from sycommon.logging.kafka_log import SYLogger
-from sycommon.logging.async_sql_logger import AsyncSQLTraceLogger
-from sycommon.synacos.nacos_service import NacosService
-
-
-class AsyncDatabaseService(metaclass=SingletonMeta):
-    _engine = None
-
-    @staticmethod
-    async def setup_database(config: dict, shareConfigKey: str):
-        common = NacosService(config).share_configs.get(shareConfigKey, {})
-        if common and common.get('spring', {}).get('datasource', None):
-            databaseConfig = common.get('spring', {}).get('datasource', None)
-            converted_dict = convert_dict_keys(databaseConfig)
-            db_config = DatabaseConfig.model_validate(converted_dict)
-
-            # 初始化 DatabaseConnector (传入配置)
-            connector = AsyncDatabaseConnector(db_config)
-
-            # 赋值 engine
-            AsyncDatabaseService._engine = connector.engine
-
-            # 执行异步测试连接
-            if not await connector.test_connection():
-                raise Exception("Database connection test failed")
-
-    @staticmethod
-    def engine():
-        return AsyncDatabaseService._engine
-
-
-class AsyncDatabaseConnector(metaclass=SingletonMeta):
-    def __init__(self, db_config: DatabaseConfig):
-        # 从 DatabaseConfig 中提取数据库连接信息
-        self.db_user = db_config.username
-        self.db_password = db_config.password
-
-        # 提取 URL 中的主机、端口和数据库名
-        url_parts = db_config.url.split('//')[1].split('/')
-        host_port = url_parts[0].split(':')
-        self.db_host = host_port[0]
-        self.db_port = host_port[1]
-        self.db_name = url_parts[1].split('?')[0]
-
-        # 提取 URL 中的参数
-        params_str = url_parts[1].split('?')[1] if len(
-            url_parts[1].split('?')) > 1 else ''
-        params = {}
-        for param in params_str.split('&'):
-            if param:
-                key, value = param.split('=')
-                params[key] = value
-
-        # 在params中去掉指定的参数
-        for key in ['useUnicode', 'characterEncoding', 'serverTimezone', 'zeroDateTimeBehavior']:
-            if key in params:
-                del params[key]
-
-        # 构建数据库连接 URL
-        # 注意：这里将 mysqlconnector 替换为 aiomysql 以支持异步
-        self.db_url = f'mysql+aiomysql://{self.db_user}:{self.db_password}@{self.db_host}:{self.db_port}/{self.db_name}'
-
-        SYLogger.info(f"Database URL: {self.db_url}")
-
-        # 优化连接池配置
-        # 使用 create_async_engine 替代 create_engine
-        self.engine = create_async_engine(
-            self.db_url,
-            connect_args=params,
-            pool_size=10,  # 连接池大小
-            max_overflow=20,  # 最大溢出连接数
-            pool_timeout=30,  # 连接超时时间（秒）
-            pool_recycle=3600,  # 连接回收时间（秒）
-            pool_pre_ping=True,  # 每次获取连接前检查连接是否有效
-            echo=False,  # 打印 SQL 语句
-        )
-
-        # 注册 SQL 日志拦截器 (注意：SQLTraceLogger 需要支持异步引擎，或者您可能需要调整日志逻辑)
-        # 假设 SQLTraceLogger.setup_sql_logging 能够处理 AsyncEngine
-        AsyncSQLTraceLogger.setup_sql_logging(self.engine)
-
-    async def test_connection(self):
-        try:
-            # 异步上下文管理器
-            async with self.engine.connect() as connection:
-                # 执行简单查询
-                await connection.execute(text("SELECT 1"))
-                return True
-        except Exception as e:
-            SYLogger.error(f"Database connection test failed: {e}")
-            return False