ErisPulse 2.1.15.dev3__py3-none-any.whl → 2.2.0.dev1__py3-none-any.whl

ErisPulse/Core/Event/meta.py

@@ -0,0 +1,81 @@
+"""
+ErisPulse 元事件处理模块
+
+提供基于装饰器的元事件处理功能
+"""
+
+from .base import BaseEventHandler
+from .manager import event_manager
+from typing import Callable, Dict, Any
+
+class MetaHandler:
+    """
+    元事件处理器
+    
+    提供元事件（如连接、断开连接、心跳等）的处理功能
+    """
+    
+    def __init__(self):
+        """
+        初始化元事件处理器
+        """
+        self.handler = event_manager.create_event_handler("meta", "meta")
+    
+    def on_meta(self, priority: int = 0):
+        """
+        通用元事件装饰器
+        
+        :param priority: 处理器优先级
+        :return: 装饰器函数
+        """
+        def decorator(func: Callable):
+            self.handler.register(func, priority)
+            return func
+        return decorator
+    
+    def on_connect(self, priority: int = 0):
+        """
+        连接事件装饰器
+        
+        :param priority: 处理器优先级
+        :return: 装饰器函数
+        """
+        def condition(event: Dict[str, Any]) -> bool:
+            return event.get("detail_type") == "connect"
+        
+        def decorator(func: Callable):
+            self.handler.register(func, priority, condition)
+            return func
+        return decorator
+    
+    def on_disconnect(self, priority: int = 0):
+        """
+        断开连接事件装饰器
+        
+        :param priority: 处理器优先级
+        :return: 装饰器函数
+        """
+        def condition(event: Dict[str, Any]) -> bool:
+            return event.get("detail_type") == "disconnect"
+        
+        def decorator(func: Callable):
+            self.handler.register(func, priority, condition)
+            return func
+        return decorator
+    
+    def on_heartbeat(self, priority: int = 0):
+        """
+        心跳事件装饰器
+        
+        :param priority: 处理器优先级
+        :return: 装饰器函数
+        """
+        def condition(event: Dict[str, Any]) -> bool:
+            return event.get("detail_type") == "heartbeat"
+        
+        def decorator(func: Callable):
+            self.handler.register(func, priority, condition)
+            return func
+        return decorator
+
+meta = MetaHandler()

ErisPulse/Core/Event/notice.py

@@ -0,0 +1,96 @@
+"""
+ErisPulse 通知处理模块
+
+提供基于装饰器的通知事件处理功能
+"""
+
+from .base import BaseEventHandler
+from .manager import event_manager
+from typing import Callable, Dict, Any
+
+class NoticeHandler:
+    """
+    通知处理器
+    
+    提供不同类型通知事件的处理功能
+    """
+    
+    def __init__(self):
+        """
+        初始化通知处理器
+        """
+        self.handler = event_manager.create_event_handler("notice", "notice")
+    
+    def on_notice(self, priority: int = 0):
+        """
+        通用通知事件装饰器
+        
+        :param priority: 处理器优先级
+        :return: 装饰器函数
+        """
+        def decorator(func: Callable):
+            self.handler.register(func, priority)
+            return func
+        return decorator
+    
+    def on_friend_add(self, priority: int = 0):
+        """
+        好友添加通知事件装饰器
+        
+        :param priority: 处理器优先级
+        :return: 装饰器函数
+        """
+        def condition(event: Dict[str, Any]) -> bool:
+            return event.get("detail_type") == "friend_increase"
+        
+        def decorator(func: Callable):
+            self.handler.register(func, priority, condition)
+            return func
+        return decorator
+    
+    def on_friend_remove(self, priority: int = 0):
+        """
+        好友删除通知事件装饰器
+        
+        :param priority: 处理器优先级
+        :return: 装饰器函数
+        """
+        def condition(event: Dict[str, Any]) -> bool:
+            return event.get("detail_type") == "friend_decrease"
+        
+        def decorator(func: Callable):
+            self.handler.register(func, priority, condition)
+            return func
+        return decorator
+    
+    def on_group_increase(self, priority: int = 0):
+        """
+        群成员增加通知事件装饰器
+        
+        :param priority: 处理器优先级
+        :return: 装饰器函数
+        """
+        def condition(event: Dict[str, Any]) -> bool:
+            return event.get("detail_type") == "group_member_increase"
+        
+        def decorator(func: Callable):
+            self.handler.register(func, priority, condition)
+            return func
+        return decorator
+    
+    def on_group_decrease(self, priority: int = 0):
+        """
+        群成员减少通知事件装饰器
+        
+        :param priority: 处理器优先级
+        :return: 装饰器函数
+        """
+        def condition(event: Dict[str, Any]) -> bool:
+            return event.get("detail_type") == "group_member_decrease"
+        
+        def decorator(func: Callable):
+            self.handler.register(func, priority, condition)
+            return func
+        return decorator
+
+notice = NoticeHandler()

ErisPulse/Core/Event/request.py

@@ -0,0 +1,66 @@
+"""
+ErisPulse 请求处理模块
+
+提供基于装饰器的请求事件处理功能
+"""
+
+from .base import BaseEventHandler
+from .manager import event_manager
+from typing import Callable, Dict, Any
+
+class RequestHandler:
+    """
+    请求处理器
+    
+    提供不同类型请求事件的处理功能（如好友申请、群邀请等）
+    """
+    
+    def __init__(self):
+        """
+        初始化请求处理器
+        """
+        self.handler = event_manager.create_event_handler("request", "request")
+    
+    def on_request(self, priority: int = 0):
+        """
+        通用请求事件装饰器
+        
+        :param priority: 处理器优先级
+        :return: 装饰器函数
+        """
+        def decorator(func: Callable):
+            self.handler.register(func, priority)
+            return func
+        return decorator
+    
+    def on_friend_request(self, priority: int = 0):
+        """
+        好友请求事件装饰器
+        
+        :param priority: 处理器优先级
+        :return: 装饰器函数
+        """
+        def condition(event: Dict[str, Any]) -> bool:
+            return event.get("detail_type") == "friend"
+        
+        def decorator(func: Callable):
+            self.handler.register(func, priority, condition)
+            return func
+        return decorator
+    
+    def on_group_request(self, priority: int = 0):
+        """
+        群邀请请求事件装饰器
+        
+        :param priority: 处理器优先级
+        :return: 装饰器函数
+        """
+        def condition(event: Dict[str, Any]) -> bool:
+            return event.get("detail_type") == "group"
+        
+        def decorator(func: Callable):
+            self.handler.register(func, priority, condition)
+            return func
+        return decorator
+
+request = RequestHandler()

ErisPulse/Core/__init__.py

@@ -2,22 +2,27 @@ from .adapter import AdapterFather, SendDSL, adapter
 from .storage import storage
 from .env import env
 from .logger import logger
-from .mods import mods
+from .module_registry import module_registry
+from .module import module
 from .router import router, adapter_server
 from .config import config
 from . import exceptions
 
+from . import Event
+
 BaseAdapter = AdapterFather
 
 __all__ = [
+    'Event',
     'BaseAdapter',
     'AdapterFather',
     'SendDSL',
     'adapter',
+    'module',
     'storage',
     'env',
     'logger',
-    'mods',
+    'module_registry',
     'exceptions',
     'router',
     'adapter_server',

ErisPulse/Core/logger.py

@@ -90,8 +90,8 @@ class Logger:
         :param level: 日志级别(DEBUG/INFO/WARNING/ERROR/CRITICAL)
         :return: bool 设置是否成功
         """
-        from .mods import mods
-        if not mods.get_module_status(module_name):
+        from .module_registry import module_registry
+        if not module_registry.get_module_status(module_name):
             self._logger.warning(f"模块 {module_name} 未启用，无法设置日志等级。")
             return False
         level = level.upper()

ErisPulse/Core/module.py

@@ -0,0 +1,150 @@
+"""
+ErisPulse 模块管理模块
+
+提供便捷的模块访问接口
+"""
+
+from typing import Any, Optional, Dict
+from .module_registry import module_registry
+from .logger import logger
+
+class ModuleManager:
+    """
+    模块管理器
+    
+    提供便捷的模块访问接口，支持获取模块实例、检查模块状态等操作
+    """
+    
+    def __init__(self):
+        self._modules = {}
+    
+    def get(self, module_name: str) -> Any:
+        """
+        获取指定模块的实例
+        
+        :param module_name: [str] 模块名称
+        :return: [Any] 模块实例或None
+        """
+        # 是否已缓存
+        if module_name in self._modules:
+            return self._modules[module_name]
+            
+        # 从模块注册表获取模块信息
+        module_info = module_registry.get_module(module_name)
+        if not module_info:
+            logger.warning(f"模块 {module_name} 未注册")
+            return None
+            
+        # 模块是否启用
+        if not module_registry.get_module_status(module_name):
+            logger.warning(f"模块 {module_name} 已禁用")
+            return None
+            
+        try:
+            from .. import sdk
+            if hasattr(sdk, module_name):
+                module_instance = getattr(sdk, module_name)
+                self._modules[module_name] = module_instance
+                return module_instance
+            else:
+                logger.warning(f"模块 {module_name} 实例未找到")
+                return None
+        except Exception as e:
+            logger.error(f"获取模块 {module_name} 实例时出错: {e}")
+            return None
+    
+    def exists(self, module_name: str) -> bool:
+        """
+        检查模块是否存在
+        
+        :param module_name: [str] 模块名称
+        :return: [bool] 模块是否存在
+        """
+        return module_registry.get_module(module_name) is not None
+    
+    def is_enabled(self, module_name: str) -> bool:
+        """
+        检查模块是否启用
+        
+        :param module_name: [str] 模块名称
+        :return: [bool] 模块是否启用
+        """
+        return module_registry.get_module_status(module_name)
+    
+    def enable(self, module_name: str) -> bool:
+        """
+        启用模块
+        
+        :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)
+        logger.info(f"模块 {module_name} 已启用")
+        return True
+    
+    def disable(self, module_name: str) -> bool:
+        """
+        禁用模块
+        
+        :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)
+        logger.info(f"模块 {module_name} 已禁用")
+        # 如果模块在缓存中，移除它
+        if module_name in self._modules:
+            del self._modules[module_name]
+        return True
+    
+    def list_modules(self) -> Dict[str, Dict[str, Any]]:
+        """
+        列出所有模块信息
+        
+        :return: [Dict[str, Dict[str, Any]]] 模块信息字典
+        """
+        return module_registry.get_all_modules()
+    
+    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:
+        """
+        通过属性访问获取模块实例
+        
+        :param module_name: [str] 模块名称
+        :return: [Any] 模块实例
+        :raises AttributeError: 当模块不存在或未启用时
+        """
+        module_instance = self.get(module_name)
+        if module_instance is None:
+            raise AttributeError(f"模块 {module_name} 不存在或未启用")
+        return module_instance
+    
+    def __contains__(self, module_name: str) -> bool:
+        """
+        检查模块是否存在且处于启用状态
+        
+        :param module_name: [str] 模块名称
+        :return: [bool] 模块是否存在且启用
+        """
+        return self.exists(module_name) and self.is_enabled(module_name)
+
+module = ModuleManager()
+
+__all__ = [
+    "module"
+]

ErisPulse/Core/{mods.py → module_registry.py}

@@ -10,19 +10,18 @@ ErisPulse 模块管理器
 {!--< /tips >!--}
 """
 
-import json
 from typing import Dict, Optional, Any, List, Set, Tuple, Union, Type, FrozenSet
 
-class ModuleManager:
+class ModuleRegistry:
     """
-    模块管理器
+    ErisPulse 模块注册表
     
-    管理所有模块的注册、状态和依赖关系
+    管理所有模块的注册信息和启用状态
     
     {!--< tips >!--}
-    1. 通过set_module/get_module管理模块信息
-    2. 通过set_module_status/get_module_status控制模块状态
-    3. 通过set_all_modules/get_all_modules批量操作模块
+    1. 模块信息通过 set_module/get_module 管理
+    2. 模块状态通过 set_module_status/get_module_status 控制
+    3. 支持批量操作模块信息
     {!--< /tips >!--}
     """
     
@@ -66,14 +65,14 @@ class ModuleManager:
         """
         设置模块启用状态
         
-        :param module_name: 模块名称
-        :param status: 启用状态
+        :param module_name: [str] 模块名称
+        :param status: [bool] 启用状态 (True=启用, False=禁用)
         
         :example:
         >>> # 启用模块
-        >>> mods.set_module_status("MyModule", True)
+        >>> module_registry.set_module_status("MyModule", True)
         >>> # 禁用模块
-        >>> mods.set_module_status("MyModule", False)
+        >>> module_registry.set_module_status("MyModule", False)
         """
         from .logger import logger
         self.storage.set(f"{self.status_prefix}{module_name}", bool(status))
@@ -83,11 +82,11 @@ class ModuleManager:
         """
         获取模块启用状态
         
-        :param module_name: 模块名称
-        :return: 模块是否启用
+        :param module_name: [str] 模块名称
+        :return: [bool] 模块是否启用
         
         :example:
-        >>> if mods.get_module_status("MyModule"):
+        >>> if module_registry.get_module_status("MyModule"):
         >>>     print("模块已启用")
         """
         status = self.storage.get(f"{self.status_prefix}{module_name}", True)
@@ -97,15 +96,19 @@ class ModuleManager:
 
     def set_module(self, module_name: str, module_info: Dict[str, Any]) -> None:
         """
-        设置模块信息
+        注册或更新模块信息
         
-        :param module_name: 模块名称
-        :param module_info: 模块信息字典
+        :param module_name: [str] 模块名称
+        :param module_info: [Dict[str, Any]] 模块信息字典
+            必须包含 version 和 description 字段
         
         :example:
-        >>> mods.set_module("MyModule", {
+        >>> module_registry.set_module("MyModule", {
         >>>     "version": "1.0.0",
         >>>     "description": "我的模块",
+        >>>     "dependencies": [],
+        >>>     "author": "开发者",
+        >>>     "license": "MIT"
         >>> })
         """
         self.storage.set(f"{self.module_prefix}{module_name}", module_info)
@@ -114,11 +117,11 @@ class ModuleManager:
         """
         获取模块信息
         
-        :param module_name: 模块名称
-        :return: 模块信息字典或None
+        :param module_name: [str] 模块名称
+        :return: [Optional[Dict[str, Any]]] 模块信息字典或None
         
         :example:
-        >>> module_info = mods.get_module("MyModule")
+        >>> module_info = module_registry.get_module("MyModule")
         >>> if module_info:
         >>>     print(f"模块版本: {module_info.get('version')}")
         """
@@ -126,12 +129,13 @@ class ModuleManager:
 
     def set_all_modules(self, modules_info: Dict[str, Dict[str, Any]]) -> None:
         """
-        批量设置多个模块信息
+        批量设置模块信息
         
-        :param modules_info: 模块信息字典
+        :param modules_info: [Dict[str, Dict[str, Any]]] 模块信息字典
+            格式: {模块名: 模块信息}
         
         :example:
-        >>> mods.set_all_modules({
+        >>> module_registry.set_all_modules({
         >>>     "Module1": {"version": "1.0", "status": True},
         >>>     "Module2": {"version": "2.0", "status": False}
         >>> })
@@ -141,12 +145,12 @@ class ModuleManager:
 
     def get_all_modules(self) -> Dict[str, Dict[str, Any]]:
         """
-        获取所有模块信息
+        获取所有已注册模块信息
         
-        :return: 模块信息字典
+        :return: [Dict[str, Dict[str, Any]]] 所有模块信息字典
         
         :example:
-        >>> all_modules = mods.get_all_modules()
+        >>> all_modules = module_registry.get_all_modules()
         >>> for name, info in all_modules.items():
         >>>     print(f"{name}: {info.get('status')}")
         """
@@ -173,13 +177,13 @@ class ModuleManager:
 
     def remove_module(self, module_name: str) -> bool:
         """
-        移除模块
+        移除模块注册信息
         
-        :param module_name: 模块名称
-        :return: 是否成功移除
+        :param module_name: [str] 模块名称
+        :return: [bool] 是否成功移除
         
         :example:
-        >>> if mods.remove_module("OldModule"):
+        >>> if module_registry.remove_module("OldModule"):
         >>>     print("模块已移除")
         """
         module_key = f"{self.module_prefix}{module_name}"
@@ -193,14 +197,14 @@ class ModuleManager:
 
     def update_prefixes(self, module_prefix: Optional[str] = None, status_prefix: Optional[str] = None) -> None:
         """
-        更新模块前缀配置
+        更新模块存储前缀配置
         
-        :param module_prefix: 新的模块数据前缀(可选)
-        :param status_prefix: 新的模块状态前缀(可选)
+        :param module_prefix: [Optional[str]] 模块数据前缀 (默认: "erispulse.data.modules.info:")
+        :param status_prefix: [Optional[str]] 模块状态前缀 (默认: "erispulse.data.modules.status:")
         
         :example:
         >>> # 更新模块前缀
-        >>> mods.update_prefixes(
+        >>> module_registry.update_prefixes(
         >>>     module_prefix="custom.module.data:",
         >>>     status_prefix="custom.module.status:"
         >>> )
@@ -216,8 +220,8 @@ class ModuleManager:
             self.storage.set("erispulse.system.status_prefix", status_prefix)
 
 
-mods = ModuleManager()
+module_registry = ModuleRegistry()
 
 __all__ = [
-    "mods",
+    "module_registry",
 ]

ErisPulse/__init__.py

@@ -10,9 +10,6 @@ ErisPulse SDK 主模块
 {!--< /tips >!--}
 """
 
-__version__ = "2.1.15-dev.3"
-__author__  = "ErisPulse"
-
 import os
 import sys
 import importlib
@@ -26,22 +23,32 @@ from pathlib import Path
 from .Core import logger
 from .Core import storage
 from .Core import env
-from .Core import mods
+from .Core import module_registry
 from .Core import adapter, AdapterFather, SendDSL
+from .Core import module
 from .Core import router, adapter_server
 from .Core import exceptions
 from .Core import config
+from .Core import Event
+
+try:
+    __version__ = importlib.metadata.version('ErisPulse')
+except importlib.metadata.PackageNotFoundError:
+    logger.critical("未找到ErisPulse版本信息，请检查是否正确安装ErisPulse")
+__author__  = "ErisPulse"
 
 sdk = sys.modules[__name__]
 
 BaseModules = {
+    "Event": Event,
     "logger": logger,
     "config": config,
     "exceptions": exceptions,
     "storage": storage,
     "env": env,
-    "mods": mods,
+    "module_registry": module_registry,
     "adapter": adapter,
+    "module": module,
     "router": router,
     "adapter_server": adapter_server,
     "SendDSL": SendDSL,
@@ -254,7 +261,7 @@ class AdapterLoader:
         :raises ImportError: 当适配器加载失败时抛出
         """
         meta_name = entry_point.name
-        adapter_status = mods.get_module_status(meta_name)
+        adapter_status = module_registry.get_module_status(meta_name)
         logger.debug(f"适配器 {meta_name} 状态: {adapter_status}")
         
         if adapter_status is False:
@@ -285,7 +292,7 @@ class AdapterLoader:
             adapter_obj.adapterInfo[meta_name] = adapter_info
             
             # 存储适配器信息
-            mods.set_module(meta_name, adapter_info)
+            module_registry.set_module(meta_name, adapter_info)
                 
             adapter_objs[meta_name] = adapter_obj
             enabled_adapters.append(meta_name)
@@ -369,7 +376,7 @@ class ModuleLoader:
         :raises ImportError: 当模块加载失败时抛出
         """
         meta_name = entry_point.name
-        module_status = mods.get_module_status(meta_name)
+        module_status = module_registry.get_module_status(meta_name)
         logger.debug(f"模块 {meta_name} 状态: {module_status}")
         
         # 首先检查模块状态，如果明确为False则直接跳过
@@ -401,7 +408,7 @@ class ModuleLoader:
             module_obj.moduleInfo = module_info
             
             # 存储模块信息
-            mods.set_module(meta_name, module_info)
+            module_registry.set_module(meta_name, module_info)
                 
             module_objs[meta_name] = module_obj
             enabled_modules.append(meta_name)