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

ErisPulse/Core/Event/__init__.py

@@ -0,0 +1,49 @@
+from .. import adapter
+"""
+ErisPulse 事件处理模块
+
+提供统一的事件处理接口，支持命令、消息、通知、请求和元事件处理
+"""
+
+from .cmd 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
+        },
+        "message": {
+            "ignore_self": True
+        }
+    }
+    
+    current_config = config.getConfig("ErisPulse.event")
+    if current_config is None:
+        config.setConfig("ErisPulse.event", default_config)
+
+_setup_default_config()
+
+__all__ = [
+    "command",
+    "message", 
+    "notice",
+    "request",
+    "meta",
+    "event_manager",
+    "exceptions"
+]

ErisPulse/Core/Event/base.py

@@ -0,0 +1,118 @@
+"""
+ErisPulse 事件处理基础模块
+
+提供事件处理的核心功能，包括事件注册、处理和中间件支持
+"""
+
+from .. import adapter, logger
+from typing import Callable, Any, Dict, List, Optional, Union
+import asyncio
+import functools
+
+class BaseEventHandler:
+    """
+    基础事件处理器
+    
+    提供事件处理的基本功能，包括处理器注册、中间件支持等
+    """
+    
+    def __init__(self, event_type: str, module_name: str = None):
+        """
+        初始化事件处理器
+        
+        :param event_type: 事件类型
+        :param module_name: 模块名称
+        """
+        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):
+        """
+        注册事件处理器
+        
+        :param handler: 事件处理器函数
+        :param priority: 处理器优先级，数值越小优先级越高
+        :param condition: 处理器条件函数，返回True时才会执行处理器
+        """
+        handler_info = {
+            "func": handler,
+            "priority": priority,
+            "condition": condition,
+            "module": self.module_name
+        }
+        self.handlers.append(handler_info)
+        # 按优先级排序
+        self.handlers.sort(key=lambda x: x["priority"])
+        
+        # 注册到适配器
+        if self.event_type:
+            adapter.on(self.event_type)(self._process_event)
+    
+    def __call__(self, priority: int = 0, condition: Callable = None):
+        """
+        装饰器方式注册事件处理器
+        
+        :param priority: 处理器优先级
+        :param condition: 处理器条件函数
+        :return: 装饰器函数
+        """
+        def decorator(func: Callable):
+            self.register(func, priority, condition)
+            return func
+        return decorator
+    
+    async def _process_event(self, event: Dict[str, Any]):
+        """
+        处理事件
+        
+        {!--< internal-use >!--}
+        内部使用的方法，用于处理事件
+        
+        :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):
+                continue
+                
+            handler = handler_info["func"]
+            try:
+                if asyncio.iscoroutinefunction(handler):
+                    await handler(processed_event)
+                else:
+                    handler(processed_event)
+            except Exception as e:
+                logger.error(f"事件处理器执行错误: {e}")
+    
+    def unregister(self, handler: Callable):
+        """
+        注销事件处理器
+        
+        :param handler: 要注销的事件处理器
+        """
+        self.handlers = [h for h in self.handlers if h["func"] != handler]

ErisPulse/Core/Event/cmd.py

@@ -0,0 +1,212 @@
+"""
+ErisPulse 命令处理模块
+
+提供基于装饰器的命令注册和处理功能
+"""
+
+from .base import BaseEventHandler
+from .manager import event_manager
+from .. import adapter, config, logger
+from typing import Callable, Union, List, Dict, Any, Optional
+import re
+import asyncio
+
+class CommandHandler:
+    """
+    命令处理器
+    
+    提供命令注册、解析和执行功能
+    """
+    
+    def __init__(self):
+        """
+        初始化命令处理器
+        """
+        self.commands: Dict[str, Dict] = {}
+        self.aliases: Dict[str, str] = {}  # 别名映射
+        self.groups: Dict[str, List[str]] = {}  # 命令组
+        self.prefix = config.getConfig("ErisPulse.event.command.prefix", "/")
+        self.handler = event_manager.create_event_handler("message", "command")
+        
+        # 注册消息处理器
+        self.handler.register(self._handle_message)
+    
+    def __call__(self, 
+                 name: Union[str, List[str]] = None, 
+                 aliases: List[str] = None,
+                 group: str = None,
+                 priority: int = 0,
+                 help: str = None,
+                 usage: str = None):
+        """
+        命令装饰器
+        
+        :param name: 命令名称，可以是字符串或字符串列表
+        :param aliases: 命令别名列表
+        :param group: 命令组名称
+        :param priority: 处理器优先级
+        :param help: 命令帮助信息
+        :param usage: 命令使用方法
+        :return: 装饰器函数
+        """
+        def decorator(func: Callable):
+            cmd_names = []
+            if isinstance(name, str):
+                cmd_names = [name]
+            elif isinstance(name, list):
+                cmd_names = name
+            else:
+                # 使用函数名作为命令名
+                cmd_names = [func.__name__]
+            
+            main_name = cmd_names[0]
+            
+            # 添加别名
+            alias_list = aliases or []
+            if len(cmd_names) > 1:
+                alias_list.extend(cmd_names[1:])
+            
+            # 注册命令
+            for cmd_name in cmd_names:
+                self.commands[cmd_name] = {
+                    "func": func,
+                    "help": help,
+                    "usage": usage,
+                    "group": group,
+                    "main_name": main_name
+                }
+                
+                # 注册别名映射
+                if cmd_name != main_name:
+                    self.aliases[cmd_name] = main_name
+            
+            # 添加到命令组
+            if group:
+                if group not in self.groups:
+                    self.groups[group] = []
+                for cmd_name in cmd_names:
+                    if cmd_name not in self.groups[group]:
+                        self.groups[group].append(cmd_name)
+            
+            return func
+        return decorator
+    
+    async def _handle_message(self, event: Dict[str, Any]):
+        """
+        处理消息事件中的命令
+        
+        {!--< internal-use >!--}
+        内部使用的方法，用于从消息中解析并执行命令
+        
+        :param event: 消息事件数据
+        """
+        # 检查是否为文本消息
+        if event.get("type") != "message":
+            return
+        
+        message_segments = event.get("message", [])
+        text_content = ""
+        for segment in message_segments:
+            if segment.get("type") == "text":
+                text_content = segment.get("data", {}).get("text", "")
+                break
+        
+        if not text_content:
+            return
+        
+        # 检查前缀
+        if not text_content.startswith(self.prefix):
+            return
+        
+        # 解析命令和参数
+        command_text = text_content[len(self.prefix):].strip()
+        parts = command_text.split()
+        if not parts:
+            return
+        
+        cmd_name = parts[0]
+        args = parts[1:] if len(parts) > 1 else []
+        
+        # 处理别名
+        actual_cmd_name = self.aliases.get(cmd_name, cmd_name)
+        
+        # 查找命令处理器
+        if actual_cmd_name in self.commands:
+            cmd_info = self.commands[actual_cmd_name]
+            handler = cmd_info["func"]
+            
+            # 添加命令相关信息到事件
+            command_info = {
+                "name": actual_cmd_name,
+                "main_name": cmd_info["main_name"],
+                "args": args,
+                "raw": command_text,
+                "help": cmd_info["help"],
+                "usage": cmd_info["usage"],
+                "group": cmd_info["group"]
+            }
+            
+            event["command"] = command_info
+            
+            try:
+                if asyncio.iscoroutinefunction(handler):
+                    await handler(event)
+                else:
+                    handler(event)
+            except Exception as e:
+                logger.error(f"命令执行错误: {e}")
+                # 可以发送错误信息给用户
+    
+    def get_command(self, name: str) -> Optional[Dict]:
+        """
+        获取命令信息
+        
+        :param name: 命令名称
+        :return: 命令信息字典，如果不存在则返回None
+        """
+        actual_name = self.aliases.get(name, name)
+        return self.commands.get(actual_name)
+    
+    def get_commands(self) -> Dict[str, Dict]:
+        """
+        获取所有命令
+        
+        :return: 命令信息字典
+        """
+        return self.commands
+    
+    def get_group_commands(self, group: str) -> List[str]:
+        """
+        获取命令组中的命令
+        
+        :param group: 命令组名称
+        :return: 命令名称列表
+        """
+        return self.groups.get(group, [])
+    
+    def help(self, command_name: str = None) -> str:
+        """
+        生成帮助信息
+        
+        :param command_name: 命令名称，如果为None则生成所有命令的帮助
+        :return: 帮助信息字符串
+        """
+        if command_name:
+            cmd_info = self.get_command(command_name)
+            if cmd_info:
+                help_text = cmd_info.get("help", "无帮助信息")
+                usage = cmd_info.get("usage", f"{self.prefix}{command_name}")
+                return f"命令: {command_name}\n用法: {usage}\n说明: {help_text}"
+            else:
+                return f"未找到命令: {command_name}"
+        else:
+            # 生成所有命令的帮助
+            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}")
+            return "\n".join(help_lines)
+
+# 创建全局命令处理器实例
+command = CommandHandler()

ErisPulse/Core/Event/exceptions.py

@@ -0,0 +1,37 @@
+"""
+ErisPulse 事件系统异常处理模块
+
+提供事件系统中可能发生的各种异常类型定义
+"""
+
+class EventException(Exception):
+    """
+    事件系统基础异常
+    
+    所有事件系统相关异常的基类
+    """
+    pass
+
+class CommandException(EventException):
+    """
+    命令处理异常
+    
+    当命令处理过程中发生错误时抛出
+    """
+    pass
+
+class EventHandlerException(EventException):
+    """
+    事件处理器异常
+    
+    当事件处理器执行过程中发生错误时抛出
+    """
+    pass
+
+class EventNotFoundException(EventException):
+    """
+    事件未找到异常
+    
+    当尝试获取不存在的事件处理器时抛出
+    """
+    pass

ErisPulse/Core/Event/manager.py

@@ -0,0 +1,128 @@
+"""
+ErisPulse 事件管理器
+
+提供全局事件管理功能，包括事件处理器创建、模块事件管理等
+"""
+
+from .. import adapter, logger, mods
+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()

ErisPulse/Core/Event/message.py

@@ -0,0 +1,91 @@
+"""
+ErisPulse 消息处理模块
+
+提供基于装饰器的消息事件处理功能
+"""
+
+from .base import BaseEventHandler
+from .manager import event_manager
+from .. import adapter
+from typing import Callable, Dict, Any
+import asyncio
+
+class MessageHandler:
+    """
+    消息处理器
+    
+    提供不同类型消息事件的处理功能
+    """
+    
+    def __init__(self):
+        """
+        初始化消息处理器
+        """
+        self.handler = event_manager.create_event_handler("message", "message")
+    
+    def on_message(self, priority: int = 0):
+        """
+        消息事件装饰器
+        
+        :param priority: 处理器优先级
+        :return: 装饰器函数
+        """
+        def decorator(func: Callable):
+            self.handler.register(func, priority)
+            return func
+        return decorator
+    
+    def on_private_message(self, priority: int = 0):
+        """
+        私聊消息事件装饰器
+        
+        :param priority: 处理器优先级
+        :return: 装饰器函数
+        """
+        def condition(event: Dict[str, Any]) -> bool:
+            return event.get("detail_type") == "private"
+        
+        def decorator(func: Callable):
+            self.handler.register(func, priority, condition)
+            return func
+        return decorator
+    
+    def on_group_message(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
+    
+    def on_at_message(self, priority: int = 0):
+        """
+        @消息事件装饰器
+        
+        :param priority: 处理器优先级
+        :return: 装饰器函数
+        """
+        def condition(event: Dict[str, Any]) -> bool:
+            # 检查消息中是否有@机器人
+            message_segments = event.get("message", [])
+            self_id = event.get("self", {}).get("user_id")
+            
+            for segment in message_segments:
+                if segment.get("type") == "mention" and segment.get("data", {}).get("user_id") == self_id:
+                    return True
+            return False
+        
+        def decorator(func: Callable):
+            self.handler.register(func, priority, condition)
+            return func
+        return decorator
+
+# 创建全局消息处理器实例
+message = MessageHandler()

ErisPulse/Core/Event/meta.py

@@ -0,0 +1,82 @@
+"""
+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,97 @@
+"""
+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,67 @@
+"""
+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

@@ -7,9 +7,13 @@ from .router import router, adapter_server
 from .config import config
 from . import exceptions
 
+from . import Event
+
 BaseAdapter = AdapterFather
 
 __all__ = [
+    'Event',
+    
     'BaseAdapter',
     'AdapterFather',
     'SendDSL',

ErisPulse/__init__.py

@@ -10,7 +10,7 @@ ErisPulse SDK 主模块
 {!--< /tips >!--}
 """
 
-__version__ = "2.1.15-dev.3"
+__version__ = "2.1.15-dev.4"
 __author__  = "ErisPulse"
 
 import os
@@ -31,10 +31,12 @@ from .Core import adapter, AdapterFather, SendDSL
 from .Core import router, adapter_server
 from .Core import exceptions
 from .Core import config
+from .Core import Event
 
 sdk = sys.modules[__name__]
 
 BaseModules = {
+    "Event": Event,
     "logger": logger,
     "config": config,
     "exceptions": exceptions,

ErisPulse/__main__.py

@@ -339,28 +339,44 @@ class PackageManager:
                     [sys.executable, "-m", "pip"] + args,
                     stdout=subprocess.PIPE,
                     stderr=subprocess.PIPE,
-                    universal_newlines=True
+                    universal_newlines=True,
+                    bufsize=1  # 行缓冲
                 )
                 
                 stdout_lines = []
                 stderr_lines = []
                 
-                # 实时读取输出
-                while True:
-                    stdout_line = process.stdout.readline()
-                    stderr_line = process.stderr.readline()
-                    
-                    if stdout_line:
-                        stdout_lines.append(stdout_line)
-                        progress.update(task, advance=1)
-                        
-                    if stderr_line:
-                        stderr_lines.append(stderr_line)
-                        progress.update(task, advance=1)
-                        
-                    if stdout_line == '' and stderr_line == '' and process.poll() is not None:
-                        break
-                        
+                # 使用超时机制避免永久阻塞
+                import threading
+                import queue
+                
+                def read_output(pipe, lines_list):
+                    try:
+                        for line in iter(pipe.readline, ''):
+                            lines_list.append(line)
+                            progress.update(task, advance=5)  # 每行增加进度
+                        pipe.close()
+                    except Exception:
+                        pass
+                
+                stdout_thread = threading.Thread(target=read_output, args=(process.stdout, stdout_lines))
+                stderr_thread = threading.Thread(target=read_output, args=(process.stderr, stderr_lines))
+                
+                stdout_thread.start()
+                stderr_thread.start()
+                
+                # 等待进程结束，最多等待5分钟
+                try:
+                    process.wait(timeout=300)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    process.wait()
+                    console.print("[warning]命令执行超时，已强制终止[/]")
+                    return False, "", "命令执行超时"
+                
+                stdout_thread.join(timeout=10)
+                stderr_thread.join(timeout=10)
+                
                 stdout = ''.join(stdout_lines)
                 stderr = ''.join(stderr_lines)
                 
@@ -368,7 +384,9 @@ class PackageManager:
             except subprocess.CalledProcessError as e:
                 console.print(f"[error]命令执行失败: {e}[/]")
                 return False, "", str(e)
-    
+            except Exception as e:
+                console.print(f"[error]执行过程中发生异常: {e}[/]")
+                return False, "", str(e)
 
     def _compare_versions(self, version1: str, version2: str) -> int:
         """
@@ -813,34 +831,83 @@ class PackageManager:
         if target_version:
             package_spec += f"=={target_version}"
         
-        # 执行更新命令
-        success, stdout, stderr = self._run_pip_command_with_output(
-            ["install", "--upgrade", package_spec],
-            f"更新 ErisPulse SDK {f'到 {target_version}' if target_version else '到最新版本'}"
-        )
-        
-        if success:
-            new_version = target_version or "最新版本"
-            console.print(Panel(
-                f"[success]ErisPulse SDK 更新成功[/]\n"
-                f"  当前版本: [bold]{current_version}[/]\n"
-                f"  更新版本: [bold]{new_version}[/]\n\n"
-                f"[dim]{stdout}[/]",
-                title="更新完成",
-                border_style="success"
-            ))
+        # 检查是否在Windows上且尝试更新自身
+        if sys.platform == "win32":
+            # 构建更新脚本
+            update_script = f"""
+import time
+import subprocess
+import sys
+import os
+
+# 等待原进程结束
+time.sleep(2)
+
+# 执行更新命令
+try:
+    result = subprocess.run([
+        sys.executable, "-m", "pip", "install", "--upgrade", "{package_spec}"
+    ], capture_output=True, text=True, timeout=300)
+    
+    if result.returncode == 0:
+        print("更新成功!")
+        print(result.stdout)
+    else:
+        print("更新失败:")
+        print(result.stderr)
+except Exception as e:
+    print(f"更新过程中出错: {{e}}")
+
+# 清理临时脚本
+try:
+    os.remove(__file__)
+except:
+    pass
+"""
+            # 创建临时更新脚本
+            import tempfile
+            script_path = os.path.join(tempfile.gettempdir(), "epsdk_update.py")
+            with open(script_path, "w", encoding="utf-8") as f:
+                f.write(update_script)
+            
+            # 启动更新进程并退出当前进程
+            console.print("[info]正在启动更新进程...[/]")
+            console.print("[info]请稍后重新运行CLI以使用新版本[/]")
             
-            if not target_version:
-                console.print("[info]请重新启动CLI以使用新版本[/]")
+            subprocess.Popen([
+                sys.executable, script_path
+            ], creationflags=subprocess.CREATE_NEW_CONSOLE)
+            
+            return True
         else:
-            console.print(Panel(
-                f"[error]ErisPulse SDK 更新失败[/]\n\n"
-                f"[dim]{stderr}[/]",
-                title="更新失败",
-                border_style="error"
-            ))
+            # 非Windows平台
+            success, stdout, stderr = self._run_pip_command_with_output(
+                ["install", "--upgrade", package_spec],
+                f"更新 ErisPulse SDK {f'到 {target_version}' if target_version else '到最新版本'}"
+            )
             
-        return success
+            if success:
+                new_version = target_version or "最新版本"
+                console.print(Panel(
+                    f"[success]ErisPulse SDK 更新成功[/]\n"
+                    f"  当前版本: [bold]{current_version}[/]\n"
+                    f"  更新版本: [bold]{new_version}[/]\n\n"
+                    f"[dim]{stdout}[/]",
+                    title="更新完成",
+                    border_style="success"
+                ))
+                
+                if not target_version:
+                    console.print("[info]请重新启动CLI以使用新版本[/]")
+            else:
+                console.print(Panel(
+                    f"[error]ErisPulse SDK 更新失败[/]\n\n"
+                    f"[dim]{stderr}[/]",
+                    title="更新失败",
+                    border_style="error"
+                ))
+                
+            return success
 
 class ReloadHandler(FileSystemEventHandler):
     """

{erispulse-2.1.15.dev3.dist-info → erispulse-2.2.0.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ErisPulse
-Version: 2.1.15.dev3
+Version: 2.2.0.dev0
 Summary: ErisPulse 是一个模块化、可扩展的异步 Python SDK 框架，主要用于构建高效、可维护的机器人应用程序。
 Author-email: "艾莉丝·格雷拉特(WSu2059)" <wsu2059@qq.com>
 License: MIT License
@@ -34,6 +34,12 @@ License: MIT License
         - Metadata definitions
         
         This ensures consistent behavior and interoperability across all adapter implementations.
+        
+        感谢所有为开源社区做出贡献的开发者和作者
+        
+        请尊重每一位开源作者的劳动成果，承诺在使用、修改和分发本软件时，将严格遵守相关许可证条款，并保留所有原始版权声明
+        
+        开源精神的核心在于分享、协作与尊重。我们希望通过本项目，能够传承这一精神，为开源社区的发展贡献一份力量
 License-File: LICENSE
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers

erispulse-2.2.0.dev0.dist-info/RECORD

@@ -0,0 +1,26 @@
+ErisPulse/__init__.py,sha256=c9pE-jRF89x4p5GF3QNU7wFxkli39tCOR_PyD_Tr8qQ,26834
+ErisPulse/__main__.py,sha256=HTq7Y7446eukTCHDX2_O9Ie8i-A7KHUCEJCmxx_j5co,76276
+ErisPulse/Core/__init__.py,sha256=gl-0UAI5_syGt1_23Lgy8P3vGjGxusWfYnTi281f5qI,520
+ErisPulse/Core/adapter.py,sha256=y75u_heNmpYLDjIBtVTfMzTHZFixWtYFv0JVskNI-2w,18300
+ErisPulse/Core/config.py,sha256=y0ChfCuw-6jAqs9Ii2tPJg0e4A765qzQLRcK6O8zh4c,2425
+ErisPulse/Core/env.py,sha256=IT_6Xks5Ka089O_4SVTvYNIC9Ly1IHX_Esb3SsleRj8,338
+ErisPulse/Core/erispulse_config.py,sha256=QDx401hNX9JcSHqCSVK33X6VTubl6HI1znAK3T_J0K0,3034
+ErisPulse/Core/exceptions.py,sha256=zuTREGczwGzbYT4Z6dACqHwgNRpiJeLFR8aCxFdOg7k,3667
+ErisPulse/Core/logger.py,sha256=6p53nQE7NFXSqs_lftW-HQB1BQcgruAYOpIYx25QLVA,11252
+ErisPulse/Core/mods.py,sha256=vKLEDr2nQ4kUULHmUQYFbRL04ePIKlwLEOGB-ldMYS8,7130
+ErisPulse/Core/router.py,sha256=s2EBh2qpt3UXYhB06Ppc1XTFuZ3u0ZfXENJxwkgPoq8,8542
+ErisPulse/Core/storage.py,sha256=oRum4eVaTc3yxcaafggoIvrk41LPbvApSCxkGM3YmzU,17904
+ErisPulse/Core/Event/__init__.py,sha256=fgK9bskLqVYau9ORfhGNBxSBJo7oZheeSYvwucigpEU,1042
+ErisPulse/Core/Event/base.py,sha256=NQb9_mA7OwxCGbcpunOQD_aV9Zq3i7xLQ1AzKM-ebl8,3758
+ErisPulse/Core/Event/cmd.py,sha256=B7c-PUaCn5qhubCqgI1pDSvvjofTLQHzmBaD0TuqJF4,6964
+ErisPulse/Core/Event/exceptions.py,sha256=iGcuPaC7F4cZeujcvBdZb9bzQGnHBdb9CcPKoB760Bo,711
+ErisPulse/Core/Event/manager.py,sha256=xIdK29jY2h-cCLFeq7JqPxuzYvuU7jAPdJMq2CPgwcQ,4270
+ErisPulse/Core/Event/message.py,sha256=n5ObSaGmyU3z5QSM5-5VwOBr69FY7p4TdRoy6Xy0Nzg,2640
+ErisPulse/Core/Event/meta.py,sha256=tr5aKoFtqCjybkpbUJ6JfuppZTk34eAipGvggPkGeSs,2282
+ErisPulse/Core/Event/notice.py,sha256=YLe5OphsF4sf1nvOokQ9bgCpCRf6MuGKRa1QjWotiK8,2825
+ErisPulse/Core/Event/request.py,sha256=FOkbW9WcUnc2uywkUWfUim4xJXXmlY1gYK6SD8Cd7So,1853
+erispulse-2.2.0.dev0.dist-info/METADATA,sha256=38Qx-4vuxUcOKVRUHlxg9qV76NE6QQtUtgsS9txSU6k,7290
+erispulse-2.2.0.dev0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+erispulse-2.2.0.dev0.dist-info/entry_points.txt,sha256=Jss71M6nEha0TA-DyVZugPYdcL14s9QpiOeIlgWxzOc,182
+erispulse-2.2.0.dev0.dist-info/licenses/LICENSE,sha256=b2XwzcfWuv_36Op3xGdjcuPHgfCz62yT3bXYjfStpxY,1852
+erispulse-2.2.0.dev0.dist-info/RECORD,,

{erispulse-2.1.15.dev3.dist-info → erispulse-2.2.0.dev0.dist-info}/licenses/LICENSE

@@ -28,4 +28,10 @@ This SDK's core adapter standardization layer strictly follows OneBot12 specific
 - Message segment definitions
 - Metadata definitions
 
-This ensures consistent behavior and interoperability across all adapter implementations.
+This ensures consistent behavior and interoperability across all adapter implementations.
+
+感谢所有为开源社区做出贡献的开发者和作者
+
+请尊重每一位开源作者的劳动成果，承诺在使用、修改和分发本软件时，将严格遵守相关许可证条款，并保留所有原始版权声明
+
+开源精神的核心在于分享、协作与尊重。我们希望通过本项目，能够传承这一精神，为开源社区的发展贡献一份力量

erispulse-2.1.15.dev3.dist-info/RECORD

@@ -1,17 +0,0 @@
-ErisPulse/__init__.py,sha256=ElwKDJgga0oePhwPXuxgUsWMevpfXdsii0X0zuJPmC0,26790
-ErisPulse/__main__.py,sha256=ePvZuyPEq5-ODog3aFMPQJCbj3TNKsZU_N3kynJ6aek,73908
-ErisPulse/Core/__init__.py,sha256=VCYMC8Ehfw603jV9KFaWdiWAh4UORSqrMTRuVfXZK0I,481
-ErisPulse/Core/adapter.py,sha256=y75u_heNmpYLDjIBtVTfMzTHZFixWtYFv0JVskNI-2w,18300
-ErisPulse/Core/config.py,sha256=y0ChfCuw-6jAqs9Ii2tPJg0e4A765qzQLRcK6O8zh4c,2425
-ErisPulse/Core/env.py,sha256=IT_6Xks5Ka089O_4SVTvYNIC9Ly1IHX_Esb3SsleRj8,338
-ErisPulse/Core/erispulse_config.py,sha256=QDx401hNX9JcSHqCSVK33X6VTubl6HI1znAK3T_J0K0,3034
-ErisPulse/Core/exceptions.py,sha256=zuTREGczwGzbYT4Z6dACqHwgNRpiJeLFR8aCxFdOg7k,3667
-ErisPulse/Core/logger.py,sha256=6p53nQE7NFXSqs_lftW-HQB1BQcgruAYOpIYx25QLVA,11252
-ErisPulse/Core/mods.py,sha256=vKLEDr2nQ4kUULHmUQYFbRL04ePIKlwLEOGB-ldMYS8,7130
-ErisPulse/Core/router.py,sha256=s2EBh2qpt3UXYhB06Ppc1XTFuZ3u0ZfXENJxwkgPoq8,8542
-ErisPulse/Core/storage.py,sha256=oRum4eVaTc3yxcaafggoIvrk41LPbvApSCxkGM3YmzU,17904
-erispulse-2.1.15.dev3.dist-info/METADATA,sha256=2F6t5xA_I3utUv6eRjgXJ24--oYEpHWQ8ZauCLRbI6I,6856
-erispulse-2.1.15.dev3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-erispulse-2.1.15.dev3.dist-info/entry_points.txt,sha256=Jss71M6nEha0TA-DyVZugPYdcL14s9QpiOeIlgWxzOc,182
-erispulse-2.1.15.dev3.dist-info/licenses/LICENSE,sha256=4jyqikiB0G0n06CEEMMTzTXjE4IShghSlB74skMSPQs,1464
-erispulse-2.1.15.dev3.dist-info/RECORD,,