sycommon-python-lib 0.1.56b18__py3-none-any.whl → 0.1.57__py3-none-any.whl

sycommon/llm/get_llm.py

@@ -1,295 +1,8 @@
-import os
-from typing import Dict, Tuple, Type, List, Optional, Callable, Any
-from langfuse import Langfuse, get_client, propagate_attributes
-from sycommon.config.Config import Config
 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
-from sycommon.tools.env import get_env_var
-from sycommon.tools.merge_headers import get_header_value
-from langfuse.langchain import CallbackHandler
-
-
-class StructuredRunnableWithToken(Runnable):
-    """带Token统计的Runnable类"""
-
-    def __init__(self, retry_chain: Runnable, langfuse: Langfuse):
-        super().__init__()
-        self.retry_chain = retry_chain
-        self.langfuse = langfuse
-        self.metadata = {"langfuse_session_id": SYLogger.get_trace_id()}
-
-    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:
-            with self.langfuse.start_as_current_observation(as_type="span", name="invoke") as span:
-                trace_id = SYLogger.get_trace_id()
-                userid = get_header_value(
-                    SYLogger.get_headers(), "x-userid-header")
-                syVersion = get_header_value(
-                    SYLogger.get_headers(), "s-y-version")
-
-                user_id = userid or syVersion or get_env_var('VERSION')
-                with propagate_attributes(session_id=trace_id, user_id=user_id):
-                    processed_config, token_handler = self._get_callback_config(
-                        config)
-                    adapted_input = self._adapt_input(input)
-                    input = {"messages": adapted_input}
-
-                    span.update_trace(input=input)
-
-                    structured_result = self.retry_chain.invoke(
-                        input,
-                        config={**processed_config, **self.metadata},
-                        **kwargs
-                    )
-
-                    span.update_trace(output=structured_result)
-
-                    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:
-            with self.langfuse.start_as_current_observation(as_type="span", name="ainvoke") as span:
-                trace_id = SYLogger.get_trace_id()
-                userid = get_header_value(
-                    SYLogger.get_headers(), "x-userid-header")
-                syVersion = get_header_value(
-                    SYLogger.get_headers(), "s-y-version")
-
-                user_id = userid or syVersion or get_env_var('VERSION')
-                with propagate_attributes(session_id=trace_id, user_id=user_id):
-                    processed_config, token_handler = self._get_callback_config(
-                        config)
-                    adapted_input = self._adapt_input(input)
-
-                    input = {"messages": adapted_input}
-
-                    span.update_trace(input=input)
-
-                    structured_result = await self.retry_chain.ainvoke(
-                        input,
-                        config={**processed_config, **self.metadata},
-                        **kwargs
-                    )
-
-                    span.update_trace(output=structured_result)
-
-                    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)
-    langfuse: Optional[Langfuse] = Field(default=None, exclude=True)
-
-    def __init__(self, llm: BaseChatModel, langfuse: Langfuse, **kwargs):
-        super().__init__(llm=llm, langfuse=langfuse, **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, self.langfuse)
-
-    # ========== 实现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 _init_langfuse() -> Tuple[List[CallbackHandler], Optional[Langfuse]]:
-    """
-    初始化 Langfuse 组件的辅助函数
-    """
-    callbacks = []
-    langfuse = None
-
-    # 基础日志回调
-    callbacks.append(LLMLogger())
-    config_dict = Config().config
-
-    server_name = config_dict.get('Name', '')
-    langfuse_configs = config_dict.get('LangfuseConfig', [])
-    environment = config_dict.get('Nacos', {}).get('namespaceId', '')
-
-    # 查找当前服务对应的 Langfuse 配置
-    target_config = next(
-        (item for item in langfuse_configs if item.get('name') == server_name), None
-    )
-
-    if target_config and target_config.get('enable', False):
-        # 设置环境变量
-        os.environ["LANGFUSE_SECRET_KEY"] = target_config.get('secretKey', '')
-        os.environ["LANGFUSE_PUBLIC_KEY"] = target_config.get('publicKey', '')
-        os.environ["LANGFUSE_BASE_URL"] = target_config.get('baseUrl', '')
-        os.environ["LANGFUSE_TRACING_ENVIRONMENT"] = environment
-        os.environ["OTEL_SERVICE_NAME"] = server_name
-
-        # 创建 Langfuse Handler 和 Client
-        langfuse_handler = CallbackHandler(
-            trace_context={"trace_id": SYLogger.get_trace_id()}
-        )
-        callbacks.append(langfuse_handler)
-        langfuse = get_client()
-
-    return callbacks, langfuse
+from sycommon.llm.sy_langfuse import LangfuseInitializer
+from sycommon.llm.usage_token import LLMWithAutoTokenUsage
 
 
 def get_llm(
@@ -303,7 +16,10 @@ def get_llm(
     if not llmConfig:
         raise Exception(f"无效的模型配置：{model}")
 
-    callbacks, langfuse = _init_langfuse()
+    # 初始化Langfuse
+    langfuse_callbacks, langfuse = LangfuseInitializer.get()
+
+    callbacks = [LLMLogger()] + langfuse_callbacks
 
     llm = init_chat_model(
         model_provider=llmConfig.provider,

sycommon/llm/struct_token.py

@@ -0,0 +1,192 @@
+from typing import Dict, List, Optional, Any
+from langfuse import Langfuse, LangfuseSpan, propagate_attributes
+from sycommon.llm.llm_logger import LLMLogger
+from langchain_core.runnables import Runnable, RunnableConfig
+from langchain_core.messages import BaseMessage, HumanMessage
+from sycommon.llm.llm_tokens import TokensCallbackHandler
+from sycommon.logging.kafka_log import SYLogger
+from sycommon.tools.env import get_env_var
+from sycommon.tools.merge_headers import get_header_value
+
+
+class StructuredRunnableWithToken(Runnable):
+    """带Token统计的Runnable类"""
+
+    def __init__(self, retry_chain: Runnable, langfuse: Optional[Langfuse]):
+        super().__init__()
+        self.retry_chain = retry_chain
+        self.langfuse = langfuse
+
+    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,
+        trace_id: Optional[str] = None,
+        user_id: Optional[str] = None
+    ) -> tuple[RunnableConfig, TokensCallbackHandler]:
+        """构建包含Token统计和metadata的回调配置"""
+        token_handler = TokensCallbackHandler()
+
+        if config is None:
+            processed_config = {"callbacks": [], "metadata": {}}
+        else:
+            processed_config = config.copy()
+            if "callbacks" not in processed_config:
+                processed_config["callbacks"] = []
+            if "metadata" not in processed_config:
+                processed_config["metadata"] = {}
+
+        # 添加 Langfuse metadata
+        if trace_id:
+            processed_config["metadata"]["langfuse_session_id"] = trace_id
+        if user_id:
+            processed_config["metadata"]["langfuse_user_id"] = user_id
+
+        callbacks = processed_config["callbacks"]
+        if not any(isinstance(cb, LLMLogger) for cb in callbacks):
+            callbacks.append(LLMLogger())
+        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]:
+        # 获取 trace_id 和 user_id
+        trace_id = SYLogger.get_trace_id()
+        userid = get_header_value(SYLogger.get_headers(), "x-userid-header")
+        syVersion = get_header_value(SYLogger.get_headers(), "s-y-version")
+        user_id = userid or syVersion or get_env_var('VERSION')
+
+        # 判断是否启用 Langfuse
+        if self.langfuse:
+            try:
+                with self.langfuse.start_as_current_observation(as_type="span", name="invoke") as span:
+                    with propagate_attributes(session_id=trace_id, user_id=user_id):
+                        span.update_trace(user_id=user_id, session_id=trace_id)
+                        return self._execute_chain(input, config, trace_id, user_id, span)
+            except Exception as e:
+                # Langfuse 跟踪失败不应阻断业务，降级执行
+                SYLogger.error(f"Langfuse 同步跟踪失败: {str(e)}", exc_info=True)
+                return self._execute_chain(input, config, trace_id, user_id, None)
+        else:
+            # 未启用 Langfuse，直接执行业务逻辑
+            return self._execute_chain(input, config, trace_id, user_id, None)
+
+    async def ainvoke(self, input: Any, config: Optional[RunnableConfig] = None, **kwargs) -> Dict[str, Any]:
+        # 获取 trace_id 和 user_id
+        trace_id = SYLogger.get_trace_id()
+        userid = get_header_value(SYLogger.get_headers(), "x-userid-header")
+        syVersion = get_header_value(SYLogger.get_headers(), "s-y-version")
+        user_id = userid or syVersion or get_env_var('VERSION')
+
+        # 判断是否启用 Langfuse
+        if self.langfuse:
+            try:
+                with self.langfuse.start_as_current_observation(as_type="span", name="ainvoke") as span:
+                    with propagate_attributes(session_id=trace_id, user_id=user_id):
+                        span.update_trace(user_id=user_id, session_id=trace_id)
+                        return await self._aexecute_chain(input, config, trace_id, user_id, span)
+            except Exception as e:
+                # Langfuse 跟踪失败不应阻断业务，降级执行
+                SYLogger.error(f"Langfuse 异步跟踪失败: {str(e)}", exc_info=True)
+                return await self._aexecute_chain(input, config, trace_id, user_id, None)
+        else:
+            # 未启用 Langfuse，直接执行业务逻辑
+            return await self._aexecute_chain(input, config, trace_id, user_id, None)
+
+    def _execute_chain(
+        self,
+        input: Any,
+        config: Optional[RunnableConfig],
+        trace_id: str,
+        user_id: str,
+        span: LangfuseSpan
+    ) -> Dict[str, Any]:
+        """执行实际的调用逻辑 (同步)"""
+        try:
+            processed_config, token_handler = self._get_callback_config(
+                config,
+                trace_id=trace_id,
+                user_id=user_id
+            )
+
+            adapted_input = self._adapt_input(input)
+            input_data = {"messages": adapted_input}
+
+            if span:
+                span.update_trace(input=input_data)
+
+            structured_result = self.retry_chain.invoke(
+                input_data,
+                config=processed_config
+            )
+
+            if span:
+                span.update_trace(output=structured_result)
+
+            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 _aexecute_chain(
+        self,
+        input: Any,
+        config: Optional[RunnableConfig],
+        trace_id: str,
+        user_id: str,
+        span: LangfuseSpan
+    ) -> Dict[str, Any]:
+        """执行实际的调用逻辑 (异步)"""
+        try:
+            processed_config, token_handler = self._get_callback_config(
+                config,
+                trace_id=trace_id,
+                user_id=user_id
+            )
+
+            adapted_input = self._adapt_input(input)
+            input_data = {"messages": adapted_input}
+
+            if span:
+                span.update_trace(input=input_data)
+
+            structured_result = await self.retry_chain.ainvoke(
+                input_data,
+                config=processed_config
+            )
+
+            if span:
+                span.update_trace(output=structured_result)
+
+            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

sycommon/llm/sy_langfuse.py

@@ -0,0 +1,103 @@
+import os
+from typing import Tuple, List, Optional, Any, Dict
+from langfuse import Langfuse, get_client
+from sycommon.config.Config import Config, SingletonMeta
+from sycommon.logging.kafka_log import SYLogger
+from langfuse.langchain import CallbackHandler
+from sycommon.tools.env import get_env_var
+from sycommon.tools.merge_headers import get_header_value
+
+
+class LangfuseInitializer(metaclass=SingletonMeta):
+    """
+    Langfuse 初始化管理器
+    """
+
+    def __init__(self):
+        self._langfuse_client: Optional[Langfuse] = None
+        self._base_callbacks: List[Any] = []
+
+        # 执行初始化
+        self._initialize()
+
+    def _initialize(self):
+        """执行实际的配置读取和组件创建"""
+        try:
+            config_dict = Config().config
+
+            server_name = config_dict.get('Name', '')
+            langfuse_configs = config_dict.get('LangfuseConfig', [])
+            environment = config_dict.get('Nacos', {}).get('namespaceId', '')
+
+            # 3. 查找匹配的配置项
+            target_config = next(
+                (item for item in langfuse_configs if item.get(
+                    'name') == server_name), None
+            )
+
+            # 4. 如果启用且配置存在，初始化 Langfuse
+            if target_config and target_config.get('enable', False):
+                # 设置环境变量
+                os.environ["LANGFUSE_SECRET_KEY"] = target_config.get(
+                    'secretKey', '')
+                os.environ["LANGFUSE_PUBLIC_KEY"] = target_config.get(
+                    'publicKey', '')
+                os.environ["LANGFUSE_BASE_URL"] = target_config.get(
+                    'baseUrl', '')
+                os.environ["LANGFUSE_TRACING_ENVIRONMENT"] = environment
+                os.environ["OTEL_SERVICE_NAME"] = server_name
+
+                self._langfuse_client = get_client()
+
+                langfuse_handler = CallbackHandler()
+                self._base_callbacks.append(langfuse_handler)
+
+                SYLogger.info(f"Langfuse 初始化成功 [Service: {server_name}]")
+            else:
+                SYLogger.info(f"Langfuse 未启用或未找到匹配配置 [Service: {server_name}]")
+
+        except Exception as e:
+            SYLogger.error(f"Langfuse 初始化异常: {str(e)}", exc_info=True)
+
+    @property
+    def callbacks(self) -> List[Any]:
+        """获取回调列表"""
+        return self._base_callbacks
+
+    @property
+    def metadata(self) -> Dict[str, Any]:
+        """动态生成包含 langfuse_session_id 和 langfuse_user_id 的 metadata"""
+        trace_id = SYLogger.get_trace_id()
+        userid = get_header_value(
+            SYLogger.get_headers(), "x-userid-header")
+        syVersion = get_header_value(
+            SYLogger.get_headers(), "s-y-version")
+        user_id = userid or syVersion or get_env_var('VERSION')
+        metadata_config = {
+            "langfuse_session_id": trace_id,
+            "langfuse_user_id": user_id,
+        }
+
+        return metadata_config
+
+    @property
+    def client(self) -> Optional[Langfuse]:
+        """获取 Langfuse 原生客户端实例"""
+        return self._langfuse_client
+
+    @property
+    def config(self) -> Dict[str, Any]:
+        return {
+            "callbacks": self.callbacks,
+            "metadata": self.metadata,
+        }
+
+    def get_components(self) -> Tuple[List[Any], Optional[Langfuse]]:
+        """获取 Langfuse 组件"""
+        return list(self._base_callbacks), self._langfuse_client
+
+    @staticmethod
+    def get() -> Tuple[List[Any], Optional[Langfuse]]:
+        """一句话获取组件"""
+        initializer = LangfuseInitializer()
+        return initializer.get_components()

sycommon/llm/usage_token.py

@@ -0,0 +1,117 @@
+from typing import Type, List, Optional, Callable
+from langfuse import Langfuse
+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, HumanMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from pydantic import BaseModel, ValidationError, Field
+from sycommon.llm.struct_token import StructuredRunnableWithToken
+
+
+class LLMWithAutoTokenUsage(BaseChatModel):
+    """自动为结构化调用返回token_usage的LLM包装类"""
+    llm: BaseChatModel = Field(default=None)
+    langfuse: Optional[Langfuse] = Field(default=None, exclude=True)
+
+    def __init__(self, llm: BaseChatModel, langfuse: Langfuse, **kwargs):
+        super().__init__(llm=llm, langfuse=langfuse, **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, self.langfuse)
+
+    # ========== 实现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

sycommon/rabbitmq/rabbitmq_client.py

@@ -27,6 +27,7 @@ class RabbitMQClient:
         exchange_name: str = "system.topic.exchange",
         exchange_type: str = "topic",
         queue_name: Optional[str] = None,
+        app_name: Optional[str] = None,
         routing_key: str = "#",
         durable: bool = True,
         auto_delete: bool = False,
@@ -45,6 +46,7 @@ class RabbitMQClient:
             logger.warning(f"无效的exchange_type: {exchange_type}，默认使用'topic'")
             self.exchange_type = ExchangeType.TOPIC
 
+        self.app_name = app_name.strip() if app_name else None
         self.queue_name = queue_name.strip() if queue_name else None
         self.routing_key = routing_key.strip() if routing_key else "#"
         self.durable = durable
@@ -104,7 +106,7 @@ class RabbitMQClient:
         logger.info(f"交换机重建成功: {self.exchange_name}")
 
         # 声明队列
-        if self.queue_name:
+        if self.queue_name and self.queue_name.endswith(f".{self.app_name}"):
             self._queue = await self._channel.declare_queue(
                 name=self.queue_name,
                 durable=self.durable,
@@ -181,7 +183,7 @@ class RabbitMQClient:
             await self._rebuild_resources()
 
             # --- 阶段3: 恢复消费 ---
-            if was_consuming and self._message_handler and self.queue_name:
+            if was_consuming and self._message_handler and self.queue_name and self.queue_name.endswith(f".{self.app_name}"):
                 logger.info("🔄 检测到重连前处于消费状态，尝试自动恢复...")
                 try:
                     self._queue = await self._channel.declare_queue(
@@ -270,7 +272,6 @@ class RabbitMQClient:
                     routing_key=message.routing_key,
                     delivery_tag=message.delivery_tag,
                     traceId=message.headers.get("trace-id"),
-                    headers=message.headers
                 )
 
             SYLogger.set_trace_id(msg_obj.traceId)
@@ -317,7 +318,7 @@ class RabbitMQClient:
                 await self.connect()
 
             if not self._queue:
-                if self.queue_name:
+                if self.queue_name and self.queue_name.endswith(f".{self.app_name}"):
                     self._queue = await self._channel.declare_queue(
                         name=self.queue_name,
                         durable=self.durable,
@@ -391,7 +392,7 @@ class RabbitMQClient:
 
                 result = await self._exchange.publish(
                     message=message,
-                    routing_key=self.routing_key or self.queue_name or "#",
+                    routing_key=self.routing_key,
                     mandatory=True,
                     timeout=5.0
                 )

sycommon/rabbitmq/rabbitmq_service_client_manager.py

@@ -100,13 +100,18 @@ class RabbitMQClientManager(RabbitMQCoreService):
             f"是否创建队列: {create_if_not_exists}"
         )
 
+        final_queue_name = None
+        if create_if_not_exists and processed_queue_name.endswith(f".{app_name}"):
+            final_queue_name = processed_queue_name
+
         # 创建客户端实例
         client = RabbitMQClient(
             connection_pool=cls._connection_pool,
             exchange_name=cls._config.get(
                 'exchange_name', "system.topic.exchange"),
             exchange_type=kwargs.get('exchange_type', "topic"),
-            queue_name=None if not create_if_not_exists else processed_queue_name,
+            queue_name=final_queue_name,
+            app_name=app_name,
             routing_key=kwargs.get(
                 'routing_key',
                 f"{queue_name.split('.')[0]}.#"

sycommon/services.py

@@ -19,24 +19,25 @@ class Services(metaclass=SingletonMeta):
     _loop: Optional[asyncio.AbstractEventLoop] = None
     _config: Optional[dict] = None
     _initialized: bool = False
-    _registered_senders: List[str] = []
     _instance: Optional['Services'] = None
     _app: Optional[FastAPI] = None
     _user_lifespan: Optional[Callable] = None
     _shutdown_lock: asyncio.Lock = asyncio.Lock()
 
-    # 用于存储待执行的异步数据库初始化任务
-    _pending_async_db_setup: List[Tuple[Callable, str]] = []
-
     def __init__(self, config: dict, app: FastAPI):
+        super().__init__()
         if not Services._config:
             Services._config = config
         Services._instance = self
         Services._app = app
+
+        # 在实例初始化时定义变量，防止类变量污染
+        self._pending_async_db_setup: List[Tuple[Callable, str]] = []
+
         self._init_event_loop()
 
     def _init_event_loop(self):
-        """初始化事件循环，确保全局只有一个循环实例"""
+        """初始化事件循环"""
         if not Services._loop:
             try:
                 Services._loop = asyncio.get_running_loop()
@@ -63,14 +64,20 @@ class Services(metaclass=SingletonMeta):
         setup_logger_levels()
         cls._app = app
         cls._config = config
+        # 保存原始的用户 lifespan
         cls._user_lifespan = app.router.lifespan_context
 
         applications.get_swagger_ui_html = custom_swagger_ui_html
         applications.get_redoc_html = custom_redoc_html
 
         if not cls._config:
-            config = yaml.safe_load(open('app.yaml', 'r', encoding='utf-8'))
-            cls._config = config
+            try:
+                with open('app.yaml', 'r', encoding='utf-8') as f:
+                    config = yaml.safe_load(f)
+                cls._config = config
+            except FileNotFoundError:
+                logging.warning("未找到 app.yaml，将使用空配置启动")
+                cls._config = {}
 
         app.state.config = {
             "host": cls._config.get('Host', '0.0.0.0'),
@@ -80,97 +87,95 @@ class Services(metaclass=SingletonMeta):
         }
 
         if middleware:
-            middleware(app, config)
+            middleware(app, cls._config)
 
         if nacos_service:
-            nacos_service(config)
+            nacos_service(cls._config)
 
         if logging_service:
-            logging_service(config)
+            logging_service(cls._config)
 
-        # 设置sentry
         sy_sentry_init()
 
-        # ========== 处理数据库服务 ==========
-        # 清空之前的待执行列表（防止热重载时重复）
-        cls._pending_async_db_setup = []
-
-        if database_service:
-            # 解析配置并区分同步/异步
-            items = [database_service] if isinstance(
-                database_service, tuple) else database_service
-            for item in items:
-                db_setup_func, db_name = item
-                if asyncio.iscoroutinefunction(db_setup_func):
-                    # 如果是异步函数，加入待执行列表
-                    logging.info(f"检测到异步数据库服务: {db_name}，将在应用启动时初始化")
-                    cls._pending_async_db_setup.append(item)
-                else:
-                    # 如果是同步函数，立即执行
-                    logging.info(f"执行同步数据库服务: {db_name}")
-                    try:
-                        db_setup_func(config, db_name)
-                    except Exception as e:
-                        logging.error(
-                            f"同步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
-                        raise
-
-        # 创建组合生命周期管理器
         @asynccontextmanager
-        async def combined_lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
-            # 1. 执行Services自身的初始化
-            instance = cls(config, app)
-
-            # ========== 执行挂起的异步数据库初始化 ==========
-            if cls._pending_async_db_setup:
-                logging.info("开始执行异步数据库初始化...")
-                for db_setup_func, db_name in cls._pending_async_db_setup:
-                    try:
-                        await db_setup_func(config, db_name)
-                        logging.info(f"异步数据库服务 {db_name} 初始化成功")
-                    except Exception as e:
-                        logging.error(
-                            f"异步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
-                        raise
-
-            # ========== 初始化 MQ ==========
-            has_valid_listeners = bool(
-                rabbitmq_listeners and len(rabbitmq_listeners) > 0)
-            has_valid_senders = bool(
-                rabbitmq_senders and len(rabbitmq_senders) > 0)
+        async def combined_lifespan(app_instance: FastAPI) -> AsyncGenerator[None, None]:
+            # 获取 Services 实例
+            instance = cls(config, app_instance)
 
             try:
-                if has_valid_listeners or has_valid_senders:
-                    await instance._setup_mq_async(
-                        rabbitmq_listeners=rabbitmq_listeners if has_valid_listeners else None,
-                        rabbitmq_senders=rabbitmq_senders if has_valid_senders else None,
-                        has_listeners=has_valid_listeners,
-                        has_senders=has_valid_senders
-                    )
-                cls._initialized = True
-                logging.info("Services初始化完成")
-            except Exception as e:
-                logging.error(f"Services初始化失败: {str(e)}", exc_info=True)
-                raise
+                # 1. 处理数据库服务
+                if database_service:
+                    instance._pending_async_db_setup = []
+
+                    items = [database_service] if isinstance(
+                        database_service, tuple) else database_service
+                    for item in items:
+                        db_setup_func, db_name = item
+                        if asyncio.iscoroutinefunction(db_setup_func):
+                            logging.info(f"注册异步数据库服务: {db_name}")
+                            instance._pending_async_db_setup.append(item)
+                        else:
+                            logging.info(f"执行同步数据库服务: {db_name}")
+                            try:
+                                db_setup_func(config, db_name)
+                            except Exception as e:
+                                logging.error(
+                                    f"同步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
+                                raise
+
+                # 2. 执行挂起的异步数据库初始化
+                if instance._pending_async_db_setup:
+                    logging.info("开始执行异步数据库初始化...")
+                    for db_setup_func, db_name in instance._pending_async_db_setup:
+                        try:
+                            await db_setup_func(config, db_name)
+                            logging.info(f"异步数据库服务 {db_name} 初始化成功")
+                        except Exception as e:
+                            logging.error(
+                                f"异步数据库服务 {db_name} 初始化失败: {e}", exc_info=True)
+                            raise
+
+                # 3. 初始化 MQ
+                has_valid_listeners = bool(
+                    rabbitmq_listeners and len(rabbitmq_listeners) > 0)
+                has_valid_senders = bool(
+                    rabbitmq_senders and len(rabbitmq_senders) > 0)
+
+                try:
+                    if has_valid_listeners or has_valid_senders:
+                        await instance._setup_mq_async(
+                            rabbitmq_listeners=rabbitmq_listeners if has_valid_listeners else None,
+                            rabbitmq_senders=rabbitmq_senders if has_valid_senders else None,
+                            has_listeners=has_valid_listeners,
+                            has_senders=has_valid_senders
+                        )
+                    cls._initialized = True
+                    logging.info("Services初始化完成")
+                except Exception as e:
+                    logging.error(f"MQ初始化失败: {str(e)}", exc_info=True)
+                    raise
 
-            app.state.services = instance
+                app_instance.state.services = instance
 
-            # 2. 执行用户定义的生命周期
-            if cls._user_lifespan:
-                async with cls._user_lifespan(app):
+                # 4. 执行用户定义的生命周期
+                if cls._user_lifespan:
+                    async with cls._user_lifespan(app_instance):
+                        yield
+                else:
                     yield
-            else:
-                yield
 
-            # 3. 执行Services的关闭逻辑
-            await cls.shutdown()
-            logging.info("Services已关闭")
+            except Exception:
+                # 如果启动过程中发生任何异常，确保进入 shutdown
+                logging.error("启动阶段发生异常，准备执行清理...")
+                raise
+            finally:
+                # 无论成功或失败，都会执行关闭逻辑
+                await cls.shutdown()
+                logging.info("Services已关闭")
 
         app.router.lifespan_context = combined_lifespan
         return app
 
-    # 移除了 _setup_database_static，因为逻辑已内联到 plugins 中
-
     async def _setup_mq_async(
         self,
         rabbitmq_listeners: Optional[List[RabbitMQListenerConfig]] = None,
@@ -186,12 +191,21 @@ class Services(metaclass=SingletonMeta):
         RabbitMQService.init(self._config, has_listeners, has_senders)
 
         start_time = asyncio.get_event_loop().time()
-        while not (RabbitMQService._connection_pool and RabbitMQService._connection_pool._initialized) and not RabbitMQService._is_shutdown:
-            if asyncio.get_event_loop().time() - start_time > 30:
-                raise TimeoutError("RabbitMQ连接池初始化超时（30秒）")
-            logging.info("等待RabbitMQ连接池初始化...")
+        timeout = 30  # 超时时间秒
+
+        # 等待连接池初始化
+        while not (RabbitMQService._connection_pool and RabbitMQService._connection_pool._initialized) \
+                and not RabbitMQService._is_shutdown:
+            if asyncio.get_event_loop().time() - start_time > timeout:
+                logging.error("RabbitMQ连接池初始化超时")
+                raise TimeoutError(f"RabbitMQ连接池初始化超时（{timeout}秒）")
+
+            logging.debug("等待RabbitMQ连接池初始化...")
             await asyncio.sleep(0.5)
 
+        if RabbitMQService._is_shutdown:
+            raise RuntimeError("RabbitMQService 在初始化期间被关闭")
+
         if has_senders and rabbitmq_senders:
             if has_listeners and rabbitmq_listeners:
                 for sender in rabbitmq_senders:
@@ -211,11 +225,8 @@ class Services(metaclass=SingletonMeta):
 
     async def _setup_senders_async(self, rabbitmq_senders, has_listeners: bool):
         """设置发送器"""
-        Services._registered_senders = [
-            sender.queue_name for sender in rabbitmq_senders]
         await RabbitMQService.setup_senders(rabbitmq_senders, has_listeners)
-        Services._registered_senders = RabbitMQService._sender_client_names
-        logging.info(f"已注册的RabbitMQ发送器: {Services._registered_senders}")
+        logging.info(f"RabbitMQ发送器注册完成")
 
     async def _setup_listeners_async(self, rabbitmq_listeners, has_senders: bool):
         """设置监听器"""
@@ -240,14 +251,12 @@ class Services(metaclass=SingletonMeta):
 
         for attempt in range(max_retries):
             try:
-                if queue_name not in cls._registered_senders:
-                    cls._registered_senders = RabbitMQService._sender_client_names
-                    if queue_name not in cls._registered_senders:
-                        raise ValueError(f"发送器 {queue_name} 未注册")
-
+                # 依赖 RabbitMQService 的内部状态
                 sender = await RabbitMQService.get_sender(queue_name)
+
                 if not sender:
-                    raise ValueError(f"发送器 '{queue_name}' 不存在或连接无效")
+                    raise ValueError(
+                        f"发送器 '{queue_name}' 不存在或未在 RabbitMQService 中注册")
 
                 await RabbitMQService.send_message(data, queue_name, **kwargs)
                 logging.info(f"消息发送成功（尝试 {attempt+1}/{max_retries}）")
@@ -269,7 +278,20 @@ class Services(metaclass=SingletonMeta):
             if RabbitMQService._is_shutdown:
                 logging.info("RabbitMQService已关闭，无需重复操作")
                 return
-            await RabbitMQService.shutdown()
+
+            try:
+                await RabbitMQService.shutdown()
+            except Exception as e:
+                logging.error(f"关闭 RabbitMQService 时发生异常: {e}", exc_info=True)
+
             cls._initialized = False
-            cls._registered_senders.clear()
+
+            # 清理实例数据
+            if cls._instance:
+                cls._instance._pending_async_db_setup.clear()
+
+            # 这对于热重载（reload）时防止旧实例内存泄漏至关重要
+            if cls._app:
+                cls._app.state.services = None
+
             logging.info("所有服务已关闭")

sycommon/synacos/nacos_client_base.py

@@ -2,6 +2,7 @@ import threading
 import time
 from typing import Optional
 import nacos
+from sycommon.config.Config import Config
 from sycommon.logging.kafka_log import SYLogger
 
 
@@ -94,8 +95,9 @@ class NacosClientBase:
 
         try:
             namespace_id = self.nacos_config['namespaceId']
+            service_name = Config().config.get('Name', '')
             self.nacos_client.list_naming_instance(
-                service_name="",  # 空服务名仅用于验证连接
+                service_name=service_name,
                 namespace_id=namespace_id,
                 group_name="DEFAULT_GROUP",
                 healthy_only=True

{sycommon_python_lib-0.1.56b18.dist-info → sycommon_python_lib-0.1.57.dist-info}/METADATA

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

{sycommon_python_lib-0.1.56b18.dist-info → sycommon_python_lib-0.1.57.dist-info}/RECORD

@@ -1,6 +1,6 @@
 command/cli.py,sha256=bP2LCLkRvfETIwWkVD70q5xFxMI4D3BpH09Ws1f-ENc,5849
 sycommon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sycommon/services.py,sha256=vcO2vbe2U1CA4ykLdH1rnxgqUIouukE-wTRsjRl2kBI,11683
+sycommon/services.py,sha256=F1fwBqVd7luywJjXeK7rF_7FzBePstyEfxXBR_5o04Q,12330
 sycommon/config/Config.py,sha256=L4vlGsVFL1ZHEULxvE8-VyLF-wDBuOMZGmWXIldqfn8,4014
 sycommon/config/DatabaseConfig.py,sha256=ILiUuYT9_xJZE2W-RYuC3JCt_YLKc1sbH13-MHIOPhg,804
 sycommon/config/EmbeddingConfig.py,sha256=gPKwiDYbeu1GpdIZXMmgqM7JqBIzCXi0yYuGRLZooMI,362
@@ -20,9 +20,12 @@ sycommon/health/metrics.py,sha256=fHqO73JuhoZkNPR-xIlxieXiTCvttq-kG-tvxag1s1s,26
 sycommon/health/ping.py,sha256=FTlnIKk5y1mPfS1ZGOeT5IM_2udF5aqVLubEtuBp18M,250
 sycommon/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/llm/embedding.py,sha256=HknwDqXmRQcAZ8-6d8wZ6n7Bv7HtxTajDt1vvzHGeFQ,8411
-sycommon/llm/get_llm.py,sha256=6Tz5vQHiOPBJa9W68Av-IrtDUqIA7ck7LOgynPqLcT8,12847
+sycommon/llm/get_llm.py,sha256=C48gt9GCwEpR26M-cUjM74_t-el18ZvlwpGhcQfR3gs,1054
 sycommon/llm/llm_logger.py,sha256=n4UeNy_-g4oHQOsw-VUzF4uo3JVRLtxaMp1FcI8FiEo,5437
 sycommon/llm/llm_tokens.py,sha256=-udDyFcmyzx6UAwIi6_d_wwI5kMd5w0-WcS2soVPQxg,4309
+sycommon/llm/struct_token.py,sha256=jlpZnTOLDmRDdrCuxZe-1pQopd6OmCM9B_gWZ48CnEQ,7655
+sycommon/llm/sy_langfuse.py,sha256=NZv6ydfn3-cxqQvuB5WdnM9GYliO9qB_RWh_XqIS3VU,3692
+sycommon/llm/usage_token.py,sha256=n0hytuaHI4tJi6wuOS3bd-yWzQjZ-lx5w9egHs8uYgg,5140
 sycommon/logging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/logging/async_sql_logger.py,sha256=_OY36XkUm__U3NhMgiecy-qd-nptZ_0gpE3J8lGAr58,2619
 sycommon/logging/kafka_log.py,sha256=gfOqdZe0HJ3PkIFfnNWG4DZVadxsCKJ6AmelR7_Z1Xs,9960
@@ -48,10 +51,10 @@ sycommon/models/mqsend_config.py,sha256=NQX9dc8PpuquMG36GCVhJe8omAW1KVXXqr6lSRU6
 sycommon/models/sso_user.py,sha256=i1WAN6k5sPcPApQEdtjpWDy7VrzWLpOrOQewGLGoGIw,2702
 sycommon/notice/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sycommon/notice/uvicorn_monitor.py,sha256=VryQYcAtjijJuGDBimbVurgwxlsLaLtkNnABPDY5Tao,7332
-sycommon/rabbitmq/rabbitmq_client.py,sha256=JZ73fc0Z8iMnayvRhRsnkEkBfzKF3wbxDKTE98RwVIA,17809
+sycommon/rabbitmq/rabbitmq_client.py,sha256=hAbLOioU_clucJ9xq88Oo-waZOuU0ii4yBVGIjz1nBE,17992
 sycommon/rabbitmq/rabbitmq_pool.py,sha256=BiFQgZPzSAFR-n5XhyIafoeWQXETF_31nFRDhMbe6aU,15577
 sycommon/rabbitmq/rabbitmq_service.py,sha256=XSHo9HuIJ_lq-vizRh4xJVdZr_2zLqeLhot09qb0euA,2025
-sycommon/rabbitmq/rabbitmq_service_client_manager.py,sha256=MM4r8Pa2rjAmzy_NpHFb4thGznr6AYk6m__IC8IIxEM,7852
+sycommon/rabbitmq/rabbitmq_service_client_manager.py,sha256=IP9TMFeG5LSrwFPEmOy1ce4baPxBUZnWJZR3nN_-XR4,8009
 sycommon/rabbitmq/rabbitmq_service_connection_monitor.py,sha256=uvoMuJDzJ9i63uVRq1NKFV10CvkbGnTMyEoq2rgjQx8,3013
 sycommon/rabbitmq/rabbitmq_service_consumer_manager.py,sha256=489r1RKd5WrTNMAcWCxUZpt9yWGrNunZlLCCp-M_rzM,11497
 sycommon/rabbitmq/rabbitmq_service_core.py,sha256=6RMvIf78DmEOZmN8dA0duA9oy4ieNswdGrOeyJdD6tU,4753
@@ -66,7 +69,7 @@ sycommon/synacos/example.py,sha256=61XL03tU8WTNOo3FUduf93F2fAwah1S0lbH1ufhRhRk,5
 sycommon/synacos/example2.py,sha256=adUaru3Hy482KrOA17DfaC4nwvLj8etIDS_KrWLWmCU,4811
 sycommon/synacos/feign.py,sha256=frB3D5LeFDtT3pJLFOwFzEOrNAJKeQNGk-BzUg9T3WM,8295
 sycommon/synacos/feign_client.py,sha256=ExO7Pd5B3eFKDjXqBRc260K1jkI49IYguLwJJaD2R-o,16166
-sycommon/synacos/nacos_client_base.py,sha256=l5jpall6nEt0Hy07Wk-PVU0VN0BmD_Mmtldmtyvvksg,4526
+sycommon/synacos/nacos_client_base.py,sha256=KZgQAg9Imfr_TfM-4LXdtrnTdJ-beu6bcNJa0c2HauE,4600
 sycommon/synacos/nacos_config_manager.py,sha256=Cff-4gpp0aD7sQVi-nEvDO4BWqK9abEDDDJ9qXKFQgs,4399
 sycommon/synacos/nacos_heartbeat_manager.py,sha256=G80_pOn37WdO_HpYUiAfpwMqAxW0ff0Bnw0NEuge9v0,5568
 sycommon/synacos/nacos_service.py,sha256=BezQ1eDIYwBPE567Po_Qh1Ki_z9WmhZy1J1NiTPbdHY,6118
@@ -79,8 +82,8 @@ sycommon/tools/env.py,sha256=Ah-tBwG2C0_hwLGFebVQgKdWWXCjTzBuF23gCkLHYy4,2437
 sycommon/tools/merge_headers.py,sha256=u9u8_1ZIuGIminWsw45YJ5qnsx9MB-Fot0VPge7itPw,4941
 sycommon/tools/snowflake.py,sha256=xQlYXwYnI85kSJ1rZ89gMVBhzemP03xrMPVX9vVa3MY,9228
 sycommon/tools/timing.py,sha256=OiiE7P07lRoMzX9kzb8sZU9cDb0zNnqIlY5pWqHcnkY,2064
-sycommon_python_lib-0.1.56b18.dist-info/METADATA,sha256=N7zStU85jo02fpC7PRFGfWcW1WRxa7zOP87idPw93_4,7302
-sycommon_python_lib-0.1.56b18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sycommon_python_lib-0.1.56b18.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
-sycommon_python_lib-0.1.56b18.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
-sycommon_python_lib-0.1.56b18.dist-info/RECORD,,
+sycommon_python_lib-0.1.57.dist-info/METADATA,sha256=qQp7G8uJ3kBSlZNbOTs3CVq4yoUa5PCfPHq0IFxxsOA,7299
+sycommon_python_lib-0.1.57.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sycommon_python_lib-0.1.57.dist-info/entry_points.txt,sha256=q_h2nbvhhmdnsOUZEIwpuoDjaNfBF9XqppDEmQn9d_A,46
+sycommon_python_lib-0.1.57.dist-info/top_level.txt,sha256=98CJ-cyM2WIKxLz-Pf0AitWLhJyrfXvyY8slwjTXNuc,17
+sycommon_python_lib-0.1.57.dist-info/RECORD,,