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

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

sycommon/logging/async_sql_logger.py

@@ -1,65 +0,0 @@
-from sqlalchemy import event
-from sqlalchemy.ext.asyncio import AsyncEngine
-from sycommon.logging.kafka_log import SYLogger
-import time
-from datetime import datetime
-from decimal import Decimal
-
-
-class AsyncSQLTraceLogger:
-    @staticmethod
-    def setup_sql_logging(engine):
-        """
-        为 SQLAlchemy 异步引擎注册事件监听器
-        注意：必须监听 engine.sync_engine，而不能直接监听 AsyncEngine
-        """
-        def serialize_params(params):
-            """处理特殊类型参数的序列化"""
-            if isinstance(params, (list, tuple)):
-                return [serialize_params(p) for p in params]
-            elif isinstance(params, dict):
-                return {k: serialize_params(v) for k, v in params.items()}
-            elif isinstance(params, datetime):
-                return params.isoformat()
-            elif isinstance(params, Decimal):
-                return float(params)
-            else:
-                return params
-
-        # ========== 核心修改 ==========
-        # 必须通过 engine.sync_engine 来获取底层的同步引擎进行监听
-        target = engine.sync_engine
-
-        @event.listens_for(target, "after_cursor_execute")
-        def after_cursor_execute(
-            conn, cursor, statement, parameters, context, executemany
-        ):
-            try:
-                # 从连接选项中获取开始时间
-                # conn 在这里是同步连接对象
-                start_time = conn.info.get('_start_time') or \
-                    conn._execution_options.get("_start_time", time.time())
-
-                execution_time = (time.time() - start_time) * 1000
-
-                sql_log = {
-                    "type": "SQL",
-                    "statement": statement,
-                    "parameters": serialize_params(parameters),
-                    "execution_time_ms": round(execution_time, 2),
-                }
-
-                # 注意：SYLogger.info 必须是线程安全的或非阻塞的，否则可能影响异步性能
-                SYLogger.info(f"SQL执行: {sql_log}")
-            except Exception as e:
-                SYLogger.error(f"SQL日志处理失败: {str(e)}")
-
-        @event.listens_for(target, "before_cursor_execute")
-        def before_cursor_execute(
-            conn, cursor, statement, parameters, context, executemany
-        ):
-            try:
-                # 记录开始时间到 execution_options
-                conn = conn.execution_options(_start_time=time.time())
-            except Exception as e:
-                SYLogger.error(f"SQL开始时间记录失败: {str(e)}")

sycommon/logging/logger_levels.py

@@ -1,23 +0,0 @@
-import logging
-
-
-def setup_logger_levels():
-    """配置各模块的日志级别，抑制无关INFO/DEBUG日志"""
-    # Nacos 客户端：仅输出WARNING及以上（屏蔽INFO级的心跳/注册日志）
-    logging.getLogger("nacos.client").setLevel(logging.WARNING)
-
-    # Kafka Python客户端：屏蔽INFO级的连接/版本检测日志
-    logging.getLogger("kafka.conn").setLevel(logging.WARNING)
-    logging.getLogger("kafka.producer").setLevel(logging.WARNING)
-
-    # Uvicorn/FastAPI：屏蔽启动/应用初始化的INFO日志（保留ERROR/WARNING）
-    # logging.getLogger("uvicorn").setLevel(logging.WARNING)
-    # logging.getLogger("uvicorn.access").setLevel(logging.WARNING)  # 屏蔽访问日志
-    # logging.getLogger("uvicorn.error").setLevel(logging.ERROR)     # 仅保留错误
-
-    # 自定义的root日志（如同步数据库/监听器初始化）：屏蔽INFO
-    logging.getLogger("root").setLevel(logging.WARNING)
-
-    # RabbitMQ相关日志（如果有专属日志器）
-    logging.getLogger("pika").setLevel(logging.WARNING)  # 若使用pika客户端
-    logging.getLogger("rabbitmq").setLevel(logging.WARNING)

sycommon/tools/merge_headers.py

@@ -1,97 +0,0 @@
-def merge_headers(
-    source_headers,  # 来源headers（支持多种格式：字典/MutableHeaders/键值对列表/元组）
-    target_headers,  # 目标headers（原有值需保留，同名覆盖source）
-    keep_keys=None,  # 需保留的key集合（None表示保留所有）
-    delete_keys={'content-length', 'accept',
-                 'content-type', 'sec-fetch-mode',
-                 'sec-fetch-dest', 'sec-fetch-site',
-                 'pragma', 'cache-control',
-                 'accept-encoding', 'priority'},  # 需删除的source key集合
-    encoding='utf-8'  # 字符编码（处理bytes转换）
-) -> dict:
-    """
-    合并headers，最终规则：
-    1. 所有key统一转为小写进行比较判断（完全大小写无关）
-    2. target_headers 同名key 完全覆盖 source_headers（source同名key不生效）
-    3. delete_keys 作用于source_headers：source中所有该列表内的key一律不添加（无论是否新增）
-    4. target_headers 中的key即使在delete_keys也始终保留，不受删除规则影响
-    5. 自动处理bytes/其他类型的键值转换为字符串
-    6. 最终输出的key全部为小写
-    """
-    # 初始化并统一转为小写集合
-    keep_keys = {k.lower() for k in keep_keys} if keep_keys else set()
-    delete_keys = {k.lower() for k in delete_keys} if delete_keys else set()
-
-    # 修复1：兼容 MutableHeaders/普通字典/None 等 target_headers 类型
-    if target_headers is None:
-        target_dict = {}
-    elif hasattr(target_headers, 'items'):
-        # 支持 MutableHeaders/Headers/普通字典（都有items()方法）
-        target_dict = dict(target_headers.items())
-    else:
-        # 兜底：可迭代对象转为字典
-        target_dict = dict(target_headers) if isinstance(
-            target_headers, (list, tuple)) else {}
-
-    # 标准化target_headers：key转为小写，保留原有值
-    processed_headers = {k.lower(): v for k, v in target_dict.items()}
-    target_original_keys = set(processed_headers.keys())
-
-    # 修复2：统一处理 source_headers 格式，确保是键值对迭代器
-    # 步骤1：将source_headers转为标准的键值对列表
-    if source_headers is None:
-        source_kv_list = []
-    elif hasattr(source_headers, 'items'):
-        # 字典/MutableHeaders → 转为键值对列表
-        source_kv_list = list(source_headers.items())
-    elif isinstance(source_headers, (list, tuple)):
-        # 列表/元组 → 校验并过滤合法的键值对（仅保留长度为2的元组/列表）
-        source_kv_list = []
-        for item in source_headers:
-            if isinstance(item, (list, tuple)) and len(item) == 2:
-                source_kv_list.append(item)
-            else:
-                # 跳过非法格式（如长度≠2的元素），避免解包报错
-                continue
-    else:
-        # 其他类型 → 空列表（避免迭代报错）
-        source_kv_list = []
-
-    # 处理来源headers的键值转换和合并（遍历标准化后的键值对）
-    for key, value in source_kv_list:
-        # 转换key为字符串并统一转为小写（判断用）
-        if not isinstance(key, str):
-            try:
-                key = key.decode(encoding, errors='replace') if isinstance(
-                    key, bytes) else str(key)
-            except Exception:
-                # 极端情况：无法转换的key直接跳过
-                continue
-
-        key_lower = key.lower()
-
-        # 转换value为字符串
-        if not isinstance(value, str):
-            try:
-                value = value.decode(encoding, errors='replace') if isinstance(
-                    value, bytes) else str(value)
-            except Exception:
-                # 无法转换的value设为空字符串
-                value = ""
-
-        # 过滤1：source的key在删除列表 → 直接跳过
-        if key_lower in delete_keys:
-            continue
-
-        # 过滤2：仅保留指定的key（如果设置了keep_keys）
-        if keep_keys and key_lower not in keep_keys:
-            continue
-
-        # 过滤3：target已有同名key → 直接跳过（target值覆盖source）
-        if key_lower in target_original_keys:
-            continue
-
-        # 仅添加符合条件的key-value（最终key为小写）
-        processed_headers[key_lower] = value
-
-    return processed_headers