sycommon-python-lib 0.1.56b5__py3-none-any.whl → 0.1.57b1__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', 300000)
+        self.Timeout = self.config.get('Timeout', 600000)
         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,6 +42,18 @@ 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:
@@ -71,6 +83,15 @@ 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/config/LangfuseConfig.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+
+
+class LangfuseConfig(BaseModel):
+    name: str
+    secretKey: str
+    publicKey: str
+    baseUrl: str
+    enable: bool
+
+    @classmethod
+    def from_config(cls, server_name: str):
+        from sycommon.config.Config import Config
+        langfuse_config = Config().get_langfuse_config(server_name)
+        return cls(**langfuse_config)

sycommon/config/SentryConfig.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+
+
+class SentryConfig(BaseModel):
+    name: str
+    dsn: str
+    enable: bool
+
+    @classmethod
+    def from_config(cls, server_name: str):
+        from sycommon.config.Config import Config
+        sentry_config = Config().get_sentry_config(server_name)
+        return cls(**sentry_config)

sycommon/llm/embedding.py

@@ -25,15 +25,21 @@ 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
@@ -46,14 +52,23 @@ class Embedding(metaclass=SingletonMeta):
             }
             request_body.update(kwargs)
 
-            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()
+            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 def _get_reranker_http_async(
         self,
@@ -64,9 +79,13 @@ 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
@@ -84,19 +103,29 @@ class Embedding(metaclass=SingletonMeta):
             }
             request_body.update(kwargs)
 
-            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()
+            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 def get_embeddings(
         self,
         corpus: List[str],
-        model: str = None
+        model: str = None,
+        timeout: Optional[Union[int, float]] = None
     ):
         """
         获取语料库的嵌入向量，结果顺序与输入语料库顺序一致
@@ -104,12 +133,24 @@ 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})")
-        # 给每个异步任务传入模型名称
+            f"Requesting embeddings for corpus: {corpus} (model: {model or self.default_embedding_model}, max_concurrency: {self.max_concurrency}, timeout: {timeout or 'None'})")
+
+        # 给每个异步任务传入模型名称和超时配置
         tasks = [self._get_embeddings_http_async(
-            text, model=model) for text in corpus]
+            text, model=model, timeout=request_timeout) for text in corpus]
         results = await asyncio.gather(*tasks)
 
         vectors = []
@@ -131,7 +172,8 @@ class Embedding(metaclass=SingletonMeta):
         self,
         top_results: List[str],
         query: str,
-        model: str = None
+        model: str = None,
+        timeout: Optional[Union[int, float]] = None
     ):
         """
         对搜索结果进行重排序
@@ -140,10 +182,23 @@ 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})")
-        data = await self._get_reranker_http_async(top_results, query, model=model)
+            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)
         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,222 +1,8 @@
-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
+from sycommon.llm.sy_langfuse import LangfuseInitializer
+from sycommon.llm.usage_token import LLMWithAutoTokenUsage
 
 
 def get_llm(
@@ -230,6 +16,11 @@ def get_llm(
     if not llmConfig:
         raise Exception(f"无效的模型配置：{model}")
 
+    # 初始化Langfuse
+    langfuse_callbacks, langfuse = LangfuseInitializer.get()
+
+    callbacks = [LLMLogger()] + langfuse_callbacks
+
     llm = init_chat_model(
         model_provider=llmConfig.provider,
         model=llmConfig.model,
@@ -237,10 +28,10 @@ def get_llm(
         api_key="-",
         temperature=0.1,
         streaming=streaming,
-        callbacks=[LLMLogger()]
+        callbacks=callbacks
     )
 
     if llm is None:
         raise Exception(f"初始化原始LLM实例失败：{model}")
 
-    return LLMWithAutoTokenUsage(llm)
+    return LLMWithAutoTokenUsage(llm, langfuse)