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

sycommon/synacos/feign.py

@@ -2,7 +2,6 @@ import io
 import os
 import time
 
-from sycommon.tools.merge_headers import merge_headers
 from sycommon.tools.snowflake import Snowflake
 
 import aiohttp
@@ -25,18 +24,14 @@ async def feign(service_name, api_path, method='GET', params=None, headers=None,
     try:
         # 初始化headers，确保是可修改的字典
         headers = headers.copy() if headers else {}
-        headers = merge_headers(SYLogger.get_headers(), headers)
         if "x-traceId-header" not in headers:
-            headers["x-traceId-header"] = SYLogger.get_trace_id() or Snowflake.id
+            headers["x-traceId-header"] = SYLogger.get_trace_id() or Snowflake.next_id()
 
         # 处理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:
-            # 将headers的key全部转为小写，统一判断
-            headers_lower = {k.lower(): v for k, v in headers.items()}
-            if "content-type" not in headers_lower:
-                headers["Content-Type"] = "application/json"
+        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')
@@ -52,7 +47,7 @@ async def feign(service_name, api_path, method='GET', params=None, headers=None,
         instance = instances[int(time.time()) % len(instances)]
 
         SYLogger.info(f"nacos:开始调用服务: {service_name}")
-        # SYLogger.info(f"nacos:请求头: {headers}")
+        SYLogger.info(f"nacos:请求头: {headers}")
 
         ip = instance.get('ip')
         port = instance.get('port')

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,9 +28,7 @@ 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
+    default_headers["x-traceId-header"] = SYLogger.get_trace_id() or Snowflake.next_id()
 
     def decorator(cls):
         class FeignClient:
@@ -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类型
+                headers["x-traceId-header"] = SYLogger.get_trace_id() or Snowflake.next_id()
                 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,29 +3,13 @@ import threading
 import socket
 import hashlib
 import random
-import os
-from typing import Optional, Type, Any
+from typing import Optional
 from os import environ
-import psutil
-
-
-class ClassProperty:
-    """
-    自定义类属性描述符，替代 @classmethod + @property 的废弃写法
-    支持通过 类.属性 的方式访问，无需实例化
-    """
-
-    def __init__(self, func):
-        self.func = func
-
-    def __get__(self, instance: Any, cls: Type) -> str:
-        # 调用传入的函数，并传入类本身作为第一个参数
-        return self.func(cls)
+import netifaces
 
 
 class Snowflake:
-    """雪花算法生成器（生产级优化版，无公网依赖，适配内网/K8s环境）"""
-    # 基础配置（可根据业务调整）
+    """雪花算法生成器（无公网依赖，适配内网环境）"""
     START_TIMESTAMP = 1388534400000  # 2014-01-01 00:00:00
     SEQUENCE_BITS = 12
     MACHINE_ID_BITS = 10
@@ -33,10 +17,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 +27,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,73 +54,72 @@ 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:
                 return self._hash_to_machine_id(local_ip)
-        except Exception:
+            else:
+                # logger.warning("读取网卡信息成功，但未找到非回环内网IP")
+                pass
+        except Exception as e:
+            # logger.warning(f"读取本机网卡IP失败: {e}，尝试使用主机名")
             pass
 
         # 4. 兜底2：获取容器主机名（K8s中默认等于Pod名称，保证唯一）
         hostname = socket.gethostname()
         if hostname:
+            # logger.info(
+            #     f"未读取到POD_NAME/POD_IP/内网IP，使用主机名: {hostname}生成machine_id")
             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)
+        # logger.warning(f"所有方式均失败，使用随机数生成machine_id: {random_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）和docker虚拟地址（172.17.0.0/16可选过滤）
                         if ip and not ip.startswith('127.'):
+                            # 可选：过滤docker0的默认地址段（根据实际内网段调整）
+                            # if not ip.startswith('172.17.'):
                             return ip
             return None
-        except Exception:
-            # psutil调用失败，降级到纯内置方法
+        except ImportError:
+            # 若未安装netifaces，降级为socket方式（仅尝试本地解析，无公网连接）
+            # logger.warning("未安装netifaces库，尝试降级方式获取IP")
             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))
+            # 绑定到0.0.0.0:0（仅用于获取本机IP，不发送数据）
+            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 +128,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,71 +177,45 @@ 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
-    def id(cls) -> str:
-        """
-        直接通过 `Snowflake.id` 属性生成雪花ID（兼容Python 3.11+）
-        :return: 雪花ID字符串
-        """
-        return cls.next_id()
-
 
 if __name__ == "__main__":
-    print("=== 生产级雪花算法ID生成测试 ===")
-    # 1. 基础生成测试
-    id1 = Snowflake.id
-    id2 = Snowflake.id
-    id3 = Snowflake.id
-    print(f"生成ID1: {id1}")
-    print(f"生成ID2: {id2}")
-    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}")
-
-    # 3. 批量唯一性验证（10000个ID）
-    print("\n=== 批量唯一性验证（10000个）===")
-    id_set = set()
-    duplicate_count = 0
-    for i in range(10000):
-        snow_id = Snowflake.id
-        if snow_id in id_set:
-            duplicate_count += 1
-        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=== 生产级雪花算法验证通过 ===")
+    # 生成1000个ID并验证
+    id_set = set()  # 用于检测重复ID
+    _MAX_JAVA_LONG = 9223372036854775807
+
+    for i in range(1000):
+        id_str = Snowflake.next_id()
+        id_num = int(id_str)
+
+        # 验证ID不超过Java long最大值
+        assert id_num <= _MAX_JAVA_LONG, f"ID超过Java long最大值: {id_num}"
+
+        # 验证ID不重复
+        assert id_str not in id_set, f"重复生成ID: {id_str}"
+        id_set.add(id_str)
+
+        # 每100个ID打印一次解析结果
+        if i % 100 == 0:
+            parse_result = Snowflake.parse_id(id_num)
+            print(f"生成ID: {id_str}")
+            print(f"解析结果: {parse_result}")
+            print("-" * 50)
+
+    print(f"成功生成{len(id_set)}个唯一雪花ID，验证通过！")

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

@@ -1,25 +1,25 @@
 Metadata-Version: 2.4
 Name: sycommon-python-lib
-Version: 0.1.55
+Version: 0.1.55a0
 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: fastapi>=0.121.2
+Requires-Dist: kafka-python>=2.2.16
 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: pydantic>=2.12.5
+Requires-Dist: netifaces>=0.11.0
+Requires-Dist: pydantic>=2.12.4
 Requires-Dist: python-dotenv>=1.2.1
 Requires-Dist: pyyaml>=6.0.3
-Requires-Dist: sqlalchemy[asyncio]>=2.0.45
-Requires-Dist: starlette>=0.50.0
-Requires-Dist: uvicorn>=0.40.0
+Requires-Dist: sqlalchemy>=2.0.44
+Requires-Dist: starlette>=0.49.3
+Requires-Dist: uuid>=1.30
+Requires-Dist: uvicorn>=0.38.0
 
 # sycommon-python-lib
 

{sycommon_python_lib-0.1.55.dist-info → sycommon_python_lib-0.1.55a0.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=Ctjpch9clULhRcSKFVlAjXDmEZ63KVHqch4xzXAQZdQ,21174
 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=ugqPgHdUydj7m481rM_RH-yrIK9hAdkLemdPSSOnQvw,6821
 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=U7RJFV8qPgWyFDpeIgmYpYnpXPrWj01kkigDf1k8sBY,8023
+sycommon/synacos/feign_client.py,sha256=qEJNQFX5irDnD6VwN79im42h9FKzoELPmdEAXzgwPT0,15435
+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=S3KWKFUKhgZ9QnzLvvaGTt2MavF9RvjDQqeUM99u6Kk,8589
 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.55a0.dist-info/METADATA,sha256=hlbD-d9IAS0lnH_ZdWhyA3c0ewXabuEFjcxeFetwBJw,7077
+sycommon_python_lib-0.1.55a0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.55a0.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.1.55a0.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.1.55a0.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