maim-message 0.2.0__tar.gz

maim_message-0.2.0/.gitignore

@@ -0,0 +1,21 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+others/

maim_message-0.2.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,258 @@
+# Maim Message
+
+一个用于定义maimcore消息通用接口的Python库。
+
+## 安装
+
+```bash
+git clone https://github.com/MaiM-with-u/maim_message
+cd maim_message
+pip install -e .
+```
+
+## 使用方法
+
+```python
+from maim_message import MessageBase
+```
+
+## 介绍
+maim_message是从maimbot项目衍生出来的各个组件之间的消息定义和交换的库，为了实现多平台和方便开发者开发，maimbot从与nonebot耦合发展到maimcore阶段，maimcore只暴露自己的websocket接口，别的组件可以通过maim_message提供的MessageClient类与maimcore连接，也可以构造MessageServer接受MessageClient连接。
+
+在这种通信协议下，可以产生多种组件类型，例如最简单的nonebot_adapter与maimcore之间的通信，nonebot作为MessageClient，连接作为MessageServer的maimcore，从而实现一个消息客户端的开发。另外还支持类似代理或中间件的插件形式，例如让nonebot连接到插件的MessageServer，插件再通过MessageClient连接到maimcore。
+
+消息的构造使用MessageBase，MessageBase提供了序列化和反序列化的方法，是消息通信的基本格式，使用时可以直接构造MessageBase，也可以继承MessageBase后构造。
+
+消息的基本内容由maim_message的Seg定义，Seg有type和data两个属性，除了特殊类型seglist之外，type并无限制，但maimcore只能处理类型为text，image，emoji，seglist的Seg，Seg支持嵌套，seglist类型的Seg的data定义为一个Seg列表，便于含有多种类型组合的消息，以及含有嵌套的消息可以直接递归的解析成Seg。
+
+目前maimcore可以处理的Seg类型以及定义如下:
+```python
+Seg(
+        "seglist",
+        [
+            Seg("text", "111(raw text)"),
+            Seg("emoji", "base64(无头base64)"),
+            Seg("image", "base64(无头base64)"),
+        ],
+    )
+```
+
+## 构造一个合法消息  
+#### 消息构造一图流
+<img src="./doc/img/maim_message_messagebase.png" alt="由于图画的太好我就不打文本了" />
+
+#### 消息构造代码参考  
+```python
+from maim_message import (
+    BaseMessageInfo,
+    UserInfo,
+    GroupInfo,
+    FormatInfo,
+    TemplateInfo,
+    MessageBase,
+    Seg
+)
+import asyncio
+
+
+def construct_message(platform):
+    # 构造消息
+    user_info = UserInfo(
+        # 必填
+        platform=platform,
+        user_id='12348765',
+        # 选填
+        user_nickname="maimai",
+        user_cardname="mai god",
+    )
+
+    group_info = GroupInfo(
+        # 必填
+        platform=platform,  # platform请务必保持一致
+        group_id='12345678',
+        # 选填
+        group_name="aaabbb",
+    )
+
+    format_info = FormatInfo(
+        # 消息内容中包含的Seg的type列表
+        content_format=["text", "image", "emoji", "at", "reply", "voice"],
+        # 消息发出后，期望最终的消息中包含的消息类型，可以帮助某些plugin判断是否向消息中添加某些消息类型
+        accept_format=["text", "image", "emoji", "reply"],
+    )
+
+    # 暂时不启用，可置None
+    template_info_custom = TemplateInfo(
+        template_items={
+            "detailed_text": "[{user_nickname}({user_nickname})]{user_cardname}: {processed_text}",
+            "main_prompt_template": "...",
+        },
+        template_name="qq123_default",
+        template_default=False,
+    )
+
+    template_info_default = TemplateInfo(template_default=True)
+
+    message_info = BaseMessageInfo(
+        # 必填
+        platform=platform,
+        message_id="12345678",  # 只会在reply和撤回消息等功能下启用，且可以不保证unique
+        time=1234567.001,  # 时间戳
+        group_info=group_info,
+        user_info=user_info,
+        # 选填和暂未启用
+        format_info=format_info,
+        template_info=None,
+        additional_config={
+            "maimcore_reply_probability_gain": 0.5  # 回复概率增益
+        },
+    )
+
+    message_segment = Seg(
+        "seglist",
+        [
+            Seg("text", "111(raw text)"),
+            Seg("emoji", "base64(raw base64)"),
+            Seg("image", "base64(raw base64)"),
+            Seg("at", "111222333(qq number)"),
+            Seg("reply", "123456(message id)"),
+            Seg("voice", "wip"),
+        ],
+    )
+
+    raw_message = "可有可无"
+
+    message = MessageBase(
+        # 必填
+        message_info=message_info,
+        message_segment=message_segment,
+        # 选填
+        raw_message=raw_message,
+    )
+    return message
+```
+
+## 简要构造一个消息客户端
+涉及到标准消息的构建与客户端的建立，maim_message提供了一个Router类，可用于管理一个客户端程序处理多种不同平台的数据时建立的多个MessageClient，可参考如下。
+
+
+```python
+from maim_message import (
+    Router,
+    RouteConfig,
+    TargetConfig,
+)
+
+# 配置路由config 
+# 从RouteConfig类构建route_config实例
+route_config = RouteConfig( 
+    #根据TargetConfig类构建一个合法的route_config
+    route_config={
+        "platform1": TargetConfig( 
+            url="ws://127.0.0.1:19000/ws",
+            token=None,  # 如果需要token验证则在这里设置
+        ),
+        # 可配置多个平台连接
+        "platform2": TargetConfig(
+            url="ws://127.0.0.1:19000/ws",
+            token="your_auth_token_here",  # 示例：带认证token的连接 
+        ),
+        "platform3": TargetConfig(
+            url="ws://127.0.0.1:19000/ws",
+            token=None, 
+        ),
+    }
+)
+
+# 使用刚刚构建的route_config,从类Router创建路由器实例router
+router = Router(route_config)
+
+
+async def main():
+    # 使用实例router的方法注册消息处理器
+    router.register_class_handler(message_handler) #message_handler示例见下方
+
+    try:
+        # 启动路由器（会自动连接所有配置的平台）
+        router_task = asyncio.create_task(router.run())
+
+        # 等待连接建立
+        await asyncio.sleep(2)
+
+        # 使用router.send_message()方法发送消息
+        await router.send_message(construct_message("test"))#接受的参数为MessageBase
+
+        # 保持运行直到被中断
+        await router_task
+
+    finally:
+        print("正在关闭连接...")
+        await router.stop()
+        print("已关闭所有连接")
+
+async def message_handler(message):
+    """
+    一个作为示例的消息处理函数
+    从mmc发来的消息将会进入此函数
+    你需要解析消息，并且向指定平台捏造合适的消息发送
+    如将mmc的MessageBase消息转换为onebotV11协议消息发送到QQ
+    或者根据其他协议发送到其他平台
+    """
+    print(f"收到消息: {message}")
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        pass  # 让asyncio.run处理清理工作
+
+```
+
+
+## 构造一个maimcore plugin
+实际上只是模仿了maimcore的结构，真正的plugins应该继续向下游发送消息。
+```python
+from maim_message import MessageBase, Seg, MessageServer
+
+
+async def process_seg(seg: Seg):
+    """处理消息段的递归函数"""
+    if seg.type == "seglist":
+        seglist = seg.data
+        for single_seg in seglist:
+            await process_seg(single_seg)
+    # 实际内容处理逻辑
+    if seg.type == "voice":
+        seg.type = "text"
+        seg.data = "[音频]"
+    elif seg.type == "at":
+        seg.type = "text"
+        seg.data = "[@某人]"
+
+
+async def handle_message(message_data):
+    """消息处理函数"""
+    message = MessageBase.from_dict(message_data)
+    await process_seg(message.message_segment)
+
+    # 将处理后的消息广播给所有连接的客户端
+    await server.send_message(message)
+
+
+if __name__ == "__main__":
+    # 创建服务器实例
+    server = MessageServer(host="0.0.0.0", port=19000)
+
+    # 注册消息处理器
+    server.register_message_handler(handle_message)
+
+    # 运行服务器
+    server.run_sync()
+
+```
+
+
+## 许可证
+
+MIT

maim_message-0.2.0/api.py

@@ -0,0 +1,91 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import json
+from typing import Optional, Dict, Any, Callable, List
+import aiohttp
+import asyncio
+import uvicorn
+
+
+class BaseMessageAPI:
+    def __init__(self, host: str = "0.0.0.0", port: int = 18000):
+        self.app = FastAPI()
+        self.host = host
+        self.port = port
+        self.message_handlers: List[Callable] = []
+        self._setup_routes()
+        self._running = False
+
+    def _setup_routes(self):
+        """设置基础路由"""
+
+        @self.app.post("/api/message")
+        async def handle_message(message: Dict[str, Any]):
+            # try:
+            for handler in self.message_handlers:
+                await handler(message)
+            return {"status": "success"}
+            # except Exception as e:
+            #     raise HTTPException(status_code=500, detail=str(e)) from e
+
+    def register_message_handler(self, handler: Callable):
+        """注册消息处理函数"""
+        self.message_handlers.append(handler)
+
+    async def send_message(self, url: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """发送消息到指定端点"""
+        async with aiohttp.ClientSession() as session:
+            try:
+                async with session.post(
+                    url, json=data, headers={"Content-Type": "application/json"}
+                ) as response:
+                    return await response.json()
+            except Exception as e:
+                # logger.error(f"发送消息失败: {str(e)}")
+                pass
+
+    def run_sync(self):
+        """同步方式运行服务器"""
+        uvicorn.run(self.app, host=self.host, port=self.port)
+
+    async def run(self):
+        """异步方式运行服务器"""
+        config = uvicorn.Config(
+            self.app, host=self.host, port=self.port, loop="asyncio"
+        )
+        self.server = uvicorn.Server(config)
+        try:
+            await self.server.serve()
+        except KeyboardInterrupt as e:
+            self.stop()
+            raise KeyboardInterrupt from e
+
+    async def start_server(self):
+        """启动服务器的异步方法"""
+        if not self._running:
+            self._running = True
+            await self.run()
+
+    async def stop(self):
+        """停止服务器"""
+        if hasattr(self, "server"):
+            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()
+
+    def start(self):
+        """启动服务器的便捷方法"""
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            loop.run_until_complete(self.start_server())
+        except KeyboardInterrupt:
+            pass
+        finally:
+            loop.close()

maim_message-0.2.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "maim_message"
+version = "0.2.0"
+description = "A message handling library"
+authors = [
+    {name = "tcmofashi"}
+]
+requires-python = ">=3.9"
+dependencies = [
+    "fastapi>=0.70.0",
+    "uvicorn>=0.15.0",
+    "aiohttp>=3.8.0",
+    "pydantic>=1.9.0",
+    "websockets>=10.0",
+]
+
+[build-system]
+requires = ["setuptools>=45", "wheel", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
+
+[tool.black]
+line-length = 100
+target-version = ['py39']
+include = '\.pyi?$'
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+line_length = 100
+
+[tool.mypy]
+python_version = "3.9"
+strict = true
+ignore_missing_imports = true

maim_message-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

maim_message-0.2.0/setup.py

@@ -0,0 +1,17 @@
+import setuptools
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="maim_message",
+    version="0.2.0",
+    author="tcmofashi",
+    url="https://github.com/MaiM-with-u/maim_message",
+    author_email="mofashiforzbx@qq.com",
+    description="A message handling library for maimcore",
+    long_description_content_type="text/markdown",
+    package_dir={"": "src"},
+    packages=setuptools.find_packages(where="src"),
+    python_requires=">=3.9",
+)

maim_message-0.2.0/src/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-0.2.0/src/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-0.2.0/src/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-0.2.0/src/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/src/maim_message.egg-info/PKG-INFO

@@ -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/src/maim_message.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+.gitignore
+LICENSE
+README.md
+api.py
+pyproject.toml
+setup.py
+src/maim_message/__init__.py
+src/maim_message/api.py
+src/maim_message/message_base.py
+src/maim_message/router.py
+src/maim_message.egg-info/PKG-INFO
+src/maim_message.egg-info/SOURCES.txt
+src/maim_message.egg-info/dependency_links.txt
+src/maim_message.egg-info/requires.txt
+src/maim_message.egg-info/top_level.txt

maim_message-0.2.0/src/maim_message.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

maim_message-0.2.0/src/maim_message.egg-info/requires.txt

@@ -0,0 +1,5 @@
+fastapi>=0.70.0
+uvicorn>=0.15.0
+aiohttp>=3.8.0
+pydantic>=1.9.0
+websockets>=10.0

maim_message-0.2.0/src/maim_message.egg-info/top_level.txt

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