ErisPulse-OneBot12Adapter 1.0.0__py3-none-any.whl

OneBot12Adapter/Core.py

@@ -0,0 +1,616 @@
+# OneBot12Adapter/Core.py
+import asyncio
+import json
+import aiohttp
+from fastapi import WebSocket, WebSocketDisconnect
+from typing import Dict, List, Optional, Union
+from dataclasses import dataclass
+from ErisPulse import sdk
+from ErisPulse.Core import router
+
+@dataclass
+class OneBot12AccountConfig:
+    """OneBot12账户配置"""
+    mode: str  # "server" or "client"
+    server_path: Optional[str] = "/onebot12"
+    server_token: Optional[str] = ""
+    client_url: Optional[str] = "ws://127.0.0.1:3001"
+    client_token: Optional[str] = ""
+    enabled: bool = True
+    name: str = ""
+    # OneBot12特有配置
+    platform: Optional[str] = "onebot12"  # 平台标识
+    implementation: Optional[str] = ""     # 实现标识
+
+class OneBot12Adapter(sdk.BaseAdapter):
+    """OneBot V12 协议适配器"""
+    
+    class Send(sdk.BaseAdapter.Send):
+        """消息发送类 - OneBot12标准"""
+        
+        def Text(self, text: str):
+            return asyncio.create_task(
+                self._adapter.call_api(
+                    endpoint="send_message",
+                    account_id=self._account_id,
+                    detail_type=self._get_detail_type(),
+                    user_id=self._target_id if self._target_type == "user" else None,
+                    group_id=self._target_id if self._target_type == "group" else None,
+                    content={"type": "text", "data": {"text": text}}
+                )
+            )
+        
+        def Image(self, file: Union[str, bytes], filename: str = "image.png"):
+            data = {}
+            if isinstance(file, bytes):
+                # 处理二进制图片数据
+                import base64
+                data["file_base64"] = base64.b64encode(file).decode('utf-8')
+                data["file_name"] = filename
+            else:
+                data["file_id"] = file
+            
+            return asyncio.create_task(
+                self._adapter.call_api(
+                    endpoint="send_message",
+                    account_id=self._account_id,
+                    detail_type=self._get_detail_type(),
+                    user_id=self._target_id if self._target_type == "user" else None,
+                    group_id=self._target_id if self._target_type == "group" else None,
+                    content={"type": "image", "data": data}
+                )
+            )
+        
+        def Audio(self, file: Union[str, bytes], filename: str = "audio.ogg"):
+            data = {}
+            if isinstance(file, bytes):
+                import base64
+                data["file_base64"] = base64.b64encode(file).decode('utf-8')
+                data["file_name"] = filename
+            else:
+                data["file_id"] = file
+            
+            return asyncio.create_task(
+                self._adapter.call_api(
+                    endpoint="send_message",
+                    account_id=self._account_id,
+                    detail_type=self._get_detail_type(),
+                    user_id=self._target_id if self._target_type == "user" else None,
+                    group_id=self._target_id if self._target_type == "group" else None,
+                    content={"type": "audio", "data": data}
+                )
+            )
+        
+        def Video(self, file: Union[str, bytes], filename: str = "video.mp4"):
+            data = {}
+            if isinstance(file, bytes):
+                import base64
+                data["file_base64"] = base64.b64encode(file).decode('utf-8')
+                data["file_name"] = filename
+            else:
+                data["file_id"] = file
+            
+            return asyncio.create_task(
+                self._adapter.call_api(
+                    endpoint="send_message",
+                    account_id=self._account_id,
+                    detail_type=self._get_detail_type(),
+                    user_id=self._target_id if self._target_type == "user" else None,
+                    group_id=self._target_id if self._target_type == "group" else None,
+                    content={"type": "video", "data": data}
+                )
+            )
+        
+        def Mention(self, user_id: Union[str, int], user_name: str = None):
+            # OneBot12的mention应该作为消息段处理
+            return self._send_complex_message([
+                {"type": "mention", "data": {"user_id": str(user_id), "user_name": user_name or ""}}
+            ])
+        
+        def Reply(self, message_id: Union[str, int], content: str = None):
+            # OneBot12的回复消息
+            message_segments = [
+                {"type": "reply", "data": {"message_id": str(message_id)}}
+            ]
+            if content:
+                message_segments.append({"type": "text", "data": {"text": content}})
+            
+            return self._send_complex_message(message_segments)
+        
+        def Location(self, latitude: float, longitude: float, title: str = "", content: str = ""):
+            data = {
+                "latitude": latitude,
+                "longitude": longitude
+            }
+            if title:
+                data["title"] = title
+            if content:
+                data["content"] = content
+            
+            return asyncio.create_task(
+                self._adapter.call_api(
+                    endpoint="send_message",
+                    account_id=self._account_id,
+                    detail_type=self._get_detail_type(),
+                    user_id=self._target_id if self._target_type == "user" else None,
+                    group_id=self._target_id if self._target_type == "group" else None,
+                    content={"type": "location", "data": data}
+                )
+            )
+        
+        def Sticker(self, file_id: str):
+            """发送表情包/贴纸"""
+            return asyncio.create_task(
+                self._adapter.call_api(
+                    endpoint="send_message",
+                    account_id=self._account_id,
+                    detail_type=self._get_detail_type(),
+                    user_id=self._target_id if self._target_type == "user" else None,
+                    group_id=self._target_id if self._target_type == "group" else None,
+                    content={"type": "sticker", "data": {"file_id": file_id}}
+                )
+            )
+        
+        def Raw(self, message_segments: List[Dict]):
+            """发送原始OneBot12消息段列表"""
+            return self._send_complex_message(message_segments)
+        
+        def Recall(self, message_id: Union[str, int]):
+            """撤回消息"""
+            return asyncio.create_task(
+                self._adapter.call_api(
+                    endpoint="delete_message",
+                    account_id=self._account_id,
+                    message_id=str(message_id)
+                )
+            )
+        
+        def Edit(self, message_id: Union[str, int], content: Union[str, List[Dict]]):
+            """编辑消息"""
+            if isinstance(content, str):
+                content = [{"type": "text", "data": {"text": content}}]
+            
+            return asyncio.create_task(
+                self._adapter.call_api(
+                    endpoint="edit_message",
+                    account_id=self._account_id,
+                    message_id=str(message_id),
+                    content=content
+                )
+            )
+        
+        def Batch(self, target_ids: List[str], message: Union[str, List[Dict]], target_type: str = "user"):
+            """批量发送消息"""
+            tasks = []
+            for target_id in target_ids:
+                if isinstance(message, str):
+                    task = self._adapter.call_api(
+                        endpoint="send_message",
+                        account_id=self._account_id,
+                        detail_type=target_type,
+                        user_id=target_id if target_type == "user" else None,
+                        group_id=target_id if target_type == "group" else None,
+                        content=[{"type": "text", "data": {"text": message}}]
+                    )
+                else:
+                    task = self._adapter.call_api(
+                        endpoint="send_message",
+                        account_id=self._account_id,
+                        detail_type=target_type,
+                        user_id=target_id if target_type == "user" else None,
+                        group_id=target_id if target_type == "group" else None,
+                        content=message
+                    )
+                tasks.append(task)
+            return tasks
+        
+        def _get_detail_type(self):
+            """获取消息详细类型"""
+            return "private" if self._target_type == "user" else "group"
+        
+        def _send_complex_message(self, message_segments: List[Dict]):
+            """发送复合消息"""
+            return asyncio.create_task(
+                self._adapter.call_api(
+                    endpoint="send_message",
+                    account_id=self._account_id,
+                    detail_type=self._get_detail_type(),
+                    user_id=self._target_id if self._target_type == "user" else None,
+                    group_id=self._target_id if self._target_type == "group" else None,
+                    content=message_segments
+                )
+            )
+
+    def __init__(self, sdk):
+        super().__init__()
+        self.sdk = sdk
+        self.logger = sdk.logger
+        self.adapter = self.sdk.adapter
+
+        # 加载配置
+        self.accounts: Dict[str, OneBot12AccountConfig] = self._load_account_configs()
+        
+        # 连接池 - 每个账户一个连接
+        self._api_response_futures: Dict[str, Dict[str, asyncio.Future]] = {}
+        self.sessions: Dict[str, aiohttp.ClientSession] = {}
+        self.connections: Dict[str, aiohttp.ClientWebSocketResponse] = {}
+        
+        # 轮询任务
+        self.reconnect_tasks: Dict[str, asyncio.Task] = {}
+        
+        # 初始化状态
+        self._is_running = False
+        
+        # 默认配置值
+        self.default_retry_interval = 30
+        self.default_timeout = 30
+        self.default_max_retries = 3
+        
+        self.logger.info(f"OneBot12适配器初始化完成，共加载 {len(self.accounts)} 个账户")
+
+    def _load_account_configs(self) -> Dict[str, OneBot12AccountConfig]:
+        """加载账户配置"""
+        accounts = {}
+        
+        # 检查新格式的账户配置
+        account_configs = self.sdk.config.getConfig("OneBotv12_Adapter.accounts", {})
+        
+        if not account_configs:
+            # 创建默认账户配置
+            self.logger.info("未找到配置文件，创建默认账户配置")
+            default_config = {
+                "default": {
+                    "mode": "server",
+                    "server_path": "/onebot12",
+                    "server_token": "",
+                    "client_url": "ws://127.0.0.1:3001",
+                    "client_token": "",
+                    "enabled": True,
+                    "platform": "onebot12",
+                    "implementation": ""
+                }
+            }
+            
+            try:
+                self.sdk.config.setConfig("OneBotv12_Adapter.accounts", default_config)
+                account_configs = default_config
+            except Exception as e:
+                self.logger.error(f"保存默认账户配置失败: {str(e)}")
+                account_configs = default_config
+
+        # 创建账户配置对象
+        for account_name, config in account_configs.items():
+            merged_config = {
+                "mode": config.get("mode", "server"),
+                "server_path": config.get("server_path", "/onebot12"),
+                "server_token": config.get("server_token", ""),
+                "client_url": config.get("client_url", "ws://127.0.0.1:3001"),
+                "client_token": config.get("client_token", ""),
+                "enabled": config.get("enabled", True),
+                "name": account_name,
+                "platform": config.get("platform", "onebot12"),
+                "implementation": config.get("implementation", "")
+            }
+            
+            accounts[account_name] = OneBot12AccountConfig(**merged_config)
+        
+        return accounts
+    
+    async def call_api(self, endpoint: str, account_id: str = None, **params):
+        """调用OneBot12 API"""
+        # 确定使用的账户ID
+        if account_id is None:
+            if not self.accounts:
+                raise ValueError("没有配置任何OneBot12账户")
+            account_id = next(iter(self.accounts.keys()))
+        
+        if account_id not in self.accounts:
+            raise ValueError(f"账户 {account_id} 不存在")
+        
+        account = self.accounts[account_id]
+        if not account.enabled:
+            raise ValueError(f"账户 {account_id} 已禁用")
+        
+        connection = self.connections.get(account_id)
+        if not connection:
+            raise ConnectionError(f"账户 {account_id} 尚未连接到OneBot12")
+        
+        if connection.closed:
+            raise ConnectionError(f"账户 {account_id} 的WebSocket连接已关闭")
+
+        # 确保该账户的响应Future字典存在
+        if account_id not in self._api_response_futures:
+            self._api_response_futures[account_id] = {}
+
+        echo = str(hash(str(params + (account_id, endpoint))))
+        future = asyncio.get_event_loop().create_future()
+        self._api_response_futures[account_id][echo] = future
+        self.logger.debug(f"账户 {account_id} 创建API调用Future: {echo}")
+
+        # OneBot12标准API请求格式
+        payload = {
+            "action": endpoint,
+            "params": params,
+            "echo": echo
+        }
+
+        self.logger.debug(f"账户 {account_id} 准备发送OneBot12 API请求: {payload}")
+        
+        try:
+            await connection.send_str(json.dumps(payload))
+            self.logger.debug(f"账户 {account_id} 调用OneBot12 API: {endpoint}")
+        except Exception as e:
+            self.logger.error(f"账户 {account_id} 发送API请求失败: {str(e)}")
+            if echo in self._api_response_futures[account_id]:
+                del self._api_response_futures[account_id][echo]
+            raise
+
+        try:
+            self.logger.debug(f"账户 {account_id} 开始等待Future: {echo}")
+            raw_response = await asyncio.wait_for(future, timeout=self.default_timeout)
+            self.logger.debug(f"账户 {account_id} OneBot12 API响应: {raw_response}")
+
+            # OneBot12标准响应处理
+            standardized_response = {
+                "status": raw_response.get("status", "ok"),
+                "retcode": raw_response.get("retcode", 0),
+                "data": raw_response.get("data"),
+                "message": raw_response.get("message", ""),
+                "self": {"user_id": account_id}
+            }
+
+            if "message_id" in raw_response:
+                standardized_response["message_id"] = raw_response["message_id"]
+
+            if "echo" in params:
+                standardized_response["echo"] = params["echo"]
+
+            return standardized_response
+
+        except asyncio.TimeoutError:
+            self.logger.error(f"账户 {account_id} API调用超时: {endpoint}")
+            if not future.done():
+                future.cancel()
+            
+            timeout_response = {
+                "status": "failed",
+                "retcode": 33001,
+                "data": None,
+                "message": f"账户 {account_id} API调用超时: {endpoint}",
+                "self": {"user_id": account_id}
+            }
+            
+            if "echo" in params:
+                timeout_response["echo"] = params["echo"]
+                
+            return timeout_response
+            
+        finally:
+            async def delayed_cleanup():
+                await asyncio.sleep(0.1)
+                if account_id in self._api_response_futures and echo in self._api_response_futures[account_id]:
+                    del self._api_response_futures[account_id][echo]
+                    self.logger.debug(f"账户 {account_id} 已删除API响应Future: {echo}")
+            
+            asyncio.create_task(delayed_cleanup())
+
+    async def connect(self, account_id: str, retry_interval=None):
+        """连接指定账户的OneBot12服务"""
+        if account_id not in self.accounts:
+            raise ValueError(f"账户 {account_id} 不存在")
+        
+        account = self.accounts[account_id]
+        if account.mode != "client":
+            return
+
+        # 创建该账户的session
+        if account_id not in self.sessions:
+            self.sessions[account_id] = aiohttp.ClientSession()
+        
+        headers = {}
+        if account.client_token:
+            headers["Authorization"] = f"Bearer {account.client_token}"
+
+        url = account.client_url
+        retry_count = 0
+        retry_interval = retry_interval or self.default_retry_interval
+
+        while self._is_running:
+            try:
+                self.connections[account_id] = await self.sessions[account_id].ws_connect(url, headers=headers)
+                self.logger.info(f"账户 {account_id} 成功连接到OneBot12服务器: {url}")
+                asyncio.create_task(self._listen(account_id))
+                return
+            except Exception as e:
+                retry_count += 1
+                self.logger.error(f"账户 {account_id} 第 {retry_count} 次连接失败: {str(e)}")
+                self.logger.info(f"账户 {account_id} 将在 {retry_interval} 秒后重试...")
+                await asyncio.sleep(retry_interval)
+
+    async def _listen(self, account_id: str):
+        """监听指定账户的WebSocket消息"""
+        connection = self.connections.get(account_id)
+        if not connection:
+            return
+            
+        try:
+            self.logger.debug(f"账户 {account_id} 开始监听OneBot12 WebSocket消息")
+            async for msg in connection:
+                if msg.type == aiohttp.WSMsgType.TEXT:
+                    self.logger.debug(f"账户 {account_id} 收到WebSocket消息: {msg.data[:100]}...")
+                    asyncio.create_task(self._handle_message(msg.data, account_id))
+                elif msg.type == aiohttp.WSMsgType.CLOSED:
+                    self.logger.info(f"账户 {account_id} WebSocket连接已关闭")
+                    break
+                elif msg.type == aiohttp.WSMsgType.ERROR:
+                    self.logger.error(f"账户 {account_id} WebSocket错误: {connection.exception()}")
+        except Exception as e:
+            self.logger.error(f"账户 {account_id} WebSocket监听异常: {str(e)}")
+        finally:
+            self.logger.debug(f"账户 {account_id} 退出WebSocket监听")
+            if account_id in self.connections:
+                del self.connections[account_id]
+            
+            if self._is_running and self.accounts[account_id].enabled and self.accounts[account_id].mode == "client":
+                self.logger.info(f"账户 {account_id} 开始重连...")
+                self.reconnect_tasks[account_id] = asyncio.create_task(self.connect(account_id))
+
+    async def _handle_api_response(self, data: Dict, account_id: str):
+        """处理API响应"""
+        echo = data.get("echo")
+        self.logger.debug(f"账户 {account_id} 收到OneBot12 API响应, echo: {echo}")
+        
+        if account_id not in self._api_response_futures:
+            self.logger.warning(f"账户 {account_id} 不存在响应Future字典")
+            return
+            
+        future = self._api_response_futures[account_id].get(echo)
+        
+        if future:
+            if not future.done():
+                future.set_result(data)
+            else:
+                self.logger.warning(f"Future已经完成，无法设置结果: {echo}")
+        else:
+            self.logger.warning(f"账户 {account_id} 未找到对应的Future: {echo}")
+
+    async def _handle_message(self, raw_msg: str, account_id: str):
+        """处理WebSocket消息"""
+        try:
+            data = json.loads(raw_msg)
+            
+            # API响应优先处理
+            if "echo" in data:
+                self.logger.debug(f"账户 {account_id} 识别为OneBot12 API响应消息: {data.get('echo')}")
+                await self._handle_api_response(data, account_id)
+                return
+            
+            self.logger.debug(f"账户 {account_id} 处理OneBot12事件: {data.get('type')}")
+            
+            # OneBot12事件直接提交，无需转换
+            if hasattr(self.adapter, "emit") and data:
+                # 确保事件包含账户信息
+                if "self" not in data:
+                    data["self"] = {}
+                if not data.get("self", {}).get("user_id"):
+                    data["self"]["user_id"] = account_id
+                
+                self.logger.debug(f"账户 {account_id} 提交OneBot12事件: {json.dumps(data, ensure_ascii=False)}")
+                await self.adapter.emit(data)
+
+        except json.JSONDecodeError:
+            self.logger.error(f"账户 {account_id} JSON解析失败: {raw_msg}")
+        except Exception as e:
+            self.logger.error(f"账户 {account_id} 消息处理异常: {str(e)}")
+
+    async def _ws_handler(self, websocket: WebSocket, account_id: str = "default"):
+        """WebSocket处理器"""
+        self.connections[account_id] = websocket
+        self.logger.info(f"账户 {account_id} 的OneBot12客户端已连接")
+
+        try:
+            while True:
+                data = await websocket.receive_text()
+                asyncio.create_task(self._handle_message(data, account_id))
+        except WebSocketDisconnect:
+            self.logger.info(f"账户 {account_id} 的OneBot12客户端断开连接")
+        except Exception as e:
+            self.logger.error(f"账户 {account_id} WebSocket处理异常: {str(e)}")
+        finally:
+            if account_id in self.connections:
+                del self.connections[account_id]
+    
+    async def _auth_handler(self, websocket: WebSocket, account_id: str = "default"):
+        """认证处理器"""
+        if account_id not in self.accounts:
+            self.logger.warning(f"账户 {account_id} 不存在")
+            await websocket.close(code=1008)
+            return False
+            
+        account = self.accounts[account_id]
+        if account.server_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 != account.server_token:
+                self.logger.warning(f"账户 {account_id} 客户端提供的Token无效")
+                await websocket.close(code=1008)
+                return False
+        return True
+
+    async def register_websocket(self):
+        """注册WebSocket路由"""
+        # 注册所有server模式的账户
+        for account_id, account in self.accounts.items():
+            if account.mode == "server" and account.enabled:
+                path = account.server_path
+                
+                def make_ws_handler(account_id):
+                    async def ws_handler(websocket):
+                        await self._ws_handler(websocket, account_id)
+                    return ws_handler
+                
+                def make_auth_handler(account_id):
+                    async def auth_handler(websocket):
+                        return await self._auth_handler(websocket, account_id)
+                    return auth_handler
+                
+                router.register_websocket(
+                    f"onebot12_{account_id}",
+                    path,
+                    make_ws_handler(account_id),
+                    auth_handler=make_auth_handler(account_id)
+                )
+                self.logger.info(f"已注册账户 {account_id} 的Server模式WebSocket路由: {path}")
+
+    async def start(self):
+        """启动适配器"""
+        self._is_running = True
+        
+        server_accounts = [aid for aid, acc in self.accounts.items() if acc.mode == "server" and acc.enabled]
+        client_accounts = [aid for aid, acc in self.accounts.items() if acc.mode == "client" and acc.enabled]
+        
+        if server_accounts:
+            self.logger.info(f"正在注册 {len(server_accounts)} 个Server模式账户的WebSocket路由")
+            await self.register_websocket()
+        
+        if client_accounts:
+            self.logger.info(f"正在启动 {len(client_accounts)} 个Client模式账户")
+            for account_id in client_accounts:
+                self.reconnect_tasks[account_id] = asyncio.create_task(self.connect(account_id))
+        
+        if not server_accounts and not client_accounts:
+            self.logger.warning("没有启用任何账户")
+        
+        self.logger.info("OneBot12适配器启动完成")
+
+    async def shutdown(self):
+        """关闭适配器"""
+        self._is_running = False
+        
+        # 取消所有重连任务
+        for task in self.reconnect_tasks.values():
+            if not task.done():
+                task.cancel()
+        self.reconnect_tasks.clear()
+        
+        # 关闭所有连接
+        for account_id, connection in self.connections.items():
+            try:
+                if hasattr(connection, 'closed') and not connection.closed:
+                    await connection.close()
+            except Exception as e:
+                self.logger.error(f"关闭账户 {account_id} 连接失败: {str(e)}")
+        self.connections.clear()
+        
+        # 关闭所有session
+        for account_id, session in self.sessions.items():
+            try:
+                await session.close()
+            except Exception as e:
+                self.logger.error(f"关闭账户 {account_id} session失败: {str(e)}")
+        self.sessions.clear()
+        
+        self.logger.info("OneBot12适配器已关闭")

OneBot12Adapter/__init__.py

@@ -0,0 +1,3 @@
+from .Core import OneBot12Adapter
+
+__all__ = ["OneBot12Adapter"]

erispulse_onebot12adapter-1.0.0.dist-info/METADATA

@@ -0,0 +1,453 @@
+Metadata-Version: 2.4
+Name: ErisPulse-OneBot12Adapter
+Version: 1.0.0
+Summary: ErisPulse的OneBotV12协议适配模块，基线协议适配器
+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-OneBot12Adapter
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# OneBot12Adapter 模块文档
+
+## 简介
+
+OneBot12Adapter 是基于 [ErisPulse](https://github.com/ErisPulse/ErisPulse/) 架构开发的 **OneBot V12 协议适配器模块**。作为ErisPulse框架的基线协议适配器，它提供完全符合OneBot12标准的事件处理机制、连接管理功能，并支持Server和Client两种运行模式。
+
+---
+
+## 特性
+
+- **多账户支持** - 支持同时配置和运行多个OneBot12账户
+- **双运行模式** - 支持Server（服务端）和Client（客户端）模式
+- **异步处理** - 全异步设计，支持高并发操作
+- **自动重连** - 网络异常时自动重连机制
+- **标准化响应** - 统一的API响应格式
+
+---
+
+## 安装与配置
+
+### 基本安装
+
+将适配器模块放置在ErisPulse的适配器目录中，并在配置中启用：
+
+```toml
+[adapters]
+onebot12 = "OneBot12Adapter"
+```
+
+### 多账户配置
+
+OneBot12适配器采用多账户配置结构：
+
+```toml
+# 主账户配置
+[OneBotv12_Adapter.accounts.main]
+mode = "server"
+server_path = "/onebot12"
+server_token = "your_main_token"
+enabled = true
+platform = "onebot12"
+implementation = "go-cqhttp"
+
+# 备用账户配置  
+[OneBotv12_Adapter.accounts.backup]
+mode = "client"
+client_url = "ws://127.0.0.1:3002"
+client_token = "your_backup_token"
+enabled = true
+platform = "onebot12"
+implementation = "shinonome"
+
+# 测试账户配置
+[OneBotv12_Adapter.accounts.test]
+mode = "client"
+client_url = "ws://127.0.0.1:3003"
+enabled = false
+```
+
+### 默认账户配置
+
+如果没有配置文件，适配器会自动创建默认配置：
+
+```toml
+[OneBotv12_Adapter.accounts.default]
+mode = "server"
+server_path = "/onebot12"
+server_token = ""
+enabled = true
+platform = "onebot12"
+```
+
+### 配置项说明
+
+每个账户独立配置以下选项：
+
+- `mode`: 运行模式，可选 "server"（服务端）或 "client"（客户端）
+- `server_path`: Server模式下的WebSocket路径
+- `server_token`: Server模式下的认证Token（可选）
+- `client_url`: Client模式下要连接的WebSocket地址
+- `client_token`: Client模式下的认证Token（可选）
+- `enabled`: 是否启用该账户（true/false）
+- `platform`: 平台标识，默认为 "onebot12"
+- `implementation`: 实现标识，如 "go-cqhttp"（可选）
+
+---
+
+## 使用方法
+
+### 基础用法
+
+```python
+from ErisPulse.Core import adapter
+
+# 获取OneBot12适配器实例
+onebot12 = adapter.get("onebot12")
+
+# 发送文本消息
+await onebot12.Send.To("group", 123456).Text("Hello World!")
+
+# 发送图片消息
+await onebot12.Send.To("user", 789012).Image("http://example.com/image.jpg")
+
+# 发送@消息
+await onebot12.Send.To("group", 123456).Mention(789012, "用户名")
+```
+
+---
+
+## 消息发送示例（DSL 链式风格）
+
+### 基础消息类型
+
+#### 文本消息
+```python
+await onebot12.Send.To("user", 123456).Text("Hello World!")
+```
+
+#### 图片消息
+```python
+# 支持URL或二进制数据
+await onebot12.Send.To("user", 123456).Image("http://example.com/image.jpg")
+
+# 支持二进制数据
+with open("local_image.png", "rb") as f:
+    image_data = f.read()
+    await onebot12.Send.To("user", 123456).Image(image_data)
+```
+
+#### 音频消息
+```python
+await onebot12.Send.To("user", 123456).Audio("http://example.com/audio.ogg")
+```
+
+#### 视频消息
+```python
+await onebot12.Send.To("user", 123456).Video("http://example.com/video.mp4")
+```
+
+### 交互消息
+
+#### @消息
+```python
+await onebot12.Send.To("group", 123456).Mention(789012, "用户名")
+```
+
+#### 回复消息
+```python
+# 仅回复，不附加内容
+await onebot12.Send.To("group", 123456).Reply("msg_id_123")
+
+# 回复并附加内容
+await onebot12.Send.To("group", 123456).Reply("msg_id_123", "这是回复内容")
+```
+
+#### 表情包/贴纸
+```python
+await onebot12.Send.To("user", 123456).Sticker("sticker_id_456")
+```
+
+#### 位置消息
+```python
+await onebot12.Send.To("group", 123456).Location(
+    latitude=39.9042, 
+    longitude=116.4074, 
+    title="北京市", 
+    content="中华人民共和国首都"
+)
+```
+
+### 复合消息
+
+#### 发送原始消息段
+```python
+message_segments = [
+    {"type": "text", "data": {"text": "你好"}},
+    {"type": "mention", "data": {"user_id": "123456", "user_name": "用户名"}},
+    {"type": "image", "data": {"file_id": "image_id"}}
+]
+await onebot12.Send.To("group", 123456).Raw(message_segments)
+```
+
+#### 批量发送
+```python
+targets = ["user1", "user2", "user3"]
+await onebot12.Send.To("user", targets).Batch(["消息1", "消息2", "消息3"])
+```
+
+### 消息管理
+
+#### 撤回消息
+```python
+await onebot12.Send.To("group", 123456).Recall("message_id_123")
+```
+
+#### 编辑消息
+```python
+# 编辑为文本
+await onebot12.Send.To("group", 123456).Edit("message_id_123", "修改后的内容")
+
+# 编辑为复合消息
+new_content = [
+    {"type": "text", "data": {"text": "修改后的内容"}},
+    {"type": "image", "data": {"file_id": "new_image_id"}}
+]
+await onebot12.Send.To("group", 123456).Edit("message_id_123", new_content)
+```
+
+---
+
+## API 调用方式
+
+### 多账户消息发送
+
+```python
+# 使用指定账户发送消息
+await onebot12.Send.To("group", 123456).Account("main").Text("来自主账户的消息")
+await onebot12.Send.To("group", 123456).Account("backup").Text("来自备用账户的消息")
+
+# 使用默认账户发送（第一个启用的账户）
+await onebot12.Send.To("group", 123456).Text("来自默认账户的消息")
+```
+
+### 直接API调用
+
+```python
+# 发送消息
+response = await onebot12.call_api(
+    "send_message",
+    account_id="main",
+    detail_type="group",
+    group_id=123456,
+    content=[{"type": "text", "data": {"text": "Hello"}}]
+)
+
+# 获取自身信息
+self_info = await onebot12.call_api("get_self_info", account_id="main")
+
+# 获取用户信息
+user_info = await onebot12.call_api(
+    "get_user_info", 
+    account_id="main",
+    user_id="user123"
+)
+
+# 获取群组信息
+group_info = await onebot12.call_api(
+    "get_group_info",
+    account_id="main", 
+    group_id="group456"
+)
+```
+
+---
+
+## 事件处理
+
+OneBot12适配器支持标准的事件监听方式：
+
+```python
+# 监听消息事件
+@sdk.adapter.OneBot12.on("message")
+async def handle_message(event):
+    if event["detail_type"] == "private":
+        print(f"收到私聊消息: {event['alt_message']}")
+    elif event["detail_type"] == "group":
+        print(f"收到群聊消息: {event['alt_message']}")
+
+# 监听通知事件
+@sdk.adapter.OneBot12.on("notice")
+async def handle_notice(event):
+    if event["detail_type"] == "group_member_increase":
+        print(f"群成员增加: {event['user_id']} 加入了 {event['group_id']}")
+    elif event["detail_type"] == "group_member_decrease":
+        print(f"群成员减少: {event['user_id']} 离开了 {event['group_id']}")
+
+# 监听请求事件
+@sdk.adapter.OneBot12.on("request")
+async def handle_request(event):
+    if event["detail_type"] == "friend":
+        print(f"收到好友请求: {event['user_id']}")
+    elif event["detail_type"] == "group":
+        print(f"收到群邀请: {event['group_id']}")
+
+# 监听元事件
+@sdk.adapter.OneBot12.on("meta_event")
+async def handle_meta_event(event):
+    if event["detail_type"] == "lifecycle":
+        print(f"生命周期事件: {event['sub_type']}")
+    elif event["detail_type"] == "heartbeat":
+        print(f"心跳事件: 间隔 {event['interval']}ms")
+```
+
+### 事件数据结构
+
+OneBot12适配器直接处理标准格式的OneBot12事件，无需转换：
+
+```python
+# 私聊消息事件示例
+{
+    "id": "event-uuid",
+    "type": "message",
+    "detail_type": "private", 
+    "self": {"user_id": "bot-id"},
+    "user_id": "user-id",
+    "message": [{"type": "text", "data": {"text": "Hello"}}],
+    "alt_message": "Hello",
+    "time": 1234567890
+}
+
+# 群聊消息事件示例
+{
+    "id": "event-uuid",
+    "type": "message",
+    "detail_type": "group",
+    "self": {"user_id": "bot-id"},
+    "user_id": "user-id", 
+    "group_id": "group-id",
+    "message": [{"type": "text", "data": {"text": "Hello group"}}],
+    "alt_message": "Hello group",
+    "time": 1234567890
+}
+```
+
+---
+
+## 运行模式说明
+
+### 多账户运行模式
+
+OneBot12适配器支持同时运行多个账户，每个账户可以独立配置为Server或Client模式：
+
+```python
+# 查看所有账户
+accounts = onebot12.accounts
+print(f"已配置账户: {list(accounts.keys())}")
+
+# 检查特定账户状态
+if "test" in accounts:
+    test_account = accounts["test"]
+    print(f"测试账户模式: {test_account.mode}, 启用状态: {test_account.enabled}")
+```
+
+### Server 模式（作为服务端监听连接）
+
+- 启动一个 WebSocket 服务器等待 OneBot12 客户端连接
+- 适用于部署多个 bot 客户端连接至同一服务端的场景
+- 每个Server账户会注册独立的WebSocket路由路径
+
+### Client 模式（主动连接 OneBot12）
+
+- 主动连接到 OneBot12 服务端
+- 更适合单个 bot 实例直接连接的情况
+- 支持自动重连机制
+
+---
+
+## 支持的消息类型及对应方法
+
+| 方法名 | 参数说明 | 用途 |
+|--------|----------|------|
+| `.Text(text: str)` | 发送纯文本消息 | 基础消息类型 |
+| `.Image(file: str/bytes, filename: str)` | 发送图片消息 | 支持URL、Base64或bytes |
+| `.Audio(file: str/bytes, filename: str)` | 发送音频消息 | 支持标准音频格式 |
+| `.Video(file: str/bytes, filename: str)` | 发送视频消息 | 支持标准视频格式 |
+| `.Mention(user_id: str/int, user_name: str)` | 发送@消息 | 群聊@功能 |
+| `.Reply(message_id: str/int, content: str)` | 发送回复消息 | 消息回复功能 |
+| `.Sticker(file_id: str)` | 发送表情包/贴纸 | 表情包功能 |
+| `.Location(lat: float, lon: float, title: str, content: str)` | 发送位置 | 位置分享 |
+| `.Raw(message_list: List[Dict])` | 发送原生消息段 | 自定义消息内容 |
+| `.Recall(message_id: str/int)` | 撤回指定消息 | 消息管理 |
+| `.Edit(message_id: str/int, content: Union[str, List[Dict]])` | 编辑消息 | 消息编辑 |
+| `.Batch(target_ids: List[str], message: Union[str, List[Dict]], target_type: str)` | 批量发送消息 | 群发功能 |
+
+---
+
+## 管理接口
+
+```python
+# 获取所有账户信息
+accounts = onebot12.accounts
+
+# 检查账户连接状态
+connection_status = {
+    account_id: connection is not None and not connection.closed
+    for account_id, connection in onebot12.connections.items()
+}
+print(f"账户连接状态: {connection_status}")
+
+# 动态启用/禁用账户（需要重启适配器）
+onebot12.accounts["test"].enabled = False
+```
+
+---
+
+## 错误处理
+
+适配器提供完善的错误处理机制：
+
+1. **网络连接异常自动重连** - 支持每个账户独立重连，间隔30秒
+2. **API调用超时处理** - 固定30秒超时机制
+3. **消息发送失败重试** - 最多3次自动重试
+4. **标准化错误响应** - 统一的错误格式和状态码
+
+---
+
+## 注意事项
+
+1. 生产环境建议启用 Token 认证以保证安全性
+2. 对于二进制内容（如图片、音频等），支持直接传入 bytes 数据
+3. 批量发送时建议适当控制并发数量，避免API限制
+4. 长时间运行的机器人建议监控连接状态，确保服务可用性
+
+---
+
+## 参考链接
+
+- [ErisPulse 主库](https://github.com/ErisPulse/ErisPulse/)
+- [OneBot V12 协议文档](https://12.onebot.dev/)
+- [平台特性文档](./platform-features.md)

erispulse_onebot12adapter-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+OneBot12Adapter/Core.py,sha256=ccVFH80p_akq3EWZEBu5bMyiBwLuwrBZY_UYrjFVelU,26167
+OneBot12Adapter/__init__.py,sha256=_rVYimIP2koiHYReVGKBJ5o3hFuVvLj1L1RqQ-7n3AA,65
+erispulse_onebot12adapter-1.0.0.dist-info/licenses/LICENSE,sha256=Q0nf8qebrO7_DA7rL4LaoHogeL38vE265P55uTIghmY,1064
+erispulse_onebot12adapter-1.0.0.dist-info/METADATA,sha256=lgDUJ9NYjVZpq2Mx_1KVLwGF3q9qs9GzPZpZKQ2T2cs,12973
+erispulse_onebot12adapter-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+erispulse_onebot12adapter-1.0.0.dist-info/entry_points.txt,sha256=Cjs3qlWJXBl98t8peEsSZYaHN9VTSW3BGJ59kspEaAs,63
+erispulse_onebot12adapter-1.0.0.dist-info/top_level.txt,sha256=uvlftRBGSF_fFElBbBz-fTPUpe4Mlmj1QpOEAtdWTgk,16
+erispulse_onebot12adapter-1.0.0.dist-info/RECORD,,

erispulse_onebot12adapter-1.0.0.dist-info/WHEEL

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

erispulse_onebot12adapter-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[erispulse.adapter]
+onebot12 = OneBot12Adapter:OneBot12Adapter

erispulse_onebot12adapter-1.0.0.dist-info/licenses/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_onebot12adapter-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+OneBot12Adapter