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

ErisPulse/Core/module.py

@@ -1,66 +1,295 @@
 """
-ErisPulse 模块管理模块
+ErisPulse 模块系统
 
-提供便捷的模块访问接口
+提供标准化的模块注册、加载和管理功能，与适配器系统保持一致的设计模式
 """
 
-from typing import Any, Optional, Dict
-from .module_registry import module_registry
+import asyncio
+from typing import Any, Dict, List, Type, Optional
 from .logger import logger
+from .config import config
+from .Bases import BaseModule
+from .lifecycle import lifecycle
 
 class ModuleManager:
     """
     模块管理器
     
-    提供便捷的模块访问接口，支持获取模块实例、检查模块状态等操作
+    提供标准化的模块注册、加载和管理功能，模仿适配器管理器的模式
+    
+    {!--< tips >!--}
+    1. 使用register方法注册模块类
+    2. 使用load/unload方法加载/卸载模块
+    3. 通过get方法获取模块实例
+    {!--< /tips >!--}
     """
     
     def __init__(self):
-        self._modules = {}
+        # 模块存储
+        self._modules: Dict[str, Any] = {}  # 已加载的模块实例
+        self._module_classes: Dict[str, Type] = {}  # 模块类映射
+        self._loaded_modules: set = set()  # 已加载的模块名称
+        self._module_info: Dict[str, Dict] = {}  # 模块信息
+        
+    # ==================== 模块注册与管理 ====================
     
-    def get(self, module_name: str) -> Any:
+    def register(self, module_name: str, module_class: Type, module_info: Optional[Dict] = None) -> bool:
         """
-        获取指定模块的实例
+        注册模块类
         
-        :param module_name: [str] 模块名称
-        :return: [Any] 模块实例或None
+        :param module_name: 模块名称
+        :param module_class: 模块类
+        :param module_info: 模块信息
+        :return: 是否注册成功
+        
+        :raises TypeError: 当模块类无效时抛出
+            
+        :example:
+        >>> module.register("MyModule", MyModuleClass)
         """
-        # 是否已缓存
-        if module_name in self._modules:
-            return self._modules[module_name]
+        # 严格验证模块类，确保继承自BaseModule
+        if not issubclass(module_class, BaseModule):
+            warn_msg = f"模块 {module_name} 的类 {module_class.__name__} 没有继承自BaseModule，但我们仍会继续尝试加载这个模块，但请注意这可能引发其他问题"
+            logger.warning(warn_msg)
+            # error_msg = f"模块 {module_name} 的类 {module_class.__name__} 必须继承自BaseModule"
+            # logger.error(error_msg)
+            # raise TypeError(error_msg)
+            
+        # 验证模块名是否合法
+        if not module_name or not isinstance(module_name, str):
+            error_msg = "模块名称必须是非空字符串"
+            logger.error(error_msg)
+            raise TypeError(error_msg)
             
-        # 从模块注册表获取模块信息
-        module_info = module_registry.get_module(module_name)
-        if not module_info:
-            logger.warning(f"模块 {module_name} 未注册")
-            return None
+        # 检查模块名是否已存在
+        if module_name in self._module_classes:
+            logger.warning(f"模块 {module_name} 已存在，将覆盖原模块类")
             
-        # 模块是否启用
-        if not module_registry.get_module_status(module_name):
-            logger.warning(f"模块 {module_name} 已禁用")
-            return None
+        self._module_classes[module_name] = module_class
+        if module_info:
+            self._module_info[module_name] = module_info
+            
+        logger.info(f"模块 {module_name} 已注册")
+        return True
+    
+    async def load(self, module_name: str) -> bool:
+        """
+        加载指定模块（标准化加载逻辑）
+        
+        :param module_name: 模块名称
+        :return: 是否加载成功
+            
+        :example:
+        >>> await module.load("MyModule")
+        """
+        # 检查模块是否已注册
+        if module_name not in self._module_classes:
+            logger.error(f"模块 {module_name} 未注册")
+            return False
+            
+        # 检查模块是否已加载
+        if module_name in self._loaded_modules:
+            logger.info(f"模块 {module_name} 已加载")
+            return True
             
         try:
             from .. import sdk
-            if hasattr(sdk, module_name):
-                module_instance = getattr(sdk, module_name)
-                self._modules[module_name] = module_instance
-                return module_instance
+            import inspect
+            
+            # 创建模块实例
+            module_class = self._module_classes[module_name]
+            
+            # 检查是否需要传入sdk参数
+            init_signature = inspect.signature(module_class.__init__)
+            params = init_signature.parameters
+            
+            if 'sdk' in params:
+                instance = module_class(sdk)
             else:
-                logger.warning(f"模块 {module_name} 实例未找到")
-                return None
+                instance = module_class()
+                
+            # 设置模块信息
+            if module_name in self._module_info:
+                setattr(instance, "moduleInfo", self._module_info[module_name])
+                
+            # 调用模块的on_load卸载方法
+            if hasattr(instance, 'on_load'):
+                try:
+                    if asyncio.iscoroutinefunction(instance.on_load):
+                        await instance.on_load({"module_name": module_name})
+                    else:
+                        instance.on_load({"module_name": module_name})
+                except Exception as e:
+                    logger.error(f"模块 {module_name} on_load 方法执行失败: {e}")
+                    return False
+                    
+            # 缓存模块实例
+            self._modules[module_name] = instance
+            self._loaded_modules.add(module_name)
+            
+            await lifecycle.submit_event(
+                    "module_load",
+                    data={
+                        "module_name": module_name,
+                        "success": True,
+                    },
+                    msg=f"模块 {module_name if module_name else 'All'} 加载成功",
+                )
+            logger.info(f"模块 {module_name} 加载成功")
+            return True
+            
         except Exception as e:
-            logger.error(f"获取模块 {module_name} 实例时出错: {e}")
-            return None
+            await lifecycle.submit_event(
+                    "module_load",
+                    data={
+                        "module_name": module_name,
+                        "success": False,
+                    },
+                    msg=f"模块 {module_name if module_name else 'All'} 加载失败: {e}",
+                )
+            logger.error(f"加载模块 {module_name} 失败: {e}")
+            return False
+            
+    async def unload(self, module_name: str = "Unknown") -> bool:
+        """
+        卸载指定模块或所有模块
+        
+        :param module_name: 模块名称，如果为None则卸载所有模块
+        :return: 是否卸载成功
+            
+        :example:
+        >>> await module.unload("MyModule")
+        >>> await module.unload()  # 卸载所有模块
+        """
+        if module_name == "Unknown":
+            # 卸载所有模块
+            success = True
+            for name in list(self._loaded_modules):
+                if not await self._unload_single_module(name):
+                    success = False
+            return success
+        else:
+            success = await self._unload_single_module(module_name)
+            
+        await lifecycle.submit_event(
+            "module.unload",
+            msg=f"模块 {module_name if module_name else 'All'} 卸载完成" if success else f"模块 {module_name if module_name else 'All'} 卸载失败",
+            data={
+                "module_name": module_name if module_name else 'All',
+                "success": success
+            }
+        )
+        return success
     
+    async def _unload_single_module(self, module_name: str) -> bool:
+        """
+        {!--< internal-use >!--}
+        卸载单个模块
+        
+        :param module_name: 模块名称
+        :return: 是否卸载成功
+        """
+        if module_name not in self._loaded_modules:
+            logger.warning(f"模块 {module_name} 未加载")
+            return False
+            
+        try:
+            # 调用模块的on_unload卸载方法
+            instance = self._modules[module_name]
+            if hasattr(instance, 'on_unload'):
+                try:
+                    if asyncio.iscoroutinefunction(instance.on_unload):
+                        await instance.on_unload({"module_name": module_name})
+                    else:
+                        instance.on_unload({"module_name": module_name})
+                except Exception as e:
+                    logger.error(f"模块 {module_name} on_unload 方法执行失败: {e}")
+                    
+            # 清理缓存
+            del self._modules[module_name]
+            self._loaded_modules.discard(module_name)
+            
+            logger.info(f"模块 {module_name} 卸载成功")
+            return True
+            
+        except Exception as e:
+            logger.error(f"卸载模块 {module_name} 失败: {e}")
+            return False
+            
+    def get(self, module_name: str) -> Any:
+        """
+        获取模块实例
+        
+        :param module_name: 模块名称
+        :return: 模块实例或None
+            
+        :example:
+        >>> my_module = module.get("MyModule")
+        """
+        return self._modules.get(module_name)
+        
     def exists(self, module_name: str) -> bool:
         """
-        检查模块是否存在
+        检查模块是否存在（在配置中注册）
         
         :param module_name: [str] 模块名称
         :return: [bool] 模块是否存在
         """
-        return module_registry.get_module(module_name) is not None
+        module_statuses = config.getConfig("ErisPulse.modules.status", {})
+        return module_name in module_statuses
+    
+    def is_loaded(self, module_name: str) -> bool:
+        """
+        检查模块是否已加载
+        
+        :param module_name: 模块名称
+        :return: 模块是否已加载
+            
+        :example:
+        >>> if module.is_loaded("MyModule"): ...
+        """
+        return module_name in self._loaded_modules
+        
+    def list_registered(self) -> List[str]:
+        """
+        列出所有已注册的模块
+        
+        :return: 模块名称列表
+            
+        :example:
+        >>> registered = module.list_registered()
+        """
+        return list(self._module_classes.keys())
+        
+    def list_loaded(self) -> List[str]:
+        """
+        列出所有已加载的模块
+        
+        :return: 模块名称列表
+            
+        :example:
+        >>> loaded = module.list_loaded()
+        """
+        return list(self._loaded_modules)
+    
+    # ==================== 模块配置管理 ====================
+    
+    def _config_register(self, module_name: str, enabled: bool = False) -> bool:
+        """
+        注册新模块信息
+        
+        :param module_name: [str] 模块名称
+        :param enabled: [bool] 是否启用模块
+        :return: [bool] 操作是否成功
+        """
+        if self.exists(module_name):
+            return True
+        
+        # 模块不存在，进行注册
+        config.setConfig(f"ErisPulse.modules.status.{module_name}", enabled)
+        status = "启用" if enabled else "禁用"
+        logger.info(f"模块 {module_name} 已注册并{status}")
+        return True
     
     def is_enabled(self, module_name: str) -> bool:
         """
@@ -69,7 +298,15 @@ class ModuleManager:
         :param module_name: [str] 模块名称
         :return: [bool] 模块是否启用
         """
-        return module_registry.get_module_status(module_name)
+        status = config.getConfig(f"ErisPulse.modules.status.{module_name}")
+        
+        if status is None:
+            return False
+        
+        if isinstance(status, str):
+            return status.lower() not in ('false', '0', 'no', 'off')
+        
+        return bool(status)
     
     def enable(self, module_name: str) -> bool:
         """
@@ -78,11 +315,7 @@ class ModuleManager:
         :param module_name: [str] 模块名称
         :return: [bool] 操作是否成功
         """
-        if not self.exists(module_name):
-            logger.error(f"模块 {module_name} 不存在")
-            return False
-            
-        module_registry.set_module_status(module_name, True)
+        config.setConfig(f"ErisPulse.modules.status.{module_name}", True)
         logger.info(f"模块 {module_name} 已启用")
         return True
     
@@ -93,33 +326,23 @@ class ModuleManager:
         :param module_name: [str] 模块名称
         :return: [bool] 操作是否成功
         """
-        if not self.exists(module_name):
-            logger.error(f"模块 {module_name} 不存在")
-            return False
-            
-        module_registry.set_module_status(module_name, False)
+        config.setConfig(f"ErisPulse.modules.status.{module_name}", False)
         logger.info(f"模块 {module_name} 已禁用")
-        # 如果模块在缓存中，移除它
+        
         if module_name in self._modules:
             del self._modules[module_name]
+        self._loaded_modules.discard(module_name)
         return True
     
-    def list_modules(self) -> Dict[str, Dict[str, Any]]:
+    def list_modules(self) -> Dict[str, bool]:
         """
-        列出所有模块信息
+        列出所有模块状态
         
-        :return: [Dict[str, Dict[str, Any]]] 模块信息字典
+        :return: [Dict[str, bool]] 模块状态字典
         """
-        return module_registry.get_all_modules()
+        return config.getConfig("ErisPulse.modules.status", {})
     
-    def get_info(self, module_name: str) -> Optional[Dict[str, Any]]:
-        """
-        获取模块详细信息
-        
-        :param module_name: [str] 模块名称
-        :return: [Optional[Dict[str, Any]]] 模块信息字典
-        """
-        return module_registry.get_module(module_name)
+    # ==================== 工具方法 ====================
     
     def __getattr__(self, module_name: str) -> Any:
         """

ErisPulse/Core/router.py

@@ -1,4 +1,3 @@
-# router.py (新文件名)
 """
 ErisPulse 路由系统
 
@@ -7,7 +6,6 @@ ErisPulse 路由系统
 {!--< tips >!--}
 1. 适配器只需注册路由，无需自行管理服务器
 2. WebSocket支持自定义认证逻辑
-3. 兼容FastAPI 0.68+ 版本
 {!--< /tips >!--}
 """
 
@@ -16,6 +14,7 @@ from fastapi.routing import APIRoute
 from typing import Dict, List, Optional, Callable, Any, Awaitable, Tuple
 from collections import defaultdict
 from .logger import logger
+from .lifecycle import lifecycle
 import asyncio
 from hypercorn.config import Config
 from hypercorn.asyncio import serve
@@ -140,7 +139,8 @@ class RouterManager:
         )
         self.app.router.routes.append(route)
         self._http_routes[module_name][full_path] = handler
-        logger.info(f"注册HTTP路由: {self.base_url}{full_path} 方法: {methods}")
+        display_url = self._format_display_url(f"{self.base_url}{full_path}")
+        logger.info(f"注册HTTP路由: {display_url} 方法: {methods}")
 
     def register_webhook(self, *args, **kwargs) -> None:
         """
@@ -148,6 +148,38 @@ class RouterManager:
         """
         return self.register_http_route(*args, **kwargs)
 
+    def unregister_http_route(self, module_name: str, path: str) -> bool:
+        """
+        取消注册HTTP路由
+
+        :param module_name: 模块名称
+        :param path: 路由路径
+
+        :return: Bool
+        """
+        try:
+            full_path = f"/{module_name}{path}"
+            if full_path not in self._http_routes[module_name]:
+                display_url = self._format_display_url(f"{self.base_url}{full_path}")
+                logger.warning(f"取消注册HTTP路由失败: 路由不存在: {display_url}")
+                return False
+            
+            display_url = self._format_display_url(f"{self.base_url}{full_path}")
+            logger.info(f"取消注册HTTP路由: {display_url}")
+            del self._http_routes[module_name][full_path]
+            
+            # 从路由列表中移除匹配的路由
+            routes = self.app.router.routes
+            self.app.router.routes = [
+                route for route in routes
+                if not (isinstance(route, APIRoute) and route.path == full_path)
+            ]
+
+            return True
+        except Exception as e:
+            logger.error(f"取消注册HTTP路由失败: {e}")
+            return False
+        
     def register_websocket(
         self,
         module_name: str,
@@ -195,8 +227,28 @@ class RouterManager:
             name=f"{module_name}_{path.replace('/', '_')}"
         )
         self._websocket_routes[module_name][full_path] = (handler, auth_handler)
-        logger.info(f"注册WebSocket: {self.base_url}{full_path} {'(需认证)' if auth_handler else ''}")
 
+        display_url = self._format_display_url(f"{self.base_url}{full_path}")
+        logger.info(f"注册WebSocket: {display_url} {'(需认证)' if auth_handler else ''}")
+        
+    def unregister_websocket(self, module_name: str, path: str) -> bool:
+        try:
+            full_path = f"/{module_name}{path}"
+
+            # 使用类型忽略注释
+            if full_path in self.app.websocket_routes:          # type: ignore  || 原因：实际上，FastAPI的API提供了websocket_routes属性
+                self.app.remove_api_websocket_route(full_path)  # type: ignore  || 原因：实际上，FastAPI的API提供了remove_api_websocket_route方法
+                display_url = self._format_display_url(f"{self.base_url}{full_path}")
+                logger.info(f"注销WebSocket: {display_url}")
+                del self._websocket_routes[module_name][full_path]
+                return True
+            display_url = self._format_display_url(f"{self.base_url}{full_path}")
+            logger.error(f"注销WebSocket失败: 路径 {display_url} 不存在")
+            return False
+        except Exception as e:
+            logger.error(f"注销WebSocket失败: {e}")
+            return False
+        
     def get_app(self) -> FastAPI:
         """
         获取FastAPI应用实例
@@ -222,21 +274,46 @@ class RouterManager:
         
         :raises RuntimeError: 当服务器已在运行时抛出
         """
-        if self._server_task and not self._server_task.done():
-            raise RuntimeError("服务器已在运行中")
+        try:
+            if self._server_task and not self._server_task.done():
+                raise RuntimeError("服务器已在运行中")
 
-        config = Config()
-        config.bind = [f"{host}:{port}"]
-        config.loglevel = "warning"
-        
-        if ssl_certfile and ssl_keyfile:
-            config.certfile = ssl_certfile
-            config.keyfile = ssl_keyfile
-        
-        self.base_url = f"http{'s' if ssl_certfile else ''}://{host}:{port}"
-        logger.info(f"启动路由服务器 {self.base_url}")
-        
-        self._server_task = asyncio.create_task(serve(self.app, config))
+            config = Config()
+            config.bind = [f"{host}:{port}"]
+            config.loglevel = "warning"
+            
+            if ssl_certfile and ssl_keyfile:
+                config.certfile = ssl_certfile
+                config.keyfile = ssl_keyfile
+            
+            self.base_url = f"http{'s' if ssl_certfile else ''}://{host}:{port}"
+            display_url = self._format_display_url(self.base_url)
+            logger.info(f"启动路由服务器 {display_url}")
+            
+            self._server_task = asyncio.create_task(serve(self.app, config))   # type: ignore || 原因: Hypercorn与FastAPIl类型不兼容
+
+            await lifecycle.submit_event(
+                "server.start",
+                msg="路由服务器已启动",
+                data={
+                    "base_url": self.base_url,
+                    "host": host,
+                    "port": port,
+                },
+            )
+        except Exception as e:
+            display_url = self._format_display_url(self.base_url)
+            await lifecycle.submit_event(
+                "server.start",
+                msg="路由服务器启动失败",
+                data={
+                    "base_url": self.base_url,
+                    "host": host,
+                    "port": port,
+                }
+            )
+            logger.error(f"启动服务器失败: {e}")
+            raise e
 
     async def stop(self) -> None:
         """
@@ -249,14 +326,26 @@ class RouterManager:
             except asyncio.CancelledError:
                 logger.info("路由服务器已停止")
             self._server_task = None
+        
+        await lifecycle.submit_event("server.stop", msg="服务器已停止")
 
-# 主要实例
-router = RouterManager()
+    def _format_display_url(self, url: str) -> str:
+        """
+        格式化URL显示，将回环地址转换为更友好的格式
+        
+        :param url: 原始URL
+        :return: 格式化后的URL
+        """
+        if "0.0.0.0" in url:
+            display_url = url.replace("0.0.0.0", "127.0.0.1")
+            return f"{url} (可访问: {display_url})"
+        elif "::" in url:
+            display_url = url.replace("::", "localhost")
+            return f"{url} (可访问: {display_url})"
+        return url
 
-# 兼容性实例
-adapter_server = router
+router = RouterManager()
 
 __all__ = [
     "router",
-    "adapter_server"
 ]