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

astrbot/core/platform/sources/weixin_official_account/weixin_offacc_adapter.py

@@ -0,0 +1,306 @@
+import asyncio
+import sys
+import uuid
+
+import quart
+from requests import Response
+from wechatpy import WeChatClient, parse_message
+from wechatpy.crypto import WeChatCrypto
+from wechatpy.exceptions import InvalidSignatureException
+from wechatpy.messages import BaseMessage, ImageMessage, TextMessage, VoiceMessage
+from wechatpy.utils import check_signature
+
+from astrbot.api.event import MessageChain
+from astrbot.api.message_components import Image, Plain, Record
+from astrbot.api.platform import (
+    AstrBotMessage,
+    MessageMember,
+    MessageType,
+    Platform,
+    PlatformMetadata,
+    register_platform_adapter,
+)
+from astrbot.core import logger
+from astrbot.core.platform.astr_message_event import MessageSesion
+
+from .weixin_offacc_event import WeixinOfficialAccountPlatformEvent
+
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
+
+
+class WecomServer:
+    def __init__(self, event_queue: asyncio.Queue, config: dict):
+        self.server = quart.Quart(__name__)
+        self.port = int(config.get("port"))
+        self.callback_server_host = config.get("callback_server_host", "0.0.0.0")
+        self.token = config.get("token")
+        self.encoding_aes_key = config.get("encoding_aes_key")
+        self.appid = config.get("appid")
+        self.server.add_url_rule(
+            "/callback/command",
+            view_func=self.verify,
+            methods=["GET"],
+        )
+        self.server.add_url_rule(
+            "/callback/command",
+            view_func=self.callback_command,
+            methods=["POST"],
+        )
+        self.crypto = WeChatCrypto(self.token, self.encoding_aes_key, self.appid)
+
+        self.event_queue = event_queue
+
+        self.callback = None
+        self.shutdown_event = asyncio.Event()
+
+    async def verify(self):
+        logger.info(f"验证请求有效性: {quart.request.args}")
+
+        args = quart.request.args
+        if not args.get("signature", None):
+            logger.error("未知的响应，请检查回调地址是否填写正确。")
+            return "err"
+        try:
+            check_signature(
+                self.token,
+                args.get("signature"),
+                args.get("timestamp"),
+                args.get("nonce"),
+            )
+            logger.info("验证请求有效性成功。")
+            return args.get("echostr", "empty")
+        except InvalidSignatureException:
+            logger.error("验证请求有效性失败，签名异常，请检查配置。")
+            return "err"
+
+    async def callback_command(self):
+        data = await quart.request.get_data()
+        msg_signature = quart.request.args.get("msg_signature")
+        timestamp = quart.request.args.get("timestamp")
+        nonce = quart.request.args.get("nonce")
+        try:
+            xml = self.crypto.decrypt_message(data, msg_signature, timestamp, nonce)
+        except InvalidSignatureException:
+            logger.error("解密失败，签名异常，请检查配置。")
+            raise
+        else:
+            msg = parse_message(xml)
+            logger.info(f"解析成功: {msg}")
+
+            if self.callback:
+                result_xml = await self.callback(msg)
+                if not result_xml:
+                    return "success"
+                if isinstance(result_xml, str):
+                    return result_xml
+
+        return "success"
+
+    async def start_polling(self):
+        logger.info(
+            f"将在 {self.callback_server_host}:{self.port} 端口启动 微信公众平台 适配器。",
+        )
+        await self.server.run_task(
+            host=self.callback_server_host,
+            port=self.port,
+            shutdown_trigger=self.shutdown_trigger,
+        )
+
+    async def shutdown_trigger(self):
+        await self.shutdown_event.wait()
+
+
+@register_platform_adapter(
+    "weixin_official_account", "微信公众平台 适配器", support_streaming_message=False
+)
+class WeixinOfficialAccountPlatformAdapter(Platform):
+    def __init__(
+        self,
+        platform_config: dict,
+        platform_settings: dict,
+        event_queue: asyncio.Queue,
+    ) -> None:
+        super().__init__(event_queue)
+        self.config = platform_config
+        self.settingss = platform_settings
+        self.client_self_id = uuid.uuid4().hex[:8]
+        self.api_base_url = platform_config.get(
+            "api_base_url",
+            "https://api.weixin.qq.com/cgi-bin/",
+        )
+        self.active_send_mode = self.config.get("active_send_mode", False)
+
+        if not self.api_base_url:
+            self.api_base_url = "https://api.weixin.qq.com/cgi-bin/"
+
+        self.api_base_url = self.api_base_url.removesuffix("/")
+        if not self.api_base_url.endswith("/cgi-bin"):
+            self.api_base_url += "/cgi-bin"
+
+        if not self.api_base_url.endswith("/"):
+            self.api_base_url += "/"
+
+        self.server = WecomServer(self._event_queue, self.config)
+
+        self.client = WeChatClient(
+            self.config["appid"].strip(),
+            self.config["secret"].strip(),
+        )
+
+        self.client.API_BASE_URL = self.api_base_url
+
+        # 微信公众号必须 5 秒内进行回复，否则会重试 3 次，我们需要对其进行消息排重
+        # msgid -> Future
+        self.wexin_event_workers: dict[str, asyncio.Future] = {}
+
+        async def callback(msg: BaseMessage):
+            try:
+                if self.active_send_mode:
+                    await self.convert_message(msg, None)
+                else:
+                    if msg.id in self.wexin_event_workers:
+                        future = self.wexin_event_workers[msg.id]
+                        logger.debug(f"duplicate message id checked: {msg.id}")
+                    else:
+                        future = asyncio.get_event_loop().create_future()
+                        self.wexin_event_workers[msg.id] = future
+                        await self.convert_message(msg, future)
+                    # I love shield so much!
+                    result = await asyncio.wait_for(
+                        asyncio.shield(future),
+                        60,
+                    )  # wait for 60s
+                    logger.debug(f"Got future result: {result}")
+                    self.wexin_event_workers.pop(msg.id, None)
+                    return result  # xml. see weixin_offacc_event.py
+            except asyncio.TimeoutError:
+                pass
+            except Exception as e:
+                logger.error(f"转换消息时出现异常: {e}")
+
+        self.server.callback = callback
+
+    @override
+    async def send_by_session(
+        self,
+        session: MessageSesion,
+        message_chain: MessageChain,
+    ):
+        await super().send_by_session(session, message_chain)
+
+    @override
+    def meta(self) -> PlatformMetadata:
+        return PlatformMetadata(
+            "weixin_official_account",
+            "微信公众平台 适配器",
+            id=self.config.get("id", "weixin_official_account"),
+            support_streaming_message=False,
+        )
+
+    @override
+    async def run(self):
+        await self.server.start_polling()
+
+    async def convert_message(
+        self,
+        msg,
+        future: asyncio.Future = None,
+    ) -> AstrBotMessage | None:
+        abm = AstrBotMessage()
+        if isinstance(msg, TextMessage):
+            abm.message_str = msg.content
+            abm.self_id = str(msg.target)
+            abm.message = [Plain(msg.content)]
+            abm.type = MessageType.FRIEND_MESSAGE
+            abm.sender = MessageMember(
+                msg.source,
+                msg.source,
+            )
+            abm.message_id = msg.id
+            abm.timestamp = msg.time
+            abm.session_id = abm.sender.user_id
+        elif msg.type == "image":
+            assert isinstance(msg, ImageMessage)
+            abm.message_str = "[图片]"
+            abm.self_id = str(msg.target)
+            abm.message = [Image(file=msg.image, url=msg.image)]
+            abm.type = MessageType.FRIEND_MESSAGE
+            abm.sender = MessageMember(
+                msg.source,
+                msg.source,
+            )
+            abm.message_id = msg.id
+            abm.timestamp = msg.time
+            abm.session_id = abm.sender.user_id
+        elif msg.type == "voice":
+            assert isinstance(msg, VoiceMessage)
+
+            resp: Response = await asyncio.get_event_loop().run_in_executor(
+                None,
+                self.client.media.download,
+                msg.media_id,
+            )
+            path = f"data/temp/wecom_{msg.media_id}.amr"
+            with open(path, "wb") as f:
+                f.write(resp.content)
+
+            try:
+                from pydub import AudioSegment
+
+                path_wav = f"data/temp/wecom_{msg.media_id}.wav"
+                audio = AudioSegment.from_file(path)
+                audio.export(path_wav, format="wav")
+            except Exception as e:
+                logger.error(
+                    f"转换音频失败: {e}。如果没有安装 pydub 和 ffmpeg 请先安装。",
+                )
+                path_wav = path
+                return
+
+            abm.message_str = ""
+            abm.self_id = str(msg.target)
+            abm.message = [Record(file=path_wav, url=path_wav)]
+            abm.type = MessageType.FRIEND_MESSAGE
+            abm.sender = MessageMember(
+                msg.source,
+                msg.source,
+            )
+            abm.message_id = msg.id
+            abm.timestamp = msg.time
+            abm.session_id = abm.sender.user_id
+        else:
+            logger.warning(f"暂未实现的事件: {msg.type}")
+            future.set_result(None)
+            return
+        # 很不优雅 :(
+        abm.raw_message = {
+            "message": msg,
+            "future": future,
+            "active_send_mode": self.active_send_mode,
+        }
+        logger.info(f"abm: {abm}")
+        await self.handle_msg(abm)
+
+    async def handle_msg(self, message: AstrBotMessage):
+        message_event = WeixinOfficialAccountPlatformEvent(
+            message_str=message.message_str,
+            message_obj=message,
+            platform_meta=self.meta(),
+            session_id=message.session_id,
+            client=self.client,
+        )
+        self.commit_event(message_event)
+
+    def get_client(self) -> WeChatClient:
+        return self.client
+
+    async def terminate(self):
+        self.server.shutdown_event.set()
+        try:
+            await self.server.server.shutdown()
+        except Exception as _:
+            pass
+        logger.info("微信公众平台 适配器已被优雅地关闭")

astrbot/core/platform/sources/weixin_official_account/weixin_offacc_event.py

@@ -0,0 +1,186 @@
+import asyncio
+import uuid
+
+from wechatpy import WeChatClient
+from wechatpy.replies import ImageReply, TextReply, VoiceReply
+
+from astrbot.api import logger
+from astrbot.api.event import AstrMessageEvent, MessageChain
+from astrbot.api.message_components import Image, Plain, Record
+from astrbot.api.platform import AstrBotMessage, PlatformMetadata
+
+try:
+    import pydub
+except Exception:
+    logger.warning(
+        "检测到 pydub 库未安装，微信公众平台将无法语音收发。如需使用语音，请前往管理面板 -> 控制台 -> 安装 Pip 库安装 pydub。",
+    )
+
+
+class WeixinOfficialAccountPlatformEvent(AstrMessageEvent):
+    def __init__(
+        self,
+        message_str: str,
+        message_obj: AstrBotMessage,
+        platform_meta: PlatformMetadata,
+        session_id: str,
+        client: WeChatClient,
+    ):
+        super().__init__(message_str, message_obj, platform_meta, session_id)
+        self.client = client
+
+    @staticmethod
+    async def send_with_client(
+        client: WeChatClient,
+        message: MessageChain,
+        user_name: str,
+    ):
+        pass
+
+    async def split_plain(self, plain: str) -> list[str]:
+        """将长文本分割成多个小文本, 每个小文本长度不超过 2048 字符
+
+        Args:
+            plain (str): 要分割的长文本
+        Returns:
+            list[str]: 分割后的文本列表
+
+        """
+        if len(plain) <= 2048:
+            return [plain]
+        result = []
+        start = 0
+        while start < len(plain):
+            # 剩下的字符串长度<2048时结束
+            if start + 2048 >= len(plain):
+                result.append(plain[start:])
+                break
+
+            # 向前搜索分割标点符号
+            end = min(start + 2048, len(plain))
+            cut_position = end
+            for i in range(end, start, -1):
+                if i < len(plain) and plain[i - 1] in [
+                    "。",
+                    "！",
+                    "？",
+                    ".",
+                    "!",
+                    "?",
+                    "\n",
+                    ";",
+                    "；",
+                ]:
+                    cut_position = i
+                    break
+
+            # 没找到合适的位置分割, 直接切分
+            if cut_position == end and end < len(plain):
+                cut_position = end
+
+            result.append(plain[start:cut_position])
+            start = cut_position
+
+        return result
+
+    async def send(self, message: MessageChain):
+        message_obj = self.message_obj
+        active_send_mode = message_obj.raw_message.get("active_send_mode", False)
+        for comp in message.chain:
+            if isinstance(comp, Plain):
+                # Split long text messages if needed
+                plain_chunks = await self.split_plain(comp.text)
+                for chunk in plain_chunks:
+                    if active_send_mode:
+                        self.client.message.send_text(message_obj.sender.user_id, chunk)
+                    else:
+                        reply = TextReply(
+                            content=chunk,
+                            message=self.message_obj.raw_message["message"],
+                        )
+                        xml = reply.render()
+                        future = self.message_obj.raw_message["future"]
+                        assert isinstance(future, asyncio.Future)
+                        future.set_result(xml)
+                    await asyncio.sleep(0.5)  # Avoid sending too fast
+            elif isinstance(comp, Image):
+                img_path = await comp.convert_to_file_path()
+
+                with open(img_path, "rb") as f:
+                    try:
+                        response = self.client.media.upload("image", f)
+                    except Exception as e:
+                        logger.error(f"微信公众平台上传图片失败: {e}")
+                        await self.send(
+                            MessageChain().message(f"微信公众平台上传图片失败: {e}"),
+                        )
+                        return
+                    logger.debug(f"微信公众平台上传图片返回: {response}")
+
+                    if active_send_mode:
+                        self.client.message.send_image(
+                            message_obj.sender.user_id,
+                            response["media_id"],
+                        )
+                    else:
+                        reply = ImageReply(
+                            media_id=response["media_id"],
+                            message=self.message_obj.raw_message["message"],
+                        )
+                        xml = reply.render()
+                        future = self.message_obj.raw_message["future"]
+                        assert isinstance(future, asyncio.Future)
+                        future.set_result(xml)
+
+            elif isinstance(comp, Record):
+                record_path = await comp.convert_to_file_path()
+                # 转成amr
+                record_path_amr = f"data/temp/{uuid.uuid4()}.amr"
+                pydub.AudioSegment.from_wav(record_path).export(
+                    record_path_amr,
+                    format="amr",
+                )
+
+                with open(record_path_amr, "rb") as f:
+                    try:
+                        response = self.client.media.upload("voice", f)
+                    except Exception as e:
+                        logger.error(f"微信公众平台上传语音失败: {e}")
+                        await self.send(
+                            MessageChain().message(f"微信公众平台上传语音失败: {e}"),
+                        )
+                        return
+                    logger.info(f"微信公众平台上传语音返回: {response}")
+
+                    if active_send_mode:
+                        self.client.message.send_voice(
+                            message_obj.sender.user_id,
+                            response["media_id"],
+                        )
+                    else:
+                        reply = VoiceReply(
+                            media_id=response["media_id"],
+                            message=self.message_obj.raw_message["message"],
+                        )
+                        xml = reply.render()
+                        future = self.message_obj.raw_message["future"]
+                        assert isinstance(future, asyncio.Future)
+                        future.set_result(xml)
+
+            else:
+                logger.warning(f"还没实现这个消息类型的发送逻辑: {comp.type}。")
+
+        await super().send(message)
+
+    async def send_streaming(self, generator, use_fallback: bool = False):
+        buffer = None
+        async for chain in generator:
+            if not buffer:
+                buffer = chain
+            else:
+                buffer.chain.extend(chain.chain)
+        if not buffer:
+            return None
+        buffer.squash_plain()
+        await self.send(buffer)
+        return await super().send_streaming(generator, use_fallback)

astrbot/core/platform_message_history_mgr.py

@@ -0,0 +1,49 @@
+from astrbot.core.db import BaseDatabase
+from astrbot.core.db.po import PlatformMessageHistory
+
+
+class PlatformMessageHistoryManager:
+    def __init__(self, db_helper: BaseDatabase):
+        self.db = db_helper
+
+    async def insert(
+        self,
+        platform_id: str,
+        user_id: str,
+        content: list[dict],  # TODO: parse from message chain
+        sender_id: str | None = None,
+        sender_name: str | None = None,
+    ):
+        """Insert a new platform message history record."""
+        await self.db.insert_platform_message_history(
+            platform_id=platform_id,
+            user_id=user_id,
+            content=content,
+            sender_id=sender_id,
+            sender_name=sender_name,
+        )
+
+    async def get(
+        self,
+        platform_id: str,
+        user_id: str,
+        page: int = 1,
+        page_size: int = 200,
+    ) -> list[PlatformMessageHistory]:
+        """Get platform message history for a specific user."""
+        history = await self.db.get_platform_message_history(
+            platform_id=platform_id,
+            user_id=user_id,
+            page=page,
+            page_size=page_size,
+        )
+        history.reverse()
+        return history
+
+    async def delete(self, platform_id: str, user_id: str, offset_sec: int = 86400):
+        """Delete platform message history records older than the specified offset."""
+        await self.db.delete_platform_message_offset(
+            platform_id=platform_id,
+            user_id=user_id,
+            offset_sec=offset_sec,
+        )

astrbot/core/provider/__init__.py

@@ -1,5 +1,4 @@
-from .provider import Provider, Personality, STTProvider
-
 from .entities import ProviderMetaData
+from .provider import Provider, STTProvider
 
-__all__ = ["Provider", "Personality", "ProviderMetaData", "STTProvider"]
+__all__ = ["Provider", "ProviderMetaData", "STTProvider"]

astrbot/core/provider/entites.py

@@ -1,19 +1,19 @@
 from astrbot.core.provider.entities import (
+    AssistantMessageSegment,
+    LLMResponse,
+    ProviderMetaData,
     ProviderRequest,
     ProviderType,
-    ProviderMetaData,
-    ToolCallsResult,
-    AssistantMessageSegment,
     ToolCallMessageSegment,
-    LLMResponse,
+    ToolCallsResult,
 )
 
 __all__ = [
+    "AssistantMessageSegment",
+    "LLMResponse",
+    "ProviderMetaData",
     "ProviderRequest",
     "ProviderType",
-    "ProviderMetaData",
-    "ToolCallsResult",
-    "AssistantMessageSegment",
     "ToolCallMessageSegment",
-    "LLMResponse",
+    "ToolCallsResult",
 ]