sycommon-python-lib 0.1.56__py3-none-any.whl → 0.1.56b2__py3-none-any.whl

sycommon/config/Config.py

@@ -15,13 +15,13 @@ class Config(metaclass=SingletonMeta):
         with open(config_file, 'r', encoding='utf-8') as f:
             self.config = yaml.safe_load(f)
         self.MaxBytes = self.config.get('MaxBytes', 209715200)
-        self.Timeout = self.config.get('Timeout', 600000)
+        self.Timeout = self.config.get('Timeout', 300000)
         self.MaxRetries = self.config.get('MaxRetries', 3)
+        self.OCR = self.config.get('OCR', None)
+        self.INVOICE_OCR = self.config.get('INVOICE_OCR', None)
         self.llm_configs = []
         self.embedding_configs = []
         self.reranker_configs = []
-        self.sentry_configs = []
-        self.langfuse_configs = []
         self._process_config()
 
     def get_llm_config(self, model_name):
@@ -42,18 +42,6 @@ class Config(metaclass=SingletonMeta):
                 return llm
         raise ValueError(f"No configuration found for model: {model_name}")
 
-    def get_sentry_config(self, name):
-        for sentry in self.sentry_configs:
-            if sentry.get('name') == name:
-                return sentry
-        raise ValueError(f"No configuration found for server: {name}")
-
-    def get_langfuse_config(self, name):
-        for langfuse in self.langfuse_configs:
-            if langfuse.get('name') == name:
-                return langfuse
-        raise ValueError(f"No configuration found for server: {name}")
-
     def _process_config(self):
         llm_config_list = self.config.get('LLMConfig', [])
         for llm_config in llm_config_list:
@@ -83,15 +71,6 @@ class Config(metaclass=SingletonMeta):
             except ValueError as e:
                 print(f"Invalid LLM configuration: {e}")
 
-        sentry_config_list = self.config.get('SentryConfig', [])
-        for sentry_config in sentry_config_list:
-            try:
-                from sycommon.config.SentryConfig import SentryConfig
-                validated_config = SentryConfig(**sentry_config)
-                self.sentry_configs.append(validated_config.model_dump())
-            except ValueError as e:
-                print(f"Invalid Sentry configuration: {e}")
-
     def set_attr(self, share_configs: dict):
         self.config = {**self.config, **
                        share_configs.get('llm', {}), **share_configs}

sycommon/llm/embedding.py

@@ -25,21 +25,15 @@ class Embedding(metaclass=SingletonMeta):
 
         # 并发信号量
         self.semaphore = asyncio.Semaphore(self.max_concurrency)
-        # 全局默认超时：永不超时（None）
-        self.default_timeout = aiohttp.ClientTimeout(total=None)
 
     async def _get_embeddings_http_async(
         self,
         input: Union[str, List[str]],
         encoding_format: str = None,
         model: str = None,
-        timeout: aiohttp.ClientTimeout = None,
         **kwargs
     ):
         async with self.semaphore:
-            # 优先使用传入的超时，无则用全局默认
-            request_timeout = timeout or self.default_timeout
-
             # 优先使用传入的模型名，无则用默认值
             target_model = model or self.default_embedding_model
             target_base_url = EmbeddingConfig.from_config(target_model).baseUrl
@@ -52,23 +46,14 @@ class Embedding(metaclass=SingletonMeta):
             }
             request_body.update(kwargs)
 
-            try:
-                async with aiohttp.ClientSession(timeout=request_timeout) as session:
-                    async with session.post(url, json=request_body) as response:
-                        if response.status != 200:
-                            error_detail = await response.text()
-                            SYLogger.error(
-                                f"Embedding request failed (model: {target_model}): {error_detail}")
-                            return None
-                        return await response.json()
-            except asyncio.TimeoutError:
-                SYLogger.error(
-                    f"Embedding request timeout (model: {target_model})")
-                return None
-            except Exception as e:
-                SYLogger.error(
-                    f"Embedding request unexpected error (model: {target_model}): {str(e)}")
-                return None
+            async with aiohttp.ClientSession() as session:
+                async with session.post(url, json=request_body) as response:
+                    if response.status != 200:
+                        error_detail = await response.text()
+                        SYLogger.error(
+                            f"Embedding request failed (model: {target_model}): {error_detail}")
+                        return None
+                    return await response.json()
 
     async def _get_reranker_http_async(
         self,
@@ -79,13 +64,9 @@ class Embedding(metaclass=SingletonMeta):
         max_chunks_per_doc: Optional[int] = None,
         return_documents: Optional[bool] = True,
         return_len: Optional[bool] = True,
-        timeout: aiohttp.ClientTimeout = None,
         **kwargs
     ):
         async with self.semaphore:
-            # 优先使用传入的超时，无则用全局默认
-            request_timeout = timeout or self.default_timeout
-
             # 优先使用传入的模型名，无则用默认值
             target_model = model or self.default_reranker_model
             target_base_url = RerankerConfig.from_config(target_model).baseUrl
@@ -103,29 +84,19 @@ class Embedding(metaclass=SingletonMeta):
             }
             request_body.update(kwargs)
 
-            try:
-                async with aiohttp.ClientSession(timeout=request_timeout) as session:
-                    async with session.post(url, json=request_body) as response:
-                        if response.status != 200:
-                            error_detail = await response.text()
-                            SYLogger.error(
-                                f"Rerank request failed (model: {target_model}): {error_detail}")
-                            return None
-                        return await response.json()
-            except asyncio.TimeoutError:
-                SYLogger.error(
-                    f"Rerank request timeout (model: {target_model})")
-                return None
-            except Exception as e:
-                SYLogger.error(
-                    f"Rerank request unexpected error (model: {target_model}): {str(e)}")
-                return None
+            async with aiohttp.ClientSession() as session:
+                async with session.post(url, json=request_body) as response:
+                    if response.status != 200:
+                        error_detail = await response.text()
+                        SYLogger.error(
+                            f"Rerank request failed (model: {target_model}): {error_detail}")
+                        return None
+                    return await response.json()
 
     async def get_embeddings(
         self,
         corpus: List[str],
-        model: str = None,
-        timeout: Optional[Union[int, float]] = None
+        model: str = None
     ):
         """
         获取语料库的嵌入向量，结果顺序与输入语料库顺序一致
@@ -133,24 +104,12 @@ class Embedding(metaclass=SingletonMeta):
         Args:
             corpus: 待生成嵌入向量的文本列表
             model: 可选，指定使用的embedding模型名称，默认使用bge-large-zh-v1.5
-            timeout: 可选，超时时间（秒）：
-                     - 传int/float：表示总超时时间（秒）
-                     - 不传/None：使用默认永不超时配置
         """
-        request_timeout = None
-        if timeout is not None:
-            if isinstance(timeout, (int, float)):
-                request_timeout = aiohttp.ClientTimeout(total=timeout)
-            else:
-                SYLogger.warning(
-                    f"Invalid timeout type: {type(timeout)}, must be int/float, use default timeout")
-
         SYLogger.info(
-            f"Requesting embeddings for corpus: {corpus} (model: {model or self.default_embedding_model}, max_concurrency: {self.max_concurrency}, timeout: {timeout or 'None'})")
-
-        # 给每个异步任务传入模型名称和超时配置
+            f"Requesting embeddings for corpus: {corpus} (model: {model or self.default_embedding_model}, max_concurrency: {self.max_concurrency})")
+        # 给每个异步任务传入模型名称
         tasks = [self._get_embeddings_http_async(
-            text, model=model, timeout=request_timeout) for text in corpus]
+            text, model=model) for text in corpus]
         results = await asyncio.gather(*tasks)
 
         vectors = []
@@ -172,8 +131,7 @@ class Embedding(metaclass=SingletonMeta):
         self,
         top_results: List[str],
         query: str,
-        model: str = None,
-        timeout: Optional[Union[int, float]] = None
+        model: str = None
     ):
         """
         对搜索结果进行重排序
@@ -182,23 +140,10 @@ class Embedding(metaclass=SingletonMeta):
             top_results: 待重排序的文本列表
             query: 排序参考的查询语句
             model: 可选，指定使用的reranker模型名称，默认使用bge-reranker-large
-            timeout: 可选，超时时间（秒）：
-                     - 传int/float：表示总超时时间（秒）
-                     - 不传/None：使用默认永不超时配置
         """
-        request_timeout = None
-        if timeout is not None:
-            if isinstance(timeout, (int, float)):
-                request_timeout = aiohttp.ClientTimeout(total=timeout)
-            else:
-                SYLogger.warning(
-                    f"Invalid timeout type: {type(timeout)}, must be int/float, use default timeout")
-
         SYLogger.info(
-            f"Requesting reranker for top_results: {top_results} (model: {model or self.default_reranker_model}, max_concurrency: {self.max_concurrency}, timeout: {timeout or 'None'})")
-
-        data = await self._get_reranker_http_async(
-            top_results, query, model=model, timeout=request_timeout)
+            f"Requesting reranker for top_results: {top_results} (model: {model or self.default_reranker_model}, max_concurrency: {self.max_concurrency})")
+        data = await self._get_reranker_http_async(top_results, query, model=model)
         SYLogger.info(
             f"Reranker for top_results: {top_results} completed (model: {model or self.default_reranker_model})")
         return data

sycommon/llm/get_llm.py

@@ -1,37 +1,177 @@
+from typing import Dict, Type, List, Union, Optional, Callable
+
 from sycommon.llm.llm_logger import LLMLogger
+from langchain_core.language_models import BaseChatModel
+from langchain_core.runnables import Runnable, RunnableLambda
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.messages import BaseMessage, SystemMessage, HumanMessage
 from langchain.chat_models import init_chat_model
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from pydantic import BaseModel, ValidationError
 from sycommon.config.LLMConfig import LLMConfig
-from sycommon.llm.sy_langfuse import LangfuseInitializer
-from sycommon.llm.usage_token import LLMWithAutoTokenUsage
 
 
-def get_llm(
-    model: str = None,
-    streaming: bool = False
-) -> LLMWithAutoTokenUsage:
+def get_llm(model: str = None, streaming: bool = False) -> BaseChatModel:
     if not model:
         model = "Qwen2.5-72B"
-
+        # model = "SyMid"
     llmConfig = LLMConfig.from_config(model)
-    if not llmConfig:
-        raise Exception(f"无效的模型配置：{model}")
+    llm = None
+    if llmConfig:
+        llm = init_chat_model(
+            model_provider=llmConfig.provider,
+            model=llmConfig.model,
+            base_url=llmConfig.baseUrl,
+            api_key="-",
+            temperature=0.1,
+            streaming=streaming,
+        )
+    else:
+        raise Exception("Invalid model")
+
+    # 为LLM动态添加with_structured_output方法，官方的with_structured_output方法有概率在qwen2.5中导致模型卡死不返回数据，2.5对functioncall支持不好
+    def with_structured_output(
+        self: BaseChatModel,
+        output_model: Type[BaseModel],
+        max_retries: int = 3,
+        is_extract: bool = False,
+        override_prompt: ChatPromptTemplate = None,
+        # 自定义处理函数列表（每个函数接收str，返回str）
+        custom_processors: Optional[List[Callable[[str], str]]] = None,
+        # 自定义解析函数（接收str，返回BaseModel）
+        custom_parser: Optional[Callable[[str], BaseModel]] = None
+    ) -> Runnable[List[BaseMessage], BaseModel]:
+        parser = PydanticOutputParser(pydantic_object=output_model)
+
+        accuracy_instructions = """
+        字段值的抽取准确率（0~1之间），评分规则：
+        1.0（完全准确）：直接从原文提取，无需任何加工，且格式与原文完全一致
+        0.9（轻微处理）：数据来源明确，但需进行格式标准化或冗余信息剔除（不改变原始数值）
+        0.8（有限推断）：数据需通过上下文关联或简单计算得出，仍有明确依据
+        0.8以下（不可靠）：数据需大量推测、存在歧义或来源不明，处理方式：直接忽略该数据，设置为None
+        """
+
+        if is_extract:
+            # 抽取模式下使用固定的抽取专用prompt
+            prompt = ChatPromptTemplate.from_messages([
+                MessagesPlaceholder(variable_name="messages"),
+                HumanMessage(content=f"""
+                请提取信息并遵循以下规则：
+                1. 准确率要求：{accuracy_instructions.strip()}
+                2. 输出格式：{parser.get_format_instructions()}
+                """)
+            ])
+        else:
+            if override_prompt:
+                prompt = override_prompt
+            else:
+                prompt = 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:
+            """移除JSON代码块标记（```json/```）"""
+            try:
+                return content.strip("```json").strip("```").strip()
+            except Exception as e:
+                raise ValueError(
+                    f"移除代码块标记失败（内容：{str(content)[:100]}）：{str(e)}") from e
+
+        def normalize_in_json(content: str) -> str:
+            """将None替换为null，确保JSON格式合法"""
+            try:
+                cleaned = content.replace("None", "null")
+                cleaned = cleaned.replace("none", "null")
+                cleaned = cleaned.replace("NONE", "null")
+                cleaned = cleaned.replace("''", '""')
+                return cleaned
+            except Exception as e:
+                raise ValueError(
+                    f"替换None为null失败（内容：{str(content)[:100]}）：{str(e)}") from e
+
+        def default_parse_to_pydantic(content: str) -> BaseModel:
+            """默认解析函数：将处理后的文本解析为Pydantic模型"""
+            try:
+                return parser.parse(content)
+            except (ValidationError, ValueError) as e:
+                raise type(e)(f"解析失败（原始内容：{content[:200]}）：{str(e)}") from e
+
+        # ========== 构建处理链条 ==========
+        # 基础链 prompt → LLM → 提取响应内容
+        base_chain = (
+            prompt
+            | self
+            | RunnableLambda(extract_response_content)
+        )
+
+        # 处理函数链 优先使用自定义，否则用默认
+        if custom_processors:
+            # 自定义处理函数 → 转为RunnableLambda列表
+            process_runnables = [RunnableLambda(
+                func) for func in custom_processors]
+        else:
+            # 默认处理函数：移除代码块标记 → 标准化JSON空值
+            process_runnables = [
+                RunnableLambda(strip_code_block_markers),
+                RunnableLambda(normalize_in_json)
+            ]
+
+        # 拼接处理链
+        process_chain = base_chain
+        for runnable in process_runnables:
+            process_chain = process_chain | runnable
+
+        # 解析函数 优先使用自定义，否则用默认
+        parse_func = custom_parser if custom_parser else default_parse_to_pydantic
+        parse_chain = process_chain | RunnableLambda(parse_func)
+
+        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,  # 指数基数（默认2）
+                "jitter": 1.0    # 随机抖动值（默认1）
+            }
+        )
 
-    # 初始化Langfuse
-    langfuse_callbacks, langfuse = LangfuseInitializer.get()
+        class StructuredRunnable(Runnable[Union[List[BaseMessage], BaseMessage, str, Dict[str, str]], BaseModel]):
+            def _adapt_input(self, input: Union[List[BaseMessage], BaseMessage, str, Dict[str, str]]) -> List[BaseMessage]:
+                """将多种输入格式统一转换为 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(
+                        "不支持的输入格式，请使用消息列表、单条消息、文本或 {'input': '文本'}")
 
-    callbacks = [LLMLogger()] + langfuse_callbacks
+            def invoke(self, input: Union[List[BaseMessage], BaseMessage, str, Dict[str, str]], config={"callbacks": [LLMLogger()]}):
+                adapted_input = self._adapt_input(input)
+                return retry_chain.invoke({"messages": adapted_input}, config=config)
 
-    llm = init_chat_model(
-        model_provider=llmConfig.provider,
-        model=llmConfig.model,
-        base_url=llmConfig.baseUrl,
-        api_key="-",
-        temperature=0.1,
-        streaming=streaming,
-        callbacks=callbacks
-    )
+            async def ainvoke(self, input: Union[List[BaseMessage], BaseMessage, str, Dict[str, str]], config={"callbacks": [LLMLogger()]}):
+                adapted_input = self._adapt_input(input)
+                return await retry_chain.ainvoke({"messages": adapted_input}, config=config)
 
-    if llm is None:
-        raise Exception(f"初始化原始LLM实例失败：{model}")
+        return StructuredRunnable()
 
-    return LLMWithAutoTokenUsage(llm, langfuse)
+    llm.__class__.with_structured_output = with_structured_output
+    return llm