From 705a6f7fbf0ef4c5673b68ac6e7d0198d73c6bd7 Mon Sep 17 00:00:00 2001 From: hemengyang Date: Wed, 12 Jan 2022 18:00:56 +0800 Subject: [PATCH 01/14] =?UTF-8?q?=E5=88=A0=E9=99=A4=E7=B1=BB=E5=9E=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- nonebot/adapters/_bot.py | 6 ++--- nonebot/adapters/_message.py | 6 ++--- nonebot/config.py | 33 +++++++++----------------- nonebot/drivers/__init__.py | 21 +++++----------- nonebot/drivers/_model.py | 1 - nonebot/drivers/fastapi.py | 36 ---------------------------- nonebot/drivers/quart.py | 20 ---------------- nonebot/matcher.py | 46 ++++++++++++------------------------ nonebot/permission.py | 4 ---- nonebot/plugin/on.py | 12 ++++------ nonebot/plugin/plugin.py | 25 +++++++------------- nonebot/rule.py | 4 ---- nonebot/typing.py | 29 ----------------------- 13 files changed, 48 insertions(+), 195 deletions(-) diff --git a/nonebot/adapters/_bot.py b/nonebot/adapters/_bot.py index 058b9ec8..05762233 100644 --- a/nonebot/adapters/_bot.py +++ b/nonebot/adapters/_bot.py @@ -27,13 +27,11 @@ class Bot(abc.ABC): _calling_api_hook: Set[T_CallingAPIHook] = set() """ - :类型: ``Set[T_CallingAPIHook]`` - :说明: call_api 时执行的函数 + :说明: call_api 时执行的函数 """ _called_api_hook: Set[T_CalledAPIHook] = set() """ - :类型: ``Set[T_CalledAPIHook]`` - :说明: call_api 后执行的函数 + :说明: call_api 后执行的函数 """ def __init__(self, adapter: "Adapter", self_id: str): diff --git a/nonebot/adapters/_message.py b/nonebot/adapters/_message.py index 3175bed8..629215fd 100644 --- a/nonebot/adapters/_message.py +++ b/nonebot/adapters/_message.py @@ -26,13 +26,11 @@ class MessageSegment(Mapping, abc.ABC, Generic[TM]): type: str """ - - 类型: ``str`` - - 说明: 消息段类型 + - 说明: 消息段类型 """ data: Dict[str, Any] = field(default_factory=lambda: {}) """ - - 类型: ``Dict[str, Union[str, list]]`` - - 说明: 消息段数据 + - 说明: 消息段数据 """ @classmethod diff --git a/nonebot/config.py b/nonebot/config.py index 7421457e..65043199 100644 --- a/nonebot/config.py +++ b/nonebot/config.py @@ -137,8 +137,7 @@ class Env(BaseConfig): environment: str = "prod" """ - - **类型**: ``str`` - - **默认值**: ``"prod"`` + - **默认值**: ``"prod"`` :说明: 当前环境名。 NoneBot 将从 ``.env.{environment}`` 文件中加载配置。 @@ -163,8 +162,7 @@ class Config(BaseConfig): # nonebot configs driver: str = "~fastapi" """ - - **类型**: ``str`` - - **默认值**: ``"~fastapi"`` + - **默认值**: ``"~fastapi"`` :说明: @@ -176,8 +174,7 @@ class Config(BaseConfig): """ host: IPvAnyAddress = IPv4Address("127.0.0.1") # type: ignore """ - - **类型**: ``IPvAnyAddress`` - - **默认值**: ``127.0.0.1`` + - **默认值**: ``127.0.0.1`` :说明: @@ -185,8 +182,7 @@ class Config(BaseConfig): """ port: int = 8080 """ - - **类型**: ``int`` - - **默认值**: ``8080`` + - **默认值**: ``8080`` :说明: @@ -194,8 +190,7 @@ class Config(BaseConfig): """ log_level: Union[int, str] = "INFO" """ - - **类型**: ``Union[int, str]`` - - **默认值**: ``INFO`` + - **默认值**: ``INFO`` :说明: @@ -215,8 +210,7 @@ class Config(BaseConfig): # bot connection configs api_timeout: Optional[float] = 30.0 """ - - **类型**: ``Optional[float]`` - - **默认值**: ``30.`` + - **默认值**: ``30.`` :说明: @@ -226,8 +220,7 @@ class Config(BaseConfig): # bot runtime configs superusers: Set[str] = set() """ - - **类型**: ``Set[str]`` - - **默认值**: ``set()`` + - **默认值**: ``set()`` :说明: @@ -241,8 +234,7 @@ class Config(BaseConfig): """ nickname: Set[str] = set() """ - - **类型**: ``Set[str]`` - - **默认值**: ``set()`` + - **默认值**: ``set()`` :说明: @@ -250,8 +242,7 @@ class Config(BaseConfig): """ command_start: Set[str] = {"/"} """ - - **类型**: ``Set[str]`` - - **默认值**: ``{"/"}`` + - **默认值**: ``{"/"}`` :说明: @@ -259,8 +250,7 @@ class Config(BaseConfig): """ command_sep: Set[str] = {"."} """ - - **类型**: ``Set[str]`` - - **默认值**: ``{"."}`` + - **默认值**: ``{"."}`` :说明: @@ -268,8 +258,7 @@ class Config(BaseConfig): """ session_expire_timeout: timedelta = timedelta(minutes=2) """ - - **类型**: ``timedelta`` - - **默认值**: ``timedelta(minutes=2)`` + - **默认值**: ``timedelta(minutes=2)`` :说明: diff --git a/nonebot/drivers/__init__.py b/nonebot/drivers/__init__.py index 7c7bf3a9..cabc3629 100644 --- a/nonebot/drivers/__init__.py +++ b/nonebot/drivers/__init__.py @@ -41,18 +41,15 @@ class Driver(abc.ABC): _adapters: Dict[str, "Adapter"] = {} """ - :类型: ``Dict[str, Adapter]`` - :说明: 已注册的适配器列表 + :说明: 已注册的适配器列表 """ _bot_connection_hook: Set[T_BotConnectionHook] = set() """ - :类型: ``Set[T_BotConnectionHook]`` - :说明: Bot 连接建立时执行的函数 + :说明: Bot 连接建立时执行的函数 """ _bot_disconnection_hook: Set[T_BotDisconnectionHook] = set() """ - :类型: ``Set[T_BotDisconnectionHook]`` - :说明: Bot 连接断开时执行的函数 + :说明: Bot 连接断开时执行的函数 """ def __init__(self, env: Env, config: Config): @@ -64,26 +61,20 @@ class Driver(abc.ABC): """ self.env: str = env.environment """ - :类型: ``str`` - :说明: 环境名称 + :说明: 环境名称 """ self.config: Config = config """ - :类型: ``Config`` - :说明: 配置对象 + :说明: 配置对象 """ self._clients: Dict[str, "Bot"] = {} """ - :类型: ``Dict[str, Bot]`` - :说明: 已连接的 Bot + :说明: 已连接的 Bot """ @property def bots(self) -> Dict[str, "Bot"]: """ - :类型: - - ``Dict[str, Bot]`` :说明: 获取当前所有已连接的 Bot diff --git a/nonebot/drivers/_model.py b/nonebot/drivers/_model.py index 0484e054..68c8424d 100644 --- a/nonebot/drivers/_model.py +++ b/nonebot/drivers/_model.py @@ -168,7 +168,6 @@ class WebSocket(abc.ABC): @abc.abstractmethod def closed(self) -> bool: """ - :类型: ``bool`` :说明: 连接是否已经关闭 """ raise NotImplementedError diff --git a/nonebot/drivers/fastapi.py b/nonebot/drivers/fastapi.py index 882e97b0..8951b3e7 100644 --- a/nonebot/drivers/fastapi.py +++ b/nonebot/drivers/fastapi.py @@ -48,90 +48,54 @@ class Config(BaseSettings): fastapi_openapi_url: Optional[str] = None """ - :类型: - - ``Optional[str]`` - :说明: ``openapi.json`` 地址，默认为 ``None`` 即关闭 """ fastapi_docs_url: Optional[str] = None """ - :类型: - - ``Optional[str]`` - :说明: ``swagger`` 地址，默认为 ``None`` 即关闭 """ fastapi_redoc_url: Optional[str] = None """ - :类型: - - ``Optional[str]`` - :说明: ``redoc`` 地址，默认为 ``None`` 即关闭 """ fastapi_include_adapter_schema: bool = True """ - :类型: - - ``bool`` - :说明: 是否包含适配器路由的 schema，默认为 ``True`` """ fastapi_reload: bool = False """ - :类型: - - ``bool`` - :说明: 开启/关闭冷重载 """ fastapi_reload_dirs: Optional[List[str]] = None """ - :类型: - - ``Optional[List[str]]`` - :说明: 重载监控文件夹列表，默认为 uvicorn 默认值 """ fastapi_reload_delay: Optional[float] = None """ - :类型: - - ``Optional[float]`` - :说明: 重载延迟，默认为 uvicorn 默认值 """ fastapi_reload_includes: Optional[List[str]] = None """ - :类型: - - ``Optional[List[str]]`` - :说明: 要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值 """ fastapi_reload_excludes: Optional[List[str]] = None """ - :类型: - - ``Optional[List[str]]`` - :说明: 不要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值 diff --git a/nonebot/drivers/quart.py b/nonebot/drivers/quart.py index a8330044..84b6ce49 100644 --- a/nonebot/drivers/quart.py +++ b/nonebot/drivers/quart.py @@ -56,50 +56,30 @@ class Config(BaseSettings): quart_reload: bool = False """ - :类型: - - ``bool`` - :说明: 开启/关闭冷重载 """ quart_reload_dirs: Optional[List[str]] = None """ - :类型: - - ``Optional[List[str]]`` - :说明: 重载监控文件夹列表，默认为 uvicorn 默认值 """ quart_reload_delay: Optional[float] = None """ - :类型: - - ``Optional[float]`` - :说明: 重载延迟，默认为 uvicorn 默认值 """ quart_reload_includes: Optional[List[str]] = None """ - :类型: - - ``Optional[List[str]]`` - :说明: 要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值 """ quart_reload_excludes: Optional[List[str]] = None """ - :类型: - - ``Optional[List[str]]`` - :说明: 不要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值 diff --git a/nonebot/matcher.py b/nonebot/matcher.py index ce30608b..c9a60f08 100644 --- a/nonebot/matcher.py +++ b/nonebot/matcher.py @@ -66,7 +66,6 @@ T = TypeVar("T") matchers: Dict[int, List[Type["Matcher"]]] = defaultdict(list) """ -:类型: ``Dict[int, List[Type[Matcher]]]`` :说明: 用于存储当前所有的事件响应器 """ current_bot: ContextVar[Bot] = ContextVar("current_bot") @@ -106,81 +105,66 @@ class Matcher(metaclass=MatcherMeta): plugin: Optional["Plugin"] = None """ - :类型: ``Optional[Plugin]`` - :说明: 事件响应器所在插件 + :说明: 事件响应器所在插件 """ module: Optional[ModuleType] = None """ - :类型: ``Optional[ModuleType]`` - :说明: 事件响应器所在插件模块 + :说明: 事件响应器所在插件模块 """ plugin_name: Optional[str] = None """ - :类型: ``Optional[str]`` - :说明: 事件响应器所在插件名 + :说明: 事件响应器所在插件名 """ module_name: Optional[str] = None """ - :类型: ``Optional[str]`` - :说明: 事件响应器所在点分割插件模块路径 + :说明: 事件响应器所在点分割插件模块路径 """ type: str = "" """ - :类型: ``str`` - :说明: 事件响应器类型 + :说明: 事件响应器类型 """ rule: Rule = Rule() """ - :类型: ``Rule`` - :说明: 事件响应器匹配规则 + :说明: 事件响应器匹配规则 """ permission: Permission = Permission() """ - :类型: ``Permission`` - :说明: 事件响应器触发权限 + :说明: 事件响应器触发权限 """ handlers: List[Dependent[Any]] = [] """ - :类型: ``List[Handler]`` - :说明: 事件响应器拥有的事件处理函数列表 + :说明: 事件响应器拥有的事件处理函数列表 """ priority: int = 1 """ - :类型: ``int`` - :说明: 事件响应器优先级 + :说明: 事件响应器优先级 """ block: bool = False """ - :类型: ``bool`` - :说明: 事件响应器是否阻止事件传播 + :说明: 事件响应器是否阻止事件传播 """ temp: bool = False """ - :类型: ``bool`` - :说明: 事件响应器是否为临时 + :说明: 事件响应器是否为临时 """ expire_time: Optional[datetime] = None """ - :类型: ``Optional[datetime]`` - :说明: 事件响应器过期时间点 + :说明: 事件响应器过期时间点 """ _default_state: T_State = {} """ - :类型: ``T_State`` - :说明: 事件响应器默认状态 + :说明: 事件响应器默认状态 """ _default_type_updater: Optional[Dependent[str]] = None """ - :类型: ``Optional[Dependent]`` - :说明: 事件响应器类型更新函数 + :说明: 事件响应器类型更新函数 """ _default_permission_updater: Optional[Dependent[Permission]] = None """ - :类型: ``Optional[Dependent]`` - :说明: 事件响应器权限更新函数 + :说明: 事件响应器权限更新函数 """ HANDLER_PARAM_TYPES = [ diff --git a/nonebot/permission.py b/nonebot/permission.py index afb527cc..2bad7061 100644 --- a/nonebot/permission.py +++ b/nonebot/permission.py @@ -77,10 +77,6 @@ class Permission: :说明: 存储 ``PermissionChecker`` - - :类型: - - * ``Set[Dependent[bool]]`` """ async def __call__( diff --git a/nonebot/plugin/on.py b/nonebot/plugin/on.py index b0ab2377..afca33d2 100644 --- a/nonebot/plugin/on.py +++ b/nonebot/plugin/on.py @@ -485,15 +485,13 @@ class CommandGroup: """ self.basecmd: Tuple[str, ...] = (cmd,) if isinstance(cmd, str) else cmd """ - - **类型**: ``Tuple[str, ...]`` - - **说明**: 命令前缀 + - **说明**: 命令前缀 """ if "aliases" in kwargs: del kwargs["aliases"] self.base_kwargs: Dict[str, Any] = kwargs """ - - **类型**: ``Dict[str, Any]`` - - **说明**: 其他传递给 ``on_command`` 的参数默认值 + - **说明**: 其他传递给 ``on_command`` 的参数默认值 """ def command(self, cmd: Union[str, Tuple[str, ...]], **kwargs) -> Type[Matcher]: @@ -554,13 +552,11 @@ class MatcherGroup: """ self.matchers: List[Type[Matcher]] = [] """ - :类型: ``List[Type[Matcher]]`` - :说明: 组内事件响应器列表 + :说明: 组内事件响应器列表 """ self.base_kwargs: Dict[str, Any] = kwargs """ - - **类型**: ``Dict[str, Any]`` - - **说明**: 其他传递给 ``on`` 的参数默认值 + - **说明**: 其他传递给 ``on`` 的参数默认值 """ def on(self, **kwargs) -> Type[Matcher]: diff --git a/nonebot/plugin/plugin.py b/nonebot/plugin/plugin.py index 83d37c79..d549d22e 100644 --- a/nonebot/plugin/plugin.py +++ b/nonebot/plugin/plugin.py @@ -10,7 +10,6 @@ if TYPE_CHECKING: plugins: Dict[str, "Plugin"] = {} """ -:类型: ``Dict[str, Plugin]`` :说明: 已加载的插件 """ @@ -21,43 +20,35 @@ class Plugin(object): name: str """ - - **类型**: ``str`` - - **说明**: 插件名称，使用 文件/文件夹 名称作为插件名 + - **说明**: 插件名称，使用 文件/文件夹 名称作为插件名 """ module: ModuleType """ - - **类型**: ``ModuleType`` - - **说明**: 插件模块对象 + - **说明**: 插件模块对象 """ module_name: str """ - - **类型**: ``str`` - - **说明**: 点分割模块路径 + - **说明**: 点分割模块路径 """ manager: "PluginManager" """ - - **类型**: ``PluginManager`` - - **说明**: 导入该插件的插件管理器 + - **说明**: 导入该插件的插件管理器 """ export: Export = field(default_factory=Export) """ - - **类型**: ``Export`` - - **说明**: 插件内定义的导出内容 + - **说明**: 插件内定义的导出内容 """ matcher: Set[Type[Matcher]] = field(default_factory=set) """ - - **类型**: ``Set[Type[Matcher]]`` - - **说明**: 插件内定义的 ``Matcher`` + - **说明**: 插件内定义的 ``Matcher`` """ parent_plugin: Optional["Plugin"] = None """ - - **类型**: ``Optional[Plugin]`` - - **说明**: 父插件 + - **说明**: 父插件 """ sub_plugins: Set["Plugin"] = field(default_factory=set) """ - - **类型**: ``Set[Plugin]`` - - **说明**: 子插件集合 + - **说明**: 子插件集合 """ diff --git a/nonebot/rule.py b/nonebot/rule.py index 368dc490..66d41a48 100644 --- a/nonebot/rule.py +++ b/nonebot/rule.py @@ -106,10 +106,6 @@ class Rule: :说明: 存储 ``RuleChecker`` - - :类型: - - * ``Set[Dependent[bool]]`` """ async def __call__( diff --git a/nonebot/typing.py b/nonebot/typing.py index 55774ca1..759ac861 100644 --- a/nonebot/typing.py +++ b/nonebot/typing.py @@ -47,8 +47,6 @@ def overrides(InterfaceClass: object): T_State = Dict[Any, Any] """ -:类型: ``Dict[Any, Any]`` - :说明: 事件处理状态 State 类型 @@ -56,24 +54,18 @@ T_State = Dict[Any, Any] T_BotConnectionHook = Callable[["Bot"], Awaitable[None]] """ -:类型: ``Callable[[Bot], Awaitable[None]]`` - :说明: Bot 连接建立时执行的函数 """ T_BotDisconnectionHook = Callable[["Bot"], Awaitable[None]] """ -:类型: ``Callable[[Bot], Awaitable[None]]`` - :说明: Bot 连接断开时执行的函数 """ T_CallingAPIHook = Callable[["Bot", str, Dict[str, Any]], Awaitable[None]] """ -:类型: ``Callable[[Bot, str, Dict[str, Any]], Awaitable[None]]`` - :说明: ``bot.call_api`` 时执行的函数 @@ -82,8 +74,6 @@ T_CalledAPIHook = Callable[ ["Bot", Optional[Exception], str, Dict[str, Any], Any], Awaitable[None] ] """ -:类型: ``Callable[[Bot, Optional[Exception], str, Dict[str, Any], Any], Awaitable[None]]`` - :说明: ``bot.call_api`` 后执行的函数，参数分别为 bot, exception, api, data, result @@ -91,8 +81,6 @@ T_CalledAPIHook = Callable[ T_EventPreProcessor = Callable[..., Union[None, Awaitable[None]]] """ -:类型: ``Callable[..., Union[None, Awaitable[None]]]`` - :依赖参数: * ``DependParam``: 子依赖参数 @@ -107,8 +95,6 @@ T_EventPreProcessor = Callable[..., Union[None, Awaitable[None]]] """ T_EventPostProcessor = Callable[..., Union[None, Awaitable[None]]] """ -:类型: ``Callable[..., Union[None, Awaitable[None]]]`` - :依赖参数: * ``DependParam``: 子依赖参数 @@ -123,8 +109,6 @@ T_EventPostProcessor = Callable[..., Union[None, Awaitable[None]]] """ T_RunPreProcessor = Callable[..., Union[None, Awaitable[None]]] """ -:类型: ``Callable[..., Union[None, Awaitable[None]]]`` - :依赖参数: * ``DependParam``: 子依赖参数 @@ -140,8 +124,6 @@ T_RunPreProcessor = Callable[..., Union[None, Awaitable[None]]] """ T_RunPostProcessor = Callable[..., Union[None, Awaitable[None]]] """ -:类型: ``Callable[..., Union[None, Awaitable[None]]]`` - :依赖参数: * ``DependParam``: 子依赖参数 @@ -159,8 +141,6 @@ T_RunPostProcessor = Callable[..., Union[None, Awaitable[None]]] T_RuleChecker = Callable[..., Union[bool, Awaitable[bool]]] """ -:类型: ``Callable[..., Union[bool, Awaitable[bool]]]`` - :依赖参数: * ``DependParam``: 子依赖参数 @@ -175,8 +155,6 @@ T_RuleChecker = Callable[..., Union[bool, Awaitable[bool]]] """ T_PermissionChecker = Callable[..., Union[bool, Awaitable[bool]]] """ -:类型: ``Callable[..., Union[bool, Awaitable[bool]]]`` - :依赖参数: * ``DependParam``: 子依赖参数 @@ -191,16 +169,12 @@ T_PermissionChecker = Callable[..., Union[bool, Awaitable[bool]]] T_Handler = Callable[..., Any] """ -:类型: ``Callable[..., Any]`` - :说明: Handler 处理函数。 """ T_TypeUpdater = Callable[..., Union[str, Awaitable[str]]] """ -:类型: ``Callable[..., Union[None, Awaitable[None]]]`` - :依赖参数: * ``DependParam``: 子依赖参数 @@ -216,8 +190,6 @@ T_TypeUpdater = Callable[..., Union[str, Awaitable[str]]] """ T_PermissionUpdater = Callable[..., Union["Permission", Awaitable["Permission"]]] """ -:类型: ``Callable[..., Union[Permission, Awaitable[Permission]]]`` - :依赖参数: * ``DependParam``: 子依赖参数 @@ -233,7 +205,6 @@ T_PermissionUpdater = Callable[..., Union["Permission", Awaitable["Permission"]] """ T_DependencyCache = Dict[Callable[..., Any], "Task[Any]"] """ -:类型: ``Dict[Callable[..., Any], Task[Any]]`` :说明: 依赖缓存, 用于存储依赖函数的返回值 """ From 0e119593472a91367a895740c9a2224d84f8401a Mon Sep 17 00:00:00 2001 From: hemengyang Date: Wed, 12 Jan 2022 18:02:08 +0800 Subject: [PATCH 02/14] =?UTF-8?q?=E5=88=A0=E9=99=A4=E9=BB=98=E8=AE=A4?= =?UTF-8?q?=E5=80=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- nonebot/config.py | 44 +++++++++++--------------------------------- 1 file changed, 11 insertions(+), 33 deletions(-) diff --git a/nonebot/config.py b/nonebot/config.py index 65043199..4f02420d 100644 --- a/nonebot/config.py +++ b/nonebot/config.py @@ -137,9 +137,7 @@ class Env(BaseConfig): environment: str = "prod" """ - - **默认值**: ``"prod"`` - - :说明: + :说明: 当前环境名。 NoneBot 将从 ``.env.{environment}`` 文件中加载配置。 """ @@ -162,9 +160,7 @@ class Config(BaseConfig): # nonebot configs driver: str = "~fastapi" """ - - **默认值**: ``"~fastapi"`` - - :说明: + :说明: NoneBot 运行所使用的 ``Driver`` 。继承自 ``nonebot.drivers.Driver`` 。 @@ -174,25 +170,19 @@ class Config(BaseConfig): """ host: IPvAnyAddress = IPv4Address("127.0.0.1") # type: ignore """ - - **默认值**: ``127.0.0.1`` - - :说明: + :说明: NoneBot 的 HTTP 和 WebSocket 服务端监听的 IP/主机名。 """ port: int = 8080 """ - - **默认值**: ``8080`` - - :说明: + :说明: NoneBot 的 HTTP 和 WebSocket 服务端监听的端口。 """ log_level: Union[int, str] = "INFO" """ - - **默认值**: ``INFO`` - - :说明: + :说明: 配置 NoneBot 日志输出等级，可以为 ``int`` 类型等级或等级名称，参考 `loguru 日志等级`_。 @@ -210,9 +200,7 @@ class Config(BaseConfig): # bot connection configs api_timeout: Optional[float] = 30.0 """ - - **默认值**: ``30.`` - - :说明: + :说明: API 请求超时时间，单位: 秒。 """ @@ -220,9 +208,7 @@ class Config(BaseConfig): # bot runtime configs superusers: Set[str] = set() """ - - **默认值**: ``set()`` - - :说明: + :说明: 机器人超级用户。 @@ -234,33 +220,25 @@ class Config(BaseConfig): """ nickname: Set[str] = set() """ - - **默认值**: ``set()`` - - :说明: + :说明: 机器人昵称。 """ command_start: Set[str] = {"/"} """ - - **默认值**: ``{"/"}`` - - :说明: + :说明: 命令的起始标记，用于判断一条消息是不是命令。 """ command_sep: Set[str] = {"."} """ - - **默认值**: ``{"."}`` - - :说明: + :说明: 命令的分隔标记，用于将文本形式的命令切分为元组（实际的命令名）。 """ session_expire_timeout: timedelta = timedelta(minutes=2) """ - - **默认值**: ``timedelta(minutes=2)`` - - :说明: + :说明: 等待用户回复的超时时间。 From 009936483887f920c04c3ea9fc76a5611bdf206f Mon Sep 17 00:00:00 2001 From: hemengyang Date: Wed, 12 Jan 2022 18:16:05 +0800 Subject: [PATCH 03/14] =?UTF-8?q?=E5=88=A0=E9=99=A4=E8=AF=B4=E6=98=8E?= =?UTF-8?q?=E5=89=8D=E7=BC=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- nonebot/__init__.py | 32 +++------ nonebot/adapters/_adapter.py | 4 +- nonebot/adapters/_bot.py | 20 ++---- nonebot/adapters/_event.py | 36 +++------- nonebot/adapters/_message.py | 21 ++---- nonebot/adapters/_template.py | 8 +-- nonebot/config.py | 43 +++--------- nonebot/drivers/__init__.py | 32 +++------ nonebot/drivers/_block_driver.py | 8 +-- nonebot/drivers/_model.py | 2 +- nonebot/drivers/fastapi.py | 36 +++------- nonebot/drivers/quart.py | 20 ++---- nonebot/exception.py | 76 +++++--------------- nonebot/log.py | 4 +- nonebot/matcher.py | 95 +++++++++---------------- nonebot/message.py | 20 ++---- nonebot/params.py | 4 +- nonebot/permission.py | 26 +++---- nonebot/plugin/export.py | 8 +-- nonebot/plugin/load.py | 32 +++------ nonebot/plugin/on.py | 116 +++++++++---------------------- nonebot/plugin/plugin.py | 26 +++---- nonebot/rule.py | 50 ++++--------- nonebot/typing.py | 59 ++++------------ nonebot/utils.py | 16 ++--- 25 files changed, 226 insertions(+), 568 deletions(-) diff --git a/nonebot/__init__.py b/nonebot/__init__.py index e5dc5aa3..93aef863 100644 --- a/nonebot/__init__.py +++ b/nonebot/__init__.py @@ -53,9 +53,7 @@ _driver: Optional[Driver] = None def get_driver() -> Driver: """ - :说明: - - 获取全局 Driver 对象。可用于在计划任务的回调中获取当前 Driver 对象。 + 获取全局 Driver 对象。可用于在计划任务的回调中获取当前 Driver 对象。 :返回: @@ -79,9 +77,7 @@ def get_driver() -> Driver: def get_app() -> Any: """ - :说明: - - 获取全局 Driver 对应 Server App 对象。 + 获取全局 Driver 对应 Server App 对象。 :返回: @@ -107,9 +103,7 @@ def get_app() -> Any: def get_asgi() -> Any: """ - :说明: - - 获取全局 Driver 对应 Asgi 对象。 + 获取全局 Driver 对应 Asgi 对象。 :返回: @@ -135,9 +129,7 @@ def get_asgi() -> Any: def get_bot(self_id: Optional[str] = None) -> Bot: """ - :说明: - - 当提供 self_id 时，此函数是 get_bots()[self_id] 的简写；当不提供时，返回一个 Bot。 + 当提供 self_id 时，此函数是 get_bots()[self_id] 的简写；当不提供时，返回一个 Bot。 :参数: @@ -173,9 +165,7 @@ def get_bot(self_id: Optional[str] = None) -> Bot: def get_bots() -> Dict[str, Bot]: """ - :说明: - - 获取所有通过 ws 连接 NoneBot 的 Bot 对象。 + 获取所有通过 ws 连接 NoneBot 的 Bot 对象。 :返回: @@ -229,13 +219,11 @@ def _resolve_combine_expr(obj_str: str) -> Type[Driver]: def init(*, _env_file: Optional[str] = None, **kwargs): """ - :说明: + 初始化 NoneBot 以及 全局 Driver 对象。 - 初始化 NoneBot 以及 全局 Driver 对象。 + NoneBot 将会从 .env 文件中读取环境信息，并使用相应的 env 文件配置。 - NoneBot 将会从 .env 文件中读取环境信息，并使用相应的 env 文件配置。 - - 你也可以传入自定义的 _env_file 来指定 NoneBot 从该文件读取配置。 + 你也可以传入自定义的 _env_file 来指定 NoneBot 从该文件读取配置。 :参数: @@ -277,9 +265,7 @@ def init(*, _env_file: Optional[str] = None, **kwargs): def run(*args: Any, **kwargs: Any) -> None: """ - :说明: - - 启动 NoneBot，即运行全局 Driver 对象。 + 启动 NoneBot，即运行全局 Driver 对象。 :参数: diff --git a/nonebot/adapters/_adapter.py b/nonebot/adapters/_adapter.py index 4d2e22ff..4977db80 100644 --- a/nonebot/adapters/_adapter.py +++ b/nonebot/adapters/_adapter.py @@ -63,9 +63,7 @@ class Adapter(abc.ABC): @abc.abstractmethod async def _call_api(self, bot: Bot, api: str, **data) -> Any: """ - :说明: - - ``adapter`` 实际调用 api 的逻辑实现函数，实现该方法以调用 api。 + ``adapter`` 实际调用 api 的逻辑实现函数，实现该方法以调用 api。 :参数: diff --git a/nonebot/adapters/_bot.py b/nonebot/adapters/_bot.py index 05762233..145cecb9 100644 --- a/nonebot/adapters/_bot.py +++ b/nonebot/adapters/_bot.py @@ -27,11 +27,11 @@ class Bot(abc.ABC): _calling_api_hook: Set[T_CallingAPIHook] = set() """ - :说明: call_api 时执行的函数 + call_api 时执行的函数 """ _called_api_hook: Set[T_CalledAPIHook] = set() """ - :说明: call_api 后执行的函数 + call_api 后执行的函数 """ def __init__(self, adapter: "Adapter", self_id: str): @@ -58,9 +58,7 @@ class Bot(abc.ABC): async def call_api(self, api: str, **data: Any) -> Any: """ - :说明: - - 调用机器人 API 接口，可以通过该函数或直接通过 bot 属性进行调用 + 调用机器人 API 接口，可以通过该函数或直接通过 bot 属性进行调用 :参数: @@ -129,9 +127,7 @@ class Bot(abc.ABC): self, event: "Event", message: Union[str, "Message", "MessageSegment"], **kwargs ) -> Any: """ - :说明: - - 调用机器人基础发送消息接口 + 调用机器人基础发送消息接口 :参数: @@ -144,9 +140,7 @@ class Bot(abc.ABC): @classmethod def on_calling_api(cls, func: T_CallingAPIHook) -> T_CallingAPIHook: """ - :说明: - - 调用 api 预处理。 + 调用 api 预处理。 :参数: @@ -160,9 +154,7 @@ class Bot(abc.ABC): @classmethod def on_called_api(cls, func: T_CalledAPIHook) -> T_CalledAPIHook: """ - :说明: - - 调用 api 后处理。 + 调用 api 后处理。 :参数: diff --git a/nonebot/adapters/_event.py b/nonebot/adapters/_event.py index 933a7085..75b04367 100644 --- a/nonebot/adapters/_event.py +++ b/nonebot/adapters/_event.py @@ -16,9 +16,7 @@ class Event(abc.ABC, BaseModel): @abc.abstractmethod def get_type(self) -> str: """ - :说明: - - 获取事件类型的方法，类型通常为 NoneBot 内置的四种类型。 + 获取事件类型的方法，类型通常为 NoneBot 内置的四种类型。 :返回: @@ -30,9 +28,7 @@ class Event(abc.ABC, BaseModel): @abc.abstractmethod def get_event_name(self) -> str: """ - :说明: - - 获取事件名称的方法。 + 获取事件名称的方法。 :返回: @@ -43,9 +39,7 @@ class Event(abc.ABC, BaseModel): @abc.abstractmethod def get_event_description(self) -> str: """ - :说明: - - 获取事件描述的方法，通常为事件具体内容。 + 获取事件描述的方法，通常为事件具体内容。 :返回: @@ -58,9 +52,7 @@ class Event(abc.ABC, BaseModel): def get_log_string(self) -> str: """ - :说明: - - 获取事件日志信息的方法，通常你不需要修改这个方法，只有当希望 NoneBot 隐藏该事件日志时，可以抛出 ``NoLogException`` 异常。 + 获取事件日志信息的方法，通常你不需要修改这个方法，只有当希望 NoneBot 隐藏该事件日志时，可以抛出 ``NoLogException`` 异常。 :返回: @@ -75,9 +67,7 @@ class Event(abc.ABC, BaseModel): @abc.abstractmethod def get_user_id(self) -> str: """ - :说明: - - 获取事件主体 id 的方法，通常是用户 id 。 + 获取事件主体 id 的方法，通常是用户 id 。 :返回: @@ -88,9 +78,7 @@ class Event(abc.ABC, BaseModel): @abc.abstractmethod def get_session_id(self) -> str: """ - :说明: - - 获取会话 id 的方法，用于判断当前事件属于哪一个会话，通常是用户 id、群组 id 组合。 + 获取会话 id 的方法，用于判断当前事件属于哪一个会话，通常是用户 id、群组 id 组合。 :返回: @@ -101,9 +89,7 @@ class Event(abc.ABC, BaseModel): @abc.abstractmethod def get_message(self) -> "Message": """ - :说明: - - 获取事件消息内容的方法。 + 获取事件消息内容的方法。 :返回: @@ -113,9 +99,7 @@ class Event(abc.ABC, BaseModel): def get_plaintext(self) -> str: """ - :说明: - - 获取消息纯文本的方法，通常不需要修改，默认通过 ``get_message().extract_plain_text`` 获取。 + 获取消息纯文本的方法，通常不需要修改，默认通过 ``get_message().extract_plain_text`` 获取。 :返回: @@ -126,9 +110,7 @@ class Event(abc.ABC, BaseModel): @abc.abstractmethod def is_tome(self) -> bool: """ - :说明: - - 获取事件是否与机器人有关的方法。 + 获取事件是否与机器人有关的方法。 :返回: diff --git a/nonebot/adapters/_message.py b/nonebot/adapters/_message.py index 629215fd..02628415 100644 --- a/nonebot/adapters/_message.py +++ b/nonebot/adapters/_message.py @@ -26,11 +26,11 @@ class MessageSegment(Mapping, abc.ABC, Generic[TM]): type: str """ - - 说明: 消息段类型 + 消息段类型 """ data: Dict[str, Any] = field(default_factory=lambda: {}) """ - - 说明: 消息段数据 + 消息段数据 """ @classmethod @@ -114,10 +114,9 @@ class Message(List[TMS], abc.ABC): @classmethod def template(cls: Type[TM], format_string: Union[str, TM]) -> MessageTemplate[TM]: """ - :说明: + 根据创建消息模板, 用法和 ``str.format`` 大致相同, 但是可以输出消息对象, 并且支持以 ``Message`` 对象作为消息模板 - 根据创建消息模板, 用法和 ``str.format`` 大致相同, 但是可以输出消息对象, 并且支持以 ``Message`` 对象作为消息模板 - 并且提供了拓展的格式化控制符, 可以用适用于该消息类型的 ``MessageSegment`` 的工厂方法创建消息 + 并且提供了拓展的格式化控制符, 可以用适用于该消息类型的 ``MessageSegment`` 的工厂方法创建消息 :示例: @@ -187,9 +186,7 @@ class Message(List[TMS], abc.ABC): def append(self: TM, obj: Union[str, TMS]) -> TM: """ - :说明: - - 添加一个消息段到消息数组末尾 + 添加一个消息段到消息数组末尾 :参数: @@ -205,9 +202,7 @@ class Message(List[TMS], abc.ABC): def extend(self: TM, obj: Union[TM, Iterable[TMS]]) -> TM: """ - :说明: - - 拼接一个消息数组或多个消息段到消息数组末尾 + 拼接一个消息数组或多个消息段到消息数组末尾 :参数: @@ -222,9 +217,7 @@ class Message(List[TMS], abc.ABC): def extract_plain_text(self: "Message[MessageSegment]") -> str: """ - :说明: - - 提取消息内纯文本消息 + 提取消息内纯文本消息 """ return "".join(str(seg) for seg in self if seg.is_text()) diff --git a/nonebot/adapters/_template.py b/nonebot/adapters/_template.py index 8460436e..4326fe42 100644 --- a/nonebot/adapters/_template.py +++ b/nonebot/adapters/_template.py @@ -47,9 +47,7 @@ class MessageTemplate(Formatter, Generic[TF]): def __init__(self, template, factory=str) -> None: """ - :说明: - - 创建一个模板 + 创建一个模板 :参数: @@ -71,9 +69,7 @@ class MessageTemplate(Formatter, Generic[TF]): def format(self, *args: Any, **kwargs: Any) -> TF: """ - :说明: - - 根据模板和参数生成消息对象 + 根据模板和参数生成消息对象 """ msg = self.factory() if isinstance(self.template, str): diff --git a/nonebot/config.py b/nonebot/config.py index 4f02420d..7e99979d 100644 --- a/nonebot/config.py +++ b/nonebot/config.py @@ -137,8 +137,7 @@ class Env(BaseConfig): environment: str = "prod" """ - :说明: - 当前环境名。 NoneBot 将从 ``.env.{environment}`` 文件中加载配置。 + 当前环境名。 NoneBot 将从 ``.env.{environment}`` 文件中加载配置。 """ class Config: @@ -160,9 +159,7 @@ class Config(BaseConfig): # nonebot configs driver: str = "~fastapi" """ - :说明: - - NoneBot 运行所使用的 ``Driver`` 。继承自 ``nonebot.drivers.Driver`` 。 + NoneBot 运行所使用的 ``Driver`` 。继承自 ``nonebot.drivers.Driver`` 。 配置格式为 ``[:][+[:]]*``。 @@ -170,21 +167,15 @@ class Config(BaseConfig): """ host: IPvAnyAddress = IPv4Address("127.0.0.1") # type: ignore """ - :说明: - - NoneBot 的 HTTP 和 WebSocket 服务端监听的 IP/主机名。 + NoneBot 的 HTTP 和 WebSocket 服务端监听的 IP/主机名。 """ port: int = 8080 """ - :说明: - - NoneBot 的 HTTP 和 WebSocket 服务端监听的端口。 + NoneBot 的 HTTP 和 WebSocket 服务端监听的端口。 """ log_level: Union[int, str] = "INFO" """ - :说明: - - 配置 NoneBot 日志输出等级，可以为 ``int`` 类型等级或等级名称，参考 `loguru 日志等级`_。 + 配置 NoneBot 日志输出等级，可以为 ``int`` 类型等级或等级名称，参考 `loguru 日志等级`_。 :示例: @@ -200,17 +191,13 @@ class Config(BaseConfig): # bot connection configs api_timeout: Optional[float] = 30.0 """ - :说明: - - API 请求超时时间，单位: 秒。 + API 请求超时时间，单位: 秒。 """ # bot runtime configs superusers: Set[str] = set() """ - :说明: - - 机器人超级用户。 + 机器人超级用户。 :示例: @@ -220,27 +207,19 @@ class Config(BaseConfig): """ nickname: Set[str] = set() """ - :说明: - - 机器人昵称。 + 机器人昵称。 """ command_start: Set[str] = {"/"} """ - :说明: - - 命令的起始标记，用于判断一条消息是不是命令。 + 命令的起始标记，用于判断一条消息是不是命令。 """ command_sep: Set[str] = {"."} """ - :说明: - - 命令的分隔标记，用于将文本形式的命令切分为元组（实际的命令名）。 + 命令的分隔标记，用于将文本形式的命令切分为元组（实际的命令名）。 """ session_expire_timeout: timedelta = timedelta(minutes=2) """ - :说明: - - 等待用户回复的超时时间。 + 等待用户回复的超时时间。 :示例: diff --git a/nonebot/drivers/__init__.py b/nonebot/drivers/__init__.py index cabc3629..7b93fae0 100644 --- a/nonebot/drivers/__init__.py +++ b/nonebot/drivers/__init__.py @@ -41,15 +41,15 @@ class Driver(abc.ABC): _adapters: Dict[str, "Adapter"] = {} """ - :说明: 已注册的适配器列表 + 已注册的适配器列表 """ _bot_connection_hook: Set[T_BotConnectionHook] = set() """ - :说明: Bot 连接建立时执行的函数 + Bot 连接建立时执行的函数 """ _bot_disconnection_hook: Set[T_BotDisconnectionHook] = set() """ - :说明: Bot 连接断开时执行的函数 + Bot 连接断开时执行的函数 """ def __init__(self, env: Env, config: Config): @@ -61,31 +61,27 @@ class Driver(abc.ABC): """ self.env: str = env.environment """ - :说明: 环境名称 + 环境名称 """ self.config: Config = config """ - :说明: 配置对象 + 配置对象 """ self._clients: Dict[str, "Bot"] = {} """ - :说明: 已连接的 Bot + 已连接的 Bot """ @property def bots(self) -> Dict[str, "Bot"]: """ - :说明: - - 获取当前所有已连接的 Bot + 获取当前所有已连接的 Bot """ return self._clients def register_adapter(self, adapter: Type["Adapter"], **kwargs) -> None: """ - :说明: - - 注册一个协议适配器 + 注册一个协议适配器 :参数: @@ -119,9 +115,7 @@ class Driver(abc.ABC): @abc.abstractmethod def run(self, *args, **kwargs): """ - :说明: - - 启动驱动框架 + 启动驱动框架 :参数: * ``*args`` @@ -143,9 +137,7 @@ class Driver(abc.ABC): def on_bot_connect(self, func: T_BotConnectionHook) -> T_BotConnectionHook: """ - :说明: - - 装饰一个函数使他在 bot 通过 WebSocket 连接成功时执行。 + 装饰一个函数使他在 bot 通过 WebSocket 连接成功时执行。 :函数参数: @@ -156,9 +148,7 @@ class Driver(abc.ABC): def on_bot_disconnect(self, func: T_BotDisconnectionHook) -> T_BotDisconnectionHook: """ - :说明: - - 装饰一个函数使他在 bot 通过 WebSocket 连接断开时执行。 + 装饰一个函数使他在 bot 通过 WebSocket 连接断开时执行。 :函数参数: diff --git a/nonebot/drivers/_block_driver.py b/nonebot/drivers/_block_driver.py index 0e8f34f8..33a019e8 100644 --- a/nonebot/drivers/_block_driver.py +++ b/nonebot/drivers/_block_driver.py @@ -39,9 +39,7 @@ class BlockDriver(Driver): @overrides(Driver) def on_startup(self, func: STARTUP_FUNC) -> STARTUP_FUNC: """ - :说明: - - 注册一个启动时执行的函数 + 注册一个启动时执行的函数 :参数: @@ -53,9 +51,7 @@ class BlockDriver(Driver): @overrides(Driver) def on_shutdown(self, func: SHUTDOWN_FUNC) -> SHUTDOWN_FUNC: """ - :说明: - - 注册一个停止时执行的函数 + 注册一个停止时执行的函数 :参数: diff --git a/nonebot/drivers/_model.py b/nonebot/drivers/_model.py index 68c8424d..7ac198f8 100644 --- a/nonebot/drivers/_model.py +++ b/nonebot/drivers/_model.py @@ -168,7 +168,7 @@ class WebSocket(abc.ABC): @abc.abstractmethod def closed(self) -> bool: """ - :说明: 连接是否已经关闭 + 连接是否已经关闭 """ raise NotImplementedError diff --git a/nonebot/drivers/fastapi.py b/nonebot/drivers/fastapi.py index 8951b3e7..47e1eb46 100644 --- a/nonebot/drivers/fastapi.py +++ b/nonebot/drivers/fastapi.py @@ -48,57 +48,39 @@ class Config(BaseSettings): fastapi_openapi_url: Optional[str] = None """ - :说明: - - ``openapi.json`` 地址，默认为 ``None`` 即关闭 + ``openapi.json`` 地址，默认为 ``None`` 即关闭 """ fastapi_docs_url: Optional[str] = None """ - :说明: - - ``swagger`` 地址，默认为 ``None`` 即关闭 + ``swagger`` 地址，默认为 ``None`` 即关闭 """ fastapi_redoc_url: Optional[str] = None """ - :说明: - - ``redoc`` 地址，默认为 ``None`` 即关闭 + ``redoc`` 地址，默认为 ``None`` 即关闭 """ fastapi_include_adapter_schema: bool = True """ - :说明: - - 是否包含适配器路由的 schema，默认为 ``True`` + 是否包含适配器路由的 schema，默认为 ``True`` """ fastapi_reload: bool = False """ - :说明: - - 开启/关闭冷重载 + 开启/关闭冷重载 """ fastapi_reload_dirs: Optional[List[str]] = None """ - :说明: - - 重载监控文件夹列表，默认为 uvicorn 默认值 + 重载监控文件夹列表，默认为 uvicorn 默认值 """ fastapi_reload_delay: Optional[float] = None """ - :说明: - - 重载延迟，默认为 uvicorn 默认值 + 重载延迟，默认为 uvicorn 默认值 """ fastapi_reload_includes: Optional[List[str]] = None """ - :说明: - - 要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值 + 要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值 """ fastapi_reload_excludes: Optional[List[str]] = None """ - :说明: - - 不要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值 + 不要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值 """ class Config: diff --git a/nonebot/drivers/quart.py b/nonebot/drivers/quart.py index 84b6ce49..f2e979eb 100644 --- a/nonebot/drivers/quart.py +++ b/nonebot/drivers/quart.py @@ -56,33 +56,23 @@ class Config(BaseSettings): quart_reload: bool = False """ - :说明: - - 开启/关闭冷重载 + 开启/关闭冷重载 """ quart_reload_dirs: Optional[List[str]] = None """ - :说明: - - 重载监控文件夹列表，默认为 uvicorn 默认值 + 重载监控文件夹列表，默认为 uvicorn 默认值 """ quart_reload_delay: Optional[float] = None """ - :说明: - - 重载延迟，默认为 uvicorn 默认值 + 重载延迟，默认为 uvicorn 默认值 """ quart_reload_includes: Optional[List[str]] = None """ - :说明: - - 要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值 + 要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值 """ quart_reload_excludes: Optional[List[str]] = None """ - :说明: - - 不要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值 + 不要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值 """ class Config: diff --git a/nonebot/exception.py b/nonebot/exception.py index 62eb23b7..4cc887ab 100644 --- a/nonebot/exception.py +++ b/nonebot/exception.py @@ -13,18 +13,14 @@ from pydantic.fields import ModelField class NoneBotException(Exception): """ - :说明: - - 所有 NoneBot 发生的异常基类。 + 所有 NoneBot 发生的异常基类。 """ # Rule Exception class ParserExit(NoneBotException): """ - :说明: - - ``shell command`` 处理消息失败时返回的异常 + ``shell command`` 处理消息失败时返回的异常 :参数: @@ -46,17 +42,13 @@ class ParserExit(NoneBotException): # Processor Exception class ProcessException(NoneBotException): """ - :说明: - - 事件处理过程中发生的异常基类。 + 事件处理过程中发生的异常基类。 """ class IgnoredException(ProcessException): """ - :说明: - - 指示 NoneBot 应该忽略该事件。可由 PreProcessor 抛出。 + 指示 NoneBot 应该忽略该事件。可由 PreProcessor 抛出。 :参数: @@ -75,9 +67,7 @@ class IgnoredException(ProcessException): class MockApiException(ProcessException): """ - :说明: - - 指示 NoneBot 阻止本次 API 调用或修改本次调用返回值，并返回自定义内容。可由 api hook 抛出。 + 指示 NoneBot 阻止本次 API 调用或修改本次调用返回值，并返回自定义内容。可由 api hook 抛出。 :参数: @@ -96,9 +86,7 @@ class MockApiException(ProcessException): class StopPropagation(ProcessException): """ - :说明: - - 指示 NoneBot 终止事件向下层传播。 + 指示 NoneBot 终止事件向下层传播。 :用法: @@ -109,17 +97,13 @@ class StopPropagation(ProcessException): # Matcher Exceptions class MatcherException(NoneBotException): """ - :说明: - - 所有 Matcher 发生的异常基类。 + 所有 Matcher 发生的异常基类。 """ class SkippedException(MatcherException): """ - :说明: - - 指示 NoneBot 立即结束当前 ``Handler`` 的处理，继续处理下一个 ``Handler``。 + 指示 NoneBot 立即结束当前 ``Handler`` 的处理，继续处理下一个 ``Handler``。 :用法: @@ -129,9 +113,7 @@ class SkippedException(MatcherException): class TypeMisMatch(SkippedException): """ - :说明: - - 当前 ``Handler`` 的参数类型不匹配。 + 当前 ``Handler`` 的参数类型不匹配。 """ def __init__(self, param: ModelField, value: Any): @@ -147,9 +129,7 @@ class TypeMisMatch(SkippedException): class PausedException(MatcherException): """ - :说明: - - 指示 NoneBot 结束当前 ``Handler`` 并等待下一条消息后继续下一个 ``Handler``。 + 指示 NoneBot 结束当前 ``Handler`` 并等待下一条消息后继续下一个 ``Handler``。 可用于用户输入新信息。 :用法: @@ -160,9 +140,7 @@ class PausedException(MatcherException): class RejectedException(MatcherException): """ - :说明: - - 指示 NoneBot 结束当前 ``Handler`` 并等待下一条消息后重新运行当前 ``Handler``。 + 指示 NoneBot 结束当前 ``Handler`` 并等待下一条消息后重新运行当前 ``Handler``。 可用于用户重新输入。 :用法: @@ -173,9 +151,7 @@ class RejectedException(MatcherException): class FinishedException(MatcherException): """ - :说明: - - 指示 NoneBot 结束当前 ``Handler`` 且后续 ``Handler`` 不再被运行。 + 指示 NoneBot 结束当前 ``Handler`` 且后续 ``Handler`` 不再被运行。 可用于结束用户会话。 :用法: @@ -187,9 +163,7 @@ class FinishedException(MatcherException): # Adapter Exceptions class AdapterException(NoneBotException): """ - :说明: - - 代表 ``Adapter`` 抛出的异常，所有的 ``Adapter`` 都要在内部继承自这个 ``Exception`` + 代表 ``Adapter`` 抛出的异常，所有的 ``Adapter`` 都要在内部继承自这个 ``Exception`` :参数: @@ -202,9 +176,7 @@ class AdapterException(NoneBotException): class NoLogException(AdapterException): """ - :说明: - - 指示 NoneBot 对当前 ``Event`` 进行处理但不显示 Log 信息，可在 ``get_log_string`` 时抛出 + 指示 NoneBot 对当前 ``Event`` 进行处理但不显示 Log 信息，可在 ``get_log_string`` 时抛出 """ pass @@ -212,9 +184,7 @@ class NoLogException(AdapterException): class ApiNotAvailable(AdapterException): """ - :说明: - - 在 API 连接不可用时抛出。 + 在 API 连接不可用时抛出。 """ pass @@ -222,9 +192,7 @@ class ApiNotAvailable(AdapterException): class NetworkError(AdapterException): """ - :说明: - - 在网络出现问题时抛出，如: API 请求地址不正确, API 请求无返回或返回状态非正常等。 + 在网络出现问题时抛出，如: API 请求地址不正确, API 请求无返回或返回状态非正常等。 """ pass @@ -232,9 +200,7 @@ class NetworkError(AdapterException): class ActionFailed(AdapterException): """ - :说明: - - API 请求成功返回数据，但 API 操作失败。 + API 请求成功返回数据，但 API 操作失败。 """ pass @@ -243,17 +209,13 @@ class ActionFailed(AdapterException): # Driver Exceptions class DriverException(NoneBotException): """ - :说明: - - ``Driver`` 抛出的异常基类 + ``Driver`` 抛出的异常基类 """ class WebSocketClosed(DriverException): """ - :说明: - - WebSocket 连接已关闭 + WebSocket 连接已关闭 """ def __init__(self, code: int, reason: Optional[str] = None): diff --git a/nonebot/log.py b/nonebot/log.py index 859353c2..cb8ef370 100644 --- a/nonebot/log.py +++ b/nonebot/log.py @@ -24,9 +24,7 @@ if TYPE_CHECKING: # logger = logging.getLogger("nonebot") logger: "Logger" = loguru.logger """ -:说明: - - NoneBot 日志记录器对象。 +NoneBot 日志记录器对象。 :默认信息: diff --git a/nonebot/matcher.py b/nonebot/matcher.py index c9a60f08..f7f27796 100644 --- a/nonebot/matcher.py +++ b/nonebot/matcher.py @@ -66,7 +66,7 @@ T = TypeVar("T") matchers: Dict[int, List[Type["Matcher"]]] = defaultdict(list) """ -:说明: 用于存储当前所有的事件响应器 +用于存储当前所有的事件响应器 """ current_bot: ContextVar[Bot] = ContextVar("current_bot") current_event: ContextVar[Event] = ContextVar("current_event") @@ -105,66 +105,66 @@ class Matcher(metaclass=MatcherMeta): plugin: Optional["Plugin"] = None """ - :说明: 事件响应器所在插件 + 事件响应器所在插件 """ module: Optional[ModuleType] = None """ - :说明: 事件响应器所在插件模块 + 事件响应器所在插件模块 """ plugin_name: Optional[str] = None """ - :说明: 事件响应器所在插件名 + 事件响应器所在插件名 """ module_name: Optional[str] = None """ - :说明: 事件响应器所在点分割插件模块路径 + 事件响应器所在点分割插件模块路径 """ type: str = "" """ - :说明: 事件响应器类型 + 事件响应器类型 """ rule: Rule = Rule() """ - :说明: 事件响应器匹配规则 + 事件响应器匹配规则 """ permission: Permission = Permission() """ - :说明: 事件响应器触发权限 + 事件响应器触发权限 """ handlers: List[Dependent[Any]] = [] """ - :说明: 事件响应器拥有的事件处理函数列表 + 事件响应器拥有的事件处理函数列表 """ priority: int = 1 """ - :说明: 事件响应器优先级 + 事件响应器优先级 """ block: bool = False """ - :说明: 事件响应器是否阻止事件传播 + 事件响应器是否阻止事件传播 """ temp: bool = False """ - :说明: 事件响应器是否为临时 + 事件响应器是否为临时 """ expire_time: Optional[datetime] = None """ - :说明: 事件响应器过期时间点 + 事件响应器过期时间点 """ _default_state: T_State = {} """ - :说明: 事件响应器默认状态 + 事件响应器默认状态 """ _default_type_updater: Optional[Dependent[str]] = None """ - :说明: 事件响应器类型更新函数 + 事件响应器类型更新函数 """ _default_permission_updater: Optional[Dependent[Permission]] = None """ - :说明: 事件响应器权限更新函数 + 事件响应器权限更新函数 """ HANDLER_PARAM_TYPES = [ @@ -210,9 +210,7 @@ class Matcher(metaclass=MatcherMeta): default_permission_updater: Optional[T_PermissionUpdater] = None, ) -> Type["Matcher"]: """ - :说明: - - 创建一个新的事件响应器，并存储至 `matchers <#matchers>`_ + 创建一个新的事件响应器，并存储至 `matchers <#matchers>`_ :参数: @@ -278,9 +276,7 @@ class Matcher(metaclass=MatcherMeta): dependency_cache: Optional[T_DependencyCache] = None, ) -> bool: """ - :说明: - - 检查是否满足触发权限 + 检查是否满足触发权限 :参数: @@ -306,9 +302,7 @@ class Matcher(metaclass=MatcherMeta): dependency_cache: Optional[T_DependencyCache] = None, ) -> bool: """ - :说明: - - 检查是否满足匹配规则 + 检查是否满足匹配规则 :参数: @@ -328,9 +322,7 @@ class Matcher(metaclass=MatcherMeta): @classmethod def type_updater(cls, func: T_TypeUpdater) -> T_TypeUpdater: """ - :说明: - - 装饰一个函数来更改当前事件响应器的默认响应事件类型更新函数 + 装饰一个函数来更改当前事件响应器的默认响应事件类型更新函数 :参数: @@ -344,9 +336,7 @@ class Matcher(metaclass=MatcherMeta): @classmethod def permission_updater(cls, func: T_PermissionUpdater) -> T_PermissionUpdater: """ - :说明: - - 装饰一个函数来更改当前事件响应器的默认会话权限更新函数 + 装饰一个函数来更改当前事件响应器的默认会话权限更新函数 :参数: @@ -374,9 +364,7 @@ class Matcher(metaclass=MatcherMeta): cls, parameterless: Optional[List[Any]] = None ) -> Callable[[T_Handler], T_Handler]: """ - :说明: - - 装饰一个函数来向事件响应器直接添加一个处理函数 + 装饰一个函数来向事件响应器直接添加一个处理函数 :参数: @@ -394,9 +382,7 @@ class Matcher(metaclass=MatcherMeta): cls, id: str = "", parameterless: Optional[List[Any]] = None ) -> Callable[[T_Handler], T_Handler]: """ - :说明: - - 装饰一个函数来指示 NoneBot 在接收用户新的一条消息后继续运行该函数 + 装饰一个函数来指示 NoneBot 在接收用户新的一条消息后继续运行该函数 :参数: @@ -436,9 +422,7 @@ class Matcher(metaclass=MatcherMeta): parameterless: Optional[List[Any]] = None, ) -> Callable[[T_Handler], T_Handler]: """ - :说明: - - 装饰一个函数来指示 NoneBot 当要获取的 ``key`` 不存在时接收用户新的一条消息并经过 ``ArgsParser`` 处理后再运行该函数，如果 ``key`` 已存在则直接继续运行 + 装饰一个函数来指示 NoneBot 当要获取的 ``key`` 不存在时接收用户新的一条消息并经过 ``ArgsParser`` 处理后再运行该函数，如果 ``key`` 已存在则直接继续运行 :参数: @@ -482,9 +466,7 @@ class Matcher(metaclass=MatcherMeta): **kwargs: Any, ) -> Any: """ - :说明: - - 发送一条消息给当前交互用户 + 发送一条消息给当前交互用户 :参数: @@ -507,9 +489,7 @@ class Matcher(metaclass=MatcherMeta): **kwargs, ) -> NoReturn: """ - :说明: - - 发送一条消息给当前交互用户并结束当前事件响应器 + 发送一条消息给当前交互用户并结束当前事件响应器 :参数: @@ -527,9 +507,7 @@ class Matcher(metaclass=MatcherMeta): **kwargs, ) -> NoReturn: """ - :说明: - - 发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续下一个处理函数 + 发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续下一个处理函数 :参数: @@ -547,10 +525,7 @@ class Matcher(metaclass=MatcherMeta): **kwargs, ) -> NoReturn: """ - :说明: - - 最近使用 ``got`` / ``receive`` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器， - 在接收用户新的一条消息后继续当前处理函数 + 最近使用 ``got`` / ``receive`` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 :参数: @@ -569,10 +544,7 @@ class Matcher(metaclass=MatcherMeta): **kwargs, ) -> NoReturn: """ - :说明: - - 最近使用 ``got`` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器， - 在接收用户新的一条消息后继续当前处理函数 + 最近使用 ``got`` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 :参数: @@ -594,10 +566,7 @@ class Matcher(metaclass=MatcherMeta): **kwargs, ) -> NoReturn: """ - :说明: - - 最近使用 ``got`` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器， - 在接收用户新的一条消息后继续当前处理函数 + 最近使用 ``got`` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 :参数: @@ -642,9 +611,7 @@ class Matcher(metaclass=MatcherMeta): def stop_propagation(self): """ - :说明: - - 阻止事件传播 + 阻止事件传播 """ self.block = True diff --git a/nonebot/message.py b/nonebot/message.py index 6611598b..de976570 100644 --- a/nonebot/message.py +++ b/nonebot/message.py @@ -69,9 +69,7 @@ RUN_POSTPCS_PARAMS = [ def event_preprocessor(func: T_EventPreProcessor) -> T_EventPreProcessor: """ - :说明: - - 事件预处理。装饰一个函数，使它在每次接收到事件并分发给各响应器之前执行。 + 事件预处理。装饰一个函数，使它在每次接收到事件并分发给各响应器之前执行。 """ _event_preprocessors.add( Dependent[None].parse(call=func, allow_types=EVENT_PCS_PARAMS) @@ -81,9 +79,7 @@ def event_preprocessor(func: T_EventPreProcessor) -> T_EventPreProcessor: def event_postprocessor(func: T_EventPostProcessor) -> T_EventPostProcessor: """ - :说明: - - 事件后处理。装饰一个函数，使它在每次接收到事件并分发给各响应器之后执行。 + 事件后处理。装饰一个函数，使它在每次接收到事件并分发给各响应器之后执行。 """ _event_postprocessors.add( Dependent[None].parse(call=func, allow_types=EVENT_PCS_PARAMS) @@ -93,9 +89,7 @@ def event_postprocessor(func: T_EventPostProcessor) -> T_EventPostProcessor: def run_preprocessor(func: T_RunPreProcessor) -> T_RunPreProcessor: """ - :说明: - - 运行预处理。装饰一个函数，使它在每次事件响应器运行前执行。 + 运行预处理。装饰一个函数，使它在每次事件响应器运行前执行。 """ _run_preprocessors.add( Dependent[None].parse(call=func, allow_types=RUN_PREPCS_PARAMS) @@ -105,9 +99,7 @@ def run_preprocessor(func: T_RunPreProcessor) -> T_RunPreProcessor: def run_postprocessor(func: T_RunPostProcessor) -> T_RunPostProcessor: """ - :说明: - - 运行后处理。装饰一个函数，使它在每次事件响应器运行后执行。 + 运行后处理。装饰一个函数，使它在每次事件响应器运行后执行。 """ _run_postprocessors.add( Dependent[None].parse(call=func, allow_types=RUN_POSTPCS_PARAMS) @@ -242,9 +234,7 @@ async def _run_matcher( async def handle_event(bot: "Bot", event: "Event") -> None: """ - :说明: - - 处理一个事件。调用该函数以实现分发事件。 + 处理一个事件。调用该函数以实现分发事件。 :参数: diff --git a/nonebot/params.py b/nonebot/params.py index bf6547ef..63dfaa39 100644 --- a/nonebot/params.py +++ b/nonebot/params.py @@ -56,9 +56,7 @@ def Depends( use_cache: bool = True, ) -> Any: """ - :说明: - - 参数依赖注入装饰器 + 参数依赖注入装饰器 :参数: diff --git a/nonebot/permission.py b/nonebot/permission.py index 2bad7061..6adf6b8d 100644 --- a/nonebot/permission.py +++ b/nonebot/permission.py @@ -35,9 +35,7 @@ async def _run_coro_with_catch(coro: Coroutine[Any, Any, Any]): class Permission: """ - :说明: - - ``Matcher`` 规则类，当事件传递时，在 ``Matcher`` 运行前进行检查。 + ``Matcher`` 规则类，当事件传递时，在 ``Matcher`` 运行前进行检查。 :示例: @@ -74,9 +72,7 @@ class Permission: for checker in checkers ) """ - :说明: - - 存储 ``PermissionChecker`` + 存储 ``PermissionChecker`` """ async def __call__( @@ -87,9 +83,7 @@ class Permission: dependency_cache: Optional[T_DependencyCache] = None, ) -> bool: """ - :说明: - - 检查是否满足某个权限 + 检查是否满足某个权限 :参数: @@ -155,19 +149,19 @@ class MetaEvent: MESSAGE = Permission(Message()) """ -- **说明**: 匹配任意 ``message`` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 message type 的 Matcher。 +匹配任意 ``message`` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 message type 的 Matcher。 """ NOTICE = Permission(Notice()) """ -- **说明**: 匹配任意 ``notice`` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 notice type 的 Matcher。 +匹配任意 ``notice`` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 notice type 的 Matcher。 """ REQUEST = Permission(Request()) """ -- **说明**: 匹配任意 ``request`` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 request type 的 Matcher。 +匹配任意 ``request`` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 request type 的 Matcher。 """ METAEVENT = Permission(MetaEvent()) """ -- **说明**: 匹配任意 ``meta_event`` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 meta_event type 的 Matcher。 +匹配任意 ``meta_event`` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 meta_event type 的 Matcher。 """ @@ -187,9 +181,7 @@ class User: def USER(*users: str, perm: Optional[Permission] = None): """ - :说明: - - ``event`` 的 ``session_id`` 在白名单内且满足 perm + ``event`` 的 ``session_id`` 在白名单内且满足 perm :参数: @@ -211,5 +203,5 @@ class SuperUser: SUPERUSER = Permission(SuperUser()) """ -- **说明**: 匹配任意超级用户消息类型事件 +匹配任意超级用户消息类型事件 """ diff --git a/nonebot/plugin/export.py b/nonebot/plugin/export.py index 2a792a01..f7bf5a80 100644 --- a/nonebot/plugin/export.py +++ b/nonebot/plugin/export.py @@ -3,9 +3,7 @@ from . import _current_plugin class Export(dict): """ - :说明: - - 插件导出内容以使得其他插件可以获得。 + 插件导出内容以使得其他插件可以获得。 :示例: @@ -46,9 +44,7 @@ class Export(dict): def export() -> Export: """ - :说明: - - 获取插件的导出内容对象 + 获取插件的导出内容对象 :返回: diff --git a/nonebot/plugin/load.py b/nonebot/plugin/load.py index 642d7bcc..ef6c1059 100644 --- a/nonebot/plugin/load.py +++ b/nonebot/plugin/load.py @@ -12,9 +12,7 @@ from .plugin import Plugin, get_plugin def load_plugin(module_path: str) -> Optional[Plugin]: """ - :说明: - - 使用 ``PluginManager`` 加载单个插件，可以是本地插件或是通过 ``pip`` 安装的插件。 + 使用 ``PluginManager`` 加载单个插件，可以是本地插件或是通过 ``pip`` 安装的插件。 :参数: @@ -32,9 +30,7 @@ def load_plugin(module_path: str) -> Optional[Plugin]: def load_plugins(*plugin_dir: str) -> Set[Plugin]: """ - :说明: - - 导入目录下多个插件，以 ``_`` 开头的插件不会被导入！ + 导入目录下多个插件，以 ``_`` 开头的插件不会被导入！ :参数: @@ -53,9 +49,7 @@ def load_all_plugins( module_path: Iterable[str], plugin_dir: Iterable[str] ) -> Set[Plugin]: """ - :说明: - - 导入指定列表中的插件以及指定目录下多个插件，以 ``_`` 开头的插件不会被导入！ + 导入指定列表中的插件以及指定目录下多个插件，以 ``_`` 开头的插件不会被导入！ :参数: @@ -73,9 +67,7 @@ def load_all_plugins( def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]: """ - :说明: - - 导入指定 json 文件中的 ``plugins`` 以及 ``plugin_dirs`` 下多个插件，以 ``_`` 开头的插件不会被导入！ + 导入指定 json 文件中的 ``plugins`` 以及 ``plugin_dirs`` 下多个插件，以 ``_`` 开头的插件不会被导入！ :参数: @@ -97,9 +89,7 @@ def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]: def load_from_toml(file_path: str, encoding: str = "utf-8") -> Set[Plugin]: """ - :说明: - - 导入指定 toml 文件 ``[tool.nonebot]`` 中的 ``plugins`` 以及 ``plugin_dirs`` 下多个插件， + 导入指定 toml 文件 ``[tool.nonebot]`` 中的 ``plugins`` 以及 ``plugin_dirs`` 下多个插件， 以 ``_`` 开头的插件不会被导入！ :参数: @@ -133,9 +123,7 @@ def load_from_toml(file_path: str, encoding: str = "utf-8") -> Set[Plugin]: def load_builtin_plugin(name: str) -> Optional[Plugin]: """ - :说明: - - 导入 NoneBot 内置插件 + 导入 NoneBot 内置插件 :返回: @@ -146,9 +134,7 @@ def load_builtin_plugin(name: str) -> Optional[Plugin]: def load_builtin_plugins(*plugins) -> Set[Plugin]: """ - :说明: - - 导入多个 NoneBot 内置插件 + 导入多个 NoneBot 内置插件 :返回: @@ -159,9 +145,7 @@ def load_builtin_plugins(*plugins) -> Set[Plugin]: def require(name: str) -> Export: """ - :说明: - - 获取一个插件的导出内容 + 获取一个插件的导出内容 :参数: diff --git a/nonebot/plugin/on.py b/nonebot/plugin/on.py index afca33d2..1319584c 100644 --- a/nonebot/plugin/on.py +++ b/nonebot/plugin/on.py @@ -55,9 +55,7 @@ def on( _depth: int = 0, ) -> Type[Matcher]: """ - :说明: - - 注册一个基础事件响应器，可自定义类型。 + 注册一个基础事件响应器，可自定义类型。 :参数: @@ -101,9 +99,7 @@ def on_metaevent( _depth: int = 0, ) -> Type[Matcher]: """ - :说明: - - 注册一个元事件响应器。 + 注册一个元事件响应器。 :参数: @@ -146,9 +142,7 @@ def on_message( _depth: int = 0, ) -> Type[Matcher]: """ - :说明: - - 注册一个消息事件响应器。 + 注册一个消息事件响应器。 :参数: @@ -191,9 +185,7 @@ def on_notice( _depth: int = 0, ) -> Type[Matcher]: """ - :说明: - - 注册一个通知事件响应器。 + 注册一个通知事件响应器。 :参数: @@ -235,9 +227,7 @@ def on_request( _depth: int = 0, ) -> Type[Matcher]: """ - :说明: - - 注册一个请求事件响应器。 + 注册一个请求事件响应器。 :参数: @@ -276,9 +266,7 @@ def on_startswith( **kwargs, ) -> Type[Matcher]: """ - :说明: - - 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。 + 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。 :参数: @@ -307,9 +295,7 @@ def on_endswith( **kwargs, ) -> Type[Matcher]: """ - :说明: - - 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。 + 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。 :参数: @@ -337,9 +323,7 @@ def on_keyword( **kwargs, ) -> Type[Matcher]: """ - :说明: - - 注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。 + 注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。 :参数: @@ -367,9 +351,7 @@ def on_command( **kwargs, ) -> Type[Matcher]: """ - :说明: - - 注册一个消息事件响应器，并且当消息以指定命令开头时响应。 + 注册一个消息事件响应器，并且当消息以指定命令开头时响应。 命令匹配规则参考: `命令形式匹配 `_ @@ -406,9 +388,7 @@ def on_shell_command( **kwargs, ) -> Type[Matcher]: """ - :说明: - - 注册一个支持 ``shell_like`` 解析参数的命令消息事件响应器。 + 注册一个支持 ``shell_like`` 解析参数的命令消息事件响应器。 与普通的 ``on_command`` 不同的是，在添加 ``parser`` 参数时, 响应器会自动处理消息。 @@ -448,9 +428,7 @@ def on_regex( **kwargs, ) -> Type[Matcher]: """ - :说明: - - 注册一个消息事件响应器，并且当消息匹配正则表达式时响应。 + 注册一个消息事件响应器，并且当消息匹配正则表达式时响应。 命令匹配规则参考: `正则匹配 `_ @@ -485,20 +463,18 @@ class CommandGroup: """ self.basecmd: Tuple[str, ...] = (cmd,) if isinstance(cmd, str) else cmd """ - - **说明**: 命令前缀 + 命令前缀 """ if "aliases" in kwargs: del kwargs["aliases"] self.base_kwargs: Dict[str, Any] = kwargs """ - - **说明**: 其他传递给 ``on_command`` 的参数默认值 + 其他传递给 ``on_command`` 的参数默认值 """ def command(self, cmd: Union[str, Tuple[str, ...]], **kwargs) -> Type[Matcher]: """ - :说明: - - 注册一个新的命令。 + 注册一个新的命令。 :参数: @@ -520,9 +496,7 @@ class CommandGroup: self, cmd: Union[str, Tuple[str, ...]], **kwargs ) -> Type[Matcher]: """ - :说明: - - 注册一个新的命令。 + 注册一个新的命令。 :参数: @@ -546,24 +520,20 @@ class MatcherGroup: def __init__(self, **kwargs): """ - :说明: - - 创建一个事件响应器组合，参数为默认值，与 ``on`` 一致 + 创建一个事件响应器组合，参数为默认值，与 ``on`` 一致 """ self.matchers: List[Type[Matcher]] = [] """ - :说明: 组内事件响应器列表 + 组内事件响应器列表 """ self.base_kwargs: Dict[str, Any] = kwargs """ - - **说明**: 其他传递给 ``on`` 的参数默认值 + 其他传递给 ``on`` 的参数默认值 """ def on(self, **kwargs) -> Type[Matcher]: """ - :说明: - - 注册一个基础事件响应器，可自定义类型。 + 注册一个基础事件响应器，可自定义类型。 :参数: @@ -588,9 +558,7 @@ class MatcherGroup: def on_metaevent(self, **kwargs) -> Type[Matcher]: """ - :说明: - - 注册一个元事件响应器。 + 注册一个元事件响应器。 :参数: @@ -615,9 +583,7 @@ class MatcherGroup: def on_message(self, **kwargs) -> Type[Matcher]: """ - :说明: - - 注册一个消息事件响应器。 + 注册一个消息事件响应器。 :参数: @@ -642,9 +608,7 @@ class MatcherGroup: def on_notice(self, **kwargs) -> Type[Matcher]: """ - :说明: - - 注册一个通知事件响应器。 + 注册一个通知事件响应器。 :参数: @@ -668,9 +632,7 @@ class MatcherGroup: def on_request(self, **kwargs) -> Type[Matcher]: """ - :说明: - - 注册一个请求事件响应器。 + 注册一个请求事件响应器。 :参数: @@ -696,9 +658,7 @@ class MatcherGroup: self, msg: Union[str, Tuple[str, ...]], **kwargs ) -> Type[Matcher]: """ - :说明: - - 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。 + 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。 :参数: @@ -725,9 +685,7 @@ class MatcherGroup: def on_endswith(self, msg: Union[str, Tuple[str, ...]], **kwargs) -> Type[Matcher]: """ - :说明: - - 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。 + 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。 :参数: @@ -754,9 +712,7 @@ class MatcherGroup: def on_keyword(self, keywords: Set[str], **kwargs) -> Type[Matcher]: """ - :说明: - - 注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。 + 注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。 :参数: @@ -787,11 +743,9 @@ class MatcherGroup: **kwargs, ) -> Type[Matcher]: """ - :说明: + 注册一个消息事件响应器，并且当消息以指定命令开头时响应。 - 注册一个消息事件响应器，并且当消息以指定命令开头时响应。 - - 命令匹配规则参考: `命令形式匹配 `_ + 命令匹配规则参考: `命令形式匹配 `_ :参数: @@ -824,13 +778,11 @@ class MatcherGroup: **kwargs, ) -> Type[Matcher]: """ - :说明: + 注册一个支持 ``shell_like`` 解析参数的命令消息事件响应器。 - 注册一个支持 ``shell_like`` 解析参数的命令消息事件响应器。 + 与普通的 ``on_command`` 不同的是，在添加 ``parser`` 参数时, 响应器会自动处理消息。 - 与普通的 ``on_command`` 不同的是，在添加 ``parser`` 参数时, 响应器会自动处理消息。 - - 并将用户输入的原始参数列表保存在 ``state["argv"]``, ``parser`` 处理的参数保存在 ``state["args"]`` 中 + 并将用户输入的原始参数列表保存在 ``state["argv"]``, ``parser`` 处理的参数保存在 ``state["args"]`` 中 :参数: @@ -862,11 +814,9 @@ class MatcherGroup: self, pattern: str, flags: Union[int, re.RegexFlag] = 0, **kwargs ) -> Type[Matcher]: """ - :说明: + 注册一个消息事件响应器，并且当消息匹配正则表达式时响应。 - 注册一个消息事件响应器，并且当消息匹配正则表达式时响应。 - - 命令匹配规则参考: `正则匹配 `_ + 命令匹配规则参考: `正则匹配 `_ :参数: diff --git a/nonebot/plugin/plugin.py b/nonebot/plugin/plugin.py index d549d22e..d590e443 100644 --- a/nonebot/plugin/plugin.py +++ b/nonebot/plugin/plugin.py @@ -10,7 +10,7 @@ if TYPE_CHECKING: plugins: Dict[str, "Plugin"] = {} """ -:说明: 已加载的插件 +已加载的插件 """ @@ -20,43 +20,41 @@ class Plugin(object): name: str """ - - **说明**: 插件名称，使用 文件/文件夹 名称作为插件名 + 插件名称，使用 文件/文件夹 名称作为插件名 """ module: ModuleType """ - - **说明**: 插件模块对象 + 插件模块对象 """ module_name: str """ - - **说明**: 点分割模块路径 + 点分割模块路径 """ manager: "PluginManager" """ - - **说明**: 导入该插件的插件管理器 + 导入该插件的插件管理器 """ export: Export = field(default_factory=Export) """ - - **说明**: 插件内定义的导出内容 + 插件内定义的导出内容 """ matcher: Set[Type[Matcher]] = field(default_factory=set) """ - - **说明**: 插件内定义的 ``Matcher`` + 插件内定义的 ``Matcher`` """ parent_plugin: Optional["Plugin"] = None """ - - **说明**: 父插件 + 父插件 """ sub_plugins: Set["Plugin"] = field(default_factory=set) """ - - **说明**: 子插件集合 + 子插件集合 """ def get_plugin(name: str) -> Optional[Plugin]: """ - :说明: - - 获取当前导入的某个插件。 + 获取当前导入的某个插件。 :参数: @@ -71,9 +69,7 @@ def get_plugin(name: str) -> Optional[Plugin]: def get_loaded_plugins() -> Set[Plugin]: """ - :说明: - - 获取当前已导入的所有插件。 + 获取当前已导入的所有插件。 :返回: diff --git a/nonebot/rule.py b/nonebot/rule.py index 66d41a48..8dc5da8b 100644 --- a/nonebot/rule.py +++ b/nonebot/rule.py @@ -63,9 +63,7 @@ CMD_RESULT = TypedDict( class Rule: """ - :说明: - - ``Matcher`` 规则类，当事件传递时，在 ``Matcher`` 运行前进行检查。 + ``Matcher`` 规则类，当事件传递时，在 ``Matcher`` 运行前进行检查。 :示例: @@ -103,9 +101,7 @@ class Rule: for checker in checkers ) """ - :说明: - - 存储 ``RuleChecker`` + 存储 ``RuleChecker`` """ async def __call__( @@ -117,9 +113,7 @@ class Rule: dependency_cache: Optional[T_DependencyCache] = None, ) -> bool: """ - :说明: - - 检查是否符合所有规则 + 检查是否符合所有规则 :参数: @@ -220,9 +214,7 @@ class StartswithRule: def startswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule: """ - :说明: - - 匹配消息开头 + 匹配消息开头 :参数: @@ -255,9 +247,7 @@ class EndswithRule: def endswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule: """ - :说明: - - 匹配消息结尾 + 匹配消息结尾 :参数: @@ -283,9 +273,7 @@ class KeywordsRule: def keyword(*keywords: str) -> Rule: """ - :说明: - - 匹配消息关键词 + 匹配消息关键词 :参数: @@ -308,9 +296,7 @@ class CommandRule: def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule: r""" - :说明: - - 命令形式匹配，根据配置里提供的 ``command_start``, ``command_sep`` 判断消息是否为命令。 + 命令形式匹配，根据配置里提供的 ``command_start``, ``command_sep`` 判断消息是否为命令。 可以通过 ``state["_prefix"]["command"]`` 获取匹配成功的命令（例：``("test",)``），通过 ``state["_prefix"]["raw_command"]`` 获取匹配成功的原始命令文本（例：``"/test"``）。 @@ -352,9 +338,7 @@ def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule: class ArgumentParser(ArgParser): """ - :说明: - - ``shell_like`` 命令参数解析器，解析出错时不会退出程序。 + ``shell_like`` 命令参数解析器，解析出错时不会退出程序。 """ def _print_message(self, message, file=None): @@ -408,15 +392,13 @@ def shell_command( *cmds: Union[str, Tuple[str, ...]], parser: Optional[ArgumentParser] = None ) -> Rule: r""" - :说明: + 支持 ``shell_like`` 解析参数的命令形式匹配，根据配置里提供的 ``command_start``, ``command_sep`` 判断消息是否为命令。 - 支持 ``shell_like`` 解析参数的命令形式匹配，根据配置里提供的 ``command_start``, ``command_sep`` 判断消息是否为命令。 + 可以通过 ``state["_prefix"]["command"]`` 获取匹配成功的命令（例：``("test",)``），通过 ``state["_prefix"]["raw_command"]`` 获取匹配成功的原始命令文本（例：``"/test"``）。 - 可以通过 ``state["_prefix"]["command"]`` 获取匹配成功的命令（例：``("test",)``），通过 ``state["_prefix"]["raw_command"]`` 获取匹配成功的原始命令文本（例：``"/test"``）。 + 可以通过 ``state["argv"]`` 获取用户输入的原始参数列表 - 可以通过 ``state["argv"]`` 获取用户输入的原始参数列表 - - 添加 ``parser`` 参数后, 可以自动处理消息并将结果保存在 ``state["args"]`` 中。 + 添加 ``parser`` 参数后, 可以自动处理消息并将结果保存在 ``state["args"]`` 中。 :参数: @@ -488,9 +470,7 @@ class RegexRule: def regex(regex: str, flags: Union[int, re.RegexFlag] = 0) -> Rule: r""" - :说明: - - 根据正则表达式进行匹配。 + 根据正则表达式进行匹配。 可以通过 ``state["_matched"]`` ``state["_matched_groups"]`` ``state["_matched_dict"]`` 获取正则表达式匹配成功的文本。 @@ -515,9 +495,7 @@ class ToMeRule: def to_me() -> Rule: """ - :说明: - - 通过 ``event.is_tome()`` 判断事件是否与机器人有关 + 通过 ``event.is_tome()`` 判断事件是否与机器人有关 :参数: diff --git a/nonebot/typing.py b/nonebot/typing.py index 759ac861..dfc253b4 100644 --- a/nonebot/typing.py +++ b/nonebot/typing.py @@ -47,36 +47,26 @@ def overrides(InterfaceClass: object): T_State = Dict[Any, Any] """ -:说明: - - 事件处理状态 State 类型 +事件处理状态 State 类型 """ T_BotConnectionHook = Callable[["Bot"], Awaitable[None]] """ -:说明: - - Bot 连接建立时执行的函数 +Bot 连接建立时执行的函数 """ T_BotDisconnectionHook = Callable[["Bot"], Awaitable[None]] """ -:说明: - - Bot 连接断开时执行的函数 +Bot 连接断开时执行的函数 """ T_CallingAPIHook = Callable[["Bot", str, Dict[str, Any]], Awaitable[None]] """ -:说明: - - ``bot.call_api`` 时执行的函数 +``bot.call_api`` 时执行的函数 """ T_CalledAPIHook = Callable[ ["Bot", Optional[Exception], str, Dict[str, Any], Any], Awaitable[None] ] """ -:说明: - - ``bot.call_api`` 后执行的函数，参数分别为 bot, exception, api, data, result +``bot.call_api`` 后执行的函数，参数分别为 bot, exception, api, data, result """ T_EventPreProcessor = Callable[..., Union[None, Awaitable[None]]] @@ -89,9 +79,7 @@ T_EventPreProcessor = Callable[..., Union[None, Awaitable[None]]] * ``StateParam``: State 对象 * ``DefaultParam``: 带有默认值的参数 -:说明: - - 事件预处理函数 EventPreProcessor 类型 +事件预处理函数 EventPreProcessor 类型 """ T_EventPostProcessor = Callable[..., Union[None, Awaitable[None]]] """ @@ -103,9 +91,7 @@ T_EventPostProcessor = Callable[..., Union[None, Awaitable[None]]] * ``StateParam``: State 对象 * ``DefaultParam``: 带有默认值的参数 -:说明: - - 事件预处理函数 EventPostProcessor 类型 +事件预处理函数 EventPostProcessor 类型 """ T_RunPreProcessor = Callable[..., Union[None, Awaitable[None]]] """ @@ -118,9 +104,7 @@ T_RunPreProcessor = Callable[..., Union[None, Awaitable[None]]] * ``MatcherParam``: Matcher 对象 * ``DefaultParam``: 带有默认值的参数 -:说明: - - 事件响应器运行前预处理函数 RunPreProcessor 类型 +事件响应器运行前预处理函数 RunPreProcessor 类型 """ T_RunPostProcessor = Callable[..., Union[None, Awaitable[None]]] """ @@ -134,9 +118,7 @@ T_RunPostProcessor = Callable[..., Union[None, Awaitable[None]]] * ``ExceptionParam``: 异常对象（可能为 None） * ``DefaultParam``: 带有默认值的参数 -:说明: - - 事件响应器运行前预处理函数 RunPostProcessor 类型，第二个参数为运行时产生的错误（如果存在） +事件响应器运行前预处理函数 RunPostProcessor 类型，第二个参数为运行时产生的错误（如果存在） """ T_RuleChecker = Callable[..., Union[bool, Awaitable[bool]]] @@ -149,9 +131,7 @@ T_RuleChecker = Callable[..., Union[bool, Awaitable[bool]]] * ``StateParam``: State 对象 * ``DefaultParam``: 带有默认值的参数 -:说明: - - RuleChecker 即判断是否响应事件的处理函数。 +RuleChecker 即判断是否响应事件的处理函数。 """ T_PermissionChecker = Callable[..., Union[bool, Awaitable[bool]]] """ @@ -162,16 +142,12 @@ T_PermissionChecker = Callable[..., Union[bool, Awaitable[bool]]] * ``EventParam``: Event 对象 * ``DefaultParam``: 带有默认值的参数 -:说明: - - RuleChecker 即判断是否响应消息的处理函数。 +RuleChecker 即判断是否响应消息的处理函数。 """ T_Handler = Callable[..., Any] """ -:说明: - - Handler 处理函数。 +Handler 处理函数。 """ T_TypeUpdater = Callable[..., Union[str, Awaitable[str]]] """ @@ -184,9 +160,7 @@ T_TypeUpdater = Callable[..., Union[str, Awaitable[str]]] * ``MatcherParam``: Matcher 对象 * ``DefaultParam``: 带有默认值的参数 -:说明: - - TypeUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新响应的事件类型。默认会更新为 ``message``。 +TypeUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新响应的事件类型。默认会更新为 ``message``。 """ T_PermissionUpdater = Callable[..., Union["Permission", Awaitable["Permission"]]] """ @@ -199,12 +173,9 @@ T_PermissionUpdater = Callable[..., Union["Permission", Awaitable["Permission"]] * ``MatcherParam``: Matcher 对象 * ``DefaultParam``: 带有默认值的参数 -:说明: - - PermissionUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新会话对象权限。默认会更新为当前事件的触发对象。 +PermissionUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新会话对象权限。默认会更新为当前事件的触发对象。 """ T_DependencyCache = Dict[Callable[..., Any], "Task[Any]"] """ -:说明: - 依赖缓存, 用于存储依赖函数的返回值 +依赖缓存, 用于存储依赖函数的返回值 """ diff --git a/nonebot/utils.py b/nonebot/utils.py index da03d690..066ca467 100644 --- a/nonebot/utils.py +++ b/nonebot/utils.py @@ -31,9 +31,7 @@ V = TypeVar("V") def escape_tag(s: str) -> str: """ - :说明: - - 用于记录带颜色日志时转义 ```` 类型特殊标签 + 用于记录带颜色日志时转义 ```` 类型特殊标签 :参数: @@ -90,9 +88,7 @@ def is_async_gen_callable(call: Callable[..., Any]) -> bool: def run_sync(call: Callable[P, R]) -> Callable[P, Awaitable[R]]: """ - :说明: - - 一个用于包装 sync function 为 async function 的装饰器 + 一个用于包装 sync function 为 async function 的装饰器 :参数: @@ -135,9 +131,7 @@ def get_name(obj: Any) -> str: class DataclassEncoder(json.JSONEncoder): """ - :说明: - - 在JSON序列化 ``Message`` (List[Dataclass]) 时使用的 ``JSONEncoder`` + 在JSON序列化 ``Message`` (List[Dataclass]) 时使用的 ``JSONEncoder`` """ @overrides(json.JSONEncoder) @@ -149,9 +143,7 @@ class DataclassEncoder(json.JSONEncoder): def logger_wrapper(logger_name: str): """ - :说明: - - 用于打印 adapter 的日志。 + 用于打印 adapter 的日志。 :log 参数: From 4ba1a09fb71be1bf7dfa0a366d0b117826d1f66f Mon Sep 17 00:00:00 2001 From: hemengyang Date: Wed, 12 Jan 2022 18:19:21 +0800 Subject: [PATCH 04/14] =?UTF-8?q?=E4=BD=BF=E7=94=A8=20markdown=20=E6=A0=BC?= =?UTF-8?q?=E5=BC=8F=E7=9A=84=E5=BC=BA=E8=B0=83=E8=AF=AD=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- nonebot/__init__.py | 86 +++---- nonebot/adapters/__init__.py | 2 +- nonebot/adapters/_adapter.py | 6 +- nonebot/adapters/_bot.py | 30 +-- nonebot/adapters/_event.py | 26 +- nonebot/adapters/_message.py | 14 +- nonebot/adapters/_template.py | 4 +- nonebot/config.py | 16 +- nonebot/drivers/__init__.py | 18 +- nonebot/drivers/_block_driver.py | 6 +- nonebot/drivers/fastapi.py | 16 +- nonebot/drivers/quart.py | 8 +- nonebot/exception.py | 38 +-- nonebot/log.py | 4 +- nonebot/matcher.py | 92 +++---- nonebot/message.py | 4 +- nonebot/params.py | 4 +- nonebot/permission.py | 34 +-- nonebot/plugin/export.py | 2 +- nonebot/plugin/load.py | 48 ++-- nonebot/plugin/on.py | 428 +++++++++++++++---------------- nonebot/plugin/plugin.py | 8 +- nonebot/rule.py | 66 ++--- nonebot/typing.py | 94 +++---- nonebot/utils.py | 18 +- 25 files changed, 536 insertions(+), 536 deletions(-) diff --git a/nonebot/__init__.py b/nonebot/__init__.py index 93aef863..610dc749 100644 --- a/nonebot/__init__.py +++ b/nonebot/__init__.py @@ -2,31 +2,31 @@ 快捷导入 ======== -为方便使用，``nonebot`` 模块从子模块导入了部分内容 +为方便使用，`nonebot` 模块从子模块导入了部分内容 -- ``on_message`` => ``nonebot.plugin.on_message`` -- ``on_notice`` => ``nonebot.plugin.on_notice`` -- ``on_request`` => ``nonebot.plugin.on_request`` -- ``on_metaevent`` => ``nonebot.plugin.on_metaevent`` -- ``on_startswith`` => ``nonebot.plugin.on_startswith`` -- ``on_endswith`` => ``nonebot.plugin.on_endswith`` -- ``on_keyword`` => ``nonebot.plugin.on_keyword`` -- ``on_command`` => ``nonebot.plugin.on_command`` -- ``on_shell_command`` => ``nonebot.plugin.on_shell_command`` -- ``on_regex`` => ``nonebot.plugin.on_regex`` -- ``CommandGroup`` => ``nonebot.plugin.CommandGroup`` -- ``Matchergroup`` => ``nonebot.plugin.MatcherGroup`` -- ``load_plugin`` => ``nonebot.plugin.load_plugin`` -- ``load_plugins`` => ``nonebot.plugin.load_plugins`` -- ``load_all_plugins`` => ``nonebot.plugin.load_all_plugins`` -- ``load_from_json`` => ``nonebot.plugin.load_from_json`` -- ``load_from_toml`` => ``nonebot.plugin.load_from_toml`` -- ``load_builtin_plugin`` => ``nonebot.plugin.load_builtin_plugin`` -- ``load_builtin_plugins`` => ``nonebot.plugin.load_builtin_plugins`` -- ``get_plugin`` => ``nonebot.plugin.get_plugin`` -- ``get_loaded_plugins`` => ``nonebot.plugin.get_loaded_plugins`` -- ``export`` => ``nonebot.plugin.export`` -- ``require`` => ``nonebot.plugin.require`` +- `on_message` => `nonebot.plugin.on_message` +- `on_notice` => `nonebot.plugin.on_notice` +- `on_request` => `nonebot.plugin.on_request` +- `on_metaevent` => `nonebot.plugin.on_metaevent` +- `on_startswith` => `nonebot.plugin.on_startswith` +- `on_endswith` => `nonebot.plugin.on_endswith` +- `on_keyword` => `nonebot.plugin.on_keyword` +- `on_command` => `nonebot.plugin.on_command` +- `on_shell_command` => `nonebot.plugin.on_shell_command` +- `on_regex` => `nonebot.plugin.on_regex` +- `CommandGroup` => `nonebot.plugin.CommandGroup` +- `Matchergroup` => `nonebot.plugin.MatcherGroup` +- `load_plugin` => `nonebot.plugin.load_plugin` +- `load_plugins` => `nonebot.plugin.load_plugins` +- `load_all_plugins` => `nonebot.plugin.load_all_plugins` +- `load_from_json` => `nonebot.plugin.load_from_json` +- `load_from_toml` => `nonebot.plugin.load_from_toml` +- `load_builtin_plugin` => `nonebot.plugin.load_builtin_plugin` +- `load_builtin_plugins` => `nonebot.plugin.load_builtin_plugins` +- `get_plugin` => `nonebot.plugin.get_plugin` +- `get_loaded_plugins` => `nonebot.plugin.get_loaded_plugins` +- `export` => `nonebot.plugin.export` +- `require` => `nonebot.plugin.require` """ import importlib @@ -57,11 +57,11 @@ def get_driver() -> Driver: :返回: - * ``Driver``: 全局 Driver 对象 + * `Driver`: 全局 Driver 对象 :异常: - * ``ValueError``: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) + * `ValueError`: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) :用法: @@ -81,11 +81,11 @@ def get_app() -> Any: :返回: - * ``Any``: Server App 对象 + * `Any`: Server App 对象 :异常: - * ``ValueError``: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) + * `ValueError`: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) :用法: @@ -107,11 +107,11 @@ def get_asgi() -> Any: :返回: - * ``Any``: Asgi 对象 + * `Any`: Asgi 对象 :异常: - * ``ValueError``: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) + * `ValueError`: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) :用法: @@ -133,17 +133,17 @@ def get_bot(self_id: Optional[str] = None) -> Bot: :参数: - * ``self_id: Optional[str]``: 用来识别 Bot 的 ID + * `self_id: Optional[str]`: 用来识别 Bot 的 ID :返回: - * ``Bot``: Bot 对象 + * `Bot`: Bot 对象 :异常: - * ``KeyError``: 对应 ID 的 Bot 不存在 - * ``ValueError``: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) - * ``ValueError``: 没有传入 ID 且没有 Bot 可用 + * `KeyError`: 对应 ID 的 Bot 不存在 + * `ValueError`: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) + * `ValueError`: 没有传入 ID 且没有 Bot 可用 :用法: @@ -169,11 +169,11 @@ def get_bots() -> Dict[str, Bot]: :返回: - * ``Dict[str, Bot]``: 一个以字符串 ID 为键，Bot 对象为值的字典 + * `Dict[str, Bot]`: 一个以字符串 ID 为键，Bot 对象为值的字典 :异常: - * ``ValueError``: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) + * `ValueError`: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) :用法: @@ -227,12 +227,12 @@ def init(*, _env_file: Optional[str] = None, **kwargs): :参数: - * ``_env_file: Optional[str]``: 配置文件名，默认从 .env.{env_name} 中读取配置 - * ``**kwargs``: 任意变量，将会存储到 Config 对象里 + * `_env_file: Optional[str]`: 配置文件名，默认从 .env.{env_name} 中读取配置 + * `**kwargs`: 任意变量，将会存储到 Config 对象里 :返回: - - ``None`` + - `None` :用法: @@ -269,12 +269,12 @@ def run(*args: Any, **kwargs: Any) -> None: :参数: - * ``*args``: 传入 Driver.run 的位置参数 - * ``**kwargs``: 传入 Driver.run 的命名参数 + * `*args`: 传入 Driver.run 的位置参数 + * `**kwargs`: 传入 Driver.run 的命名参数 :返回: - - ``None`` + - `None` :用法: diff --git a/nonebot/adapters/__init__.py b/nonebot/adapters/__init__.py index 2bae9974..ce520462 100644 --- a/nonebot/adapters/__init__.py +++ b/nonebot/adapters/__init__.py @@ -2,7 +2,7 @@ 协议适配基类 ============ -各协议请继承以下基类，并使用 ``driver.register_adapter`` 注册适配器 +各协议请继承以下基类，并使用 `driver.register_adapter` 注册适配器 """ from typing import Iterable diff --git a/nonebot/adapters/_adapter.py b/nonebot/adapters/_adapter.py index 4977db80..5927a9a6 100644 --- a/nonebot/adapters/_adapter.py +++ b/nonebot/adapters/_adapter.py @@ -63,11 +63,11 @@ class Adapter(abc.ABC): @abc.abstractmethod async def _call_api(self, bot: Bot, api: str, **data) -> Any: """ - ``adapter`` 实际调用 api 的逻辑实现函数，实现该方法以调用 api。 + `adapter` 实际调用 api 的逻辑实现函数，实现该方法以调用 api。 :参数: - * ``api: str``: API 名称 - * ``**data``: API 数据 + * `api: str`: API 名称 + * `**data`: API 数据 """ raise NotImplementedError diff --git a/nonebot/adapters/_bot.py b/nonebot/adapters/_bot.py index 145cecb9..1cd8920d 100644 --- a/nonebot/adapters/_bot.py +++ b/nonebot/adapters/_bot.py @@ -38,8 +38,8 @@ class Bot(abc.ABC): """ :参数: - * ``self_id: str``: 机器人 ID - * ``request: HTTPConnection``: request 连接对象 + * `self_id: str`: 机器人 ID + * `request: HTTPConnection`: request 连接对象 """ self.adapter: "Adapter" = adapter self.self_id: str = self_id @@ -62,8 +62,8 @@ class Bot(abc.ABC): :参数: - * ``api: str``: API 名称 - * ``**data``: API 数据 + * `api: str`: API 名称 + * `**data`: API 数据 :示例: @@ -131,9 +131,9 @@ class Bot(abc.ABC): :参数: - * ``event: Event``: 上报事件 - * ``message: Union[str, Message, MessageSegment]``: 要发送的消息 - * ``**kwargs`` + * `event: Event`: 上报事件 + * `message: Union[str, Message, MessageSegment]`: 要发送的消息 + * `**kwargs` """ raise NotImplementedError @@ -144,9 +144,9 @@ class Bot(abc.ABC): :参数: - * ``bot: Bot``: 当前 bot 对象 - * ``api: str``: 调用的 api 名称 - * ``data: Dict[str, Any]``: api 调用的参数字典 + * `bot: Bot`: 当前 bot 对象 + * `api: str`: 调用的 api 名称 + * `data: Dict[str, Any]`: api 调用的参数字典 """ cls._calling_api_hook.add(func) return func @@ -158,11 +158,11 @@ class Bot(abc.ABC): :参数: - * ``bot: Bot``: 当前 bot 对象 - * ``exception: Optional[Exception]``: 调用 api 时发生的错误 - * ``api: str``: 调用的 api 名称 - * ``data: Dict[str, Any]``: api 调用的参数字典 - * ``result: Any``: api 调用的返回 + * `bot: Bot`: 当前 bot 对象 + * `exception: Optional[Exception]`: 调用 api 时发生的错误 + * `api: str`: 调用的 api 名称 + * `data: Dict[str, Any]`: api 调用的参数字典 + * `result: Any`: api 调用的返回 """ cls._called_api_hook.add(func) return func diff --git a/nonebot/adapters/_event.py b/nonebot/adapters/_event.py index 75b04367..eae1ab43 100644 --- a/nonebot/adapters/_event.py +++ b/nonebot/adapters/_event.py @@ -20,8 +20,8 @@ class Event(abc.ABC, BaseModel): :返回: - * ``Literal["message", "notice", "request", "meta_event"]`` - * 其他自定义 ``str`` + * `Literal["message", "notice", "request", "meta_event"]` + * 其他自定义 `str` """ raise NotImplementedError @@ -32,7 +32,7 @@ class Event(abc.ABC, BaseModel): :返回: - * ``str`` + * `str` """ raise NotImplementedError @@ -43,7 +43,7 @@ class Event(abc.ABC, BaseModel): :返回: - * ``str`` + * `str` """ raise NotImplementedError @@ -52,15 +52,15 @@ class Event(abc.ABC, BaseModel): def get_log_string(self) -> str: """ - 获取事件日志信息的方法，通常你不需要修改这个方法，只有当希望 NoneBot 隐藏该事件日志时，可以抛出 ``NoLogException`` 异常。 + 获取事件日志信息的方法，通常你不需要修改这个方法，只有当希望 NoneBot 隐藏该事件日志时，可以抛出 `NoLogException` 异常。 :返回: - * ``str`` + * `str` :异常: - - ``NoLogException`` + - `NoLogException` """ return f"[{self.get_event_name()}]: {self.get_event_description()}" @@ -71,7 +71,7 @@ class Event(abc.ABC, BaseModel): :返回: - * ``str`` + * `str` """ raise NotImplementedError @@ -82,7 +82,7 @@ class Event(abc.ABC, BaseModel): :返回: - * ``str`` + * `str` """ raise NotImplementedError @@ -93,17 +93,17 @@ class Event(abc.ABC, BaseModel): :返回: - * ``Message`` + * `Message` """ raise NotImplementedError def get_plaintext(self) -> str: """ - 获取消息纯文本的方法，通常不需要修改，默认通过 ``get_message().extract_plain_text`` 获取。 + 获取消息纯文本的方法，通常不需要修改，默认通过 `get_message().extract_plain_text` 获取。 :返回: - * ``str`` + * `str` """ return self.get_message().extract_plain_text() @@ -114,6 +114,6 @@ class Event(abc.ABC, BaseModel): :返回: - * ``bool`` + * `bool` """ raise NotImplementedError diff --git a/nonebot/adapters/_message.py b/nonebot/adapters/_message.py index 02628415..cf386bb8 100644 --- a/nonebot/adapters/_message.py +++ b/nonebot/adapters/_message.py @@ -99,7 +99,7 @@ class Message(List[TMS], abc.ABC): """ :参数: - * ``message: Union[str, list, dict, MessageSegment, Message, Any]``: 消息内容 + * `message: Union[str, list, dict, MessageSegment, Message, Any]`: 消息内容 """ super().__init__(*args, **kwargs) if message is None: @@ -114,9 +114,9 @@ class Message(List[TMS], abc.ABC): @classmethod def template(cls: Type[TM], format_string: Union[str, TM]) -> MessageTemplate[TM]: """ - 根据创建消息模板, 用法和 ``str.format`` 大致相同, 但是可以输出消息对象, 并且支持以 ``Message`` 对象作为消息模板 + 根据创建消息模板, 用法和 `str.format` 大致相同, 但是可以输出消息对象, 并且支持以 `Message` 对象作为消息模板 - 并且提供了拓展的格式化控制符, 可以用适用于该消息类型的 ``MessageSegment`` 的工厂方法创建消息 + 并且提供了拓展的格式化控制符, 可以用适用于该消息类型的 `MessageSegment` 的工厂方法创建消息 :示例: @@ -137,11 +137,11 @@ class Message(List[TMS], abc.ABC): :参数: - * ``format_string: str``: 格式化字符串 + * `format_string: str`: 格式化字符串 :返回: - - ``MessageFormatter[TM]``: 消息格式化器 + - `MessageFormatter[TM]`: 消息格式化器 """ return MessageTemplate(format_string, cls) @@ -190,7 +190,7 @@ class Message(List[TMS], abc.ABC): :参数: - * ``obj: Union[str, MessageSegment]``: 要添加的消息段 + * `obj: Union[str, MessageSegment]`: 要添加的消息段 """ if isinstance(obj, MessageSegment): super(Message, self).append(obj) @@ -206,7 +206,7 @@ class Message(List[TMS], abc.ABC): :参数: - * ``obj: Union[Message, Iterable[MessageSegment]]``: 要添加的消息数组 + * `obj: Union[Message, Iterable[MessageSegment]]`: 要添加的消息数组 """ for segment in obj: self.append(segment) diff --git a/nonebot/adapters/_template.py b/nonebot/adapters/_template.py index 4326fe42..9782b2a1 100644 --- a/nonebot/adapters/_template.py +++ b/nonebot/adapters/_template.py @@ -51,8 +51,8 @@ class MessageTemplate(Formatter, Generic[TF]): :参数: - * ``template: Union[str, Message]``: 模板 - * ``factory: Union[str, Message]``: 消息构造类型，默认为 `str` + * `template: Union[str, Message]`: 模板 + * `factory: Union[str, Message]`: 消息构造类型，默认为 `str` """ self.template: TF = template self.factory: Type[TF] = factory diff --git a/nonebot/config.py b/nonebot/config.py index 7e99979d..b7fbfc04 100644 --- a/nonebot/config.py +++ b/nonebot/config.py @@ -132,12 +132,12 @@ class Env(BaseConfig): """ 运行环境配置。大小写不敏感。 - 将会从 ``nonebot.init 参数`` > ``环境变量`` > ``.env 环境配置文件`` 的优先级读取配置。 + 将会从 `nonebot.init 参数` > `环境变量` > `.env 环境配置文件` 的优先级读取配置。 """ environment: str = "prod" """ - 当前环境名。 NoneBot 将从 ``.env.{environment}`` 文件中加载配置。 + 当前环境名。 NoneBot 将从 `.env.{environment}` 文件中加载配置。 """ class Config: @@ -149,8 +149,8 @@ class Config(BaseConfig): """ NoneBot 主要配置。大小写不敏感。 - 除了 NoneBot 的配置项外，还可以自行添加配置项到 ``.env.{environment}`` 文件中。 - 这些配置将会在 json 反序列化后一起带入 ``Config`` 类中。 + 除了 NoneBot 的配置项外，还可以自行添加配置项到 `.env.{environment}` 文件中。 + 这些配置将会在 json 反序列化后一起带入 `Config` 类中。 """ _common_config: dict @@ -159,11 +159,11 @@ class Config(BaseConfig): # nonebot configs driver: str = "~fastapi" """ - NoneBot 运行所使用的 ``Driver`` 。继承自 ``nonebot.drivers.Driver`` 。 + NoneBot 运行所使用的 `Driver` 。继承自 `nonebot.drivers.Driver` 。 - 配置格式为 ``[:][+[:]]*``。 + 配置格式为 `[:][+[:]]*`。 - ``~`` 为 ``nonebot.drivers.`` 的缩写。 + `~` 为 `nonebot.drivers.` 的缩写。 """ host: IPvAnyAddress = IPv4Address("127.0.0.1") # type: ignore """ @@ -175,7 +175,7 @@ class Config(BaseConfig): """ log_level: Union[int, str] = "INFO" """ - 配置 NoneBot 日志输出等级，可以为 ``int`` 类型等级或等级名称，参考 `loguru 日志等级`_。 + 配置 NoneBot 日志输出等级，可以为 `int` 类型等级或等级名称，参考 `loguru 日志等级`_。 :示例: diff --git a/nonebot/drivers/__init__.py b/nonebot/drivers/__init__.py index 7b93fae0..9b237ec3 100644 --- a/nonebot/drivers/__init__.py +++ b/nonebot/drivers/__init__.py @@ -56,8 +56,8 @@ class Driver(abc.ABC): """ :参数: - * ``env: Env``: 包含环境信息的 Env 对象 - * ``config: Config``: 包含配置信息的 Config 对象 + * `env: Env`: 包含环境信息的 Env 对象 + * `config: Config`: 包含配置信息的 Config 对象 """ self.env: str = env.environment """ @@ -85,9 +85,9 @@ class Driver(abc.ABC): :参数: - * ``name: str``: 适配器名称，用于在连接时进行识别 - * ``adapter: Type[Bot]``: 适配器 Class - * ``**kwargs``: 其他传递给适配器的参数 + * `name: str`: 适配器名称，用于在连接时进行识别 + * `adapter: Type[Bot]`: 适配器 Class + * `**kwargs`: 其他传递给适配器的参数 """ name = adapter.get_name() if name in self._adapters: @@ -118,8 +118,8 @@ class Driver(abc.ABC): 启动驱动框架 :参数: - * ``*args`` - * ``**kwargs`` + * `*args` + * `**kwargs` """ logger.opt(colors=True).debug( f"Loaded adapters: {escape_tag(', '.join(self._adapters))}" @@ -141,7 +141,7 @@ class Driver(abc.ABC): :函数参数: - * ``bot: Bot``: 当前连接上的 Bot 对象 + * `bot: Bot`: 当前连接上的 Bot 对象 """ self._bot_connection_hook.add(func) return func @@ -152,7 +152,7 @@ class Driver(abc.ABC): :函数参数: - * ``bot: Bot``: 当前连接上的 Bot 对象 + * `bot: Bot`: 当前连接上的 Bot 对象 """ self._bot_disconnection_hook.add(func) return func diff --git a/nonebot/drivers/_block_driver.py b/nonebot/drivers/_block_driver.py index 33a019e8..3ac6eaba 100644 --- a/nonebot/drivers/_block_driver.py +++ b/nonebot/drivers/_block_driver.py @@ -27,7 +27,7 @@ class BlockDriver(Driver): @property @overrides(Driver) def type(self) -> str: - """驱动名称: ``block_driver``""" + """驱动名称: `block_driver`""" return "block_driver" @property @@ -43,7 +43,7 @@ class BlockDriver(Driver): :参数: - * ``func: Callable[[], Awaitable[None]]`` + * `func: Callable[[], Awaitable[None]]` """ self.startup_funcs.add(func) return func @@ -55,7 +55,7 @@ class BlockDriver(Driver): :参数: - * ``func: Callable[[], Awaitable[None]]`` + * `func: Callable[[], Awaitable[None]]` """ self.shutdown_funcs.add(func) return func diff --git a/nonebot/drivers/fastapi.py b/nonebot/drivers/fastapi.py index 47e1eb46..f7b1f603 100644 --- a/nonebot/drivers/fastapi.py +++ b/nonebot/drivers/fastapi.py @@ -48,19 +48,19 @@ class Config(BaseSettings): fastapi_openapi_url: Optional[str] = None """ - ``openapi.json`` 地址，默认为 ``None`` 即关闭 + `openapi.json` 地址，默认为 `None` 即关闭 """ fastapi_docs_url: Optional[str] = None """ - ``swagger`` 地址，默认为 ``None`` 即关闭 + `swagger` 地址，默认为 `None` 即关闭 """ fastapi_redoc_url: Optional[str] = None """ - ``redoc`` 地址，默认为 ``None`` 即关闭 + `redoc` 地址，默认为 `None` 即关闭 """ fastapi_include_adapter_schema: bool = True """ - 是否包含适配器路由的 schema，默认为 ``True`` + 是否包含适配器路由的 schema，默认为 `True` """ fastapi_reload: bool = False """ @@ -104,19 +104,19 @@ class Driver(ReverseDriver): @property @overrides(ReverseDriver) def type(self) -> str: - """驱动名称: ``fastapi``""" + """驱动名称: `fastapi`""" return "fastapi" @property @overrides(ReverseDriver) def server_app(self) -> FastAPI: - """``FastAPI APP`` 对象""" + """`FastAPI APP` 对象""" return self._server_app @property @overrides(ReverseDriver) def asgi(self) -> FastAPI: - """``FastAPI APP`` 对象""" + """`FastAPI APP` 对象""" return self._server_app @property @@ -168,7 +168,7 @@ class Driver(ReverseDriver): app: Optional[str] = None, **kwargs, ): - """使用 ``uvicorn`` 启动 FastAPI""" + """使用 `uvicorn` 启动 FastAPI""" super().run(host, port, app, **kwargs) LOGGING_CONFIG = { "version": 1, diff --git a/nonebot/drivers/quart.py b/nonebot/drivers/quart.py index f2e979eb..c1936ac2 100644 --- a/nonebot/drivers/quart.py +++ b/nonebot/drivers/quart.py @@ -94,19 +94,19 @@ class Driver(ReverseDriver): @property @overrides(ReverseDriver) def type(self) -> str: - """驱动名称: ``quart``""" + """驱动名称: `quart`""" return "quart" @property @overrides(ReverseDriver) def server_app(self) -> Quart: - """``Quart`` 对象""" + """`Quart` 对象""" return self._server_app @property @overrides(ReverseDriver) def asgi(self): - """``Quart`` 对象""" + """`Quart` 对象""" return self._server_app @property @@ -161,7 +161,7 @@ class Driver(ReverseDriver): app: Optional[str] = None, **kwargs, ): - """使用 ``uvicorn`` 启动 Quart""" + """使用 `uvicorn` 启动 Quart""" super().run(host, port, app, **kwargs) LOGGING_CONFIG = { "version": 1, diff --git a/nonebot/exception.py b/nonebot/exception.py index 4cc887ab..ab402038 100644 --- a/nonebot/exception.py +++ b/nonebot/exception.py @@ -20,12 +20,12 @@ class NoneBotException(Exception): # Rule Exception class ParserExit(NoneBotException): """ - ``shell command`` 处理消息失败时返回的异常 + `shell command` 处理消息失败时返回的异常 :参数: - * ``status`` - * ``message`` + * `status` + * `message` """ def __init__(self, status: int = 0, message: Optional[str] = None): @@ -52,7 +52,7 @@ class IgnoredException(ProcessException): :参数: - * ``reason``: 忽略事件的原因 + * `reason`: 忽略事件的原因 """ def __init__(self, reason): @@ -71,7 +71,7 @@ class MockApiException(ProcessException): :参数: - * ``result``: 返回的内容 + * `result`: 返回的内容 """ def __init__(self, result: Any): @@ -90,7 +90,7 @@ class StopPropagation(ProcessException): :用法: - 在 ``Matcher.block == True`` 时抛出。 + 在 `Matcher.block == True` 时抛出。 """ @@ -103,17 +103,17 @@ class MatcherException(NoneBotException): class SkippedException(MatcherException): """ - 指示 NoneBot 立即结束当前 ``Handler`` 的处理，继续处理下一个 ``Handler``。 + 指示 NoneBot 立即结束当前 `Handler` 的处理，继续处理下一个 `Handler`。 :用法: - 可以在 ``Handler`` 中通过 ``Matcher.skip()`` 抛出。 + 可以在 `Handler` 中通过 `Matcher.skip()` 抛出。 """ class TypeMisMatch(SkippedException): """ - 当前 ``Handler`` 的参数类型不匹配。 + 当前 `Handler` 的参数类型不匹配。 """ def __init__(self, param: ModelField, value: Any): @@ -129,45 +129,45 @@ class TypeMisMatch(SkippedException): class PausedException(MatcherException): """ - 指示 NoneBot 结束当前 ``Handler`` 并等待下一条消息后继续下一个 ``Handler``。 + 指示 NoneBot 结束当前 `Handler` 并等待下一条消息后继续下一个 `Handler`。 可用于用户输入新信息。 :用法: - 可以在 ``Handler`` 中通过 ``Matcher.pause()`` 抛出。 + 可以在 `Handler` 中通过 `Matcher.pause()` 抛出。 """ class RejectedException(MatcherException): """ - 指示 NoneBot 结束当前 ``Handler`` 并等待下一条消息后重新运行当前 ``Handler``。 + 指示 NoneBot 结束当前 `Handler` 并等待下一条消息后重新运行当前 `Handler`。 可用于用户重新输入。 :用法: - 可以在 ``Handler`` 中通过 ``Matcher.reject()`` 抛出。 + 可以在 `Handler` 中通过 `Matcher.reject()` 抛出。 """ class FinishedException(MatcherException): """ - 指示 NoneBot 结束当前 ``Handler`` 且后续 ``Handler`` 不再被运行。 + 指示 NoneBot 结束当前 `Handler` 且后续 `Handler` 不再被运行。 可用于结束用户会话。 :用法: - 可以在 ``Handler`` 中通过 ``Matcher.finish()`` 抛出。 + 可以在 `Handler` 中通过 `Matcher.finish()` 抛出。 """ # Adapter Exceptions class AdapterException(NoneBotException): """ - 代表 ``Adapter`` 抛出的异常，所有的 ``Adapter`` 都要在内部继承自这个 ``Exception`` + 代表 `Adapter` 抛出的异常，所有的 `Adapter` 都要在内部继承自这个 `Exception` :参数: - * ``adapter_name: str``: 标识 adapter + * `adapter_name: str`: 标识 adapter """ def __init__(self, adapter_name: str) -> None: @@ -176,7 +176,7 @@ class AdapterException(NoneBotException): class NoLogException(AdapterException): """ - 指示 NoneBot 对当前 ``Event`` 进行处理但不显示 Log 信息，可在 ``get_log_string`` 时抛出 + 指示 NoneBot 对当前 `Event` 进行处理但不显示 Log 信息，可在 `get_log_string` 时抛出 """ pass @@ -209,7 +209,7 @@ class ActionFailed(AdapterException): # Driver Exceptions class DriverException(NoneBotException): """ - ``Driver`` 抛出的异常基类 + `Driver` 抛出的异常基类 """ diff --git a/nonebot/log.py b/nonebot/log.py index cb8ef370..30ef16c6 100644 --- a/nonebot/log.py +++ b/nonebot/log.py @@ -28,8 +28,8 @@ NoneBot 日志记录器对象。 :默认信息: - * 格式: ``[%(asctime)s %(name)s] %(levelname)s: %(message)s`` - * 等级: ``INFO`` ，根据 ``config.log_level`` 配置改变 + * 格式: `[%(asctime)s %(name)s] %(levelname)s: %(message)s` + * 等级: `INFO` ，根据 `config.log_level` 配置改变 * 输出: 输出至 stdout :用法: diff --git a/nonebot/matcher.py b/nonebot/matcher.py index f7f27796..37de185a 100644 --- a/nonebot/matcher.py +++ b/nonebot/matcher.py @@ -214,21 +214,21 @@ class Matcher(metaclass=MatcherMeta): :参数: - * ``type_: str``: 事件响应器类型，与 ``event.get_type()`` 一致时触发，空字符串表示任意 - * ``rule: Optional[Rule]``: 匹配规则 - * ``permission: Optional[Permission]``: 权限 - * ``handlers: Optional[List[T_Handler]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器，即触发一次后删除 - * ``priority: int``: 响应优先级 - * ``block: bool``: 是否阻止事件向更低优先级的响应器传播 - * ``plugin: Optional[Plugin]``: 事件响应器所在插件 - * ``module: Optional[ModuleType]``: 事件响应器所在模块 - * ``default_state: Optional[T_State]``: 默认状态 ``state`` - * ``expire_time: Optional[datetime]``: 事件响应器最终有效时间点，过时即被删除 + * `type_: str`: 事件响应器类型，与 `event.get_type()` 一致时触发，空字符串表示任意 + * `rule: Optional[Rule]`: 匹配规则 + * `permission: Optional[Permission]`: 权限 + * `handlers: Optional[List[T_Handler]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器，即触发一次后删除 + * `priority: int`: 响应优先级 + * `block: bool`: 是否阻止事件向更低优先级的响应器传播 + * `plugin: Optional[Plugin]`: 事件响应器所在插件 + * `module: Optional[ModuleType]`: 事件响应器所在模块 + * `default_state: Optional[T_State]`: 默认状态 `state` + * `expire_time: Optional[datetime]`: 事件响应器最终有效时间点，过时即被删除 :返回: - - ``Type[Matcher]``: 新的事件响应器类 + - `Type[Matcher]`: 新的事件响应器类 """ NewMatcher = type( "Matcher", @@ -280,12 +280,12 @@ class Matcher(metaclass=MatcherMeta): :参数: - * ``bot: Bot``: Bot 对象 - * ``event: Event``: 上报事件 + * `bot: Bot`: Bot 对象 + * `event: Event`: 上报事件 :返回: - - ``bool``: 是否满足权限 + - `bool`: 是否满足权限 """ event_type = event.get_type() return event_type == (cls.type or event_type) and await cls.permission( @@ -306,13 +306,13 @@ class Matcher(metaclass=MatcherMeta): :参数: - * ``bot: Bot``: Bot 对象 - * ``event: Event``: 上报事件 - * ``state: T_State``: 当前状态 + * `bot: Bot`: Bot 对象 + * `event: Event`: 上报事件 + * `state: T_State`: 当前状态 :返回: - - ``bool``: 是否满足匹配规则 + - `bool`: 是否满足匹配规则 """ event_type = event.get_type() return event_type == (cls.type or event_type) and await cls.rule( @@ -326,7 +326,7 @@ class Matcher(metaclass=MatcherMeta): :参数: - * ``func: T_TypeUpdater``: 响应事件类型更新函数 + * `func: T_TypeUpdater`: 响应事件类型更新函数 """ cls._default_type_updater = Dependent[str].parse( call=func, allow_types=cls.HANDLER_PARAM_TYPES @@ -340,7 +340,7 @@ class Matcher(metaclass=MatcherMeta): :参数: - * ``func: T_PermissionUpdater``: 会话权限更新函数 + * `func: T_PermissionUpdater`: 会话权限更新函数 """ cls._default_permission_updater = Dependent[Permission].parse( call=func, allow_types=cls.HANDLER_PARAM_TYPES @@ -368,7 +368,7 @@ class Matcher(metaclass=MatcherMeta): :参数: - * ``parameterless: Optional[List[Any]]``: 非参数类型依赖列表 + * `parameterless: Optional[List[Any]]`: 非参数类型依赖列表 """ def _decorator(func: T_Handler) -> T_Handler: @@ -386,8 +386,8 @@ class Matcher(metaclass=MatcherMeta): :参数: - * ``id: str``: 消息 ID - * ``parameterless: Optional[List[Any]]``: 非参数类型依赖列表 + * `id: str`: 消息 ID + * `parameterless: Optional[List[Any]]`: 非参数类型依赖列表 """ async def _receive(event: Event, matcher: "Matcher") -> Union[None, NoReturn]: @@ -422,14 +422,14 @@ class Matcher(metaclass=MatcherMeta): parameterless: Optional[List[Any]] = None, ) -> Callable[[T_Handler], T_Handler]: """ - 装饰一个函数来指示 NoneBot 当要获取的 ``key`` 不存在时接收用户新的一条消息并经过 ``ArgsParser`` 处理后再运行该函数，如果 ``key`` 已存在则直接继续运行 + 装饰一个函数来指示 NoneBot 当要获取的 `key` 不存在时接收用户新的一条消息并经过 `ArgsParser` 处理后再运行该函数，如果 `key` 已存在则直接继续运行 :参数: - * ``key: str``: 参数名 - * ``prompt: Optional[Union[str, Message, MessageSegment, MessageFormatter]]``: 在参数不存在时向用户发送的消息 - * ``args_parser: Optional[T_ArgsParser]``: 可选参数解析函数，空则使用默认解析函数 - * ``parameterless: Optional[List[Any]]``: 非参数类型依赖列表 + * `key: str`: 参数名 + * `prompt: Optional[Union[str, Message, MessageSegment, MessageFormatter]]`: 在参数不存在时向用户发送的消息 + * `args_parser: Optional[T_ArgsParser]`: 可选参数解析函数，空则使用默认解析函数 + * `parameterless: Optional[List[Any]]`: 非参数类型依赖列表 """ async def _key_getter(event: Event, matcher: "Matcher"): @@ -470,8 +470,8 @@ class Matcher(metaclass=MatcherMeta): :参数: - * ``message: Union[str, Message, MessageSegment]``: 消息内容 - * ``**kwargs``: 其他传递给 ``bot.send`` 的参数，请参考对应 adapter 的 bot 对象 api + * `message: Union[str, Message, MessageSegment]`: 消息内容 + * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ bot = current_bot.get() event = current_event.get() @@ -493,8 +493,8 @@ class Matcher(metaclass=MatcherMeta): :参数: - * ``message: Union[str, Message, MessageSegment, MessageTemplate]``: 消息内容 - * ``**kwargs``: 其他传递给 ``bot.send`` 的参数，请参考对应 adapter 的 bot 对象 api + * `message: Union[str, Message, MessageSegment, MessageTemplate]`: 消息内容 + * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ if message is not None: await cls.send(message, **kwargs) @@ -511,8 +511,8 @@ class Matcher(metaclass=MatcherMeta): :参数: - * ``prompt: Union[str, Message, MessageSegment, MessageTemplate]``: 消息内容 - * ``**kwargs``: 其他传递给 ``bot.send`` 的参数，请参考对应 adapter 的 bot 对象 api + * `prompt: Union[str, Message, MessageSegment, MessageTemplate]`: 消息内容 + * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ if prompt is not None: await cls.send(prompt, **kwargs) @@ -525,12 +525,12 @@ class Matcher(metaclass=MatcherMeta): **kwargs, ) -> NoReturn: """ - 最近使用 ``got`` / ``receive`` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 + 最近使用 `got` / `receive` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 :参数: - * ``prompt: Union[str, Message, MessageSegment, MessageTemplate]``: 消息内容 - * ``**kwargs``: 其他传递给 ``bot.send`` 的参数，请参考对应 adapter 的 bot 对象 api + * `prompt: Union[str, Message, MessageSegment, MessageTemplate]`: 消息内容 + * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ if prompt is not None: await cls.send(prompt, **kwargs) @@ -544,13 +544,13 @@ class Matcher(metaclass=MatcherMeta): **kwargs, ) -> NoReturn: """ - 最近使用 ``got`` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 + 最近使用 `got` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 :参数: - * ``key: str``: 参数名 - * ``prompt: Union[str, Message, MessageSegment, MessageTemplate]``: 消息内容 - * ``**kwargs``: 其他传递给 ``bot.send`` 的参数，请参考对应 adapter 的 bot 对象 api + * `key: str`: 参数名 + * `prompt: Union[str, Message, MessageSegment, MessageTemplate]`: 消息内容 + * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ matcher = current_matcher.get() matcher.set_target(ARG_KEY.format(key=key)) @@ -566,13 +566,13 @@ class Matcher(metaclass=MatcherMeta): **kwargs, ) -> NoReturn: """ - 最近使用 ``got`` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 + 最近使用 `got` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 :参数: - * ``id: str``: 消息 id - * ``prompt: Union[str, Message, MessageSegment, MessageTemplate]``: 消息内容 - * ``**kwargs``: 其他传递给 ``bot.send`` 的参数，请参考对应 adapter 的 bot 对象 api + * `id: str`: 消息 id + * `prompt: Union[str, Message, MessageSegment, MessageTemplate]`: 消息内容 + * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ matcher = current_matcher.get() matcher.set_target(RECEIVE_KEY.format(id=id)) diff --git a/nonebot/message.py b/nonebot/message.py index de976570..7f825470 100644 --- a/nonebot/message.py +++ b/nonebot/message.py @@ -238,8 +238,8 @@ async def handle_event(bot: "Bot", event: "Event") -> None: :参数: - * ``bot: Bot``: Bot 对象 - * ``event: Event``: Event 对象 + * `bot: Bot`: Bot 对象 + * `event: Event`: Event 对象 :示例: diff --git a/nonebot/params.py b/nonebot/params.py index 63dfaa39..25ad7aa4 100644 --- a/nonebot/params.py +++ b/nonebot/params.py @@ -60,8 +60,8 @@ def Depends( :参数: - * ``dependency: Optional[Callable[..., Any]] = None``: 依赖函数。默认为参数的类型注释。 - * ``use_cache: bool = True``: 是否使用缓存。默认为 ``True``。 + * `dependency: Optional[Callable[..., Any]] = None`: 依赖函数。默认为参数的类型注释。 + * `use_cache: bool = True`: 是否使用缓存。默认为 `True`。 .. code-block:: python diff --git a/nonebot/permission.py b/nonebot/permission.py index 6adf6b8d..2e2b98c2 100644 --- a/nonebot/permission.py +++ b/nonebot/permission.py @@ -2,10 +2,10 @@ r""" 权限 ==== -每个 ``Matcher`` 拥有一个 ``Permission`` ，其中是 ``PermissionChecker`` 的集合，只要有一个 ``PermissionChecker`` 检查结果为 ``True`` 时就会继续运行。 +每个 `Matcher` 拥有一个 `Permission` ，其中是 `PermissionChecker` 的集合，只要有一个 `PermissionChecker` 检查结果为 `True` 时就会继续运行。 \:\:\:tip 提示 -``PermissionChecker`` 既可以是 async function 也可以是 sync function +`PermissionChecker` 既可以是 async function 也可以是 sync function \:\:\: """ @@ -35,7 +35,7 @@ async def _run_coro_with_catch(coro: Coroutine[Any, Any, Any]): class Permission: """ - ``Matcher`` 规则类，当事件传递时，在 ``Matcher`` 运行前进行检查。 + `Matcher` 规则类，当事件传递时，在 `Matcher` 运行前进行检查。 :示例: @@ -60,7 +60,7 @@ class Permission: """ :参数: - * ``*checkers: Union[T_PermissionChecker, Dependent[bool]``: PermissionChecker + * `*checkers: Union[T_PermissionChecker, Dependent[bool]`: PermissionChecker """ self.checkers: Set[Dependent[bool]] = set( @@ -72,7 +72,7 @@ class Permission: for checker in checkers ) """ - 存储 ``PermissionChecker`` + 存储 `PermissionChecker` """ async def __call__( @@ -87,14 +87,14 @@ class Permission: :参数: - * ``bot: Bot``: Bot 对象 - * ``event: Event``: Event 对象 - * ``stack: Optional[AsyncExitStack]``: 异步上下文栈 - * ``dependency_cache: Optional[CacheDict[T_Handler, Any]]``: 依赖缓存 + * `bot: Bot`: Bot 对象 + * `event: Event`: Event 对象 + * `stack: Optional[AsyncExitStack]`: 异步上下文栈 + * `dependency_cache: Optional[CacheDict[T_Handler, Any]]`: 依赖缓存 :返回: - - ``bool`` + - `bool` """ if not self.checkers: return True @@ -149,19 +149,19 @@ class MetaEvent: MESSAGE = Permission(Message()) """ -匹配任意 ``message`` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 message type 的 Matcher。 +匹配任意 `message` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 message type 的 Matcher。 """ NOTICE = Permission(Notice()) """ -匹配任意 ``notice`` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 notice type 的 Matcher。 +匹配任意 `notice` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 notice type 的 Matcher。 """ REQUEST = Permission(Request()) """ -匹配任意 ``request`` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 request type 的 Matcher。 +匹配任意 `request` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 request type 的 Matcher。 """ METAEVENT = Permission(MetaEvent()) """ -匹配任意 ``meta_event`` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 meta_event type 的 Matcher。 +匹配任意 `meta_event` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 meta_event type 的 Matcher。 """ @@ -181,12 +181,12 @@ class User: def USER(*users: str, perm: Optional[Permission] = None): """ - ``event`` 的 ``session_id`` 在白名单内且满足 perm + `event` 的 `session_id` 在白名单内且满足 perm :参数: - * ``*user: str``: 白名单 - * ``perm: Optional[Permission]``: 需要同时满足的权限 + * `*user: str`: 白名单 + * `perm: Optional[Permission]`: 需要同时满足的权限 """ return Permission(User(users, perm)) diff --git a/nonebot/plugin/export.py b/nonebot/plugin/export.py index f7bf5a80..83e494cd 100644 --- a/nonebot/plugin/export.py +++ b/nonebot/plugin/export.py @@ -48,7 +48,7 @@ def export() -> Export: :返回: - - ``Export`` + - `Export` """ plugin = _current_plugin.get() if not plugin: diff --git a/nonebot/plugin/load.py b/nonebot/plugin/load.py index ef6c1059..d182ca91 100644 --- a/nonebot/plugin/load.py +++ b/nonebot/plugin/load.py @@ -12,15 +12,15 @@ from .plugin import Plugin, get_plugin def load_plugin(module_path: str) -> Optional[Plugin]: """ - 使用 ``PluginManager`` 加载单个插件，可以是本地插件或是通过 ``pip`` 安装的插件。 + 使用 `PluginManager` 加载单个插件，可以是本地插件或是通过 `pip` 安装的插件。 :参数: - * ``module_path: str``: 插件名称 ``path.to.your.plugin`` + * `module_path: str`: 插件名称 `path.to.your.plugin` :返回: - - ``Optional[Plugin]`` + - `Optional[Plugin]` """ manager = PluginManager([module_path]) @@ -30,15 +30,15 @@ def load_plugin(module_path: str) -> Optional[Plugin]: def load_plugins(*plugin_dir: str) -> Set[Plugin]: """ - 导入目录下多个插件，以 ``_`` 开头的插件不会被导入！ + 导入目录下多个插件，以 `_` 开头的插件不会被导入！ :参数: - - ``*plugin_dir: str``: 插件路径 + - `*plugin_dir: str`: 插件路径 :返回: - - ``Set[Plugin]`` + - `Set[Plugin]` """ manager = PluginManager(search_path=plugin_dir) _managers.append(manager) @@ -49,16 +49,16 @@ def load_all_plugins( module_path: Iterable[str], plugin_dir: Iterable[str] ) -> Set[Plugin]: """ - 导入指定列表中的插件以及指定目录下多个插件，以 ``_`` 开头的插件不会被导入！ + 导入指定列表中的插件以及指定目录下多个插件，以 `_` 开头的插件不会被导入！ :参数: - - ``module_path: Iterable[str]``: 指定插件集合 - - ``plugin_dir: Iterable[str]``: 指定插件路径集合 + - `module_path: Iterable[str]`: 指定插件集合 + - `plugin_dir: Iterable[str]`: 指定插件路径集合 :返回: - - ``Set[Plugin]`` + - `Set[Plugin]` """ manager = PluginManager(module_path, plugin_dir) _managers.append(manager) @@ -67,16 +67,16 @@ def load_all_plugins( def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]: """ - 导入指定 json 文件中的 ``plugins`` 以及 ``plugin_dirs`` 下多个插件，以 ``_`` 开头的插件不会被导入！ + 导入指定 json 文件中的 `plugins` 以及 `plugin_dirs` 下多个插件，以 `_` 开头的插件不会被导入！ :参数: - - ``file_path: str``: 指定 json 文件路径 - - ``encoding: str``: 指定 json 文件编码 + - `file_path: str`: 指定 json 文件路径 + - `encoding: str`: 指定 json 文件编码 :返回: - - ``Set[Plugin]`` + - `Set[Plugin]` """ with open(file_path, "r", encoding=encoding) as f: data = json.load(f) @@ -89,17 +89,17 @@ def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]: def load_from_toml(file_path: str, encoding: str = "utf-8") -> Set[Plugin]: """ - 导入指定 toml 文件 ``[tool.nonebot]`` 中的 ``plugins`` 以及 ``plugin_dirs`` 下多个插件， - 以 ``_`` 开头的插件不会被导入！ + 导入指定 toml 文件 `[tool.nonebot]` 中的 `plugins` 以及 `plugin_dirs` 下多个插件， + 以 `_` 开头的插件不会被导入！ :参数: - - ``file_path: str``: 指定 toml 文件路径 - - ``encoding: str``: 指定 toml 文件编码 + - `file_path: str`: 指定 toml 文件路径 + - `encoding: str`: 指定 toml 文件编码 :返回: - - ``Set[Plugin]`` + - `Set[Plugin]` """ with open(file_path, "r", encoding=encoding) as f: data = tomlkit.parse(f.read()) # type: ignore @@ -127,7 +127,7 @@ def load_builtin_plugin(name: str) -> Optional[Plugin]: :返回: - - ``Plugin`` + - `Plugin` """ return load_plugin(f"nonebot.plugins.{name}") @@ -138,7 +138,7 @@ def load_builtin_plugins(*plugins) -> Set[Plugin]: :返回: - - ``Set[Plugin]`` + - `Set[Plugin]` """ return load_all_plugins([f"nonebot.plugins.{p}" for p in plugins], []) @@ -149,14 +149,14 @@ def require(name: str) -> Export: :参数: - * ``name: str``: 插件名，与 ``load_plugin`` 参数一致。如果为 ``load_plugins`` 导入的插件，则为文件(夹)名。 + * `name: str`: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。 :返回: - - ``Export`` + - `Export` :异常: - - ``RuntimeError``: 插件无法加载 + - `RuntimeError`: 插件无法加载 """ plugin = get_plugin(name) or load_plugin(name) if not plugin: diff --git a/nonebot/plugin/on.py b/nonebot/plugin/on.py index 1319584c..bf34a60f 100644 --- a/nonebot/plugin/on.py +++ b/nonebot/plugin/on.py @@ -59,18 +59,18 @@ def on( :参数: - * ``type: str``: 事件响应器类型 - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `type: str`: 事件响应器类型 + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ matcher = Matcher.new( type, @@ -103,16 +103,16 @@ def on_metaevent( :参数: - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ matcher = Matcher.new( "meta_event", @@ -146,17 +146,17 @@ def on_message( :参数: - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ matcher = Matcher.new( "message", @@ -189,16 +189,16 @@ def on_notice( :参数: - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ matcher = Matcher.new( "notice", @@ -231,16 +231,16 @@ def on_request( :参数: - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ matcher = Matcher.new( "request", @@ -270,19 +270,19 @@ def on_startswith( :参数: - * ``msg: Union[str, Tuple[str, ...]]``: 指定消息开头内容 - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``ignorecase: bool``: 是否忽略大小写 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `msg: Union[str, Tuple[str, ...]]`: 指定消息开头内容 + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `ignorecase: bool`: 是否忽略大小写 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ return on_message(startswith(msg, ignorecase) & rule, **kwargs, _depth=_depth + 1) @@ -299,19 +299,19 @@ def on_endswith( :参数: - * ``msg: Union[str, Tuple[str, ...]]``: 指定消息结尾内容 - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``ignorecase: bool``: 是否忽略大小写 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `msg: Union[str, Tuple[str, ...]]`: 指定消息结尾内容 + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `ignorecase: bool`: 是否忽略大小写 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ return on_message(endswith(msg, ignorecase) & rule, **kwargs, _depth=_depth + 1) @@ -327,18 +327,18 @@ def on_keyword( :参数: - * ``keywords: Set[str]``: 关键词列表 - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `keywords: Set[str]`: 关键词列表 + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ return on_message(keyword(*keywords) & rule, **kwargs, _depth=_depth + 1) @@ -357,19 +357,19 @@ def on_command( :参数: - * ``cmd: Union[str, Tuple[str, ...]]``: 指定命令内容 - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``aliases: Optional[Set[Union[str, Tuple[str, ...]]]]``: 命令别名 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `cmd: Union[str, Tuple[str, ...]]`: 指定命令内容 + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `aliases: Optional[Set[Union[str, Tuple[str, ...]]]]`: 命令别名 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ commands = set([cmd]) | (aliases or set()) @@ -388,28 +388,28 @@ def on_shell_command( **kwargs, ) -> Type[Matcher]: """ - 注册一个支持 ``shell_like`` 解析参数的命令消息事件响应器。 + 注册一个支持 `shell_like` 解析参数的命令消息事件响应器。 - 与普通的 ``on_command`` 不同的是，在添加 ``parser`` 参数时, 响应器会自动处理消息。 + 与普通的 `on_command` 不同的是，在添加 `parser` 参数时, 响应器会自动处理消息。 - 并将用户输入的原始参数列表保存在 ``state["argv"]``, ``parser`` 处理的参数保存在 ``state["args"]`` 中 + 并将用户输入的原始参数列表保存在 `state["argv"]`, `parser` 处理的参数保存在 `state["args"]` 中 :参数: - * ``cmd: Union[str, Tuple[str, ...]]``: 指定命令内容 - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``aliases: Optional[Set[Union[str, Tuple[str, ...]]]]``: 命令别名 - * ``parser: Optional[ArgumentParser]``: ``nonebot.rule.ArgumentParser`` 对象 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `cmd: Union[str, Tuple[str, ...]]`: 指定命令内容 + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `aliases: Optional[Set[Union[str, Tuple[str, ...]]]]`: 命令别名 + * `parser: Optional[ArgumentParser]`: `nonebot.rule.ArgumentParser` 对象 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ commands = set([cmd]) | (aliases or set()) @@ -434,19 +434,19 @@ def on_regex( :参数: - * ``pattern: str``: 正则表达式 - * ``flags: Union[int, re.RegexFlag]``: 正则匹配标志 - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `pattern: str`: 正则表达式 + * `flags: Union[int, re.RegexFlag]`: 正则匹配标志 + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ return on_message(regex(pattern, flags) & rule, **kwargs, _depth=_depth + 1) @@ -458,8 +458,8 @@ class CommandGroup: """ :参数: - * ``cmd: Union[str, Tuple[str, ...]]``: 命令前缀 - * ``**kwargs``: 其他传递给 ``on_command`` 的参数默认值，参考 `on_command <#on-command-cmd-rule-none-aliases-none-kwargs>`_ + * `cmd: Union[str, Tuple[str, ...]]`: 命令前缀 + * `**kwargs`: 其他传递给 `on_command` 的参数默认值，参考 `on_command <#on-command-cmd-rule-none-aliases-none-kwargs>`_ """ self.basecmd: Tuple[str, ...] = (cmd,) if isinstance(cmd, str) else cmd """ @@ -469,7 +469,7 @@ class CommandGroup: del kwargs["aliases"] self.base_kwargs: Dict[str, Any] = kwargs """ - 其他传递给 ``on_command`` 的参数默认值 + 其他传递给 `on_command` 的参数默认值 """ def command(self, cmd: Union[str, Tuple[str, ...]], **kwargs) -> Type[Matcher]: @@ -478,12 +478,12 @@ class CommandGroup: :参数: - * ``cmd: Union[str, Tuple[str, ...]]``: 命令前缀 - * ``**kwargs``: 其他传递给 ``on_command`` 的参数，将会覆盖命令组默认值 + * `cmd: Union[str, Tuple[str, ...]]`: 命令前缀 + * `**kwargs`: 其他传递给 `on_command` 的参数，将会覆盖命令组默认值 :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ sub_cmd = (cmd,) if isinstance(cmd, str) else cmd cmd = self.basecmd + sub_cmd @@ -500,12 +500,12 @@ class CommandGroup: :参数: - * ``cmd: Union[str, Tuple[str, ...]]``: 命令前缀 - * ``**kwargs``: 其他传递给 ``on_shell_command`` 的参数，将会覆盖命令组默认值 + * `cmd: Union[str, Tuple[str, ...]]`: 命令前缀 + * `**kwargs`: 其他传递给 `on_shell_command` 的参数，将会覆盖命令组默认值 :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ sub_cmd = (cmd,) if isinstance(cmd, str) else cmd cmd = self.basecmd + sub_cmd @@ -516,11 +516,11 @@ class CommandGroup: class MatcherGroup: - """事件响应器组合，统一管理。为 ``Matcher`` 创建提供默认属性。""" + """事件响应器组合，统一管理。为 `Matcher` 创建提供默认属性。""" def __init__(self, **kwargs): """ - 创建一个事件响应器组合，参数为默认值，与 ``on`` 一致 + 创建一个事件响应器组合，参数为默认值，与 `on` 一致 """ self.matchers: List[Type[Matcher]] = [] """ @@ -528,7 +528,7 @@ class MatcherGroup: """ self.base_kwargs: Dict[str, Any] = kwargs """ - 其他传递给 ``on`` 的参数默认值 + 其他传递给 `on` 的参数默认值 """ def on(self, **kwargs) -> Type[Matcher]: @@ -537,18 +537,18 @@ class MatcherGroup: :参数: - * ``type: str``: 事件响应器类型 - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `type: str`: 事件响应器类型 + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -562,16 +562,16 @@ class MatcherGroup: :参数: - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -587,17 +587,17 @@ class MatcherGroup: :参数: - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -612,16 +612,16 @@ class MatcherGroup: :参数: - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -636,16 +636,16 @@ class MatcherGroup: :参数: - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -662,19 +662,19 @@ class MatcherGroup: :参数: - * ``msg: Union[str, Tuple[str, ...]]``: 指定消息开头内容 - * ``ignorecase: bool``: 是否忽略大小写 - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `msg: Union[str, Tuple[str, ...]]`: 指定消息开头内容 + * `ignorecase: bool`: 是否忽略大小写 + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -689,19 +689,19 @@ class MatcherGroup: :参数: - * ``msg: Union[str, Tuple[str, ...]]``: 指定消息结尾内容 - * ``ignorecase: bool``: 是否忽略大小写 - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `msg: Union[str, Tuple[str, ...]]`: 指定消息结尾内容 + * `ignorecase: bool`: 是否忽略大小写 + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -716,18 +716,18 @@ class MatcherGroup: :参数: - * ``keywords: Set[str]``: 关键词列表 - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `keywords: Set[str]`: 关键词列表 + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -749,19 +749,19 @@ class MatcherGroup: :参数: - * ``cmd: Union[str, Tuple[str, ...]]``: 指定命令内容 - * ``aliases: Optional[Set[Union[str, Tuple[str, ...]]]]``: 命令别名 - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `cmd: Union[str, Tuple[str, ...]]`: 指定命令内容 + * `aliases: Optional[Set[Union[str, Tuple[str, ...]]]]`: 命令别名 + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -778,28 +778,28 @@ class MatcherGroup: **kwargs, ) -> Type[Matcher]: """ - 注册一个支持 ``shell_like`` 解析参数的命令消息事件响应器。 + 注册一个支持 `shell_like` 解析参数的命令消息事件响应器。 - 与普通的 ``on_command`` 不同的是，在添加 ``parser`` 参数时, 响应器会自动处理消息。 + 与普通的 `on_command` 不同的是，在添加 `parser` 参数时, 响应器会自动处理消息。 - 并将用户输入的原始参数列表保存在 ``state["argv"]``, ``parser`` 处理的参数保存在 ``state["args"]`` 中 + 并将用户输入的原始参数列表保存在 `state["argv"]`, `parser` 处理的参数保存在 `state["args"]` 中 :参数: - * ``cmd: Union[str, Tuple[str, ...]]``: 指定命令内容 - * ``aliases: Optional[Set[Union[str, Tuple[str, ...]]]]``: 命令别名 - * ``parser: Optional[ArgumentParser]``: ``nonebot.rule.ArgumentParser`` 对象 - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `cmd: Union[str, Tuple[str, ...]]`: 指定命令内容 + * `aliases: Optional[Set[Union[str, Tuple[str, ...]]]]`: 命令别名 + * `parser: Optional[ArgumentParser]`: `nonebot.rule.ArgumentParser` 对象 + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -820,19 +820,19 @@ class MatcherGroup: :参数: - * ``pattern: str``: 正则表达式 - * ``flags: Union[int, re.RegexFlag]``: 正则匹配标志 - * ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 - * ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 - * ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 - * ``temp: bool``: 是否为临时事件响应器（仅执行一次） - * ``priority: int``: 事件响应器优先级 - * ``block: bool``: 是否阻止事件向更低优先级传递 - * ``state: Optional[T_State]``: 默认 state + * `pattern: str`: 正则表达式 + * `flags: Union[int, re.RegexFlag]`: 正则匹配标志 + * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 + * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 + * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 + * `temp: bool`: 是否为临时事件响应器（仅执行一次） + * `priority: int`: 事件响应器优先级 + * `block: bool`: 是否阻止事件向更低优先级传递 + * `state: Optional[T_State]`: 默认 state :返回: - - ``Type[Matcher]`` + - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) diff --git a/nonebot/plugin/plugin.py b/nonebot/plugin/plugin.py index d590e443..d84c1f4d 100644 --- a/nonebot/plugin/plugin.py +++ b/nonebot/plugin/plugin.py @@ -40,7 +40,7 @@ class Plugin(object): """ matcher: Set[Type[Matcher]] = field(default_factory=set) """ - 插件内定义的 ``Matcher`` + 插件内定义的 `Matcher` """ parent_plugin: Optional["Plugin"] = None """ @@ -58,11 +58,11 @@ def get_plugin(name: str) -> Optional[Plugin]: :参数: - * ``name: str``: 插件名，与 ``load_plugin`` 参数一致。如果为 ``load_plugins`` 导入的插件，则为文件(夹)名。 + * `name: str`: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。 :返回: - - ``Optional[Plugin]`` + - `Optional[Plugin]` """ return plugins.get(name) @@ -73,7 +73,7 @@ def get_loaded_plugins() -> Set[Plugin]: :返回: - - ``Set[Plugin]`` + - `Set[Plugin]` """ return set(plugins.values()) diff --git a/nonebot/rule.py b/nonebot/rule.py index 8dc5da8b..66fadd81 100644 --- a/nonebot/rule.py +++ b/nonebot/rule.py @@ -2,10 +2,10 @@ r""" 规则 ==== -每个事件响应器 ``Matcher`` 拥有一个匹配规则 ``Rule`` ，其中是 ``RuleChecker`` 的集合，只有当所有 ``RuleChecker`` 检查结果为 ``True`` 时继续运行。 +每个事件响应器 `Matcher` 拥有一个匹配规则 `Rule` ，其中是 `RuleChecker` 的集合，只有当所有 `RuleChecker` 检查结果为 `True` 时继续运行。 \:\:\:tip 提示 -``RuleChecker`` 既可以是 async function 也可以是 sync function +`RuleChecker` 既可以是 async function 也可以是 sync function \:\:\: """ @@ -63,7 +63,7 @@ CMD_RESULT = TypedDict( class Rule: """ - ``Matcher`` 规则类，当事件传递时，在 ``Matcher`` 运行前进行检查。 + `Matcher` 规则类，当事件传递时，在 `Matcher` 运行前进行检查。 :示例: @@ -89,7 +89,7 @@ class Rule: """ :参数: - * ``*checkers: Union[T_RuleChecker, Dependent[bool]]``: RuleChecker + * `*checkers: Union[T_RuleChecker, Dependent[bool]]`: RuleChecker """ self.checkers: Set[Dependent[bool]] = set( @@ -101,7 +101,7 @@ class Rule: for checker in checkers ) """ - 存储 ``RuleChecker`` + 存储 `RuleChecker` """ async def __call__( @@ -117,15 +117,15 @@ class Rule: :参数: - * ``bot: Bot``: Bot 对象 - * ``event: Event``: Event 对象 - * ``state: T_State``: 当前 State - * ``stack: Optional[AsyncExitStack]``: 异步上下文栈 - * ``dependency_cache: Optional[CacheDict[T_Handler, Any]]``: 依赖缓存 + * `bot: Bot`: Bot 对象 + * `event: Event`: Event 对象 + * `state: T_State`: 当前 State + * `stack: Optional[AsyncExitStack]`: 异步上下文栈 + * `dependency_cache: Optional[CacheDict[T_Handler, Any]]`: 依赖缓存 :返回: - - ``bool`` + - `bool` """ if not self.checkers: return True @@ -218,7 +218,7 @@ def startswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Ru :参数: - * ``msg: str``: 消息开头字符串 + * `msg: str`: 消息开头字符串 """ if isinstance(msg, str): msg = (msg,) @@ -251,7 +251,7 @@ def endswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule :参数: - * ``msg: str``: 消息结尾字符串 + * `msg: str`: 消息结尾字符串 """ if isinstance(msg, str): msg = (msg,) @@ -277,7 +277,7 @@ def keyword(*keywords: str) -> Rule: :参数: - * ``*keywords: str``: 关键词 + * `*keywords: str`: 关键词 """ return Rule(KeywordsRule(*keywords)) @@ -296,20 +296,20 @@ class CommandRule: def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule: r""" - 命令形式匹配，根据配置里提供的 ``command_start``, ``command_sep`` 判断消息是否为命令。 + 命令形式匹配，根据配置里提供的 `command_start`, `command_sep` 判断消息是否为命令。 - 可以通过 ``state["_prefix"]["command"]`` 获取匹配成功的命令（例：``("test",)``），通过 ``state["_prefix"]["raw_command"]`` 获取匹配成功的原始命令文本（例：``"/test"``）。 + 可以通过 `state["_prefix"]["command"]` 获取匹配成功的命令（例：`("test",)`），通过 `state["_prefix"]["raw_command"]` 获取匹配成功的原始命令文本（例：`"/test"`）。 :参数: - * ``*cmds: Union[str, Tuple[str, ...]]``: 命令内容 + * `*cmds: Union[str, Tuple[str, ...]]`: 命令内容 :示例: - 使用默认 ``command_start``, ``command_sep`` 配置 + 使用默认 `command_start`, `command_sep` 配置 - 命令 ``("test",)`` 可以匹配：``/test`` 开头的消息 - 命令 ``("test", "sub")`` 可以匹配”``/test.sub`` 开头的消息 + 命令 `("test",)` 可以匹配：`/test` 开头的消息 + 命令 `("test", "sub")` 可以匹配”`/test.sub` 开头的消息 \:\:\:tip 提示 命令内容与后续消息间无需空格！ @@ -338,7 +338,7 @@ def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule: class ArgumentParser(ArgParser): """ - ``shell_like`` 命令参数解析器，解析出错时不会退出程序。 + `shell_like` 命令参数解析器，解析出错时不会退出程序。 """ def _print_message(self, message, file=None): @@ -392,22 +392,22 @@ def shell_command( *cmds: Union[str, Tuple[str, ...]], parser: Optional[ArgumentParser] = None ) -> Rule: r""" - 支持 ``shell_like`` 解析参数的命令形式匹配，根据配置里提供的 ``command_start``, ``command_sep`` 判断消息是否为命令。 + 支持 `shell_like` 解析参数的命令形式匹配，根据配置里提供的 `command_start`, `command_sep` 判断消息是否为命令。 - 可以通过 ``state["_prefix"]["command"]`` 获取匹配成功的命令（例：``("test",)``），通过 ``state["_prefix"]["raw_command"]`` 获取匹配成功的原始命令文本（例：``"/test"``）。 + 可以通过 `state["_prefix"]["command"]` 获取匹配成功的命令（例：`("test",)`），通过 `state["_prefix"]["raw_command"]` 获取匹配成功的原始命令文本（例：`"/test"`）。 - 可以通过 ``state["argv"]`` 获取用户输入的原始参数列表 + 可以通过 `state["argv"]` 获取用户输入的原始参数列表 - 添加 ``parser`` 参数后, 可以自动处理消息并将结果保存在 ``state["args"]`` 中。 + 添加 `parser` 参数后, 可以自动处理消息并将结果保存在 `state["args"]` 中。 :参数: - * ``*cmds: Union[str, Tuple[str, ...]]``: 命令内容 - * ``parser: Optional[ArgumentParser]``: ``nonebot.rule.ArgumentParser`` 对象 + * `*cmds: Union[str, Tuple[str, ...]]`: 命令内容 + * `parser: Optional[ArgumentParser]`: `nonebot.rule.ArgumentParser` 对象 :示例: - 使用默认 ``command_start``, ``command_sep`` 配置，更多示例参考 ``argparse`` 标准库文档。 + 使用默认 `command_start`, `command_sep` 配置，更多示例参考 `argparse` 标准库文档。 .. code-block:: python @@ -472,16 +472,16 @@ def regex(regex: str, flags: Union[int, re.RegexFlag] = 0) -> Rule: r""" 根据正则表达式进行匹配。 - 可以通过 ``state["_matched"]`` ``state["_matched_groups"]`` ``state["_matched_dict"]`` + 可以通过 `state["_matched"]` `state["_matched_groups"]` `state["_matched_dict"]` 获取正则表达式匹配成功的文本。 :参数: - * ``regex: str``: 正则表达式 - * ``flags: Union[int, re.RegexFlag]``: 正则标志 + * `regex: str`: 正则表达式 + * `flags: Union[int, re.RegexFlag]`: 正则标志 \:\:\:tip 提示 - 正则表达式匹配使用 search 而非 match，如需从头匹配请使用 ``r"^xxx"`` 来确保匹配开头 + 正则表达式匹配使用 search 而非 match，如需从头匹配请使用 `r"^xxx"` 来确保匹配开头 \:\:\: """ @@ -495,7 +495,7 @@ class ToMeRule: def to_me() -> Rule: """ - 通过 ``event.is_tome()`` 判断事件是否与机器人有关 + 通过 `event.is_tome()` 判断事件是否与机器人有关 :参数: diff --git a/nonebot/typing.py b/nonebot/typing.py index dfc253b4..7146f576 100644 --- a/nonebot/typing.py +++ b/nonebot/typing.py @@ -60,24 +60,24 @@ Bot 连接断开时执行的函数 """ T_CallingAPIHook = Callable[["Bot", str, Dict[str, Any]], Awaitable[None]] """ -``bot.call_api`` 时执行的函数 +`bot.call_api` 时执行的函数 """ T_CalledAPIHook = Callable[ ["Bot", Optional[Exception], str, Dict[str, Any], Any], Awaitable[None] ] """ -``bot.call_api`` 后执行的函数，参数分别为 bot, exception, api, data, result +`bot.call_api` 后执行的函数，参数分别为 bot, exception, api, data, result """ T_EventPreProcessor = Callable[..., Union[None, Awaitable[None]]] """ :依赖参数: - * ``DependParam``: 子依赖参数 - * ``BotParam``: Bot 对象 - * ``EventParam``: Event 对象 - * ``StateParam``: State 对象 - * ``DefaultParam``: 带有默认值的参数 + * `DependParam`: 子依赖参数 + * `BotParam`: Bot 对象 + * `EventParam`: Event 对象 + * `StateParam`: State 对象 + * `DefaultParam`: 带有默认值的参数 事件预处理函数 EventPreProcessor 类型 """ @@ -85,11 +85,11 @@ T_EventPostProcessor = Callable[..., Union[None, Awaitable[None]]] """ :依赖参数: - * ``DependParam``: 子依赖参数 - * ``BotParam``: Bot 对象 - * ``EventParam``: Event 对象 - * ``StateParam``: State 对象 - * ``DefaultParam``: 带有默认值的参数 + * `DependParam`: 子依赖参数 + * `BotParam`: Bot 对象 + * `EventParam`: Event 对象 + * `StateParam`: State 对象 + * `DefaultParam`: 带有默认值的参数 事件预处理函数 EventPostProcessor 类型 """ @@ -97,12 +97,12 @@ T_RunPreProcessor = Callable[..., Union[None, Awaitable[None]]] """ :依赖参数: - * ``DependParam``: 子依赖参数 - * ``BotParam``: Bot 对象 - * ``EventParam``: Event 对象 - * ``StateParam``: State 对象 - * ``MatcherParam``: Matcher 对象 - * ``DefaultParam``: 带有默认值的参数 + * `DependParam`: 子依赖参数 + * `BotParam`: Bot 对象 + * `EventParam`: Event 对象 + * `StateParam`: State 对象 + * `MatcherParam`: Matcher 对象 + * `DefaultParam`: 带有默认值的参数 事件响应器运行前预处理函数 RunPreProcessor 类型 """ @@ -110,13 +110,13 @@ T_RunPostProcessor = Callable[..., Union[None, Awaitable[None]]] """ :依赖参数: - * ``DependParam``: 子依赖参数 - * ``BotParam``: Bot 对象 - * ``EventParam``: Event 对象 - * ``StateParam``: State 对象 - * ``MatcherParam``: Matcher 对象 - * ``ExceptionParam``: 异常对象（可能为 None） - * ``DefaultParam``: 带有默认值的参数 + * `DependParam`: 子依赖参数 + * `BotParam`: Bot 对象 + * `EventParam`: Event 对象 + * `StateParam`: State 对象 + * `MatcherParam`: Matcher 对象 + * `ExceptionParam`: 异常对象（可能为 None） + * `DefaultParam`: 带有默认值的参数 事件响应器运行前预处理函数 RunPostProcessor 类型，第二个参数为运行时产生的错误（如果存在） """ @@ -125,11 +125,11 @@ T_RuleChecker = Callable[..., Union[bool, Awaitable[bool]]] """ :依赖参数: - * ``DependParam``: 子依赖参数 - * ``BotParam``: Bot 对象 - * ``EventParam``: Event 对象 - * ``StateParam``: State 对象 - * ``DefaultParam``: 带有默认值的参数 + * `DependParam`: 子依赖参数 + * `BotParam`: Bot 对象 + * `EventParam`: Event 对象 + * `StateParam`: State 对象 + * `DefaultParam`: 带有默认值的参数 RuleChecker 即判断是否响应事件的处理函数。 """ @@ -137,10 +137,10 @@ T_PermissionChecker = Callable[..., Union[bool, Awaitable[bool]]] """ :依赖参数: - * ``DependParam``: 子依赖参数 - * ``BotParam``: Bot 对象 - * ``EventParam``: Event 对象 - * ``DefaultParam``: 带有默认值的参数 + * `DependParam`: 子依赖参数 + * `BotParam`: Bot 对象 + * `EventParam`: Event 对象 + * `DefaultParam`: 带有默认值的参数 RuleChecker 即判断是否响应消息的处理函数。 """ @@ -153,25 +153,25 @@ T_TypeUpdater = Callable[..., Union[str, Awaitable[str]]] """ :依赖参数: - * ``DependParam``: 子依赖参数 - * ``BotParam``: Bot 对象 - * ``EventParam``: Event 对象 - * ``StateParam``: State 对象 - * ``MatcherParam``: Matcher 对象 - * ``DefaultParam``: 带有默认值的参数 + * `DependParam`: 子依赖参数 + * `BotParam`: Bot 对象 + * `EventParam`: Event 对象 + * `StateParam`: State 对象 + * `MatcherParam`: Matcher 对象 + * `DefaultParam`: 带有默认值的参数 -TypeUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新响应的事件类型。默认会更新为 ``message``。 +TypeUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新响应的事件类型。默认会更新为 `message`。 """ T_PermissionUpdater = Callable[..., Union["Permission", Awaitable["Permission"]]] """ :依赖参数: - * ``DependParam``: 子依赖参数 - * ``BotParam``: Bot 对象 - * ``EventParam``: Event 对象 - * ``StateParam``: State 对象 - * ``MatcherParam``: Matcher 对象 - * ``DefaultParam``: 带有默认值的参数 + * `DependParam`: 子依赖参数 + * `BotParam`: Bot 对象 + * `EventParam`: Event 对象 + * `StateParam`: State 对象 + * `MatcherParam`: Matcher 对象 + * `DefaultParam`: 带有默认值的参数 PermissionUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新会话对象权限。默认会更新为当前事件的触发对象。 """ diff --git a/nonebot/utils.py b/nonebot/utils.py index 066ca467..d2acb198 100644 --- a/nonebot/utils.py +++ b/nonebot/utils.py @@ -31,15 +31,15 @@ V = TypeVar("V") def escape_tag(s: str) -> str: """ - 用于记录带颜色日志时转义 ```` 类型特殊标签 + 用于记录带颜色日志时转义 `` 类型特殊标签 :参数: - * ``s: str``: 需要转义的字符串 + * `s: str`: 需要转义的字符串 :返回: - - ``str`` + - `str` """ return re.sub(r"\s]*)>", r"\\\g<0>", s) @@ -92,11 +92,11 @@ def run_sync(call: Callable[P, R]) -> Callable[P, Awaitable[R]]: :参数: - * ``call: Callable[P, R]``: 被装饰的同步函数 + * `call: Callable[P, R]`: 被装饰的同步函数 :返回: - - ``Callable[P, Awaitable[R]]`` + - `Callable[P, Awaitable[R]]` """ @wraps(call) @@ -131,7 +131,7 @@ def get_name(obj: Any) -> str: class DataclassEncoder(json.JSONEncoder): """ - 在JSON序列化 ``Message`` (List[Dataclass]) 时使用的 ``JSONEncoder`` + 在JSON序列化 `Message` (List[Dataclass]) 时使用的 `JSONEncoder` """ @overrides(json.JSONEncoder) @@ -147,9 +147,9 @@ def logger_wrapper(logger_name: str): :log 参数: - * ``level: Literal["CRITICAL", "WARNING", "INFO", "DEBUG", "TRACE"]``: 日志等级 - * ``message: str``: 日志信息 - * ``exception: Optional[Exception]``: 异常信息 + * `level: Literal["CRITICAL", "WARNING", "INFO", "DEBUG", "TRACE"]`: 日志等级 + * `message: str`: 日志信息 + * `exception: Optional[Exception]`: 异常信息 """ def log(level: str, message: str, exception: Optional[Exception] = None): From a5f32febbd6d367d7e61948d2cdc4122a28f8ac5 Mon Sep 17 00:00:00 2001 From: hemengyang Date: Wed, 12 Jan 2022 18:25:25 +0800 Subject: [PATCH 05/14] =?UTF-8?q?=E4=BB=A4=E5=8F=82=E6=95=B0=E5=88=97?= =?UTF-8?q?=E8=A1=A8=E7=AC=A6=E5=90=88=20autodoc=20=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- nonebot/__init__.py | 34 +-- nonebot/adapters/_adapter.py | 4 +- nonebot/adapters/_bot.py | 30 +-- nonebot/adapters/_event.py | 18 +- nonebot/adapters/_message.py | 8 +- nonebot/adapters/_template.py | 4 +- nonebot/drivers/__init__.py | 18 +- nonebot/drivers/_block_driver.py | 4 +- nonebot/exception.py | 10 +- nonebot/matcher.py | 78 +++---- nonebot/message.py | 4 +- nonebot/params.py | 4 +- nonebot/permission.py | 14 +- nonebot/plugin/load.py | 4 +- nonebot/plugin/on.py | 360 +++++++++++++++---------------- nonebot/plugin/plugin.py | 2 +- nonebot/rule.py | 28 +-- nonebot/typing.py | 88 ++++---- nonebot/utils.py | 10 +- 19 files changed, 361 insertions(+), 361 deletions(-) diff --git a/nonebot/__init__.py b/nonebot/__init__.py index 610dc749..d9196f91 100644 --- a/nonebot/__init__.py +++ b/nonebot/__init__.py @@ -57,11 +57,11 @@ def get_driver() -> Driver: :返回: - * `Driver`: 全局 Driver 对象 + Driver: 全局 Driver 对象 :异常: - * `ValueError`: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) + ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) :用法: @@ -81,11 +81,11 @@ def get_app() -> Any: :返回: - * `Any`: Server App 对象 + Any: Server App 对象 :异常: - * `ValueError`: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) + ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) :用法: @@ -107,11 +107,11 @@ def get_asgi() -> Any: :返回: - * `Any`: Asgi 对象 + Any: Asgi 对象 :异常: - * `ValueError`: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) + ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) :用法: @@ -133,17 +133,17 @@ def get_bot(self_id: Optional[str] = None) -> Bot: :参数: - * `self_id: Optional[str]`: 用来识别 Bot 的 ID + self_id: 用来识别 Bot 的 ID :返回: - * `Bot`: Bot 对象 + Bot: Bot 对象 :异常: - * `KeyError`: 对应 ID 的 Bot 不存在 - * `ValueError`: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) - * `ValueError`: 没有传入 ID 且没有 Bot 可用 + KeyError: 对应 ID 的 Bot 不存在 + ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) + ValueError: 没有传入 ID 且没有 Bot 可用 :用法: @@ -169,11 +169,11 @@ def get_bots() -> Dict[str, Bot]: :返回: - * `Dict[str, Bot]`: 一个以字符串 ID 为键，Bot 对象为值的字典 + Dict[str, Bot]: 一个以字符串 ID 为键，Bot 对象为值的字典 :异常: - * `ValueError`: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) + ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) :用法: @@ -227,8 +227,8 @@ def init(*, _env_file: Optional[str] = None, **kwargs): :参数: - * `_env_file: Optional[str]`: 配置文件名，默认从 .env.{env_name} 中读取配置 - * `**kwargs`: 任意变量，将会存储到 Config 对象里 + _env_file: 配置文件名，默认从 .env.{env_name} 中读取配置 + **kwargs: 任意变量，将会存储到 Config 对象里 :返回: @@ -269,8 +269,8 @@ def run(*args: Any, **kwargs: Any) -> None: :参数: - * `*args`: 传入 Driver.run 的位置参数 - * `**kwargs`: 传入 Driver.run 的命名参数 + *args: 传入 Driver.run 的位置参数 + **kwargs: 传入 Driver.run 的命名参数 :返回: diff --git a/nonebot/adapters/_adapter.py b/nonebot/adapters/_adapter.py index 5927a9a6..38b129f0 100644 --- a/nonebot/adapters/_adapter.py +++ b/nonebot/adapters/_adapter.py @@ -67,7 +67,7 @@ class Adapter(abc.ABC): :参数: - * `api: str`: API 名称 - * `**data`: API 数据 + api: API 名称 + **data: API 数据 """ raise NotImplementedError diff --git a/nonebot/adapters/_bot.py b/nonebot/adapters/_bot.py index 1cd8920d..ee3e4193 100644 --- a/nonebot/adapters/_bot.py +++ b/nonebot/adapters/_bot.py @@ -38,8 +38,8 @@ class Bot(abc.ABC): """ :参数: - * `self_id: str`: 机器人 ID - * `request: HTTPConnection`: request 连接对象 + self_id: 机器人 ID + request: request 连接对象 """ self.adapter: "Adapter" = adapter self.self_id: str = self_id @@ -62,8 +62,8 @@ class Bot(abc.ABC): :参数: - * `api: str`: API 名称 - * `**data`: API 数据 + api: API 名称 + **data: API 数据 :示例: @@ -131,9 +131,9 @@ class Bot(abc.ABC): :参数: - * `event: Event`: 上报事件 - * `message: Union[str, Message, MessageSegment]`: 要发送的消息 - * `**kwargs` + event: 上报事件 + message: 要发送的消息 + **kwargs """ raise NotImplementedError @@ -144,9 +144,9 @@ class Bot(abc.ABC): :参数: - * `bot: Bot`: 当前 bot 对象 - * `api: str`: 调用的 api 名称 - * `data: Dict[str, Any]`: api 调用的参数字典 + bot: 当前 bot 对象 + api: 调用的 api 名称 + data: api 调用的参数字典 """ cls._calling_api_hook.add(func) return func @@ -158,11 +158,11 @@ class Bot(abc.ABC): :参数: - * `bot: Bot`: 当前 bot 对象 - * `exception: Optional[Exception]`: 调用 api 时发生的错误 - * `api: str`: 调用的 api 名称 - * `data: Dict[str, Any]`: api 调用的参数字典 - * `result: Any`: api 调用的返回 + bot: 当前 bot 对象 + exception: 调用 api 时发生的错误 + api: 调用的 api 名称 + data: api 调用的参数字典 + result: api 调用的返回 """ cls._called_api_hook.add(func) return func diff --git a/nonebot/adapters/_event.py b/nonebot/adapters/_event.py index eae1ab43..831f7947 100644 --- a/nonebot/adapters/_event.py +++ b/nonebot/adapters/_event.py @@ -20,7 +20,7 @@ class Event(abc.ABC, BaseModel): :返回: - * `Literal["message", "notice", "request", "meta_event"]` + Literal["message", "notice", "request", "meta_event"] * 其他自定义 `str` """ raise NotImplementedError @@ -32,7 +32,7 @@ class Event(abc.ABC, BaseModel): :返回: - * `str` + str """ raise NotImplementedError @@ -43,7 +43,7 @@ class Event(abc.ABC, BaseModel): :返回: - * `str` + str """ raise NotImplementedError @@ -56,7 +56,7 @@ class Event(abc.ABC, BaseModel): :返回: - * `str` + str :异常: @@ -71,7 +71,7 @@ class Event(abc.ABC, BaseModel): :返回: - * `str` + str """ raise NotImplementedError @@ -82,7 +82,7 @@ class Event(abc.ABC, BaseModel): :返回: - * `str` + str """ raise NotImplementedError @@ -93,7 +93,7 @@ class Event(abc.ABC, BaseModel): :返回: - * `Message` + Message """ raise NotImplementedError @@ -103,7 +103,7 @@ class Event(abc.ABC, BaseModel): :返回: - * `str` + str """ return self.get_message().extract_plain_text() @@ -114,6 +114,6 @@ class Event(abc.ABC, BaseModel): :返回: - * `bool` + bool """ raise NotImplementedError diff --git a/nonebot/adapters/_message.py b/nonebot/adapters/_message.py index cf386bb8..6df86ae6 100644 --- a/nonebot/adapters/_message.py +++ b/nonebot/adapters/_message.py @@ -99,7 +99,7 @@ class Message(List[TMS], abc.ABC): """ :参数: - * `message: Union[str, list, dict, MessageSegment, Message, Any]`: 消息内容 + message: 消息内容 """ super().__init__(*args, **kwargs) if message is None: @@ -137,7 +137,7 @@ class Message(List[TMS], abc.ABC): :参数: - * `format_string: str`: 格式化字符串 + format_string: 格式化字符串 :返回: @@ -190,7 +190,7 @@ class Message(List[TMS], abc.ABC): :参数: - * `obj: Union[str, MessageSegment]`: 要添加的消息段 + obj: 要添加的消息段 """ if isinstance(obj, MessageSegment): super(Message, self).append(obj) @@ -206,7 +206,7 @@ class Message(List[TMS], abc.ABC): :参数: - * `obj: Union[Message, Iterable[MessageSegment]]`: 要添加的消息数组 + obj: 要添加的消息数组 """ for segment in obj: self.append(segment) diff --git a/nonebot/adapters/_template.py b/nonebot/adapters/_template.py index 9782b2a1..5c5597e7 100644 --- a/nonebot/adapters/_template.py +++ b/nonebot/adapters/_template.py @@ -51,8 +51,8 @@ class MessageTemplate(Formatter, Generic[TF]): :参数: - * `template: Union[str, Message]`: 模板 - * `factory: Union[str, Message]`: 消息构造类型，默认为 `str` + template: 模板 + factory: 消息构造类型，默认为 `str` """ self.template: TF = template self.factory: Type[TF] = factory diff --git a/nonebot/drivers/__init__.py b/nonebot/drivers/__init__.py index 9b237ec3..4f7d7d56 100644 --- a/nonebot/drivers/__init__.py +++ b/nonebot/drivers/__init__.py @@ -56,8 +56,8 @@ class Driver(abc.ABC): """ :参数: - * `env: Env`: 包含环境信息的 Env 对象 - * `config: Config`: 包含配置信息的 Config 对象 + env: 包含环境信息的 Env 对象 + config: 包含配置信息的 Config 对象 """ self.env: str = env.environment """ @@ -85,9 +85,9 @@ class Driver(abc.ABC): :参数: - * `name: str`: 适配器名称，用于在连接时进行识别 - * `adapter: Type[Bot]`: 适配器 Class - * `**kwargs`: 其他传递给适配器的参数 + name: 适配器名称，用于在连接时进行识别 + adapter: 适配器 Class + **kwargs: 其他传递给适配器的参数 """ name = adapter.get_name() if name in self._adapters: @@ -118,8 +118,8 @@ class Driver(abc.ABC): 启动驱动框架 :参数: - * `*args` - * `**kwargs` + *args + **kwargs """ logger.opt(colors=True).debug( f"Loaded adapters: {escape_tag(', '.join(self._adapters))}" @@ -141,7 +141,7 @@ class Driver(abc.ABC): :函数参数: - * `bot: Bot`: 当前连接上的 Bot 对象 + bot: 当前连接上的 Bot 对象 """ self._bot_connection_hook.add(func) return func @@ -152,7 +152,7 @@ class Driver(abc.ABC): :函数参数: - * `bot: Bot`: 当前连接上的 Bot 对象 + bot: 当前连接上的 Bot 对象 """ self._bot_disconnection_hook.add(func) return func diff --git a/nonebot/drivers/_block_driver.py b/nonebot/drivers/_block_driver.py index 3ac6eaba..217989ce 100644 --- a/nonebot/drivers/_block_driver.py +++ b/nonebot/drivers/_block_driver.py @@ -43,7 +43,7 @@ class BlockDriver(Driver): :参数: - * `func: Callable[[], Awaitable[None]]` + func """ self.startup_funcs.add(func) return func @@ -55,7 +55,7 @@ class BlockDriver(Driver): :参数: - * `func: Callable[[], Awaitable[None]]` + func """ self.shutdown_funcs.add(func) return func diff --git a/nonebot/exception.py b/nonebot/exception.py index ab402038..28855872 100644 --- a/nonebot/exception.py +++ b/nonebot/exception.py @@ -24,8 +24,8 @@ class ParserExit(NoneBotException): :参数: - * `status` - * `message` + status + message """ def __init__(self, status: int = 0, message: Optional[str] = None): @@ -52,7 +52,7 @@ class IgnoredException(ProcessException): :参数: - * `reason`: 忽略事件的原因 + reason: 忽略事件的原因 """ def __init__(self, reason): @@ -71,7 +71,7 @@ class MockApiException(ProcessException): :参数: - * `result`: 返回的内容 + result: 返回的内容 """ def __init__(self, result: Any): @@ -167,7 +167,7 @@ class AdapterException(NoneBotException): :参数: - * `adapter_name: str`: 标识 adapter + adapter_name: 标识 adapter """ def __init__(self, adapter_name: str) -> None: diff --git a/nonebot/matcher.py b/nonebot/matcher.py index 37de185a..e724906f 100644 --- a/nonebot/matcher.py +++ b/nonebot/matcher.py @@ -214,17 +214,17 @@ class Matcher(metaclass=MatcherMeta): :参数: - * `type_: str`: 事件响应器类型，与 `event.get_type()` 一致时触发，空字符串表示任意 - * `rule: Optional[Rule]`: 匹配规则 - * `permission: Optional[Permission]`: 权限 - * `handlers: Optional[List[T_Handler]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器，即触发一次后删除 - * `priority: int`: 响应优先级 - * `block: bool`: 是否阻止事件向更低优先级的响应器传播 - * `plugin: Optional[Plugin]`: 事件响应器所在插件 - * `module: Optional[ModuleType]`: 事件响应器所在模块 - * `default_state: Optional[T_State]`: 默认状态 `state` - * `expire_time: Optional[datetime]`: 事件响应器最终有效时间点，过时即被删除 + type_: 事件响应器类型，与 `event.get_type()` 一致时触发，空字符串表示任意 + rule: 匹配规则 + permission: 权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器，即触发一次后删除 + priority: 响应优先级 + block: 是否阻止事件向更低优先级的响应器传播 + plugin: 事件响应器所在插件 + module: 事件响应器所在模块 + default_state: 默认状态 `state` + expire_time: 事件响应器最终有效时间点，过时即被删除 :返回: @@ -280,8 +280,8 @@ class Matcher(metaclass=MatcherMeta): :参数: - * `bot: Bot`: Bot 对象 - * `event: Event`: 上报事件 + bot: Bot 对象 + event: 上报事件 :返回: @@ -306,9 +306,9 @@ class Matcher(metaclass=MatcherMeta): :参数: - * `bot: Bot`: Bot 对象 - * `event: Event`: 上报事件 - * `state: T_State`: 当前状态 + bot: Bot 对象 + event: 上报事件 + state: 当前状态 :返回: @@ -326,7 +326,7 @@ class Matcher(metaclass=MatcherMeta): :参数: - * `func: T_TypeUpdater`: 响应事件类型更新函数 + func: 响应事件类型更新函数 """ cls._default_type_updater = Dependent[str].parse( call=func, allow_types=cls.HANDLER_PARAM_TYPES @@ -340,7 +340,7 @@ class Matcher(metaclass=MatcherMeta): :参数: - * `func: T_PermissionUpdater`: 会话权限更新函数 + func: 会话权限更新函数 """ cls._default_permission_updater = Dependent[Permission].parse( call=func, allow_types=cls.HANDLER_PARAM_TYPES @@ -368,7 +368,7 @@ class Matcher(metaclass=MatcherMeta): :参数: - * `parameterless: Optional[List[Any]]`: 非参数类型依赖列表 + parameterless: 非参数类型依赖列表 """ def _decorator(func: T_Handler) -> T_Handler: @@ -386,8 +386,8 @@ class Matcher(metaclass=MatcherMeta): :参数: - * `id: str`: 消息 ID - * `parameterless: Optional[List[Any]]`: 非参数类型依赖列表 + id: 消息 ID + parameterless: 非参数类型依赖列表 """ async def _receive(event: Event, matcher: "Matcher") -> Union[None, NoReturn]: @@ -426,10 +426,10 @@ class Matcher(metaclass=MatcherMeta): :参数: - * `key: str`: 参数名 - * `prompt: Optional[Union[str, Message, MessageSegment, MessageFormatter]]`: 在参数不存在时向用户发送的消息 - * `args_parser: Optional[T_ArgsParser]`: 可选参数解析函数，空则使用默认解析函数 - * `parameterless: Optional[List[Any]]`: 非参数类型依赖列表 + key: 参数名 + prompt: 在参数不存在时向用户发送的消息 + args_parser: 可选参数解析函数，空则使用默认解析函数 + parameterless: 非参数类型依赖列表 """ async def _key_getter(event: Event, matcher: "Matcher"): @@ -470,8 +470,8 @@ class Matcher(metaclass=MatcherMeta): :参数: - * `message: Union[str, Message, MessageSegment]`: 消息内容 - * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api + message: 消息内容 + **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ bot = current_bot.get() event = current_event.get() @@ -493,8 +493,8 @@ class Matcher(metaclass=MatcherMeta): :参数: - * `message: Union[str, Message, MessageSegment, MessageTemplate]`: 消息内容 - * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api + message: 消息内容 + **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ if message is not None: await cls.send(message, **kwargs) @@ -511,8 +511,8 @@ class Matcher(metaclass=MatcherMeta): :参数: - * `prompt: Union[str, Message, MessageSegment, MessageTemplate]`: 消息内容 - * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api + prompt: 消息内容 + **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ if prompt is not None: await cls.send(prompt, **kwargs) @@ -529,8 +529,8 @@ class Matcher(metaclass=MatcherMeta): :参数: - * `prompt: Union[str, Message, MessageSegment, MessageTemplate]`: 消息内容 - * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api + prompt: 消息内容 + **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ if prompt is not None: await cls.send(prompt, **kwargs) @@ -548,9 +548,9 @@ class Matcher(metaclass=MatcherMeta): :参数: - * `key: str`: 参数名 - * `prompt: Union[str, Message, MessageSegment, MessageTemplate]`: 消息内容 - * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api + key: 参数名 + prompt: 消息内容 + **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ matcher = current_matcher.get() matcher.set_target(ARG_KEY.format(key=key)) @@ -570,9 +570,9 @@ class Matcher(metaclass=MatcherMeta): :参数: - * `id: str`: 消息 id - * `prompt: Union[str, Message, MessageSegment, MessageTemplate]`: 消息内容 - * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api + id: 消息 id + prompt: 消息内容 + **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ matcher = current_matcher.get() matcher.set_target(RECEIVE_KEY.format(id=id)) diff --git a/nonebot/message.py b/nonebot/message.py index 7f825470..1990b537 100644 --- a/nonebot/message.py +++ b/nonebot/message.py @@ -238,8 +238,8 @@ async def handle_event(bot: "Bot", event: "Event") -> None: :参数: - * `bot: Bot`: Bot 对象 - * `event: Event`: Event 对象 + bot: Bot 对象 + event: Event 对象 :示例: diff --git a/nonebot/params.py b/nonebot/params.py index 25ad7aa4..6e2fe354 100644 --- a/nonebot/params.py +++ b/nonebot/params.py @@ -60,8 +60,8 @@ def Depends( :参数: - * `dependency: Optional[Callable[..., Any]] = None`: 依赖函数。默认为参数的类型注释。 - * `use_cache: bool = True`: 是否使用缓存。默认为 `True`。 + dependency: 依赖函数。默认为参数的类型注释。 + use_cache: 是否使用缓存。默认为 `True`。 .. code-block:: python diff --git a/nonebot/permission.py b/nonebot/permission.py index 2e2b98c2..c813f8bb 100644 --- a/nonebot/permission.py +++ b/nonebot/permission.py @@ -60,7 +60,7 @@ class Permission: """ :参数: - * `*checkers: Union[T_PermissionChecker, Dependent[bool]`: PermissionChecker + *checkers: PermissionChecker """ self.checkers: Set[Dependent[bool]] = set( @@ -87,10 +87,10 @@ class Permission: :参数: - * `bot: Bot`: Bot 对象 - * `event: Event`: Event 对象 - * `stack: Optional[AsyncExitStack]`: 异步上下文栈 - * `dependency_cache: Optional[CacheDict[T_Handler, Any]]`: 依赖缓存 + bot: Bot 对象 + event: Event 对象 + stack: 异步上下文栈 + dependency_cache: 依赖缓存 :返回: @@ -185,8 +185,8 @@ def USER(*users: str, perm: Optional[Permission] = None): :参数: - * `*user: str`: 白名单 - * `perm: Optional[Permission]`: 需要同时满足的权限 + *user: 白名单 + perm: 需要同时满足的权限 """ return Permission(User(users, perm)) diff --git a/nonebot/plugin/load.py b/nonebot/plugin/load.py index d182ca91..891af56d 100644 --- a/nonebot/plugin/load.py +++ b/nonebot/plugin/load.py @@ -16,7 +16,7 @@ def load_plugin(module_path: str) -> Optional[Plugin]: :参数: - * `module_path: str`: 插件名称 `path.to.your.plugin` + module_path: 插件名称 `path.to.your.plugin` :返回: @@ -149,7 +149,7 @@ def require(name: str) -> Export: :参数: - * `name: str`: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。 + name: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。 :返回: diff --git a/nonebot/plugin/on.py b/nonebot/plugin/on.py index bf34a60f..4a90f628 100644 --- a/nonebot/plugin/on.py +++ b/nonebot/plugin/on.py @@ -59,14 +59,14 @@ def on( :参数: - * `type: str`: 事件响应器类型 - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + type: 事件响应器类型 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -103,12 +103,12 @@ def on_metaevent( :参数: - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + rule: 事件响应规则 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -146,13 +146,13 @@ def on_message( :参数: - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -189,12 +189,12 @@ def on_notice( :参数: - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + rule: 事件响应规则 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -231,12 +231,12 @@ def on_request( :参数: - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + rule: 事件响应规则 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -270,15 +270,15 @@ def on_startswith( :参数: - * `msg: Union[str, Tuple[str, ...]]`: 指定消息开头内容 - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `ignorecase: bool`: 是否忽略大小写 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + msg: 指定消息开头内容 + rule: 事件响应规则 + ignorecase: 是否忽略大小写 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -299,15 +299,15 @@ def on_endswith( :参数: - * `msg: Union[str, Tuple[str, ...]]`: 指定消息结尾内容 - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `ignorecase: bool`: 是否忽略大小写 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + msg: 指定消息结尾内容 + rule: 事件响应规则 + ignorecase: 是否忽略大小写 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -327,14 +327,14 @@ def on_keyword( :参数: - * `keywords: Set[str]`: 关键词列表 - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + keywords: 关键词列表 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -357,15 +357,15 @@ def on_command( :参数: - * `cmd: Union[str, Tuple[str, ...]]`: 指定命令内容 - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `aliases: Optional[Set[Union[str, Tuple[str, ...]]]]`: 命令别名 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + cmd: 指定命令内容 + rule: 事件响应规则 + aliases: 命令别名 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -396,16 +396,16 @@ def on_shell_command( :参数: - * `cmd: Union[str, Tuple[str, ...]]`: 指定命令内容 - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `aliases: Optional[Set[Union[str, Tuple[str, ...]]]]`: 命令别名 - * `parser: Optional[ArgumentParser]`: `nonebot.rule.ArgumentParser` 对象 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + cmd: 指定命令内容 + rule: 事件响应规则 + aliases: 命令别名 + parser: `nonebot.rule.ArgumentParser` 对象 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -434,15 +434,15 @@ def on_regex( :参数: - * `pattern: str`: 正则表达式 - * `flags: Union[int, re.RegexFlag]`: 正则匹配标志 - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + pattern: 正则表达式 + flags: 正则匹配标志 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -458,8 +458,8 @@ class CommandGroup: """ :参数: - * `cmd: Union[str, Tuple[str, ...]]`: 命令前缀 - * `**kwargs`: 其他传递给 `on_command` 的参数默认值，参考 `on_command <#on-command-cmd-rule-none-aliases-none-kwargs>`_ + cmd: 命令前缀 + **kwargs`on_command` 的参数默认值，参考 `on_command <#on-command-cmd-rule-none-aliases-none-kwargs>`_ """ self.basecmd: Tuple[str, ...] = (cmd,) if isinstance(cmd, str) else cmd """ @@ -478,8 +478,8 @@ class CommandGroup: :参数: - * `cmd: Union[str, Tuple[str, ...]]`: 命令前缀 - * `**kwargs`: 其他传递给 `on_command` 的参数，将会覆盖命令组默认值 + cmd: 命令前缀 + **kwargs`on_command` 的参数，将会覆盖命令组默认值 :返回: @@ -500,8 +500,8 @@ class CommandGroup: :参数: - * `cmd: Union[str, Tuple[str, ...]]`: 命令前缀 - * `**kwargs`: 其他传递给 `on_shell_command` 的参数，将会覆盖命令组默认值 + cmd: 命令前缀 + **kwargs`on_shell_command` 的参数，将会覆盖命令组默认值 :返回: @@ -537,14 +537,14 @@ class MatcherGroup: :参数: - * `type: str`: 事件响应器类型 - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + type: 事件响应器类型 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -562,12 +562,12 @@ class MatcherGroup: :参数: - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + rule: 事件响应规则 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -587,13 +587,13 @@ class MatcherGroup: :参数: - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -612,12 +612,12 @@ class MatcherGroup: :参数: - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + rule: 事件响应规则 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -636,12 +636,12 @@ class MatcherGroup: :参数: - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + rule: 事件响应规则 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -662,15 +662,15 @@ class MatcherGroup: :参数: - * `msg: Union[str, Tuple[str, ...]]`: 指定消息开头内容 - * `ignorecase: bool`: 是否忽略大小写 - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + msg: 指定消息开头内容 + ignorecase: 是否忽略大小写 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -689,15 +689,15 @@ class MatcherGroup: :参数: - * `msg: Union[str, Tuple[str, ...]]`: 指定消息结尾内容 - * `ignorecase: bool`: 是否忽略大小写 - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + msg: 指定消息结尾内容 + ignorecase: 是否忽略大小写 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -716,14 +716,14 @@ class MatcherGroup: :参数: - * `keywords: Set[str]`: 关键词列表 - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + keywords: 关键词列表 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -749,15 +749,15 @@ class MatcherGroup: :参数: - * `cmd: Union[str, Tuple[str, ...]]`: 指定命令内容 - * `aliases: Optional[Set[Union[str, Tuple[str, ...]]]]`: 命令别名 - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + cmd: 指定命令内容 + aliases: 命令别名 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -786,16 +786,16 @@ class MatcherGroup: :参数: - * `cmd: Union[str, Tuple[str, ...]]`: 指定命令内容 - * `aliases: Optional[Set[Union[str, Tuple[str, ...]]]]`: 命令别名 - * `parser: Optional[ArgumentParser]`: `nonebot.rule.ArgumentParser` 对象 - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + cmd: 指定命令内容 + aliases: 命令别名 + parser: `nonebot.rule.ArgumentParser` 对象 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: @@ -820,15 +820,15 @@ class MatcherGroup: :参数: - * `pattern: str`: 正则表达式 - * `flags: Union[int, re.RegexFlag]`: 正则匹配标志 - * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则 - * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限 - * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表 - * `temp: bool`: 是否为临时事件响应器（仅执行一次） - * `priority: int`: 事件响应器优先级 - * `block: bool`: 是否阻止事件向更低优先级传递 - * `state: Optional[T_State]`: 默认 state + pattern: 正则表达式 + flags: 正则匹配标志 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state :返回: diff --git a/nonebot/plugin/plugin.py b/nonebot/plugin/plugin.py index d84c1f4d..79587c9b 100644 --- a/nonebot/plugin/plugin.py +++ b/nonebot/plugin/plugin.py @@ -58,7 +58,7 @@ def get_plugin(name: str) -> Optional[Plugin]: :参数: - * `name: str`: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。 + name: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。 :返回: diff --git a/nonebot/rule.py b/nonebot/rule.py index 66fadd81..81149722 100644 --- a/nonebot/rule.py +++ b/nonebot/rule.py @@ -89,7 +89,7 @@ class Rule: """ :参数: - * `*checkers: Union[T_RuleChecker, Dependent[bool]]`: RuleChecker + *checkers: RuleChecker """ self.checkers: Set[Dependent[bool]] = set( @@ -117,11 +117,11 @@ class Rule: :参数: - * `bot: Bot`: Bot 对象 - * `event: Event`: Event 对象 - * `state: T_State`: 当前 State - * `stack: Optional[AsyncExitStack]`: 异步上下文栈 - * `dependency_cache: Optional[CacheDict[T_Handler, Any]]`: 依赖缓存 + bot: Bot 对象 + event: Event 对象 + state: 当前 State + stack: 异步上下文栈 + dependency_cache: 依赖缓存 :返回: @@ -218,7 +218,7 @@ def startswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Ru :参数: - * `msg: str`: 消息开头字符串 + msg: 消息开头字符串 """ if isinstance(msg, str): msg = (msg,) @@ -251,7 +251,7 @@ def endswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule :参数: - * `msg: str`: 消息结尾字符串 + msg: 消息结尾字符串 """ if isinstance(msg, str): msg = (msg,) @@ -277,7 +277,7 @@ def keyword(*keywords: str) -> Rule: :参数: - * `*keywords: str`: 关键词 + *keywords: 关键词 """ return Rule(KeywordsRule(*keywords)) @@ -302,7 +302,7 @@ def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule: :参数: - * `*cmds: Union[str, Tuple[str, ...]]`: 命令内容 + *cmds: 命令内容 :示例: @@ -402,8 +402,8 @@ def shell_command( :参数: - * `*cmds: Union[str, Tuple[str, ...]]`: 命令内容 - * `parser: Optional[ArgumentParser]`: `nonebot.rule.ArgumentParser` 对象 + *cmds: 命令内容 + parser: `nonebot.rule.ArgumentParser` 对象 :示例: @@ -477,8 +477,8 @@ def regex(regex: str, flags: Union[int, re.RegexFlag] = 0) -> Rule: :参数: - * `regex: str`: 正则表达式 - * `flags: Union[int, re.RegexFlag]`: 正则标志 + regex: 正则表达式 + flags: 正则标志 \:\:\:tip 提示 正则表达式匹配使用 search 而非 match，如需从头匹配请使用 `r"^xxx"` 来确保匹配开头 diff --git a/nonebot/typing.py b/nonebot/typing.py index 7146f576..c9528424 100644 --- a/nonebot/typing.py +++ b/nonebot/typing.py @@ -73,11 +73,11 @@ T_EventPreProcessor = Callable[..., Union[None, Awaitable[None]]] """ :依赖参数: - * `DependParam`: 子依赖参数 - * `BotParam`: Bot 对象 - * `EventParam`: Event 对象 - * `StateParam`: State 对象 - * `DefaultParam`: 带有默认值的参数 + DependParam: 子依赖参数 + BotParam: Bot 对象 + EventParam: Event 对象 + StateParam: State 对象 + DefaultParam: 带有默认值的参数 事件预处理函数 EventPreProcessor 类型 """ @@ -85,11 +85,11 @@ T_EventPostProcessor = Callable[..., Union[None, Awaitable[None]]] """ :依赖参数: - * `DependParam`: 子依赖参数 - * `BotParam`: Bot 对象 - * `EventParam`: Event 对象 - * `StateParam`: State 对象 - * `DefaultParam`: 带有默认值的参数 + DependParam: 子依赖参数 + BotParam: Bot 对象 + EventParam: Event 对象 + StateParam: State 对象 + DefaultParam: 带有默认值的参数 事件预处理函数 EventPostProcessor 类型 """ @@ -97,12 +97,12 @@ T_RunPreProcessor = Callable[..., Union[None, Awaitable[None]]] """ :依赖参数: - * `DependParam`: 子依赖参数 - * `BotParam`: Bot 对象 - * `EventParam`: Event 对象 - * `StateParam`: State 对象 - * `MatcherParam`: Matcher 对象 - * `DefaultParam`: 带有默认值的参数 + DependParam: 子依赖参数 + BotParam: Bot 对象 + EventParam: Event 对象 + StateParam: State 对象 + MatcherParam: Matcher 对象 + DefaultParam: 带有默认值的参数 事件响应器运行前预处理函数 RunPreProcessor 类型 """ @@ -110,13 +110,13 @@ T_RunPostProcessor = Callable[..., Union[None, Awaitable[None]]] """ :依赖参数: - * `DependParam`: 子依赖参数 - * `BotParam`: Bot 对象 - * `EventParam`: Event 对象 - * `StateParam`: State 对象 - * `MatcherParam`: Matcher 对象 - * `ExceptionParam`: 异常对象（可能为 None） - * `DefaultParam`: 带有默认值的参数 + DependParam: 子依赖参数 + BotParam: Bot 对象 + EventParam: Event 对象 + StateParam: State 对象 + MatcherParam: Matcher 对象 + ExceptionParam: 异常对象（可能为 None） + DefaultParam: 带有默认值的参数 事件响应器运行前预处理函数 RunPostProcessor 类型，第二个参数为运行时产生的错误（如果存在） """ @@ -125,11 +125,11 @@ T_RuleChecker = Callable[..., Union[bool, Awaitable[bool]]] """ :依赖参数: - * `DependParam`: 子依赖参数 - * `BotParam`: Bot 对象 - * `EventParam`: Event 对象 - * `StateParam`: State 对象 - * `DefaultParam`: 带有默认值的参数 + DependParam: 子依赖参数 + BotParam: Bot 对象 + EventParam: Event 对象 + StateParam: State 对象 + DefaultParam: 带有默认值的参数 RuleChecker 即判断是否响应事件的处理函数。 """ @@ -137,10 +137,10 @@ T_PermissionChecker = Callable[..., Union[bool, Awaitable[bool]]] """ :依赖参数: - * `DependParam`: 子依赖参数 - * `BotParam`: Bot 对象 - * `EventParam`: Event 对象 - * `DefaultParam`: 带有默认值的参数 + DependParam: 子依赖参数 + BotParam: Bot 对象 + EventParam: Event 对象 + DefaultParam: 带有默认值的参数 RuleChecker 即判断是否响应消息的处理函数。 """ @@ -153,12 +153,12 @@ T_TypeUpdater = Callable[..., Union[str, Awaitable[str]]] """ :依赖参数: - * `DependParam`: 子依赖参数 - * `BotParam`: Bot 对象 - * `EventParam`: Event 对象 - * `StateParam`: State 对象 - * `MatcherParam`: Matcher 对象 - * `DefaultParam`: 带有默认值的参数 + DependParam: 子依赖参数 + BotParam: Bot 对象 + EventParam: Event 对象 + StateParam: State 对象 + MatcherParam: Matcher 对象 + DefaultParam: 带有默认值的参数 TypeUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新响应的事件类型。默认会更新为 `message`。 """ @@ -166,12 +166,12 @@ T_PermissionUpdater = Callable[..., Union["Permission", Awaitable["Permission"]] """ :依赖参数: - * `DependParam`: 子依赖参数 - * `BotParam`: Bot 对象 - * `EventParam`: Event 对象 - * `StateParam`: State 对象 - * `MatcherParam`: Matcher 对象 - * `DefaultParam`: 带有默认值的参数 + DependParam: 子依赖参数 + BotParam: Bot 对象 + EventParam: Event 对象 + StateParam: State 对象 + MatcherParam: Matcher 对象 + DefaultParam: 带有默认值的参数 PermissionUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新会话对象权限。默认会更新为当前事件的触发对象。 """ diff --git a/nonebot/utils.py b/nonebot/utils.py index d2acb198..7f38953b 100644 --- a/nonebot/utils.py +++ b/nonebot/utils.py @@ -35,7 +35,7 @@ def escape_tag(s: str) -> str: :参数: - * `s: str`: 需要转义的字符串 + s: 需要转义的字符串 :返回: @@ -92,7 +92,7 @@ def run_sync(call: Callable[P, R]) -> Callable[P, Awaitable[R]]: :参数: - * `call: Callable[P, R]`: 被装饰的同步函数 + call: 被装饰的同步函数 :返回: @@ -147,9 +147,9 @@ def logger_wrapper(logger_name: str): :log 参数: - * `level: Literal["CRITICAL", "WARNING", "INFO", "DEBUG", "TRACE"]`: 日志等级 - * `message: str`: 日志信息 - * `exception: Optional[Exception]`: 异常信息 + level: 日志等级 + message: 日志信息 + exception: 异常信息 """ def log(level: str, message: str, exception: Optional[Exception] = None): From 456d333568e41b4bef4bedd3981382e29ed386bb Mon Sep 17 00:00:00 2001 From: hemengyang Date: Wed, 12 Jan 2022 18:31:12 +0800 Subject: [PATCH 06/14] =?UTF-8?q?=E4=BB=A4=E5=8F=82=E6=95=B0=E7=AC=A6?= =?UTF-8?q?=E5=90=88=E6=A0=87=E5=87=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- nonebot/__init__.py | 9 ++-- nonebot/adapters/_adapter.py | 3 +- nonebot/adapters/_bot.py | 15 +++---- nonebot/adapters/_message.py | 12 ++--- nonebot/adapters/_template.py | 3 +- nonebot/drivers/__init__.py | 9 ++-- nonebot/drivers/_block_driver.py | 6 +-- nonebot/exception.py | 12 ++--- nonebot/matcher.py | 42 ++++++------------ nonebot/message.py | 3 +- nonebot/params.py | 3 +- nonebot/permission.py | 9 ++-- nonebot/plugin/load.py | 18 +++----- nonebot/plugin/on.py | 75 +++++++++++--------------------- nonebot/plugin/plugin.py | 3 +- nonebot/rule.py | 27 ++++-------- nonebot/utils.py | 6 +-- 17 files changed, 85 insertions(+), 170 deletions(-) diff --git a/nonebot/__init__.py b/nonebot/__init__.py index d9196f91..00c47340 100644 --- a/nonebot/__init__.py +++ b/nonebot/__init__.py @@ -131,8 +131,7 @@ def get_bot(self_id: Optional[str] = None) -> Bot: """ 当提供 self_id 时，此函数是 get_bots()[self_id] 的简写；当不提供时，返回一个 Bot。 - :参数: - + 参数: self_id: 用来识别 Bot 的 ID :返回: @@ -225,8 +224,7 @@ def init(*, _env_file: Optional[str] = None, **kwargs): 你也可以传入自定义的 _env_file 来指定 NoneBot 从该文件读取配置。 - :参数: - + 参数: _env_file: 配置文件名，默认从 .env.{env_name} 中读取配置 **kwargs: 任意变量，将会存储到 Config 对象里 @@ -267,8 +265,7 @@ def run(*args: Any, **kwargs: Any) -> None: """ 启动 NoneBot，即运行全局 Driver 对象。 - :参数: - + 参数: *args: 传入 Driver.run 的位置参数 **kwargs: 传入 Driver.run 的命名参数 diff --git a/nonebot/adapters/_adapter.py b/nonebot/adapters/_adapter.py index 38b129f0..85724723 100644 --- a/nonebot/adapters/_adapter.py +++ b/nonebot/adapters/_adapter.py @@ -65,8 +65,7 @@ class Adapter(abc.ABC): """ `adapter` 实际调用 api 的逻辑实现函数，实现该方法以调用 api。 - :参数: - + 参数: api: API 名称 **data: API 数据 """ diff --git a/nonebot/adapters/_bot.py b/nonebot/adapters/_bot.py index ee3e4193..f6a35522 100644 --- a/nonebot/adapters/_bot.py +++ b/nonebot/adapters/_bot.py @@ -36,8 +36,7 @@ class Bot(abc.ABC): def __init__(self, adapter: "Adapter", self_id: str): """ - :参数: - + 参数: self_id: 机器人 ID request: request 连接对象 """ @@ -60,8 +59,7 @@ class Bot(abc.ABC): """ 调用机器人 API 接口，可以通过该函数或直接通过 bot 属性进行调用 - :参数: - + 参数: api: API 名称 **data: API 数据 @@ -129,8 +127,7 @@ class Bot(abc.ABC): """ 调用机器人基础发送消息接口 - :参数: - + 参数: event: 上报事件 message: 要发送的消息 **kwargs @@ -142,8 +139,7 @@ class Bot(abc.ABC): """ 调用 api 预处理。 - :参数: - + 参数: bot: 当前 bot 对象 api: 调用的 api 名称 data: api 调用的参数字典 @@ -156,8 +152,7 @@ class Bot(abc.ABC): """ 调用 api 后处理。 - :参数: - + 参数: bot: 当前 bot 对象 exception: 调用 api 时发生的错误 api: 调用的 api 名称 diff --git a/nonebot/adapters/_message.py b/nonebot/adapters/_message.py index 6df86ae6..eca31cbd 100644 --- a/nonebot/adapters/_message.py +++ b/nonebot/adapters/_message.py @@ -97,8 +97,7 @@ class Message(List[TMS], abc.ABC): **kwargs, ): """ - :参数: - + 参数: message: 消息内容 """ super().__init__(*args, **kwargs) @@ -135,8 +134,7 @@ class Message(List[TMS], abc.ABC): >>> Message.template("{link:image}").format(link='https://...') # 支持拓展格式化控制符 Message(MessageSegment(type='image', data={'file': 'https://...'})) - :参数: - + 参数: format_string: 格式化字符串 :返回: @@ -188,8 +186,7 @@ class Message(List[TMS], abc.ABC): """ 添加一个消息段到消息数组末尾 - :参数: - + 参数: obj: 要添加的消息段 """ if isinstance(obj, MessageSegment): @@ -204,8 +201,7 @@ class Message(List[TMS], abc.ABC): """ 拼接一个消息数组或多个消息段到消息数组末尾 - :参数: - + 参数: obj: 要添加的消息数组 """ for segment in obj: diff --git a/nonebot/adapters/_template.py b/nonebot/adapters/_template.py index 5c5597e7..cd182b41 100644 --- a/nonebot/adapters/_template.py +++ b/nonebot/adapters/_template.py @@ -49,8 +49,7 @@ class MessageTemplate(Formatter, Generic[TF]): """ 创建一个模板 - :参数: - + 参数: template: 模板 factory: 消息构造类型，默认为 `str` """ diff --git a/nonebot/drivers/__init__.py b/nonebot/drivers/__init__.py index 4f7d7d56..697e15db 100644 --- a/nonebot/drivers/__init__.py +++ b/nonebot/drivers/__init__.py @@ -54,8 +54,7 @@ class Driver(abc.ABC): def __init__(self, env: Env, config: Config): """ - :参数: - + 参数: env: 包含环境信息的 Env 对象 config: 包含配置信息的 Config 对象 """ @@ -83,8 +82,7 @@ class Driver(abc.ABC): """ 注册一个协议适配器 - :参数: - + 参数: name: 适配器名称，用于在连接时进行识别 adapter: 适配器 Class **kwargs: 其他传递给适配器的参数 @@ -117,8 +115,7 @@ class Driver(abc.ABC): """ 启动驱动框架 - :参数: - *args + 参数: *args **kwargs """ logger.opt(colors=True).debug( diff --git a/nonebot/drivers/_block_driver.py b/nonebot/drivers/_block_driver.py index 217989ce..e8bcd138 100644 --- a/nonebot/drivers/_block_driver.py +++ b/nonebot/drivers/_block_driver.py @@ -41,8 +41,7 @@ class BlockDriver(Driver): """ 注册一个启动时执行的函数 - :参数: - + 参数: func """ self.startup_funcs.add(func) @@ -53,8 +52,7 @@ class BlockDriver(Driver): """ 注册一个停止时执行的函数 - :参数: - + 参数: func """ self.shutdown_funcs.add(func) diff --git a/nonebot/exception.py b/nonebot/exception.py index 28855872..94e01633 100644 --- a/nonebot/exception.py +++ b/nonebot/exception.py @@ -22,8 +22,7 @@ class ParserExit(NoneBotException): """ `shell command` 处理消息失败时返回的异常 - :参数: - + 参数: status message """ @@ -50,8 +49,7 @@ class IgnoredException(ProcessException): """ 指示 NoneBot 应该忽略该事件。可由 PreProcessor 抛出。 - :参数: - + 参数: reason: 忽略事件的原因 """ @@ -69,8 +67,7 @@ class MockApiException(ProcessException): """ 指示 NoneBot 阻止本次 API 调用或修改本次调用返回值，并返回自定义内容。可由 api hook 抛出。 - :参数: - + 参数: result: 返回的内容 """ @@ -165,8 +162,7 @@ class AdapterException(NoneBotException): """ 代表 `Adapter` 抛出的异常，所有的 `Adapter` 都要在内部继承自这个 `Exception` - :参数: - + 参数: adapter_name: 标识 adapter """ diff --git a/nonebot/matcher.py b/nonebot/matcher.py index e724906f..ecf2c618 100644 --- a/nonebot/matcher.py +++ b/nonebot/matcher.py @@ -212,8 +212,7 @@ class Matcher(metaclass=MatcherMeta): """ 创建一个新的事件响应器，并存储至 `matchers <#matchers>`_ - :参数: - + 参数: type_: 事件响应器类型，与 `event.get_type()` 一致时触发，空字符串表示任意 rule: 匹配规则 permission: 权限 @@ -278,8 +277,7 @@ class Matcher(metaclass=MatcherMeta): """ 检查是否满足触发权限 - :参数: - + 参数: bot: Bot 对象 event: 上报事件 @@ -304,8 +302,7 @@ class Matcher(metaclass=MatcherMeta): """ 检查是否满足匹配规则 - :参数: - + 参数: bot: Bot 对象 event: 上报事件 state: 当前状态 @@ -324,8 +321,7 @@ class Matcher(metaclass=MatcherMeta): """ 装饰一个函数来更改当前事件响应器的默认响应事件类型更新函数 - :参数: - + 参数: func: 响应事件类型更新函数 """ cls._default_type_updater = Dependent[str].parse( @@ -338,8 +334,7 @@ class Matcher(metaclass=MatcherMeta): """ 装饰一个函数来更改当前事件响应器的默认会话权限更新函数 - :参数: - + 参数: func: 会话权限更新函数 """ cls._default_permission_updater = Dependent[Permission].parse( @@ -366,8 +361,7 @@ class Matcher(metaclass=MatcherMeta): """ 装饰一个函数来向事件响应器直接添加一个处理函数 - :参数: - + 参数: parameterless: 非参数类型依赖列表 """ @@ -384,8 +378,7 @@ class Matcher(metaclass=MatcherMeta): """ 装饰一个函数来指示 NoneBot 在接收用户新的一条消息后继续运行该函数 - :参数: - + 参数: id: 消息 ID parameterless: 非参数类型依赖列表 """ @@ -424,8 +417,7 @@ class Matcher(metaclass=MatcherMeta): """ 装饰一个函数来指示 NoneBot 当要获取的 `key` 不存在时接收用户新的一条消息并经过 `ArgsParser` 处理后再运行该函数，如果 `key` 已存在则直接继续运行 - :参数: - + 参数: key: 参数名 prompt: 在参数不存在时向用户发送的消息 args_parser: 可选参数解析函数，空则使用默认解析函数 @@ -468,8 +460,7 @@ class Matcher(metaclass=MatcherMeta): """ 发送一条消息给当前交互用户 - :参数: - + 参数: message: 消息内容 **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ @@ -491,8 +482,7 @@ class Matcher(metaclass=MatcherMeta): """ 发送一条消息给当前交互用户并结束当前事件响应器 - :参数: - + 参数: message: 消息内容 **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ @@ -509,8 +499,7 @@ class Matcher(metaclass=MatcherMeta): """ 发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续下一个处理函数 - :参数: - + 参数: prompt: 消息内容 **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ @@ -527,8 +516,7 @@ class Matcher(metaclass=MatcherMeta): """ 最近使用 `got` / `receive` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 - :参数: - + 参数: prompt: 消息内容 **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ @@ -546,8 +534,7 @@ class Matcher(metaclass=MatcherMeta): """ 最近使用 `got` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 - :参数: - + 参数: key: 参数名 prompt: 消息内容 **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api @@ -568,8 +555,7 @@ class Matcher(metaclass=MatcherMeta): """ 最近使用 `got` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 - :参数: - + 参数: id: 消息 id prompt: 消息内容 **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api diff --git a/nonebot/message.py b/nonebot/message.py index 1990b537..932156bd 100644 --- a/nonebot/message.py +++ b/nonebot/message.py @@ -236,8 +236,7 @@ async def handle_event(bot: "Bot", event: "Event") -> None: """ 处理一个事件。调用该函数以实现分发事件。 - :参数: - + 参数: bot: Bot 对象 event: Event 对象 diff --git a/nonebot/params.py b/nonebot/params.py index 6e2fe354..09bb0f04 100644 --- a/nonebot/params.py +++ b/nonebot/params.py @@ -58,8 +58,7 @@ def Depends( """ 参数依赖注入装饰器 - :参数: - + 参数: dependency: 依赖函数。默认为参数的类型注释。 use_cache: 是否使用缓存。默认为 `True`。 diff --git a/nonebot/permission.py b/nonebot/permission.py index c813f8bb..aea78b54 100644 --- a/nonebot/permission.py +++ b/nonebot/permission.py @@ -58,8 +58,7 @@ class Permission: def __init__(self, *checkers: Union[T_PermissionChecker, Dependent[bool]]) -> None: """ - :参数: - + 参数: *checkers: PermissionChecker """ @@ -85,8 +84,7 @@ class Permission: """ 检查是否满足某个权限 - :参数: - + 参数: bot: Bot 对象 event: Event 对象 stack: 异步上下文栈 @@ -183,8 +181,7 @@ def USER(*users: str, perm: Optional[Permission] = None): """ `event` 的 `session_id` 在白名单内且满足 perm - :参数: - + 参数: *user: 白名单 perm: 需要同时满足的权限 """ diff --git a/nonebot/plugin/load.py b/nonebot/plugin/load.py index 891af56d..6fca317a 100644 --- a/nonebot/plugin/load.py +++ b/nonebot/plugin/load.py @@ -14,8 +14,7 @@ def load_plugin(module_path: str) -> Optional[Plugin]: """ 使用 `PluginManager` 加载单个插件，可以是本地插件或是通过 `pip` 安装的插件。 - :参数: - + 参数: module_path: 插件名称 `path.to.your.plugin` :返回: @@ -32,8 +31,7 @@ def load_plugins(*plugin_dir: str) -> Set[Plugin]: """ 导入目录下多个插件，以 `_` 开头的插件不会被导入！ - :参数: - + 参数: - `*plugin_dir: str`: 插件路径 :返回: @@ -51,8 +49,7 @@ def load_all_plugins( """ 导入指定列表中的插件以及指定目录下多个插件，以 `_` 开头的插件不会被导入！ - :参数: - + 参数: - `module_path: Iterable[str]`: 指定插件集合 - `plugin_dir: Iterable[str]`: 指定插件路径集合 @@ -69,8 +66,7 @@ def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]: """ 导入指定 json 文件中的 `plugins` 以及 `plugin_dirs` 下多个插件，以 `_` 开头的插件不会被导入！ - :参数: - + 参数: - `file_path: str`: 指定 json 文件路径 - `encoding: str`: 指定 json 文件编码 @@ -92,8 +88,7 @@ def load_from_toml(file_path: str, encoding: str = "utf-8") -> Set[Plugin]: 导入指定 toml 文件 `[tool.nonebot]` 中的 `plugins` 以及 `plugin_dirs` 下多个插件， 以 `_` 开头的插件不会被导入！ - :参数: - + 参数: - `file_path: str`: 指定 toml 文件路径 - `encoding: str`: 指定 toml 文件编码 @@ -147,8 +142,7 @@ def require(name: str) -> Export: """ 获取一个插件的导出内容 - :参数: - + 参数: name: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。 :返回: diff --git a/nonebot/plugin/on.py b/nonebot/plugin/on.py index 4a90f628..c40014ef 100644 --- a/nonebot/plugin/on.py +++ b/nonebot/plugin/on.py @@ -57,8 +57,7 @@ def on( """ 注册一个基础事件响应器，可自定义类型。 - :参数: - + 参数: type: 事件响应器类型 rule: 事件响应规则 permission: 事件响应权限 @@ -101,8 +100,7 @@ def on_metaevent( """ 注册一个元事件响应器。 - :参数: - + 参数: rule: 事件响应规则 handlers: 事件处理函数列表 temp: 是否为临时事件响应器（仅执行一次） @@ -144,8 +142,7 @@ def on_message( """ 注册一个消息事件响应器。 - :参数: - + 参数: rule: 事件响应规则 permission: 事件响应权限 handlers: 事件处理函数列表 @@ -187,8 +184,7 @@ def on_notice( """ 注册一个通知事件响应器。 - :参数: - + 参数: rule: 事件响应规则 handlers: 事件处理函数列表 temp: 是否为临时事件响应器（仅执行一次） @@ -229,8 +225,7 @@ def on_request( """ 注册一个请求事件响应器。 - :参数: - + 参数: rule: 事件响应规则 handlers: 事件处理函数列表 temp: 是否为临时事件响应器（仅执行一次） @@ -268,8 +263,7 @@ def on_startswith( """ 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。 - :参数: - + 参数: msg: 指定消息开头内容 rule: 事件响应规则 ignorecase: 是否忽略大小写 @@ -297,8 +291,7 @@ def on_endswith( """ 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。 - :参数: - + 参数: msg: 指定消息结尾内容 rule: 事件响应规则 ignorecase: 是否忽略大小写 @@ -325,8 +318,7 @@ def on_keyword( """ 注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。 - :参数: - + 参数: keywords: 关键词列表 rule: 事件响应规则 permission: 事件响应权限 @@ -355,8 +347,7 @@ def on_command( 命令匹配规则参考: `命令形式匹配 `_ - :参数: - + 参数: cmd: 指定命令内容 rule: 事件响应规则 aliases: 命令别名 @@ -394,8 +385,7 @@ def on_shell_command( 并将用户输入的原始参数列表保存在 `state["argv"]`, `parser` 处理的参数保存在 `state["args"]` 中 - :参数: - + 参数: cmd: 指定命令内容 rule: 事件响应规则 aliases: 命令别名 @@ -432,8 +422,7 @@ def on_regex( 命令匹配规则参考: `正则匹配 `_ - :参数: - + 参数: pattern: 正则表达式 flags: 正则匹配标志 rule: 事件响应规则 @@ -456,8 +445,7 @@ class CommandGroup: def __init__(self, cmd: Union[str, Tuple[str, ...]], **kwargs): """ - :参数: - + 参数: cmd: 命令前缀 **kwargs`on_command` 的参数默认值，参考 `on_command <#on-command-cmd-rule-none-aliases-none-kwargs>`_ """ @@ -476,8 +464,7 @@ class CommandGroup: """ 注册一个新的命令。 - :参数: - + 参数: cmd: 命令前缀 **kwargs`on_command` 的参数，将会覆盖命令组默认值 @@ -498,8 +485,7 @@ class CommandGroup: """ 注册一个新的命令。 - :参数: - + 参数: cmd: 命令前缀 **kwargs`on_shell_command` 的参数，将会覆盖命令组默认值 @@ -535,8 +521,7 @@ class MatcherGroup: """ 注册一个基础事件响应器，可自定义类型。 - :参数: - + 参数: type: 事件响应器类型 rule: 事件响应规则 permission: 事件响应权限 @@ -560,8 +545,7 @@ class MatcherGroup: """ 注册一个元事件响应器。 - :参数: - + 参数: rule: 事件响应规则 handlers: 事件处理函数列表 temp: 是否为临时事件响应器（仅执行一次） @@ -585,8 +569,7 @@ class MatcherGroup: """ 注册一个消息事件响应器。 - :参数: - + 参数: rule: 事件响应规则 permission: 事件响应权限 handlers: 事件处理函数列表 @@ -610,8 +593,7 @@ class MatcherGroup: """ 注册一个通知事件响应器。 - :参数: - + 参数: rule: 事件响应规则 handlers: 事件处理函数列表 temp: 是否为临时事件响应器（仅执行一次） @@ -634,8 +616,7 @@ class MatcherGroup: """ 注册一个请求事件响应器。 - :参数: - + 参数: rule: 事件响应规则 handlers: 事件处理函数列表 temp: 是否为临时事件响应器（仅执行一次） @@ -660,8 +641,7 @@ class MatcherGroup: """ 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。 - :参数: - + 参数: msg: 指定消息开头内容 ignorecase: 是否忽略大小写 rule: 事件响应规则 @@ -687,8 +667,7 @@ class MatcherGroup: """ 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。 - :参数: - + 参数: msg: 指定消息结尾内容 ignorecase: 是否忽略大小写 rule: 事件响应规则 @@ -714,8 +693,7 @@ class MatcherGroup: """ 注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。 - :参数: - + 参数: keywords: 关键词列表 rule: 事件响应规则 permission: 事件响应权限 @@ -747,8 +725,7 @@ class MatcherGroup: 命令匹配规则参考: `命令形式匹配 `_ - :参数: - + 参数: cmd: 指定命令内容 aliases: 命令别名 rule: 事件响应规则 @@ -784,8 +761,7 @@ class MatcherGroup: 并将用户输入的原始参数列表保存在 `state["argv"]`, `parser` 处理的参数保存在 `state["args"]` 中 - :参数: - + 参数: cmd: 指定命令内容 aliases: 命令别名 parser: `nonebot.rule.ArgumentParser` 对象 @@ -818,8 +794,7 @@ class MatcherGroup: 命令匹配规则参考: `正则匹配 `_ - :参数: - + 参数: pattern: 正则表达式 flags: 正则匹配标志 rule: 事件响应规则 diff --git a/nonebot/plugin/plugin.py b/nonebot/plugin/plugin.py index 79587c9b..c3625b46 100644 --- a/nonebot/plugin/plugin.py +++ b/nonebot/plugin/plugin.py @@ -56,8 +56,7 @@ def get_plugin(name: str) -> Optional[Plugin]: """ 获取当前导入的某个插件。 - :参数: - + 参数: name: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。 :返回: diff --git a/nonebot/rule.py b/nonebot/rule.py index 81149722..490ce621 100644 --- a/nonebot/rule.py +++ b/nonebot/rule.py @@ -87,8 +87,7 @@ class Rule: def __init__(self, *checkers: Union[T_RuleChecker, Dependent[bool]]) -> None: """ - :参数: - + 参数: *checkers: RuleChecker """ @@ -115,8 +114,7 @@ class Rule: """ 检查是否符合所有规则 - :参数: - + 参数: bot: Bot 对象 event: Event 对象 state: 当前 State @@ -216,8 +214,7 @@ def startswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Ru """ 匹配消息开头 - :参数: - + 参数: msg: 消息开头字符串 """ if isinstance(msg, str): @@ -249,8 +246,7 @@ def endswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule """ 匹配消息结尾 - :参数: - + 参数: msg: 消息结尾字符串 """ if isinstance(msg, str): @@ -275,8 +271,7 @@ def keyword(*keywords: str) -> Rule: """ 匹配消息关键词 - :参数: - + 参数: *keywords: 关键词 """ @@ -300,8 +295,7 @@ def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule: 可以通过 `state["_prefix"]["command"]` 获取匹配成功的命令（例：`("test",)`），通过 `state["_prefix"]["raw_command"]` 获取匹配成功的原始命令文本（例：`"/test"`）。 - :参数: - + 参数: *cmds: 命令内容 :示例: @@ -400,8 +394,7 @@ def shell_command( 添加 `parser` 参数后, 可以自动处理消息并将结果保存在 `state["args"]` 中。 - :参数: - + 参数: *cmds: 命令内容 parser: `nonebot.rule.ArgumentParser` 对象 @@ -475,8 +468,7 @@ def regex(regex: str, flags: Union[int, re.RegexFlag] = 0) -> Rule: 可以通过 `state["_matched"]` `state["_matched_groups"]` `state["_matched_dict"]` 获取正则表达式匹配成功的文本。 - :参数: - + 参数: regex: 正则表达式 flags: 正则标志 @@ -497,8 +489,7 @@ def to_me() -> Rule: """ 通过 `event.is_tome()` 判断事件是否与机器人有关 - :参数: - + 参数: * 无 """ diff --git a/nonebot/utils.py b/nonebot/utils.py index 7f38953b..be2ef47c 100644 --- a/nonebot/utils.py +++ b/nonebot/utils.py @@ -33,8 +33,7 @@ def escape_tag(s: str) -> str: """ 用于记录带颜色日志时转义 `` 类型特殊标签 - :参数: - + 参数: s: 需要转义的字符串 :返回: @@ -90,8 +89,7 @@ def run_sync(call: Callable[P, R]) -> Callable[P, Awaitable[R]]: """ 一个用于包装 sync function 为 async function 的装饰器 - :参数: - + 参数: call: 被装饰的同步函数 :返回: From 187532930bab0f1166b4373832d4aabba78cc8e8 Mon Sep 17 00:00:00 2001 From: hemengyang Date: Wed, 12 Jan 2022 18:43:07 +0800 Subject: [PATCH 07/14] =?UTF-8?q?=E4=BB=A4=E8=BF=94=E5=9B=9E=E7=AC=A6?= =?UTF-8?q?=E5=90=88=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- nonebot/__init__.py | 23 ++------- nonebot/adapters/_event.py | 37 -------------- nonebot/adapters/_message.py | 5 +- nonebot/matcher.py | 15 +++--- nonebot/permission.py | 4 -- nonebot/plugin/export.py | 4 -- nonebot/plugin/load.py | 48 +++--------------- nonebot/plugin/on.py | 96 ------------------------------------ nonebot/plugin/plugin.py | 8 --- nonebot/rule.py | 4 -- nonebot/utils.py | 8 --- 11 files changed, 20 insertions(+), 232 deletions(-) diff --git a/nonebot/__init__.py b/nonebot/__init__.py index 00c47340..c496ffdf 100644 --- a/nonebot/__init__.py +++ b/nonebot/__init__.py @@ -55,8 +55,7 @@ def get_driver() -> Driver: """ 获取全局 Driver 对象。可用于在计划任务的回调中获取当前 Driver 对象。 - :返回: - + 返回: Driver: 全局 Driver 对象 :异常: @@ -79,8 +78,7 @@ def get_app() -> Any: """ 获取全局 Driver 对应 Server App 对象。 - :返回: - + 返回: Any: Server App 对象 :异常: @@ -105,8 +103,7 @@ def get_asgi() -> Any: """ 获取全局 Driver 对应 Asgi 对象。 - :返回: - + 返回: Any: Asgi 对象 :异常: @@ -134,8 +131,7 @@ def get_bot(self_id: Optional[str] = None) -> Bot: 参数: self_id: 用来识别 Bot 的 ID - :返回: - + 返回: Bot: Bot 对象 :异常: @@ -166,8 +162,7 @@ def get_bots() -> Dict[str, Bot]: """ 获取所有通过 ws 连接 NoneBot 的 Bot 对象。 - :返回: - + 返回: Dict[str, Bot]: 一个以字符串 ID 为键，Bot 对象为值的字典 :异常: @@ -228,10 +223,6 @@ def init(*, _env_file: Optional[str] = None, **kwargs): _env_file: 配置文件名，默认从 .env.{env_name} 中读取配置 **kwargs: 任意变量，将会存储到 Config 对象里 - :返回: - - - `None` - :用法: .. code-block:: python @@ -269,10 +260,6 @@ def run(*args: Any, **kwargs: Any) -> None: *args: 传入 Driver.run 的位置参数 **kwargs: 传入 Driver.run 的命名参数 - :返回: - - - `None` - :用法: .. code-block:: python diff --git a/nonebot/adapters/_event.py b/nonebot/adapters/_event.py index 831f7947..dcf411bd 100644 --- a/nonebot/adapters/_event.py +++ b/nonebot/adapters/_event.py @@ -17,11 +17,6 @@ class Event(abc.ABC, BaseModel): def get_type(self) -> str: """ 获取事件类型的方法，类型通常为 NoneBot 内置的四种类型。 - - :返回: - - Literal["message", "notice", "request", "meta_event"] - * 其他自定义 `str` """ raise NotImplementedError @@ -29,10 +24,6 @@ class Event(abc.ABC, BaseModel): def get_event_name(self) -> str: """ 获取事件名称的方法。 - - :返回: - - str """ raise NotImplementedError @@ -40,10 +31,6 @@ class Event(abc.ABC, BaseModel): def get_event_description(self) -> str: """ 获取事件描述的方法，通常为事件具体内容。 - - :返回: - - str """ raise NotImplementedError @@ -54,10 +41,6 @@ class Event(abc.ABC, BaseModel): """ 获取事件日志信息的方法，通常你不需要修改这个方法，只有当希望 NoneBot 隐藏该事件日志时，可以抛出 `NoLogException` 异常。 - :返回: - - str - :异常: - `NoLogException` @@ -68,10 +51,6 @@ class Event(abc.ABC, BaseModel): def get_user_id(self) -> str: """ 获取事件主体 id 的方法，通常是用户 id 。 - - :返回: - - str """ raise NotImplementedError @@ -79,10 +58,6 @@ class Event(abc.ABC, BaseModel): def get_session_id(self) -> str: """ 获取会话 id 的方法，用于判断当前事件属于哪一个会话，通常是用户 id、群组 id 组合。 - - :返回: - - str """ raise NotImplementedError @@ -90,20 +65,12 @@ class Event(abc.ABC, BaseModel): def get_message(self) -> "Message": """ 获取事件消息内容的方法。 - - :返回: - - Message """ raise NotImplementedError def get_plaintext(self) -> str: """ 获取消息纯文本的方法，通常不需要修改，默认通过 `get_message().extract_plain_text` 获取。 - - :返回: - - str """ return self.get_message().extract_plain_text() @@ -111,9 +78,5 @@ class Event(abc.ABC, BaseModel): def is_tome(self) -> bool: """ 获取事件是否与机器人有关的方法。 - - :返回: - - bool """ raise NotImplementedError diff --git a/nonebot/adapters/_message.py b/nonebot/adapters/_message.py index eca31cbd..1b6f8980 100644 --- a/nonebot/adapters/_message.py +++ b/nonebot/adapters/_message.py @@ -137,9 +137,8 @@ class Message(List[TMS], abc.ABC): 参数: format_string: 格式化字符串 - :返回: - - - `MessageFormatter[TM]`: 消息格式化器 + 返回: + MessageFormatter[TM]: 消息格式化器 """ return MessageTemplate(format_string, cls) diff --git a/nonebot/matcher.py b/nonebot/matcher.py index ecf2c618..087c172b 100644 --- a/nonebot/matcher.py +++ b/nonebot/matcher.py @@ -225,9 +225,8 @@ class Matcher(metaclass=MatcherMeta): default_state: 默认状态 `state` expire_time: 事件响应器最终有效时间点，过时即被删除 - :返回: - - - `Type[Matcher]`: 新的事件响应器类 + 返回: + Type[Matcher]: 新的事件响应器类 """ NewMatcher = type( "Matcher", @@ -281,9 +280,8 @@ class Matcher(metaclass=MatcherMeta): bot: Bot 对象 event: 上报事件 - :返回: - - - `bool`: 是否满足权限 + 返回: + bool: 是否满足权限 """ event_type = event.get_type() return event_type == (cls.type or event_type) and await cls.permission( @@ -307,9 +305,8 @@ class Matcher(metaclass=MatcherMeta): event: 上报事件 state: 当前状态 - :返回: - - - `bool`: 是否满足匹配规则 + 返回: + bool: 是否满足匹配规则 """ event_type = event.get_type() return event_type == (cls.type or event_type) and await cls.rule( diff --git a/nonebot/permission.py b/nonebot/permission.py index aea78b54..d3f662ae 100644 --- a/nonebot/permission.py +++ b/nonebot/permission.py @@ -89,10 +89,6 @@ class Permission: event: Event 对象 stack: 异步上下文栈 dependency_cache: 依赖缓存 - - :返回: - - - `bool` """ if not self.checkers: return True diff --git a/nonebot/plugin/export.py b/nonebot/plugin/export.py index 83e494cd..7cd62e73 100644 --- a/nonebot/plugin/export.py +++ b/nonebot/plugin/export.py @@ -45,10 +45,6 @@ class Export(dict): def export() -> Export: """ 获取插件的导出内容对象 - - :返回: - - - `Export` """ plugin = _current_plugin.get() if not plugin: diff --git a/nonebot/plugin/load.py b/nonebot/plugin/load.py index 6fca317a..24da34db 100644 --- a/nonebot/plugin/load.py +++ b/nonebot/plugin/load.py @@ -16,10 +16,6 @@ def load_plugin(module_path: str) -> Optional[Plugin]: 参数: module_path: 插件名称 `path.to.your.plugin` - - :返回: - - - `Optional[Plugin]` """ manager = PluginManager([module_path]) @@ -32,11 +28,7 @@ def load_plugins(*plugin_dir: str) -> Set[Plugin]: 导入目录下多个插件，以 `_` 开头的插件不会被导入！ 参数: - - `*plugin_dir: str`: 插件路径 - - :返回: - - - `Set[Plugin]` + plugin_dir: 插件路径 """ manager = PluginManager(search_path=plugin_dir) _managers.append(manager) @@ -50,12 +42,8 @@ def load_all_plugins( 导入指定列表中的插件以及指定目录下多个插件，以 `_` 开头的插件不会被导入！ 参数: - - `module_path: Iterable[str]`: 指定插件集合 - - `plugin_dir: Iterable[str]`: 指定插件路径集合 - - :返回: - - - `Set[Plugin]` + module_path: 指定插件集合 + plugin_dir: 指定插件路径集合 """ manager = PluginManager(module_path, plugin_dir) _managers.append(manager) @@ -67,13 +55,8 @@ def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]: 导入指定 json 文件中的 `plugins` 以及 `plugin_dirs` 下多个插件，以 `_` 开头的插件不会被导入！ 参数: - - `file_path: str`: 指定 json 文件路径 - - `encoding: str`: 指定 json 文件编码 - - :返回: - - - `Set[Plugin]` - """ + file_path: 指定 json 文件路径 + encoding: 指定 json 文件编码""" with open(file_path, "r", encoding=encoding) as f: data = json.load(f) plugins = data.get("plugins") @@ -89,13 +72,8 @@ def load_from_toml(file_path: str, encoding: str = "utf-8") -> Set[Plugin]: 以 `_` 开头的插件不会被导入！ 参数: - - `file_path: str`: 指定 toml 文件路径 - - `encoding: str`: 指定 toml 文件编码 - - :返回: - - - `Set[Plugin]` - """ + file_path: 指定 toml 文件路径 + encoding: 指定 toml 文件编码""" with open(file_path, "r", encoding=encoding) as f: data = tomlkit.parse(f.read()) # type: ignore @@ -119,10 +97,6 @@ def load_from_toml(file_path: str, encoding: str = "utf-8") -> Set[Plugin]: def load_builtin_plugin(name: str) -> Optional[Plugin]: """ 导入 NoneBot 内置插件 - - :返回: - - - `Plugin` """ return load_plugin(f"nonebot.plugins.{name}") @@ -130,10 +104,6 @@ def load_builtin_plugin(name: str) -> Optional[Plugin]: def load_builtin_plugins(*plugins) -> Set[Plugin]: """ 导入多个 NoneBot 内置插件 - - :返回: - - - `Set[Plugin]` """ return load_all_plugins([f"nonebot.plugins.{p}" for p in plugins], []) @@ -145,10 +115,6 @@ def require(name: str) -> Export: 参数: name: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。 - :返回: - - - `Export` - :异常: - `RuntimeError`: 插件无法加载 """ diff --git a/nonebot/plugin/on.py b/nonebot/plugin/on.py index c40014ef..f0fb8c93 100644 --- a/nonebot/plugin/on.py +++ b/nonebot/plugin/on.py @@ -66,10 +66,6 @@ def on( priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ matcher = Matcher.new( type, @@ -107,10 +103,6 @@ def on_metaevent( priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ matcher = Matcher.new( "meta_event", @@ -150,10 +142,6 @@ def on_message( priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ matcher = Matcher.new( "message", @@ -191,10 +179,6 @@ def on_notice( priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ matcher = Matcher.new( "notice", @@ -232,10 +216,6 @@ def on_request( priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ matcher = Matcher.new( "request", @@ -273,10 +253,6 @@ def on_startswith( priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ return on_message(startswith(msg, ignorecase) & rule, **kwargs, _depth=_depth + 1) @@ -301,10 +277,6 @@ def on_endswith( priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ return on_message(endswith(msg, ignorecase) & rule, **kwargs, _depth=_depth + 1) @@ -327,10 +299,6 @@ def on_keyword( priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ return on_message(keyword(*keywords) & rule, **kwargs, _depth=_depth + 1) @@ -357,10 +325,6 @@ def on_command( priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ commands = set([cmd]) | (aliases or set()) @@ -396,10 +360,6 @@ def on_shell_command( priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ commands = set([cmd]) | (aliases or set()) @@ -432,10 +392,6 @@ def on_regex( priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ return on_message(regex(pattern, flags) & rule, **kwargs, _depth=_depth + 1) @@ -467,10 +423,6 @@ class CommandGroup: 参数: cmd: 命令前缀 **kwargs`on_command` 的参数，将会覆盖命令组默认值 - - :返回: - - - `Type[Matcher]` """ sub_cmd = (cmd,) if isinstance(cmd, str) else cmd cmd = self.basecmd + sub_cmd @@ -488,10 +440,6 @@ class CommandGroup: 参数: cmd: 命令前缀 **kwargs`on_shell_command` 的参数，将会覆盖命令组默认值 - - :返回: - - - `Type[Matcher]` """ sub_cmd = (cmd,) if isinstance(cmd, str) else cmd cmd = self.basecmd + sub_cmd @@ -530,10 +478,6 @@ class MatcherGroup: priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -552,10 +496,6 @@ class MatcherGroup: priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -577,10 +517,6 @@ class MatcherGroup: priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -600,10 +536,6 @@ class MatcherGroup: priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -623,10 +555,6 @@ class MatcherGroup: priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -651,10 +579,6 @@ class MatcherGroup: priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -677,10 +601,6 @@ class MatcherGroup: priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -702,10 +622,6 @@ class MatcherGroup: priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -735,10 +651,6 @@ class MatcherGroup: priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -772,10 +684,6 @@ class MatcherGroup: priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -804,10 +712,6 @@ class MatcherGroup: priority: 事件响应器优先级 block: 是否阻止事件向更低优先级传递 state: 默认 state - - :返回: - - - `Type[Matcher]` """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) diff --git a/nonebot/plugin/plugin.py b/nonebot/plugin/plugin.py index c3625b46..82e4f806 100644 --- a/nonebot/plugin/plugin.py +++ b/nonebot/plugin/plugin.py @@ -58,10 +58,6 @@ def get_plugin(name: str) -> Optional[Plugin]: 参数: name: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。 - - :返回: - - - `Optional[Plugin]` """ return plugins.get(name) @@ -69,10 +65,6 @@ def get_plugin(name: str) -> Optional[Plugin]: def get_loaded_plugins() -> Set[Plugin]: """ 获取当前已导入的所有插件。 - - :返回: - - - `Set[Plugin]` """ return set(plugins.values()) diff --git a/nonebot/rule.py b/nonebot/rule.py index 490ce621..b8609ad9 100644 --- a/nonebot/rule.py +++ b/nonebot/rule.py @@ -120,10 +120,6 @@ class Rule: state: 当前 State stack: 异步上下文栈 dependency_cache: 依赖缓存 - - :返回: - - - `bool` """ if not self.checkers: return True diff --git a/nonebot/utils.py b/nonebot/utils.py index be2ef47c..8c55af14 100644 --- a/nonebot/utils.py +++ b/nonebot/utils.py @@ -35,10 +35,6 @@ def escape_tag(s: str) -> str: 参数: s: 需要转义的字符串 - - :返回: - - - `str` """ return re.sub(r"\s]*)>", r"\\\g<0>", s) @@ -91,10 +87,6 @@ def run_sync(call: Callable[P, R]) -> Callable[P, Awaitable[R]]: 参数: call: 被装饰的同步函数 - - :返回: - - - `Callable[P, Awaitable[R]]` """ @wraps(call) From edb20a478628b19987dafd380e6803edeb66cf65 Mon Sep 17 00:00:00 2001 From: hemengyang Date: Wed, 12 Jan 2022 18:45:35 +0800 Subject: [PATCH 08/14] =?UTF-8?q?=E4=BB=A4=E5=BC=82=E5=B8=B8=E7=AC=A6?= =?UTF-8?q?=E5=90=88=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- nonebot/__init__.py | 15 +++++---------- nonebot/adapters/_event.py | 5 ++--- nonebot/plugin/load.py | 4 ++-- 3 files changed, 9 insertions(+), 15 deletions(-) diff --git a/nonebot/__init__.py b/nonebot/__init__.py index c496ffdf..a3b105a8 100644 --- a/nonebot/__init__.py +++ b/nonebot/__init__.py @@ -58,8 +58,7 @@ def get_driver() -> Driver: 返回: Driver: 全局 Driver 对象 - :异常: - + 异常: ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) :用法: @@ -81,8 +80,7 @@ def get_app() -> Any: 返回: Any: Server App 对象 - :异常: - + 异常: ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) :用法: @@ -106,8 +104,7 @@ def get_asgi() -> Any: 返回: Any: Asgi 对象 - :异常: - + 异常: ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) :用法: @@ -134,8 +131,7 @@ def get_bot(self_id: Optional[str] = None) -> Bot: 返回: Bot: Bot 对象 - :异常: - + 异常: KeyError: 对应 ID 的 Bot 不存在 ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) ValueError: 没有传入 ID 且没有 Bot 可用 @@ -165,8 +161,7 @@ def get_bots() -> Dict[str, Bot]: 返回: Dict[str, Bot]: 一个以字符串 ID 为键，Bot 对象为值的字典 - :异常: - + 异常: ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) :用法: diff --git a/nonebot/adapters/_event.py b/nonebot/adapters/_event.py index dcf411bd..c439d0f1 100644 --- a/nonebot/adapters/_event.py +++ b/nonebot/adapters/_event.py @@ -41,9 +41,8 @@ class Event(abc.ABC, BaseModel): """ 获取事件日志信息的方法，通常你不需要修改这个方法，只有当希望 NoneBot 隐藏该事件日志时，可以抛出 `NoLogException` 异常。 - :异常: - - - `NoLogException` + 异常: + NoLogException """ return f"[{self.get_event_name()}]: {self.get_event_description()}" diff --git a/nonebot/plugin/load.py b/nonebot/plugin/load.py index 24da34db..957fa12b 100644 --- a/nonebot/plugin/load.py +++ b/nonebot/plugin/load.py @@ -115,8 +115,8 @@ def require(name: str) -> Export: 参数: name: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。 - :异常: - - `RuntimeError`: 插件无法加载 + 异常: + RuntimeError: 插件无法加载 """ plugin = get_plugin(name) or load_plugin(name) if not plugin: From 6d21cbed55a38f00be73d72c88a3956b3213c507 Mon Sep 17 00:00:00 2001 From: hemengyang Date: Wed, 12 Jan 2022 18:53:30 +0800 Subject: [PATCH 09/14] =?UTF-8?q?=E4=BB=A4=E7=94=A8=E6=B3=95=E7=AC=A6?= =?UTF-8?q?=E5=90=88=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- nonebot/__init__.py | 55 ++++++++++++++---------------------- nonebot/adapters/_bot.py | 7 ++--- nonebot/adapters/_message.py | 7 ++--- nonebot/config.py | 21 ++++++-------- nonebot/exception.py | 15 ++++------ nonebot/log.py | 7 ++--- nonebot/message.py | 7 ++--- nonebot/params.py | 5 ++-- nonebot/permission.py | 7 ++--- nonebot/plugin/export.py | 7 ++--- nonebot/rule.py | 19 ++++++------- 11 files changed, 64 insertions(+), 93 deletions(-) diff --git a/nonebot/__init__.py b/nonebot/__init__.py index a3b105a8..eb5f3805 100644 --- a/nonebot/__init__.py +++ b/nonebot/__init__.py @@ -61,12 +61,10 @@ def get_driver() -> Driver: 异常: ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) - :用法: - - .. code-block:: python - + 用法: + ```python driver = nonebot.get_driver() - + ``` """ if _driver is None: raise ValueError("NoneBot has not been initialized.") @@ -83,12 +81,10 @@ def get_app() -> Any: 异常: ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) - :用法: - - .. code-block:: python - + 用法: + ```python app = nonebot.get_app() - + ``` """ driver = get_driver() assert isinstance( @@ -107,12 +103,10 @@ def get_asgi() -> Any: 异常: ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) - :用法: - - .. code-block:: python - + 用法: + ```python asgi = nonebot.get_asgi() - + ``` """ driver = get_driver() assert isinstance( @@ -136,13 +130,12 @@ def get_bot(self_id: Optional[str] = None) -> Bot: ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) ValueError: 没有传入 ID 且没有 Bot 可用 - :用法: - - .. code-block:: python - + 用法: + ```python assert nonebot.get_bot('12345') == nonebot.get_bots()['12345'] another_unspecified_bot = nonebot.get_bot() + ``` """ bots = get_bots() if self_id is not None: @@ -164,12 +157,10 @@ def get_bots() -> Dict[str, Bot]: 异常: ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) - :用法: - - .. code-block:: python - + 用法: + ```python bots = nonebot.get_bots() - + ``` """ driver = get_driver() return driver.bots @@ -218,12 +209,10 @@ def init(*, _env_file: Optional[str] = None, **kwargs): _env_file: 配置文件名，默认从 .env.{env_name} 中读取配置 **kwargs: 任意变量，将会存储到 Config 对象里 - :用法: - - .. code-block:: python - + 用法: + ```python nonebot.init(database=Database(...)) - + ``` """ global _driver if not _driver: @@ -255,12 +244,10 @@ def run(*args: Any, **kwargs: Any) -> None: *args: 传入 Driver.run 的位置参数 **kwargs: 传入 Driver.run 的命名参数 - :用法: - - .. code-block:: python - + 用法: + ```python nonebot.run(host="127.0.0.1", port=8080) - + ``` """ logger.success("Running NoneBot...") get_driver().run(*args, **kwargs) diff --git a/nonebot/adapters/_bot.py b/nonebot/adapters/_bot.py index f6a35522..eb0cdc23 100644 --- a/nonebot/adapters/_bot.py +++ b/nonebot/adapters/_bot.py @@ -63,12 +63,11 @@ class Bot(abc.ABC): api: API 名称 **data: API 数据 - :示例: - - .. code-block:: python - + 用法: + ```python await bot.call_api("send_msg", message="hello world") await bot.send_msg(message="hello world") + ``` """ result: Any = None diff --git a/nonebot/adapters/_message.py b/nonebot/adapters/_message.py index 1b6f8980..e126e3fb 100644 --- a/nonebot/adapters/_message.py +++ b/nonebot/adapters/_message.py @@ -117,10 +117,8 @@ class Message(List[TMS], abc.ABC): 并且提供了拓展的格式化控制符, 可以用适用于该消息类型的 `MessageSegment` 的工厂方法创建消息 - :示例: - - .. code-block:: python - + 用法: + ```python >>> Message.template("{} {}").format("hello", "world") # 基础演示 Message(MessageSegment(type='text', data={'text': 'hello world'})) >>> Message.template("{} {}").format(MessageSegment.image("file///..."), "world") # 支持消息段等对象 @@ -133,6 +131,7 @@ class Message(List[TMS], abc.ABC): MessageSegment(type='text', data={'text': 'test hello world'})) >>> Message.template("{link:image}").format(link='https://...') # 支持拓展格式化控制符 Message(MessageSegment(type='image', data={'file': 'https://...'})) + ``` 参数: format_string: 格式化字符串 diff --git a/nonebot/config.py b/nonebot/config.py index b7fbfc04..2787b90b 100644 --- a/nonebot/config.py +++ b/nonebot/config.py @@ -177,12 +177,11 @@ class Config(BaseConfig): """ 配置 NoneBot 日志输出等级，可以为 `int` 类型等级或等级名称，参考 `loguru 日志等级`_。 - :示例: - - .. code-block:: default - + 用法: + ```conf LOG_LEVEL=25 LOG_LEVEL=INFO + ``` .. _loguru 日志等级: https://loguru.readthedocs.io/en/stable/api/logger.html#levels @@ -199,11 +198,10 @@ class Config(BaseConfig): """ 机器人超级用户。 - :示例: - - .. code-block:: default - + 用法: + ```conf SUPERUSERS=["12345789"] + ``` """ nickname: Set[str] = set() """ @@ -221,13 +219,12 @@ class Config(BaseConfig): """ 等待用户回复的超时时间。 - :示例: - - .. code-block:: default - + 用法: + ```conf SESSION_EXPIRE_TIMEOUT=120 # 单位: 秒 SESSION_EXPIRE_TIMEOUT=[DD ][HH:MM]SS[.ffffff] SESSION_EXPIRE_TIMEOUT=P[DD]DT[HH]H[MM]M[SS]S # ISO 8601 + ``` """ # adapter configs diff --git a/nonebot/exception.py b/nonebot/exception.py index 94e01633..e501c4fe 100644 --- a/nonebot/exception.py +++ b/nonebot/exception.py @@ -85,8 +85,7 @@ class StopPropagation(ProcessException): """ 指示 NoneBot 终止事件向下层传播。 - :用法: - + 用法: 在 `Matcher.block == True` 时抛出。 """ @@ -102,8 +101,7 @@ class SkippedException(MatcherException): """ 指示 NoneBot 立即结束当前 `Handler` 的处理，继续处理下一个 `Handler`。 - :用法: - + 用法: 可以在 `Handler` 中通过 `Matcher.skip()` 抛出。 """ @@ -129,8 +127,7 @@ class PausedException(MatcherException): 指示 NoneBot 结束当前 `Handler` 并等待下一条消息后继续下一个 `Handler`。 可用于用户输入新信息。 - :用法: - + 用法: 可以在 `Handler` 中通过 `Matcher.pause()` 抛出。 """ @@ -140,8 +137,7 @@ class RejectedException(MatcherException): 指示 NoneBot 结束当前 `Handler` 并等待下一条消息后重新运行当前 `Handler`。 可用于用户重新输入。 - :用法: - + 用法: 可以在 `Handler` 中通过 `Matcher.reject()` 抛出。 """ @@ -151,8 +147,7 @@ class FinishedException(MatcherException): 指示 NoneBot 结束当前 `Handler` 且后续 `Handler` 不再被运行。 可用于结束用户会话。 - :用法: - + 用法: 可以在 `Handler` 中通过 `Matcher.finish()` 抛出。 """ diff --git a/nonebot/log.py b/nonebot/log.py index 30ef16c6..c95d0c2c 100644 --- a/nonebot/log.py +++ b/nonebot/log.py @@ -32,11 +32,10 @@ NoneBot 日志记录器对象。 * 等级: `INFO` ，根据 `config.log_level` 配置改变 * 输出: 输出至 stdout -:用法: - -.. code-block:: python - +用法: + ```python from nonebot.log import logger + ``` """ # default_handler = logging.StreamHandler(sys.stdout) diff --git a/nonebot/message.py b/nonebot/message.py index 932156bd..f3d83de0 100644 --- a/nonebot/message.py +++ b/nonebot/message.py @@ -240,12 +240,11 @@ async def handle_event(bot: "Bot", event: "Event") -> None: bot: Bot 对象 event: Event 对象 - :示例: - - .. code-block:: python - + 用法: + ```python import asyncio asyncio.create_task(handle_event(bot, event)) + ``` """ show_log = True log_msg = f"{escape_tag(bot.type.upper())} {escape_tag(bot.self_id)} | " diff --git a/nonebot/params.py b/nonebot/params.py index 09bb0f04..a6c2cd01 100644 --- a/nonebot/params.py +++ b/nonebot/params.py @@ -62,8 +62,8 @@ def Depends( dependency: 依赖函数。默认为参数的类型注释。 use_cache: 是否使用缓存。默认为 `True`。 - .. code-block:: python - + 用法: + ```python def depend_func() -> Any: return ... @@ -75,6 +75,7 @@ def Depends( async def handler(param_name: Any = Depends(depend_func), gen: Any = Depends(depend_gen_func)): ... + ``` """ return DependsInner(dependency, use_cache=use_cache) diff --git a/nonebot/permission.py b/nonebot/permission.py index d3f662ae..c314aea9 100644 --- a/nonebot/permission.py +++ b/nonebot/permission.py @@ -37,14 +37,13 @@ class Permission: """ `Matcher` 规则类，当事件传递时，在 `Matcher` 运行前进行检查。 - :示例: - - .. code-block:: python - + 用法: + ```python Permission(async_function) | sync_function # 等价于 from nonebot.utils import run_sync Permission(async_function, run_sync(sync_function)) + ``` """ __slots__ = ("checkers",) diff --git a/nonebot/plugin/export.py b/nonebot/plugin/export.py index 7cd62e73..20b86957 100644 --- a/nonebot/plugin/export.py +++ b/nonebot/plugin/export.py @@ -5,10 +5,8 @@ class Export(dict): """ 插件导出内容以使得其他插件可以获得。 - :示例: - - .. code-block:: python - + 用法: + ```python nonebot.export().default = "bar" @nonebot.export() @@ -23,6 +21,7 @@ class Export(dict): @nonebot.export().sub def something_else(): pass + ``` """ def __call__(self, func, **kwargs): diff --git a/nonebot/rule.py b/nonebot/rule.py index b8609ad9..9a814636 100644 --- a/nonebot/rule.py +++ b/nonebot/rule.py @@ -65,14 +65,13 @@ class Rule: """ `Matcher` 规则类，当事件传递时，在 `Matcher` 运行前进行检查。 - :示例: - - .. code-block:: python - + 用法: + ```python Rule(async_function) & sync_function # 等价于 from nonebot.utils import run_sync Rule(async_function, run_sync(sync_function)) + ``` """ __slots__ = ("checkers",) @@ -294,8 +293,7 @@ def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule: 参数: *cmds: 命令内容 - :示例: - + 用法: 使用默认 `command_start`, `command_sep` 配置 命令 `("test",)` 可以匹配：`/test` 开头的消息 @@ -394,18 +392,17 @@ def shell_command( *cmds: 命令内容 parser: `nonebot.rule.ArgumentParser` 对象 - :示例: - - 使用默认 `command_start`, `command_sep` 配置，更多示例参考 `argparse` 标准库文档。 - - .. code-block:: python + 用法: + 使用默认 `command_start`, `command_sep` 配置，更多示例参考 `argparse` 标准库文档。 + ```python from nonebot.rule import ArgumentParser parser = ArgumentParser() parser.add_argument("-a", action="store_true") rule = shell_command("ls", parser=parser) + ``` \:\:\:tip 提示 命令内容与后续消息间无需空格！ From 0e97022d3bba9c5c9ca70987084b4b7958f39456 Mon Sep 17 00:00:00 2001 From: hemengyang Date: Wed, 12 Jan 2022 19:10:29 +0800 Subject: [PATCH 10/14] =?UTF-8?q?=E8=B0=83=E6=95=B4=E7=BC=A9=E8=BF=9B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- nonebot/__init__.py | 34 +-- nonebot/adapters/_adapter.py | 4 +- nonebot/adapters/_bot.py | 29 ++- nonebot/adapters/_event.py | 2 +- nonebot/adapters/_message.py | 10 +- nonebot/adapters/_template.py | 4 +- nonebot/drivers/__init__.py | 10 +- nonebot/drivers/_block_driver.py | 6 - nonebot/exception.py | 10 +- nonebot/matcher.py | 85 ++++--- nonebot/message.py | 4 +- nonebot/params.py | 4 +- nonebot/permission.py | 8 +- nonebot/plugin/load.py | 22 +- nonebot/plugin/on.py | 368 +++++++++++++++---------------- nonebot/plugin/plugin.py | 2 +- nonebot/rule.py | 22 +- nonebot/utils.py | 4 +- 18 files changed, 309 insertions(+), 319 deletions(-) diff --git a/nonebot/__init__.py b/nonebot/__init__.py index eb5f3805..dcc52e0c 100644 --- a/nonebot/__init__.py +++ b/nonebot/__init__.py @@ -56,10 +56,10 @@ def get_driver() -> Driver: 获取全局 Driver 对象。可用于在计划任务的回调中获取当前 Driver 对象。 返回: - Driver: 全局 Driver 对象 + Driver: 全局 Driver 对象 异常: - ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) + ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) 用法: ```python @@ -76,10 +76,10 @@ def get_app() -> Any: 获取全局 Driver 对应 Server App 对象。 返回: - Any: Server App 对象 + Any: Server App 对象 异常: - ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) + ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) 用法: ```python @@ -98,10 +98,10 @@ def get_asgi() -> Any: 获取全局 Driver 对应 Asgi 对象。 返回: - Any: Asgi 对象 + Any: Asgi 对象 异常: - ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) + ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) 用法: ```python @@ -120,15 +120,15 @@ def get_bot(self_id: Optional[str] = None) -> Bot: 当提供 self_id 时，此函数是 get_bots()[self_id] 的简写；当不提供时，返回一个 Bot。 参数: - self_id: 用来识别 Bot 的 ID + self_id: 用来识别 Bot 的 ID 返回: - Bot: Bot 对象 + Bot: Bot 对象 异常: - KeyError: 对应 ID 的 Bot 不存在 - ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) - ValueError: 没有传入 ID 且没有 Bot 可用 + KeyError: 对应 ID 的 Bot 不存在 + ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) + ValueError: 没有传入 ID 且没有 Bot 可用 用法: ```python @@ -152,10 +152,10 @@ def get_bots() -> Dict[str, Bot]: 获取所有通过 ws 连接 NoneBot 的 Bot 对象。 返回: - Dict[str, Bot]: 一个以字符串 ID 为键，Bot 对象为值的字典 + Dict[str, Bot]: 一个以字符串 ID 为键，Bot 对象为值的字典 异常: - ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) + ValueError: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) 用法: ```python @@ -206,8 +206,8 @@ def init(*, _env_file: Optional[str] = None, **kwargs): 你也可以传入自定义的 _env_file 来指定 NoneBot 从该文件读取配置。 参数: - _env_file: 配置文件名，默认从 .env.{env_name} 中读取配置 - **kwargs: 任意变量，将会存储到 Config 对象里 + _env_file: 配置文件名，默认从 .env.{env_name} 中读取配置 + **kwargs: 任意变量，将会存储到 Config 对象里 用法: ```python @@ -241,8 +241,8 @@ def run(*args: Any, **kwargs: Any) -> None: 启动 NoneBot，即运行全局 Driver 对象。 参数: - *args: 传入 Driver.run 的位置参数 - **kwargs: 传入 Driver.run 的命名参数 + *args: 传入 Driver.run 的位置参数 + **kwargs: 传入 Driver.run 的命名参数 用法: ```python diff --git a/nonebot/adapters/_adapter.py b/nonebot/adapters/_adapter.py index 85724723..85cd0847 100644 --- a/nonebot/adapters/_adapter.py +++ b/nonebot/adapters/_adapter.py @@ -66,7 +66,7 @@ class Adapter(abc.ABC): `adapter` 实际调用 api 的逻辑实现函数，实现该方法以调用 api。 参数: - api: API 名称 - **data: API 数据 + api: API 名称 + **data: API 数据 """ raise NotImplementedError diff --git a/nonebot/adapters/_bot.py b/nonebot/adapters/_bot.py index eb0cdc23..238c45df 100644 --- a/nonebot/adapters/_bot.py +++ b/nonebot/adapters/_bot.py @@ -37,8 +37,8 @@ class Bot(abc.ABC): def __init__(self, adapter: "Adapter", self_id: str): """ 参数: - self_id: 机器人 ID - request: request 连接对象 + self_id: 机器人 ID + request: request 连接对象 """ self.adapter: "Adapter" = adapter self.self_id: str = self_id @@ -60,8 +60,8 @@ class Bot(abc.ABC): 调用机器人 API 接口，可以通过该函数或直接通过 bot 属性进行调用 参数: - api: API 名称 - **data: API 数据 + api: API 名称 + **data: API 数据 用法: ```python @@ -127,9 +127,8 @@ class Bot(abc.ABC): 调用机器人基础发送消息接口 参数: - event: 上报事件 - message: 要发送的消息 - **kwargs + event: 上报事件 + message: 要发送的消息 """ raise NotImplementedError @@ -139,9 +138,9 @@ class Bot(abc.ABC): 调用 api 预处理。 参数: - bot: 当前 bot 对象 - api: 调用的 api 名称 - data: api 调用的参数字典 + bot: 当前 bot 对象 + api: 调用的 api 名称 + data: api 调用的参数字典 """ cls._calling_api_hook.add(func) return func @@ -152,11 +151,11 @@ class Bot(abc.ABC): 调用 api 后处理。 参数: - bot: 当前 bot 对象 - exception: 调用 api 时发生的错误 - api: 调用的 api 名称 - data: api 调用的参数字典 - result: api 调用的返回 + bot: 当前 bot 对象 + exception: 调用 api 时发生的错误 + api: 调用的 api 名称 + data: api 调用的参数字典 + result: api 调用的返回 """ cls._called_api_hook.add(func) return func diff --git a/nonebot/adapters/_event.py b/nonebot/adapters/_event.py index c439d0f1..e7780bb2 100644 --- a/nonebot/adapters/_event.py +++ b/nonebot/adapters/_event.py @@ -42,7 +42,7 @@ class Event(abc.ABC, BaseModel): 获取事件日志信息的方法，通常你不需要修改这个方法，只有当希望 NoneBot 隐藏该事件日志时，可以抛出 `NoLogException` 异常。 异常: - NoLogException + NoLogException """ return f"[{self.get_event_name()}]: {self.get_event_description()}" diff --git a/nonebot/adapters/_message.py b/nonebot/adapters/_message.py index e126e3fb..52db50ee 100644 --- a/nonebot/adapters/_message.py +++ b/nonebot/adapters/_message.py @@ -98,7 +98,7 @@ class Message(List[TMS], abc.ABC): ): """ 参数: - message: 消息内容 + message: 消息内容 """ super().__init__(*args, **kwargs) if message is None: @@ -134,10 +134,10 @@ class Message(List[TMS], abc.ABC): ``` 参数: - format_string: 格式化字符串 + format_string: 格式化字符串 返回: - MessageFormatter[TM]: 消息格式化器 + MessageFormatter[TM]: 消息格式化器 """ return MessageTemplate(format_string, cls) @@ -185,7 +185,7 @@ class Message(List[TMS], abc.ABC): 添加一个消息段到消息数组末尾 参数: - obj: 要添加的消息段 + obj: 要添加的消息段 """ if isinstance(obj, MessageSegment): super(Message, self).append(obj) @@ -200,7 +200,7 @@ class Message(List[TMS], abc.ABC): 拼接一个消息数组或多个消息段到消息数组末尾 参数: - obj: 要添加的消息数组 + obj: 要添加的消息数组 """ for segment in obj: self.append(segment) diff --git a/nonebot/adapters/_template.py b/nonebot/adapters/_template.py index cd182b41..b3edf51d 100644 --- a/nonebot/adapters/_template.py +++ b/nonebot/adapters/_template.py @@ -50,8 +50,8 @@ class MessageTemplate(Formatter, Generic[TF]): 创建一个模板 参数: - template: 模板 - factory: 消息构造类型，默认为 `str` + template: 模板 + factory: 消息构造类型，默认为 `str` """ self.template: TF = template self.factory: Type[TF] = factory diff --git a/nonebot/drivers/__init__.py b/nonebot/drivers/__init__.py index 697e15db..4564ed28 100644 --- a/nonebot/drivers/__init__.py +++ b/nonebot/drivers/__init__.py @@ -55,8 +55,8 @@ class Driver(abc.ABC): def __init__(self, env: Env, config: Config): """ 参数: - env: 包含环境信息的 Env 对象 - config: 包含配置信息的 Config 对象 + env: 包含环境信息的 Env 对象 + config: 包含配置信息的 Config 对象 """ self.env: str = env.environment """ @@ -83,9 +83,9 @@ class Driver(abc.ABC): 注册一个协议适配器 参数: - name: 适配器名称，用于在连接时进行识别 - adapter: 适配器 Class - **kwargs: 其他传递给适配器的参数 + name: 适配器名称，用于在连接时进行识别 + adapter: 适配器 Class + **kwargs: 其他传递给适配器的参数 """ name = adapter.get_name() if name in self._adapters: diff --git a/nonebot/drivers/_block_driver.py b/nonebot/drivers/_block_driver.py index e8bcd138..bf87659b 100644 --- a/nonebot/drivers/_block_driver.py +++ b/nonebot/drivers/_block_driver.py @@ -40,9 +40,6 @@ class BlockDriver(Driver): def on_startup(self, func: STARTUP_FUNC) -> STARTUP_FUNC: """ 注册一个启动时执行的函数 - - 参数: - func """ self.startup_funcs.add(func) return func @@ -51,9 +48,6 @@ class BlockDriver(Driver): def on_shutdown(self, func: SHUTDOWN_FUNC) -> SHUTDOWN_FUNC: """ 注册一个停止时执行的函数 - - 参数: - func """ self.shutdown_funcs.add(func) return func diff --git a/nonebot/exception.py b/nonebot/exception.py index e501c4fe..3c6bdb39 100644 --- a/nonebot/exception.py +++ b/nonebot/exception.py @@ -21,10 +21,6 @@ class NoneBotException(Exception): class ParserExit(NoneBotException): """ `shell command` 处理消息失败时返回的异常 - - 参数: - status - message """ def __init__(self, status: int = 0, message: Optional[str] = None): @@ -50,7 +46,7 @@ class IgnoredException(ProcessException): 指示 NoneBot 应该忽略该事件。可由 PreProcessor 抛出。 参数: - reason: 忽略事件的原因 + reason: 忽略事件的原因 """ def __init__(self, reason): @@ -68,7 +64,7 @@ class MockApiException(ProcessException): 指示 NoneBot 阻止本次 API 调用或修改本次调用返回值，并返回自定义内容。可由 api hook 抛出。 参数: - result: 返回的内容 + result: 返回的内容 """ def __init__(self, result: Any): @@ -158,7 +154,7 @@ class AdapterException(NoneBotException): 代表 `Adapter` 抛出的异常，所有的 `Adapter` 都要在内部继承自这个 `Exception` 参数: - adapter_name: 标识 adapter + adapter_name: 标识 adapter """ def __init__(self, adapter_name: str) -> None: diff --git a/nonebot/matcher.py b/nonebot/matcher.py index 087c172b..2c9c8878 100644 --- a/nonebot/matcher.py +++ b/nonebot/matcher.py @@ -213,20 +213,20 @@ class Matcher(metaclass=MatcherMeta): 创建一个新的事件响应器，并存储至 `matchers <#matchers>`_ 参数: - type_: 事件响应器类型，与 `event.get_type()` 一致时触发，空字符串表示任意 - rule: 匹配规则 - permission: 权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器，即触发一次后删除 - priority: 响应优先级 - block: 是否阻止事件向更低优先级的响应器传播 - plugin: 事件响应器所在插件 - module: 事件响应器所在模块 - default_state: 默认状态 `state` - expire_time: 事件响应器最终有效时间点，过时即被删除 + type_: 事件响应器类型，与 `event.get_type()` 一致时触发，空字符串表示任意 + rule: 匹配规则 + permission: 权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器，即触发一次后删除 + priority: 响应优先级 + block: 是否阻止事件向更低优先级的响应器传播 + plugin: 事件响应器所在插件 + module: 事件响应器所在模块 + default_state: 默认状态 `state` + expire_time: 事件响应器最终有效时间点，过时即被删除 返回: - Type[Matcher]: 新的事件响应器类 + Type[Matcher]: 新的事件响应器类 """ NewMatcher = type( "Matcher", @@ -277,11 +277,11 @@ class Matcher(metaclass=MatcherMeta): 检查是否满足触发权限 参数: - bot: Bot 对象 - event: 上报事件 + bot: Bot 对象 + event: 上报事件 返回: - bool: 是否满足权限 + bool: 是否满足权限 """ event_type = event.get_type() return event_type == (cls.type or event_type) and await cls.permission( @@ -301,12 +301,12 @@ class Matcher(metaclass=MatcherMeta): 检查是否满足匹配规则 参数: - bot: Bot 对象 - event: 上报事件 - state: 当前状态 + bot: Bot 对象 + event: 上报事件 + state: 当前状态 返回: - bool: 是否满足匹配规则 + bool: 是否满足匹配规则 """ event_type = event.get_type() return event_type == (cls.type or event_type) and await cls.rule( @@ -319,7 +319,7 @@ class Matcher(metaclass=MatcherMeta): 装饰一个函数来更改当前事件响应器的默认响应事件类型更新函数 参数: - func: 响应事件类型更新函数 + func: 响应事件类型更新函数 """ cls._default_type_updater = Dependent[str].parse( call=func, allow_types=cls.HANDLER_PARAM_TYPES @@ -332,7 +332,7 @@ class Matcher(metaclass=MatcherMeta): 装饰一个函数来更改当前事件响应器的默认会话权限更新函数 参数: - func: 会话权限更新函数 + func: 会话权限更新函数 """ cls._default_permission_updater = Dependent[Permission].parse( call=func, allow_types=cls.HANDLER_PARAM_TYPES @@ -359,7 +359,7 @@ class Matcher(metaclass=MatcherMeta): 装饰一个函数来向事件响应器直接添加一个处理函数 参数: - parameterless: 非参数类型依赖列表 + parameterless: 非参数类型依赖列表 """ def _decorator(func: T_Handler) -> T_Handler: @@ -376,8 +376,8 @@ class Matcher(metaclass=MatcherMeta): 装饰一个函数来指示 NoneBot 在接收用户新的一条消息后继续运行该函数 参数: - id: 消息 ID - parameterless: 非参数类型依赖列表 + id: 消息 ID + parameterless: 非参数类型依赖列表 """ async def _receive(event: Event, matcher: "Matcher") -> Union[None, NoReturn]: @@ -412,13 +412,12 @@ class Matcher(metaclass=MatcherMeta): parameterless: Optional[List[Any]] = None, ) -> Callable[[T_Handler], T_Handler]: """ - 装饰一个函数来指示 NoneBot 当要获取的 `key` 不存在时接收用户新的一条消息并经过 `ArgsParser` 处理后再运行该函数，如果 `key` 已存在则直接继续运行 + 装饰一个函数来指示 NoneBot 当要获取的 `key` 不存在时接收用户新的一条消息再运行该函数，如果 `key` 已存在则直接继续运行 参数: - key: 参数名 - prompt: 在参数不存在时向用户发送的消息 - args_parser: 可选参数解析函数，空则使用默认解析函数 - parameterless: 非参数类型依赖列表 + key: 参数名 + prompt: 在参数不存在时向用户发送的消息 + parameterless: 非参数类型依赖列表 """ async def _key_getter(event: Event, matcher: "Matcher"): @@ -458,8 +457,8 @@ class Matcher(metaclass=MatcherMeta): 发送一条消息给当前交互用户 参数: - message: 消息内容 - **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api + message: 消息内容 + **kwargs: `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ bot = current_bot.get() event = current_event.get() @@ -480,8 +479,8 @@ class Matcher(metaclass=MatcherMeta): 发送一条消息给当前交互用户并结束当前事件响应器 参数: - message: 消息内容 - **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api + message: 消息内容 + **kwargs: `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ if message is not None: await cls.send(message, **kwargs) @@ -497,8 +496,8 @@ class Matcher(metaclass=MatcherMeta): 发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续下一个处理函数 参数: - prompt: 消息内容 - **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api + prompt: 消息内容 + **kwargs`: bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ if prompt is not None: await cls.send(prompt, **kwargs) @@ -514,8 +513,8 @@ class Matcher(metaclass=MatcherMeta): 最近使用 `got` / `receive` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 参数: - prompt: 消息内容 - **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api + prompt: 消息内容 + **kwargs: `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ if prompt is not None: await cls.send(prompt, **kwargs) @@ -532,9 +531,9 @@ class Matcher(metaclass=MatcherMeta): 最近使用 `got` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 参数: - key: 参数名 - prompt: 消息内容 - **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api + key: 参数名 + prompt: 消息内容 + **kwargs: `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ matcher = current_matcher.get() matcher.set_target(ARG_KEY.format(key=key)) @@ -553,9 +552,9 @@ class Matcher(metaclass=MatcherMeta): 最近使用 `got` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 参数: - id: 消息 id - prompt: 消息内容 - **kwargs`bot.send` 的参数，请参考对应 adapter 的 bot 对象 api + id: 消息 id + prompt: 消息内容 + **kwargs: `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api """ matcher = current_matcher.get() matcher.set_target(RECEIVE_KEY.format(id=id)) diff --git a/nonebot/message.py b/nonebot/message.py index f3d83de0..877ee7ad 100644 --- a/nonebot/message.py +++ b/nonebot/message.py @@ -237,8 +237,8 @@ async def handle_event(bot: "Bot", event: "Event") -> None: 处理一个事件。调用该函数以实现分发事件。 参数: - bot: Bot 对象 - event: Event 对象 + bot: Bot 对象 + event: Event 对象 用法: ```python diff --git a/nonebot/params.py b/nonebot/params.py index a6c2cd01..ad1d3e63 100644 --- a/nonebot/params.py +++ b/nonebot/params.py @@ -59,8 +59,8 @@ def Depends( 参数依赖注入装饰器 参数: - dependency: 依赖函数。默认为参数的类型注释。 - use_cache: 是否使用缓存。默认为 `True`。 + dependency: 依赖函数。默认为参数的类型注释。 + use_cache: 是否使用缓存。默认为 `True`。 用法: ```python diff --git a/nonebot/permission.py b/nonebot/permission.py index c314aea9..18ce52df 100644 --- a/nonebot/permission.py +++ b/nonebot/permission.py @@ -84,10 +84,10 @@ class Permission: 检查是否满足某个权限 参数: - bot: Bot 对象 - event: Event 对象 - stack: 异步上下文栈 - dependency_cache: 依赖缓存 + bot: Bot 对象 + event: Event 对象 + stack: 异步上下文栈 + dependency_cache: 依赖缓存 """ if not self.checkers: return True diff --git a/nonebot/plugin/load.py b/nonebot/plugin/load.py index 957fa12b..6ebb93bf 100644 --- a/nonebot/plugin/load.py +++ b/nonebot/plugin/load.py @@ -15,7 +15,7 @@ def load_plugin(module_path: str) -> Optional[Plugin]: 使用 `PluginManager` 加载单个插件，可以是本地插件或是通过 `pip` 安装的插件。 参数: - module_path: 插件名称 `path.to.your.plugin` + module_path: 插件名称 `path.to.your.plugin` """ manager = PluginManager([module_path]) @@ -28,7 +28,7 @@ def load_plugins(*plugin_dir: str) -> Set[Plugin]: 导入目录下多个插件，以 `_` 开头的插件不会被导入！ 参数: - plugin_dir: 插件路径 + plugin_dir: 插件路径 """ manager = PluginManager(search_path=plugin_dir) _managers.append(manager) @@ -42,8 +42,8 @@ def load_all_plugins( 导入指定列表中的插件以及指定目录下多个插件，以 `_` 开头的插件不会被导入！ 参数: - module_path: 指定插件集合 - plugin_dir: 指定插件路径集合 + module_path: 指定插件集合 + plugin_dir: 指定插件路径集合 """ manager = PluginManager(module_path, plugin_dir) _managers.append(manager) @@ -55,8 +55,9 @@ def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]: 导入指定 json 文件中的 `plugins` 以及 `plugin_dirs` 下多个插件，以 `_` 开头的插件不会被导入！ 参数: - file_path: 指定 json 文件路径 - encoding: 指定 json 文件编码""" + file_path: 指定 json 文件路径 + encoding: 指定 json 文件编码 + """ with open(file_path, "r", encoding=encoding) as f: data = json.load(f) plugins = data.get("plugins") @@ -72,8 +73,9 @@ def load_from_toml(file_path: str, encoding: str = "utf-8") -> Set[Plugin]: 以 `_` 开头的插件不会被导入！ 参数: - file_path: 指定 toml 文件路径 - encoding: 指定 toml 文件编码""" + file_path: 指定 toml 文件路径 + encoding: 指定 toml 文件编码 + """ with open(file_path, "r", encoding=encoding) as f: data = tomlkit.parse(f.read()) # type: ignore @@ -113,10 +115,10 @@ def require(name: str) -> Export: 获取一个插件的导出内容 参数: - name: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。 + name: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。 异常: - RuntimeError: 插件无法加载 + RuntimeError: 插件无法加载 """ plugin = get_plugin(name) or load_plugin(name) if not plugin: diff --git a/nonebot/plugin/on.py b/nonebot/plugin/on.py index f0fb8c93..d03b1965 100644 --- a/nonebot/plugin/on.py +++ b/nonebot/plugin/on.py @@ -58,14 +58,14 @@ def on( 注册一个基础事件响应器，可自定义类型。 参数: - type: 事件响应器类型 - rule: 事件响应规则 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + type: 事件响应器类型 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ matcher = Matcher.new( type, @@ -97,12 +97,12 @@ def on_metaevent( 注册一个元事件响应器。 参数: - rule: 事件响应规则 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + rule: 事件响应规则 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ matcher = Matcher.new( "meta_event", @@ -135,13 +135,13 @@ def on_message( 注册一个消息事件响应器。 参数: - rule: 事件响应规则 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ matcher = Matcher.new( "message", @@ -173,12 +173,12 @@ def on_notice( 注册一个通知事件响应器。 参数: - rule: 事件响应规则 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + rule: 事件响应规则 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ matcher = Matcher.new( "notice", @@ -210,12 +210,12 @@ def on_request( 注册一个请求事件响应器。 参数: - rule: 事件响应规则 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + rule: 事件响应规则 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ matcher = Matcher.new( "request", @@ -244,15 +244,15 @@ def on_startswith( 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。 参数: - msg: 指定消息开头内容 - rule: 事件响应规则 - ignorecase: 是否忽略大小写 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + msg: 指定消息开头内容 + rule: 事件响应规则 + ignorecase: 是否忽略大小写 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ return on_message(startswith(msg, ignorecase) & rule, **kwargs, _depth=_depth + 1) @@ -268,15 +268,15 @@ def on_endswith( 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。 参数: - msg: 指定消息结尾内容 - rule: 事件响应规则 - ignorecase: 是否忽略大小写 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + msg: 指定消息结尾内容 + rule: 事件响应规则 + ignorecase: 是否忽略大小写 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ return on_message(endswith(msg, ignorecase) & rule, **kwargs, _depth=_depth + 1) @@ -291,14 +291,14 @@ def on_keyword( 注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。 参数: - keywords: 关键词列表 - rule: 事件响应规则 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + keywords: 关键词列表 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ return on_message(keyword(*keywords) & rule, **kwargs, _depth=_depth + 1) @@ -313,18 +313,18 @@ def on_command( """ 注册一个消息事件响应器，并且当消息以指定命令开头时响应。 - 命令匹配规则参考: `命令形式匹配 `_ + 命令匹配规则参考: `命令形式匹配 `_ 参数: - cmd: 指定命令内容 - rule: 事件响应规则 - aliases: 命令别名 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + cmd: 指定命令内容 + rule: 事件响应规则 + aliases: 命令别名 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ commands = set([cmd]) | (aliases or set()) @@ -345,21 +345,21 @@ def on_shell_command( """ 注册一个支持 `shell_like` 解析参数的命令消息事件响应器。 - 与普通的 `on_command` 不同的是，在添加 `parser` 参数时, 响应器会自动处理消息。 + 与普通的 `on_command` 不同的是，在添加 `parser` 参数时, 响应器会自动处理消息。 - 并将用户输入的原始参数列表保存在 `state["argv"]`, `parser` 处理的参数保存在 `state["args"]` 中 + 并将用户输入的原始参数列表保存在 `state["argv"]`, `parser` 处理的参数保存在 `state["args"]` 中 参数: - cmd: 指定命令内容 - rule: 事件响应规则 - aliases: 命令别名 - parser: `nonebot.rule.ArgumentParser` 对象 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + cmd: 指定命令内容 + rule: 事件响应规则 + aliases: 命令别名 + parser: `nonebot.rule.ArgumentParser` 对象 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ commands = set([cmd]) | (aliases or set()) @@ -380,18 +380,18 @@ def on_regex( """ 注册一个消息事件响应器，并且当消息匹配正则表达式时响应。 - 命令匹配规则参考: `正则匹配 `_ + 命令匹配规则参考: `正则匹配 `_ 参数: - pattern: 正则表达式 - flags: 正则匹配标志 - rule: 事件响应规则 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + pattern: 正则表达式 + flags: 正则匹配标志 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ return on_message(regex(pattern, flags) & rule, **kwargs, _depth=_depth + 1) @@ -402,8 +402,8 @@ class CommandGroup: def __init__(self, cmd: Union[str, Tuple[str, ...]], **kwargs): """ 参数: - cmd: 命令前缀 - **kwargs`on_command` 的参数默认值，参考 `on_command <#on-command-cmd-rule-none-aliases-none-kwargs>`_ + cmd: 命令前缀 + **kwargs: `on_command` 的参数默认值，参考 `on_command <#on-command-cmd-rule-none-aliases-none-kwargs>`_ """ self.basecmd: Tuple[str, ...] = (cmd,) if isinstance(cmd, str) else cmd """ @@ -421,8 +421,8 @@ class CommandGroup: 注册一个新的命令。 参数: - cmd: 命令前缀 - **kwargs`on_command` 的参数，将会覆盖命令组默认值 + cmd: 命令前缀 + **kwargs: `on_command` 的参数，将会覆盖命令组默认值 """ sub_cmd = (cmd,) if isinstance(cmd, str) else cmd cmd = self.basecmd + sub_cmd @@ -438,8 +438,8 @@ class CommandGroup: 注册一个新的命令。 参数: - cmd: 命令前缀 - **kwargs`on_shell_command` 的参数，将会覆盖命令组默认值 + cmd: 命令前缀 + **kwargs: `on_shell_command` 的参数，将会覆盖命令组默认值 """ sub_cmd = (cmd,) if isinstance(cmd, str) else cmd cmd = self.basecmd + sub_cmd @@ -470,14 +470,14 @@ class MatcherGroup: 注册一个基础事件响应器，可自定义类型。 参数: - type: 事件响应器类型 - rule: 事件响应规则 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + type: 事件响应器类型 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -490,12 +490,12 @@ class MatcherGroup: 注册一个元事件响应器。 参数: - rule: 事件响应规则 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + rule: 事件响应规则 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -510,13 +510,13 @@ class MatcherGroup: 注册一个消息事件响应器。 参数: - rule: 事件响应规则 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -530,12 +530,12 @@ class MatcherGroup: 注册一个通知事件响应器。 参数: - rule: 事件响应规则 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + rule: 事件响应规则 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -549,12 +549,12 @@ class MatcherGroup: 注册一个请求事件响应器。 参数: - rule: 事件响应规则 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + rule: 事件响应规则 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -570,15 +570,15 @@ class MatcherGroup: 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。 参数: - msg: 指定消息开头内容 - ignorecase: 是否忽略大小写 - rule: 事件响应规则 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + msg: 指定消息开头内容 + ignorecase: 是否忽略大小写 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -592,15 +592,15 @@ class MatcherGroup: 注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。 参数: - msg: 指定消息结尾内容 - ignorecase: 是否忽略大小写 - rule: 事件响应规则 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + msg: 指定消息结尾内容 + ignorecase: 是否忽略大小写 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -614,14 +614,14 @@ class MatcherGroup: 注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。 参数: - keywords: 关键词列表 - rule: 事件响应规则 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + keywords: 关键词列表 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -642,15 +642,15 @@ class MatcherGroup: 命令匹配规则参考: `命令形式匹配 `_ 参数: - cmd: 指定命令内容 - aliases: 命令别名 - rule: 事件响应规则 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + cmd: 指定命令内容 + aliases: 命令别名 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -674,16 +674,16 @@ class MatcherGroup: 并将用户输入的原始参数列表保存在 `state["argv"]`, `parser` 处理的参数保存在 `state["args"]` 中 参数: - cmd: 指定命令内容 - aliases: 命令别名 - parser: `nonebot.rule.ArgumentParser` 对象 - rule: 事件响应规则 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + cmd: 指定命令内容 + aliases: 命令别名 + parser: `nonebot.rule.ArgumentParser` 对象 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) @@ -703,15 +703,15 @@ class MatcherGroup: 命令匹配规则参考: `正则匹配 `_ 参数: - pattern: 正则表达式 - flags: 正则匹配标志 - rule: 事件响应规则 - permission: 事件响应权限 - handlers: 事件处理函数列表 - temp: 是否为临时事件响应器（仅执行一次） - priority: 事件响应器优先级 - block: 是否阻止事件向更低优先级传递 - state: 默认 state + pattern: 正则表达式 + flags: 正则匹配标志 + rule: 事件响应规则 + permission: 事件响应权限 + handlers: 事件处理函数列表 + temp: 是否为临时事件响应器（仅执行一次） + priority: 事件响应器优先级 + block: 是否阻止事件向更低优先级传递 + state: 默认 state """ final_kwargs = self.base_kwargs.copy() final_kwargs.update(kwargs) diff --git a/nonebot/plugin/plugin.py b/nonebot/plugin/plugin.py index 82e4f806..58098e12 100644 --- a/nonebot/plugin/plugin.py +++ b/nonebot/plugin/plugin.py @@ -57,7 +57,7 @@ def get_plugin(name: str) -> Optional[Plugin]: 获取当前导入的某个插件。 参数: - name: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。 + name: 插件名，与 `load_plugin` 参数一致。如果为 `load_plugins` 导入的插件，则为文件(夹)名。 """ return plugins.get(name) diff --git a/nonebot/rule.py b/nonebot/rule.py index 9a814636..36e19d80 100644 --- a/nonebot/rule.py +++ b/nonebot/rule.py @@ -114,11 +114,11 @@ class Rule: 检查是否符合所有规则 参数: - bot: Bot 对象 - event: Event 对象 - state: 当前 State - stack: 异步上下文栈 - dependency_cache: 依赖缓存 + bot: Bot 对象 + event: Event 对象 + state: 当前 State + stack: 异步上下文栈 + dependency_cache: 依赖缓存 """ if not self.checkers: return True @@ -210,7 +210,7 @@ def startswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Ru 匹配消息开头 参数: - msg: 消息开头字符串 + msg: 消息开头字符串 """ if isinstance(msg, str): msg = (msg,) @@ -242,7 +242,7 @@ def endswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule 匹配消息结尾 参数: - msg: 消息结尾字符串 + msg: 消息结尾字符串 """ if isinstance(msg, str): msg = (msg,) @@ -458,12 +458,12 @@ def regex(regex: str, flags: Union[int, re.RegexFlag] = 0) -> Rule: r""" 根据正则表达式进行匹配。 - 可以通过 `state["_matched"]` `state["_matched_groups"]` `state["_matched_dict"]` - 获取正则表达式匹配成功的文本。 + 可以通过 `state["_matched"]` `state["_matched_groups"]` `state["_matched_dict"]` + 获取正则表达式匹配成功的文本。 参数: - regex: 正则表达式 - flags: 正则标志 + regex: 正则表达式 + flags: 正则标志 \:\:\:tip 提示 正则表达式匹配使用 search 而非 match，如需从头匹配请使用 `r"^xxx"` 来确保匹配开头 diff --git a/nonebot/utils.py b/nonebot/utils.py index 8c55af14..ced56782 100644 --- a/nonebot/utils.py +++ b/nonebot/utils.py @@ -34,7 +34,7 @@ def escape_tag(s: str) -> str: 用于记录带颜色日志时转义 `` 类型特殊标签 参数: - s: 需要转义的字符串 + s: 需要转义的字符串 """ return re.sub(r"\s]*)>", r"\\\g<0>", s) @@ -86,7 +86,7 @@ def run_sync(call: Callable[P, R]) -> Callable[P, Awaitable[R]]: 一个用于包装 sync function 为 async function 的装饰器 参数: - call: 被装饰的同步函数 + call: 被装饰的同步函数 """ @wraps(call) From f298930f9d8d427a109d172ab7810ab3da181d52 Mon Sep 17 00:00:00 2001 From: hemengyang Date: Wed, 12 Jan 2022 19:15:56 +0800 Subject: [PATCH 11/14] =?UTF-8?q?=E6=9B=B4=E6=96=B0=E4=BE=9D=E8=B5=96?= =?UTF-8?q?=E5=8F=82=E6=95=B0=E7=9A=84=E6=B3=A8=E9=87=8A?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- nonebot/typing.py | 136 +++++++++++++++++++++++----------------------- 1 file changed, 68 insertions(+), 68 deletions(-) diff --git a/nonebot/typing.py b/nonebot/typing.py index c9528424..d863905c 100644 --- a/nonebot/typing.py +++ b/nonebot/typing.py @@ -71,78 +71,78 @@ T_CalledAPIHook = Callable[ T_EventPreProcessor = Callable[..., Union[None, Awaitable[None]]] """ -:依赖参数: - - DependParam: 子依赖参数 - BotParam: Bot 对象 - EventParam: Event 对象 - StateParam: State 对象 - DefaultParam: 带有默认值的参数 - 事件预处理函数 EventPreProcessor 类型 + +依赖参数: + + - DependParam: 子依赖参数 + - BotParam: Bot 对象 + - EventParam: Event 对象 + - StateParam: State 对象 + - DefaultParam: 带有默认值的参数 """ T_EventPostProcessor = Callable[..., Union[None, Awaitable[None]]] """ -:依赖参数: - - DependParam: 子依赖参数 - BotParam: Bot 对象 - EventParam: Event 对象 - StateParam: State 对象 - DefaultParam: 带有默认值的参数 - 事件预处理函数 EventPostProcessor 类型 + +依赖参数: + + - DependParam: 子依赖参数 + - BotParam: Bot 对象 + - EventParam: Event 对象 + - StateParam: State 对象 + - DefaultParam: 带有默认值的参数 """ T_RunPreProcessor = Callable[..., Union[None, Awaitable[None]]] """ -:依赖参数: - - DependParam: 子依赖参数 - BotParam: Bot 对象 - EventParam: Event 对象 - StateParam: State 对象 - MatcherParam: Matcher 对象 - DefaultParam: 带有默认值的参数 - 事件响应器运行前预处理函数 RunPreProcessor 类型 + +依赖参数: + + - DependParam: 子依赖参数 + - BotParam: Bot 对象 + - EventParam: Event 对象 + - StateParam: State 对象 + - MatcherParam: Matcher 对象 + - DefaultParam: 带有默认值的参数 """ T_RunPostProcessor = Callable[..., Union[None, Awaitable[None]]] """ -:依赖参数: - - DependParam: 子依赖参数 - BotParam: Bot 对象 - EventParam: Event 对象 - StateParam: State 对象 - MatcherParam: Matcher 对象 - ExceptionParam: 异常对象（可能为 None） - DefaultParam: 带有默认值的参数 - 事件响应器运行前预处理函数 RunPostProcessor 类型，第二个参数为运行时产生的错误（如果存在） + +依赖参数: + + - DependParam: 子依赖参数 + - BotParam: Bot 对象 + - EventParam: Event 对象 + - StateParam: State 对象 + - MatcherParam: Matcher 对象 + - ExceptionParam: 异常对象（可能为 None） + - DefaultParam: 带有默认值的参数 """ T_RuleChecker = Callable[..., Union[bool, Awaitable[bool]]] """ -:依赖参数: - - DependParam: 子依赖参数 - BotParam: Bot 对象 - EventParam: Event 对象 - StateParam: State 对象 - DefaultParam: 带有默认值的参数 - RuleChecker 即判断是否响应事件的处理函数。 + +依赖参数: + + - DependParam: 子依赖参数 + - BotParam: Bot 对象 + - EventParam: Event 对象 + - StateParam: State 对象 + - DefaultParam: 带有默认值的参数 """ T_PermissionChecker = Callable[..., Union[bool, Awaitable[bool]]] """ -:依赖参数: - - DependParam: 子依赖参数 - BotParam: Bot 对象 - EventParam: Event 对象 - DefaultParam: 带有默认值的参数 - RuleChecker 即判断是否响应消息的处理函数。 + +依赖参数: + + - DependParam: 子依赖参数 + - BotParam: Bot 对象 + - EventParam: Event 对象 + - DefaultParam: 带有默认值的参数 """ T_Handler = Callable[..., Any] @@ -151,29 +151,29 @@ Handler 处理函数。 """ T_TypeUpdater = Callable[..., Union[str, Awaitable[str]]] """ -:依赖参数: - - DependParam: 子依赖参数 - BotParam: Bot 对象 - EventParam: Event 对象 - StateParam: State 对象 - MatcherParam: Matcher 对象 - DefaultParam: 带有默认值的参数 - TypeUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新响应的事件类型。默认会更新为 `message`。 + +依赖参数: + + - DependParam: 子依赖参数 + - BotParam: Bot 对象 + - EventParam: Event 对象 + - StateParam: State 对象 + - MatcherParam: Matcher 对象 + - DefaultParam: 带有默认值的参数 """ T_PermissionUpdater = Callable[..., Union["Permission", Awaitable["Permission"]]] """ -:依赖参数: - - DependParam: 子依赖参数 - BotParam: Bot 对象 - EventParam: Event 对象 - StateParam: State 对象 - MatcherParam: Matcher 对象 - DefaultParam: 带有默认值的参数 - PermissionUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新会话对象权限。默认会更新为当前事件的触发对象。 + +依赖参数: + + - DependParam: 子依赖参数 + - BotParam: Bot 对象 + - EventParam: Event 对象 + - StateParam: State 对象 + - MatcherParam: Matcher 对象 + - DefaultParam: 带有默认值的参数 """ T_DependencyCache = Dict[Callable[..., Any], "Task[Any]"] """ From cd69b22d4338a40fe0e75a0431da576e054a865a Mon Sep 17 00:00:00 2001 From: hemengyang Date: Wed, 12 Jan 2022 19:20:59 +0800 Subject: [PATCH 12/14] =?UTF-8?q?=E4=BB=A4=20tip=20=E7=AC=A6=E5=90=88?= =?UTF-8?q?=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- nonebot/permission.py | 6 +++--- nonebot/rule.py | 40 ++++++++++++++++++++-------------------- 2 files changed, 23 insertions(+), 23 deletions(-) diff --git a/nonebot/permission.py b/nonebot/permission.py index 18ce52df..d5a0cf56 100644 --- a/nonebot/permission.py +++ b/nonebot/permission.py @@ -1,12 +1,12 @@ -r""" +""" 权限 ==== 每个 `Matcher` 拥有一个 `Permission` ，其中是 `PermissionChecker` 的集合，只要有一个 `PermissionChecker` 检查结果为 `True` 时就会继续运行。 -\:\:\:tip 提示 +::: tip 提示 `PermissionChecker` 既可以是 async function 也可以是 sync function -\:\:\: +::: """ import asyncio diff --git a/nonebot/rule.py b/nonebot/rule.py index 36e19d80..88c5e9da 100644 --- a/nonebot/rule.py +++ b/nonebot/rule.py @@ -1,12 +1,12 @@ -r""" +""" 规则 ==== 每个事件响应器 `Matcher` 拥有一个匹配规则 `Rule` ，其中是 `RuleChecker` 的集合，只有当所有 `RuleChecker` 检查结果为 `True` 时继续运行。 -\:\:\:tip 提示 +::: tip 提示 `RuleChecker` 既可以是 async function 也可以是 sync function -\:\:\: +::: """ import re @@ -267,7 +267,7 @@ def keyword(*keywords: str) -> Rule: 匹配消息关键词 参数: - *keywords: 关键词 + *keywords: 关键词 """ return Rule(KeywordsRule(*keywords)) @@ -285,23 +285,23 @@ class CommandRule: def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule: - r""" + """ 命令形式匹配，根据配置里提供的 `command_start`, `command_sep` 判断消息是否为命令。 - 可以通过 `state["_prefix"]["command"]` 获取匹配成功的命令（例：`("test",)`），通过 `state["_prefix"]["raw_command"]` 获取匹配成功的原始命令文本（例：`"/test"`）。 + 可以通过 `state["_prefix"]["command"]` 获取匹配成功的命令（例：`("test",)`），通过 `state["_prefix"]["raw_command"]` 获取匹配成功的原始命令文本（例：`"/test"`）。 参数: - *cmds: 命令内容 + *cmds: 命令内容 用法: - 使用默认 `command_start`, `command_sep` 配置 + 使用默认 `command_start`, `command_sep` 配置 - 命令 `("test",)` 可以匹配：`/test` 开头的消息 - 命令 `("test", "sub")` 可以匹配”`/test.sub` 开头的消息 + 命令 `("test",)` 可以匹配：`/test` 开头的消息 + 命令 `("test", "sub")` 可以匹配”`/test.sub` 开头的消息 - \:\:\:tip 提示 + ::: tip 提示 命令内容与后续消息间无需空格！ - \:\:\: + ::: """ config = get_driver().config @@ -379,7 +379,7 @@ class ShellCommandRule: def shell_command( *cmds: Union[str, Tuple[str, ...]], parser: Optional[ArgumentParser] = None ) -> Rule: - r""" + """ 支持 `shell_like` 解析参数的命令形式匹配，根据配置里提供的 `command_start`, `command_sep` 判断消息是否为命令。 可以通过 `state["_prefix"]["command"]` 获取匹配成功的命令（例：`("test",)`），通过 `state["_prefix"]["raw_command"]` 获取匹配成功的原始命令文本（例：`"/test"`）。 @@ -389,8 +389,8 @@ def shell_command( 添加 `parser` 参数后, 可以自动处理消息并将结果保存在 `state["args"]` 中。 参数: - *cmds: 命令内容 - parser: `nonebot.rule.ArgumentParser` 对象 + *cmds: 命令内容 + parser: `nonebot.rule.ArgumentParser` 对象 用法: 使用默认 `command_start`, `command_sep` 配置，更多示例参考 `argparse` 标准库文档。 @@ -404,9 +404,9 @@ def shell_command( rule = shell_command("ls", parser=parser) ``` - \:\:\:tip 提示 + ::: tip 提示 命令内容与后续消息间无需空格！ - \:\:\: + ::: """ if parser is not None and not isinstance(parser, ArgumentParser): raise TypeError("`parser` must be an instance of nonebot.rule.ArgumentParser") @@ -455,7 +455,7 @@ class RegexRule: def regex(regex: str, flags: Union[int, re.RegexFlag] = 0) -> Rule: - r""" + """ 根据正则表达式进行匹配。 可以通过 `state["_matched"]` `state["_matched_groups"]` `state["_matched_dict"]` @@ -465,9 +465,9 @@ def regex(regex: str, flags: Union[int, re.RegexFlag] = 0) -> Rule: regex: 正则表达式 flags: 正则标志 - \:\:\:tip 提示 + ::: tip 提示 正则表达式匹配使用 search 而非 match，如需从头匹配请使用 `r"^xxx"` 来确保匹配开头 - \:\:\: + ::: """ return Rule(RegexRule(regex, flags)) From ec06010298e8f0c66d3d8b1b925087dfcef67976 Mon Sep 17 00:00:00 2001 From: hemengyang Date: Wed, 12 Jan 2022 19:24:01 +0800 Subject: [PATCH 13/14] =?UTF-8?q?=E4=BB=A4=E6=A0=87=E9=A2=98=E7=AC=A6?= =?UTF-8?q?=E5=90=88=20markdown=20=E8=AF=AD=E6=B3=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- nonebot/__init__.py | 3 +-- nonebot/adapters/__init__.py | 3 +-- nonebot/config.py | 3 +-- nonebot/dependencies/__init__.py | 3 +-- nonebot/drivers/__init__.py | 3 +-- nonebot/drivers/aiohttp.py | 3 +-- nonebot/drivers/fastapi.py | 3 +-- nonebot/drivers/quart.py | 3 +-- nonebot/exception.py | 3 +-- nonebot/log.py | 3 +-- nonebot/matcher.py | 3 +-- nonebot/message.py | 3 +-- nonebot/permission.py | 3 +-- nonebot/plugin/__init__.py | 3 +-- nonebot/rule.py | 3 +-- nonebot/typing.py | 3 +-- 16 files changed, 16 insertions(+), 32 deletions(-) diff --git a/nonebot/__init__.py b/nonebot/__init__.py index dcc52e0c..f247aaad 100644 --- a/nonebot/__init__.py +++ b/nonebot/__init__.py @@ -1,6 +1,5 @@ """ -快捷导入 -======== +## 快捷导入 为方便使用，`nonebot` 模块从子模块导入了部分内容 diff --git a/nonebot/adapters/__init__.py b/nonebot/adapters/__init__.py index ce520462..829d2286 100644 --- a/nonebot/adapters/__init__.py +++ b/nonebot/adapters/__init__.py @@ -1,6 +1,5 @@ """ -协议适配基类 -============ +## 协议适配基类 各协议请继承以下基类，并使用 `driver.register_adapter` 注册适配器 """ diff --git a/nonebot/config.py b/nonebot/config.py index 2787b90b..9dab8f51 100644 --- a/nonebot/config.py +++ b/nonebot/config.py @@ -1,6 +1,5 @@ """ -配置 -==== +## 配置 NoneBot 使用 `pydantic`_ 以及 `python-dotenv`_ 来读取配置。 diff --git a/nonebot/dependencies/__init__.py b/nonebot/dependencies/__init__.py index 42e02b9f..3a52dcdb 100644 --- a/nonebot/dependencies/__init__.py +++ b/nonebot/dependencies/__init__.py @@ -1,6 +1,5 @@ """ -依赖注入处理模块 -================ +## 依赖注入处理模块 该模块实现了依赖注入的定义与处理。 """ diff --git a/nonebot/drivers/__init__.py b/nonebot/drivers/__init__.py index 4564ed28..c620f766 100644 --- a/nonebot/drivers/__init__.py +++ b/nonebot/drivers/__init__.py @@ -1,6 +1,5 @@ """ -后端驱动适配基类 -================= +## 后端驱动适配基类 各驱动请继承以下基类 """ diff --git a/nonebot/drivers/aiohttp.py b/nonebot/drivers/aiohttp.py index 243de63d..934cd1fb 100644 --- a/nonebot/drivers/aiohttp.py +++ b/nonebot/drivers/aiohttp.py @@ -1,6 +1,5 @@ """ -AIOHTTP 驱动适配 -================ +## AIOHTTP 驱动适配 本驱动仅支持客户端连接 """ diff --git a/nonebot/drivers/fastapi.py b/nonebot/drivers/fastapi.py index f7b1f603..3a0a58d2 100644 --- a/nonebot/drivers/fastapi.py +++ b/nonebot/drivers/fastapi.py @@ -1,6 +1,5 @@ """ -FastAPI 驱动适配 -================ +## FastAPI 驱动适配 本驱动同时支持服务端以及客户端连接 diff --git a/nonebot/drivers/quart.py b/nonebot/drivers/quart.py index c1936ac2..f1f22da0 100644 --- a/nonebot/drivers/quart.py +++ b/nonebot/drivers/quart.py @@ -1,6 +1,5 @@ """ -Quart 驱动适配 -================ +## Quart 驱动适配 后端使用方法请参考: `Quart 文档`_ diff --git a/nonebot/exception.py b/nonebot/exception.py index 3c6bdb39..9ea7cdd1 100644 --- a/nonebot/exception.py +++ b/nonebot/exception.py @@ -1,6 +1,5 @@ """ -异常 -==== +## 异常 下列文档中的异常是所有 NoneBot 运行时可能会抛出的。 这些异常并非所有需要用户处理，在 NoneBot 内部运行时被捕获，并进行对应操作。 diff --git a/nonebot/log.py b/nonebot/log.py index c95d0c2c..4c86af27 100644 --- a/nonebot/log.py +++ b/nonebot/log.py @@ -1,6 +1,5 @@ """ -日志 -==== +## 日志 NoneBot 使用 `loguru`_ 来记录日志信息。 diff --git a/nonebot/matcher.py b/nonebot/matcher.py index 2c9c8878..e1de199e 100644 --- a/nonebot/matcher.py +++ b/nonebot/matcher.py @@ -1,6 +1,5 @@ """ -事件响应器 -========== +## 事件响应器 该模块实现事件响应器的创建与运行，并提供一些快捷方法来帮助用户更好的与机器人进行对话 。 """ diff --git a/nonebot/message.py b/nonebot/message.py index 877ee7ad..6a927558 100644 --- a/nonebot/message.py +++ b/nonebot/message.py @@ -1,6 +1,5 @@ """ -事件处理 -======== +## 事件处理 NoneBot 内部处理并按优先级分发事件给所有事件响应器，提供了多个插槽以进行事件的预处理等。 """ diff --git a/nonebot/permission.py b/nonebot/permission.py index d5a0cf56..c8b07871 100644 --- a/nonebot/permission.py +++ b/nonebot/permission.py @@ -1,6 +1,5 @@ """ -权限 -==== +## 权限 每个 `Matcher` 拥有一个 `Permission` ，其中是 `PermissionChecker` 的集合，只要有一个 `PermissionChecker` 检查结果为 `True` 时就会继续运行。 diff --git a/nonebot/plugin/__init__.py b/nonebot/plugin/__init__.py index e9cd0538..beb65fad 100644 --- a/nonebot/plugin/__init__.py +++ b/nonebot/plugin/__init__.py @@ -1,6 +1,5 @@ """ -插件 -==== +## 插件 为 NoneBot 插件开发提供便携的定义函数。 """ diff --git a/nonebot/rule.py b/nonebot/rule.py index 88c5e9da..a103e703 100644 --- a/nonebot/rule.py +++ b/nonebot/rule.py @@ -1,6 +1,5 @@ """ -规则 -==== +## 规则 每个事件响应器 `Matcher` 拥有一个匹配规则 `Rule` ，其中是 `RuleChecker` 的集合，只有当所有 `RuleChecker` 检查结果为 `True` 时继续运行。 diff --git a/nonebot/typing.py b/nonebot/typing.py index d863905c..f43ab359 100644 --- a/nonebot/typing.py +++ b/nonebot/typing.py @@ -1,6 +1,5 @@ """ -类型 -==== +## 类型 下面的文档中，「类型」部分使用 Python 的 Type Hint 语法，见 `PEP 484`_、`PEP 526`_ 和 `typing`_。 From 98deadb4d69306dc3e4f6f7819e860d31ee3b25c Mon Sep 17 00:00:00 2001 From: hemengyang Date: Wed, 12 Jan 2022 19:41:42 +0800 Subject: [PATCH 14/14] =?UTF-8?q?=E7=B2=97=E7=95=A5=E8=BF=87=E4=B8=80?= =?UTF-8?q?=E9=81=8D=EF=BC=8C=E4=BF=AE=E5=A4=8D=E4=B8=80=E7=9C=BC=E5=8F=AF?= =?UTF-8?q?=E8=A7=81=E7=9A=84=E9=97=AE=E9=A2=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- nonebot/config.py | 20 +++++--------------- nonebot/drivers/__init__.py | 13 ++++--------- nonebot/drivers/fastapi.py | 5 +---- nonebot/drivers/quart.py | 13 +++---------- nonebot/exception.py | 8 ++++---- nonebot/log.py | 15 +++++++-------- nonebot/rule.py | 3 --- nonebot/typing.py | 11 +---------- nonebot/utils.py | 11 +++++------ 9 files changed, 30 insertions(+), 69 deletions(-) diff --git a/nonebot/config.py b/nonebot/config.py index 9dab8f51..5fad11be 100644 --- a/nonebot/config.py +++ b/nonebot/config.py @@ -1,16 +1,9 @@ """ ## 配置 -NoneBot 使用 `pydantic`_ 以及 `python-dotenv`_ 来读取配置。 +NoneBot 使用 [`pydantic`](https://pydantic-docs.helpmanual.io/) 以及 [`python-dotenv`](https://saurabh-kumar.com/python-dotenv/) 来读取配置。 -配置项需符合特殊格式或 json 序列化格式。详情见 `pydantic Field Type`_ 文档。 - -.. _pydantic: - https://pydantic-docs.helpmanual.io/ -.. _python-dotenv: - https://saurabh-kumar.com/python-dotenv/ -.. _pydantic Field Type: - https://pydantic-docs.helpmanual.io/usage/types/ +配置项需符合特殊格式或 json 序列化格式。详情见 [`pydantic Field Type`](https://pydantic-docs.helpmanual.io/usage/types/) 文档。 """ import os from pathlib import Path @@ -160,9 +153,9 @@ class Config(BaseConfig): """ NoneBot 运行所使用的 `Driver` 。继承自 `nonebot.drivers.Driver` 。 - 配置格式为 `[:][+[:]]*`。 + 配置格式为 `[:][+[:]]*`。 - `~` 为 `nonebot.drivers.` 的缩写。 + `~` 为 `nonebot.drivers.` 的缩写。 """ host: IPvAnyAddress = IPv4Address("127.0.0.1") # type: ignore """ @@ -174,16 +167,13 @@ class Config(BaseConfig): """ log_level: Union[int, str] = "INFO" """ - 配置 NoneBot 日志输出等级，可以为 `int` 类型等级或等级名称，参考 `loguru 日志等级`_。 + 配置 NoneBot 日志输出等级，可以为 `int` 类型等级或等级名称，参考 [`loguru 日志等级`](https://loguru.readthedocs.io/en/stable/api/logger.html#levels)。 用法: ```conf LOG_LEVEL=25 LOG_LEVEL=INFO ``` - - .. _loguru 日志等级: - https://loguru.readthedocs.io/en/stable/api/logger.html#levels """ # bot connection configs diff --git a/nonebot/drivers/__init__.py b/nonebot/drivers/__init__.py index c620f766..a32fdde5 100644 --- a/nonebot/drivers/__init__.py +++ b/nonebot/drivers/__init__.py @@ -113,9 +113,6 @@ class Driver(abc.ABC): def run(self, *args, **kwargs): """ 启动驱动框架 - - 参数: *args - **kwargs """ logger.opt(colors=True).debug( f"Loaded adapters: {escape_tag(', '.join(self._adapters))}" @@ -135,9 +132,8 @@ class Driver(abc.ABC): """ 装饰一个函数使他在 bot 通过 WebSocket 连接成功时执行。 - :函数参数: - - bot: 当前连接上的 Bot 对象 + 参数: + bot: 当前连接上的 Bot 对象 """ self._bot_connection_hook.add(func) return func @@ -146,9 +142,8 @@ class Driver(abc.ABC): """ 装饰一个函数使他在 bot 通过 WebSocket 连接断开时执行。 - :函数参数: - - bot: 当前连接上的 Bot 对象 + 参数: + bot: 当前连接上的 Bot 对象 """ self._bot_disconnection_hook.add(func) return func diff --git a/nonebot/drivers/fastapi.py b/nonebot/drivers/fastapi.py index 3a0a58d2..99f374f5 100644 --- a/nonebot/drivers/fastapi.py +++ b/nonebot/drivers/fastapi.py @@ -3,10 +3,7 @@ 本驱动同时支持服务端以及客户端连接 -后端使用方法请参考: `FastAPI 文档`_ - -.. _FastAPI 文档: - https://fastapi.tiangolo.com/ +后端使用方法请参考: [`FastAPI 文档`](https://fastapi.tiangolo.com/) """ import logging diff --git a/nonebot/drivers/quart.py b/nonebot/drivers/quart.py index f1f22da0..d6ebbeab 100644 --- a/nonebot/drivers/quart.py +++ b/nonebot/drivers/quart.py @@ -1,10 +1,7 @@ """ ## Quart 驱动适配 -后端使用方法请参考: `Quart 文档`_ - -.. _Quart 文档: - https://pgjones.gitlab.io/quart/index.html +后端使用方法请参考: [`Quart 文档`](https://pgjones.gitlab.io/quart/index.html) """ import asyncio @@ -139,16 +136,12 @@ class Driver(ReverseDriver): @overrides(ReverseDriver) def on_startup(self, func: _AsyncCallable) -> _AsyncCallable: - """参考文档: `Startup and Shutdown`_ - - .. _Startup and Shutdown: - https://pgjones.gitlab.io/quart/how_to_guides/startup_shutdown.html - """ + """参考文档: [`Startup and Shutdown`](https://pgjones.gitlab.io/quart/how_to_guides/startup_shutdown.html)""" return self.server_app.before_serving(func) # type: ignore @overrides(ReverseDriver) def on_shutdown(self, func: _AsyncCallable) -> _AsyncCallable: - """参考文档: `Startup and Shutdown`_""" + """参考文档: [`Startup and Shutdown`](https://pgjones.gitlab.io/quart/how_to_guides/startup_shutdown.html)""" return self.server_app.after_serving(func) # type: ignore @overrides(ReverseDriver) diff --git a/nonebot/exception.py b/nonebot/exception.py index 9ea7cdd1..eb489a73 100644 --- a/nonebot/exception.py +++ b/nonebot/exception.py @@ -97,7 +97,7 @@ class SkippedException(MatcherException): 指示 NoneBot 立即结束当前 `Handler` 的处理，继续处理下一个 `Handler`。 用法: - 可以在 `Handler` 中通过 `Matcher.skip()` 抛出。 + 可以在 `Handler` 中通过 `Matcher.skip()` 抛出。 """ @@ -123,7 +123,7 @@ class PausedException(MatcherException): 可用于用户输入新信息。 用法: - 可以在 `Handler` 中通过 `Matcher.pause()` 抛出。 + 可以在 `Handler` 中通过 `Matcher.pause()` 抛出。 """ @@ -133,7 +133,7 @@ class RejectedException(MatcherException): 可用于用户重新输入。 用法: - 可以在 `Handler` 中通过 `Matcher.reject()` 抛出。 + 可以在 `Handler` 中通过 `Matcher.reject()` 抛出。 """ @@ -143,7 +143,7 @@ class FinishedException(MatcherException): 可用于结束用户会话。 用法: - 可以在 `Handler` 中通过 `Matcher.finish()` 抛出。 + 可以在 `Handler` 中通过 `Matcher.finish()` 抛出。 """ diff --git a/nonebot/log.py b/nonebot/log.py index 4c86af27..a1bf7f26 100644 --- a/nonebot/log.py +++ b/nonebot/log.py @@ -1,12 +1,11 @@ """ ## 日志 -NoneBot 使用 `loguru`_ 来记录日志信息。 +NoneBot 使用 [`loguru`][loguru] 来记录日志信息。 -自定义 logger 请参考 `loguru`_ 文档。 +自定义 logger 请参考 [`loguru`][loguru] 文档。 -.. _loguru: - https://github.com/Delgan/loguru +[loguru]: https://github.com/Delgan/loguru """ import sys @@ -25,11 +24,11 @@ logger: "Logger" = loguru.logger """ NoneBot 日志记录器对象。 -:默认信息: +默认信息: - * 格式: `[%(asctime)s %(name)s] %(levelname)s: %(message)s` - * 等级: `INFO` ，根据 `config.log_level` 配置改变 - * 输出: 输出至 stdout + - 格式: `[%(asctime)s %(name)s] %(levelname)s: %(message)s` + - 等级: `INFO` ，根据 `config.log_level` 配置改变 + - 输出: 输出至 stdout 用法: ```python diff --git a/nonebot/rule.py b/nonebot/rule.py index a103e703..d0d0e7b8 100644 --- a/nonebot/rule.py +++ b/nonebot/rule.py @@ -480,9 +480,6 @@ class ToMeRule: def to_me() -> Rule: """ 通过 `event.is_tome()` 判断事件是否与机器人有关 - - 参数: - * 无 """ return Rule(ToMeRule()) diff --git a/nonebot/typing.py b/nonebot/typing.py index f43ab359..938e92ba 100644 --- a/nonebot/typing.py +++ b/nonebot/typing.py @@ -1,20 +1,11 @@ """ ## 类型 -下面的文档中，「类型」部分使用 Python 的 Type Hint 语法，见 `PEP 484`_、`PEP 526`_ 和 `typing`_。 +下面的文档中，「类型」部分使用 Python 的 Type Hint 语法，见 [`PEP 484`](https://www.python.org/dev/peps/pep-0484/)、[`PEP 526`](https://www.python.org/dev/peps/pep-0526/) 和 [`typing`](https://docs.python.org/3/library/typing.html)。 除了 Python 内置的类型，下面还出现了如下 NoneBot 自定类型，实际上它们是 Python 内置类型的别名。 以下类型均可从 nonebot.typing 模块导入。 - -.. _PEP 484: - https://www.python.org/dev/peps/pep-0484/ - -.. _PEP 526: - https://www.python.org/dev/peps/pep-0526/ - -.. _typing: - https://docs.python.org/3/library/typing.html """ from typing import ( TYPE_CHECKING, diff --git a/nonebot/utils.py b/nonebot/utils.py index ced56782..8c621df6 100644 --- a/nonebot/utils.py +++ b/nonebot/utils.py @@ -133,13 +133,12 @@ class DataclassEncoder(json.JSONEncoder): def logger_wrapper(logger_name: str): """ - 用于打印 adapter 的日志。 + 用于打印 adapter 的日志。 - :log 参数: - - level: 日志等级 - message: 日志信息 - exception: 异常信息 + 参数: + level: 日志等级 + message: 日志信息 + exception: 异常信息 """ def log(level: str, message: str, exception: Optional[Exception] = None):