ErisPulse 2.1.13rc3__py3-none-any.whl → 2.1.14.dev2__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

@@ -174,7 +174,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"])

ErisPulse/Core/{server.py → router.py}

@@ -1,6 +1,8 @@
+# router.py (新文件名)
 """
-ErisPulse Adapter Server
-提供统一的适配器服务入口，支持HTTP和WebSocket路由
+ErisPulse 路由系统
+
+提供统一的HTTP和WebSocket路由管理，支持多适配器路由注册和生命周期管理。
 
 {!--< tips >!--}
 1. 适配器只需注册路由，无需自行管理服务器
@@ -19,9 +21,9 @@ from hypercorn.config import Config
 from hypercorn.asyncio import serve
 
 
-class AdapterServer:
+class RouterManager:
     """
-    适配器服务器管理器
+    路由管理器
     
     {!--< tips >!--}
     核心功能：
@@ -33,18 +35,18 @@ class AdapterServer:
 
     def __init__(self):
         """
-        初始化适配器服务器
+        初始化路由管理器
         
         {!--< tips >!--}
         会自动创建FastAPI实例并设置核心路由
         {!--< /tips >!--}
         """
         self.app = FastAPI(
-            title="ErisPulse Adapter Server",
-            description="统一适配器服务入口点",
+            title="ErisPulse Router",
+            description="统一路由管理入口点",
             version="1.0.0"
         )
-        self._webhook_routes: Dict[str, Dict[str, Callable]] = defaultdict(dict)
+        self._http_routes: Dict[str, Dict[str, Callable]] = defaultdict(dict)
         self._websocket_routes: Dict[str, Dict[str, Tuple[Callable, Optional[Callable]]]] = defaultdict(dict)
         self.base_url = ""
         self._server_task: Optional[asyncio.Task] = None
@@ -66,7 +68,7 @@ class AdapterServer:
             :return: 
                 Dict[str, str]: 包含服务状态的字典
             """
-            return {"status": "ok", "service": "ErisPulse Adapter Server"}
+            return {"status": "ok", "service": "ErisPulse Router"}
             
         @self.app.get("/routes")
         async def list_routes() -> Dict[str, Any]:
@@ -74,36 +76,23 @@ class AdapterServer:
             列出所有已注册路由
             
             :return: 
-                Dict[str, Any]: 包含所有路由信息的字典，格式为:
-                {
-                    "http_routes": [
-                        {
-                            "path": "/adapter1/route1",
-                            "adapter": "adapter1",
-                            "methods": ["POST"]
-                        },
-                        ...
-                    ],
-                    "websocket_routes": [
-                        {
-                            "path": "/adapter1/ws",
-                            "adapter": "adapter1",
-                            "requires_auth": true
-                        },
-                        ...
-                    ],
-                    "base_url": self.base_url
-                }
+                Dict[str, Any]: 包含所有路由信息的字典
             """
             http_routes = []
-            for adapter, routes in self._webhook_routes.items():
+            for adapter, routes in self._http_routes.items():
                 for path, handler in routes.items():
-                    route = self.app.router.routes[-1]  # 获取最后添加的路由
-                    if isinstance(route, APIRoute) and route.path == path:
+                    # 查找对应的路由对象
+                    route_obj = None
+                    for route in self.app.router.routes:
+                        if isinstance(route, APIRoute) and route.path == path:
+                            route_obj = route
+                            break
+                    
+                    if route_obj:
                         http_routes.append({
                             "path": path,
                             "adapter": adapter,
-                            "methods": route.methods
+                            "methods": list(route_obj.methods)
                         })
             
             websocket_routes = []
@@ -121,9 +110,9 @@ class AdapterServer:
                 "base_url": self.base_url
             }
 
-    def register_webhook(
+    def register_http_route(
         self, 
-        adapter_name: str,
+        module_name: str,
         path: str,
         handler: Callable,
         methods: List[str] = ["POST"]
@@ -131,35 +120,37 @@ class AdapterServer:
         """
         注册HTTP路由
         
-        :param adapter_name: str 适配器名称
-        :param path: str 路由路径(如"/message")
+        :param module_name: str 模块名称
+        :param path: str 路由路径
         :param handler: Callable 处理函数
         :param methods: List[str] HTTP方法列表(默认["POST"])
         
         :raises ValueError: 当路径已注册时抛出
-        
-        {!--< tips >!--}
-        路径会自动添加适配器前缀，如：/adapter_name/path
-        {!--< /tips >!--}
         """
-        full_path = f"/{adapter_name}{path}"
+        full_path = f"/{module_name}{path}"
         
-        if full_path in self._webhook_routes[adapter_name]:
+        if full_path in self._http_routes[module_name]:
             raise ValueError(f"路径 {full_path} 已注册")
             
         route = APIRoute(
             path=full_path,
             endpoint=handler,
             methods=methods,
-            name=f"{adapter_name}{path}"
+            name=f"{module_name}_{path.replace('/', '_')}"
         )
         self.app.router.routes.append(route)
-        self._webhook_routes[adapter_name][full_path] = handler
+        self._http_routes[module_name][full_path] = handler
         logger.info(f"注册HTTP路由: {self.base_url}{full_path} 方法: {methods}")
 
+    def register_webhook(self, *args, **kwargs) -> None:
+        """
+        兼容性方法：注册HTTP路由（适配器旧接口）
+        """
+        return self.register_http_route(*args, **kwargs)
+
     def register_websocket(
         self,
-        adapter_name: str,
+        module_name: str,
         path: str,
         handler: Callable[[WebSocket], Awaitable[Any]],
         auth_handler: Optional[Callable[[WebSocket], Awaitable[bool]]] = None,
@@ -167,29 +158,21 @@ class AdapterServer:
         """
         注册WebSocket路由
         
-        :param adapter_name: str 适配器名称
-        :param path: str WebSocket路径(如"/ws")
+        :param module_name: str 模块名称
+        :param path: str WebSocket路径
         :param handler: Callable[[WebSocket], Awaitable[Any]] 主处理函数
         :param auth_handler: Optional[Callable[[WebSocket], Awaitable[bool]]] 认证函数
         
         :raises ValueError: 当路径已注册时抛出
-        
-        {!--< tips >!--}
-        认证函数应返回布尔值，False将拒绝连接
-        {!--< /tips >!--}
         """
-        full_path = f"/{adapter_name}{path}"
+        full_path = f"/{module_name}{path}"
         
-        if full_path in self._websocket_routes[adapter_name]:
+        if full_path in self._websocket_routes[module_name]:
             raise ValueError(f"WebSocket路径 {full_path} 已注册")
             
         async def websocket_endpoint(websocket: WebSocket) -> None:
             """
             WebSocket端点包装器
-            
-            {!--< internal-use >!--}
-            处理连接生命周期和错误处理
-            {!--< /internal-use >!--}
             """
             await websocket.accept()
             
@@ -209,17 +192,16 @@ class AdapterServer:
         self.app.add_api_websocket_route(
             path=full_path,
             endpoint=websocket_endpoint,
-            name=f"{adapter_name}{path}"
+            name=f"{module_name}_{path.replace('/', '_')}"
         )
-        self._websocket_routes[adapter_name][full_path] = (handler, auth_handler)
+        self._websocket_routes[module_name][full_path] = (handler, auth_handler)
         logger.info(f"注册WebSocket: {self.base_url}{full_path} {'(需认证)' if auth_handler else ''}")
 
     def get_app(self) -> FastAPI:
         """
         获取FastAPI应用实例
         
-        :return: 
-            FastAPI: FastAPI应用实例
+        :return: FastAPI应用实例
         """
         return self.app
 
@@ -231,7 +213,7 @@ class AdapterServer:
         ssl_keyfile: Optional[str] = None
     ) -> None:
         """
-        启动适配器服务器
+        启动路由服务器
         
         :param host: str 监听地址(默认"0.0.0.0")
         :param port: int 监听端口(默认8000)
@@ -252,25 +234,24 @@ class AdapterServer:
             config.keyfile = ssl_keyfile
         
         self.base_url = f"http{'s' if ssl_certfile else ''}://{host}:{port}"
-        logger.info(f"启动服务器 {self.base_url}")
+        logger.info(f"启动路由服务器 {self.base_url}")
         
         self._server_task = asyncio.create_task(serve(self.app, config))
 
     async def stop(self) -> None:
         """
         停止服务器
-        
-        {!--< tips >!--}
-        会等待所有连接正常关闭
-        {!--< /tips >!--}
         """
         if self._server_task:
             self._server_task.cancel()
             try:
                 await self._server_task
             except asyncio.CancelledError:
-                logger.info("服务器已停止")
+                logger.info("路由服务器已停止")
             self._server_task = None
 
+# 主要实例
+router = RouterManager()
 
-adapter_server = AdapterServer()
+# 兼容性实例
+adapter_server = router

ErisPulse/__init__.py

@@ -10,6 +10,9 @@ ErisPulse SDK 主模块
 {!--< /tips >!--}
 """
 
+__version__ = "2.1.14dev1"
+__author__  = "ErisPulse"
+
 import os
 import sys
 import importlib
@@ -19,28 +22,36 @@ from typing import Dict, List, Tuple, Type, Any
 from pathlib import Path
 
 # BaseModules: SDK核心模块
-from .Core import util
-from .Core import raiserr
 from .Core import logger
 from .Core import env
 from .Core import mods
 from .Core import adapter, AdapterFather, SendDSL
-from .Core import adapter_server
+from .Core import router, adapter_server
+from .Core import exceptions
+from .Core import config
 
 sdk = sys.modules[__name__]
 
 BaseModules = {
-    "util": util,
     "logger": logger,
-    "raiserr": raiserr,
+    "config": config,
+    "exceptions": exceptions,
     "env": env,
     "mods": mods,
     "adapter": adapter,
+    "router": router,
+    "adapter_server": adapter_server,
     "SendDSL": SendDSL,
     "AdapterFather": AdapterFather,
     "BaseAdapter": AdapterFather
 }
 
+import asyncio
+
+asyncio_loop = asyncio.get_event_loop()
+
+exceptions.setup_async_loop(asyncio_loop)
+
 for module, moduleObj in BaseModules.items():
     setattr(sdk, module, moduleObj)
 
@@ -664,23 +675,24 @@ def _prepare_environment() -> bool:
     {!--< internal-use >!--}
     准备运行环境
     
-    1. 初始化项目环境文件
-    2. 加载环境变量配置
+    初始化项目环境文件
 
     :return: bool 环境准备是否成功
     """
     logger.info("[Init] 准备初始化环境...")
     try:
+        from .Core.erispulse_config import get_erispulse_config
+        get_erispulse_config()
+        logger.info("[Init] 配置文件已加载")
+        
         main_init = init_progress()
         if main_init:
             logger.info("[Init] 项目入口已生成, 你可以在 main.py 中编写一些代码")
-        env.load_env_file()
         return True
     except Exception as e:
         logger.error(f"环境准备失败: {e}")
         return False
 
-
 def init() -> bool:
     """
     SDK初始化入口

ErisPulse/__main__.py

@@ -19,7 +19,6 @@ import json
 import asyncio
 from urllib.parse import urlparse
 from typing import List, Dict, Tuple, Optional, Callable, Any
-from importlib.metadata import version, PackageNotFoundError
 from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler
 
@@ -188,26 +187,38 @@ class PackageManager:
         
         try:
             # 查找模块和适配器
-            for dist in importlib.metadata.distributions():
-                if "ErisPulse-" in dist.metadata["Name"]:
-                    entry_points = dist.entry_points
-                    for ep in entry_points:
-                        if ep.group == "erispulse.module":
-                            packages["modules"][ep.name] = {
-                                "package": dist.metadata["Name"],
-                                "version": dist.version,
-                                "summary": dist.metadata["Summary"],
-                                "enabled": self._is_module_enabled(ep.name)
-                            }
-                        elif ep.group == "erispulse.adapter":
-                            packages["adapters"][ep.name] = {
-                                "package": dist.metadata["Name"],
-                                "version": dist.version,
-                                "summary": dist.metadata["Summary"]
-                            }
+            entry_points = importlib.metadata.entry_points()
+            
+            # 处理模块
+            if hasattr(entry_points, 'select'):
+                module_entries = entry_points.select(group='erispulse.module')
+            else:
+                module_entries = entry_points.get('erispulse.module', [])
+            
+            for entry in module_entries:
+                dist = entry.dist
+                packages["modules"][entry.name] = {
+                    "package": dist.metadata["Name"],
+                    "version": dist.version,
+                    "summary": dist.metadata["Summary"],
+                    "enabled": self._is_module_enabled(entry.name)
+                }
+            
+            # 处理适配器
+            if hasattr(entry_points, 'select'):
+                adapter_entries = entry_points.select(group='erispulse.adapter')
+            else:
+                adapter_entries = entry_points.get('erispulse.adapter', [])
+            
+            for entry in adapter_entries:
+                dist = entry.dist
+                packages["adapters"][entry.name] = {
+                    "package": dist.metadata["Name"],
+                    "version": dist.version,
+                    "summary": dist.metadata["Summary"]
+                }
             
             # 查找CLI扩展
-            entry_points = importlib.metadata.entry_points()
             if hasattr(entry_points, 'select'):
                 cli_entries = entry_points.select(group='erispulse.cli')
             else:
@@ -222,9 +233,9 @@ class PackageManager:
                 }
                 
         except Exception as e:
-            console.print(f"[error]获取已安装包信息失败: {e}[/]")
+            print(f"[error] 获取已安装包信息失败: {e}")
             import traceback
-            console.print(traceback.format_exc())
+            print(traceback.format_exc())
         
         return packages
     

{erispulse-2.1.13rc3.dist-info → erispulse-2.1.14.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ErisPulse
-Version: 2.1.13rc3
+Version: 2.1.14.dev2
 Summary: ErisPulse 是一个模块化、可扩展的异步 Python SDK 框架，主要用于构建高效、可维护的机器人应用程序。
 Author-email: "艾莉丝·格雷拉特(WSu2059)" <wsu2059@qq.com>, runoneall <runoobsteve@gmail.com>
 License: MIT License

erispulse-2.1.14.dev2.dist-info/RECORD

@@ -0,0 +1,16 @@
+ErisPulse/__init__.py,sha256=YoqCrqbR1dxjajBii6D4iebuVUl2bZaZYbpPXEgGBz8,26428
+ErisPulse/__main__.py,sha256=aDYN5_11PdL3tj2ruhNoXwNc9TmAUnBtFujQgnEf_sI,37573
+ErisPulse/Core/__init__.py,sha256=hX2yEt9VSD3JubiofoQdcY4v1lnQUU02dhuVADkMTVo,437
+ErisPulse/Core/adapter.py,sha256=oBJOp6SS8sm8NgIxQwetGsHu24wHNXz7ESQ5yKJSo7Q,18234
+ErisPulse/Core/config.py,sha256=2BRWINOqKtHSCP4KfhuiRpGwR96jWGKV7gjZSi_VQHE,2397
+ErisPulse/Core/env.py,sha256=U45f9WtriVyd3tW1N8to-ZvpzcF9gD8DJzNTC1jY2cM,17665
+ErisPulse/Core/erispulse_config.py,sha256=QDx401hNX9JcSHqCSVK33X6VTubl6HI1znAK3T_J0K0,3034
+ErisPulse/Core/exceptions.py,sha256=zuTREGczwGzbYT4Z6dACqHwgNRpiJeLFR8aCxFdOg7k,3667
+ErisPulse/Core/logger.py,sha256=HY6jkTQpztbc07mewHbMpaFNv_2-fX-87G78UEa3DTo,8306
+ErisPulse/Core/mods.py,sha256=2yIq8t9Ca9CBPRiZU0yr8Lc0XGmmkB7LlH-5FWqXjw4,7023
+ErisPulse/Core/router.py,sha256=66hT8VC2dVNX-dANldoOPDcqQ94hidFkNnvKgAPemGQ,8491
+erispulse-2.1.14.dev2.dist-info/METADATA,sha256=h-m8vZWF0_WsUwiSj83NmYEZz0zEA91-cdR39EkyKpc,6264
+erispulse-2.1.14.dev2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+erispulse-2.1.14.dev2.dist-info/entry_points.txt,sha256=Jss71M6nEha0TA-DyVZugPYdcL14s9QpiOeIlgWxzOc,182
+erispulse-2.1.14.dev2.dist-info/licenses/LICENSE,sha256=4jyqikiB0G0n06CEEMMTzTXjE4IShghSlB74skMSPQs,1464
+erispulse-2.1.14.dev2.dist-info/RECORD,,

ErisPulse/Core/raiserr.py

@@ -1,181 +0,0 @@
-"""
-ErisPulse 错误管理系统
-
-提供全局异常捕获功能。不再推荐使用自定义错误注册功能。
-
-{!--< tips >!--}
-1. 请使用Python原生异常抛出方法
-2. 系统会自动捕获并格式化所有未处理异常
-3. 注册功能已标记为弃用，将在未来版本移除
-{!--< /tips >!--}
-"""
-
-import sys
-import traceback
-import asyncio
-from typing import Dict, Any, Optional, Type, Callable, List, Set, Tuple, Union
-
-class Error:
-    """
-    错误管理器
-    
-    {!--< deprecated >!--} 请使用Python原生异常抛出方法 | 2025-07-18
-    
-    {!--< tips >!--}
-    1. 注册功能将在未来版本移除
-    2. 请直接使用raise Exception("message")方式抛出异常
-    {!--< /tips >!--}
-    """
-    
-    def __init__(self):
-        self._types = {}
-
-    def register(self, name: str, doc: str = "", base: Type[Exception] = Exception) -> Type[Exception]:
-        """
-        注册新的错误类型
-        
-        {!--< deprecated >!--} 请使用Python原生异常抛出方法 | 2025-07-18
-        
-        :param name: 错误类型名称
-        :param doc: 错误描述文档
-        :param base: 基础异常类
-        :return: 注册的错误类
-        """
-        if name not in self._types:
-            err_cls = type(name, (base,), {"__doc__": doc})
-            self._types[name] = err_cls
-        return self._types[name]
-
-    def __getattr__(self, name: str) -> Callable[..., None]:
-        """
-        动态获取错误抛出函数
-        
-        {!--< deprecated >!--} 请使用Python原生异常抛出方法 | 2025-07-18
-        
-        :param name: 错误类型名称
-        :return: 错误抛出函数
-        
-        :raises AttributeError: 当错误类型未注册时抛出
-        """
-        def raiser(msg: str, exit: bool = False) -> None:
-            """
-            错误抛出函数
-            
-            :param msg: 错误消息
-            :param exit: 是否退出程序
-            """
-            from .logger import logger
-            err_cls = self._types.get(name) or self.register(name)
-            exc = err_cls(msg)
-
-            red = '\033[91m'
-            reset = '\033[0m'
-
-            logger.error(f"{red}{name}: {msg} | {err_cls.__doc__}{reset}")
-            logger.error(f"{red}{ ''.join(traceback.format_stack()) }{reset}")
-
-            if exit:
-                raise exc
-        return raiser
-
-    def info(self, name: Optional[str] = None) -> Dict[str, Any]:
-        """
-        获取错误信息
-        
-        {!--< deprecated >!--} 此功能将在未来版本移除 | 2025-07-18
-        
-        :param name: 错误类型名称(可选)
-        :return: 错误信息字典
-        """
-        result = {}
-        for err_name, err_cls in self._types.items():
-            result[err_name] = {
-                "type": err_name,
-                "doc": getattr(err_cls, "__doc__", ""),
-                "class": err_cls,
-            }
-        if name is None:
-            return result
-        err_cls = self._types.get(name)
-        if not err_cls:
-            return {
-                "type": None,
-                "doc": None,
-                "class": None,
-            }
-        return {
-            "type": name,
-            "doc": getattr(err_cls, "__doc__", ""),
-            "class": err_cls,
-        }
-
-
-raiserr = Error()
-
-def global_exception_handler(exc_type: Type[Exception], exc_value: Exception, exc_traceback: Any) -> None:
-    """
-    全局异常处理器
-    
-    :param exc_type: 异常类型
-    :param exc_value: 异常值
-    :param exc_traceback: 追踪信息
-    """
-    RED = '\033[91m'
-    YELLOW = '\033[93m'
-    BLUE = '\033[94m'
-    RESET = '\033[0m'
-    
-    error_title = f"{RED}{exc_type.__name__}{RESET}: {YELLOW}{exc_value}{RESET}"
-    traceback_lines = traceback.format_exception(exc_type, exc_value, exc_traceback)
-    
-    colored_traceback = []
-    for line in traceback_lines:
-        if "File " in line and ", line " in line:
-            parts = line.split(', line ')
-            colored_line = f"{BLUE}{parts[0]}{RESET}, line {parts[1]}"
-            colored_traceback.append(colored_line)
-        else:
-            colored_traceback.append(f"{RED}{line}{RESET}")
-    
-    full_error = f"""
-{error_title}
-{RED}Traceback:{RESET}
-{colored_traceback}"""
-    
-    sys.stderr.write(full_error)
-
-def async_exception_handler(loop: asyncio.AbstractEventLoop, context: Dict[str, Any]) -> None:
-    """
-    异步异常处理器
-    
-    :param loop: 事件循环
-    :param context: 上下文字典
-    """
-    RED = '\033[91m'
-    YELLOW = '\033[93m'
-    BLUE = '\033[94m'
-    RESET = '\033[0m'
-    
-    exception = context.get('exception')
-    if exception:
-        tb = ''.join(traceback.format_exception(type(exception), exception, exception.__traceback__))
-        
-        colored_tb = []
-        for line in tb.split('\n'):
-            if "File " in line and ", line " in line:
-                parts = line.split(', line ')
-                colored_line = f"{BLUE}{parts[0]}{RESET}, line {parts[1]}"
-                colored_tb.append(colored_line)
-            else:
-                colored_tb.append(f"{RED}{line}{RESET}")
-        
-        error_msg = f"""{RED}{type(exception).__name__}{RESET}: {YELLOW}{exception}{RESET}
-{RED}Traceback:{RESET}
-{colored_tb}"""
-        sys.stderr.write(error_msg)
-    else:
-        msg = context.get('message', 'Unknown async error')
-        sys.stderr.write(f"{RED}Async Error{RESET}: {YELLOW}{msg}{RESET}")
-
-sys.excepthook = global_exception_handler
-asyncio.get_event_loop().set_exception_handler(async_exception_handler)

ErisPulse/Core/util.py

@@ -1,123 +0,0 @@
-"""
-ErisPulse 工具函数集合
-
-提供常用工具函数，包括拓扑排序、缓存装饰器、异步执行等实用功能。
-
-{!--< tips >!--}
-1. 使用@cache装饰器缓存函数结果
-2. 使用@run_in_executor在独立线程中运行同步函数
-3. 使用@retry实现自动重试机制
-{!--< /tips >!--}
-"""
-
-import time
-import asyncio
-import functools
-import traceback
-from concurrent.futures import ThreadPoolExecutor
-from collections import defaultdict, deque
-from typing import List, Dict, Type, Callable, Any, Optional, Set
-
-executor = ThreadPoolExecutor()
-
-class Util:
-    """
-    工具函数集合
-    
-    提供各种实用功能，简化开发流程
-    
-    {!--< tips >!--}
-    1. 拓扑排序用于解决依赖关系
-    2. 装饰器简化常见模式实现
-    3. 异步执行提升性能
-    {!--< /tips >!--}
-    """
-    def ExecAsync(self, async_func: Callable, *args: Any, **kwargs: Any) -> Any:
-        """
-        异步执行函数
-        
-        :param async_func: 异步函数
-        :param args: 位置参数
-        :param kwargs: 关键字参数
-        :return: 函数执行结果
-        
-        :example:
-        >>> result = util.ExecAsync(my_async_func, arg1, arg2)
-        """
-        loop = asyncio.get_event_loop()
-        return loop.run_in_executor(executor, lambda: asyncio.run(async_func(*args, **kwargs)))
-
-    def cache(self, func: Callable) -> Callable:
-        """
-        缓存装饰器
-        
-        :param func: 被装饰函数
-        :return: 装饰后的函数
-        
-        :example:
-        >>> @util.cache
-        >>> def expensive_operation(param):
-        >>>     return heavy_computation(param)
-        """
-        cache_dict = {}
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            key = (args, tuple(sorted(kwargs.items())))
-            if key not in cache_dict:
-                cache_dict[key] = func(*args, **kwargs)
-            return cache_dict[key]
-        return wrapper
-
-    def run_in_executor(self, func: Callable) -> Callable:
-        """
-        在独立线程中执行同步函数的装饰器
-        
-        :param func: 被装饰的同步函数
-        :return: 可等待的协程函数
-        
-        :example:
-        >>> @util.run_in_executor
-        >>> def blocking_io():
-        >>>     # 执行阻塞IO操作
-        >>>     return result
-        """
-        @functools.wraps(func)
-        async def wrapper(*args, **kwargs):
-            loop = asyncio.get_event_loop()
-            try:
-                return await loop.run_in_executor(None, lambda: func(*args, **kwargs))
-            except Exception as e:
-                from . import logger
-                logger.error(f"线程内发生未处理异常:\n{''.join(traceback.format_exc())}")
-        return wrapper
-
-    def retry(self, max_attempts: int = 3, delay: int = 1) -> Callable:
-        """
-        自动重试装饰器
-        
-        :param max_attempts: 最大重试次数 (默认: 3)
-        :param delay: 重试间隔(秒) (默认: 1)
-        :return: 装饰器函数
-        
-        :example:
-        >>> @util.retry(max_attempts=5, delay=2)
-        >>> def unreliable_operation():
-        >>>     # 可能失败的操作
-        """
-        def decorator(func: Callable) -> Callable:
-            @functools.wraps(func)
-            def wrapper(*args, **kwargs):
-                attempts = 0
-                while attempts < max_attempts:
-                    try:
-                        return func(*args, **kwargs)
-                    except Exception as e:
-                        attempts += 1
-                        if attempts == max_attempts:
-                            raise
-                        time.sleep(delay)
-            return wrapper
-        return decorator
-
-
-util = Util()

erispulse-2.1.13rc3.dist-info/RECORD

@@ -1,16 +0,0 @@
-ErisPulse/__init__.py,sha256=T-N56UQyBmpvlqwH2wGi5ptPzaJpbgF5tKkJt0DlkaM,26099
-ErisPulse/__main__.py,sha256=kGpk-BeztjhrdNwWL2mZxaVy05y4XicCS6SZGtQERho,37409
-ErisPulse/Core/__init__.py,sha256=tBYPahQ7-w7U6M69xy8DW0_ECa9ja-Q0y_SQqVswYBo,409
-ErisPulse/Core/adapter.py,sha256=ZK81dibJ471FowL0MRXkS113iBcMgj_VzpTw0PzhAEo,18102
-ErisPulse/Core/config.py,sha256=ZmwGdtHSOE7K5uOGzLYcyl3ZF3sAmeWAntqcdfDzhpM,5027
-ErisPulse/Core/env.py,sha256=HGkzsdbxh8c1GSDJhnGP9B09Sz2ZeNbRxWieaFmAcug,18870
-ErisPulse/Core/logger.py,sha256=cJzNXF-EmdWxwgiHg5Itmkwsva2Jhe9l9X4rXKiXHgc,8296
-ErisPulse/Core/mods.py,sha256=2yIq8t9Ca9CBPRiZU0yr8Lc0XGmmkB7LlH-5FWqXjw4,7023
-ErisPulse/Core/raiserr.py,sha256=vlyaaiOIYkyqm9dAqSW9E54JBzX-9roHDp5_r6I0yUU,5591
-ErisPulse/Core/server.py,sha256=FkDTeLuHD5IBnWVxvYU8pHb6yCt8GzyvC1bpOiJ7G7I,9217
-ErisPulse/Core/util.py,sha256=7rdMmn6sBFqYd4znxBCcJjuv2eyTExdeKyZopgds868,3796
-erispulse-2.1.13rc3.dist-info/METADATA,sha256=ppMW2h_uDFhvpfP9u30vbaHgQA9fr_oPdDzeWaLQRf4,6262
-erispulse-2.1.13rc3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-erispulse-2.1.13rc3.dist-info/entry_points.txt,sha256=Jss71M6nEha0TA-DyVZugPYdcL14s9QpiOeIlgWxzOc,182
-erispulse-2.1.13rc3.dist-info/licenses/LICENSE,sha256=4jyqikiB0G0n06CEEMMTzTXjE4IShghSlB74skMSPQs,1464
-erispulse-2.1.13rc3.dist-info/RECORD,,