ErisPulse 2.1.5__py3-none-any.whl → 2.1.7__py3-none-any.whl

ErisPulse/Core/mods.py

@@ -26,8 +26,8 @@ class ModuleManager:
     {!--< /tips >!--}
     """
     
-    DEFAULT_MODULE_PREFIX = "erispulse.module.data:"
-    DEFAULT_STATUS_PREFIX = "erispulse.module.status:"
+    DEFAULT_MODULE_PREFIX = "erispulse.data.modules.info:"
+    DEFAULT_STATUS_PREFIX = "erispulse.data.modules.status:"
 
     def __init__(self):
         from .env import env
@@ -75,12 +75,9 @@ class ModuleManager:
         >>> # 禁用模块
         >>> mods.set_module_status("MyModule", False)
         """
+        from .logger import logger
         self.env.set(f"{self.status_prefix}{module_name}", bool(status))
-
-        module_info = self.get_module(module_name)
-        if module_info:
-            module_info["status"] = bool(status)
-            self.env.set(f"{self.module_prefix}{module_name}", module_info)
+        logger.debug(f"模块 {module_name} 状态已设置为 {status}")
 
     def get_module_status(self, module_name: str) -> bool:
         """
@@ -95,7 +92,7 @@ class ModuleManager:
         """
         status = self.env.get(f"{self.status_prefix}{module_name}", True)
         if isinstance(status, str):
-            return status.lower() == 'true'
+            return status.lower() not in ('false', '0', 'no', 'off')
         return bool(status)
 
     def set_module(self, module_name: str, module_info: Dict[str, Any]) -> None:
@@ -109,11 +106,9 @@ class ModuleManager:
         >>> mods.set_module("MyModule", {
         >>>     "version": "1.0.0",
         >>>     "description": "我的模块",
-        >>>     "status": True
         >>> })
         """
         self.env.set(f"{self.module_prefix}{module_name}", module_info)
-        self.set_module_status(module_name, module_info.get('status', True))
 
     def get_module(self, module_name: str) -> Optional[Dict[str, Any]]:
         """
@@ -164,8 +159,6 @@ class ModuleManager:
                 module_name = key[prefix_len:]
                 module_info = self.get_module(module_name)
                 if module_info:
-                    status = self.get_module_status(module_name)
-                    module_info['status'] = bool(status)
                     modules_info[module_name] = module_info
         return modules_info
 

ErisPulse/__init__.py

@@ -27,9 +27,6 @@ from .Core import mods
 from .Core import adapter, AdapterFather, SendDSL
 from .Core import adapter_server
 
-# 确保windows下的shell能正确显示颜色
-os.system('')
-
 sdk = sys.modules[__name__]
 
 BaseModules = {
@@ -244,62 +241,47 @@ class AdapterLoader:
             
         :raises ImportError: 当适配器加载失败时抛出
         """
+        meta_name = entry_point.name
+        adapter_status = mods.get_module_status(meta_name)
+        logger.debug(f"适配器 {meta_name} 状态: {adapter_status}")
+        
+        if adapter_status is False:
+            disabled_adapters.append(meta_name)
+            logger.warning(f"适配器 {meta_name} 已禁用，跳过加载")
+            return adapter_objs, enabled_adapters, disabled_adapters
+            
         try:
-            loaded_obj = entry_point.load()
-            adapter_obj = sys.modules[loaded_obj.__module__]
+            loaded_class = entry_point.load()
+            adapter_obj = sys.modules[loaded_class.__module__]
             dist = importlib.metadata.distribution(entry_point.dist.name)
             
-            # 创建adapterInfo
             adapter_info = {
                 "meta": {
-                    "name": entry_point.name,
+                    "name": meta_name,
                     "version": getattr(adapter_obj, "__version__", dist.version if dist else "1.0.0"),
                     "description": getattr(adapter_obj, "__description__", ""),
                     "author": getattr(adapter_obj, "__author__", ""),
                     "license": getattr(adapter_obj, "__license__", ""),
                     "package": entry_point.dist.name
                 },
-                "adapter_class": loaded_obj
+                "adapter_class": loaded_class
             }
             
-            # 检查是否已经加载过这个适配器类
-            existing_instance = None
-            for existing_adapter in adapter_objs.values():
-                if hasattr(existing_adapter, 'adapterInfo'):
-                    for existing_adapter_info in existing_adapter.adapterInfo.values():
-                        if isinstance(existing_adapter_info, dict) and existing_adapter_info["adapter_class"] == loaded_obj:
-                            existing_instance = existing_adapter_info["adapter_class"]
-                            break
-            
-            # 如果已经存在实例，则复用
-            if existing_instance is not None:
-                adapter_info["adapter_class"] = existing_instance
-            
             if not hasattr(adapter_obj, 'adapterInfo'):
                 adapter_obj.adapterInfo = {}
                 
-            adapter_obj.adapterInfo[entry_point.name] = adapter_info
-            
-            # 检查适配器状态
-            meta_name = entry_point.name
-            stored_info = mods.get_module(meta_name) or {
-                "status": True,
-                "info": adapter_info
-            }
-            mods.set_module(meta_name, stored_info)
+            adapter_obj.adapterInfo[meta_name] = adapter_info
             
-            if not stored_info.get('status', True):
-                disabled_adapters.append(meta_name)
-                logger.warning(f"适配器 {meta_name} 已禁用，跳过加载")
-                return adapter_objs, enabled_adapters, disabled_adapters
+            # 存储适配器信息
+            mods.set_module(meta_name, adapter_info)
                 
             adapter_objs[meta_name] = adapter_obj
             enabled_adapters.append(meta_name)
-            logger.debug(f"从PyPI包加载适配器: {meta_name}")
+            logger.debug(f"从PyPI包发现适配器: {meta_name}")
             
         except Exception as e:
-            logger.warning(f"从entry-point加载适配器 {entry_point.name} 失败: {e}")
-            raise ImportError(f"无法加载适配器 {entry_point.name}: {e}")
+            logger.warning(f"从entry-point加载适配器 {meta_name} 失败: {e}")
+            raise ImportError(f"无法加载适配器 {meta_name}: {e}")
             
         return adapter_objs, enabled_adapters, disabled_adapters
 
@@ -374,18 +356,26 @@ class ModuleLoader:
             
         :raises ImportError: 当模块加载失败时抛出
         """
+        meta_name = entry_point.name
+        module_status = mods.get_module_status(meta_name)
+        logger.debug(f"模块 {meta_name} 状态: {module_status}")
+        
+        # 首先检查模块状态，如果明确为False则直接跳过
+        if module_status is False:
+            disabled_modules.append(meta_name)
+            logger.warning(f"模块 {meta_name} 已禁用，跳过加载")
+            return module_objs, enabled_modules, disabled_modules
+            
         try:
             loaded_obj = entry_point.load()
             module_obj = sys.modules[loaded_obj.__module__]
             dist = importlib.metadata.distribution(entry_point.dist.name)
             
-            # 从pyproject.toml读取加载策略
-            lazy_load = ModuleLoader._should_lazy_load(dist)
+            lazy_load = ModuleLoader._should_lazy_load(loaded_obj)
             
-            # 创建moduleInfo
             module_info = {
                 "meta": {
-                    "name": entry_point.name,
+                    "name": meta_name,
                     "version": getattr(module_obj, "__version__", dist.version if dist else "1.0.0"),
                     "description": getattr(module_obj, "__description__", ""),
                     "author": getattr(module_obj, "__author__", ""),
@@ -398,26 +388,16 @@ class ModuleLoader:
             
             module_obj.moduleInfo = module_info
             
-            # 检查模块状态
-            meta_name = entry_point.name
-            stored_info = mods.get_module(meta_name) or {
-                "status": True,
-                "info": module_info
-            }
-            mods.set_module(meta_name, stored_info)
-            
-            if not stored_info.get('status', True):
-                disabled_modules.append(meta_name)
-                logger.warning(f"模块 {meta_name} 已禁用，跳过加载")
-                return module_objs, enabled_modules, disabled_modules
+            # 存储模块信息
+            mods.set_module(meta_name, module_info)
                 
             module_objs[meta_name] = module_obj
             enabled_modules.append(meta_name)
             logger.debug(f"从PyPI包加载模块: {meta_name}")
             
         except Exception as e:
-            logger.warning(f"从entry-point加载模块 {entry_point.name} 失败: {e}")
-            raise ImportError(f"无法加载模块 {entry_point.name}: {e}")
+            logger.warning(f"从entry-point加载模块 {meta_name} 失败: {e}")
+            raise ImportError(f"无法加载模块 {meta_name}: {e}")
             
         return module_objs, enabled_modules, disabled_modules
     
@@ -512,7 +492,7 @@ class ModuleInitializer:
         
         :return: bool 模块初始化是否成功
         """
-        # 第一阶段：将所有模块挂载到LazyModule代理上
+        # 将所有模块挂载到LazyModule代理上
         for module_name in modules:
             module_obj = module_objs[module_name]
             meta_name = module_obj.moduleInfo["meta"]["name"]
@@ -544,7 +524,7 @@ class ModuleInitializer:
                 setattr(sdk, meta_name, None)
                 return False
         
-        # 第二阶段：检查并初始化需要立即加载的模块
+        # 检查并初始化需要立即加载的模块
         for module_name in modules:
             module_obj = module_objs[module_name]
             meta_name = module_obj.moduleInfo["meta"]["name"]
@@ -577,7 +557,6 @@ class ModuleInitializer:
                 return False
                 
         return True
-    
     @staticmethod
     def _register_adapters(adapters: List[str], adapter_objs: Dict[str, Any]) -> bool:
         """
@@ -590,9 +569,6 @@ class ModuleInitializer:
         :return: bool 适配器注册是否成功
         """
         success = True
-        # 存储平台名到适配器类的映射
-        platform_to_adapter = {}
-        # 存储已注册的适配器类到实例的映射
         registered_classes = {}
 
         for adapter_name in adapters:
@@ -601,28 +577,31 @@ class ModuleInitializer:
             try:
                 if hasattr(adapter_obj, "adapterInfo") and isinstance(adapter_obj.adapterInfo, dict):
                     for platform, adapter_info in adapter_obj.adapterInfo.items():
-                        # 如果这个平台已经注册过，跳过
-                        if platform in platform_to_adapter:
+                        if platform in sdk.adapter._adapters:
                             continue
                             
                         adapter_class = adapter_info["adapter_class"]
                         
-                        # 检查是否已经注册过这个适配器类
                         if adapter_class in registered_classes:
-                            # 获取已注册的实例
-                            existing_instance = registered_classes[adapter_class]
-                            # 将新平台名指向已有实例
-                            sdk.adapter._adapters[platform] = existing_instance
-                            sdk.adapter._platform_to_instance[platform] = existing_instance
+                            instance = registered_classes[adapter_class]
+                            # 改为直接操作适配器字典而不是调用register
+                            sdk.adapter._adapters[platform] = instance
+                            sdk.adapter._platform_to_instance[platform] = instance
+                            logger.debug(f"复用适配器实例 {adapter_class.__name__} 到平台别称 {platform}")
                         else:
-                            # 注册新适配器
-                            sdk.adapter.register(platform, adapter_class)
-                            # 记录已注册的类和实例
-                            registered_classes[adapter_class] = sdk.adapter._adapters[platform]
-                        
-                        # 记录平台到适配器的映射
-                        platform_to_adapter[platform] = adapter_class
-                        logger.info(f"注册适配器: {platform}")
+                            init_signature = inspect.signature(adapter_class.__init__)
+                            params = init_signature.parameters
+                            
+                            if 'sdk' in params:
+                                instance = adapter_class(sdk)
+                            else:
+                                instance = adapter_class()
+                            
+                            # 直接操作适配器字典
+                            sdk.adapter._adapters[platform] = instance
+                            sdk.adapter._platform_to_instance[platform] = instance
+                            registered_classes[adapter_class] = instance
+                            logger.info(f"注册适配器: {platform} ({adapter_class.__name__})")
             except Exception as e:
                 logger.error(f"适配器 {adapter_name} 注册失败: {e}")
                 success = False

ErisPulse/__main__.py

@@ -1,30 +1,3 @@
-"""
-# CLI 入口
-
-提供命令行界面(CLI)用于包管理和启动入口。
-
-## 主要命令
-### 包管理:
-    install: 安装模块/适配器包
-    uninstall: 卸载模块/适配器包
-    list: 列出已安装的模块/适配器
-    list-remote: 列出远程PyPI上的ErisPulse模块和适配器
-    upgrade: 升级所有模块/适配器
-
-### 启动:
-    run: 运行脚本
-    --reload: 启用热重载
-
-### 示例用法:
-```
-# 安装模块
-epsdk install Yunhu
-
-# 启用热重载
-epsdk run main.py --reload
-```
-"""
-
 import argparse
 import importlib.metadata
 import subprocess
@@ -38,21 +11,45 @@ from typing import List, Dict, Tuple, Optional
 from importlib.metadata import version, PackageNotFoundError
 from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler
-from .Core.shellprint import shellprint, Shell_Printer
+
+# Rich console setup
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.progress import Progress, BarColumn, TextColumn
+from rich.prompt import Confirm, Prompt
+from rich.text import Text
+from rich.box import SIMPLE, ROUNDED, DOUBLE
+from rich.style import Style
+from rich.theme import Theme
+from rich.layout import Layout
+from rich.live import Live
+
+# 确保在Windows上启用颜色
+import sys
+if sys.platform == "win32":
+    from colorama import init
+    init()
+
+theme = Theme({
+    "info": "cyan",
+    "success": "green",
+    "warning": "yellow",
+    "error": "red",
+    "title": "magenta",
+    "default": "default",
+    "progress": "green",
+    "progress.remaining": "white",
+})
+
+console = Console(theme=theme, color_system="auto", force_terminal=True)
 
 class PyPIManager:
     """
     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"
@@ -73,7 +70,6 @@ class PyPIManager:
         :raises ClientError: 当网络请求失败时抛出
         :raises asyncio.TimeoutError: 当请求超时时抛出
         """
-
         import aiohttp
         from aiohttp import ClientError, ClientTimeout
         
@@ -92,7 +88,11 @@ class PyPIManager:
                         }
         except (ClientError, asyncio.TimeoutError) as e:
             last_error = e
-            shellprint.panel(f"官方源请求失败，尝试备用源: {e}", "警告", "warning")
+            console.print(Panel(
+                f"官方源请求失败，尝试备用源: {e}",
+                title="警告",
+                style="warning"
+            ))
         
         try:
             async with aiohttp.ClientSession(timeout=timeout) as session:
@@ -108,7 +108,11 @@ class PyPIManager:
             last_error = e
             
         if last_error:
-            shellprint.panel(f"获取远程模块列表失败: {last_error}", "错误", "error")
+            console.print(Panel(
+                f"获取远程模块列表失败: {last_error}",
+                title="错误",
+                style="error"
+            ))
         return {"modules": {}, "adapters": {}}
     
     @staticmethod
@@ -145,33 +149,81 @@ class PyPIManager:
                                 "summary": dist.metadata["Summary"]
                             }
         except Exception as e:
-            shellprint.panel(f"获取已安装包信息失败: {e}", "错误", "error")
+            console.print(Panel(
+                f"获取已安装包信息失败: {e}",
+                title="错误",
+                style="error"
+            ))
         
         return packages
     
+    @staticmethod
+    def uv_install_package(package_name: str, upgrade: bool = False) -> bool:
+        """
+        优先使用uv安装包
+        
+        :param package_name: str 要安装的包名
+        :param upgrade: bool 是否升级已安装的包 (默认: False)
+        :return: bool 安装是否成功
+        """
+        try:
+            # 检查uv是否可用
+            uv_check = subprocess.run(["uv", "--version"], capture_output=True)
+            if uv_check.returncode != 0:
+                return False  # uv不可用
+            
+            cmd = ["uv", "pip", "install"]
+            if upgrade:
+                cmd.append("--upgrade")
+            cmd.append(package_name)
+            
+            with console.status(f"使用uv安装 {package_name}..."):
+                result = subprocess.run(cmd, check=True)
+                return result.returncode == 0
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+    
     @staticmethod
     def install_package(package_name: str, upgrade: bool = False) -> bool:
         """
-        安装指定包
+        安装指定包 (修改后优先尝试uv)
         
         :param package_name: str 要安装的包名
         :param upgrade: bool 是否升级已安装的包 (默认: False)
         :return: bool 安装是否成功
         """
+        # 优先尝试uv安装
+        if PyPIManager.uv_install_package(package_name, upgrade):
+            console.print(Panel(
+                f"包 {package_name} 安装成功 (使用uv)",
+                title="成功",
+                style="success"
+            ))
+            return True
+            
+        # 回退到pip安装
         try:
             cmd = [sys.executable, "-m", "pip", "install"]
             if upgrade:
                 cmd.append("--upgrade")
             cmd.append(package_name)
             
-            shellprint.status(f"正在安装 {package_name}...")
-            result = subprocess.run(cmd, check=True)
-            if result.returncode == 0:
-                shellprint.panel(f"包 {package_name} 安装成功", "成功", "success")
-                return True
-            return False
+            with console.status(f"使用pip安装 {package_name}..."):
+                result = subprocess.run(cmd, check=True)
+                if result.returncode == 0:
+                    console.print(Panel(
+                        f"包 {package_name} 安装成功",
+                        title="成功",
+                        style="success"
+                    ))
+                    return True
+                return False
         except subprocess.CalledProcessError as e:
-            shellprint.panel(f"安装包 {package_name} 失败: {e}", "错误", "error")
+            console.print(Panel(
+                f"安装包 {package_name} 失败: {e}",
+                title="错误",
+                style="error"
+            ))
             return False
     
     @staticmethod
@@ -183,17 +235,25 @@ class PyPIManager:
         :return: bool 卸载是否成功
         """
         try:
-            shellprint.status(f"正在卸载 {package_name}...")
-            result = subprocess.run(
-                [sys.executable, "-m", "pip", "uninstall", "-y", package_name],
-                check=True
-            )
-            if result.returncode == 0:
-                shellprint.panel(f"包 {package_name} 卸载成功", "成功", "success")
-                return True
-            return False
+            with console.status(f"正在卸载 {package_name}..."):
+                result = subprocess.run(
+                    [sys.executable, "-m", "pip", "uninstall", "-y", package_name],
+                    check=True
+                )
+                if result.returncode == 0:
+                    console.print(Panel(
+                        f"包 {package_name} 卸载成功",
+                        title="成功",
+                        style="success"
+                    ))
+                    return True
+                return False
         except subprocess.CalledProcessError as e:
-            shellprint.panel(f"卸载包 {package_name} 失败: {e}", "错误", "error")
+            console.print(Panel(
+                f"卸载包 {package_name} 失败: {e}",
+                title="错误",
+                style="error"
+            ))
             return False
     
     @staticmethod
@@ -202,11 +262,6 @@ class PyPIManager:
         升级所有已安装的ErisPulse包
         
         :return: bool 升级是否成功
-        
-        {!--< tips >!--}
-        1. 会先列出所有可升级的包
-        2. 需要用户确认才会执行升级
-        {!--< /tips >!--}
         """
         try:
             installed = PyPIManager.get_installed_packages()
@@ -217,17 +272,21 @@ class PyPIManager:
                     all_packages.add(pkg_info["package"])
             
             if not all_packages:
-                shellprint.panel("没有找到可升级的ErisPulse包", "提示", "info")
+                console.print(Panel(
+                    "没有找到可升级的ErisPulse包",
+                    title="提示",
+                    style="info"
+                ))
                 return False
                 
-            shellprint.panel(
+            console.print(Panel(
                 f"找到 {len(all_packages)} 个可升级的包:\n" + 
                 "\n".join(f"  - {pkg}" for pkg in all_packages),
-                "升级列表",
-                "info"
-            )
+                title="升级列表",
+                style="info"
+            ))
             
-            if not shellprint.confirm("确认升级所有包吗？", default=False):
+            if not Confirm.ask("确认升级所有包吗？", default=False):
                 return False
                 
             for pkg in all_packages:
@@ -235,7 +294,11 @@ class PyPIManager:
                 
             return True
         except Exception as e:
-            shellprint.panel(f"升级包失败: {e}", "错误", "error")
+            console.print(Panel(
+                f"升级包失败: {e}",
+                title="错误",
+                style="error"
+            ))
             return False
 
 class ReloadHandler(FileSystemEventHandler):
@@ -243,31 +306,24 @@ class ReloadHandler(FileSystemEventHandler):
     热重载处理器
     
     监控文件变化并自动重启脚本
-
-    {!--< tips >!--}
-    1. 基于watchdog实现文件监控
-    2. 有1秒的防抖延迟
-    3. 会终止旧进程并启动新进程
-    {!--< /tips >!--}
     """
-    def __init__(self, script_path, *args, **kwargs):
+    def __init__(self, script_path, reload_mode=False, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.script_path = script_path
         self.process = None
         self.last_reload = time.time()
+        self.reload_mode = reload_mode
         self.start_process()
 
     def start_process(self):
         """
         启动/重启被监控的进程
-        
-        {!--< internal-use >!--}
         """
         if self.process:
             self.process.terminate()
             self.process.wait()
             
-        shellprint.status(f"启动进程: {self.script_path}")
+        console.print(f"[bold green]启动进程:[/] {self.script_path}")
         self.process = subprocess.Popen([sys.executable, self.script_path])
         self.last_reload = time.time()
 
@@ -281,68 +337,67 @@ class ReloadHandler(FileSystemEventHandler):
         if now - self.last_reload < 1.0:
             return
             
-        if event.src_path.endswith(".py"):
-            print(f"\n{Shell_Printer.CYAN}[热重载] 检测到文件变动: {event.src_path}{Shell_Printer.RESET}")
+        if event.src_path.endswith(".py") and self.reload_mode:
+            console.print(f"\n[cyan][热重载] 文件发生变动: {event.src_path}[/]")
+            self.start_process()
+        elif event.src_path.endswith("config.toml"):
+            console.print(f"\n[cyan][热重载] 配置发生变动: {event.src_path}[/]")
             self.start_process()
 
-def start_reloader(script_path):
+def start_reloader(script_path, reload_mode=False):
     """
     启动热重载监控
     
     :param script_path: str 要监控的脚本路径
-    
-    {!--< tips >!--}
-    1. 监控脚本所在目录和modules目录
-    2. 按Ctrl+C可停止监控
-    {!--< /tips >!--}
+    :param reload_mode: bool 是否启用完整重载模式 (默认: False)
     """
-    project_root = os.path.dirname(os.path.abspath(__file__))
+    if not os.path.exists(script_path):
+        console.print(Panel(
+            f"找不到指定文件: {script_path}",
+            title="错误",
+            style="error"
+        ))
+        return
     watch_dirs = [
         os.path.dirname(os.path.abspath(script_path)),
-        os.path.join(project_root, "modules")
     ]
 
-    handler = ReloadHandler(script_path)
+    handler = ReloadHandler(script_path, reload_mode)
     observer = Observer()
 
     for d in watch_dirs:
         if os.path.exists(d):
-            observer.schedule(handler, d, recursive=True)
+            if reload_mode:
+                # 完整重载模式：监控所有.py文件
+                observer.schedule(handler, d, recursive=True)
+            else:
+                # 普通模式：只监控config.toml
+                observer.schedule(handler, d, recursive=False)
 
     observer.start()
-    print(f"\n{Shell_Printer.GREEN}{Shell_Printer.BOLD}[热重载] 已启动{Shell_Printer.RESET}")
-    print(f"{Shell_Printer.DIM}监控目录: {', '.join(watch_dirs)}{Shell_Printer.RESET}\n")
+    console.print("\n[bold green][热重载] 已启动[/]")
+    mode_desc = "开发重载模式" if reload_mode else "配置监控模式"
+    console.print(f"[dim]模式: {mode_desc}\n监控目录: {', '.join(watch_dirs)}[/]\n")
     try:
+        first_interrupt = True
         while True:
             time.sleep(1)
     except KeyboardInterrupt:
-        observer.stop()
-        if handler.process:
-            handler.process.terminate()
-    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
-
-    if reload:
-        start_reloader(script_path)
-    else:
-        shellprint.panel(f"运行脚本: {Shell_Printer.BOLD}{script_path}{Shell_Printer.RESET}", "执行", "info")
-        import runpy
-        try:
-            runpy.run_path(script_path, run_name="__main__")
-        except KeyboardInterrupt:
-            shellprint.panel("脚本执行已中断", "中断", "info")
+        if first_interrupt:
+            first_interrupt = False
+            console.print("\n[bold green]正在安全关闭热重载...[/]")
+            console.print("[bold red]再次按下Ctrl+C以强制关闭[/]")
+            try:
+                observer.stop()
+                if handler.process:
+                    handler.process.terminate()
+                observer.join()
+            except KeyboardInterrupt:
+                console.print("[bold red]强制关闭热重载[/]")
+                raise
+        else:
+            console.print(Panel("[bold red]强制关闭热重载[/]"))
+            raise
 
 def get_erispulse_version():
     """
@@ -360,31 +415,46 @@ def main():
     CLI主入口
     
     解析命令行参数并执行相应命令
-    
-    {!--< tips >!--}
-    1. 使用argparse处理命令行参数
-    2. 支持彩色输出和表格显示
-    3. 提供详细的错误处理
-    {!--< /tips >!--}
     """
     
     parser = argparse.ArgumentParser(
         prog="epsdk",
         formatter_class=argparse.RawTextHelpFormatter,
-        description=f"{Shell_Printer.BOLD}ErisPulse SDK 命令行工具 {get_erispulse_version()}{Shell_Printer.RESET}"
+        description=f"ErisPulse SDK 命令行工具 {get_erispulse_version()}"
     )
-    parser._positionals.title = f"{Shell_Printer.BOLD}{Shell_Printer.CYAN}基本命令{Shell_Printer.RESET}"
-    parser._optionals.title = f"{Shell_Printer.BOLD}{Shell_Printer.MAGENTA}可选参数{Shell_Printer.RESET}"
+    parser._positionals.title = "基本"
+    parser._optionals.title = "可选"
     
-    parser.add_argument("--version", action="store_true", help="显示版本信息并退出")
+    parser.add_argument("--version", action="store_true", help="显示版本信息")
     
     subparsers = parser.add_subparsers(
         dest='command', 
-        title='可用的命令',
-        metavar=f"{Shell_Printer.GREEN}<命令>{Shell_Printer.RESET}",
-        help='具体命令的帮助信息'
+        metavar="<命令>",
     )
 
+    # 在main()函数中修改第三方命令加载部分
+    try:
+        entry_points = importlib.metadata.entry_points()
+        if hasattr(entry_points, 'select'):
+            cli_entries = entry_points.select(group='erispulse.cli')
+        else:
+            cli_entries = entry_points.get('erispulse.cli', [])
+        
+        for entry in cli_entries:
+            try:
+                cli_func = entry.load()
+                if callable(cli_func):
+                    # 直接调用函数并传入subparsers和console
+                    cli_func(subparsers, console)
+                else:
+                    console.print(f"[yellow]模块 {entry.name} 的入口点不是可调用对象[/]")
+            except Exception as e:
+                console.print(f"[red]加载第三方命令 {entry.name} 失败: {e}[/]")
+                import traceback
+                console.print(traceback.format_exc())
+    except Exception as e:
+        console.print(f"[yellow]加载第三方CLI命令失败: {e}[/]", style="warning")
+
     # 安装命令
     install_parser = subparsers.add_parser('install', help='安装模块/适配器包')
     install_parser.add_argument('package', type=str, help='要安装的包名')
@@ -394,6 +464,14 @@ def main():
     uninstall_parser = subparsers.add_parser('uninstall', help='卸载模块/适配器包')
     uninstall_parser.add_argument('package', type=str, help='要卸载的包名')
     
+    # 启用命令
+    enable_parser = subparsers.add_parser('enable', help='启用模块')
+    enable_parser.add_argument('module', type=str, help='要启用的模块名')
+
+    # 禁用命令
+    disable_parser = subparsers.add_parser('disable', help='禁用模块')
+    disable_parser.add_argument('module', type=str, help='要禁用的模块名')
+
     # 列表命令
     list_parser = subparsers.add_parser('list', help='列出已安装的模块/适配器')
     list_parser.add_argument('--type', '-t', choices=['modules', 'adapters', 'all'], default='all', 
@@ -411,18 +489,19 @@ def main():
     run_parser = subparsers.add_parser('run', help='运行指定主程序')
     run_parser.add_argument('script', type=str, help='要运行的主程序路径')
     run_parser.add_argument('--reload', action='store_true', help='启用热重载模式')
-
+    
     args = parser.parse_args()
     
     if args.version:
-        print(f"{Shell_Printer.GREEN}ErisPulse {get_erispulse_version()}{Shell_Printer.RESET}")
+        console.print(f"[green]ErisPulse {get_erispulse_version()}[/]")
         return
         
     if not args.command:
         parser.print_help()
-        return
     
     try:
+        if hasattr(args, 'func'):
+            args.func(args)
         if args.command == "install":
             import asyncio
             # 首先检查是否是远程模块/适配器的简称
@@ -438,11 +517,11 @@ def main():
             
             # 如果找到远程包，使用完整包名安装
             if full_package_name:
-                shellprint.panel(
-                    f"找到远程包: {Shell_Printer.BOLD}{args.package}{Shell_Printer.RESET} → {Shell_Printer.BLUE}{full_package_name}{Shell_Printer.RESET}",
-                    "信息",
-                    "info"
-                )
+                console.print(Panel(
+                    f"找到远程包: [bold]{args.package}[/] → [blue]{full_package_name}[/]",
+                    title="信息",
+                    style="info"
+                ))
                 PyPIManager.install_package(full_package_name, args.upgrade)
             else:
                 # 否则按原样安装
@@ -450,77 +529,132 @@ def main():
             
         elif args.command == "uninstall":
             PyPIManager.uninstall_package(args.package)
-            
+
+        elif args.command == "enable":
+            from ErisPulse.Core import mods
+            installed = PyPIManager.get_installed_packages()
+            if args.module not in installed["modules"]:
+                console.print(Panel(
+                    f"模块 [red]{args.module}[/] 不存在或未安装",
+                    title="错误",
+                    style="error"
+                ))
+            else:
+                mods.set_module_status(args.module, True)
+                console.print(Panel(
+                    f"模块 [green]{args.module}[/] 已启用",
+                    title="成功",
+                    style="success"
+                ))
+                
+        elif args.command == "disable":
+            from ErisPulse.Core import mods
+            installed = PyPIManager.get_installed_packages()
+            if args.module not in installed["modules"]:
+                console.print(Panel(
+                    f"模块 [red]{args.module}[/] 不存在或未安装",
+                    title="错误",
+                    style="error"
+                ))
+            else:
+                mods.set_module_status(args.module, False)
+                console.print(Panel(
+                    f"模块 [yellow]{args.module}[/] 已禁用",
+                    title="成功",
+                    style="warning"
+                ))
+                
         elif args.command == "list":
             installed = PyPIManager.get_installed_packages()
             
             if args.type in ["modules", "all"] and installed["modules"]:
-                rows = [
-                    [
-                        f"{Shell_Printer.GREEN}{name}{Shell_Printer.RESET}",
-                        f"{Shell_Printer.BLUE}{info['package']}{Shell_Printer.RESET}",
-                        info["version"],
-                        info["summary"]
-                    ] for name, info in installed["modules"].items()
-                ]
-                shellprint.table(["模块名", "包名", "版本", "描述"], rows, "已安装模块", "info")
+                table = Table(title="已安装模块", box=SIMPLE)
+                table.add_column("模块名", style="green")
+                table.add_column("包名", style="blue")
+                table.add_column("版本")
+                table.add_column("描述")
+                
+                for name, info in installed["modules"].items():
+                    table.add_row(name, info["package"], info["version"], info["summary"])
+                
+                console.print(table)
                 
             if args.type in ["adapters", "all"] and installed["adapters"]:
-                rows = [
-                    [
-                        f"{Shell_Printer.YELLOW}{name}{Shell_Printer.RESET}",
-                        f"{Shell_Printer.BLUE}{info['package']}{Shell_Printer.RESET}",
-                        info["version"],
-                        info["summary"]
-                    ] for name, info in installed["adapters"].items()
-                ]
-                shellprint.table(["适配器名", "包名", "版本", "描述"], rows, "已安装适配器", "info")
+                table = Table(title="已安装适配器", box=SIMPLE)
+                table.add_column("适配器名", style="yellow")
+                table.add_column("包名", style="blue")
+                table.add_column("版本")
+                table.add_column("描述")
+                
+                for name, info in installed["adapters"].items():
+                    table.add_row(name, info["package"], info["version"], info["summary"])
+                
+                console.print(table)
                 
             if not installed["modules"] and not installed["adapters"]:
-                shellprint.panel("没有安装任何ErisPulse模块或适配器", "提示", "info")
+                console.print(Panel(
+                    "没有安装任何ErisPulse模块或适配器",
+                    title="提示",
+                    style="info"
+                ))
                 
         elif args.command == "upgrade":
-            if args.force or shellprint.confirm("确定要升级所有ErisPulse模块和适配器吗？", default=False):
+            if args.force or Confirm.ask("确定要升级所有ErisPulse模块和适配器吗？", default=False):
                 PyPIManager.upgrade_all()
                 
         elif args.command == "run":
-            run_script(args.script, args.reload)
-            
+            start_reloader(args.script, args.reload)
         elif args.command == "list-remote":
             import asyncio
             try:
                 remote_packages = asyncio.run(PyPIManager.get_remote_packages())
                 
                 if args.type in ["modules", "all"] and remote_packages["modules"]:
-                    rows = [
-                        [
-                            f"{Shell_Printer.GREEN}{name}{Shell_Printer.RESET}",
-                            f"{Shell_Printer.BLUE}{info['package']}{Shell_Printer.RESET}",
-                            info["version"],
-                            info["description"]
-                        ] for name, info in remote_packages["modules"].items()
-                    ]
-                    shellprint.table(["模块名", "包名", "版本", "描述"], rows, "远程模块", "info")
+                    table = Table(title="远程模块", box=SIMPLE)
+                    table.add_column("模块名", style="green")
+                    table.add_column("包名", style="blue")
+                    table.add_column("版本")
+                    table.add_column("描述")
+                    
+                    for name, info in remote_packages["modules"].items():
+                        table.add_row(name, info["package"], info["version"], info["description"])
+                    
+                    console.print(table)
                     
                 if args.type in ["adapters", "all"] and remote_packages["adapters"]:
-                    rows = [
-                        [
-                            f"{Shell_Printer.YELLOW}{name}{Shell_Printer.RESET}",
-                            f"{Shell_Printer.BLUE}{info['package']}{Shell_Printer.RESET}",
-                            info["version"],
-                            info["description"]
-                        ] for name, info in remote_packages["adapters"].items()
-                    ]
-                    shellprint.table(["适配器名", "包名", "版本", "描述"], rows, "远程适配器", "info")
+                    table = Table(title="远程适配器", box=SIMPLE)
+                    table.add_column("适配器名", style="yellow")
+                    table.add_column("包名", style="blue")
+                    table.add_column("版本")
+                    table.add_column("描述")
+                    
+                    for name, info in remote_packages["adapters"].items():
+                        table.add_row(name, info["package"], info["version"], info["description"])
+                    
+                    console.print(table)
                     
                 if not remote_packages["modules"] and not remote_packages["adapters"]:
-                    shellprint.panel("没有找到远程模块或适配器", "提示", "info")
+                    console.print(Panel(
+                        "没有找到远程模块或适配器",
+                        title="提示",
+                        style="info"
+                    ))
                     
             except Exception as e:
-                shellprint.panel(f"获取远程列表失败: {e}", "错误", "error")
-
+                console.print(Panel(
+                    f"获取远程列表失败: {e}",
+                    title="错误",
+                    style="error"
+                ))
+        
+    except KeyboardInterrupt as e:
+        pass
     except Exception as e:
-        shellprint.panel(f"执行命令时出错: {e}", "错误", "error")
+        console.print(Panel(
+            f"执行命令时出错: {e}",
+            title="错误",
+            style="error"
+        ))
 
 if __name__ == "__main__":
     main()

{erispulse-2.1.5.dist-info → erispulse-2.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ErisPulse
-Version: 2.1.5
+Version: 2.1.7
 Summary: ErisPulse 是一个模块化、可扩展的异步 Python SDK 框架，主要用于构建高效、可维护的机器人应用程序。
 Author-email: "艾莉丝·格雷拉特(WSu2059)" <wsu2059@qq.com>, runoneall <runoobsteve@gmail.com>
 License: MIT License
@@ -49,11 +49,14 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Requires-Dist: aiohttp
+Requires-Dist: colorama
 Requires-Dist: fastapi>=0.116.1
 Requires-Dist: hypercorn>=0.14.0
+Requires-Dist: keyboard
 Requires-Dist: pip
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: python-multipart>=0.0.20
+Requires-Dist: rich
 Requires-Dist: toml
 Requires-Dist: watchdog
 Description-Content-Type: text/markdown

{erispulse-2.1.5.dist-info → erispulse-2.1.7.dist-info}/RECORD

@@ -1,16 +1,15 @@
-ErisPulse/__init__.py,sha256=hsgvpT1GTBvjHpUlGSljVzuTwGgtlraQ4WnLMUFm5EM,27013
-ErisPulse/__main__.py,sha256=qqx1F8bPRKhjalKVapI3RtLupHuLlYPRk503oduYADY,19947
+ErisPulse/__init__.py,sha256=T-N56UQyBmpvlqwH2wGi5ptPzaJpbgF5tKkJt0DlkaM,26099
+ErisPulse/__main__.py,sha256=QwHMu8lmWbjS3EyOYV-wea3I0xcGmH_McWNx7JSGwts,24853
 ErisPulse/Core/__init__.py,sha256=XnQFMn4HMKzxa6KHJEvOpwt0v8jp21vAbw6aG0O8sPs,722
 ErisPulse/Core/adapter.py,sha256=lw5T336EsNtjUgSPdevcOZReZNkA8oYvvTRCHk_fo_o,18149
 ErisPulse/Core/env.py,sha256=D2BwtSbKggbeAsOzwwVv-kd5UkVmYlDUHtgLzFZqKUI,19841
 ErisPulse/Core/logger.py,sha256=VYhWKPXn88ib7S_OKCr_MibdnMH8k5sHkwLtNDZP3QM,7034
-ErisPulse/Core/mods.py,sha256=5SPutuzbMrA-VZwiXeNxYWfrdbpLRdYfQ0RvEkFuQgg,7308
+ErisPulse/Core/mods.py,sha256=2yIq8t9Ca9CBPRiZU0yr8Lc0XGmmkB7LlH-5FWqXjw4,7023
 ErisPulse/Core/raiserr.py,sha256=TQCKbYrfqu8tjX7dJiJemK0lZCQ4-5875nUGXgb8HUk,5606
 ErisPulse/Core/server.py,sha256=FkDTeLuHD5IBnWVxvYU8pHb6yCt8GzyvC1bpOiJ7G7I,9217
-ErisPulse/Core/shellprint.py,sha256=-BFoyFho_D3XEhxIoKt6x5gO4C62LKwmJWKDUGiPjNY,5908
 ErisPulse/Core/util.py,sha256=7rdMmn6sBFqYd4znxBCcJjuv2eyTExdeKyZopgds868,3796
-erispulse-2.1.5.dist-info/METADATA,sha256=9R7jlHvOoAtXb7irzBiubt-Yub3ynOVvQGzw2MtDy0U,6190
-erispulse-2.1.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-erispulse-2.1.5.dist-info/entry_points.txt,sha256=Jss71M6nEha0TA-DyVZugPYdcL14s9QpiOeIlgWxzOc,182
-erispulse-2.1.5.dist-info/licenses/LICENSE,sha256=4jyqikiB0G0n06CEEMMTzTXjE4IShghSlB74skMSPQs,1464
-erispulse-2.1.5.dist-info/RECORD,,
+erispulse-2.1.7.dist-info/METADATA,sha256=4xIp6y-QyDEaC13715lWFeEYK2D965Ij1EuToHiJ37U,6258
+erispulse-2.1.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+erispulse-2.1.7.dist-info/entry_points.txt,sha256=Jss71M6nEha0TA-DyVZugPYdcL14s9QpiOeIlgWxzOc,182
+erispulse-2.1.7.dist-info/licenses/LICENSE,sha256=4jyqikiB0G0n06CEEMMTzTXjE4IShghSlB74skMSPQs,1464
+erispulse-2.1.7.dist-info/RECORD,,

ErisPulse/Core/shellprint.py

@@ -1,165 +0,0 @@
-import sys
-
-class Shell_Printer:
-    # ANSI 颜色代码
-    RESET = "\033[0m"
-    BOLD = "\033[1m"
-    RED = "\033[91m"
-    GREEN = "\033[92m"
-    YELLOW = "\033[93m"
-    BLUE = "\033[94m"
-    MAGENTA = "\033[95m"
-    CYAN = "\033[96m"
-    WHITE = "\033[97m"
-    DIM = "\033[2m"
-    UNDERLINE = "\033[4m"
-    BG_BLUE = "\033[44m"
-    BG_GREEN = "\033[42m"
-    BG_YELLOW = "\033[43m"
-    BG_RED = "\033[41m"
-
-    def __init__(self):
-        pass
-
-    @classmethod
-    def _get_color(cls, level):
-        return {
-            "info": cls.CYAN,
-            "success": cls.GREEN,
-            "warning": cls.YELLOW,
-            "error": cls.RED,
-            "title": cls.MAGENTA,
-            "default": cls.RESET,
-        }.get(level, cls.RESET)
-
-    @classmethod
-    def panel(cls, msg: str, title: str = None, level: str = "info") -> None:
-        color = cls._get_color(level)
-        width = 70
-        border_char = "─" * width
-        
-        if level == "error":
-            border_char = "═" * width
-            msg = f"{cls.RED}✗ {msg}{cls.RESET}"
-        elif level == "warning":
-            border_char = "─" * width
-            msg = f"{cls.YELLOW}⚠ {msg}{cls.RESET}"
-        
-        title_line = ""
-        if title:
-            title = f" {title.upper()} "
-            title_padding = (width - len(title)) // 2
-            left_pad = " " * title_padding
-            right_pad = " " * (width - len(title) - title_padding)
-            title_line = f"{cls.DIM}┌{left_pad}{cls.BOLD}{color}{title}{cls.RESET}{cls.DIM}{right_pad}┐{cls.RESET}\n"
-        
-        lines = []
-        for line in msg.split("\n"):
-            if len(line) > width - 4:
-                words = line.split()
-                current_line = ""
-                for word in words:
-                    if len(current_line) + len(word) + 1 > width - 4:
-                        lines.append(f"{cls.DIM}│{cls.RESET} {current_line.ljust(width-4)} {cls.DIM}│{cls.RESET}")
-                        current_line = word
-                    else:
-                        current_line += (" " + word) if current_line else word
-                if current_line:
-                    lines.append(f"{cls.DIM}│{cls.RESET} {current_line.ljust(width-4)} {cls.DIM}│{cls.RESET}")
-            else:
-                lines.append(f"{cls.DIM}│{cls.RESET} {line.ljust(width-4)} {cls.DIM}│{cls.RESET}")
-        
-        if level == "error":
-            border_style = "╘"
-        elif level == "warning":
-            border_style = "╧"
-        else:
-            border_style = "└"
-        bottom_border = f"{cls.DIM}{border_style}{border_char}┘{cls.RESET}"
-        
-        panel = f"{title_line}"
-        panel += f"{cls.DIM}├{border_char}┤{cls.RESET}\n"
-        panel += "\n".join(lines) + "\n"
-        panel += f"{bottom_border}\n"
-        
-        print(panel)
-
-    @classmethod
-    def table(cls, headers, rows, title=None, level="info") -> None:
-        color = cls._get_color(level)
-        if title:
-            print(f"{cls.BOLD}{color}== {title} =={cls.RESET}")
-        
-        col_widths = [len(h) for h in headers]
-        for row in rows:
-            for i, cell in enumerate(row):
-                col_widths[i] = max(col_widths[i], len(str(cell)))
-        
-        fmt = "│".join(f" {{:<{w}}} " for w in col_widths)
-        
-        top_border = "┌" + "┬".join("─" * (w+2) for w in col_widths) + "┐"
-        print(f"{cls.DIM}{top_border}{cls.RESET}")
-        
-        header_line = fmt.format(*headers)
-        print(f"{cls.BOLD}{color}│{header_line}│{cls.RESET}")
-        
-        separator = "├" + "┼".join("─" * (w+2) for w in col_widths) + "┤"
-        print(f"{cls.DIM}{separator}{cls.RESET}")
-        
-        for row in rows:
-            row_line = fmt.format(*row)
-            print(f"│{row_line}│")
-        
-        bottom_border = "└" + "┴".join("─" * (w+2) for w in col_widths) + "┘"
-        print(f"{cls.DIM}{bottom_border}{cls.RESET}")
-
-    @classmethod
-    def progress_bar(cls, current, total, prefix="", suffix="", length=50):
-        filled_length = int(length * current // total)
-        percent = min(100.0, 100 * (current / float(total)))
-        bar = f"{cls.GREEN}{'█' * filled_length}{cls.WHITE}{'░' * (length - filled_length)}{cls.RESET}"
-        sys.stdout.write(f"\r{cls.BOLD}{prefix}{cls.RESET} {bar} {cls.BOLD}{percent:.1f}%{cls.RESET} {suffix}")
-        sys.stdout.flush()
-        if current == total:
-            print()
-
-    @classmethod
-    def confirm(cls, msg, default=False) -> bool:
-        yes_options = {'y', 'yes'}
-        no_options = {'n', 'no'}
-        default_str = "Y/n" if default else "y/N"
-        prompt = f"{cls.BOLD}{msg}{cls.RESET} [{cls.CYAN}{default_str}{cls.RESET}]: "
-        
-        while True:
-            ans = input(prompt).strip().lower()
-            if not ans:
-                return default
-            if ans in yes_options:
-                return True
-            if ans in no_options:
-                return False
-            print(f"{cls.YELLOW}请输入 'y' 或 'n'{cls.RESET}")
-
-    @classmethod
-    def ask(cls, msg, choices=None, default="") -> str:
-        prompt = f"{cls.BOLD}{msg}{cls.RESET}"
-        if choices:
-            prompt += f" ({cls.CYAN}{'/'.join(choices)}{cls.RESET})"
-        if default:
-            prompt += f" [{cls.BLUE}默认: {default}{cls.RESET}]"
-        prompt += ": "
-        
-        while True:
-            ans = input(prompt).strip()
-            if not ans and default:
-                return default
-            if not choices or ans in choices:
-                return ans
-            print(f"{cls.YELLOW}请输入有效选项: {', '.join(choices)}{cls.RESET}")
-
-    @classmethod
-    def status(cls, msg, success=True):
-        symbol = f"{cls.GREEN}✓" if success else f"{cls.RED}✗"
-        print(f"\r{symbol}{cls.RESET} {msg}")
-
-shellprint = Shell_Printer()