ErisPulse 2.1.13rc2__py3-none-any.whl → 2.1.14a1__py3-none-any.whl

ErisPulse/Core/__init__.py

@@ -2,9 +2,10 @@ from .adapter import AdapterFather, SendDSL, adapter
 from .env import env
 from .logger import logger
 from .mods import mods
-from .raiserr import raiserr
-from .util import util
-from .server import adapter_server
+from .router import router, adapter_server
+from .config import config
+from . import exceptions
+
 BaseAdapter = AdapterFather
 
 __all__ = [
@@ -15,7 +16,8 @@ __all__ = [
     'env',
     'logger',
     'mods',
-    'raiserr',
-    'util',
-    'adapter_server'
+    'exceptions',
+    'router',
+    'adapter_server',
+    'config'
 ]

ErisPulse/Core/adapter.py

@@ -13,14 +13,12 @@ ErisPulse 适配器系统
 
 import functools
 import asyncio
-import uuid
-import time
 from typing import (
     Callable, Any, Dict, List, Type, Optional, Set, 
-    Union, Awaitable, TypeVar, Generic, Tuple, Coroutine, FrozenSet
+    Union, Awaitable
 )
 from collections import defaultdict
-
+from .logger import logger
 
 class SendDSLBase:
     """
@@ -114,7 +112,6 @@ class BaseAdapter:
             :example:
             >>> await adapter.Send.To("123").Example("Hello")
             """
-            from .logger import logger
             logger.debug(f"适配器 {self._adapter.__class__.__name__} 发送了实例类型的消息: {text}")
             
         
@@ -378,7 +375,7 @@ class AdapterManager:
             for name in set(combinations):
                 setattr(self, name, instance)
         else:
-            self.logger.warning(f"平台名 {platform} 过长，如果您是开发者，请考虑使用更短的名称")
+            logger.warning(f"平台名 {platform} 过长，如果您是开发者，请考虑使用更短的名称")
             setattr(self, platform.lower(), instance)
             setattr(self, platform.upper(), instance)
             setattr(self, platform.capitalize(), instance)
@@ -401,10 +398,18 @@ class AdapterManager:
         """
         if platforms is None:
             platforms = list(self._adapters.keys())
+        if not isinstance(platforms, list):
+            platforms = [platforms]
+        for platform in platforms:
+            if platform not in self._adapters:
+                raise ValueError(f"平台 {platform} 未注册")
+        
+        logger.info(f"启动适配器 {platforms}")
 
-        from .server import adapter_server
-        from .config import get_server_config
+        from .router import adapter_server
+        from .erispulse_config import get_server_config
         server_config = get_server_config()
+
         host = server_config["host"]
         port = server_config["port"]
         ssl_cert = server_config.get("ssl_certfile", None)
@@ -441,16 +446,14 @@ class AdapterManager:
         :param adapter: 适配器实例
         :param platform: 平台名称
         """
-        from .. import sdk
 
-        # 加锁防止并发启动
         if not getattr(adapter, "_starting_lock", None):
             adapter._starting_lock = asyncio.Lock()
 
         async with adapter._starting_lock:
             # 再次确认是否已经被启动
             if adapter in self._started_instances:
-                sdk.logger.info(f"适配器 {platform}（实例ID: {id(adapter)}）已被其他协程启动，跳过")
+                logger.info(f"适配器 {platform}（实例ID: {id(adapter)}）已被其他协程启动，跳过")
                 return
 
             retry_count = 0
@@ -464,12 +467,12 @@ class AdapterManager:
                     return
                 except Exception as e:
                     retry_count += 1
-                    sdk.logger.error(f"平台 {platform} 启动失败（第{retry_count}次重试）: {e}")
+                    logger.error(f"平台 {platform} 启动失败（第{retry_count}次重试）: {e}")
 
                     try:
                         await adapter.shutdown()
                     except Exception as stop_err:
-                        sdk.logger.warning(f"停止适配器失败: {stop_err}")
+                        logger.warning(f"停止适配器失败: {stop_err}")
 
                     # 计算等待时间
                     if retry_count <= len(backoff_intervals):
@@ -477,7 +480,7 @@ class AdapterManager:
                     else:
                         wait_time = fixed_delay
 
-                    sdk.logger.info(f"将在 {wait_time // 60} 分钟后再次尝试重启 {platform}")
+                    logger.info(f"将在 {wait_time // 60} 分钟后再次尝试重启 {platform}")
                     await asyncio.sleep(wait_time)
 
     async def shutdown(self) -> None:
@@ -490,7 +493,7 @@ class AdapterManager:
         for adapter in self._adapters.values():
             await adapter.shutdown()
         
-        from .server import adapter_server
+        from .router import adapter_server
         await adapter_server.stop()
 
     def get(self, platform: str) -> Optional[BaseAdapter]:

ErisPulse/Core/config.py

@@ -72,101 +72,3 @@ class ConfigManager:
             return False
 
 config = ConfigManager()
-
-# 默认配置
-DEFAULT_CONFIG = {
-    "server": {
-        "host": "0.0.0.0",
-        "port": 8000,
-        "ssl_certfile": None,
-        "ssl_keyfile": None
-    },
-    "logger": {
-        "level": "INFO",
-        "log_files": [],
-        "memory_limit": 1000
-    }
-}
-
-def _ensure_config_structure(config: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    确保配置结构完整，补全缺失的配置项
-    
-    :param config: 当前配置
-    :return: 补全后的完整配置
-    """
-    merged_config = DEFAULT_CONFIG.copy()
-    
-    # 深度合并配置
-    for section, default_values in DEFAULT_CONFIG.items():
-        if section not in config:
-            config[section] = default_values.copy()
-            continue
-            
-        if not isinstance(config[section], dict):
-            config[section] = default_values.copy()
-            continue
-            
-        for key, default_value in default_values.items():
-            if key not in config[section]:
-                config[section][key] = default_value
-                
-    return config
-
-def get_config() -> Dict[str, Any]:
-    """
-    获取当前配置，自动补全缺失的配置项并保存
-    
-    :return: 完整的配置字典
-    """
-
-    # 获取现有配置
-    current_config = config.getConfig("ErisPulse")
-    
-    # 如果完全没有配置，设置默认配置
-    if current_config is None:
-        config.setConfig("ErisPulse", DEFAULT_CONFIG)
-        return DEFAULT_CONFIG
-    
-    # 检查并补全缺失的配置项
-    complete_config = _ensure_config_structure(current_config)
-    
-    # 如果配置有变化，更新到存储
-    if current_config != complete_config:
-        config.setConfig("ErisPulse", complete_config)
-    
-    return complete_config
-
-def update_config(new_config: Dict[str, Any]) -> bool:
-    """
-    更新配置，自动补全缺失的配置项
-    
-    :param new_config: 新的配置字典
-    :return: 是否更新成功
-    """
-    # 获取当前配置并合并新配置
-    current = get_config()
-    merged = {**current, **new_config}
-    
-    # 确保合并后的配置结构完整
-    complete_config = _ensure_config_structure(merged)
-    
-    return config.setConfig("ErisPulse", complete_config)
-
-def get_server_config() -> Dict[str, Any]:
-    """
-    获取服务器配置，确保结构完整
-    
-    :return: 服务器配置字典
-    """
-    config = get_config()
-    return config["server"]
-
-def get_logger_config() -> Dict[str, Any]:
-    """
-    获取日志配置，确保结构完整
-    
-    :return: 日志配置字典
-    """
-    config = get_config()
-    return config["logger"]

ErisPulse/Core/env.py

@@ -13,14 +13,10 @@ ErisPulse 环境配置模块
 import os
 import json
 import sqlite3
-import importlib.util
 import shutil
 import time
-import toml
-from pathlib import Path
 from datetime import datetime
-from functools import lru_cache
-from typing import List, Dict, Optional, Any, Set, Tuple, Union, Type, FrozenSet
+from typing import List, Dict, Optional, Any, Tuple, Type
 
 class EnvManager:
     """
@@ -39,7 +35,6 @@ class EnvManager:
     db_path = os.path.join(os.path.dirname(__file__), "../data/config.db")
     SNAPSHOT_DIR = os.path.join(os.path.dirname(__file__), "../data/snapshots")
     
-    CONFIG_FILE = "config.toml"
 
     def __new__(cls, *args, **kwargs):
         if not cls._instance:
@@ -192,8 +187,6 @@ class EnvManager:
             from .config import config
             return config.getConfig(key, default)
         except Exception as e:
-            from . import logger
-            logger.error(f"读取配置文件 {self.CONFIG_FILE} 失败: {e}")
             return default
     
     def setConfig(self, key: str, value: Any) -> bool:
@@ -207,8 +200,6 @@ class EnvManager:
             from .config import config
             return config.setConfig(key, value)
         except Exception as e:
-            from . import logger
-            logger.error(f"写入配置文件 {self.CONFIG_FILE} 失败: {e}")
             return False
 
     def delete(self, key: str) -> bool:
@@ -385,29 +376,7 @@ class EnvManager:
             return True
         except Exception as e:
             return False
-            
-    def load_env_file(self) -> bool:
-        """
-        加载env.py文件中的配置项
         
-        :return: 操作是否成功
-        
-        :example:
-        >>> env.load_env_file()  # 加载env.py中的配置
-        """
-        try:
-            env_file = Path("env.py")
-            if env_file.exists():
-                spec = importlib.util.spec_from_file_location("env_module", env_file)
-                env_module = importlib.util.module_from_spec(spec)
-                spec.loader.exec_module(env_module)
-                for key, value in vars(env_module).items():
-                    if not key.startswith("__") and isinstance(value, (dict, list, str, int, float, bool)):
-                        self.set(key, value)
-            return True
-        except Exception as e:
-            return False
-            
     def __getattr__(self, key: str) -> Any:
         """
         通过属性访问配置项

ErisPulse/Core/erispulse_config.py

@@ -0,0 +1,105 @@
+"""
+ErisPulse 框架配置管理
+
+专门管理 ErisPulse 框架自身的配置项。
+"""
+
+from typing import Dict, Any
+from .config import config
+
+# 默认配置
+DEFAULT_ERISPULSE_CONFIG = {
+    "server": {
+        "host": "0.0.0.0",
+        "port": 8000,
+        "ssl_certfile": None,
+        "ssl_keyfile": None
+    },
+    "logger": {
+        "level": "INFO",
+        "log_files": [],
+        "memory_limit": 1000
+    }
+}
+
+def _ensure_erispulse_config_structure(config_dict: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    确保 ErisPulse 配置结构完整，补全缺失的配置项
+    
+    :param config_dict: 当前配置
+    :return: 补全后的完整配置
+    """
+    merged_config = DEFAULT_ERISPULSE_CONFIG.copy()
+    
+    # 深度合并配置
+    for section, default_values in DEFAULT_ERISPULSE_CONFIG.items():
+        if section not in config_dict:
+            config_dict[section] = default_values.copy()
+            continue
+            
+        if not isinstance(config_dict[section], dict):
+            config_dict[section] = default_values.copy()
+            continue
+            
+        for key, default_value in default_values.items():
+            if key not in config_dict[section]:
+                config_dict[section][key] = default_value
+                
+    return config_dict
+
+def get_erispulse_config() -> Dict[str, Any]:
+    """
+    获取 ErisPulse 框架配置，自动补全缺失的配置项并保存
+    
+    :return: 完整的 ErisPulse 配置字典
+    """
+    # 获取现有配置
+    current_config = config.getConfig("ErisPulse")
+    
+    # 如果完全没有配置，设置默认配置
+    if current_config is None:
+        config.setConfig("ErisPulse", DEFAULT_ERISPULSE_CONFIG)
+        return DEFAULT_ERISPULSE_CONFIG
+    
+    # 检查并补全缺失的配置项
+    complete_config = _ensure_erispulse_config_structure(current_config)
+    
+    # 如果配置有变化，更新到存储
+    if current_config != complete_config:
+        config.setConfig("ErisPulse", complete_config)
+    
+    return complete_config
+
+def update_erispulse_config(new_config: Dict[str, Any]) -> bool:
+    """
+    更新 ErisPulse 配置，自动补全缺失的配置项
+    
+    :param new_config: 新的配置字典
+    :return: 是否更新成功
+    """
+    # 获取当前配置并合并新配置
+    current = get_erispulse_config()
+    merged = {**current, **new_config}
+    
+    # 确保合并后的配置结构完整
+    complete_config = _ensure_erispulse_config_structure(merged)
+    
+    return config.setConfig("ErisPulse", complete_config)
+
+def get_server_config() -> Dict[str, Any]:
+    """
+    获取服务器配置，确保结构完整
+    
+    :return: 服务器配置字典
+    """
+    erispulse_config = get_erispulse_config()
+    return erispulse_config["server"]
+
+def get_logger_config() -> Dict[str, Any]:
+    """
+    获取日志配置，确保结构完整
+    
+    :return: 日志配置字典
+    """
+    erispulse_config = get_erispulse_config()
+    return erispulse_config["logger"]

ErisPulse/Core/exceptions.py

@@ -0,0 +1,108 @@
+"""
+ErisPulse 全局异常处理系统
+
+提供统一的异常捕获和格式化功能，支持同步和异步代码的异常处理。
+"""
+
+import sys
+import traceback
+import asyncio
+import os
+from typing import Dict, Any, Type
+
+class ExceptionHandler:
+    @staticmethod
+    def format_exception(exc_type: Type[Exception], exc_value: Exception, exc_traceback: Any) -> str:
+        """
+        :param exc_type: 异常类型
+        :param exc_value: 异常值
+        :param exc_traceback: 追踪信息
+        :return: 格式化后的异常信息
+        """
+        tb_list = traceback.extract_tb(exc_traceback)
+        if tb_list:
+            last_frame = tb_list[-1]
+            filename = os.path.basename(last_frame.filename)
+            line_number = last_frame.lineno
+            function_name = last_frame.name
+            return f"ERROR: {filename}:{function_name}:{line_number}: {exc_type.__name__}: {exc_value}"
+        else:
+            return f"ERROR: {exc_type.__name__}: {exc_value}"
+        
+    @staticmethod
+    def format_async_exception(exception: Exception) -> str:
+        """
+        :param exception: 异常对象
+        :return: 格式化后的异常信息
+        """
+        if exception.__traceback__:
+            tb_list = traceback.extract_tb(exception.__traceback__)
+            if tb_list:
+                last_frame = tb_list[-1]
+                filename = os.path.basename(last_frame.filename)
+                line_number = last_frame.lineno
+                function_name = last_frame.name
+                return f"ERROR: {filename}:{function_name}:{line_number}: {type(exception).__name__}: {exception}"
+        
+        return f"ERROR: {type(exception).__name__}: {exception}"
+
+def global_exception_handler(exc_type: Type[Exception], exc_value: Exception, exc_traceback: Any) -> None:
+    """
+    全局异常处理器
+    
+    :param exc_type: 异常类型
+    :param exc_value: 异常值
+    :param exc_traceback: 追踪信息
+    """
+    try:
+        from ErisPulse import logger
+        err_logger = logger.error
+    except ImportError:
+        err_logger = sys.stderr.write
+
+    formatted_error = ExceptionHandler.format_exception(exc_type, exc_value, exc_traceback)
+    err_logger(formatted_error)
+
+def async_exception_handler(loop: asyncio.AbstractEventLoop, context: Dict[str, Any]) -> None:
+    """
+    异步异常处理器
+    
+    :param loop: 事件循环
+    :param context: 上下文字典
+    """
+    try:
+        from ErisPulse import logger
+        err_logger = logger.error
+    except ImportError:
+        err_logger = sys.stderr.write
+    
+    exception = context.get('exception')
+    if exception:
+        try:
+            formatted_error = ExceptionHandler.format_async_exception(exception)
+            err_logger(formatted_error + '\n')
+        except Exception:
+            err_logger(f"ERROR: 捕捉器发生错误，原始异常信息：\n\n{exception}\n\n" + traceback.format_exc())
+    else:
+        msg = context.get('message', '未知异步错误')
+        err_logger(f"ERROR: 未处理的异步错误: {msg}\n")
+
+def setup_async_loop(loop: asyncio.AbstractEventLoop = None) -> None:
+    """
+    为指定的事件循环设置异常处理器
+    
+    :param loop: 事件循环实例，如果为None则使用当前事件循环
+    """
+    if loop is None:
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = asyncio.get_event_loop()
+    
+    loop.set_exception_handler(async_exception_handler)
+
+sys.excepthook = global_exception_handler
+try:
+    asyncio.get_event_loop().set_exception_handler(async_exception_handler)
+except RuntimeError:
+    pass

ErisPulse/Core/logger.py

@@ -56,6 +56,10 @@ class Logger:
         """
         if limit > 0:
             self._max_logs = limit
+            # 更新所有已存在的日志列表大小
+            for module_name in self._logs:
+                while len(self._logs[module_name]) > self._max_logs:
+                    self._logs[module_name].pop(0)
             return True
         else:
             self._logger.warning("日志存储上限必须大于0。")
@@ -174,7 +178,7 @@ class Logger:
         self._logs[ModuleName].append(msg)
 
     def _setup_config(self):
-        from .config import get_logger_config
+        from .erispulse_config import get_logger_config
         logger_config = get_logger_config()
         if "level" in logger_config:
             self.set_level(logger_config["level"])
@@ -198,6 +202,20 @@ class Logger:
             module_name = "ErisPulse"
         return module_name
 
+    def get_child(self, child_name: str = None):
+        """
+        获取子日志记录器
+        
+        :param child_name: 子模块名称(可选)
+        :return: LoggerChild 子日志记录器实例
+        """
+        caller_module = self._get_caller()
+        if child_name:
+            full_module_name = f"{caller_module}.{child_name}"
+        else:
+            full_module_name = caller_module
+        return LoggerChild(self, full_module_name)
+
     def debug(self, msg, *args, **kwargs):
         caller_module = self._get_caller()
         if self._get_effective_level(caller_module) <= logging.DEBUG:
@@ -229,4 +247,59 @@ class Logger:
             self._logger.critical(f"[{caller_module}] {msg}", *args, **kwargs)
             raise Exception(msg)
 
+
+class LoggerChild:
+    """
+    子日志记录器
+    
+    用于创建具有特定名称的子日志记录器，仅改变模块名称，其他功能全部委托给父日志记录器
+    """
+    
+    def __init__(self, parent_logger: Logger, name: str):
+        """
+        初始化子日志记录器
+        
+        :param parent_logger: 父日志记录器实例
+        :param name: 子日志记录器名称
+        """
+        self._parent = parent_logger
+        self._name = name
+        
+    def debug(self, msg, *args, **kwargs):
+        if self._parent._get_effective_level(self._name.split('.')[0]) <= logging.DEBUG:
+            self._parent._save_in_memory(self._name, msg)
+            self._parent._logger.debug(f"[{self._name}] {msg}", *args, **kwargs)
+
+    def info(self, msg, *args, **kwargs):
+        if self._parent._get_effective_level(self._name.split('.')[0]) <= logging.INFO:
+            self._parent._save_in_memory(self._name, msg)
+            self._parent._logger.info(f"[{self._name}] {msg}", *args, **kwargs)
+
+    def warning(self, msg, *args, **kwargs):
+        if self._parent._get_effective_level(self._name.split('.')[0]) <= logging.WARNING:
+            self._parent._save_in_memory(self._name, msg)
+            self._parent._logger.warning(f"[{self._name}] {msg}", *args, **kwargs)
+
+    def error(self, msg, *args, **kwargs):
+        if self._parent._get_effective_level(self._name.split('.')[0]) <= logging.ERROR:
+            self._parent._save_in_memory(self._name, msg)
+            self._parent._logger.error(f"[{self._name}] {msg}", *args, **kwargs)
+
+    def critical(self, msg, *args, **kwargs):
+        if self._parent._get_effective_level(self._name.split('.')[0]) <= logging.CRITICAL:
+            self._parent._save_in_memory(self._name, msg)
+            self._parent._logger.critical(f"[{self._name}] {msg}", *args, **kwargs)
+            raise Exception(msg)
+
+    def get_child(self, child_name: str):
+        """
+        获取子日志记录器的子记录器
+        
+        :param child_name: 子模块名称
+        :return: LoggerChild 子日志记录器实例
+        """
+        full_child_name = f"{self._name}.{child_name}"
+        return LoggerChild(self._parent, full_child_name)
+
+
 logger = Logger()