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

astrbot/core/star/filter/command.py

@@ -1,11 +1,30 @@
-import re
 import inspect
-from typing import List, Any, Type, Dict
-from . import HandlerFilter
-from astrbot.core.platform.astr_message_event import AstrMessageEvent
+import re
+import types
+import typing
+from typing import Any
+
 from astrbot.core.config import AstrBotConfig
-from .custom_filter import CustomFilter
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+
 from ..star_handler import StarHandlerMetadata
+from . import HandlerFilter
+from .custom_filter import CustomFilter
+
+
+class GreedyStr(str):
+    """标记指令完成其他参数接收后的所有剩余文本。"""
+
+
+def unwrap_optional(annotation) -> tuple:
+    """去掉 Optional[T] / Union[T, None] / T|None，返回 T"""
+    args = typing.get_args(annotation)
+    non_none_args = [a for a in args if a is not type(None)]
+    if len(non_none_args) == 1:
+        return (non_none_args[0],)
+    if len(non_none_args) > 1:
+        return tuple(non_none_args)
+    return ()
 
 
 # 标准指令受到 wake_prefix 的制约。
@@ -15,25 +34,32 @@ class CommandFilter(HandlerFilter):
     def __init__(
         self,
         command_name: str,
-        alias: set = None,
-        handler_md: StarHandlerMetadata = None,
-        parent_command_names: List[str] = [""],
+        alias: set | None = None,
+        handler_md: StarHandlerMetadata | None = None,
+        parent_command_names: list[str] | None = None,
     ):
         self.command_name = command_name
         self.alias = alias if alias else set()
-        self.parent_command_names = parent_command_names
+        self.parent_command_names = (
+            parent_command_names if parent_command_names is not None else [""]
+        )
         if handler_md:
             self.init_handler_md(handler_md)
-        self.custom_filter_list: List[CustomFilter] = []
+        self.custom_filter_list: list[CustomFilter] = []
+
+        # Cache for complete command names list
+        self._cmpl_cmd_names: list | None = None
 
     def print_types(self):
-        result = ""
+        parts = []
         for k, v in self.handler_params.items():
             if isinstance(v, type):
-                result += f"{k}({v.__name__}),"
+                parts.append(f"{k}({v.__name__}),")
+            elif isinstance(v, types.UnionType) or typing.get_origin(v) is typing.Union:
+                parts.append(f"{k}({v}),")
             else:
-                result += f"{k}({type(v).__name__})={v},"
-        result = result.rstrip(",")
+                parts.append(f"{k}({type(v).__name__})={v},")
+        result = "".join(parts).rstrip(",")
         return result
 
     def init_handler_md(self, handle_md: StarHandlerMetadata):
@@ -64,23 +90,40 @@ class CommandFilter(HandlerFilter):
         return True
 
     def validate_and_convert_params(
-        self, params: List[Any], param_type: Dict[str, Type]
-    ) -> Dict[str, Any]:
+        self,
+        params: list[Any],
+        param_type: dict[str, type],
+    ) -> dict[str, Any]:
         """将参数列表 params 根据 param_type 转换为参数字典。"""
         result = {}
-        for i, (param_name, param_type_or_default_val) in enumerate(param_type.items()):
+        param_items = list(param_type.items())
+        for i, (param_name, param_type_or_default_val) in enumerate(param_items):
+            is_greedy = param_type_or_default_val is GreedyStr
+
+            if is_greedy:
+                # GreedyStr 必须是最后一个参数
+                if i != len(param_items) - 1:
+                    raise ValueError(
+                        f"参数 '{param_name}' (GreedyStr) 必须是最后一个参数。",
+                    )
+
+                # 将剩余的所有部分合并成一个字符串
+                remaining_params = params[i:]
+                result[param_name] = " ".join(remaining_params)
+                break
+            # 没有 GreedyStr 的情况
             if i >= len(params):
                 if (
-                    isinstance(param_type_or_default_val, Type)
+                    isinstance(param_type_or_default_val, (type, types.UnionType))
+                    or typing.get_origin(param_type_or_default_val) is typing.Union
                     or param_type_or_default_val is inspect.Parameter.empty
                 ):
                     # 是类型
                     raise ValueError(
-                        f"必要参数缺失。该指令完整参数: {self.print_types()}"
+                        f"必要参数缺失。该指令完整参数: {self.print_types()}",
                     )
-                else:
-                    # 是默认值
-                    result[param_name] = param_type_or_default_val
+                # 是默认值
+                result[param_name] = param_type_or_default_val
             else:
                 # 尝试强制转换
                 try:
@@ -92,18 +135,58 @@ class CommandFilter(HandlerFilter):
                     elif isinstance(param_type_or_default_val, str):
                         # 如果 param_type_or_default_val 是字符串，直接赋值
                         result[param_name] = params[i]
+                    elif isinstance(param_type_or_default_val, bool):
+                        # 处理布尔类型
+                        lower_param = str(params[i]).lower()
+                        if lower_param in ["true", "yes", "1"]:
+                            result[param_name] = True
+                        elif lower_param in ["false", "no", "0"]:
+                            result[param_name] = False
+                        else:
+                            raise ValueError(
+                                f"参数 {param_name} 必须是布尔值（true/false, yes/no, 1/0）。",
+                            )
                     elif isinstance(param_type_or_default_val, int):
                         result[param_name] = int(params[i])
                     elif isinstance(param_type_or_default_val, float):
                         result[param_name] = float(params[i])
                     else:
-                        result[param_name] = param_type_or_default_val(params[i])
+                        origin = typing.get_origin(param_type_or_default_val)
+                        if origin in (typing.Union, types.UnionType):
+                            # 注解是联合类型
+                            # NOTE: 目前没有处理联合类型嵌套相关的注解写法
+                            nn_types = unwrap_optional(param_type_or_default_val)
+                            if len(nn_types) == 1:
+                                # 只有一个非 NoneType 类型
+                                result[param_name] = nn_types[0](params[i])
+                            else:
+                                # 没有或者有多个非 NoneType 类型，这里我们暂时直接赋值为原始值。
+                                # NOTE: 目前还没有做类型校验
+                                result[param_name] = params[i]
+                        else:
+                            result[param_name] = param_type_or_default_val(params[i])
                 except ValueError:
                     raise ValueError(
-                        f"参数 {param_name} 类型错误。完整参数: {self.print_types()}"
+                        f"参数 {param_name} 类型错误。完整参数: {self.print_types()}",
                     )
         return result
 
+    def get_complete_command_names(self):
+        if self._cmpl_cmd_names is not None:
+            return self._cmpl_cmd_names
+        self._cmpl_cmd_names = [
+            f"{parent} {cmd}" if parent else cmd
+            for cmd in [self.command_name] + list(self.alias)
+            for parent in self.parent_command_names or [""]
+        ]
+        return self._cmpl_cmd_names
+
+    def equals(self, message_str: str) -> bool:
+        for full_cmd in self.get_complete_command_names():
+            if message_str == full_cmd:
+                return True
+        return False
+
     def filter(self, event: AstrMessageEvent, cfg: AstrBotConfig) -> bool:
         if not event.is_at_or_wake_command:
             return False
@@ -113,18 +196,11 @@ class CommandFilter(HandlerFilter):
 
         # 检查是否以指令开头
         message_str = re.sub(r"\s+", " ", event.get_message_str().strip())
-        candidates = [self.command_name] + list(self.alias)
         ok = False
-        for candidate in candidates:
-            for parent_command_name in self.parent_command_names:
-                if parent_command_name:
-                    _full = f"{parent_command_name} {candidate}"
-                else:
-                    _full = candidate
-                if message_str.startswith(f"{_full} ") or message_str == _full:
-                    message_str = message_str[len(_full) :].strip()
-                    ok = True
-                    break
+        for full_cmd in self.get_complete_command_names():
+            if message_str.startswith(f"{full_cmd} ") or message_str == full_cmd:
+                ok = True
+                message_str = message_str[len(full_cmd) :].strip()
         if not ok:
             return False
 

astrbot/core/star/filter/command_group.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
-from typing import List, Union
+from astrbot.core.config import AstrBotConfig
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+
 from . import HandlerFilter
 from .command import CommandFilter
-from astrbot.core.platform.astr_message_event import AstrMessageEvent
-from astrbot.core.config import AstrBotConfig
 from .custom_filter import CustomFilter
 
 
@@ -13,27 +13,35 @@ class CommandGroupFilter(HandlerFilter):
     def __init__(
         self,
         group_name: str,
-        alias: set = None,
-        parent_group: CommandGroupFilter = None,
+        alias: set | None = None,
+        parent_group: CommandGroupFilter | None = None,
     ):
         self.group_name = group_name
         self.alias = alias if alias else set()
-        self.sub_command_filters: List[Union[CommandFilter, CommandGroupFilter]] = []
-        self.custom_filter_list: List[CustomFilter] = []
+        self.sub_command_filters: list[CommandFilter | CommandGroupFilter] = []
+        self.custom_filter_list: list[CustomFilter] = []
         self.parent_group = parent_group
 
+        # Cache for complete command names list
+        self._cmpl_cmd_names: list | None = None
+
     def add_sub_command_filter(
-        self, sub_command_filter: Union[CommandFilter, CommandGroupFilter]
+        self,
+        sub_command_filter: CommandFilter | CommandGroupFilter,
     ):
         self.sub_command_filters.append(sub_command_filter)
 
     def add_custom_filter(self, custom_filter: CustomFilter):
         self.custom_filter_list.append(custom_filter)
 
-    def get_complete_command_names(self) -> List[str]:
+    def get_complete_command_names(self) -> list[str]:
         """遍历父节点获取完整的指令名。
 
-        新版本 v3.4.29 采用预编译指令，不再从指令组递归遍历子指令，因此这个方法是返回包括别名在内的整个指令名列表。"""
+        新版本 v3.4.29 采用预编译指令，不再从指令组递归遍历子指令，因此这个方法是返回包括别名在内的整个指令名列表。
+        """
+        if self._cmpl_cmd_names is not None:
+            return self._cmpl_cmd_names
+
         parent_cmd_names = (
             self.parent_group.get_complete_command_names() if self.parent_group else []
         )
@@ -47,17 +55,18 @@ class CommandGroupFilter(HandlerFilter):
         for parent_cmd_name in parent_cmd_names:
             for candidate in candidates:
                 result.append(parent_cmd_name + " " + candidate)
+        self._cmpl_cmd_names = result
         return result
 
     # 以树的形式打印出来
     def print_cmd_tree(
         self,
-        sub_command_filters: List[Union[CommandFilter, CommandGroupFilter]],
+        sub_command_filters: list[CommandFilter | CommandGroupFilter],
         prefix: str = "",
-        event: AstrMessageEvent = None,
-        cfg: AstrBotConfig = None,
+        event: AstrMessageEvent | None = None,
+        cfg: AstrBotConfig | None = None,
     ) -> str:
-        result = ""
+        parts = []
         for sub_filter in sub_command_filters:
             if isinstance(sub_filter, CommandFilter):
                 custom_filter_pass = True
@@ -65,31 +74,32 @@ class CommandGroupFilter(HandlerFilter):
                     custom_filter_pass = sub_filter.custom_filter_ok(event, cfg)
                 if custom_filter_pass:
                     cmd_th = sub_filter.print_types()
-                    result += f"{prefix}├── {sub_filter.command_name}"
+                    line = f"{prefix}├── {sub_filter.command_name}"
                     if cmd_th:
-                        result += f" ({cmd_th})"
+                        line += f" ({cmd_th})"
                     else:
-                        result += " (无参数指令)"
+                        line += " (无参数指令)"
 
                     if sub_filter.handler_md and sub_filter.handler_md.desc:
-                        result += f": {sub_filter.handler_md.desc}"
+                        line += f": {sub_filter.handler_md.desc}"
 
-                    result += "\n"
+                    parts.append(line + "\n")
             elif isinstance(sub_filter, CommandGroupFilter):
                 custom_filter_pass = True
                 if event and cfg:
                     custom_filter_pass = sub_filter.custom_filter_ok(event, cfg)
                 if custom_filter_pass:
-                    result += f"{prefix}├── {sub_filter.group_name}"
-                    result += "\n"
-                    result += sub_filter.print_cmd_tree(
-                        sub_filter.sub_command_filters,
-                        prefix + "│   ",
-                        event=event,
-                        cfg=cfg,
+                    parts.append(f"{prefix}├── {sub_filter.group_name}\n")
+                    parts.append(
+                        sub_filter.print_cmd_tree(
+                            sub_filter.sub_command_filters,
+                            prefix + "│   ",
+                            event=event,
+                            cfg=cfg,
+                        )
                     )
 
-        return result
+        return "".join(parts)
 
     def custom_filter_ok(self, event: AstrMessageEvent, cfg: AstrBotConfig) -> bool:
         for custom_filter in self.custom_filter_list:
@@ -97,6 +107,12 @@ class CommandGroupFilter(HandlerFilter):
                 return False
         return True
 
+    def startswith(self, message_str: str) -> bool:
+        return message_str.startswith(tuple(self.get_complete_command_names()))
+
+    def equals(self, message_str: str) -> bool:
+        return message_str in self.get_complete_command_names()
+
     def filter(self, event: AstrMessageEvent, cfg: AstrBotConfig) -> bool:
         if not event.is_at_or_wake_command:
             return False
@@ -105,18 +121,14 @@ class CommandGroupFilter(HandlerFilter):
         if not self.custom_filter_ok(event, cfg):
             return False
 
-        complete_command_names = self.get_complete_command_names()
-        if event.message_str.strip() in complete_command_names:
+        if self.equals(event.message_str.strip()):
             tree = (
                 self.group_name
                 + "\n"
                 + self.print_cmd_tree(self.sub_command_filters, event=event, cfg=cfg)
             )
             raise ValueError(
-                f"指令组 {self.group_name} 未填写完全。这个指令组下有如下指令：\n"
-                + tree
+                f"参数不足。{self.group_name} 指令组下有如下指令，请参考：\n" + tree,
             )
 
-        # complete_command_names = [name + " " for name in complete_command_names]
-        # return event.message_str.startswith(tuple(complete_command_names))
-        return False
+        return self.startswith(event.message_str)

astrbot/core/star/filter/custom_filter.py

@@ -1,8 +1,9 @@
-from abc import abstractmethod, ABCMeta
+from abc import ABCMeta, abstractmethod
 
-from . import HandlerFilter
-from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core.config import AstrBotConfig
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+
+from . import HandlerFilter
 
 
 class CustomFilterMeta(ABCMeta):
@@ -38,7 +39,7 @@ class CustomFilterOr(CustomFilter):
         super().__init__()
         if not isinstance(filter1, (CustomFilter, CustomFilterAnd, CustomFilterOr)):
             raise ValueError(
-                "CustomFilter lass can only operate with other CustomFilter."
+                "CustomFilter lass can only operate with other CustomFilter.",
             )
         self.filter1 = filter1
         self.filter2 = filter2
@@ -52,7 +53,7 @@ class CustomFilterAnd(CustomFilter):
         super().__init__()
         if not isinstance(filter1, (CustomFilter, CustomFilterAnd, CustomFilterOr)):
             raise ValueError(
-                "CustomFilter lass can only operate with other CustomFilter."
+                "CustomFilter lass can only operate with other CustomFilter.",
             )
         self.filter1 = filter1
         self.filter2 = filter2

astrbot/core/star/filter/event_message_type.py

@@ -1,9 +1,11 @@
 import enum
-from . import HandlerFilter
-from astrbot.core.platform.astr_message_event import AstrMessageEvent
+
 from astrbot.core.config import AstrBotConfig
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
 from astrbot.core.platform.message_type import MessageType
 
+from . import HandlerFilter
+
 
 class EventMessageType(enum.Flag):
     GROUP_MESSAGE = enum.auto()

astrbot/core/star/filter/permission.py

@@ -1,7 +1,9 @@
 import enum
-from . import HandlerFilter
-from astrbot.core.platform.astr_message_event import AstrMessageEvent
+
 from astrbot.core.config import AstrBotConfig
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+
+from . import HandlerFilter
 
 
 class PermissionType(enum.Flag):

astrbot/core/star/filter/platform_adapter_type.py

@@ -1,38 +1,71 @@
 import enum
-from . import HandlerFilter
-from astrbot.core.platform.astr_message_event import AstrMessageEvent
+
 from astrbot.core.config import AstrBotConfig
-from typing import Union
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+
+from . import HandlerFilter
 
 
 class PlatformAdapterType(enum.Flag):
     AIOCQHTTP = enum.auto()
     QQOFFICIAL = enum.auto()
-    VCHAT = enum.auto()
-    GEWECHAT = enum.auto()
     TELEGRAM = enum.auto()
     WECOM = enum.auto()
     LARK = enum.auto()
-    ALL = AIOCQHTTP | QQOFFICIAL | VCHAT | GEWECHAT | TELEGRAM | WECOM | LARK
+    WECHATPADPRO = enum.auto()
+    DINGTALK = enum.auto()
+    DISCORD = enum.auto()
+    SLACK = enum.auto()
+    KOOK = enum.auto()
+    VOCECHAT = enum.auto()
+    WEIXIN_OFFICIAL_ACCOUNT = enum.auto()
+    SATORI = enum.auto()
+    MISSKEY = enum.auto()
+    ALL = (
+        AIOCQHTTP
+        | QQOFFICIAL
+        | TELEGRAM
+        | WECOM
+        | LARK
+        | WECHATPADPRO
+        | DINGTALK
+        | DISCORD
+        | SLACK
+        | KOOK
+        | VOCECHAT
+        | WEIXIN_OFFICIAL_ACCOUNT
+        | SATORI
+        | MISSKEY
+    )
 
 
 ADAPTER_NAME_2_TYPE = {
     "aiocqhttp": PlatformAdapterType.AIOCQHTTP,
     "qq_official": PlatformAdapterType.QQOFFICIAL,
-    "vchat": PlatformAdapterType.VCHAT,
-    "gewechat": PlatformAdapterType.GEWECHAT,
     "telegram": PlatformAdapterType.TELEGRAM,
     "wecom": PlatformAdapterType.WECOM,
     "lark": PlatformAdapterType.LARK,
+    "dingtalk": PlatformAdapterType.DINGTALK,
+    "discord": PlatformAdapterType.DISCORD,
+    "slack": PlatformAdapterType.SLACK,
+    "kook": PlatformAdapterType.KOOK,
+    "wechatpadpro": PlatformAdapterType.WECHATPADPRO,
+    "vocechat": PlatformAdapterType.VOCECHAT,
+    "weixin_official_account": PlatformAdapterType.WEIXIN_OFFICIAL_ACCOUNT,
+    "satori": PlatformAdapterType.SATORI,
+    "misskey": PlatformAdapterType.MISSKEY,
 }
 
 
 class PlatformAdapterTypeFilter(HandlerFilter):
-    def __init__(self, platform_adapter_type_or_str: Union[PlatformAdapterType, str]):
-        self.type_or_str = platform_adapter_type_or_str
+    def __init__(self, platform_adapter_type_or_str: PlatformAdapterType | str):
+        if isinstance(platform_adapter_type_or_str, str):
+            self.platform_type = ADAPTER_NAME_2_TYPE.get(platform_adapter_type_or_str)
+        else:
+            self.platform_type = platform_adapter_type_or_str
 
     def filter(self, event: AstrMessageEvent, cfg: AstrBotConfig) -> bool:
         adapter_name = event.get_platform_name()
-        if adapter_name in ADAPTER_NAME_2_TYPE:
-            return ADAPTER_NAME_2_TYPE[adapter_name] & self.type_or_str
+        if adapter_name in ADAPTER_NAME_2_TYPE and self.platform_type is not None:
+            return bool(ADAPTER_NAME_2_TYPE[adapter_name] & self.platform_type)
         return False

astrbot/core/star/filter/regex.py

@@ -1,7 +1,9 @@
 import re
-from . import HandlerFilter
-from astrbot.core.platform.astr_message_event import AstrMessageEvent
+
 from astrbot.core.config import AstrBotConfig
+from astrbot.core.platform.astr_message_event import AstrMessageEvent
+
+from . import HandlerFilter
 
 
 # 正则表达式过滤器不会受到 wake_prefix 的制约。

astrbot/core/star/register/__init__.py

@@ -1,33 +1,37 @@
 from .star import register_star
 from .star_handler import (
+    register_after_message_sent,
+    register_agent,
     register_command,
     register_command_group,
-    register_event_message_type,
-    register_platform_adapter_type,
-    register_regex,
-    register_permission_type,
     register_custom_filter,
+    register_event_message_type,
+    register_llm_tool,
     register_on_astrbot_loaded,
+    register_on_decorating_result,
     register_on_llm_request,
     register_on_llm_response,
-    register_llm_tool,
-    register_on_decorating_result,
-    register_after_message_sent,
+    register_on_platform_loaded,
+    register_permission_type,
+    register_platform_adapter_type,
+    register_regex,
 )
 
 __all__ = [
-    "register_star",
+    "register_after_message_sent",
+    "register_agent",
     "register_command",
     "register_command_group",
-    "register_event_message_type",
-    "register_platform_adapter_type",
-    "register_regex",
-    "register_permission_type",
     "register_custom_filter",
+    "register_event_message_type",
+    "register_llm_tool",
     "register_on_astrbot_loaded",
+    "register_on_decorating_result",
     "register_on_llm_request",
     "register_on_llm_response",
-    "register_llm_tool",
-    "register_on_decorating_result",
-    "register_after_message_sent",
+    "register_on_platform_loaded",
+    "register_permission_type",
+    "register_platform_adapter_type",
+    "register_regex",
+    "register_star",
 ]

astrbot/core/star/register/star.py

@@ -1,9 +1,23 @@
-from ..star import star_registry, StarMetadata, star_map
+import warnings
 
+from astrbot.core.star import StarMetadata, star_map
 
-def register_star(name: str, author: str, desc: str, version: str, repo: str = None):
+_warned_register_star = False
+
+
+def register_star(
+    name: str,
+    author: str,
+    desc: str,
+    version: str,
+    repo: str | None = None,
+):
     """注册一个插件(Star)。
 
+    [DEPRECATED] 该装饰器已废弃，将在未来版本中移除。
+    在 v3.5.19 版本之后（不含），您不需要使用该装饰器来装饰插件类，
+    AstrBot 会自动识别继承自 Star 的类并将其作为插件类加载。
+
     Args:
         name: 插件名称。
         author: 作者。
@@ -19,20 +33,34 @@ def register_star(name: str, author: str, desc: str, version: str, repo: str = N
         ...
 
     帮助信息会被自动提取。使用 `/plugin <插件名> 可以查看帮助信息。`
+
     """
+    global _warned_register_star
+    if not _warned_register_star:
+        _warned_register_star = True
+        warnings.warn(
+            "The 'register_star' decorator is deprecated and will be removed in a future version.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
 
     def decorator(cls):
-        star_metadata = StarMetadata(
-            name=name,
-            author=author,
-            desc=desc,
-            version=version,
-            repo=repo,
-            star_cls_type=cls,
-            module_path=cls.__module__,
-        )
-        star_registry.append(star_metadata)
-        star_map[cls.__module__] = star_metadata
+        if not star_map.get(cls.__module__):
+            metadata = StarMetadata(
+                name=name,
+                author=author,
+                desc=desc,
+                version=version,
+                repo=repo,
+            )
+            star_map[cls.__module__] = metadata
+        else:
+            star_map[cls.__module__].name = name
+            star_map[cls.__module__].author = author
+            star_map[cls.__module__].desc = desc
+            star_map[cls.__module__].version = version
+            star_map[cls.__module__].repo = repo
+
         return cls
 
     return decorator