ErisPulse 2.4.2.dev0__py3-none-any.whl → 2.4.3.dev0__py3-none-any.whl

ErisPulse/CLI/commands/run.py

@@ -1,14 +1,12 @@
 """
 Run 命令实现
 
-运行主程序
+直接运行主程序，支持热重载模式
 """
 
 import os
 import time
-import sys
-import subprocess
-import tempfile
+import asyncio
 from argparse import ArgumentParser
 from watchdog.observers import Observer
 from rich.panel import Panel
@@ -22,127 +20,38 @@ class ReloadHandler(FileSystemEventHandler):
     """
     文件系统事件处理器
     
-    实现热重载功能，监控 .py 文件变更并自动重启
-    
+    监控 .py 文件变更并触发 sdk.restart() 热重载
+
     {!--< tips >!--}
-    1. 仅在 --reload 模式下启用监控
-    2. 监控 .py 文件，修改后创建清理信号文件并重启
-    3. 子进程检测到清理信号文件后自动调用 sdk.uninit()
-    4. 进程终止时使用清理信号文件确保资源正确释放
+    1. 文件监控运行在独立线程
+    2. 通过 run_coroutine_threadsafe 安全调度到事件循环
+    3. 内置 1 秒防抖，避免短时间内多次重载
     {!--< /tips >!--}
     """
 
-    def __init__(self, script_path: str, reload_mode: bool = False):
-        """
-        初始化处理器
-        
-        :param script_path: [str] 要监控的脚本路径
-        :param reload_mode: [bool] 是否启用重载模式 (默认: False)
-        """
+    def __init__(self, loop: asyncio.AbstractEventLoop):
         super().__init__()
-        self.script_path = os.path.abspath(script_path)
-        self.process = None
-        self.last_reload = time.time()
-        self.reload_mode = reload_mode
-        # 清理信号文件
-        self.cleanup_file = os.path.join(
-            tempfile.gettempdir(),
-            f"erispulse_cleanup_{os.getpid()}.signal"
-        )
-        self.start_process()
-
-    def start_process(self):
-        """
-        启动监控进程
-        
-        注入环境变量，让子进程知道自己是由 CLI 启动的
-        """
-        if self.process:
-            self._terminate_process()
-        
-        console.print(f"[bold]启动进程: [path]{self.script_path}[/][/]") 
-        env = os.environ.copy()
-        env['ERISPULSE_SUBPROCESS'] = 'true'
-        env['ERISPULSE_CLEANUP_FILE'] = self.cleanup_file
-        
-        self.process = subprocess.Popen(
-            [sys.executable, self.script_path],
-            stdin=sys.stdin,
-            stdout=sys.stdout,
-            stderr=sys.stderr,
-            env=env
-        )
-        self.last_reload = time.time()
-
-    def _terminate_process(self):
-        """
-        终止当前进程
-        
-        创建清理信号文件，通知子进程执行清理操作
-        等待最多 10 秒让进程正常退出
-        """
-        try:
-            # console.print(f"[dim]正在终止进程 (PID: {self.process.pid})[/]")
-            console.print(f"[dim]正在终止进程[/]")
-
-            # 创建清理信号文件
-            try:
-                with open(self.cleanup_file, 'w') as f:
-                    f.write('cleanup')
-                # console.print(f"[dim]已创建清理信号文件: {self.cleanup_file}[/]")
-            except Exception as e:
-                console.print(f"[warning]创建清理信号文件失败: {e}[/]")
-            
-            # 等待子进程开始清理
-            time.sleep(0.5)
-            
-            # 终止进程
-            self.process.terminate()
-            
-            # 等待进程退出
-            returncode = self.process.wait(timeout=10)
-            console.print(f"[dim]进程已退出[/]")
-            
-            # 清理信号文件
-            try:
-                if os.path.exists(self.cleanup_file):
-                    os.remove(self.cleanup_file)
-            except Exception:
-                pass
-        except subprocess.TimeoutExpired:
-            console.print("[warning]进程未在10秒内正常退出，强制终止[/]")
-            self.process.kill()
-            self.process.wait()
-        except Exception as e:
-            console.print(f"[error]终止进程时出错: {e}[/]")
+        self._loop = loop
+        self._last_reload = 0.0
 
     def on_modified(self, event):
-        """
-        文件修改事件处理
-        
-        仅在 --reload 模式下监控 .py 文件变更
-        
-        :param event: [FileSystemEvent] 文件系统事件
-        """
         now = time.time()
-        if now - self.last_reload < 1.0:  # 防抖
+        if now - self._last_reload < 1.0:
             return
-            
-        if event.src_path.endswith(".py") and self.reload_mode:
-            self._handle_reload(event, "文件变动")
+        if event.src_path.endswith(".py"):
+            self._last_reload = now
+            self._schedule_reload(event)
 
-    def _handle_reload(self, event, reason: str):
-        """
-        处理热重载逻辑
-        
-        创建清理信号文件，通知子进程执行清理，然后重启进程
-        
-        :param event: [FileSystemEvent] 文件系统事件
-        :param reason: [str] 重载原因
-        """
-        console.print(f"检测到文件变更 ({reason})，正在重启...")
-        self._terminate_process()
-        self.start_process()
+    def _schedule_reload(self, event):
+        async def _do_reload():
+            try:
+                from ... import sdk
+                await sdk.restart()
+            except Exception as e:
+                console.print(f"[error]热重载失败: {e}[/]")
+
+        console.print(f"检测到文件变更 ({os.path.basename(event.src_path)})，正在热重载...")
+        asyncio.run_coroutine_threadsafe(_do_reload(), self._loop)
 
 
 class RunCommand(Command):
@@ -156,16 +65,11 @@ class RunCommand(Command):
     description = "运行主程序"
     
     def add_arguments(self, parser: ArgumentParser):
-        """
-        添加命令行参数
-        
-        :param parser: [ArgumentParser] 参数解析器
-        """
         parser.add_argument(
             'script',
             nargs='?',
-            default='main.py',
-            help='要运行的主程序路径 (默认: main.py)'
+            default=None,
+            help='要运行的主程序路径 (不指定则直接运行 SDK)'
         )
         parser.add_argument(
             '--reload',
@@ -175,78 +79,74 @@ class RunCommand(Command):
         )
     
     def execute(self, args):
-        """
-        执行命令
-        
-        :param args: [Namespace] 命令行参数
-        """
         script = args.script
         reload_mode = args.reload
         
-        # 检查脚本是否存在
-        if not os.path.exists(script):
-            console.print(f"[info]脚本 [path]{script}[/] 不存在，正在创建...[/]")
-            from ... import _prepare_environment
-            import asyncio
-            asyncio.run(_prepare_environment(script))
-        
-        # 设置文件监控
-        self.observer = Observer()
-        self.handler = ReloadHandler(script, reload_mode)
-        self._setup_watchdog(script, reload_mode)
-        
-        try:
-            while True:
-                time.sleep(0.5)
-        except KeyboardInterrupt:
-            self._cleanup()
-    
-    def _setup_watchdog(self, script_path: str, reload_mode: bool) -> list:
+        if script:
+            if not os.path.exists(script):
+                console.print(f"[error]脚本 [path]{script}[/] 不存在[/]")
+                console.print("[info]使用 [cyan]epsdk init[/cyan] 创建新项目[/]")
+                return
+            self._run_script(script, reload_mode)
+        else:
+            self._run_internal(reload_mode)
+
+    def _run_internal(self, reload_mode: bool):
         """
-        设置文件监控
-        
-        :param script_path: [str] 要监控的脚本路径
-        :param reload_mode: [bool] 是否启用重载模式
-        :return: [list] 监控的目录列表
+        直接运行 SDK（不指定脚本时）
         """
-        watch_dirs = [
-            os.path.dirname(os.path.abspath(script_path)),
-        ]
-        
-        for d in watch_dirs:
-            if os.path.exists(d):
-                self.observer.schedule(
-                    self.handler,
-                    d,
-                    recursive=reload_mode
-                )
-                console.print(f"[dim]监控目录: [path]{d}[/][/]")
-
-        if reload_mode:
-            console.print(Panel(
-                f"[bold]开发重载模式[/]\n监控目录: [path]{', '.join(watch_dirs)}[/]",
-                title="热重载已启动",
-                border_style="info"
-            ))
-        else:
-            console.print(Panel(
-                f"主程序: [path]{script_path}[/]",
-                title="程序已启动",
-                border_style="info"
-            ))
-        
-        # 启动 observer
-        self.observer.start()
-        return watch_dirs
-    
-    def _cleanup(self):
+        async def _run():
+            from ... import sdk
+
+            if reload_mode:
+                loop = asyncio.get_running_loop()
+                self._setup_watchdog(".", loop)
+
+            await sdk.run(keep_running=True)
+
+        try:
+            asyncio.run(_run())
+        except KeyboardInterrupt:
+            pass
+        finally:
+            if reload_mode and hasattr(self, '_observer'):
+                self._observer.stop()
+                self._observer.join()
+
+    def _run_script(self, script_path: str, reload_mode: bool):
         """
-        清理资源
-        
-        停止文件监控，终止子进程
+        运行指定脚本文件
         """
-        if self.observer:
-            self.observer.stop()
-            self.observer.join()
-            if self.handler and self.handler.process:
-                self.handler._terminate_process()
+        async def _run():
+            from ... import sdk
+
+            if reload_mode:
+                loop = asyncio.get_running_loop()
+                watch_dir = os.path.dirname(os.path.abspath(script_path))
+                self._setup_watchdog(watch_dir, loop)
+
+            await sdk.run(keep_running=True)
+
+        try:
+            asyncio.run(_run())
+        except KeyboardInterrupt:
+            pass
+        finally:
+            if reload_mode and hasattr(self, '_observer'):
+                self._observer.stop()
+                self._observer.join()
+
+    def _setup_watchdog(self, watch_dir: str, loop: asyncio.AbstractEventLoop):
+        if not os.path.exists(watch_dir):
+            return
+
+        self._observer = Observer()
+        self._handler = ReloadHandler(loop=loop)
+        self._observer.schedule(self._handler, watch_dir, recursive=True)
+        self._observer.start()
+
+        console.print(Panel(
+            f"[bold]开发重载模式[/]\n监控目录: [path]{watch_dir}[/]",
+            title="热重载已启动",
+            border_style="info"
+        ))

ErisPulse/CLI/commands/run.pyi

@@ -7,14 +7,12 @@
 """
 Run 命令实现
 
-运行主程序
+直接运行主程序，支持热重载模式
 """
 
 import os
 import time
-import sys
-import subprocess
-import tempfile
+import asyncio
 from argparse import ArgumentParser
 from watchdog.observers import Observer
 from rich.panel import Panel
@@ -26,56 +24,19 @@ class ReloadHandler(FileSystemEventHandler):
     """
     文件系统事件处理器
     
-    实现热重载功能，监控 .py 文件变更并自动重启
+    监控 .py 文件变更并触发 sdk.restart() 热重载
     
     {!--< tips >!--}
-    1. 仅在 --reload 模式下启用监控
-    2. 监控 .py 文件，修改后创建清理信号文件并重启
-    3. 子进程检测到清理信号文件后自动调用 sdk.uninit()
-    4. 进程终止时使用清理信号文件确保资源正确释放
+    1. 文件监控运行在独立线程
+    2. 通过 run_coroutine_threadsafe 安全调度到事件循环
+    3. 内置 1 秒防抖，避免短时间内多次重载
     {!--< /tips >!--}
     """
-    def __init__(self: None, script_path: str, reload_mode: bool = ...) -> ...:
-        """
-        初始化处理器
-        
-        :param script_path: [str] 要监控的脚本路径
-        :param reload_mode: [bool] 是否启用重载模式 (默认: False)
-        """
-        ...
-    def start_process(self: object) -> ...:
-        """
-        启动监控进程
-        
-        注入环境变量，让子进程知道自己是由 CLI 启动的
-        """
-        ...
-    def _terminate_process(self: object) -> ...:
-        """
-        终止当前进程
-        
-        创建清理信号文件，通知子进程执行清理操作
-        等待最多 10 秒让进程正常退出
-        """
+    def __init__(self: None, loop: asyncio.AbstractEventLoop) -> ...:
         ...
     def on_modified(self: object, event: ...) -> ...:
-        """
-        文件修改事件处理
-        
-        仅在 --reload 模式下监控 .py 文件变更
-        
-        :param event: [FileSystemEvent] 文件系统事件
-        """
         ...
-    def _handle_reload(self: object, event: ..., reason: str) -> ...:
-        """
-        处理热重载逻辑
-        
-        创建清理信号文件，通知子进程执行清理，然后重启进程
-        
-        :param event: [FileSystemEvent] 文件系统事件
-        :param reason: [str] 重载原因
-        """
+    def _schedule_reload(self: object, event: ...) -> ...:
         ...
 
 class RunCommand(Command):
@@ -85,32 +46,18 @@ class RunCommand(Command):
     运行主程序，支持热重载模式
     """
     def add_arguments(self: object, parser: ArgumentParser) -> ...:
-        """
-        添加命令行参数
-        
-        :param parser: [ArgumentParser] 参数解析器
-        """
         ...
     def execute(self: object, args: ...) -> ...:
-        """
-        执行命令
-        
-        :param args: [Namespace] 命令行参数
-        """
         ...
-    def _setup_watchdog(self: object, script_path: str, reload_mode: bool) -> list:
+    def _run_internal(self: object, reload_mode: bool) -> ...:
         """
-        设置文件监控
-        
-        :param script_path: [str] 要监控的脚本路径
-        :param reload_mode: [bool] 是否启用重载模式
-        :return: [list] 监控的目录列表
+        直接运行 SDK（不指定脚本时）
         """
         ...
-    def _cleanup(self: object) -> ...:
+    def _run_script(self: object, script_path: str, reload_mode: bool) -> ...:
         """
-        清理资源
-        
-        停止文件监控，终止子进程
+        运行指定脚本文件
         """
         ...
+    def _setup_watchdog(self: object, watch_dir: str, loop: asyncio.AbstractEventLoop) -> ...:
+        ...

ErisPulse/Core/Bases/adapter.py

@@ -341,11 +341,10 @@ class BaseAdapter(ABC):
         """
         raise NotImplementedError("适配器必须实现shutdown方法")
 
-    async def emit(self) -> None:
-        from ..logger import logger
-
-        logger.error(
-            "适配器调用了一个被弃用的原生方法emit，请检查适配器的实现，如果你是开发者请查看ErisPulse的文档进行更新。如果你是普通用户请查看本适配器是否有更新"
+    async def emit(self, *args, **kwargs):
+        raise NotImplementedError(
+            "适配器的 emit 方法已被弃用。请使用 adapter.emit() 通过 AdapterManager 提交事件。"
+            "如果你是适配器开发者，请查看 ErisPulse 文档进行更新。"
         )
 
     def send(

ErisPulse/Core/Bases/adapter.pyi

@@ -158,7 +158,7 @@ class BaseAdapter(ABC):
         :raises NotImplementedError: 必须由子类实现
         """
         ...
-    async def emit(self: object) -> None:
+    async def emit(self: object, *args: ..., **kwargs: ...) -> ...:
         ...
     def send(self: object, target_type: str, target_id: str, message: Any, **kwargs: Any) -> asyncio.Task:
         """

ErisPulse/Core/__init__.py

@@ -15,44 +15,33 @@ from .config import config, ConfigManager
 from . import Event
 from .Event.message_builder import MessageBuilder
 
-# 兼容性别名定义
-adapter_server  = router        # 路由管理器别名
 env             = storage       # 存储管理器别名
-AdapterFather   = BaseAdapter   # 适配器基类别名
 
 __all__ = [
-    # 事件模块
     'Event',
 
-    # 适配器相关
-    'adapter',          # 适配器管理器
-    'AdapterManager',   # 适配器管理器类
-    'AdapterFather',    # 适配器基类
-    'BaseAdapter',      # 适配器基类别名
-    'SendDSL',          # DSL发送接口基类
-    'MessageBuilder',   # 消息构建器
-
-    # 模块相关
-    'module',           # 模块管理器
-    'ModuleManager',    # 模块管理器类
-    'BaseModule',       # 模块基类
-    
-    # 存储和配置相关
-    'storage',          # 存储管理器
-    'StorageManager',   # 存储管理器类
-    'config',           # 配置管理器
-    'ConfigManager',    # 配置管理器类
+    'adapter',
+    'AdapterManager',
+    'BaseAdapter',
+    'SendDSL',
+    'MessageBuilder',
+
+    'module',
+    'ModuleManager',
+    'BaseModule',
+
+    'storage',
+    'StorageManager',
+    'config',
     'env',              # 配置管理器别名
+    'ConfigManager',
+
+    'router',
+    'RouterManager',
 
-    # 路由相关
-    'router',           # 路由管理器
-    'RouterManager',    # 路由管理器类
-    'adapter_server',   # 路由管理器别名
-
-    # 基础设施
-    'logger',           # 日志管理器
-    'Logger',           # 日志管理器类
-    'LoggerChild',      # 日志子管理器类
-    'lifecycle',        # 生命周期管理器
-    'LifecycleManager', # 生命周期管理器类
+    'logger',
+    'Logger',
+    'LoggerChild',
+    'lifecycle',
+    'LifecycleManager',
 ]