sycommon-python-lib 0.2.0b29__tar.gz → 0.2.0b32__tar.gz

{sycommon_python_lib-0.2.0b29 → sycommon_python_lib-0.2.0b32}/PKG-INFO

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

{sycommon_python_lib-0.2.0b29 → sycommon_python_lib-0.2.0b32}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sycommon-python-lib"
-version = "0.2.0b29"
+version = "0.2.0b32"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.11"

{sycommon_python_lib-0.2.0b29 → sycommon_python_lib-0.2.0b32}/src/sycommon/heartbeat_process/heartbeat_process_manager.py

@@ -217,16 +217,24 @@ class HeartbeatProcessManager:
         worker.run()
 
     @classmethod
-    def stop(cls, timeout: float = 10.0) -> None:
+    def stop(cls, timeout: float = 10.0, from_signal_handler: bool = False) -> None:
         """停止心跳进程
 
         Args:
             timeout: 等待进程退出的超时时间（秒）
+            from_signal_handler: 是否从信号处理函数中调用（信号处理函数中不能使用 Loguru）
         """
         if not cls._is_running or cls._process is None:
             return
 
-        logger.info("正在停止心跳进程...")
+        def _log(msg: str):
+            """信号处理函数中使用 print，其他情况使用 logger"""
+            if from_signal_handler:
+                print(f"[HeartbeatProcessManager] {msg}")
+            else:
+                logger.info(msg)
+
+        _log("正在停止心跳进程...")
 
         try:
             # 设置停止信号
@@ -237,17 +245,23 @@ class HeartbeatProcessManager:
             cls._process.join(timeout=timeout)
 
             if cls._process.is_alive():
-                logger.warning("心跳进程未能在超时时间内退出，强制终止")
+                _log("心跳进程未能在超时时间内退出，强制终止")
                 cls._process.terminate()
                 cls._process.join(timeout=2.0)
 
                 if cls._process.is_alive():
-                    logger.error("心跳进程强制终止失败")
+                    if from_signal_handler:
+                        print("[HeartbeatProcessManager] 心跳进程强制终止失败")
+                    else:
+                        logger.error("心跳进程强制终止失败")
 
-            logger.info("心跳进程已停止")
+            _log("心跳进程已停止")
 
         except Exception as e:
-            logger.error(f"停止心跳进程异常: {e}")
+            if from_signal_handler:
+                print(f"[HeartbeatProcessManager] 停止心跳进程异常: {e}")
+            else:
+                logger.error(f"停止心跳进程异常: {e}")
         finally:
             cls._cleanup()
 

{sycommon_python_lib-0.2.0b29 → sycommon_python_lib-0.2.0b32}/src/sycommon/llm/get_llm.py

@@ -59,9 +59,15 @@ def get_llm(
         # 指令模式（默认）
         llm = get_llm("Qwen3.5-122B-A10B", thinking=False)
 
-        # 结构化输出
+        # 结构化输出 - 默认模式（推荐）
+        # use_native=False（默认）：使用 OutputFixingRunnable，更稳定
         llm = get_llm("Qwen3.5-122B-A10B")
-        chain = llm.with_structured_output(MyModel)
+        chain = llm.with_structured_output(MyModel)  # use_native=False 默认
+        result = await chain.ainvoke([HumanMessage(content="你好")])
+
+        # 使用原生模式（需模型支持 function calling）
+        llm = get_llm("Qwen3.5-122B-A10B")
+        chain = llm.with_structured_output(MyModel, use_native=True)
         result = await chain.ainvoke([HumanMessage(content="你好")])
         print(result._token_usage_)  # Token 统计
 
@@ -146,6 +152,7 @@ def get_llm(
         "streaming": streaming,
         "timeout": timeout,
         "max_retries": max_retries,
+        "model_kwargs": {"response_format": {"type": "json_object"}},
     }
 
     # 合并其他透传参数（包括 presence_penalty, extra_body, top_p 等）

{sycommon_python_lib-0.2.0b29 → sycommon_python_lib-0.2.0b32}/src/sycommon/llm/llm_with_token_tracking.py

@@ -200,6 +200,15 @@ class LLMWithTokenTracking(BaseChatModel):
     def _llm_type(self) -> str:
         return self.llm._llm_type
 
+    def _stream(self, messages, stop=None, run_manager=None, **kwargs):
+        """流式生成 - 委托给底层 LLM"""
+        yield from self.llm._stream(messages, stop=stop, run_manager=run_manager, **kwargs)
+
+    async def _astream(self, messages, stop=None, run_manager=None, **kwargs):
+        """异步流式生成 - 委托给底层 LLM"""
+        async for chunk in self.llm._astream(messages, stop=stop, run_manager=run_manager, **kwargs):
+            yield chunk
+
     def __getattr__(self, name):
         """代理所有其他属性到原始 llm（如 model_name, max_tokens, with_structured_output 等）"""
         try:

sycommon_python_lib-0.2.0b32/src/sycommon/llm/native_with_fallback_runnable.py

@@ -0,0 +1,201 @@
+# -*- coding: utf-8 -*-
+"""
+原生模式 + 降级修正 Runnable
+
+第一次使用原生 with_structured_output，失败后降级到修正逻辑。
+"""
+
+import json
+import re
+from typing import Type, Optional, Any
+
+from pydantic import BaseModel, ValidationError
+from langchain_core.language_models import BaseChatModel
+from langchain_core.runnables import Runnable, RunnableConfig
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.messages import HumanMessage
+
+
+class NativeWithFallbackRunnable(Runnable):
+    """
+    原生模式 + 降级修正 Runnable
+
+    第一次使用原生 with_structured_output，失败后降级到修正逻辑。
+    """
+
+    def __init__(
+        self,
+        native_runnable: Runnable,
+        llm: BaseChatModel,
+        output_model: Type[BaseModel],
+        max_retries: int = 3
+    ):
+        super().__init__()
+        self.native_runnable = native_runnable
+        self.llm = llm
+        self.output_model = output_model
+        self.max_retries = max_retries
+        self.parser = PydanticOutputParser(pydantic_object=output_model)
+
+    def _try_parse_result(self, result) -> BaseModel:
+        """尝试将结果转换为 Pydantic 模型"""
+        if isinstance(result, self.output_model):
+            return result
+
+        if isinstance(result, dict):
+            return self.output_model(**result)
+
+        if isinstance(result, str):
+            processed = self._process_content(result)
+            data = json.loads(processed)
+            return self.output_model(**data)
+
+        raise ValueError(f"无法将结果转换为 {self.output_model.__name__}")
+
+    def _process_content(self, content: str) -> str:
+        """处理内容"""
+        content = content.strip("```json").strip("```").strip()
+        json_match = re.search(r'\{[\s\S]*\}', content)
+        if json_match:
+            content = json_match.group(0)
+        content = content.replace("None", "null").replace("none", "null").replace("NONE", "null")
+        content = content.replace('"', '"').replace('"', '"')
+        return content
+
+    def _extract_content(self, response) -> str:
+        """从 LLM 响应中提取文本内容"""
+        if hasattr(response, 'content'):
+            return response.content
+        return str(response)
+
+    def _request_fix(self, messages: list, failed_output: str, error_message: str, config=None) -> str:
+        """请求 LLM 修正输出"""
+        fix_prompt = f"""上一次输出解析失败，请根据错误信息修正后重新输出。
+
+**重要提示**：
+1. 必须严格按照指定的 JSON schema 输出
+2. 不能遗漏任何必需字段（required fields）
+3. 不能添加 schema 中未定义的字段
+4. 字段类型必须匹配（字符串、数字、列表、对象等）
+
+错误信息：
+{error_message}
+
+上一次输出：
+{failed_output}
+
+输出格式，请严格按照以下 JSON schema 输出，不要输出任何多余内容：
+{self.parser.get_format_instructions()}"""
+
+        fix_messages = messages + [HumanMessage(content=fix_prompt)]
+        response = self.llm.invoke(fix_messages, config=config)
+        return self._extract_content(response)
+
+    async def _arequest_fix(self, messages: list, failed_output: str, error_message: str, config=None) -> str:
+        """异步请求 LLM 修正输出"""
+        fix_prompt = f"""上一次输出解析失败，请根据错误信息修正后重新输出。
+
+**重要提示**：
+1. 必须严格按照指定的 JSON schema 输出
+2. 不能遗漏任何必需字段（required fields）
+3. 不能添加 schema 中未定义的字段
+4. 字段类型必须匹配（字符串、数字、列表、对象等）
+
+错误信息：
+{error_message}
+
+上一次输出：
+{failed_output}
+
+输出格式，请严格按照以下 JSON schema 输出，不要输出任何多余内容：
+{self.parser.get_format_instructions()}"""
+
+        fix_messages = messages + [HumanMessage(content=fix_prompt)]
+        response = await self.llm.ainvoke(fix_messages, config=config)
+        return self._extract_content(response)
+
+    def invoke(self, input: Any, config: Optional[RunnableConfig] = None) -> BaseModel:
+        """同步调用"""
+        messages = input if isinstance(input, list) else input.get("messages", [])
+        last_error = None
+        last_content = None
+
+        for attempt in range(self.max_retries):
+            try:
+                if attempt == 0:
+                    # 第一次：使用原生 runnable
+                    result = self.native_runnable.invoke(input, config=config)
+                    return self._try_parse_result(result)
+                else:
+                    # 修正模式
+                    from sycommon.logging.kafka_log import SYLogger
+                    SYLogger.warning(f"[Native降级修正] 第 {attempt} 次尝试，错误: {last_error}")
+
+                    last_content = self._request_fix(
+                        messages, last_content or "", str(last_error), config
+                    )
+                    processed = self._process_content(last_content)
+                    try:
+                        result = self.parser.parse(processed)
+                        return result
+                    except Exception:
+                        data = json.loads(processed)
+                        return self.output_model(**data)
+
+            except (ValidationError, json.JSONDecodeError, ValueError, TypeError) as e:
+                last_error = e
+                from sycommon.logging.kafka_log import SYLogger
+                if attempt == 0:
+                    try:
+                        last_content = str(result) if 'result' in dir() else ""
+                    except:
+                        last_content = ""
+                    SYLogger.warning(f"[Native降级修正] 原生模式失败，降级到修正模式: {e}")
+
+                if attempt == self.max_retries - 1:
+                    raise ValueError(f"经过 {self.max_retries} 次尝试仍无法解析: {last_error}")
+
+        raise ValueError("未知错误")
+
+    async def ainvoke(self, input: Any, config: Optional[RunnableConfig] = None) -> BaseModel:
+        """异步调用"""
+        messages = input if isinstance(input, list) else input.get("messages", [])
+        last_error = None
+        last_content = None
+
+        for attempt in range(self.max_retries):
+            try:
+                if attempt == 0:
+                    # 第一次：使用原生 runnable
+                    result = await self.native_runnable.ainvoke(input, config=config)
+                    return self._try_parse_result(result)
+                else:
+                    # 修正模式
+                    from sycommon.logging.kafka_log import SYLogger
+                    SYLogger.warning(f"[Native降级修正] 第 {attempt} 次尝试，错误: {last_error}")
+
+                    last_content = await self._arequest_fix(
+                        messages, last_content or "", str(last_error), config
+                    )
+                    processed = self._process_content(last_content)
+                    try:
+                        result = self.parser.parse(processed)
+                        return result
+                    except Exception:
+                        data = json.loads(processed)
+                        return self.output_model(**data)
+
+            except (ValidationError, json.JSONDecodeError, ValueError, TypeError) as e:
+                last_error = e
+                from sycommon.logging.kafka_log import SYLogger
+                if attempt == 0:
+                    try:
+                        last_content = str(result) if 'result' in dir() else ""
+                    except:
+                        last_content = ""
+                    SYLogger.warning(f"[Native降级修正] 原生模式失败，降级到修正模式: {e}")
+
+                if attempt == self.max_retries - 1:
+                    raise ValueError(f"经过 {self.max_retries} 次尝试仍无法解析: {last_error}")
+
+        raise ValueError("未知错误")

sycommon_python_lib-0.2.0b32/src/sycommon/llm/output_fixing_runnable.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+"""
+结构化输出自动修正 Runnable
+
+当 JSON 解析失败时，自动将错误信息和原始输出发送给 LLM 请求修正。
+类似于 LangChain 旧版的 OutputFixingParser 功能。
+"""
+
+import json
+import re
+from typing import Type, Optional, Any
+
+from pydantic import BaseModel, ValidationError
+from langchain_core.language_models import BaseChatModel
+from langchain_core.runnables import Runnable, RunnableConfig
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.messages import HumanMessage
+
+
+class OutputFixingRunnable(Runnable):
+    """
+    结构化输出自动修正 Runnable
+
+    特点：
+    - 当解析失败时，自动将错误信息和原始输出发送给 LLM 请求修正
+    - 支持自定义最大重试次数
+    - 自动处理常见的 JSON 格式问题（中文引号、代码块标记等）
+
+    适用场景：
+    - 输出偶尔格式错误
+    - 需要稳定可靠的 JSON 解析
+    """
+
+    def __init__(
+        self,
+        base_chain: Runnable,
+        llm: BaseChatModel,
+        output_model: Type[BaseModel],
+        max_retries: int = 3
+    ):
+        super().__init__()
+        self.base_chain = base_chain
+        self.llm = llm
+        self.output_model = output_model
+        self.max_retries = max_retries
+        self.parser = PydanticOutputParser(pydantic_object=output_model)
+
+    def invoke(self, input: Any, config: Optional[RunnableConfig] = None) -> BaseModel:
+        """同步调用"""
+        # 获取 LLM 响应（通过 base_chain，包含 prompt）
+        response = self.base_chain.invoke(input, config=config)
+        content = self._extract_content(response)
+
+        last_error = None
+        last_content = content
+
+        for attempt in range(self.max_retries):
+            try:
+                # 处理内容并尝试解析
+                processed = self._process_content(last_content)
+                # 先尝试直接用 PydanticOutputParser 解析
+                try:
+                    result = self.parser.parse(processed)
+                    return result
+                except Exception:
+                    # 如果失败，尝试用 json.loads 解析后再实例化
+                    data = json.loads(processed)
+                    result = self.output_model(**data)
+                    return result
+            except (ValidationError, json.JSONDecodeError, ValueError, TypeError) as e:
+                last_error = e
+                from sycommon.logging.kafka_log import SYLogger
+                SYLogger.warning(f"[OutputFixing] 第 {attempt + 1} 次解析失败: {e}")
+
+                if attempt < self.max_retries - 1:
+                    # 请求 LLM 修正
+                    last_content = self._request_fix(
+                        original_input=input,
+                        failed_output=last_content,
+                        error_message=str(e),
+                        config=config
+                    )
+
+        raise ValueError(f"经过 {self.max_retries} 次尝试仍无法解析: {last_error}")
+
+    async def ainvoke(self, input: Any, config: Optional[RunnableConfig] = None) -> BaseModel:
+        """异步调用"""
+        # 获取 LLM 响应（通过 base_chain，包含 prompt）
+        response = await self.base_chain.ainvoke(input, config=config)
+        content = self._extract_content(response)
+
+        last_error = None
+        last_content = content
+
+        for attempt in range(self.max_retries):
+            try:
+                # 处理内容并尝试解析
+                processed = self._process_content(last_content)
+                # 先尝试直接用 PydanticOutputParser 解析
+                try:
+                    result = self.parser.parse(processed)
+                    return result
+                except Exception:
+                    # 如果失败，尝试用 json.loads 解析后再实例化
+                    data = json.loads(processed)
+                    result = self.output_model(**data)
+                    return result
+            except (ValidationError, json.JSONDecodeError, ValueError, TypeError) as e:
+                last_error = e
+                from sycommon.logging.kafka_log import SYLogger
+                SYLogger.warning(f"[OutputFixing] 第 {attempt + 1} 次解析失败: {e}")
+
+                if attempt < self.max_retries - 1:
+                    # 请求 LLM 修正
+                    last_content = await self._arequest_fix(
+                        original_input=input,
+                        failed_output=last_content,
+                        error_message=str(e),
+                        config=config
+                    )
+
+        raise ValueError(f"经过 {self.max_retries} 次尝试仍无法解析: {last_error}")
+
+    def _extract_content(self, response) -> str:
+        """从 LLM 响应中提取文本内容"""
+        if hasattr(response, 'content'):
+            return response.content
+        return str(response)
+
+    def _process_content(self, content: str) -> str:
+        """处理内容（移除代码块标记、规范化 JSON）"""
+        # 移除 markdown 代码块标记
+        content = content.strip("```json").strip("```").strip()
+
+        # 尝试提取 JSON 对象（处理前后有多余文本的情况）
+        json_match = re.search(r'\{[\s\S]*\}', content)
+        if json_match:
+            content = json_match.group(0)
+
+        # 规范化 null 值
+        content = content.replace("None", "null").replace(
+            "none", "null").replace("NONE", "null")
+
+        # 规范化中文引号为英文引号（只处理键和字符串值外部的引号）
+        content = content.replace('"', '"').replace('"', '"')
+
+        # 处理单引号（谨慎处理，只替换明显不是内容中的单引号）
+        # 不再简单替换所有单引号为双引号，因为这可能破坏内容
+
+        return content
+
+    def _request_fix(
+        self,
+        original_input: Any,
+        failed_output: str,
+        error_message: str,
+        config: Optional[RunnableConfig] = None
+    ) -> str:
+        """请求 LLM 修正输出"""
+        fix_prompt = f"""上一次输出解析失败，请根据错误信息修正后重新输出。
+
+**重要提示**：
+1. 必须严格按照指定的 JSON schema 输出
+2. 不能遗漏任何必需字段（required fields）
+3. 不能添加 schema 中未定义的字段
+4. 字段类型必须匹配（字符串、数字、列表、对象等）
+
+错误信息：
+{error_message}
+
+上一次输出：
+{failed_output}
+
+输出格式，请严格按照以下 JSON schema 输出，不要输出任何多余内容：
+{self.parser.get_format_instructions()}"""
+
+        # 提取原始消息
+        messages = original_input.get("messages", []) if isinstance(
+            original_input, dict) else []
+        fix_messages = messages + [HumanMessage(content=fix_prompt)]
+
+        response = self.llm.invoke(fix_messages, config=config)
+        return self._extract_content(response)
+
+    async def _arequest_fix(
+        self,
+        original_input: Any,
+        failed_output: str,
+        error_message: str,
+        config: Optional[RunnableConfig] = None
+    ) -> str:
+        """异步请求 LLM 修正输出"""
+        fix_prompt = f"""上一次输出解析失败，请根据错误信息修正后重新输出。
+
+**重要提示**：
+1. 必须严格按照指定的 JSON schema 输出
+2. 不能遗漏任何必需字段（required fields）
+3. 不能添加 schema 中未定义的字段
+4. 字段类型必须匹配（字符串、数字、列表、对象等）
+
+错误信息：
+{error_message}
+
+上一次输出：
+{failed_output}
+
+输出格式，请严格按照以下 JSON schema 输出，不要输出任何多余内容：
+{self.parser.get_format_instructions()}"""
+
+        # 提取原始消息
+        messages = original_input.get("messages", []) if isinstance(
+            original_input, dict) else []
+        fix_messages = messages + [HumanMessage(content=fix_prompt)]
+
+        response = await self.llm.ainvoke(fix_messages, config=config)
+        return self._extract_content(response)

{sycommon_python_lib-0.2.0b29 → sycommon_python_lib-0.2.0b32}/src/sycommon/llm/token_usage_mysql_service.py

@@ -101,7 +101,7 @@ class TokenUsageMySQLService(metaclass=SingletonMeta):
                 # 创建表（如果不存在）
                 await session.execute(text(f"""
                     CREATE TABLE IF NOT EXISTS token_usage_daily (
-                        id INT AUTO_INCREMENT PRIMARY KEY,
+                        id INT AUTO_INCREMENT PRIMARY KEY COMMENT '主键ID',
                         user_id VARCHAR(128) NULL COMMENT '用户ID',
                         tenant_id VARCHAR(128) NULL COMMENT '租户ID',
                         service_name VARCHAR(128) NULL COMMENT '服务名称',
@@ -113,7 +113,7 @@ class TokenUsageMySQLService(metaclass=SingletonMeta):
                         usage_date DATE NOT NULL COMMENT '使用日期',
                         created_at DATETIME DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
                         updated_at DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
-                        UNIQUE KEY uq_user_service_env_date (user_id, service_name, system_env, usage_date),
+                        UNIQUE KEY uniq_user_service_env_date (user_id, service_name, system_env, usage_date),
                         INDEX idx_user_id (user_id),
                         INDEX idx_service_name (service_name),
                         INDEX idx_tenant_id (tenant_id),