ErisPulse 2.2.0.dev1__py3-none-any.whl → 2.2.0.dev2__py3-none-any.whl

ErisPulse/Core/Event/__init__.py

@@ -2,29 +2,33 @@
 ErisPulse 事件处理模块
 
 提供统一的事件处理接口，支持命令、消息、通知、请求和元事件处理
+
+{!--< tips >!--}
+1. 所有事件处理都基于OneBot12标准事件格式
+2. 通过装饰器方式注册事件处理器
+3. 支持优先级和条件过滤
+{!--< /tips >!--}
 """
 
-from .cmd import command
+from .command import command
 from .message import message
 from .notice import notice
 from .request import request
 from .meta import meta
-from .manager import event_manager
 from . import exceptions
 from .. import config
 
 # 初始化默认配置
 def _setup_default_config():
     """
-    设置默认配置
-    
     {!--< internal-use >!--}
-    内部使用的方法，用于初始化默认配置
+    设置默认配置
     """
     default_config = {
         "command": {
             "prefix": "/",
-            "case_sensitive": True
+            "case_sensitive": True,
+            "allow_space_prefix": False
         },
         "message": {
             "ignore_self": True
@@ -43,6 +47,5 @@ __all__ = [
     "notice",
     "request",
     "meta",
-    "event_manager",
     "exceptions"
 ]

ErisPulse/Core/Event/base.py

@@ -1,18 +1,23 @@
 """
 ErisPulse 事件处理基础模块
 
-提供事件处理的核心功能，包括事件注册、处理和中间件支持
+提供事件处理的核心功能，包括事件注册和处理
+
+{!--< tips >!--}
+1. 所有事件处理都基于OneBot12标准事件格式
+2. 通过适配器系统进行事件分发和接收
+{!--< /tips >!--}
 """
 
 from .. import adapter, logger
-from typing import Callable, Any, Dict, List, Optional, Union
+from typing import Callable, Any, Dict, List, Optional
 import asyncio
 
 class BaseEventHandler:
     """
     基础事件处理器
     
-    提供事件处理的基本功能，包括处理器注册、中间件支持等
+    提供事件处理的基本功能，包括处理器注册等
     """
     
     def __init__(self, event_type: str, module_name: str = None):
@@ -25,17 +30,6 @@ class BaseEventHandler:
         self.event_type = event_type
         self.module_name = module_name
         self.handlers: List[Dict] = []
-        self.middlewares: List[Callable] = []
-    
-    def middleware(self, func: Callable) -> Callable:
-        """
-        添加中间件
-        
-        :param func: 中间件函数
-        :return: 中间件函数
-        """
-        self.middlewares.append(func)
-        return func
     
     def register(self, handler: Callable, priority: int = 0, condition: Callable = None):
         """
@@ -81,30 +75,19 @@ class BaseEventHandler:
         
         :param event: 事件数据
         """
-        # 执行中间件
-        processed_event = event
-        for middleware in self.middlewares:
-            try:
-                if asyncio.iscoroutinefunction(middleware):
-                    processed_event = await middleware(processed_event)
-                else:
-                    processed_event = middleware(processed_event)
-            except Exception as e:
-                logger.error(f"中间件执行错误: {e}")
-        
         # 执行处理器
         for handler_info in self.handlers:
             condition = handler_info.get("condition")
             # 检查条件
-            if condition and not condition(processed_event):
+            if condition and not condition(event):
                 continue
                 
             handler = handler_info["func"]
             try:
                 if asyncio.iscoroutinefunction(handler):
-                    await handler(processed_event)
+                    await handler(event)
                 else:
-                    handler(processed_event)
+                    handler(event)
             except Exception as e:
                 logger.error(f"事件处理器执行错误: {e}")
     

ErisPulse/Core/Event/{cmd.py → command.py}

@@ -1,32 +1,34 @@
+# ErisPulse/Core/Event/cmd.py
 """
 ErisPulse 命令处理模块
 
 提供基于装饰器的命令注册和处理功能
+
+{!--< tips >!--}
+1. 支持命令别名和命令组
+2. 支持命令权限控制
+3. 支持命令帮助系统
+{!--< /tips >!--}
 """
 
 from .base import BaseEventHandler
-from .manager import event_manager
-from .. import config, logger
+from .. import adapter, config, logger
 from typing import Callable, Union, List, Dict, Any, Optional
 import asyncio
+import re
 
 class CommandHandler:
-    """
-    命令处理器
-    
-    提供命令注册、解析和执行功能
-    """
-    
     def __init__(self):
-        """
-        初始化命令处理器
-        """
         self.commands: Dict[str, Dict] = {}
         self.aliases: Dict[str, str] = {}  # 别名映射
         self.groups: Dict[str, List[str]] = {}  # 命令组
+        self.permissions: Dict[str, Callable] = {}  # 权限检查函数
         self.prefix = config.getConfig("ErisPulse.event.command.prefix", "/")
-        self.handler = event_manager.create_event_handler("message", "command")
+        self.case_sensitive = config.getConfig("ErisPulse.event.command.case_sensitive", True)
+        self.allow_space_prefix = config.getConfig("ErisPulse.event.command.allow_space_prefix", False)
         
+        # 创建消息事件处理器
+        self.handler = BaseEventHandler("message", "command")
         # 注册消息处理器
         self.handler.register(self._handle_message)
     
@@ -35,8 +37,10 @@ class CommandHandler:
                  aliases: List[str] = None,
                  group: str = None,
                  priority: int = 0,
+                 permission: Callable = None,
                  help: str = None,
-                 usage: str = None):
+                 usage: str = None,
+                 hidden: bool = False):
         """
         命令装饰器
         
@@ -44,8 +48,10 @@ class CommandHandler:
         :param aliases: 命令别名列表
         :param group: 命令组名称
         :param priority: 处理器优先级
+        :param permission: 权限检查函数，返回True时允许执行命令
         :param help: 命令帮助信息
         :param usage: 命令使用方法
+        :param hidden: 是否在帮助中隐藏命令
         :return: 装饰器函数
         """
         def decorator(func: Callable):
@@ -72,12 +78,18 @@ class CommandHandler:
                     "help": help,
                     "usage": usage,
                     "group": group,
+                    "permission": permission,
+                    "hidden": hidden,
                     "main_name": main_name
                 }
                 
                 # 注册别名映射
                 if cmd_name != main_name:
                     self.aliases[cmd_name] = main_name
+                
+                # 注册权限检查函数
+                if permission and cmd_name not in self.permissions:
+                    self.permissions[cmd_name] = permission
             
             # 添加到命令组
             if group:
@@ -113,12 +125,20 @@ class CommandHandler:
         if not text_content:
             return
         
+        # 处理大小写敏感性
+        check_text = text_content if self.case_sensitive else text_content.lower()
+        prefix = self.prefix if self.case_sensitive else self.prefix.lower()
+        
         # 检查前缀
-        if not text_content.startswith(self.prefix):
-            return
+        if not check_text.startswith(prefix):
+            # 检查是否允许空格前缀 (例如: "/ command")
+            if self.allow_space_prefix and check_text.startswith(prefix + " "):
+                pass
+            else:
+                return
         
         # 解析命令和参数
-        command_text = text_content[len(self.prefix):].strip()
+        command_text = check_text[len(prefix):].strip()
         parts = command_text.split()
         if not parts:
             return
@@ -126,6 +146,10 @@ class CommandHandler:
         cmd_name = parts[0]
         args = parts[1:] if len(parts) > 1 else []
         
+        # 处理大小写敏感性
+        if not self.case_sensitive:
+            cmd_name = cmd_name.lower()
+        
         # 处理别名
         actual_cmd_name = self.aliases.get(cmd_name, cmd_name)
         
@@ -134,6 +158,20 @@ class CommandHandler:
             cmd_info = self.commands[actual_cmd_name]
             handler = cmd_info["func"]
             
+            # 检查权限
+            permission_func = cmd_info.get("permission") or self.permissions.get(actual_cmd_name)
+            if permission_func:
+                try:
+                    has_permission = permission_func(event) if not asyncio.iscoroutinefunction(permission_func) \
+                                    else await permission_func(event)
+                    if not has_permission:
+                        await self._send_permission_denied(event)
+                        return
+                except Exception as e:
+                    logger.error(f"权限检查错误: {e}")
+                    await self._send_permission_denied(event)
+                    return
+            
             # 添加命令相关信息到事件
             command_info = {
                 "name": actual_cmd_name,
@@ -154,7 +192,52 @@ class CommandHandler:
                     handler(event)
             except Exception as e:
                 logger.error(f"命令执行错误: {e}")
-                # 可以发送错误信息给用户
+                await self._send_command_error(event, str(e))
+    
+    async def _send_permission_denied(self, event: Dict[str, Any]):
+        """
+        发送权限拒绝消息
+        
+        {!--< internal-use >!--}
+        内部使用的方法
+        
+        :param event: 事件数据
+        """
+        try:
+            platform = event.get("platform")
+            user_id = event.get("user_id")
+            group_id = event.get("group_id")
+            detail_type = "group" if group_id else "private"
+            target_id = group_id or user_id
+            
+            if platform and hasattr(adapter, platform):
+                adapter_instance = getattr(adapter, platform)
+                await adapter_instance.Send.To(detail_type, target_id).Text("权限不足，无法执行该命令")
+        except Exception as e:
+            logger.error(f"发送权限拒绝消息失败: {e}")
+    
+    async def _send_command_error(self, event: Dict[str, Any], error: str):
+        """
+        发送命令错误消息
+        
+        {!--< internal-use >!--}
+        内部使用的方法
+        
+        :param event: 事件数据
+        :param error: 错误信息
+        """
+        try:
+            platform = event.get("platform")
+            user_id = event.get("user_id")
+            group_id = event.get("group_id")
+            detail_type = "group" if group_id else "private"
+            target_id = group_id or user_id
+            
+            if platform and hasattr(adapter, platform):
+                adapter_instance = getattr(adapter, platform)
+                await adapter_instance.Send.To(detail_type, target_id).Text(f"命令执行出错: {error}")
+        except Exception as e:
+            logger.error(f"发送命令错误消息失败: {e}")
     
     def get_command(self, name: str) -> Optional[Dict]:
         """
@@ -183,11 +266,21 @@ class CommandHandler:
         """
         return self.groups.get(group, [])
     
-    def help(self, command_name: str = None) -> str:
+    def get_visible_commands(self) -> Dict[str, Dict]:
+        """
+        获取所有可见命令（非隐藏命令）
+        
+        :return: 可见命令信息字典
+        """
+        return {name: info for name, info in self.commands.items() 
+                if not info.get("hidden", False) and name == info["main_name"]}
+    
+    def help(self, command_name: str = None, show_hidden: bool = False) -> str:
         """
         生成帮助信息
         
         :param command_name: 命令名称，如果为None则生成所有命令的帮助
+        :param show_hidden: 是否显示隐藏命令
         :return: 帮助信息字符串
         """
         if command_name:
@@ -200,11 +293,18 @@ class CommandHandler:
                 return f"未找到命令: {command_name}"
         else:
             # 生成所有命令的帮助
+            commands_to_show = self.get_visible_commands() if not show_hidden else {
+                name: info for name, info in self.commands.items() 
+                if name == info["main_name"]
+            }
+            
+            if not commands_to_show:
+                return "暂无可用命令"
+            
             help_lines = ["可用命令:"]
-            for cmd_name, cmd_info in self.commands.items():
-                if cmd_name == cmd_info["main_name"]:  # 只显示主命令
-                    help_text = cmd_info.get("help", "无说明")
-                    help_lines.append(f"  {self.prefix}{cmd_name} - {help_text}")
+            for cmd_name, cmd_info in commands_to_show.items():
+                help_text = cmd_info.get("help", "无说明")
+                help_lines.append(f"  {self.prefix}{cmd_name} - {help_text}")
             return "\n".join(help_lines)
 
 command = CommandHandler()

ErisPulse/Core/Event/message.py

@@ -2,25 +2,20 @@
 ErisPulse 消息处理模块
 
 提供基于装饰器的消息事件处理功能
+
+{!--< tips >!--}
+1. 支持私聊、群聊消息分类处理
+2. 支持@消息特殊处理
+3. 支持自定义条件过滤
+{!--< /tips >!--}
 """
 
 from .base import BaseEventHandler
-from .manager import event_manager
 from typing import Callable, Dict, Any
-import asyncio
 
 class MessageHandler:
-    """
-    消息处理器
-    
-    提供不同类型消息事件的处理功能
-    """
-    
     def __init__(self):
-        """
-        初始化消息处理器
-        """
-        self.handler = event_manager.create_event_handler("message", "message")
+        self.handler = BaseEventHandler("message", "message")
     
     def on_message(self, priority: int = 0):
         """

ErisPulse/Core/Event/meta.py

@@ -1,25 +1,21 @@
+# ErisPulse/Core/Event/meta.py
 """
 ErisPulse 元事件处理模块
 
 提供基于装饰器的元事件处理功能
+
+{!--< tips >!--}
+1. 支持连接、断开连接等生命周期事件
+2. 适用于系统状态监控和初始化操作
+{!--< /tips >!--}
 """
 
 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")
+        self.handler = BaseEventHandler("meta", "meta")
     
     def on_meta(self, priority: int = 0):
         """

ErisPulse/Core/Event/notice.py

@@ -2,24 +2,19 @@
 ErisPulse 通知处理模块
 
 提供基于装饰器的通知事件处理功能
+
+{!--< tips >!--}
+1. 支持好友、群组等不同类型通知
+2. 支持成员变动等细粒度事件
+{!--< /tips >!--}
 """
 
 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")
+        self.handler = BaseEventHandler("notice", "notice")
     
     def on_notice(self, priority: int = 0):
         """

ErisPulse/Core/Event/request.py

@@ -2,24 +2,19 @@
 ErisPulse 请求处理模块
 
 提供基于装饰器的请求事件处理功能
+
+{!--< tips >!--}
+1. 支持好友请求、群邀请等不同类型请求
+2. 可以通过返回特定值来同意或拒绝请求
+{!--< /tips >!--}
 """
 
 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")
+        self.handler = BaseEventHandler("request", "request")
     
     def on_request(self, priority: int = 0):
         """

{erispulse-2.2.0.dev1.dist-info → erispulse-2.2.0.dev2.dist-info}/METADATA

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

{erispulse-2.2.0.dev1.dist-info → erispulse-2.2.0.dev2.dist-info}/RECORD

@@ -11,17 +11,16 @@ ErisPulse/Core/module.py,sha256=wCIFC3qHukeu7DSj8TuNMw8s_gzTwk7_coM4oflmieA,4680
 ErisPulse/Core/module_registry.py,sha256=BeOQwh3Pwv2fceBLJEObF6Ek65td0VOFzv3L0aEudXY,7740
 ErisPulse/Core/router.py,sha256=s2EBh2qpt3UXYhB06Ppc1XTFuZ3u0ZfXENJxwkgPoq8,8542
 ErisPulse/Core/storage.py,sha256=oRum4eVaTc3yxcaafggoIvrk41LPbvApSCxkGM3YmzU,17904
-ErisPulse/Core/Event/__init__.py,sha256=xndqrBPwIrvS8rspy8c_4We6sfrjNCFBJNmcBuMv0NU,1019
-ErisPulse/Core/Event/base.py,sha256=cr7FEaSnxxpAKNMR9a4RkX6xX5BiqndsMwBZV_me4W8,3741
-ErisPulse/Core/Event/cmd.py,sha256=iiKcvHFYYj_1ZnhmFJ0Ow4X96MjwSYIrGW_IWw0Z74w,6909
+ErisPulse/Core/Event/__init__.py,sha256=ixL1jaF0qXt0LbHckRWPH7Xu159qeeXQcsp4ZOs8J6Y,1120
+ErisPulse/Core/Event/base.py,sha256=cimfKDvFviZsaFU_DGDaN0G_zlz8r7PdFZiUM7_WuAo,3080
+ErisPulse/Core/Event/command.py,sha256=k6aiAYkkCLg3MTxqDeNF9AIiEtPud9CkMbfJzICeZSM,11266
 ErisPulse/Core/Event/exceptions.py,sha256=iGcuPaC7F4cZeujcvBdZb9bzQGnHBdb9CcPKoB760Bo,711
-ErisPulse/Core/Event/manager.py,sha256=S__BVAyGbY41W4ocPiTQ00BDaPxH-kj0lWoLl2Q3MRw,4225
-ErisPulse/Core/Event/message.py,sha256=TBDmeribhCRQrV6M0Df_815PgBwneap1-e0xc9IvT9k,2581
-ErisPulse/Core/Event/meta.py,sha256=ThUrYhTDPjzy3XwlMEGTFTzQBOV7-irtIvbPEe76Mk4,2243
-ErisPulse/Core/Event/notice.py,sha256=lnPJCTfAe5xviO-IkpCkcP8UhaAEJ3FvtBbNmoS9Ji4,2789
-ErisPulse/Core/Event/request.py,sha256=Ri46OFYu7jkFeRqS4kHD_6j7KCpOdmDNjrxAki5YsWQ,1817
-erispulse-2.2.0.dev1.dist-info/METADATA,sha256=9W2b-GP4uSM5IO4xV_owvZJcPUJmvT2EgsXrggvMjUY,7290
-erispulse-2.2.0.dev1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-erispulse-2.2.0.dev1.dist-info/entry_points.txt,sha256=Jss71M6nEha0TA-DyVZugPYdcL14s9QpiOeIlgWxzOc,182
-erispulse-2.2.0.dev1.dist-info/licenses/LICENSE,sha256=b2XwzcfWuv_36Op3xGdjcuPHgfCz62yT3bXYjfStpxY,1852
-erispulse-2.2.0.dev1.dist-info/RECORD,,
+ErisPulse/Core/Event/message.py,sha256=dXB2-HYJ20jVzuWqUOzH1V4an-F9csF32n_qCG69Gss,2499
+ErisPulse/Core/Event/meta.py,sha256=KjEXilYe6Vj-t30gBlBRrFHxn8vkhKY1c6W99BOxUr4,2172
+ErisPulse/Core/Event/notice.py,sha256=3z7DDbgEAbY0RgcYw9MdaFwxEDzksqc4QriYSEPfHTY,2705
+ErisPulse/Core/Event/request.py,sha256=ojQpNMlYBGPNF9sh3IUwV-dwXZ8sjJRVcogFQLw_aJ8,1721
+erispulse-2.2.0.dev2.dist-info/METADATA,sha256=s6WbM3VyyFF8nYG2oRqFfC_trASCxMM1RveO7IzMO20,7290
+erispulse-2.2.0.dev2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+erispulse-2.2.0.dev2.dist-info/entry_points.txt,sha256=Jss71M6nEha0TA-DyVZugPYdcL14s9QpiOeIlgWxzOc,182
+erispulse-2.2.0.dev2.dist-info/licenses/LICENSE,sha256=b2XwzcfWuv_36Op3xGdjcuPHgfCz62yT3bXYjfStpxY,1852
+erispulse-2.2.0.dev2.dist-info/RECORD,,

ErisPulse/Core/Event/manager.py

@@ -1,127 +0,0 @@
-"""
-ErisPulse 事件管理器
-
-提供全局事件管理功能，包括事件处理器创建、模块事件管理等
-"""
-
-from .. import logger
-from .base import BaseEventHandler
-from .exceptions import EventNotFoundException
-from typing import Dict, List, Optional, Callable, Any
-import asyncio
-
-class EventManager:
-    """
-    事件管理器
-    
-    管理所有事件处理器，提供全局事件处理功能
-    """
-    
-    def __init__(self):
-        """
-        初始化事件管理器
-        """
-        self.event_handlers: Dict[str, BaseEventHandler] = {}
-        self.module_events: Dict[str, List[str]] = {}
-        self.global_middlewares: List[Callable] = []
-    
-    def create_event_handler(self, event_type: str, module_name: str = None) -> BaseEventHandler:
-        """
-        创建事件处理器
-        
-        :param event_type: 事件类型
-        :param module_name: 模块名称
-        :return: 事件处理器实例
-        """
-        if event_type not in self.event_handlers:
-            handler = BaseEventHandler(event_type, module_name)
-            self.event_handlers[event_type] = handler
-        return self.event_handlers[event_type]
-    
-    def get_event_handler(self, event_type: str) -> Optional[BaseEventHandler]:
-        """
-        获取事件处理器
-        
-        :param event_type: 事件类型
-        :return: 事件处理器实例，如果不存在则返回None
-        """
-        return self.event_handlers.get(event_type)
-    
-    def register_module_event(self, module_name: str, event_type: str):
-        """
-        注册模块事件
-        
-        :param module_name: 模块名称
-        :param event_type: 事件类型
-        """
-        if module_name not in self.module_events:
-            self.module_events[module_name] = []
-        if event_type not in self.module_events[module_name]:
-            self.module_events[module_name].append(event_type)
-    
-    def middleware(self, func: Callable):
-        """
-        添加全局中间件
-        
-        :param func: 中间件函数
-        :return: 中间件函数
-        """
-        self.global_middlewares.append(func)
-        return func
-    
-    async def emit(self, event_type: str, event_data: Dict[str, Any]):
-        """
-        触发事件
-        
-        :param event_type: 事件类型
-        :param event_data: 事件数据
-        """
-        # 执行全局中间件
-        processed_data = event_data
-        for middleware in self.global_middlewares:
-            try:
-                if asyncio.iscoroutinefunction(middleware):
-                    processed_data = await middleware(processed_data)
-                else:
-                    processed_data = middleware(processed_data)
-            except Exception as e:
-                logger.error(f"全局中间件执行错误: {e}")
-        
-        # 触发事件处理器
-        if event_type in self.event_handlers:
-            handler = self.event_handlers[event_type]
-            await handler._process_event(processed_data)
-        
-        # 触发通配符处理器
-        if "*" in self.event_handlers:
-            handler = self.event_handlers["*"]
-            await handler._process_event(processed_data)
-    
-    def get_module_events(self, module_name: str) -> List[str]:
-        """
-        获取模块注册的事件
-        
-        :param module_name: 模块名称
-        :return: 事件类型列表
-        """
-        return self.module_events.get(module_name, [])
-    
-    def cleanup_module_events(self, module_name: str):
-        """
-        清理模块事件
-        
-        :param module_name: 模块名称
-        """
-        if module_name in self.module_events:
-            event_types = self.module_events[module_name]
-            for event_type in event_types:
-                if event_type in self.event_handlers:
-                    # 移除该模块注册的处理器
-                    handler = self.event_handlers[event_type]
-                    handler.handlers = [
-                        h for h in handler.handlers 
-                        if h.get("module") != module_name
-                    ]
-            del self.module_events[module_name]
-
-event_manager = EventManager()