sycommon-python-lib 0.1.56b3__tar.gz → 0.1.56b5__tar.gz

{sycommon_python_lib-0.1.56b3 → sycommon_python_lib-0.1.56b5}/PKG-INFO

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

{sycommon_python_lib-0.1.56b3 → sycommon_python_lib-0.1.56b5}/pyproject.toml

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

sycommon_python_lib-0.1.56b5/src/sycommon/llm/get_llm.py

@@ -0,0 +1,246 @@
+from typing import Dict, Type, List, Optional, Callable, Any
+from sycommon.llm.llm_logger import LLMLogger
+from langchain_core.language_models import BaseChatModel
+from langchain_core.runnables import Runnable, RunnableLambda, RunnableConfig
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.messages import BaseMessage, HumanMessage
+from langchain.chat_models import init_chat_model
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from pydantic import BaseModel, ValidationError, Field
+from sycommon.config.LLMConfig import LLMConfig
+from sycommon.llm.llm_tokens import TokensCallbackHandler
+from sycommon.logging.kafka_log import SYLogger
+
+
+class StructuredRunnableWithToken(Runnable):
+    """带Token统计的Runnable类"""
+
+    def __init__(self, retry_chain: Runnable):
+        super().__init__()
+        self.retry_chain = retry_chain
+
+    def _adapt_input(self, input: Any) -> List[BaseMessage]:
+        """适配输入格式"""
+        if isinstance(input, list) and all(isinstance(x, BaseMessage) for x in input):
+            return input
+        elif isinstance(input, BaseMessage):
+            return [input]
+        elif isinstance(input, str):
+            return [HumanMessage(content=input)]
+        elif isinstance(input, dict) and "input" in input:
+            return [HumanMessage(content=str(input["input"]))]
+        else:
+            raise ValueError(f"不支持的输入格式：{type(input)}")
+
+    def _get_callback_config(self, config: Optional[RunnableConfig] = None) -> tuple[RunnableConfig, TokensCallbackHandler]:
+        """构建包含Token统计的回调配置"""
+        # 每次调用创建新的Token处理器实例
+        token_handler = TokensCallbackHandler()
+
+        # 初始化配置
+        if config is None:
+            processed_config = {"callbacks": []}
+        else:
+            processed_config = config.copy()
+            if "callbacks" not in processed_config:
+                processed_config["callbacks"] = []
+
+        # 添加回调（去重）
+        callbacks = processed_config["callbacks"]
+        # 添加LLMLogger（如果不存在）
+        if not any(isinstance(cb, LLMLogger) for cb in callbacks):
+            callbacks.append(LLMLogger())
+        # 添加Token处理器
+        callbacks.append(token_handler)
+
+        # 按类型去重
+        callback_types = {}
+        unique_callbacks = []
+        for cb in callbacks:
+            cb_type = type(cb)
+            if cb_type not in callback_types:
+                callback_types[cb_type] = cb
+                unique_callbacks.append(cb)
+
+        processed_config["callbacks"] = unique_callbacks
+
+        return processed_config, token_handler
+
+    # 同步调用
+    def invoke(self, input: Any, config: Optional[RunnableConfig] = None, ** kwargs) -> Dict[str, Any]:
+        try:
+            processed_config, token_handler = self._get_callback_config(
+                config)
+            adapted_input = self._adapt_input(input)
+
+            structured_result = self.retry_chain.invoke(
+                {"messages": adapted_input},
+                config=processed_config,
+                **kwargs
+            )
+
+            # 获取Token统计结果
+            token_usage = token_handler.usage_metadata
+            structured_result._token_usage_ = token_usage
+
+            return structured_result
+
+        except Exception as e:
+            SYLogger.error(f"同步LLM调用失败: {str(e)}", exc_info=True)
+            return None
+
+    # 异步调用
+    async def ainvoke(self, input: Any, config: Optional[RunnableConfig] = None, ** kwargs) -> Dict[str, Any]:
+        try:
+            processed_config, token_handler = self._get_callback_config(
+                config)
+            adapted_input = self._adapt_input(input)
+
+            structured_result = await self.retry_chain.ainvoke(
+                {"messages": adapted_input},
+                config=processed_config,
+                **kwargs
+            )
+
+            token_usage = token_handler.usage_metadata
+            structured_result._token_usage_ = token_usage
+
+            return structured_result
+
+        except Exception as e:
+            SYLogger.error(f"异步LLM调用失败: {str(e)}", exc_info=True)
+            return None
+
+
+class LLMWithAutoTokenUsage(BaseChatModel):
+    """自动为结构化调用返回token_usage的LLM包装类"""
+    llm: BaseChatModel = Field(default=None)
+
+    def __init__(self, llm: BaseChatModel, **kwargs):
+        super().__init__(llm=llm, ** kwargs)
+
+    def with_structured_output(
+        self,
+        output_model: Type[BaseModel],
+        max_retries: int = 3,
+        is_extract: bool = False,
+        override_prompt: ChatPromptTemplate = None,
+        custom_processors: Optional[List[Callable[[str], str]]] = None,
+        custom_parser: Optional[Callable[[str], BaseModel]] = None
+    ) -> Runnable:
+        """返回支持自动统计Token的结构化Runnable"""
+        parser = PydanticOutputParser(pydantic_object=output_model)
+
+        # 提示词模板
+        accuracy_instructions = """
+        字段值的抽取准确率（0~1之间），评分规则：
+        1.0（完全准确）：直接从原文提取，无需任何加工，且格式与原文完全一致
+        0.9（轻微处理）：数据来源明确，但需进行格式标准化或冗余信息剔除（不改变原始数值）
+        0.8（有限推断）：数据需通过上下文关联或简单计算得出，仍有明确依据
+        0.8以下（不可靠）：数据需大量推测、存在歧义或来源不明，处理方式：直接忽略该数据，设置为None
+        """
+
+        if is_extract:
+            prompt = ChatPromptTemplate.from_messages([
+                MessagesPlaceholder(variable_name="messages"),
+                HumanMessage(content=f"""
+                请提取信息并遵循以下规则：
+                1. 准确率要求：{accuracy_instructions.strip()}
+                2. 输出格式：{parser.get_format_instructions()}
+                """)
+            ])
+        else:
+            prompt = override_prompt or ChatPromptTemplate.from_messages([
+                MessagesPlaceholder(variable_name="messages"),
+                HumanMessage(content=f"""
+                输出格式：{parser.get_format_instructions()}
+                """)
+            ])
+
+        # 文本处理函数
+        def extract_response_content(response: BaseMessage) -> str:
+            try:
+                return response.content
+            except Exception as e:
+                raise ValueError(f"提取响应内容失败：{str(e)}") from e
+
+        def strip_code_block_markers(content: str) -> str:
+            try:
+                return content.strip("```json").strip("```").strip()
+            except Exception as e:
+                raise ValueError(f"移除代码块标记失败：{str(e)}") from e
+
+        def normalize_in_json(content: str) -> str:
+            try:
+                return content.replace("None", "null").replace("none", "null").replace("NONE", "null").replace("''", '""')
+            except Exception as e:
+                raise ValueError(f"JSON格式化失败：{str(e)}") from e
+
+        def default_parse_to_pydantic(content: str) -> BaseModel:
+            try:
+                return parser.parse(content)
+            except (ValidationError, ValueError) as e:
+                raise ValueError(f"解析结构化结果失败：{str(e)}") from e
+
+        # ========== 构建处理链 ==========
+        base_chain = prompt | self.llm | RunnableLambda(
+            extract_response_content)
+
+        # 文本处理链
+        process_runnables = custom_processors or [
+            RunnableLambda(strip_code_block_markers),
+            RunnableLambda(normalize_in_json)
+        ]
+        process_chain = base_chain
+        for runnable in process_runnables:
+            process_chain = process_chain | runnable
+
+        # 解析链
+        parse_chain = process_chain | RunnableLambda(
+            custom_parser or default_parse_to_pydantic)
+
+        # 重试链
+        retry_chain = parse_chain.with_retry(
+            retry_if_exception_type=(ValidationError, ValueError),
+            stop_after_attempt=max_retries,
+            wait_exponential_jitter=True,
+            exponential_jitter_params={
+                "initial": 0.1, "max": 3.0, "exp_base": 2.0, "jitter": 1.0}
+        )
+
+        return StructuredRunnableWithToken(retry_chain)
+
+    # ========== 实现BaseChatModel抽象方法 ==========
+    def _generate(self, messages, stop=None, run_manager=None, ** kwargs):
+        return self.llm._generate(messages, stop=stop, run_manager=run_manager, ** kwargs)
+
+    @property
+    def _llm_type(self) -> str:
+        return self.llm._llm_type
+
+
+def get_llm(
+    model: str = None,
+    streaming: bool = False
+) -> LLMWithAutoTokenUsage:
+    if not model:
+        model = "Qwen2.5-72B"
+
+    llmConfig = LLMConfig.from_config(model)
+    if not llmConfig:
+        raise Exception(f"无效的模型配置：{model}")
+
+    llm = init_chat_model(
+        model_provider=llmConfig.provider,
+        model=llmConfig.model,
+        base_url=llmConfig.baseUrl,
+        api_key="-",
+        temperature=0.1,
+        streaming=streaming,
+        callbacks=[LLMLogger()]
+    )
+
+    if llm is None:
+        raise Exception(f"初始化原始LLM实例失败：{model}")
+
+    return LLMWithAutoTokenUsage(llm)

sycommon_python_lib-0.1.56b5/src/sycommon/llm/llm_tokens.py

@@ -0,0 +1,119 @@
+from typing import Any
+from langchain_core.callbacks import AsyncCallbackHandler
+from langchain_core.outputs.llm_result import LLMResult
+from sycommon.logging.kafka_log import SYLogger
+
+
+class TokensCallbackHandler(AsyncCallbackHandler):
+    """
+    继承AsyncCallbackHandler的Token统计处理器
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.input_tokens = 0
+        self.output_tokens = 0
+        self.total_tokens = 0
+        self.usage_metadata = {}
+        self.reset()
+
+    def reset(self):
+        """重置Token统计数据"""
+        self.input_tokens = 0
+        self.output_tokens = 0
+        self.total_tokens = 0
+        self.usage_metadata = {
+            "input_tokens": 0,
+            "output_tokens": 0,
+            "total_tokens": 0
+        }
+
+    # ========== 同步回调方法（兼容签名） ==========
+    def on_llm_end(
+        self,
+        response: LLMResult,
+        **kwargs: Any,
+    ) -> None:
+        """同步LLM调用结束时的回调"""
+        self._parse_token_usage(response)
+
+    # ========== 异步回调方法（兼容签名） ==========
+    async def on_llm_end(
+        self,
+        response: LLMResult,
+        **kwargs: Any,
+    ) -> None:
+        """异步LLM调用结束时的回调"""
+        self._parse_token_usage(response)
+
+    def _parse_token_usage(self, response: LLMResult) -> None:
+        """
+        通用Token解析逻辑，不依赖特定类结构
+        兼容各种LLM响应格式
+        """
+        try:
+            # 情况1: 标准LangChain响应（有llm_output属性）
+            if response.llm_output:
+                llm_output = response.llm_output
+                self._parse_from_llm_output(llm_output)
+
+            # 情况2: 包含generations的响应
+            elif response.generations:
+                self._parse_from_generations(response.generations)
+
+            # 计算总Token
+            if self.total_tokens <= 0:
+                self.total_tokens = self.input_tokens + self.output_tokens
+
+            # 更新metadata
+            self.usage_metadata = {
+                "input_tokens": self.input_tokens,
+                "output_tokens": self.output_tokens,
+                "total_tokens": self.total_tokens
+            }
+
+            SYLogger.debug(
+                f"Token统计成功 - 输入: {self.input_tokens}, 输出: {self.output_tokens}")
+
+        except Exception as e:
+            SYLogger.warning(f"Token解析失败: {str(e)}", exc_info=True)
+            self.reset()
+
+    def _parse_from_llm_output(self, llm_output: dict) -> None:
+        """从llm_output字典解析Token信息"""
+        if not isinstance(llm_output, dict):
+            return
+
+        # OpenAI标准格式
+        if 'token_usage' in llm_output:
+            token_usage = llm_output['token_usage']
+            self.input_tokens = token_usage.get(
+                'prompt_tokens', token_usage.get('input_tokens', 0))
+            self.output_tokens = token_usage.get(
+                'completion_tokens', token_usage.get('output_tokens', 0))
+            self.total_tokens = token_usage.get('total_tokens', 0)
+
+        # 直接包含Token信息
+        else:
+            self.input_tokens = llm_output.get(
+                'input_tokens', llm_output.get('prompt_tokens', 0))
+            self.output_tokens = llm_output.get(
+                'output_tokens', llm_output.get('completion_tokens', 0))
+            self.total_tokens = token_usage.get('total_tokens', 0)
+
+    def _parse_from_generations(self, generations: list) -> None:
+        """从generations列表解析Token信息"""
+        if not isinstance(generations, list) or len(generations) == 0:
+            return
+
+        # 遍历generation信息
+        for gen_group in generations:
+            for generation in gen_group:
+                if hasattr(generation, 'generation_info') and generation.generation_info:
+                    gen_info = generation.generation_info
+                    self.input_tokens = gen_info.get(
+                        'input_tokens', gen_info.get('prompt_tokens', 0))
+                    self.output_tokens = gen_info.get(
+                        'output_tokens', gen_info.get('completion_tokens', 0))
+                    self.total_tokens = gen_info.get('total_tokens', 0)
+                    return

{sycommon_python_lib-0.1.56b3 → sycommon_python_lib-0.1.56b5}/src/sycommon/rabbitmq/rabbitmq_client.py

@@ -145,10 +145,15 @@ class RabbitMQClient:
             raise RuntimeError("客户端已关闭，无法重新连接")
 
         async with self._connect_lock:
-            # 释放旧资源（回调+通道，单通道无需归还，仅清理状态）
-            if self._conn_close_callback and self._channel_conn:
-                self._channel_conn.close_callbacks.discard(
-                    self._conn_close_callback)
+            # 1. 清理旧连接回调（防止内存泄漏）
+            if self._channel_conn and self._conn_close_callback:
+                try:
+                    self._channel_conn.close_callbacks.discard(
+                        self._conn_close_callback)
+                except Exception:
+                    pass
+
+            # 2. 清理状态
             self._channel = None
             self._channel_conn = None
             self._exchange = None
@@ -156,18 +161,14 @@ class RabbitMQClient:
             self._conn_close_callback = None
 
             try:
-                # 从单通道池获取通道+连接（连接池自动确保通道有效）
+                # 3. 获取新通道
                 self._channel, self._channel_conn = await self.connection_pool.acquire_channel()
 
+                # 4. 设置新连接回调（使用 weakref）
                 def on_conn_closed(conn: AbstractRobustConnection, exc: Optional[BaseException]):
-                    """连接关闭回调：触发固定间隔重连"""
-                    logger.warning(
-                        f"客户端连接关闭: {conn!r}，原因: {exc}", exc_info=exc)
-                    self._reconnect_fail_count += 1
-                    # 超过阈值告警
-                    if self._reconnect_fail_count >= self._reconnect_alert_threshold:
-                        logger.error(
-                            f"连接失败次数已达阈值({self._reconnect_alert_threshold})，请检查MQ服务状态")
+                    # 注意：这里需要访问外部的 self，使用闭包或 weakref
+                    # 简单起见，这里用闭包，但务必在 self.close 或 self.connect 时清理回调
+                    logger.warning(f"检测到连接关闭: {exc}")
                     if not self._closed:
                         asyncio.create_task(self._safe_reconnect())
 
@@ -176,20 +177,26 @@ class RabbitMQClient:
                     self._channel_conn.close_callbacks.add(
                         self._conn_close_callback)
 
-                # 重建交换机/队列资源
+                # 5. 重建资源
                 await self._rebuild_resources()
 
-                # 重连成功，重置失败计数器
+                # 重置计数
                 self._reconnect_fail_count = 0
                 logger.info("客户端连接初始化完成")
             except Exception as e:
                 logger.error(f"客户端连接失败: {str(e)}", exc_info=True)
-                # 清理异常状态
-                if self._conn_close_callback and self._channel_conn:
-                    self._channel_conn.close_callbacks.discard(
-                        self._conn_close_callback)
+                # 失败时也要清理可能产生的残留引用
+                if self._channel_conn and self._conn_close_callback:
+                    try:
+                        self._channel_conn.close_callbacks.discard(
+                            self._conn_close_callback)
+                    except Exception:
+                        pass
+                # 清空状态
                 self._channel = None
                 self._channel_conn = None
+                self._conn_close_callback = None
+
                 # 触发重连
                 if not self._closed:
                     asyncio.create_task(self._safe_reconnect())