ErisPulse-OneBot11Adapter 3.0.0__tar.gz

erispulse_onebot11adapter-3.0.0/ErisPulse_OneBot11Adapter.egg-info/PKG-INFO

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: ErisPulse-OneBot11Adapter
+Version: 3.0.0
+Summary: ErisPulse的OneBotV11协议适配模块，异步的OneBot触发器
+Author-email: wsu2059q <wsu2059@qq.com>
+License: MIT License
+        
+        Copyright (c) 2025 WSu2059
+        
+        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.
+        
+Project-URL: homepage, https://github.com/ErisPulse/ErisPulse-OneBot11Adapter
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# OneBotAdapter 模块文档
+
+## 简介
+OneBotAdapter 是基于 [ErisPulse](https://github.com/ErisPulse/ErisPulse/) 架构开发的 **OneBot V11 协议适配器模块**。它提供统一的事件处理机制、连接管理功能，并支持 Server 和 Connect 两种运行模式。
+
+---
+
+## 使用示例
+
+### 初始化与事件处理
+
+```python
+from ErisPulse import sdk
+
+async def main():
+    # 初始化 SDK
+    sdk.init()
+
+    # 获取适配器实例
+    onebot = sdk.adapter.QQ
+
+    # 注册事件处理器
+    @onebot.on("message")
+    async def handle_message(data):
+        print(f"收到消息: {data}")
+        await onebot.Send.To("user", data["user_id"]).Text("已收到您的消息！")
+
+    @onebot.on("notice")
+    async def handle_notice(data):
+        print(f"收到通知: {data}")
+
+    @onebot.on("request")
+    async def handle_request(data):
+        print(f"收到请求: {data}")
+
+    # 启动适配器
+    await sdk.adapter.startup()
+
+    # 保持程序运行
+    await asyncio.Event().wait()
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())
+```
+
+---
+
+### 消息发送示例（DSL 链式风格）
+
+#### 文本消息
+```python
+await onebot.Send.To("group", 123456).Text("Hello World!")
+```
+
+#### 图片消息
+```python
+await onebot.Send.To("user", 123456).Image("http://example.com/image.jpg")
+```
+
+#### 语音消息
+```python
+await onebot.Send.To("user", 123456).Voice("http://example.com/audio.mp3")
+```
+
+#### 视频消息
+```python
+await onebot.Send.To("group", 123456).Video("http://example.com/video.mp4")
+```
+
+#### 发送原生 CQ 消息
+```python
+await onebot.Send.To("user", 123456).Raw([
+    {"type": "text", "data": {"text": "你好"}},
+    {"type": "image", "data": {"file": "http://example.com/image.png"}}
+])
+```
+
+---
+
+## 支持的消息类型及对应方法
+
+| 方法名   | 参数说明 | 用途 |
+|----------|----------|------|
+| `.Text(text: str)` | 发送纯文本消息 | 基础消息类型 |
+| `.Image(file: str)` | 发送图片消息（URL 或 Base64） | 支持 CQ 格式 |
+| `.Voice(file: str)` | 发送语音消息 | 支持 CQ 格式 |
+| `.Video(file: str)` | 发送视频消息 | 支持 CQ 格式 |
+| `.Raw(message_list: List[Dict])` | 发送原始 OneBot 消息结构 | 自定义消息内容 |
+
+---
+
+## 配置说明
+
+在 `env.py` 中进行如下配置：
+
+```python
+sdk.env.set("OneBotAdapter", {
+    "mode": "client",  # 可选 server 或 client
+    "server": {
+        "host": "127.0.0.1",      # WebSocket 监听地址
+        "port": 8080,             # WebSocket 监听端口
+        "path": "/",              # WebSocket 路径
+        "token": "your_token"     # 认证 Token（可选）
+    },
+    "client": {
+        "url": "ws://127.0.0.1:3001",  # 连接的目标地址
+        "token": "your_token"         # 请求头或查询参数中的 Token
+    }
+})
+```
+
+---
+
+## 事件类型
+
+支持以下 OneBot 标准事件类型：
+
+| 事件类型       | 映射名称 | 说明 |
+|----------------|----------|------|
+| `message`      | `message` | 消息事件 |
+| `notice`       | `notice`  | 通知类事件（如群成员变动） |
+| `request`      | `request` | 请求类事件（如加群请求） |
+| `meta_event`   | `meta_event` | 元事件（如心跳包） |
+
+---
+
+## API 调用方式
+
+通过 `call_api` 方法调用 OneBot 提供的任意 API 接口：
+
+```python
+response = await onebot.call_api(
+    endpoint="send_msg",
+    message_type="group",
+    group_id=123456,
+    message="Hello!"
+)
+```
+
+该方法会自动处理响应结果并返回，若超时将抛出异常。
+
+---
+
+## 运行模式说明
+
+### Server 模式（作为服务端监听连接）
+
+- 启动一个 WebSocket 服务器等待 OneBot 客户端连接。
+- 适用于部署多个 bot 客户端连接至同一服务端的场景。
+
+### Client 模式（主动连接 OneBot）
+
+- 主动连接到 OneBot 服务（如 go-cqhttp）。
+- 更适合单个 bot 实例直接连接的情况。
+
+---
+
+## 生命周期管理
+
+### 启动适配器
+```python
+await sdk.adapter.startup()
+```
+此方法会根据配置启动 Server 或连接到 OneBot 客户端。
+
+### 关闭适配器
+```python
+await sdk.adapter.shutdown()
+```
+确保资源释放，关闭 WebSocket 连接。
+
+---
+
+## 注意事项
+
+1. 所有 `.Send.*()` 方法返回 `asyncio.Task`，建议使用 `await` 等待执行完成。
+2. 确保在调用 `startup()` 前完成所有事件处理器注册。
+3. 生产环境建议启用 Token 认证以保证安全性。
+4. 若使用 Server 模式，请注意防火墙和端口开放情况。
+5. 程序退出时请调用 `shutdown()` 释放资源。
+
+---
+
+## 参考链接
+
+- [ErisPulse 主库](https://github.com/ErisPulse/ErisPulse/)
+- [OneBot V11 协议文档](https://github.com/botuniverse/onebot-11)
+- [go-cqhttp 项目地址](https://github.com/Mrs4s/go-cqhttp)
+- [模块开发指南](https://github.com/ErisPulse/ErisPulse/tree/main/docs/DEVELOPMENT.md)

erispulse_onebot11adapter-3.0.0/ErisPulse_OneBot11Adapter.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+ErisPulse_OneBot11Adapter.egg-info/PKG-INFO
+ErisPulse_OneBot11Adapter.egg-info/SOURCES.txt
+ErisPulse_OneBot11Adapter.egg-info/dependency_links.txt
+ErisPulse_OneBot11Adapter.egg-info/entry_points.txt
+ErisPulse_OneBot11Adapter.egg-info/top_level.txt
+OneBotAdapter/Converter.py
+OneBotAdapter/Core.py
+OneBotAdapter/__init__.py

erispulse_onebot11adapter-3.0.0/ErisPulse_OneBot11Adapter.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

erispulse_onebot11adapter-3.0.0/ErisPulse_OneBot11Adapter.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[erispulse.adapter]
+onebot11 = OneBotAdapter:OneBotAdapter
+qq = OneBotAdapter:OneBotAdapter

erispulse_onebot11adapter-3.0.0/ErisPulse_OneBot11Adapter.egg-info/top_level.txt

@@ -0,0 +1 @@
+OneBotAdapter

erispulse_onebot11adapter-3.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 WSu2059
+
+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.

erispulse_onebot11adapter-3.0.0/OneBotAdapter/Converter.py

@@ -0,0 +1,265 @@
+import time
+from typing import Dict, Optional, List, Any
+
+class OneBot11Converter:
+    def __init__(self):
+        self._setup_event_mapping()
+    
+    def _setup_event_mapping(self):
+        """初始化事件类型映射"""
+        self.event_map = {
+            "message": "message",
+            "notice": "notice",
+            "request": "request",
+            "meta_event": "meta_event"
+        }
+        
+        self.notice_subtypes = {
+            "group_upload": "group_file_upload",
+            "group_admin": "group_admin_change",
+            "group_decrease": "group_member_decrease",
+            "group_increase": "group_member_increase",
+            "group_ban": "group_ban",
+            "friend_add": "friend_increase",
+            "friend_delete": "friend_decrease",
+            "group_recall": "message_recall",
+            "friend_recall": "message_recall",
+            "notify": "notify"
+        }
+
+    def convert(self, raw_event: Dict) -> Optional[Dict]:
+        """
+        将OneBot11事件转换为OneBot12格式
+        
+        :param raw_event: 原始OneBot11事件数据
+        :return: 转换后的OneBot12事件，None表示不支持的事件类型
+        """
+        if not isinstance(raw_event, dict):
+            raise ValueError("事件数据必须是字典类型")
+
+        post_type = raw_event.get("post_type")
+        if post_type not in self.event_map:
+            return None
+
+        # 基础事件结构
+        onebot_event = {
+            "id": str(raw_event.get("time", int(time.time()))),
+            "time": raw_event.get("time", int(time.time())),
+            "platform": "onebot11",
+            "self": {
+                "platform": "onebot11",
+                "user_id": str(raw_event.get("self_id", ""))
+            },
+            "onebot11_raw": raw_event  # 保留原始数据
+        }
+
+        # 根据事件类型分发处理
+        handler = getattr(self, f"_handle_{post_type}", None)
+        if handler:
+            return handler(raw_event, onebot_event)
+        
+        return None
+
+    def _handle_message(self, raw_event: Dict, base_event: Dict) -> Dict:
+        """处理消息事件"""
+        message_type = raw_event["message_type"]
+        detail_type = "private" if message_type == "private" else "group"
+        
+        # 解析CQ码消息
+        message_segments = self._parse_cq_code(raw_event["message"])
+        alt_message = self._generate_alt_message(message_segments)
+        
+        base_event.update({
+            "type": "message",
+            "detail_type": detail_type,
+            "message_id": str(raw_event.get("message_id", "")),
+            "message": message_segments,
+            "alt_message": alt_message,
+            "user_id": str(raw_event.get("user_id", "")),
+            "onebot11_message": raw_event["message"]
+        })
+
+        if detail_type == "group":
+            base_event["group_id"] = str(raw_event.get("group_id", ""))
+        
+        # 处理子类型
+        if raw_event.get("sub_type") == "group":
+            base_event["sub_type"] = "group"
+        elif raw_event.get("sub_type") == "friend":
+            base_event["sub_type"] = "friend"
+        
+        return base_event
+
+    def _parse_cq_code(self, message: Any) -> List[Dict]:
+        """解析CQ码消息为OneBot12消息段"""
+        if isinstance(message, str):
+            return [{"type": "text", "data": {"text": message}}]
+        
+        segments = []
+        for segment in message:
+            if isinstance(segment, str):
+                segments.append({"type": "text", "data": {"text": segment}})
+            elif isinstance(segment, dict):
+                cq_type = segment["type"]
+                if cq_type == "text":
+                    segments.append({"type": "text", "data": {"text": segment["data"]["text"]}})
+                elif cq_type == "image":
+                    segments.append({
+                        "type": "image",
+                        "data": {
+                            "file": segment["data"].get("file"),
+                            "url": segment["data"].get("url"),
+                            "cache": segment["data"].get("cache", 1),
+                            "sub_type": segment["data"].get("type", 0)
+                        }
+                    })
+                elif cq_type == "record":
+                    segments.append({
+                        "type": "audio",
+                        "data": {
+                            "file": segment["data"].get("file"),
+                            "url": segment["data"].get("url"),
+                            "magic": segment["data"].get("magic", 0)
+                        }
+                    })
+                elif cq_type == "at":
+                    segments.append({
+                        "type": "mention",
+                        "data": {
+                            "user_id": segment["data"].get("qq"),
+                            "user_name": segment["data"].get("name", "")
+                        }
+                    })
+                else:
+                    segments.append({
+                        "type": f"onebot11_{cq_type}",
+                        "data": segment["data"]
+                    })
+        
+        return segments
+
+    def _generate_alt_message(self, segments: List[Dict]) -> str:
+        """生成替代文本消息"""
+        parts = []
+        for seg in segments:
+            if seg["type"] == "text":
+                parts.append(seg["data"]["text"])
+            elif seg["type"] == "image":
+                parts.append("[图片]")
+            elif seg["type"] == "audio":
+                parts.append("[语音]")
+            elif seg["type"] == "mention":
+                parts.append(f"@{seg['data'].get('user_name', seg['data'].get('user_id', ''))}")
+        return "".join(parts)
+
+    def _handle_notice(self, raw_event: Dict, base_event: Dict) -> Dict:
+        """处理通知事件"""
+        notice_type = raw_event["notice_type"]
+        sub_type = raw_event.get("sub_type", "")
+        
+        # 映射通知子类型
+        detail_type = self.notice_subtypes.get(notice_type, notice_type)
+        
+        base_event.update({
+            "type": "notice",
+            "detail_type": detail_type,
+            "onebot11_notice": raw_event
+        })
+        
+        # 处理不同类型的通知
+        if notice_type == "group_upload":
+            base_event.update({
+                "group_id": str(raw_event.get("group_id")),
+                "user_id": str(raw_event.get("user_id")),
+                "onebot11_file": raw_event.get("file")
+            })
+        elif notice_type == "group_admin":
+            base_event.update({
+                "group_id": str(raw_event.get("group_id")),
+                "user_id": str(raw_event.get("user_id")),
+                "sub_type": "set" if sub_type == "set" else "unset"
+            })
+        elif notice_type in ["group_increase", "group_decrease"]:
+            base_event.update({
+                "group_id": str(raw_event.get("group_id")),
+                "user_id": str(raw_event.get("user_id")),
+                "operator_id": str(raw_event.get("operator_id", "")),
+                "sub_type": sub_type
+            })
+        elif notice_type == "group_ban":
+            base_event.update({
+                "group_id": str(raw_event.get("group_id")),
+                "operator_id": str(raw_event.get("operator_id")),
+                "user_id": str(raw_event.get("user_id")),
+                "duration": raw_event.get("duration", 0)
+            })
+        elif notice_type in ["friend_add", "friend_delete"]:
+            base_event.update({
+                "user_id": str(raw_event.get("user_id"))
+            })
+        elif notice_type in ["group_recall", "friend_recall"]:
+            base_event.update({
+                "message_id": str(raw_event.get("message_id")),
+                "user_id": str(raw_event.get("user_id")),
+                "group_id": str(raw_event.get("group_id", "")) if notice_type == "group_recall" else None
+            })
+        elif notice_type == "notify":
+            if sub_type == "honor":
+                base_event.update({
+                    "group_id": str(raw_event.get("group_id")),
+                    "user_id": str(raw_event.get("user_id")),
+                    "honor_type": raw_event.get("honor_type")
+                })
+            elif sub_type == "poke":
+                base_event.update({
+                    "group_id": str(raw_event.get("group_id", "")),
+                    "user_id": str(raw_event.get("user_id")),
+                    "target_id": str(raw_event.get("target_id"))
+                })
+        
+        return base_event
+
+    def _handle_request(self, raw_event: Dict, base_event: Dict) -> Dict:
+        """处理请求事件"""
+        request_type = raw_event["request_type"]
+        
+        base_event.update({
+            "type": "request",
+            "detail_type": f"onebot11_{request_type}",
+            "onebot11_request": raw_event
+        })
+        
+        if request_type == "friend":
+            base_event.update({
+                "user_id": str(raw_event.get("user_id")),
+                "comment": raw_event.get("comment"),
+                "flag": raw_event.get("flag")
+            })
+        elif request_type == "group":
+            base_event.update({
+                "group_id": str(raw_event.get("group_id")),
+                "user_id": str(raw_event.get("user_id")),
+                "comment": raw_event.get("comment"),
+                "sub_type": raw_event.get("sub_type"),
+                "flag": raw_event.get("flag")
+            })
+        
+        return base_event
+
+    def _handle_meta_event(self, raw_event: Dict, base_event: Dict) -> Dict:
+        """处理元事件"""
+        meta_type = raw_event["meta_event_type"]
+        
+        base_event.update({
+            "type": "meta_event",
+            "detail_type": f"onebot11_{meta_type}",
+            "onebot11_meta": raw_event
+        })
+        
+        if meta_type == "lifecycle":
+            base_event["sub_type"] = raw_event.get("sub_type", "")
+        elif meta_type == "heartbeat":
+            base_event["interval"] = raw_event.get("interval", 0)
+            base_event["status"] = raw_event.get("status", {})
+        
+        return base_event

erispulse_onebot11adapter-3.0.0/OneBotAdapter/Core.py

@@ -0,0 +1,276 @@
+import asyncio
+import json
+import aiohttp
+from fastapi import WebSocket, WebSocketDisconnect
+from typing import Dict, List, Optional, Any, Type
+from ErisPulse import sdk
+from ErisPulse.Core import adapter_server
+
+class OneBotAdapter(sdk.BaseAdapter):
+    class Send(sdk.BaseAdapter.Send):
+        def Text(self, text: str):
+            return asyncio.create_task(
+                self._adapter.call_api(
+                    endpoint="send_msg",
+                    message_type="private" if self._target_type == "user" else "group",
+                    user_id=self._target_id if self._target_type == "user" else None,
+                    group_id=self._target_id if self._target_type == "group" else None,
+                    message=text
+                )
+            )
+
+        def Image(self, file: str):
+            return self._send("image", {"file": file})
+
+        def Voice(self, file: str):
+            return self._send("voice", {"file": file})
+
+        def Video(self, file: str):
+            return self._send("video", {"file": file})
+
+        def Raw(self, message_list):
+            """
+            发送原生OneBot消息列表格式
+            :param message_list: List[Dict], 例如：
+                [{"type": "text", "data": {"text": "Hello"}}, {"type": "image", "data": {"file": "http://..."}}
+            """
+            raw_message = ''.join([
+                f"[CQ:{msg['type']},{','.join([f'{k}={v}' for k, v in msg['data'].items()])}]"
+                for msg in message_list
+            ])
+            return self._send_raw(raw_message)
+
+        def Recall(self, message_id: int):
+            return asyncio.create_task(
+                self._adapter.call_api(
+                    endpoint="delete_msg",
+                    message_id=message_id
+                )
+            )
+
+        async def Edit(self, message_id: int, new_text: str):
+            await self.Recall(message_id)
+            return self.Text(new_text)
+
+        def Batch(self, target_ids: List[str], text: str, target_type: str = "user"):
+            tasks = []
+            for target_id in target_ids:
+                task = asyncio.create_task(
+                    self._adapter.call_api(
+                        endpoint="send_msg",
+                        message_type=target_type,
+                        user_id=target_id if target_type == "user" else None,
+                        group_id=target_id if target_type == "group" else None,
+                        message=text
+                    )
+                )
+                tasks.append(task)
+            return tasks
+
+        def _send(self, msg_type: str, data: dict):
+            message = f"[CQ:{msg_type},{','.join([f'{k}={v}' for k, v in data.items()])}]"
+            return self._send_raw(message)
+
+        def _send_raw(self, message: str):
+            return asyncio.create_task(
+                self._adapter.call_api(
+                    endpoint="send_msg",
+                    message_type="private" if self._target_type == "user" else "group",
+                    user_id=self._target_id if self._target_type == "user" else None,
+                    group_id=self._target_id if self._target_type == "group" else None,
+                    message=message
+                )
+            )
+
+    def __init__(self, sdk):
+        super().__init__()
+        self.sdk = sdk
+        self.logger = sdk.logger
+        self.adapter = self.sdk.adapter
+
+        self.config = self._load_config()
+        self._api_response_futures = {}
+        self.session: Optional[aiohttp.ClientSession] = None
+        self.connection: Optional[aiohttp.ClientWebSocketResponse] = None
+        self._setup_event_mapping()
+        self.logger.info("OneBot适配器初始化完成")
+
+        self.convert = self._setup_coverter()
+
+    def _setup_coverter(self):
+        from .Converter import OneBot11Converter
+        convert = OneBot11Converter()
+        return convert.convert
+
+    def _load_config(self) -> Dict:
+        config = self.sdk.env.getConfig("OneBotv11_Adapter")
+        self.logger.debug(f"读取配置: {config}")
+        if not config:
+            default_config = {
+                "mode": "server",
+                "server": {
+                    "path": "/",
+                    "token": ""
+                },
+                "client": {
+                    "url": "ws://127.0.0.1:3001",
+                    "token": ""
+                }
+            }
+            try:
+                sdk.logger.warning("配置文件不存在，已创建默认配置文件")
+                self.sdk.env.setConfig("OneBotv11_Adapter", default_config)
+                return default_config
+            except Exception as e:
+                self.logger.error(f"保存默认配置失败: {str(e)}")
+                return default_config
+        return config
+
+    def _setup_event_mapping(self):
+        self.event_map = {
+            "message": "message",
+            "notice": "notice",
+            "request": "request",
+            "meta_event": "meta_event"
+        }
+        self.logger.debug("事件映射已设置")
+
+    async def call_api(self, endpoint: str, **params):
+        if not self.connection:
+            raise ConnectionError("尚未连接到OneBot")
+
+        echo = str(hash(str(params)))
+        future = asyncio.get_event_loop().create_future()
+        self._api_response_futures[echo] = future
+
+        payload = {
+            "action": endpoint,
+            "params": params,
+            "echo": echo
+        }
+
+        await self.connection.send_str(json.dumps(payload))
+        self.logger.debug(f"调用OneBot API: {endpoint}")
+
+        try:
+            result = await asyncio.wait_for(future, timeout=30)
+            return result
+        except asyncio.TimeoutError:
+            future.cancel()
+            self.logger.error(f"API调用超时: {endpoint}")
+            raise TimeoutError(f"API调用超时: {endpoint}")
+            return None
+        finally:
+            if echo in self._api_response_futures:
+                del self._api_response_futures[echo]
+                self.logger.debug(f"已删除API响应Future: {echo}")
+    async def connect(self, retry_interval=30):
+        if self.config.get("mode") != "client":
+            return
+
+        self.session = aiohttp.ClientSession()
+        headers = {}
+        if token := self.config.get("client", {}).get("token"):
+            headers["Authorization"] = f"Bearer {token}"
+
+        url = self.config["client"]["url"]
+        retry_count = 0
+
+        while True:
+            try:
+                self.connection = await self.session.ws_connect(url, headers=headers)
+                self.logger.info(f"成功连接到OneBot服务器: {url}")
+                asyncio.create_task(self._listen())
+                return
+            except Exception as e:
+                retry_count += 1
+                self.logger.error(f"第 {retry_count} 次连接失败: {str(e)}")
+                self.logger.info(f"将在 {retry_interval} 秒后重试...")
+                await asyncio.sleep(retry_interval)
+
+    async def _listen(self):
+        try:
+            async for msg in self.connection:
+                if msg.type == aiohttp.WSMsgType.TEXT:
+                    await self._handle_message(msg.data)
+                elif msg.type == aiohttp.WSMsgType.CLOSED:
+                    break
+                elif msg.type == aiohttp.WSMsgType.ERROR:
+                    self.logger.error(f"WebSocket错误: {self.connection.exception()}")
+        except Exception as e:
+            self.logger.error(f"WebSocket监听异常: {str(e)}")
+
+    async def _handle_message(self, raw_msg: str):
+        try:
+            data = json.loads(raw_msg)
+            if "echo" in data:
+                echo = data["echo"]
+                future = self._api_response_futures.get(echo)
+                if future and not future.done():
+                    future.set_result(data.get("data"))
+                return
+
+            post_type = data.get("post_type")
+            event_type = self.event_map.get(post_type, "unknown")
+            await self.emit(event_type, data)
+            self.logger.debug(f"处理OneBot事件: {event_type}")
+            if hasattr(self.adapter, "emit"):
+                onebot_event = self.convert(data)
+                self.logger.debug(f"OneBot12事件数据: {json.dumps(onebot_event, ensure_ascii=False)}")
+                if onebot_event:
+                    await self.adapter.emit(onebot_event)
+
+        except json.JSONDecodeError:
+            self.logger.error(f"JSON解析失败: {raw_msg}")
+        except Exception as e:
+            self.logger.error(f"消息处理异常: {str(e)}")
+    async def _ws_handler(self, websocket: WebSocket):
+        self.connection = websocket
+        self.logger.info("新的OneBot客户端已连接")
+
+        try:
+            while True:
+                data = await websocket.receive_text()
+                await self._handle_message(data)
+        except WebSocketDisconnect:
+            self.logger.info("OneBot客户端断开连接")
+        except Exception as e:
+            self.logger.error(f"WebSocket处理异常: {str(e)}")
+        finally:
+            self.connection = None
+    
+    async def _auth_handler(self, websocket: WebSocket):
+        if token := self.config["server"].get("token"):
+            client_token = websocket.headers.get("Authorization", "").replace("Bearer ", "")
+            if not client_token:
+                query = dict(websocket.query_params)
+                client_token = query.get("token", "")
+
+            if client_token != token:
+                self.logger.warning("客户端提供的Token无效")
+                await websocket.close(code=1008)
+                return False
+        return True
+    async def start(self):
+        mode = self.config.get("mode")
+        if mode == "server":
+            self.logger.info("正在注册Server模式WebSocket路由")
+            adapter_server.register_websocket(
+                adapter_name="onebot",
+                path="/ws",
+                handler=self._ws_handler,
+                auth_handler=self._auth_handler
+            )
+        elif mode == "client":
+            self.logger.info("正在启动Client模式")
+            await self.connect()
+        else:
+            self.logger.error("无效的模式配置")
+            raise ValueError("模式配置错误")
+
+    async def shutdown(self):
+        if self.connection and not self.connection.closed:
+            await self.connection.close()
+        if self.session:
+            await self.session.close()
+        self.logger.info("OneBot适配器已关闭")

erispulse_onebot11adapter-3.0.0/OneBotAdapter/__init__.py

@@ -0,0 +1 @@
+from .Core import OneBotAdapter

erispulse_onebot11adapter-3.0.0/PKG-INFO

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: ErisPulse-OneBot11Adapter
+Version: 3.0.0
+Summary: ErisPulse的OneBotV11协议适配模块，异步的OneBot触发器
+Author-email: wsu2059q <wsu2059@qq.com>
+License: MIT License
+        
+        Copyright (c) 2025 WSu2059
+        
+        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.
+        
+Project-URL: homepage, https://github.com/ErisPulse/ErisPulse-OneBot11Adapter
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# OneBotAdapter 模块文档
+
+## 简介
+OneBotAdapter 是基于 [ErisPulse](https://github.com/ErisPulse/ErisPulse/) 架构开发的 **OneBot V11 协议适配器模块**。它提供统一的事件处理机制、连接管理功能，并支持 Server 和 Connect 两种运行模式。
+
+---
+
+## 使用示例
+
+### 初始化与事件处理
+
+```python
+from ErisPulse import sdk
+
+async def main():
+    # 初始化 SDK
+    sdk.init()
+
+    # 获取适配器实例
+    onebot = sdk.adapter.QQ
+
+    # 注册事件处理器
+    @onebot.on("message")
+    async def handle_message(data):
+        print(f"收到消息: {data}")
+        await onebot.Send.To("user", data["user_id"]).Text("已收到您的消息！")
+
+    @onebot.on("notice")
+    async def handle_notice(data):
+        print(f"收到通知: {data}")
+
+    @onebot.on("request")
+    async def handle_request(data):
+        print(f"收到请求: {data}")
+
+    # 启动适配器
+    await sdk.adapter.startup()
+
+    # 保持程序运行
+    await asyncio.Event().wait()
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())
+```
+
+---
+
+### 消息发送示例（DSL 链式风格）
+
+#### 文本消息
+```python
+await onebot.Send.To("group", 123456).Text("Hello World!")
+```
+
+#### 图片消息
+```python
+await onebot.Send.To("user", 123456).Image("http://example.com/image.jpg")
+```
+
+#### 语音消息
+```python
+await onebot.Send.To("user", 123456).Voice("http://example.com/audio.mp3")
+```
+
+#### 视频消息
+```python
+await onebot.Send.To("group", 123456).Video("http://example.com/video.mp4")
+```
+
+#### 发送原生 CQ 消息
+```python
+await onebot.Send.To("user", 123456).Raw([
+    {"type": "text", "data": {"text": "你好"}},
+    {"type": "image", "data": {"file": "http://example.com/image.png"}}
+])
+```
+
+---
+
+## 支持的消息类型及对应方法
+
+| 方法名   | 参数说明 | 用途 |
+|----------|----------|------|
+| `.Text(text: str)` | 发送纯文本消息 | 基础消息类型 |
+| `.Image(file: str)` | 发送图片消息（URL 或 Base64） | 支持 CQ 格式 |
+| `.Voice(file: str)` | 发送语音消息 | 支持 CQ 格式 |
+| `.Video(file: str)` | 发送视频消息 | 支持 CQ 格式 |
+| `.Raw(message_list: List[Dict])` | 发送原始 OneBot 消息结构 | 自定义消息内容 |
+
+---
+
+## 配置说明
+
+在 `env.py` 中进行如下配置：
+
+```python
+sdk.env.set("OneBotAdapter", {
+    "mode": "client",  # 可选 server 或 client
+    "server": {
+        "host": "127.0.0.1",      # WebSocket 监听地址
+        "port": 8080,             # WebSocket 监听端口
+        "path": "/",              # WebSocket 路径
+        "token": "your_token"     # 认证 Token（可选）
+    },
+    "client": {
+        "url": "ws://127.0.0.1:3001",  # 连接的目标地址
+        "token": "your_token"         # 请求头或查询参数中的 Token
+    }
+})
+```
+
+---
+
+## 事件类型
+
+支持以下 OneBot 标准事件类型：
+
+| 事件类型       | 映射名称 | 说明 |
+|----------------|----------|------|
+| `message`      | `message` | 消息事件 |
+| `notice`       | `notice`  | 通知类事件（如群成员变动） |
+| `request`      | `request` | 请求类事件（如加群请求） |
+| `meta_event`   | `meta_event` | 元事件（如心跳包） |
+
+---
+
+## API 调用方式
+
+通过 `call_api` 方法调用 OneBot 提供的任意 API 接口：
+
+```python
+response = await onebot.call_api(
+    endpoint="send_msg",
+    message_type="group",
+    group_id=123456,
+    message="Hello!"
+)
+```
+
+该方法会自动处理响应结果并返回，若超时将抛出异常。
+
+---
+
+## 运行模式说明
+
+### Server 模式（作为服务端监听连接）
+
+- 启动一个 WebSocket 服务器等待 OneBot 客户端连接。
+- 适用于部署多个 bot 客户端连接至同一服务端的场景。
+
+### Client 模式（主动连接 OneBot）
+
+- 主动连接到 OneBot 服务（如 go-cqhttp）。
+- 更适合单个 bot 实例直接连接的情况。
+
+---
+
+## 生命周期管理
+
+### 启动适配器
+```python
+await sdk.adapter.startup()
+```
+此方法会根据配置启动 Server 或连接到 OneBot 客户端。
+
+### 关闭适配器
+```python
+await sdk.adapter.shutdown()
+```
+确保资源释放，关闭 WebSocket 连接。
+
+---
+
+## 注意事项
+
+1. 所有 `.Send.*()` 方法返回 `asyncio.Task`，建议使用 `await` 等待执行完成。
+2. 确保在调用 `startup()` 前完成所有事件处理器注册。
+3. 生产环境建议启用 Token 认证以保证安全性。
+4. 若使用 Server 模式，请注意防火墙和端口开放情况。
+5. 程序退出时请调用 `shutdown()` 释放资源。
+
+---
+
+## 参考链接
+
+- [ErisPulse 主库](https://github.com/ErisPulse/ErisPulse/)
+- [OneBot V11 协议文档](https://github.com/botuniverse/onebot-11)
+- [go-cqhttp 项目地址](https://github.com/Mrs4s/go-cqhttp)
+- [模块开发指南](https://github.com/ErisPulse/ErisPulse/tree/main/docs/DEVELOPMENT.md)

erispulse_onebot11adapter-3.0.0/README.md

@@ -0,0 +1,190 @@
+# OneBotAdapter 模块文档
+
+## 简介
+OneBotAdapter 是基于 [ErisPulse](https://github.com/ErisPulse/ErisPulse/) 架构开发的 **OneBot V11 协议适配器模块**。它提供统一的事件处理机制、连接管理功能，并支持 Server 和 Connect 两种运行模式。
+
+---
+
+## 使用示例
+
+### 初始化与事件处理
+
+```python
+from ErisPulse import sdk
+
+async def main():
+    # 初始化 SDK
+    sdk.init()
+
+    # 获取适配器实例
+    onebot = sdk.adapter.QQ
+
+    # 注册事件处理器
+    @onebot.on("message")
+    async def handle_message(data):
+        print(f"收到消息: {data}")
+        await onebot.Send.To("user", data["user_id"]).Text("已收到您的消息！")
+
+    @onebot.on("notice")
+    async def handle_notice(data):
+        print(f"收到通知: {data}")
+
+    @onebot.on("request")
+    async def handle_request(data):
+        print(f"收到请求: {data}")
+
+    # 启动适配器
+    await sdk.adapter.startup()
+
+    # 保持程序运行
+    await asyncio.Event().wait()
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())
+```
+
+---
+
+### 消息发送示例（DSL 链式风格）
+
+#### 文本消息
+```python
+await onebot.Send.To("group", 123456).Text("Hello World!")
+```
+
+#### 图片消息
+```python
+await onebot.Send.To("user", 123456).Image("http://example.com/image.jpg")
+```
+
+#### 语音消息
+```python
+await onebot.Send.To("user", 123456).Voice("http://example.com/audio.mp3")
+```
+
+#### 视频消息
+```python
+await onebot.Send.To("group", 123456).Video("http://example.com/video.mp4")
+```
+
+#### 发送原生 CQ 消息
+```python
+await onebot.Send.To("user", 123456).Raw([
+    {"type": "text", "data": {"text": "你好"}},
+    {"type": "image", "data": {"file": "http://example.com/image.png"}}
+])
+```
+
+---
+
+## 支持的消息类型及对应方法
+
+| 方法名   | 参数说明 | 用途 |
+|----------|----------|------|
+| `.Text(text: str)` | 发送纯文本消息 | 基础消息类型 |
+| `.Image(file: str)` | 发送图片消息（URL 或 Base64） | 支持 CQ 格式 |
+| `.Voice(file: str)` | 发送语音消息 | 支持 CQ 格式 |
+| `.Video(file: str)` | 发送视频消息 | 支持 CQ 格式 |
+| `.Raw(message_list: List[Dict])` | 发送原始 OneBot 消息结构 | 自定义消息内容 |
+
+---
+
+## 配置说明
+
+在 `env.py` 中进行如下配置：
+
+```python
+sdk.env.set("OneBotAdapter", {
+    "mode": "client",  # 可选 server 或 client
+    "server": {
+        "host": "127.0.0.1",      # WebSocket 监听地址
+        "port": 8080,             # WebSocket 监听端口
+        "path": "/",              # WebSocket 路径
+        "token": "your_token"     # 认证 Token（可选）
+    },
+    "client": {
+        "url": "ws://127.0.0.1:3001",  # 连接的目标地址
+        "token": "your_token"         # 请求头或查询参数中的 Token
+    }
+})
+```
+
+---
+
+## 事件类型
+
+支持以下 OneBot 标准事件类型：
+
+| 事件类型       | 映射名称 | 说明 |
+|----------------|----------|------|
+| `message`      | `message` | 消息事件 |
+| `notice`       | `notice`  | 通知类事件（如群成员变动） |
+| `request`      | `request` | 请求类事件（如加群请求） |
+| `meta_event`   | `meta_event` | 元事件（如心跳包） |
+
+---
+
+## API 调用方式
+
+通过 `call_api` 方法调用 OneBot 提供的任意 API 接口：
+
+```python
+response = await onebot.call_api(
+    endpoint="send_msg",
+    message_type="group",
+    group_id=123456,
+    message="Hello!"
+)
+```
+
+该方法会自动处理响应结果并返回，若超时将抛出异常。
+
+---
+
+## 运行模式说明
+
+### Server 模式（作为服务端监听连接）
+
+- 启动一个 WebSocket 服务器等待 OneBot 客户端连接。
+- 适用于部署多个 bot 客户端连接至同一服务端的场景。
+
+### Client 模式（主动连接 OneBot）
+
+- 主动连接到 OneBot 服务（如 go-cqhttp）。
+- 更适合单个 bot 实例直接连接的情况。
+
+---
+
+## 生命周期管理
+
+### 启动适配器
+```python
+await sdk.adapter.startup()
+```
+此方法会根据配置启动 Server 或连接到 OneBot 客户端。
+
+### 关闭适配器
+```python
+await sdk.adapter.shutdown()
+```
+确保资源释放，关闭 WebSocket 连接。
+
+---
+
+## 注意事项
+
+1. 所有 `.Send.*()` 方法返回 `asyncio.Task`，建议使用 `await` 等待执行完成。
+2. 确保在调用 `startup()` 前完成所有事件处理器注册。
+3. 生产环境建议启用 Token 认证以保证安全性。
+4. 若使用 Server 模式，请注意防火墙和端口开放情况。
+5. 程序退出时请调用 `shutdown()` 释放资源。
+
+---
+
+## 参考链接
+
+- [ErisPulse 主库](https://github.com/ErisPulse/ErisPulse/)
+- [OneBot V11 协议文档](https://github.com/botuniverse/onebot-11)
+- [go-cqhttp 项目地址](https://github.com/Mrs4s/go-cqhttp)
+- [模块开发指南](https://github.com/ErisPulse/ErisPulse/tree/main/docs/DEVELOPMENT.md)

erispulse_onebot11adapter-3.0.0/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "ErisPulse-OneBot11Adapter"
+version = "3.0.0"
+description = "ErisPulse的OneBotV11协议适配模块，异步的OneBot触发器"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { file = "LICENSE" }
+authors = [ { name = "wsu2059q", email = "wsu2059@qq.com" } ]
+dependencies = [
+    
+]
+
+[project.urls]
+"homepage" = "https://github.com/ErisPulse/ErisPulse-OneBot11Adapter"
+
+[project.entry-points."erispulse.adapter"]
+onebot11 = "OneBotAdapter:OneBotAdapter"
+qq = "OneBotAdapter:OneBotAdapter"

erispulse_onebot11adapter-3.0.0/setup.cfg

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