ErisPulse 1.2.9__py3-none-any.whl → 2.1.1__py3-none-any.whl

ErisPulse/Core/server.py

@@ -0,0 +1,276 @@
+"""
+ErisPulse Adapter Server
+提供统一的适配器服务入口，支持HTTP和WebSocket路由
+
+{!--< tips >!--}
+1. 适配器只需注册路由，无需自行管理服务器
+2. WebSocket支持自定义认证逻辑
+3. 兼容FastAPI 0.68+ 版本
+{!--< /tips >!--}
+"""
+
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.routing import APIRoute
+from typing import Dict, List, Optional, Callable, Any, Awaitable, Tuple
+from collections import defaultdict
+from .logger import logger
+import asyncio
+from hypercorn.config import Config
+from hypercorn.asyncio import serve
+
+
+class AdapterServer:
+    """
+    适配器服务器管理器
+    
+    {!--< tips >!--}
+    核心功能：
+    - HTTP/WebSocket路由注册
+    - 生命周期管理
+    - 统一错误处理
+    {!--< /tips >!--}
+    """
+
+    def __init__(self):
+        """
+        初始化适配器服务器
+        
+        {!--< tips >!--}
+        会自动创建FastAPI实例并设置核心路由
+        {!--< /tips >!--}
+        """
+        self.app = FastAPI(
+            title="ErisPulse Adapter Server",
+            description="统一适配器服务入口点",
+            version="1.0.0"
+        )
+        self._webhook_routes: Dict[str, Dict[str, Callable]] = defaultdict(dict)
+        self._websocket_routes: Dict[str, Dict[str, Tuple[Callable, Optional[Callable]]]] = defaultdict(dict)
+        self.base_url = ""
+        self._server_task: Optional[asyncio.Task] = None
+        self._setup_core_routes()
+
+    def _setup_core_routes(self) -> None:
+        """
+        设置系统核心路由
+        
+        {!--< internal-use >!--}
+        此方法仅供内部使用
+        {!--< /internal-use >!--}
+        """
+        @self.app.get("/health")
+        async def health_check() -> Dict[str, str]:
+            """
+            健康检查端点
+            
+            :return: 
+                Dict[str, str]: 包含服务状态的字典
+            """
+            return {"status": "ok", "service": "ErisPulse Adapter Server"}
+            
+        @self.app.get("/routes")
+        async def list_routes() -> Dict[str, Any]:
+            """
+            列出所有已注册路由
+            
+            :return: 
+                Dict[str, Any]: 包含所有路由信息的字典，格式为:
+                {
+                    "http_routes": [
+                        {
+                            "path": "/adapter1/route1",
+                            "adapter": "adapter1",
+                            "methods": ["POST"]
+                        },
+                        ...
+                    ],
+                    "websocket_routes": [
+                        {
+                            "path": "/adapter1/ws",
+                            "adapter": "adapter1",
+                            "requires_auth": true
+                        },
+                        ...
+                    ],
+                    "base_url": self.base_url
+                }
+            """
+            http_routes = []
+            for adapter, routes in self._webhook_routes.items():
+                for path, handler in routes.items():
+                    route = self.app.router.routes[-1]  # 获取最后添加的路由
+                    if isinstance(route, APIRoute) and route.path == path:
+                        http_routes.append({
+                            "path": path,
+                            "adapter": adapter,
+                            "methods": route.methods
+                        })
+            
+            websocket_routes = []
+            for adapter, routes in self._websocket_routes.items():
+                for path, (handler, auth_handler) in routes.items():
+                    websocket_routes.append({
+                        "path": path,
+                        "adapter": adapter,
+                        "requires_auth": auth_handler is not None
+                    })
+            
+            return {
+                "http_routes": http_routes,
+                "websocket_routes": websocket_routes,
+                "base_url": self.base_url
+            }
+
+    def register_webhook(
+        self, 
+        adapter_name: str,
+        path: str,
+        handler: Callable,
+        methods: List[str] = ["POST"]
+    ) -> None:
+        """
+        注册HTTP路由
+        
+        :param adapter_name: str 适配器名称
+        :param path: str 路由路径(如"/message")
+        :param handler: Callable 处理函数
+        :param methods: List[str] HTTP方法列表(默认["POST"])
+        
+        :raises ValueError: 当路径已注册时抛出
+        
+        {!--< tips >!--}
+        路径会自动添加适配器前缀，如：/adapter_name/path
+        {!--< /tips >!--}
+        """
+        full_path = f"/{adapter_name}{path}"
+        
+        if full_path in self._webhook_routes[adapter_name]:
+            raise ValueError(f"路径 {full_path} 已注册")
+            
+        route = APIRoute(
+            path=full_path,
+            endpoint=handler,
+            methods=methods,
+            name=f"{adapter_name}{path}"
+        )
+        self.app.router.routes.append(route)
+        self._webhook_routes[adapter_name][full_path] = handler
+        logger.info(f"注册HTTP路由: {self.base_url}{full_path} 方法: {methods}")
+
+    def register_websocket(
+        self,
+        adapter_name: str,
+        path: str,
+        handler: Callable[[WebSocket], Awaitable[Any]],
+        auth_handler: Optional[Callable[[WebSocket], Awaitable[bool]]] = None,
+    ) -> None:
+        """
+        注册WebSocket路由
+        
+        :param adapter_name: str 适配器名称
+        :param path: str WebSocket路径(如"/ws")
+        :param handler: Callable[[WebSocket], Awaitable[Any]] 主处理函数
+        :param auth_handler: Optional[Callable[[WebSocket], Awaitable[bool]]] 认证函数
+        
+        :raises ValueError: 当路径已注册时抛出
+        
+        {!--< tips >!--}
+        认证函数应返回布尔值，False将拒绝连接
+        {!--< /tips >!--}
+        """
+        full_path = f"/{adapter_name}{path}"
+        
+        if full_path in self._websocket_routes[adapter_name]:
+            raise ValueError(f"WebSocket路径 {full_path} 已注册")
+            
+        async def websocket_endpoint(websocket: WebSocket) -> None:
+            """
+            WebSocket端点包装器
+            
+            {!--< internal-use >!--}
+            处理连接生命周期和错误处理
+            {!--< /internal-use >!--}
+            """
+            await websocket.accept()
+            
+            try:
+                if auth_handler and not await auth_handler(websocket):
+                    await websocket.close(code=1008)
+                    return
+                
+                await handler(websocket)
+                
+            except WebSocketDisconnect:
+                logger.debug(f"客户端断开: {full_path}")
+            except Exception as e:
+                logger.error(f"WebSocket错误: {e}")
+                await websocket.close(code=1011)
+                
+        self.app.add_api_websocket_route(
+            path=full_path,
+            endpoint=websocket_endpoint,
+            name=f"{adapter_name}{path}"
+        )
+        self._websocket_routes[adapter_name][full_path] = (handler, auth_handler)
+        logger.info(f"注册WebSocket: {self.base_url}{full_path} {'(需认证)' if auth_handler else ''}")
+
+    def get_app(self) -> FastAPI:
+        """
+        获取FastAPI应用实例
+        
+        :return: 
+            FastAPI: FastAPI应用实例
+        """
+        return self.app
+
+    async def start(
+        self,
+        host: str = "0.0.0.0",
+        port: int = 8000,
+        ssl_certfile: Optional[str] = None,
+        ssl_keyfile: Optional[str] = None
+    ) -> None:
+        """
+        启动适配器服务器
+        
+        :param host: str 监听地址(默认"0.0.0.0")
+        :param port: int 监听端口(默认8000)
+        :param ssl_certfile: Optional[str] SSL证书路径
+        :param ssl_keyfile: Optional[str] SSL密钥路径
+        
+        :raises RuntimeError: 当服务器已在运行时抛出
+        """
+        if self._server_task and not self._server_task.done():
+            raise RuntimeError("服务器已在运行中")
+
+        config = Config()
+        config.bind = [f"{host}:{port}"]
+        # config.loglevel = "debug"
+        
+        if ssl_certfile and ssl_keyfile:
+            config.certfile = ssl_certfile
+            config.keyfile = ssl_keyfile
+        
+        self.base_url = f"http{'s' if ssl_certfile else ''}://{host}:{port}"
+        logger.info(f"启动服务器 {self.base_url}")
+        
+        self._server_task = asyncio.create_task(serve(self.app, config))
+
+    async def stop(self) -> None:
+        """
+        停止服务器
+        
+        {!--< tips >!--}
+        会等待所有连接正常关闭
+        {!--< /tips >!--}
+        """
+        if self._server_task:
+            self._server_task.cancel()
+            try:
+                await self._server_task
+            except asyncio.CancelledError:
+                logger.info("服务器已停止")
+            self._server_task = None
+
+
+adapter_server = AdapterServer()

ErisPulse/Core/shellprint.py

@@ -0,0 +1,165 @@
+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()

ErisPulse/Core/util.py

@@ -0,0 +1,126 @@
+"""
+ErisPulse 工具函数集合
+
+提供常用工具函数，包括拓扑排序、缓存装饰器、异步执行等实用功能。
+
+{!--< tips >!--}
+1. 使用@cache装饰器缓存函数结果
+2. 使用@run_in_executor在独立线程中运行同步函数
+3. 使用@retry实现自动重试机制
+{!--< /tips >!--}
+"""
+
+import time
+import asyncio
+import functools
+import traceback
+from concurrent.futures import ThreadPoolExecutor
+from collections import defaultdict, deque
+from typing import List, Dict, Type, Callable, Any, Optional, Set
+
+executor = ThreadPoolExecutor()
+
+class Util:
+    """
+    工具函数集合
+    
+    提供各种实用功能，简化开发流程
+    
+    {!--< tips >!--}
+    1. 拓扑排序用于解决依赖关系
+    2. 装饰器简化常见模式实现
+    3. 异步执行提升性能
+    {!--< /tips >!--}
+    """
+    def ExecAsync(self, async_func: Callable, *args: Any, **kwargs: Any) -> Any:
+        """
+        异步执行函数
+        
+        :param async_func: 异步函数
+        :param args: 位置参数
+        :param kwargs: 关键字参数
+        :return: 函数执行结果
+        
+        :example:
+        >>> result = util.ExecAsync(my_async_func, arg1, arg2)
+        """
+        loop = asyncio.get_event_loop()
+        return loop.run_in_executor(executor, lambda: asyncio.run(async_func(*args, **kwargs)))
+
+    def cache(self, func: Callable) -> Callable:
+        """
+        缓存装饰器
+        
+        :param func: 被装饰函数
+        :return: 装饰后的函数
+        
+        :example:
+        >>> @util.cache
+        >>> def expensive_operation(param):
+        >>>     return heavy_computation(param)
+        """
+        cache_dict = {}
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            key = (args, tuple(sorted(kwargs.items())))
+            if key not in cache_dict:
+                cache_dict[key] = func(*args, **kwargs)
+            return cache_dict[key]
+        return wrapper
+
+    def run_in_executor(self, func: Callable) -> Callable:
+        """
+        在独立线程中执行同步函数的装饰器
+        
+        :param func: 被装饰的同步函数
+        :return: 可等待的协程函数
+        
+        :example:
+        >>> @util.run_in_executor
+        >>> def blocking_io():
+        >>>     # 执行阻塞IO操作
+        >>>     return result
+        """
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            loop = asyncio.get_event_loop()
+            try:
+                return await loop.run_in_executor(None, lambda: func(*args, **kwargs))
+            except Exception as e:
+                from . import logger, raiserr
+                logger.error(f"线程内发生未处理异常:\n{''.join(traceback.format_exc())}")
+                raiserr.CaughtExternalError(
+                    f"检测到线程内异常，请优先使用 sdk.raiserr 抛出错误。\n原始异常: {type(e).__name__}: {e}"
+                )
+        return wrapper
+
+    def retry(self, max_attempts: int = 3, delay: int = 1) -> Callable:
+        """
+        自动重试装饰器
+        
+        :param max_attempts: 最大重试次数 (默认: 3)
+        :param delay: 重试间隔(秒) (默认: 1)
+        :return: 装饰器函数
+        
+        :example:
+        >>> @util.retry(max_attempts=5, delay=2)
+        >>> def unreliable_operation():
+        >>>     # 可能失败的操作
+        """
+        def decorator(func: Callable) -> Callable:
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                attempts = 0
+                while attempts < max_attempts:
+                    try:
+                        return func(*args, **kwargs)
+                    except Exception as e:
+                        attempts += 1
+                        if attempts == max_attempts:
+                            raise
+                        time.sleep(delay)
+            return wrapper
+        return decorator
+
+
+util = Util()