sycommon-python-lib 0.2.0b28__tar.gz → 0.2.0b30__tar.gz

{sycommon_python_lib-0.2.0b28 → sycommon_python_lib-0.2.0b30}/PKG-INFO

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

{sycommon_python_lib-0.2.0b28 → sycommon_python_lib-0.2.0b30}/pyproject.toml

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

{sycommon_python_lib-0.2.0b28 → sycommon_python_lib-0.2.0b30}/src/sycommon/heartbeat_process/heartbeat_process_manager.py

@@ -16,7 +16,6 @@ import atexit
 import multiprocessing
 import os
 from multiprocessing import Process, Event
-from multiprocessing.context import ForkContext
 from multiprocessing.synchronize import Event as EventType
 from typing import Optional
 
@@ -104,8 +103,11 @@ class HeartbeatProcessManager:
         优先级：
         1. 环境变量 HEARTBEAT_PROCESS_MODE
         2. 代码设置 enable_process_mode()
+        3. 操作系统检测（Windows 默认禁用）
 
-        默认：启用进程模式（True）
+        默认：
+        - Windows: 禁用进程模式（spawn 模式有限制）
+        - macOS/Linux: 启用进程模式
         """
         # 环境变量优先
         env_mode = os.getenv('HEARTBEAT_PROCESS_MODE', '').lower()
@@ -114,7 +116,14 @@ class HeartbeatProcessManager:
         if env_mode in ('true', '1', 'yes'):
             return True
 
-        # 默认启用进程模式
+        # Windows 默认禁用进程模式（spawn 模式需要 if __name__ == '__main__' 保护）
+        # Windows 使用 spawn 模式启动子进程，要求主模块必须有 if __name__ == '__main__': 保护。
+        # 但用户的 app.py 在模块顶层调用了 Services.plugins()，导致子进程启动时重新执行这些代码。
+        import platform
+        if platform.system() == 'Windows':
+            return False
+
+        # macOS/Linux 默认启用进程模式
         return True
 
     @classmethod
@@ -208,16 +217,24 @@ class HeartbeatProcessManager:
         worker.run()
 
     @classmethod
-    def stop(cls, timeout: float = 10.0) -> None:
+    def stop(cls, timeout: float = 10.0, from_signal_handler: bool = False) -> None:
         """停止心跳进程
 
         Args:
             timeout: 等待进程退出的超时时间（秒）
+            from_signal_handler: 是否从信号处理函数中调用（信号处理函数中不能使用 Loguru）
         """
         if not cls._is_running or cls._process is None:
             return
 
-        logger.info("正在停止心跳进程...")
+        def _log(msg: str):
+            """信号处理函数中使用 print，其他情况使用 logger"""
+            if from_signal_handler:
+                print(f"[HeartbeatProcessManager] {msg}")
+            else:
+                logger.info(msg)
+
+        _log("正在停止心跳进程...")
 
         try:
             # 设置停止信号
@@ -228,17 +245,23 @@ class HeartbeatProcessManager:
             cls._process.join(timeout=timeout)
 
             if cls._process.is_alive():
-                logger.warning("心跳进程未能在超时时间内退出，强制终止")
+                _log("心跳进程未能在超时时间内退出，强制终止")
                 cls._process.terminate()
                 cls._process.join(timeout=2.0)
 
                 if cls._process.is_alive():
-                    logger.error("心跳进程强制终止失败")
+                    if from_signal_handler:
+                        print("[HeartbeatProcessManager] 心跳进程强制终止失败")
+                    else:
+                        logger.error("心跳进程强制终止失败")
 
-            logger.info("心跳进程已停止")
+            _log("心跳进程已停止")
 
         except Exception as e:
-            logger.error(f"停止心跳进程异常: {e}")
+            if from_signal_handler:
+                print(f"[HeartbeatProcessManager] 停止心跳进程异常: {e}")
+            else:
+                logger.error(f"停止心跳进程异常: {e}")
         finally:
             cls._cleanup()
 

{sycommon_python_lib-0.2.0b28 → sycommon_python_lib-0.2.0b30}/src/sycommon/llm/llm_with_token_tracking.py

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

{sycommon_python_lib-0.2.0b28 → sycommon_python_lib-0.2.0b30}/src/sycommon/llm/native_smart_retry_runnable.py

@@ -46,8 +46,9 @@ class NativeSmartRetryRunnable(Runnable):
     def _process_content(self, content: str) -> str:
         """处理内容（移除代码块标记、规范化 JSON）"""
         content = content.strip("```json").strip("```").strip()
-        content = content.replace("None", "null").replace("none", "null").replace("NONE", "null")
-        content = content.replace("''", '""')
+        content = content.replace("None", "null").replace(
+            "none", "null").replace("NONE", "null")
+        content = content.replace("'", '"')
         return content
 
     def _try_parse_result(self, result: Any) -> BaseModel:
@@ -77,7 +78,8 @@ class NativeSmartRetryRunnable(Runnable):
 
     def invoke(self, input: Any, config: Optional[RunnableConfig] = None) -> BaseModel:
         """同步调用（带智能修正重试）"""
-        messages = input if isinstance(input, list) else input.get("messages", [])
+        messages = input if isinstance(
+            input, list) else input.get("messages", [])
         last_error = None
         last_result = None
         result = None
@@ -94,7 +96,8 @@ class NativeSmartRetryRunnable(Runnable):
                     SYLogger.info(f"[原生智能修正] 第 {attempt} 次尝试，错误: {last_error}")
 
                     # 构建修正请求
-                    parser = PydanticOutputParser(pydantic_object=self.output_model)
+                    parser = PydanticOutputParser(
+                        pydantic_object=self.output_model)
                     correction_input = {
                         "messages": messages,
                         "error_message": str(last_error),
@@ -103,7 +106,8 @@ class NativeSmartRetryRunnable(Runnable):
                     }
 
                     correction_chain = self.correction_prompt | self.llm
-                    raw_response = correction_chain.invoke(correction_input, config=config)
+                    raw_response = correction_chain.invoke(
+                        correction_input, config=config)
                     content = self._extract_content(raw_response)
 
                     # 尝试从修正后的响应中提取结构化数据
@@ -117,13 +121,15 @@ class NativeSmartRetryRunnable(Runnable):
                 SYLogger.warning(f"[原生智能修正] 第 {attempt + 1} 次失败: {e}")
 
                 if attempt == self.max_retries - 1:
-                    raise ValueError(f"经过 {self.max_retries} 次尝试仍无法获取有效结果: {last_error}") from last_error
+                    raise ValueError(
+                        f"经过 {self.max_retries} 次尝试仍无法获取有效结果: {last_error}") from last_error
 
         raise ValueError("未知错误")
 
     async def ainvoke(self, input: Any, config: Optional[RunnableConfig] = None) -> BaseModel:
         """异步调用（带智能修正重试）"""
-        messages = input if isinstance(input, list) else input.get("messages", [])
+        messages = input if isinstance(
+            input, list) else input.get("messages", [])
         last_error = None
         last_result = None
         result = None
@@ -140,7 +146,8 @@ class NativeSmartRetryRunnable(Runnable):
                     SYLogger.info(f"[原生智能修正] 第 {attempt} 次尝试，错误: {last_error}")
 
                     # 构建修正请求
-                    parser = PydanticOutputParser(pydantic_object=self.output_model)
+                    parser = PydanticOutputParser(
+                        pydantic_object=self.output_model)
                     correction_input = {
                         "messages": messages,
                         "error_message": str(last_error),
@@ -163,6 +170,7 @@ class NativeSmartRetryRunnable(Runnable):
                 SYLogger.warning(f"[原生智能修正] 第 {attempt + 1} 次失败: {e}")
 
                 if attempt == self.max_retries - 1:
-                    raise ValueError(f"经过 {self.max_retries} 次尝试仍无法获取有效结果: {last_error}") from last_error
+                    raise ValueError(
+                        f"经过 {self.max_retries} 次尝试仍无法获取有效结果: {last_error}") from last_error
 
         raise ValueError("未知错误")

{sycommon_python_lib-0.2.0b28 → sycommon_python_lib-0.2.0b30}/src/sycommon/llm/smart_retry_runnable.py

@@ -49,13 +49,15 @@ class SmartRetryRunnable(Runnable):
     def _process_content(self, content: str) -> str:
         """处理内容（移除代码块标记、规范化 JSON）"""
         content = content.strip("```json").strip("```").strip()
-        content = content.replace("None", "null").replace("none", "null").replace("NONE", "null")
-        content = content.replace("''", '""')
+        content = content.replace("None", "null").replace(
+            "none", "null").replace("NONE", "null")
+        content = content.replace("'", '"')
         return content
 
     def invoke(self, input: Any, config: Optional[RunnableConfig] = None) -> BaseModel:
         """同步调用（带智能修正重试）"""
-        messages = input.get("messages", []) if isinstance(input, dict) else input
+        messages = input.get("messages", []) if isinstance(
+            input, dict) else input
         last_error = None
         last_content = None
 
@@ -64,7 +66,8 @@ class SmartRetryRunnable(Runnable):
                 # 第一次尝试或修正后的尝试
                 if attempt == 0:
                     # 使用 process_chain（包含 base_chain + 处理步骤）
-                    raw_response = self.process_chain.invoke(input, config=config)
+                    raw_response = self.process_chain.invoke(
+                        input, config=config)
                     content = self._extract_content(raw_response)
                     processed_content = self._process_content(content)
                 else:
@@ -80,7 +83,8 @@ class SmartRetryRunnable(Runnable):
                     }
 
                     correction_chain = self.correction_prompt | self.llm
-                    raw_response = correction_chain.invoke(correction_input, config=config)
+                    raw_response = correction_chain.invoke(
+                        correction_input, config=config)
                     content = self._extract_content(raw_response)
                     processed_content = self._process_content(content)
 
@@ -98,13 +102,15 @@ class SmartRetryRunnable(Runnable):
 
                 if attempt == self.max_retries - 1:
                     # 达到最大重试次数，抛出异常
-                    raise ValueError(f"经过 {self.max_retries} 次尝试仍无法解析: {last_error}") from last_error
+                    raise ValueError(
+                        f"经过 {self.max_retries} 次尝试仍无法解析: {last_error}") from last_error
 
         raise ValueError("未知错误")
 
     async def ainvoke(self, input: Any, config: Optional[RunnableConfig] = None) -> BaseModel:
         """异步调用（带智能修正重试）"""
-        messages = input.get("messages", []) if isinstance(input, dict) else input
+        messages = input.get("messages", []) if isinstance(
+            input, dict) else input
         last_error = None
         last_content = None
 
@@ -147,6 +153,7 @@ class SmartRetryRunnable(Runnable):
 
                 if attempt == self.max_retries - 1:
                     # 达到最大重试次数，抛出异常
-                    raise ValueError(f"经过 {self.max_retries} 次尝试仍无法解析: {last_error}") from last_error
+                    raise ValueError(
+                        f"经过 {self.max_retries} 次尝试仍无法解析: {last_error}") from last_error
 
         raise ValueError("未知错误")

{sycommon_python_lib-0.2.0b28 → sycommon_python_lib-0.2.0b30}/src/sycommon/llm/usage_token.py

@@ -3,13 +3,14 @@
 LLM Token 统计和结构化输出模块
 """
 
-from typing import Type, List, Optional, Callable
+from typing import Type, List, Optional, Callable, Iterator, AsyncIterator
 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 HumanMessage
 from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.outputs import ChatGenerationChunk
 from pydantic import BaseModel, ValidationError, Field
 
 from sycommon.config.LLMConfig import LLMConfig
@@ -90,7 +91,8 @@ class LLMWithAutoTokenUsage(BaseChatModel):
 上一次输出：
 {previous_output}
 
-请修正错误，确保所有字段都符合要求，不要改变原有属性。
+输出格式，请严格按照以下JSON格式输出，不要输出任何多余内容，不要省略任何字段：
+{format_instructions}
 """)
         ])
 
@@ -145,14 +147,14 @@ class LLMWithAutoTokenUsage(BaseChatModel):
                 HumanMessage(content=f"""
                 请提取信息并遵循以下规则：
                 1. 准确率要求：{accuracy_instructions.strip()}
-                2. 输出格式：{parser.get_format_instructions()}
+                2. 输出格式，请严格按照以下JSON格式输出，不要输出任何多余内容，不要省略任何字段：{parser.get_format_instructions()}
                 """)
             ])
         else:
             prompt = override_prompt or ChatPromptTemplate.from_messages([
                 MessagesPlaceholder(variable_name="messages"),
                 HumanMessage(content=f"""
-                输出格式：{parser.get_format_instructions()}
+                输出格式，请严格按照以下JSON格式输出，不要输出任何多余内容，不要省略任何字段：{parser.get_format_instructions()}
                 """)
             ])
 
@@ -168,7 +170,7 @@ class LLMWithAutoTokenUsage(BaseChatModel):
 上一次输出：
 {previous_output}
 
-请修正错误，严格按照以下格式输出：
+输出格式，请严格按照以下JSON格式输出，不要输出任何多余内容，不要省略任何字段：
 {format_instructions}
 """)
         ])
@@ -229,6 +231,19 @@ class LLMWithAutoTokenUsage(BaseChatModel):
     def _generate(self, messages, stop=None, run_manager=None, **kwargs):
         return self.llm._generate(messages, stop=stop, run_manager=run_manager, **kwargs)
 
+    async def _agenerate(self, messages, stop=None, run_manager=None, **kwargs):
+        """异步生成 - 委托给底层 LLM"""
+        return await self.llm._agenerate(messages, stop=stop, run_manager=run_manager, **kwargs)
+
+    def _stream(self, messages, stop=None, run_manager=None, **kwargs):
+        """流式生成 - 委托给底层 LLM"""
+        yield from self.llm._stream(messages, stop=stop, run_manager=run_manager, **kwargs)
+
+    async def _astream(self, messages, stop=None, run_manager=None, **kwargs):
+        """异步流式生成 - 委托给底层 LLM"""
+        async for chunk in self.llm._astream(messages, stop=stop, run_manager=run_manager, **kwargs):
+            yield chunk
+
     @property
     def _llm_type(self) -> str:
         return self.llm._llm_type

{sycommon_python_lib-0.2.0b28 → sycommon_python_lib-0.2.0b30}/src/sycommon/rabbitmq/rabbitmq_service.py

@@ -65,9 +65,14 @@ class RabbitMQService(RabbitMQConnectionMonitor, RabbitMQProducerManager, Rabbit
         优先级：
         1. 环境变量 HEARTBEAT_PROCESS_MODE
         2. 配置项 useProcessMode
+        3. 操作系统检测（Windows 默认禁用）
 
-        默认：启用进程模式（True）
+        默认：
+        - Windows: 禁用进程模式（spawn 模式有限制）
+        - macOS/Linux: 启用进程模式
         """
+        import platform
+
         env_mode = os.getenv('HEARTBEAT_PROCESS_MODE', '').lower()
         if env_mode in ('false', '0', 'no'):
             cls._use_process_mode = False
@@ -75,13 +80,21 @@ class RabbitMQService(RabbitMQConnectionMonitor, RabbitMQProducerManager, Rabbit
         elif env_mode in ('true', '1', 'yes'):
             cls._use_process_mode = True
         else:
-            # 从配置读取，默认启用进程模式
-            config_value = config.get('useProcessMode', True)
-            # 处理字符串配置
-            if isinstance(config_value, str):
-                cls._use_process_mode = config_value.lower() not in ('false', '0', 'no')
+            # 从配置读取
+            config_value = config.get('useProcessMode')
+            if config_value is not None:
+                # 处理字符串配置
+                if isinstance(config_value, str):
+                    cls._use_process_mode = config_value.lower() not in ('false', '0', 'no')
+                else:
+                    cls._use_process_mode = bool(config_value)
             else:
-                cls._use_process_mode = bool(config_value)
+                # 默认：Windows 禁用进程模式，其他系统启用
+                if platform.system() == 'Windows':
+                    cls._use_process_mode = False
+                    logger.info("RabbitMQ: Windows 系统默认禁用进程模式，使用 asyncio 模式")
+                else:
+                    cls._use_process_mode = True
 
         if cls._use_process_mode:
             logger.info("RabbitMQ: 启用进程模式，连接监控将在独立进程中运行")
@@ -116,9 +129,12 @@ class RabbitMQService(RabbitMQConnectionMonitor, RabbitMQProducerManager, Rabbit
 
             # 环境变量明确启用
             if env_enabled in ('true', '1', 'yes') or env_pool_size:
-                pool_size = int(env_pool_size) if env_pool_size.isdigit() else 0
-                ProcessPoolConsumerManager.configure(enabled=True, pool_size=pool_size)
-                logger.info(f"RabbitMQ: 环境变量配置消费者进程池，大小: {ProcessPoolConsumerManager.get_pool_size()}")
+                pool_size = int(
+                    env_pool_size) if env_pool_size.isdigit() else 0
+                ProcessPoolConsumerManager.configure(
+                    enabled=True, pool_size=pool_size)
+                logger.info(
+                    f"RabbitMQ: 环境变量配置消费者进程池，大小: {ProcessPoolConsumerManager.get_pool_size()}")
                 return
 
             # 从配置文件读取
@@ -133,12 +149,15 @@ class RabbitMQService(RabbitMQConnectionMonitor, RabbitMQProducerManager, Rabbit
                     pool_enabled = bool(config_enabled)
 
                 pool_size = int(config_pool_size) if config_pool_size else 0
-                ProcessPoolConsumerManager.configure(enabled=pool_enabled, pool_size=pool_size)
+                ProcessPoolConsumerManager.configure(
+                    enabled=pool_enabled, pool_size=pool_size)
                 logger.info(f"RabbitMQ: 配置文件设置消费者进程池，启用: {pool_enabled}")
             else:
                 # 使用默认配置（禁用）
-                ProcessPoolConsumerManager.configure(enabled=False, pool_size=0)
-                logger.info("RabbitMQ: 消费者进程池默认禁用，如需启用请设置 MQ_PROCESS_POOL_ENABLED=true")
+                ProcessPoolConsumerManager.configure(
+                    enabled=False, pool_size=0)
+                logger.info(
+                    "RabbitMQ: 消费者进程池默认禁用，如需启用请设置 MQ_PROCESS_POOL_ENABLED=true")
 
         except Exception as e:
             logger.warning(f"RabbitMQ: 配置消费者进程池失败: {e}，使用默认配置")
@@ -169,7 +188,8 @@ class RabbitMQService(RabbitMQConnectionMonitor, RabbitMQProducerManager, Rabbit
 
             # 启动心跳进程（仅 RabbitMQ 监控）
             HeartbeatProcessManager.enable_process_mode(True)
-            success = HeartbeatProcessManager.start(rabbitmq_config=rabbitmq_config)
+            success = HeartbeatProcessManager.start(
+                rabbitmq_config=rabbitmq_config)
 
             if success:
                 cls._heartbeat_process_started = True

{sycommon_python_lib-0.2.0b28 → sycommon_python_lib-0.2.0b30}/src/sycommon/synacos/nacos_service.py

@@ -84,9 +84,14 @@ class NacosService(metaclass=SingletonMeta):
         优先级：
         1. 环境变量 HEARTBEAT_PROCESS_MODE
         2. 配置项 useProcessMode
+        3. 操作系统检测（Windows 默认禁用）
 
-        默认：启用进程模式（True）
+        默认：
+        - Windows: 禁用进程模式（spawn 模式有限制）
+        - macOS/Linux: 启用进程模式
         """
+        import platform
+
         env_mode = os.getenv('HEARTBEAT_PROCESS_MODE', '').lower()
         if env_mode in ('false', '0', 'no'):
             self._use_process_mode = False
@@ -94,13 +99,21 @@ class NacosService(metaclass=SingletonMeta):
         elif env_mode in ('true', '1', 'yes'):
             self._use_process_mode = True
         else:
-            # 从配置读取，默认启用进程模式
-            config_value = self.nacos_config.get('useProcessMode', True)
-            # 处理字符串配置
-            if isinstance(config_value, str):
-                self._use_process_mode = config_value.lower() not in ('false', '0', 'no')
+            # 从配置读取
+            config_value = self.nacos_config.get('useProcessMode')
+            if config_value is not None:
+                # 处理字符串配置
+                if isinstance(config_value, str):
+                    self._use_process_mode = config_value.lower() not in ('false', '0', 'no')
+                else:
+                    self._use_process_mode = bool(config_value)
             else:
-                self._use_process_mode = bool(config_value)
+                # 默认：Windows 禁用进程模式，其他系统启用
+                if platform.system() == 'Windows':
+                    self._use_process_mode = False
+                    SYLogger.info("nacos:Windows 系统默认禁用进程模式，使用线程模式")
+                else:
+                    self._use_process_mode = True
 
         if self._use_process_mode:
             SYLogger.info("nacos:启用进程模式，心跳将在独立进程中运行")
@@ -231,17 +244,23 @@ class NacosService(metaclass=SingletonMeta):
         return config_ip
 
     def handle_signal(self, signum, frame):
-        """处理退出信号（保持原有逻辑）"""
-        SYLogger.info(f"nacos:收到信号 {signum}，正在关闭服务...")
+        """处理退出信号（保持原有逻辑）
+
+        注意：信号处理函数中不能使用 Loguru（会导致死锁），
+        使用 print 代替日志输出。
+        """
+        # 信号处理函数中不能使用 Loguru，会导致死锁
+        print(f"[NacosService] 收到信号 {signum}，正在关闭服务...")
 
         # 停止心跳进程
         if self._heartbeat_process_started:
             try:
                 from sycommon.heartbeat_process import HeartbeatProcessManager
-                HeartbeatProcessManager.stop()
-                SYLogger.info("nacos:心跳进程已停止")
+                # 从信号处理函数中调用，使用 print 替代 logger 避免死锁
+                HeartbeatProcessManager.stop(from_signal_handler=True)
+                print("[NacosService] 心跳进程已停止")
             except Exception as e:
-                SYLogger.error(f"nacos:停止心跳进程异常: {e}")
+                print(f"[NacosService] 停止心跳进程异常: {e}")
 
         self.registration.deregister_service()
         sys.exit(0)

{sycommon_python_lib-0.2.0b28 → sycommon_python_lib-0.2.0b30}/src/sycommon_python_lib.egg-info/PKG-INFO

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