ErisPulse 2.2.1.dev0__py3-none-any.whl → 2.3.0.dev5__py3-none-any.whl

ErisPulse/Core/config.py

@@ -3,74 +3,173 @@ ErisPulse 配置中心
 
 集中管理所有配置项，避免循环导入问题
 提供自动补全缺失配置项的功能
+添加内存缓存和延迟写入机制以提高性能
 """
+
 import os
+import time
 import toml
-from typing import Dict, Any, Optional
+import threading
+from typing import Any, Dict
 
 class ConfigManager:
     def __init__(self, config_file: str = "config.toml"):
-        self.CONFIG_FILE = config_file
+        self.CONFIG_FILE: str = config_file
+        self._cache: Dict[str, Any] = {}  # 内存缓存
+        self._dirty_keys: Dict[str, Any] = {}  # 待写入的键值对
+        self._cache_timestamp = 0  # 缓存时间戳
+        self._cache_timeout = 60  # 缓存超时时间（秒）
+        self._write_delay = 5  # 写入延迟（秒）
+        self._write_timer = None  # 写入定时器
+        self._lock = threading.RLock()  # 线程安全锁
+        self._load_config()  # 初始化时加载配置
+
+    def _load_config(self) -> None:
+        """
+        从文件加载配置到缓存
+        """
+        with self._lock:
+            try:
+                if not os.path.exists(self.CONFIG_FILE):
+                    self._cache = {}
+                    self._cache_timestamp = time.time()
+                    return
+
+                with open(self.CONFIG_FILE, "r", encoding="utf-8") as f:
+                    config = toml.load(f)
+                    self._cache = config
+                    self._cache_timestamp = time.time()
+            except Exception as e:
+                from .logger import logger
+                logger.error(f"加载配置文件 {self.CONFIG_FILE} 失败: {e}")
+                self._cache = {}
+                self._cache_timestamp = time.time()
+
+    def _flush_config(self) -> None:
+        """
+        将待写入的配置刷新到文件
+        """
+        with self._lock:
+            if not self._dirty_keys:
+                return  # 没有需要写入的内容
+
+            try:
+                # 从文件读取完整配置
+                if os.path.exists(self.CONFIG_FILE):
+                    with open(self.CONFIG_FILE, "r", encoding="utf-8") as f:
+                        config = toml.load(f)
+                else:
+                    config = {}
+
+                # 应用待写入的更改
+                for key, value in self._dirty_keys.items():
+                    keys = key.split('.')
+                    current = config
+                    for k in keys[:-1]:
+                        if k not in current:
+                            current[k] = {}
+                        current = current[k]
+                    current[keys[-1]] = value
+
+                # 写入文件
+                with open(self.CONFIG_FILE, "w", encoding="utf-8") as f:
+                    toml.dump(config, f)
+
+                # 更新缓存并清除待写入队列
+                self._cache = config
+                self._cache_timestamp = time.time()
+                self._dirty_keys.clear()
+
+            except Exception as e:
+                from .logger import logger
+                logger.error(f"写入配置文件 {self.CONFIG_FILE} 失败: {e}")
+
+    def _schedule_write(self) -> None:
+        """
+        安排延迟写入
+        """
+        if self._write_timer:
+            self._write_timer.cancel()
+        
+        self._write_timer = threading.Timer(self._write_delay, self._flush_config)
+        self._write_timer.daemon = True
+        self._write_timer.start()
+
+    def _check_cache_validity(self) -> None:
+        """
+        检查缓存有效性，必要时重新加载
+        """
+        current_time = time.time()
+        if current_time - self._cache_timestamp > self._cache_timeout:
+            self._load_config()
 
     def getConfig(self, key: str, default: Any = None) -> Any:
         """
-        获取模块/适配器配置项
+        获取模块/适配器配置项（优先从缓存获取）
         :param key: 配置项的键(支持点分隔符如"module.sub.key")
         :param default: 默认值
         :return: 配置项的值
         """
-        try:
-            if not os.path.exists(self.CONFIG_FILE):
-                return default
-                
-            with open(self.CONFIG_FILE, "r", encoding="utf-8") as f:
-                config = toml.load(f)
-            
-            # 支持点分隔符访问嵌套配置
+        with self._lock:
+            self._check_cache_validity()
+
+            # 优先检查待写入队列
+            if key in self._dirty_keys:
+                return self._dirty_keys[key]
+
+            # 然后检查缓存
             keys = key.split('.')
-            value = config
+            value = self._cache
             for k in keys:
                 if k not in value:
                     return default
                 value = value[k]
-                
+
             return value
-        except Exception as e:
-            from . import logger
-            logger.error(f"读取配置文件 {self.CONFIG_FILE} 失败: {e}")
-            return default
-    
-    def setConfig(self, key: str, value: Any) -> bool:
+
+    def setConfig(self, key: str, value: Any, immediate: bool = False) -> bool:
         """
-        设置模块/适配器配置
+        设置模块/适配器配置（缓存+延迟写入）
         :param key: 配置项键名(支持点分隔符如"module.sub.key")
         :param value: 配置项值
+        :param immediate: 是否立即写入磁盘（默认为False，延迟写入）
         :return: 操作是否成功
         """
         try:
-            config = {}
-            if os.path.exists(self.CONFIG_FILE):
-                with open(self.CONFIG_FILE, "r", encoding="utf-8") as f:
-                    config = toml.load(f)
-            
-            # 支持点分隔符设置嵌套配置
-            keys = key.split('.')
-            current = config
-            for k in keys[:-1]:
-                if k not in current:
-                    current[k] = {}
-                current = current[k]
-            current[keys[-1]] = value
-            
-            with open(self.CONFIG_FILE, "w", encoding="utf-8") as f:
-                toml.dump(config, f)
+            with self._lock:
+                # 先更新待写入队列
+                self._dirty_keys[key] = value
+                
+                if immediate:
+                    # 立即写入磁盘
+                    self._flush_config()
+                else:
+                    # 安排延迟写入
+                    self._schedule_write()
                 
             return True
         except Exception as e:
-            from . import logger
-            logger.error(f"写入配置文件 {self.CONFIG_FILE} 失败: {e}")
+            from .logger import logger
+            logger.error(f"设置配置项 {key} 失败: {e}")
             return False
 
+    def force_save(self) -> None:
+        """
+        强制立即保存所有待写入的配置到磁盘
+        """
+        with self._lock:
+            self._flush_config()
+
+    def reload(self) -> None:
+        """
+        重新从磁盘加载配置，丢弃所有未保存的更改
+        """
+        with self._lock:
+            if self._write_timer:
+                self._write_timer.cancel()
+            self._dirty_keys.clear()
+            self._load_config()
+
 config = ConfigManager()
 
 __all__ = [

ErisPulse/Core/exceptions.py

@@ -87,7 +87,7 @@ def async_exception_handler(loop: asyncio.AbstractEventLoop, context: Dict[str,
         msg = context.get('message', '未知异步错误')
         err_logger(f"ERROR: 未处理的异步错误: {msg}\n")
 
-def setup_async_loop(loop: asyncio.AbstractEventLoop = None) -> None:
+def setup_async_loop(loop: asyncio.AbstractEventLoop = None) -> None:   # type: ignore || 原因: 在实现中，已经完成了对于本方法的类型检查
     """
     为指定的事件循环设置异常处理器
     
@@ -99,6 +99,11 @@ def setup_async_loop(loop: asyncio.AbstractEventLoop = None) -> None:
         except RuntimeError:
             loop = asyncio.get_event_loop()
     
+    if loop is not None:
+        loop.set_exception_handler(async_exception_handler)
+    else:
+        raise RuntimeError("无法获取有效的事件循环")
+    
     loop.set_exception_handler(async_exception_handler)
 
 sys.excepthook = global_exception_handler

ErisPulse/Core/lifecycle.py

@@ -0,0 +1,167 @@
+"""
+ErisPulse 生命周期管理模块
+
+提供统一的生命周期事件管理和触发机制
+
+事件标准格式:
+{
+    "event": "事件名称",  # 必填
+    "timestamp": float,  # 必填，Unix时间戳
+    "data": dict,        # 可选，事件相关数据
+    "source": str,       # 必填，事件来源
+    "msg": str           # 可选，事件描述
+}
+"""
+
+import asyncio
+import time
+from typing import Callable, List, Dict, Any
+from .logger import logger
+
+class LifecycleManager:
+    """
+    生命周期管理器
+    
+    管理SDK的生命周期事件，提供事件注册和触发功能
+    支持点式结构事件监听，例如 module.init 可以被 module 监听到
+    """
+    
+    # 预定义的标准事件列表
+    STANDARD_EVENTS = {
+        "core": ["init.start", "init.complete"],
+        "module": ["load", "init", "unload"],
+        "adapter": ["load", "start", "status.change", "stop", "stopped"],
+        "server": ["start", "stop"]
+    }
+    
+    def __init__(self):
+        self._handlers: Dict[str, List[Callable]] = {}
+        self._timers: Dict[str, float] = {}  # 用于存储计时器
+        
+    def _validate_event(self, event_data: Dict[str, Any]) -> bool:
+        """
+        验证事件数据格式
+        
+        :param event_data: 事件数据字典
+        :return: 是否有效
+        """
+        if not isinstance(event_data, dict):
+            logger.error("事件数据必须是字典")
+            
+        required_fields = ["event", "timestamp", "source"]
+        for field in required_fields:
+            if field not in event_data:
+                logger.error(f"事件缺少必填字段: {field}")
+                
+        if not isinstance(event_data["event"], str):
+            logger.error("event字段必须是字符串")
+            
+        if not isinstance(event_data["timestamp"], (int, float)):
+            logger.error("timestamp字段必须是数字")
+            
+        if "data" in event_data and not isinstance(event_data["data"], dict):
+            logger.error("data字段必须是字典")
+            
+        return True
+        
+    def on(self, event: str) -> Callable:
+        """
+        注册生命周期事件处理器
+        
+        :param event: 事件名称，支持点式结构如 module.init
+        :return: 装饰器函数
+        
+        :raises ValueError: 当事件名无效时抛出
+        """
+        if not isinstance(event, str) or not event:
+            raise ValueError("事件名称必须是非空字符串")
+        def decorator(func: Callable) -> Callable:
+            if event not in self._handlers:
+                self._handlers[event] = []
+            self._handlers[event].append(func)
+            return func
+        return decorator
+        
+    def start_timer(self, timer_id: str) -> None:
+        """
+        开始计时
+        
+        :param timer_id: 计时器ID
+        """
+        self._timers[timer_id] = time.time()
+        
+    def get_duration(self, timer_id: str) -> float:
+        """
+        获取指定计时器的持续时间
+        
+        :param timer_id: 计时器ID
+        :return: 持续时间(秒)
+        """
+        if timer_id in self._timers:
+            return time.time() - self._timers[timer_id]
+        return 0.0
+        
+    def stop_timer(self, timer_id: str) -> float:
+        """
+        停止计时并返回持续时间
+        
+        :param timer_id: 计时器ID
+        :return: 持续时间(秒)
+        """
+        duration = self.get_duration(timer_id)
+        if timer_id in self._timers:
+            del self._timers[timer_id]
+        return duration
+        
+    async def submit_event(self, event_type: str, *, source: str = "ErisPulse", msg: str = "", data: dict = {}, timestamp = time.time()) -> None:
+        """
+        提交生命周期事件
+        
+        :param event: 事件名称
+        :param event_data: 事件数据字典
+        """
+        # 构建完整事件数据
+        event_data = {
+            "event": event_type,
+            "timestamp": timestamp,
+            "data": data,
+            "source": source,
+            "msg": msg
+        }
+            
+        # 验证事件格式
+        self._validate_event(event_data)
+        
+        # 触发通配符处理器（如果存在）
+        if "*" in self._handlers:
+            await self._execute_handlers("*", event_data)
+            
+        # 触发完整事件名的处理器
+        if event_type in self._handlers:
+            await self._execute_handlers(event_type, event_data)
+            
+        # 触发父级事件名的处理器（点式结构）
+        parts = event_type.split('.')
+        for i in range(len(parts) - 1, 0, -1):
+            parent_event = '.'.join(parts[:i])
+            if parent_event in self._handlers:
+                await self._execute_handlers(parent_event, event_data)
+                
+    async def _execute_handlers(self, event: str, event_data: Dict[str, Any]) -> None:
+        """
+        执行事件处理器
+        
+        :param event: 事件名称
+        :param event_data: 事件数据
+        """
+        logger.debug(f"触发生命周期事件: {event}")
+        for handler in self._handlers[event]:
+            try:
+                if asyncio.iscoroutinefunction(handler):
+                    await handler(event_data)
+                else:
+                    handler(event_data)
+            except Exception as e:
+                logger.error(f"生命周期事件处理器执行错误 {event}: {e}")
+
+lifecycle = LifecycleManager()