maim-message 0.2.0__py3-none-any.whl

maim_message/__init__.py

@@ -0,0 +1,30 @@
+"""Maim Message - A message handling library"""
+
+__version__ = "0.1.0"
+
+from .api import MessageClient, MessageServer
+from .router import Router, RouteConfig, TargetConfig
+from .message_base import (
+    Seg,
+    GroupInfo,
+    UserInfo,
+    FormatInfo,
+    TemplateInfo,
+    BaseMessageInfo,
+    MessageBase,
+)
+
+__all__ = [
+    "MessageClient",
+    "MessageServer",
+    "Router",
+    "RouteConfig",
+    "TargetConfig",
+    "Seg",
+    "GroupInfo",
+    "UserInfo",
+    "FormatInfo",
+    "TemplateInfo",
+    "BaseMessageInfo",
+    "MessageBase",
+]

maim_message/api.py

@@ -0,0 +1,325 @@
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from typing import Dict, Any, Callable, List, Set, Optional
+import aiohttp
+import asyncio
+import uvicorn
+import json
+from .message_base import MessageBase
+
+
+class BaseMessageHandler:
+    """消息处理基类"""
+
+    def __init__(self):
+        self.message_handlers: List[Callable] = []
+        self.background_tasks = set()
+
+    def register_message_handler(self, handler: Callable):
+        """注册消息处理函数"""
+        self.message_handlers.append(handler)
+
+    async def process_message(self, message: Dict[str, Any]):
+        """处理单条消息"""
+        tasks = []
+        for handler in self.message_handlers:
+            try:
+                tasks.append(handler(message))
+            except Exception as e:
+                raise RuntimeError(str(e)) from e
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+
+    async def _handle_message(self, message: Dict[str, Any]):
+        """后台处理单个消息"""
+        try:
+            await self.process_message(message)
+        except Exception as e:
+            raise RuntimeError(str(e)) from e
+
+
+class MessageServer(BaseMessageHandler):
+    """WebSocket服务端"""
+
+    _class_handlers: List[Callable] = []  # 类级别的消息处理器
+
+    def __init__(
+        self,
+        host: str = "0.0.0.0",
+        port: int = 18000,
+        enable_token=False,
+        app: Optional[FastAPI] = None,
+        path: str = "/ws",
+    ):
+        super().__init__()
+        # 将类级别的处理器添加到实例处理器中
+        self.message_handlers.extend(self._class_handlers)
+        self.host = host
+        self.port = port
+        self.path = path
+        self.app = app or FastAPI()
+        self.own_app = app is None  # 标记是否使用自己创建的app
+        self.active_websockets: Set[WebSocket] = set()
+        self.platform_websockets: Dict[str, WebSocket] = {}  # 平台到websocket的映射
+        self.valid_tokens: Set[str] = set()
+        self.enable_token = enable_token
+        self._setup_routes()
+        self._running = False
+
+    @classmethod
+    def register_class_handler(cls, handler: Callable):
+        """注册类级别的消息处理器"""
+        if handler not in cls._class_handlers:
+            cls._class_handlers.append(handler)
+
+    def register_message_handler(self, handler: Callable):
+        """注册实例级别的消息处理器"""
+        if handler not in self.message_handlers:
+            self.message_handlers.append(handler)
+
+    async def verify_token(self, token: str) -> bool:
+        if not self.enable_token:
+            return True
+        return token in self.valid_tokens
+
+    def add_valid_token(self, token: str):
+        self.valid_tokens.add(token)
+
+    def remove_valid_token(self, token: str):
+        self.valid_tokens.discard(token)
+
+    def _setup_routes(self):
+        """设置WebSocket路由"""
+
+        # 使用传入的path作为WebSocket endpoint
+        @self.app.websocket(self.path)
+        async def websocket_endpoint(websocket: WebSocket):
+            headers = dict(websocket.headers)
+            token = headers.get("authorization")
+            platform = headers.get("platform", "default")
+            if self.enable_token:
+                if not token or not await self.verify_token(token):
+                    await websocket.close(code=1008, reason="Invalid or missing token")
+                    return
+
+            await websocket.accept()
+            self.active_websockets.add(websocket)
+
+            # 添加到platform映射
+            if platform not in self.platform_websockets:
+                self.platform_websockets[platform] = websocket
+
+            try:
+                while True:
+                    message = await websocket.receive_json()
+                    asyncio.create_task(self._handle_message(message))
+            except WebSocketDisconnect:
+                self._remove_websocket(websocket, platform)
+            except Exception as e:
+                self._remove_websocket(websocket, platform)
+                raise RuntimeError(str(e)) from e
+            finally:
+                self._remove_websocket(websocket, platform)
+
+    def _remove_websocket(self, websocket: WebSocket, platform: str):
+        """从所有集合中移除websocket"""
+        if websocket in self.active_websockets:
+            self.active_websockets.remove(websocket)
+        if platform in self.platform_websockets:
+            if self.platform_websockets[platform] == websocket:
+                del self.platform_websockets[platform]
+
+    async def broadcast_message(self, message: Dict[str, Any]):
+        disconnected = set()
+        for websocket in self.active_websockets:
+            try:
+                await websocket.send_json(message)
+            except Exception:
+                disconnected.add(websocket)
+        for websocket in disconnected:
+            self.active_websockets.remove(websocket)
+
+    async def broadcast_to_platform(self, platform: str, message: Dict[str, Any]):
+        """向指定平台的所有WebSocket客户端广播消息"""
+        if platform not in self.platform_websockets:
+            return
+
+        disconnected = set()
+        try:
+            await self.platform_websockets[platform].send_json(message)
+        except Exception:
+            disconnected.add(self.platform_websockets[platform])
+
+        # 清理断开的连接
+        for websocket in disconnected:
+            self._remove_websocket(websocket, platform)
+
+    async def send_message(self, message: MessageBase):
+        await self.broadcast_to_platform(
+            message.message_info.platform, message.to_dict()
+        )
+
+    def run_sync(self):
+        """同步方式运行服务器"""
+        if not self.own_app:
+            raise RuntimeError("当使用外部FastAPI实例时，请使用该实例的运行方法")
+        uvicorn.run(self.app, host=self.host, port=self.port)
+
+    async def run(self):
+        """异步方式运行服务器"""
+        self._running = True
+        try:
+            if self.own_app:
+                # 如果使用自己的 FastAPI 实例，运行 uvicorn 服务器
+                config = uvicorn.Config(
+                    self.app, host=self.host, port=self.port, loop="asyncio"
+                )
+                self.server = uvicorn.Server(config)
+                await self.server.serve()
+            else:
+                # 如果使用外部 FastAPI 实例，保持运行状态以处理消息
+                while self._running:
+                    await asyncio.sleep(1)
+        except KeyboardInterrupt:
+            await self.stop()
+            raise
+        except Exception as e:
+            await self.stop()
+            raise RuntimeError(f"服务器运行错误: {str(e)}") from e
+        finally:
+            await self.stop()
+
+    async def start_server(self):
+        """启动服务器的异步方法"""
+        if not self._running:
+            self._running = True
+            await self.run()
+
+    async def stop(self):
+        """停止服务器"""
+        # 清理platform映射
+        self.platform_websockets.clear()
+
+        # 取消所有后台任务
+        for task in self.background_tasks:
+            task.cancel()
+        # 等待所有任务完成
+        await asyncio.gather(*self.background_tasks, return_exceptions=True)
+        self.background_tasks.clear()
+
+        # 关闭所有WebSocket连接
+        for websocket in self.active_websockets:
+            await websocket.close()
+        self.active_websockets.clear()
+
+        if hasattr(self, "server") and self.own_app:
+            self._running = False
+            # 正确关闭 uvicorn 服务器
+            self.server.should_exit = True
+            await self.server.shutdown()
+            # 等待服务器完全停止
+            if hasattr(self.server, "started") and self.server.started:
+                await self.server.main_loop()
+            # 清理处理程序
+            self.message_handlers.clear()
+
+
+class MessageClient(BaseMessageHandler):
+    """WebSocket客户端"""
+
+    _class_handlers: List[Callable] = []  # 类级别的消息处理器
+
+    def __init__(self):
+        super().__init__()
+        self.message_handlers.extend(self._class_handlers)
+        self.platform = None
+        self.remote_ws = None
+        self.remote_ws_url = None
+        self.remote_ws_token = None
+        self.remote_ws_connected = False
+        self.remote_reconnect_interval = 5
+        self._running = False
+        self.retry_count = 0
+
+    @classmethod
+    def register_class_handler(cls, handler: Callable):
+        """注册类级别的消息处理器"""
+        if handler not in cls._class_handlers:
+            cls._class_handlers.append(handler)
+
+    def register_message_handler(self, handler: Callable):
+        """注册实例级别的消息处理器"""
+        if handler not in self.message_handlers:
+            self.message_handlers.append(handler)
+
+    async def connect(self, url: str, platform: str, token: Optional[str] = None):
+        """设置连接参数"""
+        self.remote_ws_url = url
+        self.remote_ws_token = token
+        self.platform = platform
+        self._running = True
+
+    async def run(self):
+        """维持websocket连接和消息处理"""
+        self.retry_count = 0
+        headers = {"platform": self.platform}
+        if self.remote_ws_token:
+            headers["Authorization"] = str(self.remote_ws_token)
+
+        while self._running:
+            try:
+                print(f"正在连接到 {self.remote_ws_url}")
+                async with aiohttp.ClientSession() as session:
+                    ws = await session.ws_connect(self.remote_ws_url, headers=headers)
+                    self.remote_ws = ws
+                    self.remote_ws_connected = True
+                    print(f"已连接到 {self.remote_ws_url}")
+                    self.retry_count = 0
+
+                    try:
+                        async for msg in ws:
+                            if not self._running:
+                                break
+                            if msg.type == aiohttp.WSMsgType.TEXT:
+                                try:
+                                    message = msg.json()
+                                    asyncio.create_task(self._handle_message(message))
+                                except json.JSONDecodeError as e:
+                                    print(f"收到无效的JSON消息: {e}")
+                            elif msg.type in (
+                                aiohttp.WSMsgType.CLOSED,
+                                aiohttp.WSMsgType.ERROR,
+                            ):
+                                break
+                    finally:
+                        await ws.close()
+
+            except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+                print(f"连接失败 ({self.retry_count}): {e}")
+                self.retry_count += 1
+            except asyncio.CancelledError:
+                break
+            finally:
+                self.remote_ws_connected = False
+                self.remote_ws = None
+
+            if self._running:
+                await asyncio.sleep(self.remote_reconnect_interval)
+
+    async def stop(self):
+        """停止客户端"""
+        self._running = False
+        if self.remote_ws and not self.remote_ws.closed:
+            await self.remote_ws.close()
+        self.remote_ws_connected = False
+        self.remote_ws = None
+
+    async def send_message(self, message: Dict[str, Any]) -> bool:
+        """发送消息到服务器"""
+        if not self.remote_ws_connected:
+            raise RuntimeError("未连接到服务器")
+        try:
+            await self.remote_ws.send_json(message)
+            return True
+        except Exception as e:
+            self.remote_ws_connected = False
+            raise RuntimeError(f"发送消息失败: {e}") from e

maim_message/message_base.py

@@ -0,0 +1,257 @@
+from dataclasses import dataclass, asdict
+from typing import List, Optional, Union, Dict
+
+
+@dataclass
+class Seg:
+    """消息片段类，用于表示消息的不同部分
+
+    Attributes:
+        type: 片段类型，可以是 'text'、'image'、'seglist' 等
+        data: 片段的具体内容
+            - 对于 text 类型，data 是字符串
+            - 对于 image 类型，data 是 base64 字符串
+            - 对于 seglist 类型，data 是 Seg 列表
+        translated_data: 经过翻译处理的数据（可选）
+    """
+
+    type: str
+    data: Union[str, List["Seg"]]
+
+    # def __init__(self, type: str, data: Union[str, List['Seg']],):
+    #     """初始化实例，确保字典和属性同步"""
+    #     # 先初始化字典
+    #     self.type = type
+    #     self.data = data
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "Seg":
+        """从字典创建Seg实例"""
+        type = data.get("type")
+        data = data.get("data")
+        if type == "seglist":
+            data = [Seg.from_dict(seg) for seg in data]
+        return cls(type=type, data=data)
+
+    def to_dict(self) -> Dict:
+        """转换为字典格式"""
+        result = {"type": self.type}
+        if self.type == "seglist":
+            result["data"] = [seg.to_dict() for seg in self.data]
+        else:
+            result["data"] = self.data
+        return result
+
+
+@dataclass
+class GroupInfo:
+    """群组信息类"""
+
+    platform: Optional[str] = None
+    group_id: Optional[str] = None
+    group_name: Optional[str] = None  # 群名称
+
+    def to_dict(self) -> Dict:
+        """转换为字典格式"""
+        return {k: v for k, v in asdict(self).items() if v is not None}
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "GroupInfo":
+        """从字典创建GroupInfo实例
+
+        Args:
+            data: 包含必要字段的字典
+
+        Returns:
+            GroupInfo: 新的实例
+        """
+        if data.get("group_id") is None:
+            return None
+        return cls(
+            platform=data.get("platform"),
+            group_id=data.get("group_id"),
+            group_name=data.get("group_name", None),
+        )
+
+
+@dataclass
+class UserInfo:
+    """用户信息类"""
+
+    platform: Optional[str] = None
+    user_id: Optional[str] = None
+    user_nickname: Optional[str] = None  # 用户昵称
+    user_cardname: Optional[str] = None  # 用户群昵称
+
+    def to_dict(self) -> Dict:
+        """转换为字典格式"""
+        return {k: v for k, v in asdict(self).items() if v is not None}
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "UserInfo":
+        """从字典创建UserInfo实例
+
+        Args:
+            data: 包含必要字段的字典
+
+        Returns:
+            UserInfo: 新的实例
+        """
+        return cls(
+            platform=data.get("platform"),
+            user_id=data.get("user_id"),
+            user_nickname=data.get("user_nickname", None),
+            user_cardname=data.get("user_cardname", None),
+        )
+
+
+@dataclass
+class FormatInfo:
+    """格式信息类"""
+
+    """
+    目前maimcore可接受的格式为text,image,emoji
+    可发送的格式为text,emoji,reply
+    """
+
+    content_format: Optional[List["str"]] = None
+    accept_format: Optional[List["str"]] = None
+
+    def to_dict(self) -> Dict:
+        """转换为字典格式"""
+        return {k: v for k, v in asdict(self).items() if v is not None}
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "FormatInfo":
+        """从字典创建FormatInfo实例
+        Args:
+            data: 包含必要字段的字典
+        Returns:
+            FormatInfo: 新的实例
+        """
+        return cls(
+            content_format=data.get("content_format"),
+            accept_format=data.get("accept_format"),
+        )
+
+
+@dataclass
+class TemplateInfo:
+    """模板信息类"""
+
+    template_items: Optional[Dict[str, str]] = None
+    template_name: Optional[Dict[str, str]] = None
+    template_default: bool = True
+
+    def to_dict(self) -> Dict:
+        """转换为字典格式"""
+        return {k: v for k, v in asdict(self).items() if v is not None}
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "TemplateInfo":
+        """从字典创建TemplateInfo实例
+        Args:
+            data: 包含必要字段的字典
+        Returns:
+            TemplateInfo: 新的实例
+        """
+        return cls(
+            template_items=data.get("template_items"),
+            template_name=data.get("template_name"),
+            template_default=data.get("template_default", True),
+        )
+
+
+@dataclass
+class BaseMessageInfo:
+    """消息信息类"""
+
+    platform: Optional[str] = None
+    message_id: Optional[str] = None
+    time: Optional[float] = None
+    group_info: Optional[GroupInfo] = None
+    user_info: Optional[UserInfo] = None
+    format_info: Optional[FormatInfo] = None
+    template_info: Optional[TemplateInfo] = None
+    additional_config: Optional[dict] = None
+
+    def to_dict(self) -> Dict:
+        """转换为字典格式"""
+        result = {}
+        for field, value in asdict(self).items():
+            if value is not None:
+                if isinstance(value, (GroupInfo, UserInfo, FormatInfo, TemplateInfo)):
+                    result[field] = value.to_dict()
+                else:
+                    result[field] = value
+        return result
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "BaseMessageInfo":
+        """从字典创建BaseMessageInfo实例
+
+        Args:
+            data: 包含必要字段的字典
+
+        Returns:
+            BaseMessageInfo: 新的实例
+        """
+        group_info = GroupInfo.from_dict(data.get("group_info", {}))
+        user_info = UserInfo.from_dict(data.get("user_info", {}))
+        format_info = FormatInfo.from_dict(data.get("format_info", {}))
+        template_info = TemplateInfo.from_dict(data.get("template_info", {}))
+        return cls(
+            platform=data.get("platform"),
+            message_id=data.get("message_id"),
+            time=data.get("time"),
+            additional_config=data.get("additional_config", None),
+            group_info=group_info,
+            user_info=user_info,
+            format_info=format_info,
+            template_info=template_info,
+        )
+
+
+@dataclass
+class MessageBase:
+    """消息类"""
+
+    message_info: BaseMessageInfo
+    message_segment: Seg
+    raw_message: Optional[str] = None  # 原始消息，包含未解析的cq码
+
+    def to_dict(self) -> Dict:
+        """转换为字典格式
+
+        Returns:
+            Dict: 包含所有非None字段的字典，其中：
+                - message_info: 转换为字典格式
+                - message_segment: 转换为字典格式
+                - raw_message: 如果存在则包含
+        """
+        result = {
+            "message_info": self.message_info.to_dict(),
+            "message_segment": self.message_segment.to_dict(),
+        }
+        if self.raw_message is not None:
+            result["raw_message"] = self.raw_message
+        return result
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "MessageBase":
+        """从字典创建MessageBase实例
+
+        Args:
+            data: 包含必要字段的字典
+
+        Returns:
+            MessageBase: 新的实例
+        """
+        message_info = BaseMessageInfo.from_dict(data.get("message_info", {}))
+        message_segment = Seg.from_dict(data.get("message_segment", {}))
+        raw_message = data.get("raw_message", None)
+        return cls(
+            message_info=message_info,
+            message_segment=message_segment,
+            raw_message=raw_message,
+        )

maim_message/router.py

@@ -0,0 +1,211 @@
+from typing import Optional, Dict, Any, Callable, List, Set
+from dataclasses import dataclass, asdict
+from .message_base import MessageBase
+from .api import MessageClient
+from fastapi import WebSocket
+import asyncio
+
+
+@dataclass
+class TargetConfig:
+    url: str = None
+    token: Optional[str] = None
+
+    def to_dict(self) -> Dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "TargetConfig":
+        return cls(url=data.get("url"), token=data.get("token"))
+
+
+@dataclass
+class RouteConfig:
+    route_config: Dict[str, TargetConfig] = None
+
+    def to_dict(self) -> Dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> "RouteConfig":
+        route_config = data.get("route_config")
+        for k in route_config.keys():
+            route_config[k] = TargetConfig.from_dict(route_config[k])
+        return cls(route_config=route_config)
+
+
+class Router:
+    def __init__(self, config: RouteConfig):
+        self.config = config
+        self.clients: Dict[str, MessageClient] = {}
+        self._running = False
+        self._client_tasks: Dict[str, asyncio.Task] = {}
+        self._monitor_task = None
+
+    async def _monitor_connections(self):
+        """监控所有客户端连接状态"""
+        await asyncio.sleep(3)  # 等待初始连接建立
+        while self._running:
+            for platform in list(self.clients.keys()):
+                client = self.clients[platform]
+                if not client.remote_ws_connected:
+                    print(f"检测到平台 {platform} 连接断开，尝试重连...")
+                    await self._reconnect_platform(platform)
+            await asyncio.sleep(5)  # 每5秒检查一次
+
+    async def _reconnect_platform(self, platform: str):
+        """重新连接指定平台"""
+        if platform in self._client_tasks:
+            task = self._client_tasks[platform]
+            if not task.done():
+                task.cancel()
+            await asyncio.gather(task, return_exceptions=True)
+            del self._client_tasks[platform]
+
+        if platform in self.clients:
+            await self.clients[platform].stop()
+            del self.clients[platform]
+
+        await self.connect(platform)
+
+    async def add_platform(self, platform: str, config: TargetConfig):
+        """动态添加新平台"""
+        self.config.route_config[platform] = config
+        if self._running:
+            await self.connect(platform)
+
+    async def remove_platform(self, platform: str):
+        """动态移除平台"""
+        if platform in self.config.route_config:
+            del self.config.route_config[platform]
+
+        if platform in self._client_tasks:
+            task = self._client_tasks[platform]
+            if not task.done():
+                task.cancel()
+            await asyncio.gather(task, return_exceptions=True)
+            del self._client_tasks[platform]
+
+        if platform in self.clients:
+            await self.clients[platform].stop()
+            del self.clients[platform]
+
+    async def connect(self, platform: str):
+        """连接指定平台"""
+        if platform not in self.config.route_config:
+            raise ValueError(f"未找到平台配置: {platform}")
+
+        config = self.config.route_config[platform]
+        client = MessageClient()
+        await client.connect(config.url, platform, config.token)
+        self.clients[platform] = client
+
+        if self._running:
+            self._client_tasks[platform] = asyncio.create_task(client.run())
+
+    async def run(self):
+        """运行所有客户端连接"""
+        self._running = True
+        try:
+            # 初始化所有平台的连接
+            for platform in self.config.route_config:
+                if platform not in self.clients:
+                    await self.connect(platform)
+
+            # 启动连接监控
+            self._monitor_task = asyncio.create_task(self._monitor_connections())
+
+            # 等待运行状态改变
+            while self._running:
+                await asyncio.sleep(1)
+
+        except asyncio.CancelledError:
+            await self.stop()
+        finally:
+            if self._monitor_task:
+                self._monitor_task.cancel()
+                await asyncio.gather(self._monitor_task, return_exceptions=True)
+
+    async def stop(self):
+        """停止所有客户端"""
+        self._running = False
+
+        # 取消监控任务
+        if self._monitor_task and not self._monitor_task.done():
+            self._monitor_task.cancel()
+            await asyncio.gather(self._monitor_task, return_exceptions=True)
+
+        # 先取消所有后台任务
+        for task in self._client_tasks.values():
+            if not task.done():
+                task.cancel()
+
+        # 等待任务取消完成
+        if self._client_tasks:
+            await asyncio.gather(*self._client_tasks.values(), return_exceptions=True)
+        self._client_tasks.clear()
+
+        # 然后停止所有客户端
+        stop_tasks = []
+        for client in self.clients.values():
+            stop_tasks.append(client.stop())
+        if stop_tasks:
+            await asyncio.gather(*stop_tasks, return_exceptions=True)
+
+        self.clients.clear()
+
+    def register_class_handler(self, handler):
+        MessageClient.register_class_handler(handler)
+
+    def get_target_url(self, message: MessageBase):
+        platform = message.message_info.platform
+        if platform in self.config.route_config.keys():
+            return self.config.route_config[platform].url
+        else:
+            return None
+
+    async def send_message(self, message: MessageBase):
+        url = self.get_target_url(message)
+        platform = message.message_info.platform
+        if url is None:
+            raise ValueError(f"不存在该平台url配置: {platform}")
+        if platform not in self.clients.keys():
+            client = MessageClient()
+            await client.connect(
+                url, platform, self.config.route_config[platform].token
+            )
+            self.clients[platform] = client
+        await self.clients[platform].send_message(message.to_dict())
+
+    async def _adjust_connections(self, new_config: RouteConfig):
+        """根据新配置调整连接"""
+        # 获取新旧配置的平台集合
+        old_platforms = set(self.config.route_config.keys())
+        new_platforms = set(new_config.route_config.keys())
+
+        # 需要移除的平台
+        for platform in old_platforms - new_platforms:
+            await self.remove_platform(platform)
+
+        # 需要更新或添加的平台
+        for platform in new_platforms:
+            new_target = new_config.route_config[platform]
+            if platform in self.config.route_config:
+                old_target = self.config.route_config[platform]
+                # 如果配置发生变化，需要重新连接
+                if (
+                    new_target.url != old_target.url
+                    or new_target.token != old_target.token
+                ):
+                    await self.remove_platform(platform)
+                    await self.add_platform(platform, new_target)
+            else:
+                # 新增平台
+                await self.add_platform(platform, new_target)
+
+    async def update_config(self, config_data: Dict):
+        """更新路由配置并动态调整连接"""
+        new_config = RouteConfig.from_dict(config_data)
+        if self._running:
+            await self._adjust_connections(new_config)
+        self.config = new_config

maim_message-0.2.0.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: maim_message
+Version: 0.2.0
+Summary: A message handling library
+Home-page: https://github.com/MaiM-with-u/maim_message
+Author: tcmofashi
+Author-email: mofashiforzbx@qq.com
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.70.0
+Requires-Dist: uvicorn>=0.15.0
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: pydantic>=1.9.0
+Requires-Dist: websockets>=10.0
+Dynamic: author-email
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python

maim_message-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+maim_message/__init__.py,sha256=ih0naYzxAWb7Yt94uYoTFQ3sBuObXqqWVbF883uDIPQ,546
+maim_message/api.py,sha256=Ld_dspGuCYYTaMZ7q6hnYdNH3iFcs9XmX3cj7TdtfL8,11942
+maim_message/message_base.py,sha256=7T3JxLD0dPZQVwXPT25OJ9-e8ygIPAi05CXVE2edyYY,7668
+maim_message/router.py,sha256=27KS0md0lPyRSXnO_39f95ZFqqM779MhKT7l78IfcHk,7548
+maim_message-0.2.0.dist-info/licenses/LICENSE,sha256=6eOvIUpv5IL5w4vTijzoJJeHmhFKMR_k4fm3UKEwpqE,1066
+maim_message-0.2.0.dist-info/METADATA,sha256=HOlT22_-hhZVZbmvO6ACzpOI8FfFxU9nMJ_lGzo7NLE,562
+maim_message-0.2.0.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+maim_message-0.2.0.dist-info/top_level.txt,sha256=wOWXqKObh2GcTVymGVt3F-mDPzkskcxSwnL5zPHWK18,13
+maim_message-0.2.0.dist-info/RECORD,,

maim_message-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (79.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

maim_message-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 tcmofashi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

maim_message-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+maim_message