ErisPulse 1.1.12__py3-none-any.whl → 1.1.14__py3-none-any.whl

ErisPulse/__main__.py

@@ -1,3 +1,48 @@
+"""
+# CLI 入口
+
+提供命令行界面(CLI)用于模块管理、源管理和开发调试。
+
+## 主要功能
+- 模块管理: 安装/卸载/启用/禁用
+- 源管理: 添加/删除/更新源
+- 热重载: 开发时自动重启
+- 彩色终端输出
+
+## 主要命令
+### 模块管理:
+    install: 安装模块
+    uninstall: 卸载模块
+    enable: 启用模块
+    disable: 禁用模块
+    list: 列出模块
+    update: 更新模块列表
+    upgrade: 升级模块
+
+### 源管理:
+    origin add: 添加源
+    origin del: 删除源  
+    origin list: 列出源
+
+### 开发调试:
+    run: 运行脚本
+    --reload: 启用热重载
+
+### 示例用法:
+
+```
+# 安装模块
+epsdk install MyModule
+
+# 启用热重载
+epsdk run main.py --reload
+
+# 管理源
+epsdk origin add https://example.com/map.json
+```
+
+"""
+
 import argparse
 import os
 import sys
@@ -9,6 +54,7 @@ import fnmatch
 import asyncio
 import subprocess
 import json
+import json
 from .db import env
 from .mods import mods
 from watchdog.observers import Observer
@@ -37,7 +83,6 @@ class Shell_Printer:
 
     @classmethod
     def _get_color(cls, level):
-        """根据消息级别返回颜色"""
         return {
             "info": cls.CYAN,
             "success": cls.GREEN,
@@ -49,77 +94,87 @@ class Shell_Printer:
 
     @classmethod
     def panel(cls, msg: str, title: str = None, level: str = "info") -> None:
-        """带标题和边框的面板，支持颜色编码"""
         color = cls._get_color(level)
-        border_char = "═" * 60
+        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 = (60 - len(title) - 4) // 2
+            title_padding = (width - len(title)) // 2
             left_pad = " " * title_padding
-            right_pad = " " * (60 - len(title) - title_padding - 4)
-            title_line = f"{cls.DIM}╔{left_pad}{cls.BOLD}{color}{title}{cls.RESET}{cls.DIM}{right_pad}╗{cls.RESET}\n"
+            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"):
-            padding = (60 - len(line) - 4) // 2
-            left_pad = " " * padding
-            right_pad = " " * (60 - len(line) - padding - 4)
-            lines.append(f"{cls.DIM}║{cls.RESET}{left_pad}{line}{right_pad}{cls.DIM}║{cls.RESET}")
+            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}")
         
-        # 底部边框
-        bottom_border = f"{cls.DIM}╚{border_char}╝{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}{border_char}\n"
+        panel = f"{title_line}"
+        panel += f"{cls.DIM}├{border_char}┤{cls.RESET}\n"
         panel += "\n".join(lines) + "\n"
-        panel += f"{border_char}\n{bottom_border}\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}"
@@ -130,7 +185,6 @@ class Shell_Printer:
 
     @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"
@@ -148,7 +202,6 @@ class Shell_Printer:
 
     @classmethod
     def ask(cls, msg, choices=None, default=None) -> str | None:
-        """带颜色和选择的提问"""
         prompt = f"{cls.BOLD}{msg}{cls.RESET}"
         if choices:
             prompt += f" ({cls.CYAN}{'/'.join(choices)}{cls.RESET})"
@@ -166,7 +219,6 @@ class Shell_Printer:
 
     @classmethod
     def status(cls, msg, success=True):
-        """显示状态指示器"""
         symbol = f"{cls.GREEN}✓" if success else f"{cls.RED}✗"
         print(f"\r{symbol}{cls.RESET} {msg}")
 
@@ -179,10 +231,29 @@ class SourceManager:
     def _init_sources(self):
         if not env.get('origins'):
             env.set('origins', [])
+            
+            primary_source = "https://erisdev.com/map.json"
+            secondary_source = "https://raw.githubusercontent.com/ErisPulse/ErisPulse-ModuleRepo/refs/heads/main/map.json"
+            
+            shellprint.status("正在验证主源...")
+            validated_url = asyncio.run(self._validate_url(primary_source))
+            
+            if validated_url:
+                env.set('origins', [validated_url])
+                shellprint.status(f"主源 {validated_url} 已成功添加")
+            else:
+                if secondary_source not in env.get('origins', []):
+                    env.set('origins', [secondary_source])
+                    shellprint.panel(
+                        f"主源不可用，已添加备用源 {secondary_source}\n\n"
+                        f"{Shell_Printer.YELLOW}提示:{Shell_Printer.RESET} 建议尽快升级 ErisPulse SDK 版本",
+                        "源初始化", 
+                        "warning"
+                    )
 
     async def _validate_url(self, url):
         if not url.startswith(('http://', 'https://')):
-            protocol = shellprint.confirm("未指定协议，请输入使用的协议", choices=['http', 'https'], default="https")
+            protocol = shellprint.ask("未指定协议，请输入使用的协议", choices=['http', 'https'], default="https")
             url = f"{protocol}://{url}"
         if not url.endswith('.json'):
             url = f"{url}/map.json"
@@ -190,10 +261,12 @@ class SourceManager:
             async with aiohttp.ClientSession() as session:
                 async with session.get(url) as response:
                     response.raise_for_status()
-                    if response.headers.get('Content-Type', '').startswith('application/json'):
+                    try:
+                        content = await response.text()
+                        json.loads(content)
                         return url
-                    else:
-                        shellprint.panel(f"源 {url} 返回的内容不是有效的 JSON 格式", "错误", "error")
+                    except (ValueError, json.JSONDecodeError) as e:
+                        shellprint.panel(f"源 {url} 返回的内容不是有效的 JSON 格式: {e}", "错误", "error")
                         return None
         except Exception as e:
             shellprint.panel(f"访问源 {url} 失败: {e}", "错误", "error")
@@ -230,8 +303,9 @@ class SourceManager:
                     async with aiohttp.ClientSession() as session:
                         async with session.get(origin) as response:
                             response.raise_for_status()
-                            if response.headers.get('Content-Type', '').startswith('application/json'):
-                                content = await response.json()
+                            try:
+                                text = await response.text()
+                                content = json.loads(text)
                                 providers[content["name"]] = content["base"]
                                 for module in content["modules"].keys():
                                     module_content = content["modules"][module]
@@ -244,8 +318,8 @@ class SourceManager:
                                         module,
                                         f"{providers[content['name']]}{module_origin_name}"
                                     ])
-                            else:
-                                shellprint.panel(f"源 {origin} 返回的内容不是有效的 JSON 格式", "错误", "error")
+                            except (ValueError, json.JSONDecodeError) as e:
+                                shellprint.panel(f"源 {origin} 返回的内容不是有效的 JSON 格式: {e}", "错误", "error")
                 except Exception as e:
                     shellprint.panel(f"获取 {origin} 时出错: {e}", "错误", "error")
                     
@@ -1073,7 +1147,12 @@ def main():
         else:
             shellprint.panel(f"运行脚本: {Shell_Printer.BOLD}{script_path}{Shell_Printer.RESET}", "执行", "info")
             import runpy
-            runpy.run_path(script_path, run_name="__main__")
+
+            # 添加KeyboardInterrupt异常捕捉
+            try:
+                runpy.run_path(script_path, run_name="__main__")
+            except KeyboardInterrupt:
+                shellprint.panel("脚本执行已中断", "中断", "info")
             
     elif args.command == 'origin':
         if args.origin_command == 'add':
@@ -1090,7 +1169,6 @@ def main():
         else:
             origin_parser.print_help()
     else:
-        # 如果没有提供命令，显示帮助信息
         parser.print_help()
 
 if __name__ == "__main__":

ErisPulse/adapter.py

@@ -1,3 +1,354 @@
+"""
+# 适配器系统
+
+提供平台适配器基类、消息发送DSL和适配器管理功能。支持多平台消息处理、事件驱动和生命周期管理。
+
+## 核心功能
+1. 适配器基类定义
+2. 链式消息发送DSL
+3. 适配器注册和管理
+4. 事件处理系统
+5. 中间件支持
+
+## API 文档
+
+### 适配器基类 (BaseAdapter)
+适配器基类提供了与外部平台交互的标准接口。
+
+#### call_api(endpoint: str, **params) -> Any
+调用平台API的抽象方法。
+- 参数:
+  - endpoint: API端点
+  - **params: API参数
+- 返回:
+  - Any: API调用结果
+- 说明:
+  - 必须由子类实现
+  - 处理与平台的实际通信
+- 示例:
+```python
+class MyPlatformAdapter(BaseAdapter):
+    async def call_api(self, endpoint: str, **params):
+        if endpoint == "/send":
+            return await self._send_message(params)
+        elif endpoint == "/upload":
+            return await self._upload_file(params)
+        raise NotImplementedError(f"未实现的端点: {endpoint}")
+```
+
+#### start() -> None
+启动适配器的抽象方法。
+- 参数: 无
+- 返回:
+  - None
+- 说明:
+  - 必须由子类实现
+  - 处理适配器的初始化和启动逻辑
+- 示例:
+```python
+class MyPlatformAdapter(BaseAdapter):
+    async def start(self):
+        self.client = await self._create_client()
+        self.ws = await self.client.create_websocket()
+        self._start_heartbeat()
+```
+
+#### shutdown() -> None
+关闭适配器的抽象方法。
+- 参数: 无
+- 返回:
+  - None
+- 说明:
+  - 必须由子类实现
+  - 处理资源清理和关闭逻辑
+- 示例:
+```python
+class MyPlatformAdapter(BaseAdapter):
+    async def shutdown(self):
+        if self.ws:
+            await self.ws.close()
+        if self.client:
+            await self.client.close()
+```
+
+#### on(event_type: str = "*") -> Callable
+事件监听装饰器。
+- 参数:
+  - event_type: 事件类型，默认"*"表示所有事件
+- 返回:
+  - Callable: 装饰器函数
+- 示例:
+```python
+adapter = MyPlatformAdapter()
+
+@adapter.on("message")
+async def handle_message(data):
+    print(f"收到消息: {data}")
+
+@adapter.on("error")
+async def handle_error(error):
+    print(f"发生错误: {error}")
+
+# 处理所有事件
+@adapter.on()
+async def handle_all(event):
+    print(f"事件: {event}")
+```
+
+#### emit(event_type: str, data: Any) -> None
+触发事件。
+- 参数:
+  - event_type: 事件类型
+  - data: 事件数据
+- 返回:
+  - None
+- 示例:
+```python
+class MyPlatformAdapter(BaseAdapter):
+    async def _handle_websocket_message(self, message):
+        # 处理消息并触发相应事件
+        if message.type == "chat":
+            await self.emit("message", {
+                "type": "chat",
+                "content": message.content,
+                "sender": message.sender
+            })
+```
+
+#### middleware(func: Callable) -> Callable
+添加中间件处理器。
+- 参数:
+  - func: 中间件函数
+- 返回:
+  - Callable: 中间件函数
+- 示例:
+```python
+adapter = MyPlatformAdapter()
+
+@adapter.middleware
+async def log_middleware(data):
+    print(f"处理数据: {data}")
+    return data
+
+@adapter.middleware
+async def filter_middleware(data):
+    if "spam" in data.get("content", ""):
+        return None
+    return data
+```
+
+### 消息发送DSL (SendDSL)
+提供链式调用风格的消息发送接口。
+
+#### To(target_type: str = None, target_id: str = None) -> 'SendDSL'
+设置消息目标。
+- 参数:
+  - target_type: 目标类型（可选）
+  - target_id: 目标ID
+- 返回:
+  - SendDSL: 发送器实例
+- 示例:
+```python
+# 发送到用户
+sdk.adapter.Platform.Send.To("user", "123").Text("Hello")
+
+# 发送到群组
+sdk.adapter.Platform.Send.To("group", "456").Text("Hello Group")
+
+# 简化形式（只有ID）
+sdk.adapter.Platform.Send.To("123").Text("Hello")
+```
+
+#### Text(text: str) -> Task
+发送文本消息。
+- 参数:
+  - text: 文本内容
+- 返回:
+  - Task: 异步任务
+- 示例:
+```python
+# 发送简单文本
+await sdk.adapter.Platform.Send.To("user", "123").Text("Hello")
+
+# 发送格式化文本
+name = "Alice"
+await sdk.adapter.Platform.Send.To("123").Text(f"Hello {name}")
+```
+
+### 适配器管理 (AdapterManager)
+管理多个平台适配器的注册、启动和关闭。
+
+#### register(platform: str, adapter_class: Type[BaseAdapter]) -> bool
+注册新的适配器类。
+- 参数:
+  - platform: 平台名称
+  - adapter_class: 适配器类
+- 返回:
+  - bool: 注册是否成功
+- 示例:
+```python
+# 注册适配器
+sdk.adapter.register("MyPlatform", MyPlatformAdapter)
+
+# 注册多个适配器
+adapters = {
+    "Platform1": Platform1Adapter,
+    "Platform2": Platform2Adapter
+}
+for name, adapter in adapters.items():
+    sdk.adapter.register(name, adapter)
+```
+
+#### startup(platforms: List[str] = None) -> None
+启动指定的适配器。
+- 参数:
+  - platforms: 要启动的平台列表，None表示所有平台
+- 返回:
+  - None
+- 示例:
+```python
+# 启动所有适配器
+await sdk.adapter.startup()
+
+# 启动指定适配器
+await sdk.adapter.startup(["Platform1", "Platform2"])
+```
+
+#### shutdown() -> None
+关闭所有适配器。
+- 参数: 无
+- 返回:
+  - None
+- 示例:
+```python
+# 关闭所有适配器
+await sdk.adapter.shutdown()
+
+# 在程序退出时关闭
+import atexit
+atexit.register(lambda: asyncio.run(sdk.adapter.shutdown()))
+```
+
+## 最佳实践
+
+1. 适配器实现
+```python
+class MyPlatformAdapter(sdk.BaseAdapter):
+    class Send(sdk.BaseAdapter.Send):
+        # 实现基本消息类型
+        def Text(self, text: str):
+            return asyncio.create_task(
+                self._adapter.call_api(
+                    endpoint="/send",
+                    content=text,
+                    recvId=self._target_id,
+                    recvType=self._target_type
+                )
+            )
+            
+        # 添加自定义消息类型
+        def Image(self, file: bytes):
+            return asyncio.create_task(
+                self._adapter.call_api(
+                    endpoint="/send_image",
+                    file=file,
+                    recvId=self._target_id,
+                    recvType=self._target_type
+                )
+            )
+    
+    async def call_api(self, endpoint: str, **params):
+        # 实现API调用逻辑
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"{self.api_base}{endpoint}",
+                json=params
+            ) as response:
+                return await response.json()
+                
+    async def start(self):
+        # 初始化连接
+        self.client = await self._create_client()
+        # 启动事件监听
+        asyncio.create_task(self._listen_events())
+        
+    async def shutdown(self):
+        # 清理资源
+        if self.client:
+            await self.client.close()
+```
+
+2. 事件处理
+```python
+# 注册事件处理器
+adapter = MyPlatformAdapter()
+
+@adapter.on("message")
+async def handle_message(data):
+    # 消息处理逻辑
+    if data["type"] == "text":
+        await process_text_message(data)
+    elif data["type"] == "image":
+        await process_image_message(data)
+
+# 使用中间件
+@adapter.middleware
+async def auth_middleware(data):
+    if not verify_token(data.get("token")):
+        return None
+    return data
+
+@adapter.middleware
+async def log_middleware(data):
+    sdk.logger.info(f"处理事件: {data}")
+    return data
+```
+
+3. 消息发送
+```python
+# 基本消息发送
+async def send_welcome(user_id: str):
+    await sdk.adapter.Platform.Send.To("user", user_id).Text("欢迎！")
+
+# 复杂消息处理
+async def process_group_notification(group_id: str, event: dict):
+    # 发送格式化消息
+    message = format_notification(event)
+    await sdk.adapter.Platform.Send.To("group", group_id).Text(message)
+    
+    # 发送附加文件
+    if event.get("has_attachment"):
+        file_data = await get_attachment(event["attachment_id"])
+        await sdk.adapter.Platform.Send.To("group", group_id).File(file_data)
+```
+
+## 注意事项
+
+1. 适配器实现
+   - 确保正确实现所有抽象方法
+   - 处理所有可能的异常情况
+   - 实现适当的重试机制
+   - 注意资源的正确释放
+
+2. 事件处理
+   - 避免在事件处理器中执行长时间操作
+   - 使用适当的错误处理
+   - 考虑事件处理的顺序性
+   - 合理使用中间件过滤机制
+
+3. 消息发送
+   - 实现消息发送的限流机制
+   - 处理发送失败的情况
+   - 注意消息格式的平台兼容性
+   - 大文件传输时考虑分片
+
+4. 生命周期管理
+   - 确保适配器正确启动和关闭
+   - 处理意外断开的情况
+   - 实现自动重连机制
+   - 注意资源泄漏问题
+"""
+
 import functools
 import asyncio
 from typing import Callable, Any, Dict, List, Type, Optional, Set