AstrBot 4.5.1__py3-none-any.whl → 4.5.3__py3-none-any.whl

astrbot/core/pipeline/respond/stage.py

@@ -1,25 +1,27 @@
-import random
 import asyncio
 import math
+import random
+from collections.abc import AsyncGenerator
+
 import astrbot.core.message.components as Comp
-from typing import Union, AsyncGenerator
-from ..stage import register_stage, Stage
-from ..context import PipelineContext, call_event_hook
-from astrbot.core.platform.astr_message_event import AstrMessageEvent
-from astrbot.core.message.message_event_result import MessageChain, ResultContentType
 from astrbot.core import logger
 from astrbot.core.message.components import BaseMessageComponent, ComponentType
+from astrbot.core.message.message_event_result import MessageChain, ResultContentType
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core.star.star_handler import EventType
 from astrbot.core.utils.path_util import path_Mapping
 from astrbot.core.utils.session_lock import session_lock_manager
 
+from ..context import PipelineContext, call_event_hook
+from ..stage import Stage, register_stage
+
 
 @register_stage
 class RespondStage(Stage):
     # 组件类型到其非空判断函数的映射
     _component_validators = {
         Comp.Plain: lambda comp: bool(
-            comp.text and comp.text.strip()
+            comp.text and comp.text.strip(),
         ),  # 纯文本消息需要strip
         Comp.Face: lambda comp: comp.id is not None,  # QQ表情
         Comp.Record: lambda comp: bool(comp.file),  # 语音
@@ -58,7 +60,7 @@ class RespondStage(Stage):
             "segmented_reply"
         ]["interval_method"]
         self.log_base = float(
-            ctx.astrbot_config["platform_settings"]["segmented_reply"]["log_base"]
+            ctx.astrbot_config["platform_settings"]["segmented_reply"]["log_base"],
         )
         interval_str: str = ctx.astrbot_config["platform_settings"]["segmented_reply"][
             "interval"
@@ -86,17 +88,16 @@ class RespondStage(Stage):
                 wc = await self._word_cnt(comp.text)
                 i = math.log(wc + 1, self.log_base)
                 return random.uniform(i, i + 0.5)
-            else:
-                return random.uniform(1, 1.75)
-        else:
-            # random
-            return random.uniform(self.interval[0], self.interval[1])
+            return random.uniform(1, 1.75)
+        # random
+        return random.uniform(self.interval[0], self.interval[1])
 
     async def _is_empty_message_chain(self, chain: list[BaseMessageComponent]):
         """检查消息链是否为空
 
         Args:
             chain (list[BaseMessageComponent]): 包含消息对象的列表
+
         """
         if not chain:
             return True
@@ -150,8 +151,9 @@ class RespondStage(Stage):
         return extracted
 
     async def process(
-        self, event: AstrMessageEvent
-    ) -> Union[None, AsyncGenerator[None, None]]:
+        self,
+        event: AstrMessageEvent,
+    ) -> None | AsyncGenerator[None, None]:
         result = event.get_result()
         if result is None:
             return
@@ -159,7 +161,7 @@ class RespondStage(Stage):
             return
 
         logger.info(
-            f"Prepare to send - {event.get_sender_name()}/{event.get_sender_id()}: {event._outline_chain(result.chain)}"
+            f"Prepare to send - {event.get_sender_name()}/{event.get_sender_id()}: {event._outline_chain(result.chain)}",
         )
 
         if result.result_content_type == ResultContentType.STREAMING_RESULT:
@@ -168,12 +170,13 @@ class RespondStage(Stage):
                 return
             # 流式结果直接交付平台适配器处理
             use_fallback = self.config.get("provider_settings", {}).get(
-                "streaming_segmented", False
+                "streaming_segmented",
+                False,
             )
             logger.info(f"应用流式输出({event.get_platform_id()})")
             await event.send_streaming(result.async_stream, use_fallback)
             return
-        elif len(result.chain) > 0:
+        if len(result.chain) > 0:
             # 检查路径映射
             if mappings := self.platform_settings.get("path_mapping", []):
                 for idx, component in enumerate(result.chain):
@@ -212,7 +215,7 @@ class RespondStage(Stage):
                 if not result.chain or len(result.chain) == 0:
                     # may fix #2670
                     logger.warning(
-                        f"实际消息链为空, 跳过发送阶段。header_chain: {header_comps}, actual_chain: {result.chain}"
+                        f"实际消息链为空, 跳过发送阶段。header_chain: {header_comps}, actual_chain: {result.chain}",
                     )
                     return
                 async with session_lock_manager.acquire_lock(event.unified_msg_origin):
@@ -237,7 +240,7 @@ class RespondStage(Stage):
                 ):
                     # may fix #2670
                     logger.warning(
-                        f"消息链全为 Reply 和 At 消息段, 跳过发送阶段。chain: {result.chain}"
+                        f"消息链全为 Reply 和 At 消息段, 跳过发送阶段。chain: {result.chain}",
                     )
                     return
                 sep_comps = self._extract_comp(

astrbot/core/pipeline/result_decorate/stage.py

@@ -1,7 +1,7 @@
 import re
 import time
 import traceback
-from typing import AsyncGenerator, Union
+from collections.abc import AsyncGenerator
 
 from astrbot.core import file_token_service, html_renderer, logger
 from astrbot.core.message.components import At, File, Image, Node, Plain, Record, Reply
@@ -30,8 +30,7 @@ class ResultDecorateStage(Stage):
         self.t2i_word_threshold = ctx.astrbot_config["t2i_word_threshold"]
         try:
             self.t2i_word_threshold = int(self.t2i_word_threshold)
-            if self.t2i_word_threshold < 50:
-                self.t2i_word_threshold = 50
+            self.t2i_word_threshold = max(self.t2i_word_threshold, 50)
         except BaseException:
             self.t2i_word_threshold = 150
         self.t2i_strategy = ctx.astrbot_config["t2i_strategy"]
@@ -46,7 +45,7 @@ class ResultDecorateStage(Stage):
         self.words_count_threshold = int(
             ctx.astrbot_config["platform_settings"]["segmented_reply"][
                 "words_count_threshold"
-            ]
+            ],
         )
         self.enable_segmented_reply = ctx.astrbot_config["platform_settings"][
             "segmented_reply"
@@ -71,8 +70,9 @@ class ResultDecorateStage(Stage):
                     await self.content_safe_check_stage.initialize(ctx)
 
     async def process(
-        self, event: AstrMessageEvent
-    ) -> Union[None, AsyncGenerator[None, None]]:
+        self,
+        event: AstrMessageEvent,
+    ) -> None | AsyncGenerator[None, None]:
         result = event.get_result()
         if result is None or not result.chain:
             return
@@ -94,34 +94,36 @@ class ResultDecorateStage(Stage):
                 if isinstance(comp, Plain):
                     text += comp.text
             async for _ in self.content_safe_check_stage.process(
-                event, check_text=text
+                event,
+                check_text=text,
             ):
                 yield
 
         # 发送消息前事件钩子
         handlers = star_handlers_registry.get_handlers_by_event_type(
-            EventType.OnDecoratingResultEvent, plugins_name=event.plugins_name
+            EventType.OnDecoratingResultEvent,
+            plugins_name=event.plugins_name,
         )
         for handler in handlers:
             try:
                 logger.debug(
-                    f"hook(on_decorating_result) -> {star_map[handler.handler_module_path].name} - {handler.handler_name}"
+                    f"hook(on_decorating_result) -> {star_map[handler.handler_module_path].name} - {handler.handler_name}",
                 )
                 if is_stream:
                     logger.warning(
-                        "启用流式输出时，依赖发送消息前事件钩子的插件可能无法正常工作"
+                        "启用流式输出时，依赖发送消息前事件钩子的插件可能无法正常工作",
                     )
                 await handler.handler(event)
                 if event.get_result() is None or not event.get_result().chain:
                     logger.debug(
-                        f"hook(on_decorating_result) -> {star_map[handler.handler_module_path].name} - {handler.handler_name} 将消息结果清空。"
+                        f"hook(on_decorating_result) -> {star_map[handler.handler_module_path].name} - {handler.handler_name} 将消息结果清空。",
                     )
             except BaseException:
                 logger.error(traceback.format_exc())
 
             if event.is_stopped():
                 logger.info(
-                    f"{star_map[handler.handler_module_path].name} - {handler.handler_name} 终止了事件传播。"
+                    f"{star_map[handler.handler_module_path].name} - {handler.handler_name} 终止了事件传播。",
                 )
                 return
 
@@ -160,7 +162,9 @@ class ResultDecorateStage(Stage):
                                 new_chain.append(comp)
                                 continue
                             split_response = re.findall(
-                                self.regex, comp.text, re.DOTALL | re.MULTILINE
+                                self.regex,
+                                comp.text,
+                                re.DOTALL | re.MULTILINE,
                             )
                             if not split_response:
                                 new_chain.append(comp)
@@ -177,7 +181,7 @@ class ResultDecorateStage(Stage):
 
             # TTS
             tts_provider = self.ctx.plugin_manager.context.get_using_tts_provider(
-                event.unified_msg_origin
+                event.unified_msg_origin,
             )
 
             if (
@@ -187,7 +191,7 @@ class ResultDecorateStage(Stage):
             ):
                 if not tts_provider:
                     logger.warning(
-                        f"会话 {event.unified_msg_origin} 未配置文本转语音模型。"
+                        f"会话 {event.unified_msg_origin} 未配置文本转语音模型。",
                     )
                 else:
                     new_chain = []
@@ -199,7 +203,7 @@ class ResultDecorateStage(Stage):
                                 logger.info(f"TTS 结果: {audio_path}")
                                 if not audio_path:
                                     logger.error(
-                                        f"由于 TTS 音频文件未找到，消息段转语音失败: {comp.text}"
+                                        f"由于 TTS 音频文件未找到，消息段转语音失败: {comp.text}",
                                     )
                                     new_chain.append(comp)
                                     continue
@@ -217,7 +221,7 @@ class ResultDecorateStage(Stage):
                                 url = None
                                 if use_file_service and callback_api_base:
                                     token = await file_token_service.register_file(
-                                        audio_path
+                                        audio_path,
                                     )
                                     url = f"{callback_api_base}/api/file/{token}"
                                     logger.debug(f"已注册：{url}")
@@ -226,7 +230,7 @@ class ResultDecorateStage(Stage):
                                     Record(
                                         file=url or audio_path,
                                         url=url or audio_path,
-                                    )
+                                    ),
                                 )
                                 if dual_output:
                                     new_chain.append(comp)
@@ -242,12 +246,13 @@ class ResultDecorateStage(Stage):
             elif (
                 result.use_t2i_ is None and self.ctx.astrbot_config["t2i"]
             ) or result.use_t2i_:
-                plain_str = ""
+                parts = []
                 for comp in result.chain:
                     if isinstance(comp, Plain):
-                        plain_str += "\n\n" + comp.text
+                        parts.append("\n\n" + comp.text)
                     else:
                         break
+                plain_str = "".join(parts)
                 if plain_str and len(plain_str) > self.t2i_word_threshold:
                     render_start = time.time()
                     try:
@@ -262,7 +267,7 @@ class ResultDecorateStage(Stage):
                         return
                     if time.time() - render_start > 3:
                         logger.warning(
-                            "文本转图片耗时超过了 3 秒，如果觉得很慢可以使用 /t2i 关闭文本转图片模式。"
+                            "文本转图片耗时超过了 3 秒，如果觉得很慢可以使用 /t2i 关闭文本转图片模式。",
                         )
                     if url:
                         if url.startswith("http"):
@@ -286,7 +291,9 @@ class ResultDecorateStage(Stage):
                         word_cnt += len(comp.text)
                 if word_cnt > self.forward_threshold:
                     node = Node(
-                        uin=event.get_self_id(), name="AstrBot", content=[*result.chain]
+                        uin=event.get_self_id(),
+                        name="AstrBot",
+                        content=[*result.chain],
                     )
                     result.chain = [node]
 
@@ -298,7 +305,8 @@ class ResultDecorateStage(Stage):
                     and event.get_message_type() != MessageType.FRIEND_MESSAGE
                 ):
                     result.chain.insert(
-                        0, At(qq=event.get_sender_id(), name=event.get_sender_name())
+                        0,
+                        At(qq=event.get_sender_id(), name=event.get_sender_name()),
                     )
                     if len(result.chain) > 1 and isinstance(result.chain[1], Plain):
                         result.chain[1].text = "\n" + result.chain[1].text

astrbot/core/pipeline/scheduler.py

@@ -1,9 +1,11 @@
+from collections.abc import AsyncGenerator
+
+from astrbot.core import logger
+from astrbot.core.platform import AstrMessageEvent
+
 from . import STAGES_ORDER
-from .stage import registered_stages
 from .context import PipelineContext
-from typing import AsyncGenerator
-from astrbot.core.platform import AstrMessageEvent
-from astrbot.core import logger
+from .stage import registered_stages
 
 
 class PipelineScheduler:
@@ -11,7 +13,7 @@ class PipelineScheduler:
 
     def __init__(self, context: PipelineContext):
         registered_stages.sort(
-            key=lambda x: STAGES_ORDER.index(x.__name__)
+            key=lambda x: STAGES_ORDER.index(x.__name__),
         )  # 按照顺序排序
         self.ctx = context  # 上下文对象
         self.stages = []  # 存储阶段实例
@@ -29,12 +31,13 @@ class PipelineScheduler:
         Args:
             event (AstrMessageEvent): 事件对象
             from_stage (int): 从第几个阶段开始执行, 默认从0开始
+
         """
         for i in range(from_stage, len(self.stages)):
             stage = self.stages[i]  # 获取当前要执行的阶段
             # logger.debug(f"执行阶段 {stage.__class__.__name__}")
             coroutine = stage.process(
-                event
+                event,
             )  # 调用阶段的process方法, 返回协程或者异步生成器
 
             if isinstance(coroutine, AsyncGenerator):
@@ -43,7 +46,7 @@ class PipelineScheduler:
                     # 此处是前置处理完成后的暂停点(yield), 下面开始执行后续阶段
                     if event.is_stopped():
                         logger.debug(
-                            f"阶段 {stage.__class__.__name__} 已终止事件传播。"
+                            f"阶段 {stage.__class__.__name__} 已终止事件传播。",
                         )
                         break
 
@@ -53,7 +56,7 @@ class PipelineScheduler:
                     # 此处是后续所有阶段处理完毕后返回的点, 执行后置处理
                     if event.is_stopped():
                         logger.debug(
-                            f"阶段 {stage.__class__.__name__} 已终止事件传播。"
+                            f"阶段 {stage.__class__.__name__} 已终止事件传播。",
                         )
                         break
             else:
@@ -70,6 +73,7 @@ class PipelineScheduler:
 
         Args:
             event (AstrMessageEvent): 事件对象
+
         """
         await self._process_stages(event)
 

astrbot/core/pipeline/session_status_check/stage.py

@@ -1,9 +1,11 @@
-from ..stage import Stage, register_stage
-from ..context import PipelineContext
-from typing import AsyncGenerator, Union
+from collections.abc import AsyncGenerator
+
+from astrbot.core import logger
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core.star.session_llm_manager import SessionServiceManager
-from astrbot.core import logger
+
+from ..context import PipelineContext
+from ..stage import Stage, register_stage
 
 
 @register_stage
@@ -15,19 +17,21 @@ class SessionStatusCheckStage(Stage):
         self.conv_mgr = ctx.plugin_manager.context.conversation_manager
 
     async def process(
-        self, event: AstrMessageEvent
-    ) -> Union[None, AsyncGenerator[None, None]]:
+        self,
+        event: AstrMessageEvent,
+    ) -> None | AsyncGenerator[None, None]:
         # 检查会话是否整体启用
         if not SessionServiceManager.is_session_enabled(event.unified_msg_origin):
             logger.debug(f"会话 {event.unified_msg_origin} 已被关闭，已终止事件传播。")
 
             # workaround for #2309
             conv_id = await self.conv_mgr.get_curr_conversation_id(
-                event.unified_msg_origin
+                event.unified_msg_origin,
             )
             if not conv_id:
                 await self.conv_mgr.new_conversation(
-                    event.unified_msg_origin, platform_id=event.get_platform_id()
+                    event.unified_msg_origin,
+                    platform_id=event.get_platform_id(),
                 )
 
             event.stop_event()

astrbot/core/pipeline/stage.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
+
 import abc
-from typing import List, AsyncGenerator, Union, Type
+from collections.abc import AsyncGenerator
+
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
+
 from .context import PipelineContext
 
-registered_stages: List[Type[Stage]] = []  # 维护了所有已注册的 Stage 实现类类型
+registered_stages: list[type[Stage]] = []  # 维护了所有已注册的 Stage 实现类类型
 
 
 def register_stage(cls):
@@ -22,18 +25,21 @@ class Stage(abc.ABC):
 
         Args:
             ctx (PipelineContext): 消息管道上下文对象, 包括配置和插件管理器
+
         """
         raise NotImplementedError
 
     @abc.abstractmethod
     async def process(
-        self, event: AstrMessageEvent
-    ) -> Union[None, AsyncGenerator[None, None]]:
+        self,
+        event: AstrMessageEvent,
+    ) -> None | AsyncGenerator[None, None]:
         """处理事件
 
         Args:
             event (AstrMessageEvent): 事件对象，包含事件的相关信息
         Returns:
             Union[None, AsyncGenerator[None, None]]: 处理结果，可能是 None 或者异步生成器, 如果为 None 则表示不需要继续处理, 如果为异步生成器则表示需要继续处理(进入下一个阶段)
+
         """
         raise NotImplementedError

astrbot/core/pipeline/waking_check/stage.py

@@ -1,11 +1,11 @@
-from typing import AsyncGenerator, Union
+from collections.abc import AsyncGenerator
 
 from astrbot import logger
 from astrbot.core.message.components import At, AtAll, Reply
 from astrbot.core.message.message_event_result import MessageChain, MessageEventResult
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
-from astrbot.core.star.filter.permission import PermissionTypeFilter
 from astrbot.core.star.filter.command_group import CommandGroupFilter
+from astrbot.core.star.filter.permission import PermissionTypeFilter
 from astrbot.core.star.session_plugin_manager import SessionPluginManager
 from astrbot.core.star.star import star_map
 from astrbot.core.star.star_handler import EventType, star_handlers_registry
@@ -30,10 +30,12 @@ class WakingCheckStage(Stage):
 
         Args:
             ctx (PipelineContext): 消息管道上下文对象, 包括配置和插件管理器
+
         """
         self.ctx = ctx
         self.no_permission_reply = self.ctx.astrbot_config["platform_settings"].get(
-            "no_permission_reply", True
+            "no_permission_reply",
+            True,
         )
         # 私聊是否需要 wake_prefix 才能唤醒机器人
         self.friend_message_needs_wake_prefix = self.ctx.astrbot_config[
@@ -41,15 +43,18 @@ class WakingCheckStage(Stage):
         ].get("friend_message_needs_wake_prefix", False)
         # 是否忽略机器人自己发送的消息
         self.ignore_bot_self_message = self.ctx.astrbot_config["platform_settings"].get(
-            "ignore_bot_self_message", False
+            "ignore_bot_self_message",
+            False,
         )
         self.ignore_at_all = self.ctx.astrbot_config["platform_settings"].get(
-            "ignore_at_all", False
+            "ignore_at_all",
+            False,
         )
 
     async def process(
-        self, event: AstrMessageEvent
-    ) -> Union[None, AsyncGenerator[None, None]]:
+        self,
+        event: AstrMessageEvent,
+    ) -> None | AsyncGenerator[None, None]:
         if (
             self.ignore_bot_self_message
             and event.get_self_id() == event.get_sender_id()
@@ -123,7 +128,8 @@ class WakingCheckStage(Stage):
         logger.debug(f"enabled_plugins_name: {enabled_plugins_name}")
 
         for handler in star_handlers_registry.get_handlers_by_event_type(
-            EventType.AdapterMessageEvent, plugins_name=event.plugins_name
+            EventType.AdapterMessageEvent,
+            plugins_name=event.plugins_name,
         ):
             # filter 需满足 AND 逻辑关系
             passed = True
@@ -138,15 +144,14 @@ class WakingCheckStage(Stage):
                         if not filter.filter(event, self.ctx.astrbot_config):
                             permission_not_pass = True
                             permission_filter_raise_error = filter.raise_error
-                    else:
-                        if not filter.filter(event, self.ctx.astrbot_config):
-                            passed = False
-                            break
+                    elif not filter.filter(event, self.ctx.astrbot_config):
+                        passed = False
+                        break
                 except Exception as e:
                     await event.send(
                         MessageEventResult().message(
-                            f"插件 {star_map[handler.handler_module_path].name}: {e}"
-                        )
+                            f"插件 {star_map[handler.handler_module_path].name}: {e}",
+                        ),
                     )
                     event.stop_event()
                     passed = False
@@ -159,11 +164,11 @@ class WakingCheckStage(Stage):
                     if self.no_permission_reply:
                         await event.send(
                             MessageChain().message(
-                                f"您(ID: {event.get_sender_id()})的权限不足以使用此指令。通过 /sid 获取 ID 并请管理员添加。"
-                            )
+                                f"您(ID: {event.get_sender_id()})的权限不足以使用此指令。通过 /sid 获取 ID 并请管理员添加。",
+                            ),
                         )
                     logger.info(
-                        f"触发 {star_map[handler.handler_module_path].name} 时, 用户(ID={event.get_sender_id()}) 权限不足。"
+                        f"触发 {star_map[handler.handler_module_path].name} 时, 用户(ID={event.get_sender_id()}) 权限不足。",
                     )
                     event.stop_event()
                     return
@@ -185,7 +190,8 @@ class WakingCheckStage(Stage):
 
         # 根据会话配置过滤插件处理器
         activated_handlers = SessionPluginManager.filter_handlers_by_session(
-            event, activated_handlers
+            event,
+            activated_handlers,
         )
 
         event.set_extra("activated_handlers", activated_handlers)

astrbot/core/pipeline/whitelist_check/stage.py

@@ -1,9 +1,11 @@
-from ..stage import Stage, register_stage
-from ..context import PipelineContext
-from typing import AsyncGenerator, Union
+from collections.abc import AsyncGenerator
+
+from astrbot.core import logger
 from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core.platform.message_type import MessageType
-from astrbot.core import logger
+
+from ..context import PipelineContext
+from ..stage import Stage, register_stage
 
 
 @register_stage
@@ -27,8 +29,9 @@ class WhitelistCheckStage(Stage):
         self.wl_log = ctx.astrbot_config["platform_settings"]["id_whitelist_log"]
 
     async def process(
-        self, event: AstrMessageEvent
-    ) -> Union[None, AsyncGenerator[None, None]]:
+        self,
+        event: AstrMessageEvent,
+    ) -> None | AsyncGenerator[None, None]:
         if not self.enable_whitelist_check:
             # 白名单检查未启用
             return
@@ -60,6 +63,6 @@ class WhitelistCheckStage(Stage):
         ):
             if self.wl_log:
                 logger.info(
-                    f"会话 ID {event.unified_msg_origin} 不在会话白名单中，已终止事件传播。请在配置文件中添加该会话 ID 到白名单。"
+                    f"会话 ID {event.unified_msg_origin} 不在会话白名单中，已终止事件传播。请在配置文件中添加该会话 ID 到白名单。",
                 )
             event.stop_event()

astrbot/core/platform/__init__.py

@@ -1,14 +1,14 @@
-from .platform import Platform
 from .astr_message_event import AstrMessageEvent
+from .astrbot_message import AstrBotMessage, Group, MessageMember, MessageType
+from .platform import Platform
 from .platform_metadata import PlatformMetadata
-from .astrbot_message import AstrBotMessage, MessageMember, MessageType, Group
 
 __all__ = [
-    "Platform",
-    "AstrMessageEvent",
-    "PlatformMetadata",
     "AstrBotMessage",
+    "AstrMessageEvent",
+    "Group",
     "MessageMember",
     "MessageType",
-    "Group",
+    "Platform",
+    "PlatformMetadata",
 ]