AstrBot 3.5.6__py3-none-any.whl → 4.7.0__py3-none-any.whl

astrbot/core/platform/manager.py

@@ -1,23 +1,28 @@
-import traceback
 import asyncio
+import traceback
+from asyncio import Queue
+
+from astrbot.core import logger
 from astrbot.core.config.astrbot_config import AstrBotConfig
+from astrbot.core.star.star_handler import EventType, star_handlers_registry, star_map
+
 from .platform import Platform
-from typing import List
-from asyncio import Queue
 from .register import platform_cls_map
-from astrbot.core import logger
 from .sources.webchat.webchat_adapter import WebChatAdapter
 
 
 class PlatformManager:
     def __init__(self, config: AstrBotConfig, event_queue: Queue):
-        self.platform_insts: List[Platform] = []
+        self.platform_insts: list[Platform] = []
         """加载的 Platform 的实例"""
 
         self._inst_map = {}
 
         self.platforms_config = config["platform"]
         self.settings = config["platform_settings"]
+        """NOTE: 这里是 default 的配置文件，以保证最大的兼容性；
+        这个配置中的 unique_session 需要特殊处理，
+        约定整个项目中对 unique_session 的引用都从 default 的配置中获取"""
         self.event_queue = event_queue
 
     async def initialize(self):
@@ -32,7 +37,7 @@ class PlatformManager:
         webchat_inst = WebChatAdapter({}, self.settings, self.event_queue)
         self.platform_insts.append(webchat_inst)
         asyncio.create_task(
-            self._task_wrapper(asyncio.create_task(webchat_inst.run(), name="webchat"))
+            self._task_wrapper(asyncio.create_task(webchat_inst.run(), name="webchat")),
         )
 
     async def load_platform(self, platform_config: dict):
@@ -43,7 +48,7 @@ class PlatformManager:
                 return
 
             logger.info(
-                f"载入 {platform_config['type']}({platform_config['id']}) 平台适配器 ..."
+                f"载入 {platform_config['type']}({platform_config['id']}) 平台适配器 ...",
             )
             match platform_config["type"]:
                 case "aiocqhttp":
@@ -58,30 +63,58 @@ class PlatformManager:
                     from .sources.qqofficial_webhook.qo_webhook_adapter import (
                         QQOfficialWebhookPlatformAdapter,  # noqa: F401
                     )
-                case "gewechat":
-                    from .sources.gewechat.gewechat_platform_adapter import (
-                        GewechatPlatformAdapter,  # noqa: F401
+                case "wechatpadpro":
+                    from .sources.wechatpadpro.wechatpadpro_adapter import (
+                        WeChatPadProAdapter,  # noqa: F401
                     )
                 case "lark":
-                    from .sources.lark.lark_adapter import LarkPlatformAdapter  # noqa: F401
+                    from .sources.lark.lark_adapter import (
+                        LarkPlatformAdapter,  # noqa: F401
+                    )
                 case "dingtalk":
                     from .sources.dingtalk.dingtalk_adapter import (
                         DingtalkPlatformAdapter,  # noqa: F401
                     )
                 case "telegram":
-                    from .sources.telegram.tg_adapter import TelegramPlatformAdapter  # noqa: F401
+                    from .sources.telegram.tg_adapter import (
+                        TelegramPlatformAdapter,  # noqa: F401
+                    )
                 case "wecom":
-                    from .sources.wecom.wecom_adapter import WecomPlatformAdapter  # noqa: F401
+                    from .sources.wecom.wecom_adapter import (
+                        WecomPlatformAdapter,  # noqa: F401
+                    )
+                case "wecom_ai_bot":
+                    from .sources.wecom_ai_bot.wecomai_adapter import (
+                        WecomAIBotAdapter,  # noqa: F401
+                    )
+                case "weixin_official_account":
+                    from .sources.weixin_official_account.weixin_offacc_adapter import (
+                        WeixinOfficialAccountPlatformAdapter,  # noqa: F401
+                    )
+                case "discord":
+                    from .sources.discord.discord_platform_adapter import (
+                        DiscordPlatformAdapter,  # noqa: F401
+                    )
+                case "misskey":
+                    from .sources.misskey.misskey_adapter import (
+                        MisskeyPlatformAdapter,  # noqa: F401
+                    )
+                case "slack":
+                    from .sources.slack.slack_adapter import SlackAdapter  # noqa: F401
+                case "satori":
+                    from .sources.satori.satori_adapter import (
+                        SatoriPlatformAdapter,  # noqa: F401
+                    )
         except (ImportError, ModuleNotFoundError) as e:
             logger.error(
-                f"加载平台适配器 {platform_config['type']} 失败，原因：{e}。请检查依赖库是否安装。提示：可以在 管理面板->控制台->安装Pip库 中安装依赖库。"
+                f"加载平台适配器 {platform_config['type']} 失败，原因：{e}。请检查依赖库是否安装。提示：可以在 管理面板->控制台->安装Pip库 中安装依赖库。",
             )
         except Exception as e:
             logger.error(f"加载平台适配器 {platform_config['type']} 失败，原因：{e}。")
 
         if platform_config["type"] not in platform_cls_map:
             logger.error(
-                f"未找到适用于 {platform_config['type']}({platform_config['id']}) 平台适配器，请检查是否已经安装或者名称填写错误"
+                f"未找到适用于 {platform_config['type']}({platform_config['id']}) 平台适配器，请检查是否已经安装或者名称填写错误",
             )
             return
         cls_type = platform_cls_map[platform_config["type"]]
@@ -97,9 +130,20 @@ class PlatformManager:
                 asyncio.create_task(
                     inst.run(),
                     name=f"platform_{platform_config['type']}_{platform_config['id']}",
-                )
-            )
+                ),
+            ),
         )
+        handlers = star_handlers_registry.get_handlers_by_event_type(
+            EventType.OnPlatformLoadedEvent,
+        )
+        for handler in handlers:
+            try:
+                logger.info(
+                    f"hook(on_platform_loaded) -> {star_map[handler.handler_module_path].name} - {handler.handler_name}",
+                )
+                await handler.handler()
+            except Exception:
+                logger.error(traceback.format_exc())
 
     async def _task_wrapper(self, task: asyncio.Task):
         try:
@@ -137,7 +181,7 @@ class PlatformManager:
                         inst
                         for inst in self.platform_insts
                         if inst.client_self_id == client_id
-                    )
+                    ),
                 )
             except Exception:
                 logger.warning(f"可能未完全移除 {platform_id} 平台适配器")

astrbot/core/platform/message_session.py

@@ -0,0 +1,30 @@
+from dataclasses import dataclass
+
+from astrbot.core.platform.message_type import MessageType
+
+
+@dataclass
+class MessageSession:
+    """描述一条消息在 AstrBot 中对应的会话的唯一标识。
+    如果您需要实例化 MessageSession，请不要给 platform_id 赋值（或者同时给 platform_name 和 platform_id 赋值相同值）。它会在 __post_init__ 中自动设置为 platform_name 的值。
+    """
+
+    platform_name: str
+    """平台适配器实例的唯一标识符。自 AstrBot v4.0.0 起，该字段实际为 platform_id。"""
+    message_type: MessageType
+    session_id: str
+    platform_id: str | None = None
+
+    def __str__(self):
+        return f"{self.platform_id}:{self.message_type.value}:{self.session_id}"
+
+    def __post_init__(self):
+        self.platform_id = self.platform_name
+
+    @staticmethod
+    def from_str(session_str: str):
+        platform_id, message_type, session_id = session_str.split(":")
+        return MessageSession(platform_id, MessageType(message_type), session_id)
+
+
+MessageSesion = MessageSession  # back compatibility

astrbot/core/platform/platform.py

@@ -1,13 +1,16 @@
 import abc
 import uuid
-from typing import Awaitable, Any
 from asyncio import Queue
-from .platform_metadata import PlatformMetadata
-from .astr_message_event import AstrMessageEvent
+from collections.abc import Awaitable
+from typing import Any
+
 from astrbot.core.message.message_event_result import MessageChain
-from .astr_message_event import MessageSesion
 from astrbot.core.utils.metrics import Metric
 
+from .astr_message_event import AstrMessageEvent
+from .message_session import MessageSesion
+from .platform_metadata import PlatformMetadata
+
 
 class Platform(abc.ABC):
     def __init__(self, event_queue: Queue):
@@ -18,42 +21,31 @@ class Platform(abc.ABC):
 
     @abc.abstractmethod
     def run(self) -> Awaitable[Any]:
-        """
-        得到一个平台的运行实例，需要返回一个协程对象。
-        """
+        """得到一个平台的运行实例，需要返回一个协程对象。"""
         raise NotImplementedError
 
     async def terminate(self):
-        """
-        终止一个平台的运行实例。
-        """
-        ...
+        """终止一个平台的运行实例。"""
 
     @abc.abstractmethod
     def meta(self) -> PlatformMetadata:
-        """
-        得到一个平台的元数据。
-        """
+        """得到一个平台的元数据。"""
         raise NotImplementedError
 
     async def send_by_session(
-        self, session: MessageSesion, message_chain: MessageChain
+        self,
+        session: MessageSesion,
+        message_chain: MessageChain,
     ) -> Awaitable[Any]:
-        """
-        通过会话发送消息。该方法旨在让插件能够直接通过**可持久化的会话数据**发送消息，而不需要保存 event 对象。
+        """通过会话发送消息。该方法旨在让插件能够直接通过**可持久化的会话数据**发送消息，而不需要保存 event 对象。
 
         异步方法。
         """
         await Metric.upload(msg_event_tick=1, adapter_name=self.meta().name)
 
     def commit_event(self, event: AstrMessageEvent):
-        """
-        提交一个事件到事件队列。
-        """
+        """提交一个事件到事件队列。"""
         self._event_queue.put_nowait(event)
 
     def get_client(self):
-        """
-        获取平台的客户端对象。
-        """
-        pass
+        """获取平台的客户端对象。"""

astrbot/core/platform/platform_metadata.py

@@ -4,13 +4,18 @@ from dataclasses import dataclass
 @dataclass
 class PlatformMetadata:
     name: str
-    """平台的名称"""
+    """平台的名称，即平台的类型，如 aiocqhttp, discord, slack"""
     description: str
     """平台的描述"""
-    id: str = None
+    id: str | None = None
     """平台的唯一标识符，用于配置中识别特定平台"""
 
-    default_config_tmpl: dict = None
+    default_config_tmpl: dict | None = None
     """平台的默认配置模板"""
-    adapter_display_name: str = None
+    adapter_display_name: str | None = None
     """显示在 WebUI 配置页中的平台名称，如空则是 name"""
+    logo_path: str | None = None
+    """平台适配器的 logo 文件路径（相对于插件目录）"""
+
+    support_streaming_message: bool = True
+    """平台是否支持真实流式传输"""

astrbot/core/platform/register.py

@@ -1,28 +1,31 @@
-from typing import List, Dict, Type
-from .platform_metadata import PlatformMetadata
 from astrbot.core import logger
 
-platform_registry: List[PlatformMetadata] = []
+from .platform_metadata import PlatformMetadata
+
+platform_registry: list[PlatformMetadata] = []
 """维护了通过装饰器注册的平台适配器"""
-platform_cls_map: Dict[str, Type] = {}
+platform_cls_map: dict[str, type] = {}
 """维护了平台适配器名称和适配器类的映射"""
 
 
 def register_platform_adapter(
     adapter_name: str,
     desc: str,
-    default_config_tmpl: dict = None,
-    adapter_display_name: str = None,
+    default_config_tmpl: dict | None = None,
+    adapter_display_name: str | None = None,
+    logo_path: str | None = None,
+    support_streaming_message: bool = True,
 ):
     """用于注册平台适配器的带参装饰器。
 
     default_config_tmpl 指定了平台适配器的默认配置模板。用户填写好后将会作为 platform_config 传入你的 Platform 类的实现类。
+    logo_path 指定了平台适配器的 logo 文件路径，是相对于插件目录的路径。
     """
 
     def decorator(cls):
         if adapter_name in platform_cls_map:
             raise ValueError(
-                f"平台适配器 {adapter_name} 已经注册过了，可能发生了适配器命名冲突。"
+                f"平台适配器 {adapter_name} 已经注册过了，可能发生了适配器命名冲突。",
             )
 
         # 添加必备选项
@@ -39,6 +42,8 @@ def register_platform_adapter(
             description=desc,
             default_config_tmpl=default_config_tmpl,
             adapter_display_name=adapter_display_name,
+            logo_path=logo_path,
+            support_streaming_message=support_streaming_message,
         )
         platform_registry.append(pm)
         platform_cls_map[adapter_name] = cls

astrbot/core/platform/sources/aiocqhttp/aiocqhttp_message_event.py

@@ -1,90 +1,166 @@
 import asyncio
 import re
-from typing import AsyncGenerator, Dict, List
-from aiocqhttp import CQHttp
+from collections.abc import AsyncGenerator
+
+from aiocqhttp import CQHttp, Event
+
 from astrbot.api.event import AstrMessageEvent, MessageChain
-from astrbot.api.message_components import At, Image, Node, Nodes, Plain, Record
+from astrbot.api.message_components import (
+    BaseMessageComponent,
+    File,
+    Image,
+    Node,
+    Nodes,
+    Plain,
+    Record,
+    Video,
+)
 from astrbot.api.platform import Group, MessageMember
 
 
 class AiocqhttpMessageEvent(AstrMessageEvent):
     def __init__(
-        self, message_str, message_obj, platform_meta, session_id, bot: CQHttp
+        self,
+        message_str,
+        message_obj,
+        platform_meta,
+        session_id,
+        bot: CQHttp,
     ):
         super().__init__(message_str, message_obj, platform_meta, session_id)
         self.bot = bot
 
+    @staticmethod
+    async def _from_segment_to_dict(segment: BaseMessageComponent) -> dict:
+        """修复部分字段"""
+        if isinstance(segment, (Image, Record)):
+            # For Image and Record segments, we convert them to base64
+            bs64 = await segment.convert_to_base64()
+            return {
+                "type": segment.type.lower(),
+                "data": {
+                    "file": f"base64://{bs64}",
+                },
+            }
+        if isinstance(segment, File):
+            # For File segments, we need to handle the file differently
+            d = await segment.to_dict()
+            return d
+        if isinstance(segment, Video):
+            d = await segment.to_dict()
+            return d
+        # For other segments, we simply convert them to a dict by calling toDict
+        return segment.toDict()
+
     @staticmethod
     async def _parse_onebot_json(message_chain: MessageChain):
         """解析成 OneBot json 格式"""
         ret = []
         for segment in message_chain.chain:
-            d = segment.toDict()
             if isinstance(segment, Plain):
-                d["type"] = "text"
-                d["data"]["text"] = segment.text.strip()
-                # 如果是空文本或者只带换行符的文本，不发送
-                if not d["data"]["text"]:
+                if not segment.text.strip():
                     continue
-            elif isinstance(segment, (Image, Record)):
-                # convert to base64
-                bs64 = await segment.convert_to_base64()
-                d["data"] = {
-                    "file": f"base64://{bs64}",
-                }
-            elif isinstance(segment, At):
-                d["data"] = {
-                    "qq": str(segment.qq)  # 转换为字符串
-                }
+            d = await AiocqhttpMessageEvent._from_segment_to_dict(segment)
             ret.append(d)
         return ret
 
-    async def send(self, message: MessageChain):
-        ret = await AiocqhttpMessageEvent._parse_onebot_json(message)
-
-        if not ret:
+    @classmethod
+    async def _dispatch_send(
+        cls,
+        bot: CQHttp,
+        event: Event | None,
+        is_group: bool,
+        session_id: str,
+        messages: list[dict],
+    ):
+        # session_id 必须是纯数字字符串
+        session_id = int(session_id) if session_id.isdigit() else None
+
+        if is_group and isinstance(session_id, int):
+            await bot.send_group_msg(group_id=session_id, message=messages)
+        elif not is_group and isinstance(session_id, int):
+            await bot.send_private_msg(user_id=session_id, message=messages)
+        elif isinstance(event, Event):  # 最后兜底
+            await bot.send(event=event, message=messages)
+        else:
+            raise ValueError(
+                f"无法发送消息：缺少有效的数字 session_id({session_id}) 或 event({event})",
+            )
+
+    @classmethod
+    async def send_message(
+        cls,
+        bot: CQHttp,
+        message_chain: MessageChain,
+        event: Event | None = None,
+        is_group: bool = False,
+        session_id: str | None = None,
+    ):
+        """发送消息至 QQ 协议端（aiocqhttp）。
+
+        Args:
+            bot (CQHttp): aiocqhttp 机器人实例
+            message_chain (MessageChain): 要发送的消息链
+            event (Event | None, optional): aiocqhttp 事件对象.
+            is_group (bool, optional): 是否为群消息.
+            session_id (str | None, optional): 会话 ID（群号或 QQ 号
+
+        """
+        # 转发消息、文件消息不能和普通消息混在一起发送
+        send_one_by_one = any(
+            isinstance(seg, (Node, Nodes, File)) for seg in message_chain.chain
+        )
+        if not send_one_by_one:
+            ret = await cls._parse_onebot_json(message_chain)
+            if not ret:
+                return
+            await cls._dispatch_send(bot, event, is_group, session_id, ret)
             return
-
-        send_one_by_one = False
-        for seg in message.chain:
+        for seg in message_chain.chain:
             if isinstance(seg, (Node, Nodes)):
-                # 转发消息不能和普通消息混在一起发送
-                send_one_by_one = True
-                break
-
-        if send_one_by_one:
-            for seg in message.chain:
-                if isinstance(seg, (Node, Nodes)):
-                    # 合并转发消息
-
-                    if isinstance(seg, Node):
-                        nodes = Nodes([seg])
-                        seg = nodes
-
-                    payload = seg.toDict()
-                    if self.get_group_id():
-                        payload["group_id"] = self.get_group_id()
-                        await self.bot.call_action("send_group_forward_msg", **payload)
-                    else:
-                        payload["user_id"] = self.get_sender_id()
-                        await self.bot.call_action(
-                            "send_private_forward_msg", **payload
-                        )
+                # 合并转发消息
+                if isinstance(seg, Node):
+                    nodes = Nodes([seg])
+                    seg = nodes
+
+                payload = await seg.to_dict()
+
+                if is_group:
+                    payload["group_id"] = session_id
+                    await bot.call_action("send_group_forward_msg", **payload)
                 else:
-                    await self.bot.send(
-                        self.message_obj.raw_message,
-                        await AiocqhttpMessageEvent._parse_onebot_json(
-                            MessageChain([seg])
-                        ),
-                    )
-                    await asyncio.sleep(0.5)
-        else:
-            await self.bot.send(self.message_obj.raw_message, ret)
+                    payload["user_id"] = session_id
+                    await bot.call_action("send_private_forward_msg", **payload)
+            elif isinstance(seg, File):
+                d = await cls._from_segment_to_dict(seg)
+                await cls._dispatch_send(bot, event, is_group, session_id, [d])
+            else:
+                messages = await cls._parse_onebot_json(MessageChain([seg]))
+                if not messages:
+                    continue
+                await cls._dispatch_send(bot, event, is_group, session_id, messages)
+                await asyncio.sleep(0.5)
 
+    async def send(self, message: MessageChain):
+        """发送消息"""
+        event = getattr(self.message_obj, "raw_message", None)
+
+        is_group = bool(self.get_group_id())
+        session_id = self.get_group_id() if is_group else self.get_sender_id()
+
+        await self.send_message(
+            bot=self.bot,
+            message_chain=message,
+            event=event,  # 不强制要求一定是 Event
+            is_group=is_group,
+            session_id=session_id,
+        )
         await super().send(message)
 
     async def send_streaming(
-        self, generator: AsyncGenerator, use_fallback: bool = False
+        self,
+        generator: AsyncGenerator,
+        use_fallback: bool = False,
     ):
         if not use_fallback:
             buffer = None
@@ -94,7 +170,7 @@ class AiocqhttpMessageEvent(AstrMessageEvent):
                 else:
                     buffer.chain.extend(chain.chain)
             if not buffer:
-                return
+                return None
             buffer.squash_plain()
             await self.send(buffer)
             return await super().send_streaming(generator, use_fallback)
@@ -130,7 +206,7 @@ class AiocqhttpMessageEvent(AstrMessageEvent):
             group_id=group_id,
         )
 
-        members: List[Dict] = await self.bot.call_action(
+        members: list[dict] = await self.bot.call_action(
             "get_group_member_list",
             group_id=group_id,
         )