ErisPulse 2.1.0__py3-none-any.whl → 2.1.2__py3-none-any.whl

ErisPulse/Core/__init__.py

@@ -17,3 +17,17 @@ __all__ = [
     'util',
     'adapter_server'
 ]
+
+_config = env.getConfig("ErisPulse")
+
+if _config is None:
+    defaultConfig = {
+        "server": {
+            "host": "0.0.0.0",
+            "port": 8000,
+            "ssl_certfile": None,
+            "ssl_keyfile": None
+        }
+    }
+    env.setConfig("ErisPulse", defaultConfig)
+    _config = defaultConfig

ErisPulse/Core/adapter.py

@@ -34,20 +34,22 @@ class SendDSLBase:
     {!--< /tips >!--}
     """
     
-    def __init__(self, adapter: 'BaseAdapter', target_type: Optional[str] = None, target_id: Optional[str] = None):
+    def __init__(self, adapter: 'BaseAdapter', target_type: Optional[str] = None, target_id: Optional[str] = None, account_id: Optional[str] = None):
         """
         初始化DSL发送器
         
         :param adapter: 所属适配器实例
         :param target_type: 目标类型(可选)
         :param target_id: 目标ID(可选)
+        :param _account_id: 发送账号(可选)
         """
         self._adapter = adapter
         self._target_type = target_type
         self._target_id = target_id
         self._target_to = target_id
+        self._account = account_id
 
-    def To(self, target_type: str = None, target_id: str = None) -> 'SendDSL':
+    def To(self, target_type: str = None, target_id: Union[str, int] = None) -> 'SendDSL':
         """
         设置消息目标
         
@@ -63,7 +65,20 @@ class SendDSLBase:
             target_id = target_type
             target_type = None
 
-        return self.__class__(self._adapter, target_type, target_id)
+        return self.__class__(self._adapter, target_type, target_id, self._account_id)
+
+    def Using(self, account_id: Union[str, int]) -> 'SendDSL':
+        """
+        设置发送账号
+        
+        :param _account_id: 发送账号
+        :return: SendDSL实例
+        
+        :example:
+        >>> adapter.Send.Using("bot1").To("123").Text("Hello")
+        >>> adapter.Send.To("123").Using("bot1").Text("Hello")  # 支持乱序
+        """
+        return self.__class__(self._adapter, self._target_type, self._target_id, account_id)
 
 
 class BaseAdapter:
@@ -90,56 +105,40 @@ class BaseAdapter:
         {!--< /tips >!--}
         """
         
-        def Text(self, text: str) -> Awaitable[Any]:
+        def Example(self, text: str) -> Awaitable[Any]:
             """
-            基础文本消息发送方法
+            示例消息发送方法
             
             :param text: 文本内容
             :return: 异步任务
-            
             :example:
-            >>> await adapter.Send.To("123").Text("Hello")
+            >>> await adapter.Send.To("123").Example("Hello")
             """
-            return asyncio.create_task(
-                self._adapter.call_api(
-                    endpoint="/send",
-                    content=text,
-                    recvId=self._target_id,
-                    recvType=self._target_type
-                )
-            )
+            from .logger import logger
+            logger.debug(f"适配器 {self._adapter.__class__.__name__} 发送了实例类型的消息: {text}")
+            
         
     def __init__(self):
         """
         初始化适配器
         """
-        self._handlers = defaultdict(list)  # 原生事件处理器
-        self._onebot_handlers = defaultdict(list)  # OneBot12事件处理器
+        self._handlers = defaultdict(list)
         self._middlewares = []
         self.Send = self.__class__.Send(self)
 
-    def on(self, event_type: str = "*", *, onebot12: bool = False) -> Callable[[Callable], Callable]:
+    def on(self, event_type: str = "*") -> Callable[[Callable], Callable]:
         """
         适配器事件监听装饰器
         
         :param event_type: 事件类型
-        :param onebot12: 是否监听OneBot12协议事件
         :return: 装饰器函数
-        
-        :example:
-        >>> @adapter.on("message")
-        >>> async def handle_message(data):
-        >>>     print(f"收到消息: {data}")
         """
         def decorator(func: Callable) -> Callable:
             @functools.wraps(func)
             async def wrapper(*args, **kwargs):
                 return await func(*args, **kwargs)
-            
-            if onebot12:
-                self._onebot_handlers[event_type].append(wrapper)
-            else:
-                self._handlers[event_type].append(wrapper)
+            self._handlers[event_type].append(wrapper)
+
             return wrapper
         return decorator
 
@@ -166,7 +165,6 @@ class BaseAdapter:
         :param endpoint: API端点
         :param params: API参数
         :return: API调用结果
-        
         :raises NotImplementedError: 必须由子类实现
         """
         raise NotImplementedError("适配器必须实现call_api方法")
@@ -186,36 +184,6 @@ class BaseAdapter:
         :raises NotImplementedError: 必须由子类实现
         """
         raise NotImplementedError("适配器必须实现shutdown方法")
-
-    def add_handler(self, *args: Any) -> None:
-        """
-        添加事件处理器
-        
-        :param args: 参数列表
-            - 1个参数: 处理器函数(监听所有事件)
-            - 2个参数: 事件类型和处理器函数
-            
-        :raises TypeError: 当参数数量无效时抛出
-            
-        :example:
-        >>> # 监听所有事件
-        >>> adapter.add_handler(handle_all_events)
-        >>> # 监听特定事件
-        >>> adapter.add_handler("message", handle_message)
-        """
-        if len(args) == 1:
-            event_type = "*"
-            handler = args[0]
-        elif len(args) == 2:
-            event_type, handler = args
-        else:
-            raise TypeError("add_handler() 接受 1 个（监听所有事件）或 2 个参数（指定事件类型）")
-
-        @functools.wraps(handler)
-        async def wrapper(*handler_args, **handler_kwargs):
-            return await handler(*handler_args, **handler_kwargs)
-
-        self._handlers[event_type].append(wrapper)
         
     async def emit(self, event_type: str, data: Any) -> None:
         """
@@ -240,35 +208,6 @@ class BaseAdapter:
         for handler in self._handlers.get("*", []):
             await handler(data)
 
-    async def emit_onebot12(self, event_type: str, onebot_data: Dict) -> None:
-        """
-        提交OneBot12协议事件
-        
-        :param event_type: OneBot12事件类型
-        :param onebot_data: 符合OneBot12标准的事件数据
-        
-        :example:
-        >>> await adapter.emit_onebot12("message", {
-        >>>     "id": "123",
-        >>>     "time": 1620000000,
-        >>>     "type": "message",
-        >>>     "detail_type": "private",
-        >>>     "message": [{"type": "text", "data": {"text": "Hello"}}]
-        >>> })
-        """
-        # 先执行中间件
-        for middleware in self._middlewares:
-            onebot_data = await middleware(onebot_data)
-
-        # 触发OneBot12事件处理器
-        if event_type in self._onebot_handlers:
-            for handler in self._onebot_handlers[event_type]:
-                await handler(onebot_data)
-
-        # 触发通配符 "*" 的处理器
-        for handler in self._onebot_handlers.get("*", []):
-            await handler(onebot_data)
-
     async def send(self, target_type: str, target_id: str, message: Any, **kwargs: Any) -> Any:
         """
         发送消息的便捷方法
@@ -467,18 +406,8 @@ class AdapterManager:
         from .logger import logger
         from .server import adapter_server
 
-        server_config = env.getConfig("Server")
-
-        if server_config is None:
-            server_config = {
-                "host": "0.0.0.0",
-                "port": 8000,
-                "ssl_certfile": None,
-                "ssl_keyfile": None
-            }
-            env.setConfig("Server", server_config)
-            logger.info("已创建服务器配置")
-        
+        from . import _config
+        server_config = _config.get("server", {})
         host = server_config["host"]
         port = server_config["port"]
         ssl_cert = server_config.get("ssl_certfile", None)
@@ -565,7 +494,7 @@ class AdapterManager:
             await adapter.shutdown()
         
         from .server import adapter_server
-        adapter_server.stop()
+        await adapter_server.stop()
 
     def get(self, platform: str) -> Optional[BaseAdapter]:
         """
@@ -616,4 +545,4 @@ class AdapterManager:
 
 AdapterFather = BaseAdapter
 adapter = AdapterManager()
-SendDSL = SendDSLBase
+SendDSL = SendDSLBase

ErisPulse/Core/logger.py

@@ -1,9 +1,32 @@
+"""
+ErisPulse 日志系统
+
+提供模块化日志记录功能，支持多级日志、模块过滤和内存存储。
+
+{!--< tips >!--}
+1. 支持按模块设置不同日志级别
+2. 日志可存储在内存中供后续分析
+3. 自动识别调用模块名称
+{!--< /tips >!--}
+"""
+
 import logging
 import inspect
 import datetime
 from typing import List, Dict, Any, Optional, Union, Type, Set, Tuple, FrozenSet
 
 class Logger:
+    """
+    日志管理器
+    
+    提供模块化日志记录和存储功能
+    
+    {!--< tips >!--}
+    1. 使用set_module_level设置模块日志级别
+    2. 使用get_logs获取历史日志
+    3. 支持标准日志级别(DEBUG, INFO等)
+    {!--< /tips >!--}
+    """
     def __init__(self):
         self._logs = {}
         self._module_levels = {}
@@ -16,6 +39,12 @@ class Logger:
             self._logger.addHandler(console_handler)
 
     def set_level(self, level: str) -> bool:
+        """
+        设置全局日志级别
+        
+        :param level: 日志级别(DEBUG/INFO/WARNING/ERROR/CRITICAL)
+        :return: bool 设置是否成功
+        """
         try:
             level = level.upper()
             if hasattr(logging, level):
@@ -27,6 +56,13 @@ class Logger:
             return False
 
     def set_module_level(self, module_name: str, level: str) -> bool:
+        """
+        设置指定模块日志级别
+
+        :param module_name: 模块名称
+        :param level: 日志级别(DEBUG/INFO/WARNING/ERROR/CRITICAL)
+        :return: bool 设置是否成功
+        """
         from .env import env
         if not env.get_module_status(module_name):
             self._logger.warning(f"模块 {module_name} 未启用，无法设置日志等级。")
@@ -41,6 +77,12 @@ class Logger:
             return False
 
     def set_output_file(self, path) -> bool:
+        """
+        设置日志输出
+
+        :param path: 日志文件路径 Str/List
+        :return: bool 设置是否成功
+        """
         if self._file_handler:
             self._logger.removeHandler(self._file_handler)
             self._file_handler.close()
@@ -58,7 +100,14 @@ class Logger:
             except Exception as e:
                 self._logger.error(f"无法设置日志文件 {p}: {e}")
                 return False
+            
     def save_logs(self, path) -> bool:
+        """
+        保存所有在内存中记录的日志
+        
+        :param path: 日志文件路径 Str/List
+        :return: bool 设置是否成功
+        """
         if self._logs == None:
             self._logger.warning("没有log记录可供保存。")
             return False
@@ -79,6 +128,12 @@ class Logger:
                 return False
 
     def get_logs(self, module_name: str = None) -> dict:
+        """
+        获取日志内容
+
+        :param module_name (可选): 模块名称
+        :return: dict 日志内容
+        """
         if module_name:
             return {module_name: self._logs.get(module_name, [])}
         return {k: v.copy() for k, v in self._logs.items()}

ErisPulse/Core/server.py

@@ -245,7 +245,7 @@ class AdapterServer:
 
         config = Config()
         config.bind = [f"{host}:{port}"]
-        # config.loglevel = "debug"
+        config.loglevel = "warning"
         
         if ssl_certfile and ssl_keyfile:
             config.certfile = ssl_certfile

ErisPulse/__init__.py

@@ -13,11 +13,9 @@ ErisPulse SDK 主模块
 import os
 import sys
 import importlib
-import asyncio
-import toml
 import inspect
 import importlib.metadata
-from typing import Dict, List, Tuple, Optional, Set, Type, Any, Callable
+from typing import Dict, List, Tuple, Type, Any
 from pathlib import Path
 
 # BaseModules: SDK核心模块
@@ -73,14 +71,14 @@ class LazyModule:
     {!--< /tips >!--}
     """
     
-    def __init__(self, module_name: str, module_class: Type, sdk_ref: Any, module_info: Dict[str, Any]):
+    def __init__(self, module_name: str, module_class: Type, sdk_ref: Any, module_info: Dict[str, Any]) -> None:
         """
         初始化懒加载包装器
         
-        :param module_name: 模块名称
-        :param module_class: 模块类
-        :param sdk_ref: SDK引用
-        :param module_info: 模块信息字典
+        :param module_name: str 模块名称
+        :param module_class: Type 模块类
+        :param sdk_ref: Any SDK引用
+        :param module_info: Dict[str, Any] 模块信息字典
         """
         self._module_name = module_name
         self._module_class = module_class
@@ -90,7 +88,11 @@ class LazyModule:
         self._initialized = False
     
     def _initialize(self):
-        """实际初始化模块"""
+        """
+        实际初始化模块
+        
+        :raises LazyLoadError: 当模块初始化失败时抛出
+        """
         try:
             # 获取类的__init__参数信息
             init_signature = inspect.signature(self._module_class.__init__)
@@ -110,16 +112,77 @@ class LazyModule:
             raise raiserr.LazyLoadError(f"无法初始化模块 {self._module_name}: {e}")
     
     def __getattr__(self, name: str) -> Any:
-        """属性访问时触发初始化"""
+        """
+        属性访问时触发初始化
+        
+        :param name: str 要访问的属性名
+        :return: Any 模块属性值
+        """
         if not self._initialized:
             self._initialize()
         return getattr(self._instance, name)
     
     def __call__(self, *args, **kwargs) -> Any:
-        """调用时触发初始化"""
+        """
+        调用时触发初始化
+        
+        :param args: 位置参数
+        :param kwargs: 关键字参数
+        :return: Any 模块调用结果
+        """
         if not self._initialized:
             self._initialize()
         return self._instance(*args, **kwargs)
+    
+    def __bool__(self) -> bool:
+        """
+        判断模块布尔值时触发初始化
+
+        :return: bool 模块布尔值
+        """
+        if not self._initialized:
+            self._initialize()
+        return bool(self._instance)
+    
+    def __str__(self) -> str:
+        """
+        转换为字符串时触发初始化
+        
+        :return: str 模块字符串表示
+        """
+        if not self._initialized:
+            self._initialize()
+            return str(self._instance)
+        return str(self._instance)
+    
+    # 确保模块在被赋值给变量后仍然能正确工作
+    def __getattribute__(self, name: str) -> Any:
+        try:
+            # 首先尝试获取常规属性
+            return super().__getattribute__(name)
+        except AttributeError:
+            # 如果常规属性不存在，触发初始化
+            if name != '_initialized' and not self._initialized:
+                self._initialize()
+                return getattr(self._instance, name)
+            raise
+        
+    def __copy__(self):
+        """
+        浅拷贝时返回自身，保持懒加载特性
+
+        :return: self
+        """
+        return self
+
+    def __deepcopy__(self, memo):
+        """
+        深拷贝时返回自身，保持懒加载特性
+
+        :param memo: memo
+        :return: self
+        """
+        return self
 
 
 class AdapterLoader:
@@ -375,8 +438,8 @@ class ModuleLoader:
         """
         检查模块是否应该懒加载
         
-        :param module_class: 模块类
-        :return: bool: 如果返回 False，则立即加载；否则懒加载
+        :param module_class: Type 模块类
+        :return: bool 如果返回 False，则立即加载；否则懒加载
         """
         # 检查模块是否定义了 should_eager_load() 方法
         if hasattr(module_class, "should_eager_load"):
@@ -413,7 +476,8 @@ class ModuleInitializer:
         4. 注册适配器
         5. 初始化各模块
         
-        :return: bool: 初始化是否成功
+        :return: bool 初始化是否成功
+        :raises InitError: 当初始化失败时抛出
         """
         logger.info("[Init] SDK 正在初始化...")
         
@@ -426,23 +490,20 @@ class ModuleInitializer:
             module_objs, enabled_modules, disabled_modules = ModuleLoader.load()
             logger.info(f"[Init] 加载了 {len(enabled_modules)} 个模块, {len(disabled_modules)} 个模块被禁用")
             
-            if os.path.join(os.path.dirname(__file__), "modules"):
+            modules_dir = os.path.join(os.path.dirname(__file__), "modules")
+            if os.path.exists(modules_dir) and os.listdir(modules_dir):
                 logger.warning("[Warning] 你的项目使用了已经弃用的模块加载方式, 请尽快使用 PyPI 模块加载方式代替")
             
             if not enabled_modules and not enabled_adapters:
                 logger.warning("[Init] 没有找到可用的模块和适配器")
                 return True
             
-            # 3. 预记录所有模块信息到SDK属性中
-            logger.debug("[Init] 正在预记录模块信息...")
-            ModuleInitializer._pre_register_modules(enabled_modules, module_objs)
-            
-            # 4. 注册适配器
+            # 3. 注册适配器
             logger.debug("[Init] 正在注册适配器...")
             if not ModuleInitializer._register_adapters(enabled_adapters, adapter_objs):
                 return False
             
-            # 5. 初始化模块
+            # 4. 初始化模块
             logger.debug("[Init] 正在初始化模块...")
             success = ModuleInitializer._initialize_modules(enabled_modules, module_objs)
             logger.info(f"[Init] SDK初始化{'成功' if success else '失败'}")
@@ -454,20 +515,81 @@ class ModuleInitializer:
             return False
     
     @staticmethod
-    def _pre_register_modules(modules: List[str], module_objs: Dict[str, Any]) -> None:
+    def _initialize_modules(modules: List[str], module_objs: Dict[str, Any]) -> bool:
         """
-        预记录所有模块信息到SDK属性中
+        {!--< internal-use >!--}
+        初始化模块
+        
+        :param modules: List[str] 模块名称列表
+        :param module_objs: Dict[str, Any] 模块对象字典
         
-        确保所有模块在初始化前都已在SDK中注册
+        :return: bool 模块初始化是否成功
         """
+        # 第一阶段：将所有模块挂载到LazyModule代理上
         for module_name in modules:
             module_obj = module_objs[module_name]
             meta_name = module_obj.moduleInfo["meta"]["name"]
             
-            # 即使模块是懒加载的，也先在SDK中创建占位符
-            if not hasattr(sdk, meta_name):
+            if hasattr(sdk, meta_name):
+                continue
+                
+            try:
+                entry_points = importlib.metadata.entry_points()
+                if hasattr(entry_points, 'select'):
+                    module_entries = entry_points.select(group='erispulse.module')
+                    module_entry_map = {entry.name: entry for entry in module_entries}
+                else:
+                    module_entries = entry_points.get('erispulse.module', [])
+                    module_entry_map = {entry.name: entry for entry in module_entries}
+                
+                entry_point = module_entry_map.get(meta_name)
+                if entry_point:
+                    module_class = entry_point.load()
+                    
+                    # 创建LazyModule代理
+                    lazy_module = LazyModule(meta_name, module_class, sdk, module_obj.moduleInfo)
+                    setattr(sdk, meta_name, lazy_module)
+                    
+                    logger.debug(f"预注册模块: {meta_name}")
+                    
+            except Exception as e:
+                logger.error(f"预注册模块 {meta_name} 失败: {e}")
                 setattr(sdk, meta_name, None)
-                logger.debug(f"预注册模块: {meta_name}")
+                return False
+        
+        # 第二阶段：检查并初始化需要立即加载的模块
+        for module_name in modules:
+            module_obj = module_objs[module_name]
+            meta_name = module_obj.moduleInfo["meta"]["name"]
+            
+            if not hasattr(sdk, meta_name):
+                continue
+                
+            try:
+                entry_points = importlib.metadata.entry_points()
+                if hasattr(entry_points, 'select'):
+                    module_entries = entry_points.select(group='erispulse.module')
+                    module_entry_map = {entry.name: entry for entry in module_entries}
+                else:
+                    module_entries = entry_points.get('erispulse.module', [])
+                    module_entry_map = {entry.name: entry for entry in module_entries}
+                
+                entry_point = module_entry_map.get(meta_name)
+                if entry_point:
+                    module_class = entry_point.load()
+                    
+                    # 检查是否需要立即加载
+                    lazy_load = ModuleLoader._should_lazy_load(module_class)
+                    if not lazy_load:
+                        # 触发LazyModule的初始化
+                        getattr(sdk, meta_name)._initialize()
+                        logger.debug(f"立即初始化模块: {meta_name}")
+                        
+            except Exception as e:
+                logger.error(f"初始化模块 {meta_name} 失败: {e}")
+                return False
+                
+        return True
     
     @staticmethod
     def _register_adapters(adapters: List[str], adapter_objs: Dict[str, Any]) -> bool:
@@ -475,10 +597,10 @@ class ModuleInitializer:
         {!--< internal-use >!--}
         注册适配器
         
-        :param adapters: 适配器名称列表
-        :param adapter_objs: 适配器对象字典
+        :param adapters: List[str] 适配器名称列表
+        :param adapter_objs: Dict[str, Any] 适配器对象字典
         
-        :return: bool: 适配器注册是否成功
+        :return: bool 适配器注册是否成功
         """
         success = True
         # 存储平台名到适配器类的映射
@@ -519,85 +641,6 @@ class ModuleInitializer:
                 success = False
         return success
     
-    @staticmethod
-    def _initialize_modules(modules: List[str], module_objs: Dict[str, Any]) -> bool:
-        """
-        {!--< internal-use >!--}
-        初始化模块
-        
-        :param modules: 模块名称列表
-        :param module_objs: 模块对象字典
-        
-        :return: bool: 模块初始化是否成功
-        """
-        success = True
-        
-        try:
-            entry_points = importlib.metadata.entry_points()
-            if hasattr(entry_points, 'select'):
-                module_entries = entry_points.select(group='erispulse.module')
-                module_entry_map = {entry.name: entry for entry in module_entries}
-            else:
-                module_entries = entry_points.get('erispulse.module', [])
-                module_entry_map = {entry.name: entry for entry in module_entries}
-        except Exception as e:
-            logger.error(f"获取 entry_points 失败: {e}")
-            return False
-        
-        # 第一次遍历：创建所有模块的占位符
-        for module_name in modules:
-            module_obj = module_objs[module_name]
-            meta_name = module_obj.moduleInfo["meta"]["name"]
-            
-            if not mods.get_module_status(meta_name):
-                continue
-                
-            entry_point = module_entry_map.get(meta_name)
-            if not entry_point:
-                logger.error(f"找不到模块 {meta_name} 的 entry-point")
-                success = False
-                continue
-            
-            # 创建模块占位符
-            if not hasattr(sdk, meta_name):
-                setattr(sdk, meta_name, None)
-        
-        # 第二次遍历：实际初始化模块
-        for module_name in modules:
-            module_obj = module_objs[module_name]
-            meta_name = module_obj.moduleInfo["meta"]["name"]
-            
-            try:
-                if not mods.get_module_status(meta_name):
-                    continue
-                
-                entry_point = module_entry_map.get(meta_name)
-                if not entry_point:
-                    continue
-                
-                module_class = entry_point.load()
-                lazy_load = ModuleLoader._should_lazy_load(module_class)
-                
-                if lazy_load:
-                    lazy_module = LazyModule(meta_name, module_class, sdk, module_obj.moduleInfo)
-                    setattr(sdk, meta_name, lazy_module)
-                else:
-                    init_signature = inspect.signature(module_class.__init__)
-                    if 'sdk' in init_signature.parameters:
-                        instance = module_class(sdk)
-                    else:
-                        instance = module_class()
-                    
-                    setattr(instance, "moduleInfo", module_obj.moduleInfo)
-                    setattr(sdk, meta_name, instance)
-                    logger.debug(f"模块 {meta_name} 已初始化")
-                    
-            except Exception as e:
-                logger.error(f"初始化模块 {meta_name} 失败: {e}")
-                success = False
-        
-        return success
-    
 def init_progress() -> bool:
     """
     初始化项目环境文件
@@ -605,7 +648,7 @@ def init_progress() -> bool:
     1. 检查并创建main.py入口文件
     2. 确保基础目录结构存在
 
-    :return: bool: 是否创建了新的main.py文件
+    :return: bool 是否创建了新的main.py文件
     
     {!--< tips >!--}
     1. 如果main.py已存在则不会覆盖
@@ -658,7 +701,7 @@ def _prepare_environment() -> bool:
     1. 初始化项目环境文件
     2. 加载环境变量配置
 
-    :return: bool: 环境准备是否成功
+    :return: bool 环境准备是否成功
     """
     logger.info("[Init] 准备初始化环境...")
     try:
@@ -680,7 +723,7 @@ def init() -> bool:
     1. 准备运行环境
     2. 初始化所有模块和适配器
 
-    :return: bool: SDK初始化是否成功
+    :return: bool SDK初始化是否成功
     
     {!--< tips >!--}
     1. 这是SDK的主要入口函数
@@ -700,8 +743,8 @@ def load_module(module_name: str) -> bool:
     """
     手动加载指定模块
     
-    :param module_name: 要加载的模块名称
-    :return: bool: 加载是否成功
+    :param module_name: str 要加载的模块名称
+    :return: bool 加载是否成功
     
     {!--< tips >!--}
     1. 可用于手动触发懒加载模块的初始化

ErisPulse/__main__.py

@@ -5,7 +5,6 @@
 
 ## 主要命令
 ### 包管理:
-    search: 搜索PyPI上的ErisPulse模块
     install: 安装模块/适配器包
     uninstall: 卸载模块/适配器包
     list: 列出已安装的模块/适配器
@@ -42,8 +41,18 @@ from watchdog.events import FileSystemEventHandler
 from .Core.shellprint import shellprint, Shell_Printer
 
 class PyPIManager:
-    """管理PyPI上的ErisPulse模块和适配器"""
+    """
+    PyPI包管理器
     
+    负责与PyPI交互，包括搜索、安装、卸载和升级ErisPulse模块/适配器
+
+    {!--< tips >!--}
+    1. 支持多个远程源作为备份
+    2. 自动区分模块和适配器
+    3. 提供详细的错误处理
+    {!--< /tips >!--}
+    """
+
     REMOTE_SOURCES = [
         "https://erisdev.com/packages.json",
         "https://raw.githubusercontent.com/ErisPulse/ErisPulse-ModuleRepo/main/packages.json"
@@ -51,6 +60,20 @@ class PyPIManager:
     
     @staticmethod
     async def get_remote_packages() -> dict:
+        """
+        获取远程包列表
+        
+        从配置的远程源获取所有可用的ErisPulse模块和适配器
+
+        :return: 
+            Dict[str, Dict]: 包含模块和适配器的字典
+                - modules: 模块字典 {模块名: 模块信息}
+                - adapters: 适配器字典 {适配器名: 适配器信息}
+                
+        :raises ClientError: 当网络请求失败时抛出
+        :raises asyncio.TimeoutError: 当请求超时时抛出
+        """
+
         import aiohttp
         from aiohttp import ClientError, ClientTimeout
         
@@ -86,30 +109,16 @@ class PyPIManager:
             shellprint.panel(f"获取远程模块列表失败: {last_error}", "错误", "error")
         return {"modules": {}, "adapters": {}}
     
-    @staticmethod
-    def search_packages(query: str) -> List[Dict[str, str]]:
-        try:
-            result = subprocess.run(
-                [sys.executable, "-m", "pip", "search", query],
-                capture_output=True,
-                text=True
-            )
-            
-            packages = []
-            for line in result.stdout.split('\n'):
-                if "ErisPulse-" in line:
-                    parts = line.split(' ', 1)
-                    if len(parts) >= 1:
-                        name = parts[0].strip()
-                        desc = parts[1].strip() if len(parts) > 1 else ""
-                        packages.append({"name": name, "description": desc})
-            return packages
-        except Exception as e:
-            shellprint.panel(f"搜索PyPI包失败: {e}", "错误", "error")
-            return []
-    
     @staticmethod
     def get_installed_packages() -> Dict[str, Dict[str, str]]:
+        """
+        获取已安装的包信息
+        
+        :return: 
+            Dict[str, Dict[str, Dict[str, str]]]: 已安装包字典
+                - modules: 已安装模块 {模块名: 模块信息}
+                - adapters: 已安装适配器 {适配器名: 适配器信息}
+        """
         packages = {
             "modules": {},
             "adapters": {}
@@ -140,6 +149,13 @@ class PyPIManager:
     
     @staticmethod
     def install_package(package_name: str, upgrade: bool = False) -> bool:
+        """
+        安装指定包
+        
+        :param package_name: str 要安装的包名
+        :param upgrade: bool 是否升级已安装的包 (默认: False)
+        :return: bool 安装是否成功
+        """
         try:
             cmd = [sys.executable, "-m", "pip", "install"]
             if upgrade:
@@ -158,6 +174,12 @@ class PyPIManager:
     
     @staticmethod
     def uninstall_package(package_name: str) -> bool:
+        """
+        卸载指定包
+        
+        :param package_name: str 要卸载的包名
+        :return: bool 卸载是否成功
+        """
         try:
             shellprint.status(f"正在卸载 {package_name}...")
             result = subprocess.run(
@@ -174,6 +196,16 @@ class PyPIManager:
     
     @staticmethod
     def upgrade_all() -> bool:
+        """
+        升级所有已安装的ErisPulse包
+        
+        :return: bool 升级是否成功
+        
+        {!--< tips >!--}
+        1. 会先列出所有可升级的包
+        2. 需要用户确认才会执行升级
+        {!--< /tips >!--}
+        """
         try:
             installed = PyPIManager.get_installed_packages()
             all_packages = set()
@@ -205,6 +237,17 @@ class PyPIManager:
             return False
 
 class ReloadHandler(FileSystemEventHandler):
+    """
+    热重载处理器
+    
+    监控文件变化并自动重启脚本
+
+    {!--< tips >!--}
+    1. 基于watchdog实现文件监控
+    2. 有1秒的防抖延迟
+    3. 会终止旧进程并启动新进程
+    {!--< /tips >!--}
+    """
     def __init__(self, script_path, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.script_path = script_path
@@ -213,6 +256,11 @@ class ReloadHandler(FileSystemEventHandler):
         self.start_process()
 
     def start_process(self):
+        """
+        启动/重启被监控的进程
+        
+        {!--< internal-use >!--}
+        """
         if self.process:
             self.process.terminate()
             self.process.wait()
@@ -222,6 +270,11 @@ class ReloadHandler(FileSystemEventHandler):
         self.last_reload = time.time()
 
     def on_modified(self, event):
+        """
+        文件修改事件处理
+        
+        :param event: FileSystemEvent 文件系统事件对象
+        """
         now = time.time()
         if now - self.last_reload < 1.0:
             return
@@ -231,6 +284,16 @@ class ReloadHandler(FileSystemEventHandler):
             self.start_process()
 
 def start_reloader(script_path):
+    """
+    启动热重载监控
+    
+    :param script_path: str 要监控的脚本路径
+    
+    {!--< tips >!--}
+    1. 监控脚本所在目录和modules目录
+    2. 按Ctrl+C可停止监控
+    {!--< /tips >!--}
+    """
     project_root = os.path.dirname(os.path.abspath(__file__))
     watch_dirs = [
         os.path.dirname(os.path.abspath(script_path)),
@@ -257,6 +320,14 @@ def start_reloader(script_path):
     observer.join()
 
 def run_script(script_path: str, reload: bool = False):
+    """
+    运行指定脚本
+    
+    :param script_path: str 要运行的脚本路径
+    :param reload: bool 是否启用热重载 (默认: False)
+    
+    :raises FileNotFoundError: 当脚本不存在时抛出
+    """
     if not os.path.exists(script_path):
         shellprint.panel(f"找不到指定文件: {script_path}", "错误", "error")
         return
@@ -270,13 +341,31 @@ def run_script(script_path: str, reload: bool = False):
             runpy.run_path(script_path, run_name="__main__")
         except KeyboardInterrupt:
             shellprint.panel("脚本执行已中断", "中断", "info")
+
 def get_erispulse_version():
+    """
+    获取当前安装的ErisPulse版本
+    
+    :return: str ErisPulse版本号或"unknown version"
+    """
     try:
         return version("ErisPulse")
     except PackageNotFoundError:
         return "unknown version"
 
 def main():
+    """
+    CLI主入口
+    
+    解析命令行参数并执行相应命令
+    
+    {!--< tips >!--}
+    1. 使用argparse处理命令行参数
+    2. 支持彩色输出和表格显示
+    3. 提供详细的错误处理
+    {!--< /tips >!--}
+    """
+    
     parser = argparse.ArgumentParser(
         prog="epsdk",
         formatter_class=argparse.RawTextHelpFormatter,
@@ -293,11 +382,7 @@ def main():
         metavar=f"{Shell_Printer.GREEN}<命令>{Shell_Printer.RESET}",
         help='具体命令的帮助信息'
     )
-    
-    # 搜索命令
-    search_parser = subparsers.add_parser('search', help='搜索PyPI上的ErisPulse模块')
-    search_parser.add_argument('query', type=str, help='搜索关键词')
-    
+
     # 安装命令
     install_parser = subparsers.add_parser('install', help='安装模块/适配器包')
     install_parser.add_argument('package', type=str, help='要安装的包名')
@@ -336,20 +421,7 @@ def main():
         return
     
     try:
-        if args.command == "search":
-            packages = PyPIManager.search_packages(args.query)
-            if packages:
-                rows = [
-                    [
-                        f"{Shell_Printer.BLUE}{pkg['name']}{Shell_Printer.RESET}",
-                        pkg['description']
-                    ] for pkg in packages
-                ]
-                shellprint.table(["包名", "描述"], rows, "搜索结果", "info")
-            else:
-                shellprint.panel(f"未找到匹配 '{args.query}' 的ErisPulse包", "提示", "info")
-                
-        elif args.command == "install":
+        if args.command == "install":
             import asyncio
             # 首先检查是否是远程模块/适配器的简称
             remote_packages = asyncio.run(PyPIManager.get_remote_packages())

{erispulse-2.1.0.dist-info → erispulse-2.1.2.dist-info}/METADATA

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

erispulse-2.1.2.dist-info/RECORD

@@ -0,0 +1,16 @@
+ErisPulse/__init__.py,sha256=kQr2n1oeThlJVy7NY_ZMXgDsgZuhsBC5V6ysl2I59PQ,27471
+ErisPulse/__main__.py,sha256=yxlB-rCQKy7D5XMWqP5id1sOQbzLuPx048NNpLaCDf8,19851
+ErisPulse/Core/__init__.py,sha256=Wnkb4rI5kZhg8cdJE1sBfNRch55Aqp56npQ0DGXyHMA,675
+ErisPulse/Core/adapter.py,sha256=zeil2mhlZoUg8Wg6GlEMVnQ7f5rJWZNxc0c1g3c4W0w,18146
+ErisPulse/Core/env.py,sha256=9WYNadD9h2jP_2wxOVBJEhH1uDzbctW7eB4Ba9RSjA4,20409
+ErisPulse/Core/logger.py,sha256=40vDe_D3L6ople-RZX8eGXntrZpFGHHzSl3pYxK-FLI,7196
+ErisPulse/Core/mods.py,sha256=5SPutuzbMrA-VZwiXeNxYWfrdbpLRdYfQ0RvEkFuQgg,7308
+ErisPulse/Core/raiserr.py,sha256=QLQ3r7p4iFP86XBLq9mtf1wv1xSlgny35i8t5-l4DXo,4620
+ErisPulse/Core/server.py,sha256=FkDTeLuHD5IBnWVxvYU8pHb6yCt8GzyvC1bpOiJ7G7I,9217
+ErisPulse/Core/shellprint.py,sha256=-BFoyFho_D3XEhxIoKt6x5gO4C62LKwmJWKDUGiPjNY,5908
+ErisPulse/Core/util.py,sha256=kyydBAJHHG9I7rMRzKWtLAQMZoJyBqHiBAweqcraFkU,4001
+erispulse-2.1.2.dist-info/METADATA,sha256=weSMmPWTDHy4mx36qhkHle7Wj9dC7dKv7qO_IX19vOI,6161
+erispulse-2.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+erispulse-2.1.2.dist-info/entry_points.txt,sha256=Jss71M6nEha0TA-DyVZugPYdcL14s9QpiOeIlgWxzOc,182
+erispulse-2.1.2.dist-info/licenses/LICENSE,sha256=lBYj7Nk4urLvByj4HvQFxu8j9hThhFF6OGfyxAZBP9Q,1451
+erispulse-2.1.2.dist-info/RECORD,,

erispulse-2.1.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-ErisPulse/__init__.py,sha256=4jcAocMDQt4xdE9B3di8lGCtrU47Y4DY2ipW_9diYbU,26210
-ErisPulse/__main__.py,sha256=DeMBevz0KyLywnd5HccgZDwVfv-EKQOpo1fsVypKwiE,18525
-ErisPulse/Core/__init__.py,sha256=CIxWFdB6-0D8YJz7IdW052A4YllDsklEONCRj7mOpkQ,362
-ErisPulse/Core/adapter.py,sha256=gzryZjrOy0uowE5oU4MaVTtGPW7HP4StfvP5ECC4rUk,20510
-ErisPulse/Core/env.py,sha256=9WYNadD9h2jP_2wxOVBJEhH1uDzbctW7eB4Ba9RSjA4,20409
-ErisPulse/Core/logger.py,sha256=035II2YvRmcAvbbCEsmMxjvAJhdLvQlUqaDXAufWk_E,5782
-ErisPulse/Core/mods.py,sha256=5SPutuzbMrA-VZwiXeNxYWfrdbpLRdYfQ0RvEkFuQgg,7308
-ErisPulse/Core/raiserr.py,sha256=QLQ3r7p4iFP86XBLq9mtf1wv1xSlgny35i8t5-l4DXo,4620
-ErisPulse/Core/server.py,sha256=H8dUUj8mxBLEd3ick7btbWEE_m58Y6277Zo5FY7Ild4,9217
-ErisPulse/Core/shellprint.py,sha256=-BFoyFho_D3XEhxIoKt6x5gO4C62LKwmJWKDUGiPjNY,5908
-ErisPulse/Core/util.py,sha256=kyydBAJHHG9I7rMRzKWtLAQMZoJyBqHiBAweqcraFkU,4001
-erispulse-2.1.0.dist-info/METADATA,sha256=Ip9gteaaYMG0Qkzxq_DbFnmvCYNC8ULMPxCZ6jYimeA,6161
-erispulse-2.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-erispulse-2.1.0.dist-info/entry_points.txt,sha256=Jss71M6nEha0TA-DyVZugPYdcL14s9QpiOeIlgWxzOc,182
-erispulse-2.1.0.dist-info/licenses/LICENSE,sha256=lBYj7Nk4urLvByj4HvQFxu8j9hThhFF6OGfyxAZBP9Q,1451
-erispulse-2.1.0.dist-info/RECORD,,