ProjectHentai/nonebot2
6
0
Fork 0
mirror of https://github.com/nonebot/nonebot2.git synced 2024-11-28 03:26:18 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

使用 markdown 格式的强调语法

Browse Source
This commit is contained in:
hemengyang 2022-01-12 18:19:21 +08:00
parent 0099364838
commit 4ba1a09fb7
25 changed files with 536 additions and 536 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

86
nonebot/__init__.py
View File

@ -2,31 +2,31 @@
快捷导入 快捷导入
======== ========
为方便使用，``nonebot`` 模块从子模块导入了部分内容 为方便使用，`nonebot` 模块从子模块导入了部分内容
- ``on_message`` => ``nonebot.plugin.on_message`` - `on_message` => `nonebot.plugin.on_message`
- ``on_notice`` => ``nonebot.plugin.on_notice`` - `on_notice` => `nonebot.plugin.on_notice`
- ``on_request`` => ``nonebot.plugin.on_request`` - `on_request` => `nonebot.plugin.on_request`
- ``on_metaevent`` => ``nonebot.plugin.on_metaevent`` - `on_metaevent` => `nonebot.plugin.on_metaevent`
- ``on_startswith`` => ``nonebot.plugin.on_startswith`` - `on_startswith` => `nonebot.plugin.on_startswith`
- ``on_endswith`` => ``nonebot.plugin.on_endswith`` - `on_endswith` => `nonebot.plugin.on_endswith`
- ``on_keyword`` => ``nonebot.plugin.on_keyword`` - `on_keyword` => `nonebot.plugin.on_keyword`
- ``on_command`` => ``nonebot.plugin.on_command`` - `on_command` => `nonebot.plugin.on_command`
- ``on_shell_command`` => ``nonebot.plugin.on_shell_command`` - `on_shell_command` => `nonebot.plugin.on_shell_command`
- ``on_regex`` => ``nonebot.plugin.on_regex`` - `on_regex` => `nonebot.plugin.on_regex`
- ``CommandGroup`` => ``nonebot.plugin.CommandGroup`` - `CommandGroup` => `nonebot.plugin.CommandGroup`
- ``Matchergroup`` => ``nonebot.plugin.MatcherGroup`` - `Matchergroup` => `nonebot.plugin.MatcherGroup`
- ``load_plugin`` => ``nonebot.plugin.load_plugin`` - `load_plugin` => `nonebot.plugin.load_plugin`
- ``load_plugins`` => ``nonebot.plugin.load_plugins`` - `load_plugins` => `nonebot.plugin.load_plugins`
- ``load_all_plugins`` => ``nonebot.plugin.load_all_plugins`` - `load_all_plugins` => `nonebot.plugin.load_all_plugins`
- ``load_from_json`` => ``nonebot.plugin.load_from_json`` - `load_from_json` => `nonebot.plugin.load_from_json`
- ``load_from_toml`` => ``nonebot.plugin.load_from_toml`` - `load_from_toml` => `nonebot.plugin.load_from_toml`
- ``load_builtin_plugin`` => ``nonebot.plugin.load_builtin_plugin`` - `load_builtin_plugin` => `nonebot.plugin.load_builtin_plugin`
- ``load_builtin_plugins`` => ``nonebot.plugin.load_builtin_plugins`` - `load_builtin_plugins` => `nonebot.plugin.load_builtin_plugins`
- ``get_plugin`` => ``nonebot.plugin.get_plugin`` - `get_plugin` => `nonebot.plugin.get_plugin`
- ``get_loaded_plugins`` => ``nonebot.plugin.get_loaded_plugins`` - `get_loaded_plugins` => `nonebot.plugin.get_loaded_plugins`
- ``export`` => ``nonebot.plugin.export`` - `export` => `nonebot.plugin.export`
- ``require`` => ``nonebot.plugin.require`` - `require` => `nonebot.plugin.require`
""" """
import importlib 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 不存在 * `KeyError`: 对应 ID 的 Bot 不存在
* ``ValueError``: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用) * `ValueError`: 全局 Driver 对象尚未初始化 (nonebot.init 尚未调用)
* ``ValueError``: 没有传入 ID 且没有 Bot 可用 * `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} 中读取配置 * `_env_file: Optional[str]`: 配置文件名，默认从 .env.{env_name} 中读取配置
* ``**kwargs``: 任意变量，将会存储到 Config 对象里 * `**kwargs`: 任意变量，将会存储到 Config 对象里
:返回: :返回:
- ``None`` - `None`
:用法: :用法:
@ -269,12 +269,12 @@ def run(*args: Any, **kwargs: Any) -> None:
:参数: :参数:
* ``*args``: 传入 Driver.run 的位置参数 * `*args`: 传入 Driver.run 的位置参数
* ``**kwargs``: 传入 Driver.run 的命名参数 * `**kwargs`: 传入 Driver.run 的命名参数
:返回: :返回:
- ``None`` - `None`
:用法: :用法:

2
nonebot/adapters/__init__.py
View File

@ -2,7 +2,7 @@
协议适配基类 协议适配基类
============ ============
各协议请继承以下基类，并使用 ``driver.register_adapter`` 注册适配器 各协议请继承以下基类，并使用 `driver.register_adapter` 注册适配器
""" """
from typing import Iterable from typing import Iterable

6
nonebot/adapters/_adapter.py
View File

@ -63,11 +63,11 @@ class Adapter(abc.ABC):
@abc.abstractmethod @abc.abstractmethod
async def _call_api(self, bot: Bot, api: str, **data) -> Any: async def _call_api(self, bot: Bot, api: str, **data) -> Any:
""" """
``adapter`` 实际调用 api 的逻辑实现函数，实现该方法以调用 api。 `adapter` 实际调用 api 的逻辑实现函数，实现该方法以调用 api。
:参数: :参数:
* ``api: str``: API 名称 * `api: str`: API 名称
* ``**data``: API 数据 * `**data`: API 数据
""" """
raise NotImplementedError raise NotImplementedError

30
nonebot/adapters/_bot.py
View File

@ -38,8 +38,8 @@ class Bot(abc.ABC):
""" """
:参数: :参数:
* ``self_id: str``: 机器人 ID * `self_id: str`: 机器人 ID
* ``request: HTTPConnection``: request 连接对象 * `request: HTTPConnection`: request 连接对象
""" """
self.adapter: "Adapter" = adapter self.adapter: "Adapter" = adapter
self.self_id: str = self_id self.self_id: str = self_id
@ -62,8 +62,8 @@ class Bot(abc.ABC):
:参数: :参数:
* ``api: str``: API 名称 * `api: str`: API 名称
* ``**data``: API 数据 * `**data`: API 数据
:示例: :示例:
@ -131,9 +131,9 @@ class Bot(abc.ABC):
:参数: :参数:
* ``event: Event``: 上报事件 * `event: Event`: 上报事件
* ``message: Union[str, Message, MessageSegment]``: 要发送的消息 * `message: Union[str, Message, MessageSegment]`: 要发送的消息
* ``**kwargs`` * `**kwargs`
""" """
raise NotImplementedError raise NotImplementedError
@ -144,9 +144,9 @@ class Bot(abc.ABC):
:参数: :参数:
* ``bot: Bot``: 当前 bot 对象 * `bot: Bot`: 当前 bot 对象
* ``api: str``: 调用的 api 名称 * `api: str`: 调用的 api 名称
* ``data: Dict[str, Any]``: api 调用的参数字典 * `data: Dict[str, Any]`: api 调用的参数字典
""" """
cls._calling_api_hook.add(func) cls._calling_api_hook.add(func)
return func return func
@ -158,11 +158,11 @@ class Bot(abc.ABC):
:参数: :参数:
* ``bot: Bot``: 当前 bot 对象 * `bot: Bot`: 当前 bot 对象
* ``exception: Optional[Exception]``: 调用 api 时发生的错误 * `exception: Optional[Exception]`: 调用 api 时发生的错误
* ``api: str``: 调用的 api 名称 * `api: str`: 调用的 api 名称
* ``data: Dict[str, Any]``: api 调用的参数字典 * `data: Dict[str, Any]`: api 调用的参数字典
* ``result: Any``: api 调用的返回 * `result: Any`: api 调用的返回
""" """
cls._called_api_hook.add(func) cls._called_api_hook.add(func)
return func return func

26
nonebot/adapters/_event.py
View File

@ -20,8 +20,8 @@ class Event(abc.ABC, BaseModel):
:返回: :返回:
* ``Literal["message", "notice", "request", "meta_event"]`` * `Literal["message", "notice", "request", "meta_event"]`
* 其他自定义 ``str`` * 其他自定义 `str`
""" """
raise NotImplementedError raise NotImplementedError
@ -32,7 +32,7 @@ class Event(abc.ABC, BaseModel):
:返回: :返回:
* ``str`` * `str`
""" """
raise NotImplementedError raise NotImplementedError
@ -43,7 +43,7 @@ class Event(abc.ABC, BaseModel):
:返回: :返回:
* ``str`` * `str`
""" """
raise NotImplementedError raise NotImplementedError
@ -52,15 +52,15 @@ class Event(abc.ABC, BaseModel):
def get_log_string(self) -> str: def get_log_string(self) -> str:
""" """
获取事件日志信息的方法，通常你不需要修改这个方法，只有当希望 NoneBot 隐藏该事件日志时，可以抛出 ``NoLogException`` 异常。 获取事件日志信息的方法，通常你不需要修改这个方法，只有当希望 NoneBot 隐藏该事件日志时，可以抛出 `NoLogException` 异常。
:返回: :返回:
* ``str`` * `str`
:异常: :异常:
- ``NoLogException`` - `NoLogException`
""" """
return f"[{self.get_event_name()}]: {self.get_event_description()}" return f"[{self.get_event_name()}]: {self.get_event_description()}"
@ -71,7 +71,7 @@ class Event(abc.ABC, BaseModel):
:返回: :返回:
* ``str`` * `str`
""" """
raise NotImplementedError raise NotImplementedError
@ -82,7 +82,7 @@ class Event(abc.ABC, BaseModel):
:返回: :返回:
* ``str`` * `str`
""" """
raise NotImplementedError raise NotImplementedError
@ -93,17 +93,17 @@ class Event(abc.ABC, BaseModel):
:返回: :返回:
* ``Message`` * `Message`
""" """
raise NotImplementedError raise NotImplementedError
def get_plaintext(self) -> str: def get_plaintext(self) -> str:
""" """
获取消息纯文本的方法，通常不需要修改，默认通过 ``get_message().extract_plain_text`` 获取。 获取消息纯文本的方法，通常不需要修改，默认通过 `get_message().extract_plain_text` 获取。
:返回: :返回:
* ``str`` * `str`
""" """
return self.get_message().extract_plain_text() return self.get_message().extract_plain_text()
@ -114,6 +114,6 @@ class Event(abc.ABC, BaseModel):
:返回: :返回:
* ``bool`` * `bool`
""" """
raise NotImplementedError raise NotImplementedError

14
nonebot/adapters/_message.py
View File

@ -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) super().__init__(*args, **kwargs)
if message is None: if message is None:
@ -114,9 +114,9 @@ class Message(List[TMS], abc.ABC):
@classmethod @classmethod
def template(cls: Type[TM], format_string: Union[str, TM]) -> MessageTemplate[TM]: 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) 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): if isinstance(obj, MessageSegment):
super(Message, self).append(obj) 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: for segment in obj:
self.append(segment) self.append(segment)

4
nonebot/adapters/_template.py
View File

@ -51,8 +51,8 @@ class MessageTemplate(Formatter, Generic[TF]):
:参数: :参数:
* ``template: Union[str, Message]``: 模板 * `template: Union[str, Message]`: 模板
* ``factory: Union[str, Message]``: 消息构造类型，默认为 `str` * `factory: Union[str, Message]`: 消息构造类型，默认为 `str`
""" """
self.template: TF = template self.template: TF = template
self.factory: Type[TF] = factory self.factory: Type[TF] = factory

16
nonebot/config.py
View File

@ -132,12 +132,12 @@ class Env(BaseConfig):
""" """
运行环境配置。大小写不敏感。 运行环境配置。大小写不敏感。
将会从 ``nonebot.init 参数`` > ``环境变量`` > ``.env 环境配置文件`` 的优先级读取配置。 将会从 `nonebot.init 参数` > `环境变量` > `.env 环境配置文件` 的优先级读取配置。
""" """
environment: str = "prod" environment: str = "prod"
""" """
当前环境名。 NoneBot 将从 ``.env.{environment}`` 文件中加载配置。 当前环境名。 NoneBot 将从 `.env.{environment}` 文件中加载配置。
""" """
class Config: class Config:
@ -149,8 +149,8 @@ class Config(BaseConfig):
""" """
NoneBot 主要配置。大小写不敏感。 NoneBot 主要配置。大小写不敏感。
除了 NoneBot 的配置项外，还可以自行添加配置项到 ``.env.{environment}`` 文件中。 除了 NoneBot 的配置项外，还可以自行添加配置项到 `.env.{environment}` 文件中。
这些配置将会在 json 反序列化后一起带入 ``Config`` 类中。 这些配置将会在 json 反序列化后一起带入 `Config` 类中。
""" """
_common_config: dict _common_config: dict
@ -159,11 +159,11 @@ class Config(BaseConfig):
# nonebot configs # nonebot configs
driver: str = "~fastapi" driver: str = "~fastapi"
""" """
NoneBot 运行所使用的 ``Driver`` 。继承自 ``nonebot.drivers.Driver`` 。 NoneBot 运行所使用的 `Driver` 。继承自 `nonebot.drivers.Driver` 。
配置格式为 ``<module>[:<Driver>][+<module>[:<Mixin>]]*``。 配置格式为 `<module>[:<Driver>][+<module>[:<Mixin>]]*`。
``~`` 为 ``nonebot.drivers.`` 的缩写。 `~` 为 `nonebot.drivers.` 的缩写。
""" """
host: IPvAnyAddress = IPv4Address("127.0.0.1") # type: ignore host: IPvAnyAddress = IPv4Address("127.0.0.1") # type: ignore
""" """
@ -175,7 +175,7 @@ class Config(BaseConfig):
""" """
log_level: Union[int, str] = "INFO" log_level: Union[int, str] = "INFO"
""" """
配置 NoneBot 日志输出等级，可以为 ``int`` 类型等级或等级名称，参考 `loguru 日志等级`_。 配置 NoneBot 日志输出等级，可以为 `int` 类型等级或等级名称，参考 `loguru 日志等级`_。
:示例: :示例:

18
nonebot/drivers/__init__.py
View File

@ -56,8 +56,8 @@ class Driver(abc.ABC):
""" """
:参数: :参数:
* ``env: Env``: 包含环境信息的 Env 对象 * `env: Env`: 包含环境信息的 Env 对象
* ``config: Config``: 包含配置信息的 Config 对象 * `config: Config`: 包含配置信息的 Config 对象
""" """
self.env: str = env.environment self.env: str = env.environment
""" """
@ -85,9 +85,9 @@ class Driver(abc.ABC):
:参数: :参数:
* ``name: str``: 适配器名称，用于在连接时进行识别 * `name: str`: 适配器名称，用于在连接时进行识别
* ``adapter: Type[Bot]``: 适配器 Class * `adapter: Type[Bot]`: 适配器 Class
* ``**kwargs``: 其他传递给适配器的参数 * `**kwargs`: 其他传递给适配器的参数
""" """
name = adapter.get_name() name = adapter.get_name()
if name in self._adapters: if name in self._adapters:
@ -118,8 +118,8 @@ class Driver(abc.ABC):
启动驱动框架 启动驱动框架
:参数: :参数:
* ``*args`` * `*args`
* ``**kwargs`` * `**kwargs`
""" """
logger.opt(colors=True).debug( logger.opt(colors=True).debug(
f"<g>Loaded adapters: {escape_tag(', '.join(self._adapters))}</g>" f"<g>Loaded adapters: {escape_tag(', '.join(self._adapters))}</g>"
@ -141,7 +141,7 @@ class Driver(abc.ABC):
:函数参数: :函数参数:
* ``bot: Bot``: 当前连接上的 Bot 对象 * `bot: Bot`: 当前连接上的 Bot 对象
""" """
self._bot_connection_hook.add(func) self._bot_connection_hook.add(func)
return func return func
@ -152,7 +152,7 @@ class Driver(abc.ABC):
:函数参数: :函数参数:
* ``bot: Bot``: 当前连接上的 Bot 对象 * `bot: Bot`: 当前连接上的 Bot 对象
""" """
self._bot_disconnection_hook.add(func) self._bot_disconnection_hook.add(func)
return func return func

6
nonebot/drivers/_block_driver.py
View File

@ -27,7 +27,7 @@ class BlockDriver(Driver):
@property @property
@overrides(Driver) @overrides(Driver)
def type(self) -> str: def type(self) -> str:
"""驱动名称: ``block_driver``""" """驱动名称: `block_driver`"""
return "block_driver" return "block_driver"
@property @property
@ -43,7 +43,7 @@ class BlockDriver(Driver):
:参数: :参数:
* ``func: Callable[[], Awaitable[None]]`` * `func: Callable[[], Awaitable[None]]`
""" """
self.startup_funcs.add(func) self.startup_funcs.add(func)
return func return func
@ -55,7 +55,7 @@ class BlockDriver(Driver):
:参数: :参数:
* ``func: Callable[[], Awaitable[None]]`` * `func: Callable[[], Awaitable[None]]`
""" """
self.shutdown_funcs.add(func) self.shutdown_funcs.add(func)
return func return func

16
nonebot/drivers/fastapi.py
View File

@ -48,19 +48,19 @@ class Config(BaseSettings):
fastapi_openapi_url: Optional[str] = None fastapi_openapi_url: Optional[str] = None
""" """
``openapi.json`` 地址，默认为 ``None`` 即关闭 `openapi.json` 地址，默认为 `None` 即关闭
""" """
fastapi_docs_url: Optional[str] = None fastapi_docs_url: Optional[str] = None
""" """
``swagger`` 地址，默认为 ``None`` 即关闭 `swagger` 地址，默认为 `None` 即关闭
""" """
fastapi_redoc_url: Optional[str] = None fastapi_redoc_url: Optional[str] = None
""" """
``redoc`` 地址，默认为 ``None`` 即关闭 `redoc` 地址，默认为 `None` 即关闭
""" """
fastapi_include_adapter_schema: bool = True fastapi_include_adapter_schema: bool = True
""" """
是否包含适配器路由的 schema，默认为 ``True`` 是否包含适配器路由的 schema，默认为 `True`
""" """
fastapi_reload: bool = False fastapi_reload: bool = False
""" """
@ -104,19 +104,19 @@ class Driver(ReverseDriver):
@property @property
@overrides(ReverseDriver) @overrides(ReverseDriver)
def type(self) -> str: def type(self) -> str:
"""驱动名称: ``fastapi``""" """驱动名称: `fastapi`"""
return "fastapi" return "fastapi"
@property @property
@overrides(ReverseDriver) @overrides(ReverseDriver)
def server_app(self) -> FastAPI: def server_app(self) -> FastAPI:
"""``FastAPI APP`` 对象""" """`FastAPI APP` 对象"""
return self._server_app return self._server_app
@property @property
@overrides(ReverseDriver) @overrides(ReverseDriver)
def asgi(self) -> FastAPI: def asgi(self) -> FastAPI:
"""``FastAPI APP`` 对象""" """`FastAPI APP` 对象"""
return self._server_app return self._server_app
@property @property
@ -168,7 +168,7 @@ class Driver(ReverseDriver):
app: Optional[str] = None, app: Optional[str] = None,
**kwargs, **kwargs,
): ):
"""使用 ``uvicorn`` 启动 FastAPI""" """使用 `uvicorn` 启动 FastAPI"""
super().run(host, port, app, **kwargs) super().run(host, port, app, **kwargs)
LOGGING_CONFIG = { LOGGING_CONFIG = {
"version": 1, "version": 1,

8
nonebot/drivers/quart.py
View File

@ -94,19 +94,19 @@ class Driver(ReverseDriver):
@property @property
@overrides(ReverseDriver) @overrides(ReverseDriver)
def type(self) -> str: def type(self) -> str:
"""驱动名称: ``quart``""" """驱动名称: `quart`"""
return "quart" return "quart"
@property @property
@overrides(ReverseDriver) @overrides(ReverseDriver)
def server_app(self) -> Quart: def server_app(self) -> Quart:
"""``Quart`` 对象""" """`Quart` 对象"""
return self._server_app return self._server_app
@property @property
@overrides(ReverseDriver) @overrides(ReverseDriver)
def asgi(self): def asgi(self):
"""``Quart`` 对象""" """`Quart` 对象"""
return self._server_app return self._server_app
@property @property
@ -161,7 +161,7 @@ class Driver(ReverseDriver):
app: Optional[str] = None, app: Optional[str] = None,
**kwargs, **kwargs,
): ):
"""使用 ``uvicorn`` 启动 Quart""" """使用 `uvicorn` 启动 Quart"""
super().run(host, port, app, **kwargs) super().run(host, port, app, **kwargs)
LOGGING_CONFIG = { LOGGING_CONFIG = {
"version": 1, "version": 1,

38
nonebot/exception.py
View File

@ -20,12 +20,12 @@ class NoneBotException(Exception):
# Rule Exception # Rule Exception
class ParserExit(NoneBotException): class ParserExit(NoneBotException):
""" """
``shell command`` 处理消息失败时返回的异常 `shell command` 处理消息失败时返回的异常
:参数: :参数:
* ``status`` * `status`
* ``message`` * `message`
""" """
def __init__(self, status: int = 0, message: Optional[str] = None): def __init__(self, status: int = 0, message: Optional[str] = None):
@ -52,7 +52,7 @@ class IgnoredException(ProcessException):
:参数: :参数:
* ``reason``: 忽略事件的原因 * `reason`: 忽略事件的原因
""" """
def __init__(self, reason): def __init__(self, reason):
@ -71,7 +71,7 @@ class MockApiException(ProcessException):
:参数: :参数:
* ``result``: 返回的内容 * `result`: 返回的内容
""" """
def __init__(self, result: Any): 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): class SkippedException(MatcherException):
""" """
指示 NoneBot 立即结束当前 ``Handler`` 的处理，继续处理下一个 ``Handler``。 指示 NoneBot 立即结束当前 `Handler` 的处理，继续处理下一个 `Handler`。
:用法: :用法:
可以在 ``Handler`` 中通过 ``Matcher.skip()`` 抛出。 可以在 `Handler` 中通过 `Matcher.skip()` 抛出。
""" """
class TypeMisMatch(SkippedException): class TypeMisMatch(SkippedException):
""" """
当前 ``Handler`` 的参数类型不匹配。 当前 `Handler` 的参数类型不匹配。
""" """
def __init__(self, param: ModelField, value: Any): def __init__(self, param: ModelField, value: Any):
@ -129,45 +129,45 @@ class TypeMisMatch(SkippedException):
class PausedException(MatcherException): class PausedException(MatcherException):
""" """
指示 NoneBot 结束当前 ``Handler`` 并等待下一条消息后继续下一个 ``Handler``。 指示 NoneBot 结束当前 `Handler` 并等待下一条消息后继续下一个 `Handler`。
可用于用户输入新信息。 可用于用户输入新信息。
:用法: :用法:
可以在 ``Handler`` 中通过 ``Matcher.pause()`` 抛出。 可以在 `Handler` 中通过 `Matcher.pause()` 抛出。
""" """
class RejectedException(MatcherException): class RejectedException(MatcherException):
""" """
指示 NoneBot 结束当前 ``Handler`` 并等待下一条消息后重新运行当前 ``Handler``。 指示 NoneBot 结束当前 `Handler` 并等待下一条消息后重新运行当前 `Handler`。
可用于用户重新输入。 可用于用户重新输入。
:用法: :用法:
可以在 ``Handler`` 中通过 ``Matcher.reject()`` 抛出。 可以在 `Handler` 中通过 `Matcher.reject()` 抛出。
""" """
class FinishedException(MatcherException): class FinishedException(MatcherException):
""" """
指示 NoneBot 结束当前 ``Handler`` 且后续 ``Handler`` 不再被运行。 指示 NoneBot 结束当前 `Handler` 且后续 `Handler` 不再被运行。
可用于结束用户会话。 可用于结束用户会话。
:用法: :用法:
可以在 ``Handler`` 中通过 ``Matcher.finish()`` 抛出。 可以在 `Handler` 中通过 `Matcher.finish()` 抛出。
""" """
# Adapter Exceptions # Adapter Exceptions
class AdapterException(NoneBotException): class AdapterException(NoneBotException):
""" """
代表 ``Adapter`` 抛出的异常，所有的 ``Adapter`` 都要在内部继承自这个 ``Exception`` 代表 `Adapter` 抛出的异常，所有的 `Adapter` 都要在内部继承自这个 `Exception`
:参数: :参数:
* ``adapter_name: str``: 标识 adapter * `adapter_name: str`: 标识 adapter
""" """
def __init__(self, adapter_name: str) -> None: def __init__(self, adapter_name: str) -> None:
@ -176,7 +176,7 @@ class AdapterException(NoneBotException):
class NoLogException(AdapterException): class NoLogException(AdapterException):
""" """
指示 NoneBot 对当前 ``Event`` 进行处理但不显示 Log 信息，可在 ``get_log_string`` 时抛出 指示 NoneBot 对当前 `Event` 进行处理但不显示 Log 信息，可在 `get_log_string` 时抛出
""" """
pass pass
@ -209,7 +209,7 @@ class ActionFailed(AdapterException):
# Driver Exceptions # Driver Exceptions
class DriverException(NoneBotException): class DriverException(NoneBotException):
""" """
``Driver`` 抛出的异常基类 `Driver` 抛出的异常基类
""" """

4
nonebot/log.py
View File

@ -28,8 +28,8 @@ NoneBot 日志记录器对象。
:默认信息: :默认信息:
* 格式: ``[%(asctime)s %(name)s] %(levelname)s: %(message)s`` * 格式: `[%(asctime)s %(name)s] %(levelname)s: %(message)s`
* 等级: ``INFO`` ，根据 ``config.log_level`` 配置改变 * 等级: `INFO` ，根据 `config.log_level` 配置改变
* 输出: 输出至 stdout * 输出: 输出至 stdout
:用法: :用法:

92
nonebot/matcher.py
View File

@ -214,21 +214,21 @@ class Matcher(metaclass=MatcherMeta):
:参数: :参数:
* ``type_: str``: 事件响应器类型，与 ``event.get_type()`` 一致时触发，空字符串表示任意 * `type_: str`: 事件响应器类型，与 `event.get_type()` 一致时触发，空字符串表示任意
* ``rule: Optional[Rule]``: 匹配规则 * `rule: Optional[Rule]`: 匹配规则
* ``permission: Optional[Permission]``: 权限 * `permission: Optional[Permission]`: 权限
* ``handlers: Optional[List[T_Handler]]``: 事件处理函数列表 * `handlers: Optional[List[T_Handler]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器，即触发一次后删除 * `temp: bool`: 是否为临时事件响应器，即触发一次后删除
* ``priority: int``: 响应优先级 * `priority: int`: 响应优先级
* ``block: bool``: 是否阻止事件向更低优先级的响应器传播 * `block: bool`: 是否阻止事件向更低优先级的响应器传播
* ``plugin: Optional[Plugin]``: 事件响应器所在插件 * `plugin: Optional[Plugin]`: 事件响应器所在插件
* ``module: Optional[ModuleType]``: 事件响应器所在模块 * `module: Optional[ModuleType]`: 事件响应器所在模块
* ``default_state: Optional[T_State]``: 默认状态 ``state`` * `default_state: Optional[T_State]`: 默认状态 `state`
* ``expire_time: Optional[datetime]``: 事件响应器最终有效时间点，过时即被删除 * `expire_time: Optional[datetime]`: 事件响应器最终有效时间点，过时即被删除
:返回: :返回:
- ``Type[Matcher]``: 新的事件响应器类 - `Type[Matcher]`: 新的事件响应器类
""" """
NewMatcher = type( NewMatcher = type(
"Matcher", "Matcher",
@ -280,12 +280,12 @@ class Matcher(metaclass=MatcherMeta):
:参数: :参数:
* ``bot: Bot``: Bot 对象 * `bot: Bot`: Bot 对象
* ``event: Event``: 上报事件 * `event: Event`: 上报事件
:返回: :返回:
- ``bool``: 是否满足权限 - `bool`: 是否满足权限
""" """
event_type = event.get_type() event_type = event.get_type()
return event_type == (cls.type or event_type) and await cls.permission( return event_type == (cls.type or event_type) and await cls.permission(
@ -306,13 +306,13 @@ class Matcher(metaclass=MatcherMeta):
:参数: :参数:
* ``bot: Bot``: Bot 对象 * `bot: Bot`: Bot 对象
* ``event: Event``: 上报事件 * `event: Event`: 上报事件
* ``state: T_State``: 当前状态 * `state: T_State`: 当前状态
:返回: :返回:
- ``bool``: 是否满足匹配规则 - `bool`: 是否满足匹配规则
""" """
event_type = event.get_type() event_type = event.get_type()
return event_type == (cls.type or event_type) and await cls.rule( 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( cls._default_type_updater = Dependent[str].parse(
call=func, allow_types=cls.HANDLER_PARAM_TYPES 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( cls._default_permission_updater = Dependent[Permission].parse(
call=func, allow_types=cls.HANDLER_PARAM_TYPES 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: def _decorator(func: T_Handler) -> T_Handler:
@ -386,8 +386,8 @@ class Matcher(metaclass=MatcherMeta):
:参数: :参数:
* ``id: str``: 消息 ID * `id: str`: 消息 ID
* ``parameterless: Optional[List[Any]]``: 非参数类型依赖列表 * `parameterless: Optional[List[Any]]`: 非参数类型依赖列表
""" """
async def _receive(event: Event, matcher: "Matcher") -> Union[None, NoReturn]: async def _receive(event: Event, matcher: "Matcher") -> Union[None, NoReturn]:
@ -422,14 +422,14 @@ class Matcher(metaclass=MatcherMeta):
parameterless: Optional[List[Any]] = None, parameterless: Optional[List[Any]] = None,
) -> Callable[[T_Handler], T_Handler]: ) -> Callable[[T_Handler], T_Handler]:
""" """
装饰一个函数来指示 NoneBot 当要获取的 ``key`` 不存在时接收用户新的一条消息并经过 ``ArgsParser`` 处理后再运行该函数，如果 ``key`` 已存在则直接继续运行 装饰一个函数来指示 NoneBot 当要获取的 `key` 不存在时接收用户新的一条消息并经过 `ArgsParser` 处理后再运行该函数，如果 `key` 已存在则直接继续运行
:参数: :参数:
* ``key: str``: 参数名 * `key: str`: 参数名
* ``prompt: Optional[Union[str, Message, MessageSegment, MessageFormatter]]``: 在参数不存在时向用户发送的消息 * `prompt: Optional[Union[str, Message, MessageSegment, MessageFormatter]]`: 在参数不存在时向用户发送的消息
* ``args_parser: Optional[T_ArgsParser]``: 可选参数解析函数，空则使用默认解析函数 * `args_parser: Optional[T_ArgsParser]`: 可选参数解析函数，空则使用默认解析函数
* ``parameterless: Optional[List[Any]]``: 非参数类型依赖列表 * `parameterless: Optional[List[Any]]`: 非参数类型依赖列表
""" """
async def _key_getter(event: Event, matcher: "Matcher"): async def _key_getter(event: Event, matcher: "Matcher"):
@ -470,8 +470,8 @@ class Matcher(metaclass=MatcherMeta):
:参数: :参数:
* ``message: Union[str, Message, MessageSegment]``: 消息内容 * `message: Union[str, Message, MessageSegment]`: 消息内容
* ``**kwargs``: 其他传递给 ``bot.send`` 的参数，请参考对应 adapter 的 bot 对象 api * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
""" """
bot = current_bot.get() bot = current_bot.get()
event = current_event.get() event = current_event.get()
@ -493,8 +493,8 @@ class Matcher(metaclass=MatcherMeta):
:参数: :参数:
* ``message: Union[str, Message, MessageSegment, MessageTemplate]``: 消息内容 * `message: Union[str, Message, MessageSegment, MessageTemplate]`: 消息内容
* ``**kwargs``: 其他传递给 ``bot.send`` 的参数，请参考对应 adapter 的 bot 对象 api * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
""" """
if message is not None: if message is not None:
await cls.send(message, **kwargs) await cls.send(message, **kwargs)
@ -511,8 +511,8 @@ class Matcher(metaclass=MatcherMeta):
:参数: :参数:
* ``prompt: Union[str, Message, MessageSegment, MessageTemplate]``: 消息内容 * `prompt: Union[str, Message, MessageSegment, MessageTemplate]`: 消息内容
* ``**kwargs``: 其他传递给 ``bot.send`` 的参数，请参考对应 adapter 的 bot 对象 api * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
""" """
if prompt is not None: if prompt is not None:
await cls.send(prompt, **kwargs) await cls.send(prompt, **kwargs)
@ -525,12 +525,12 @@ class Matcher(metaclass=MatcherMeta):
**kwargs, **kwargs,
) -> NoReturn: ) -> NoReturn:
""" """
最近使用 ``got`` / ``receive`` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 最近使用 `got` / `receive` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数
:参数: :参数:
* ``prompt: Union[str, Message, MessageSegment, MessageTemplate]``: 消息内容 * `prompt: Union[str, Message, MessageSegment, MessageTemplate]`: 消息内容
* ``**kwargs``: 其他传递给 ``bot.send`` 的参数，请参考对应 adapter 的 bot 对象 api * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
""" """
if prompt is not None: if prompt is not None:
await cls.send(prompt, **kwargs) await cls.send(prompt, **kwargs)
@ -544,13 +544,13 @@ class Matcher(metaclass=MatcherMeta):
**kwargs, **kwargs,
) -> NoReturn: ) -> NoReturn:
""" """
最近使用 ``got`` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 最近使用 `got` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数
:参数: :参数:
* ``key: str``: 参数名 * `key: str`: 参数名
* ``prompt: Union[str, Message, MessageSegment, MessageTemplate]``: 消息内容 * `prompt: Union[str, Message, MessageSegment, MessageTemplate]`: 消息内容
* ``**kwargs``: 其他传递给 ``bot.send`` 的参数，请参考对应 adapter 的 bot 对象 api * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
""" """
matcher = current_matcher.get() matcher = current_matcher.get()
matcher.set_target(ARG_KEY.format(key=key)) matcher.set_target(ARG_KEY.format(key=key))
@ -566,13 +566,13 @@ class Matcher(metaclass=MatcherMeta):
**kwargs, **kwargs,
) -> NoReturn: ) -> NoReturn:
""" """
最近使用 ``got`` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数 最近使用 `got` 接收的消息不符合预期，发送一条消息给当前交互用户并暂停事件响应器，在接收用户新的一条消息后继续当前处理函数
:参数: :参数:
* ``id: str``: 消息 id * `id: str`: 消息 id
* ``prompt: Union[str, Message, MessageSegment, MessageTemplate]``: 消息内容 * `prompt: Union[str, Message, MessageSegment, MessageTemplate]`: 消息内容
* ``**kwargs``: 其他传递给 ``bot.send`` 的参数，请参考对应 adapter 的 bot 对象 api * `**kwargs`: 其他传递给 `bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
""" """
matcher = current_matcher.get() matcher = current_matcher.get()
matcher.set_target(RECEIVE_KEY.format(id=id)) matcher.set_target(RECEIVE_KEY.format(id=id))

4
nonebot/message.py
View File

@ -238,8 +238,8 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
:参数: :参数:
* ``bot: Bot``: Bot 对象 * `bot: Bot`: Bot 对象
* ``event: Event``: Event 对象 * `event: Event`: Event 对象
:示例: :示例:

4
nonebot/params.py
View File

@ -60,8 +60,8 @@ def Depends(
:参数: :参数:
* ``dependency: Optional[Callable[..., Any]] = None``: 依赖函数。默认为参数的类型注释。 * `dependency: Optional[Callable[..., Any]] = None`: 依赖函数。默认为参数的类型注释。
* ``use_cache: bool = True``: 是否使用缓存。默认为 ``True``。 * `use_cache: bool = True`: 是否使用缓存。默认为 `True`。
.. code-block:: python .. code-block:: python

34
nonebot/permission.py
View File

@ -2,10 +2,10 @@ r"""
权限 权限
==== ====
每个 ``Matcher`` 拥有一个 ``Permission`` ，其中是 ``PermissionChecker`` 的集合，只要有一个 ``PermissionChecker`` 检查结果为 ``True`` 时就会继续运行。 每个 `Matcher` 拥有一个 `Permission` ，其中是 `PermissionChecker` 的集合，只要有一个 `PermissionChecker` 检查结果为 `True` 时就会继续运行。
\:\:\:tip 提示 \:\:\: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: 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( self.checkers: Set[Dependent[bool]] = set(
@ -72,7 +72,7 @@ class Permission:
for checker in checkers for checker in checkers
) )
""" """
存储 ``PermissionChecker`` 存储 `PermissionChecker`
""" """
async def __call__( async def __call__(
@ -87,14 +87,14 @@ class Permission:
:参数: :参数:
* ``bot: Bot``: Bot 对象 * `bot: Bot`: Bot 对象
* ``event: Event``: Event 对象 * `event: Event`: Event 对象
* ``stack: Optional[AsyncExitStack]``: 异步上下文栈 * `stack: Optional[AsyncExitStack]`: 异步上下文栈
* ``dependency_cache: Optional[CacheDict[T_Handler, Any]]``: 依赖缓存 * `dependency_cache: Optional[CacheDict[T_Handler, Any]]`: 依赖缓存
:返回: :返回:
- ``bool`` - `bool`
""" """
if not self.checkers: if not self.checkers:
return True return True
@ -149,19 +149,19 @@ class MetaEvent:
MESSAGE = Permission(Message()) MESSAGE = Permission(Message())
""" """
匹配任意 ``message`` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 message type 的 Matcher。 匹配任意 `message` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 message type 的 Matcher。
""" """
NOTICE = Permission(Notice()) NOTICE = Permission(Notice())
""" """
匹配任意 ``notice`` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 notice type 的 Matcher。 匹配任意 `notice` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 notice type 的 Matcher。
""" """
REQUEST = Permission(Request()) REQUEST = Permission(Request())
""" """
匹配任意 ``request`` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 request type 的 Matcher。 匹配任意 `request` 类型事件，仅在需要同时捕获不同类型事件时使用。优先使用 request type 的 Matcher。
""" """
METAEVENT = Permission(MetaEvent()) 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): def USER(*users: str, perm: Optional[Permission] = None):
""" """
``event`` 的 ``session_id`` 在白名单内且满足 perm `event` 的 `session_id` 在白名单内且满足 perm
:参数: :参数:
* ``*user: str``: 白名单 * `*user: str`: 白名单
* ``perm: Optional[Permission]``: 需要同时满足的权限 * `perm: Optional[Permission]`: 需要同时满足的权限
""" """
return Permission(User(users, perm)) return Permission(User(users, perm))

2
nonebot/plugin/export.py
View File

@ -48,7 +48,7 @@ def export() -> Export:
:返回: :返回:
- ``Export`` - `Export`
""" """
plugin = _current_plugin.get() plugin = _current_plugin.get()
if not plugin: if not plugin:

48
nonebot/plugin/load.py
View File

@ -12,15 +12,15 @@ from .plugin import Plugin, get_plugin
def load_plugin(module_path: str) -> Optional[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]) manager = PluginManager([module_path])
@ -30,15 +30,15 @@ def load_plugin(module_path: str) -> Optional[Plugin]:
def load_plugins(*plugin_dir: str) -> Set[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) manager = PluginManager(search_path=plugin_dir)
_managers.append(manager) _managers.append(manager)
@ -49,16 +49,16 @@ def load_all_plugins(
module_path: Iterable[str], plugin_dir: Iterable[str] module_path: Iterable[str], plugin_dir: Iterable[str]
) -> Set[Plugin]: ) -> Set[Plugin]:
""" """
导入指定列表中的插件以及指定目录下多个插件，以 ``_`` 开头的插件不会被导入！ 导入指定列表中的插件以及指定目录下多个插件，以 `_` 开头的插件不会被导入！
:参数: :参数:
- ``module_path: Iterable[str]``: 指定插件集合 - `module_path: Iterable[str]`: 指定插件集合
- ``plugin_dir: Iterable[str]``: 指定插件路径集合 - `plugin_dir: Iterable[str]`: 指定插件路径集合
:返回: :返回:
- ``Set[Plugin]`` - `Set[Plugin]`
""" """
manager = PluginManager(module_path, plugin_dir) manager = PluginManager(module_path, plugin_dir)
_managers.append(manager) _managers.append(manager)
@ -67,16 +67,16 @@ def load_all_plugins(
def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]: 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 文件路径 - `file_path: str`: 指定 json 文件路径
- ``encoding: str``: 指定 json 文件编码 - `encoding: str`: 指定 json 文件编码
:返回: :返回:
- ``Set[Plugin]`` - `Set[Plugin]`
""" """
with open(file_path, "r", encoding=encoding) as f: with open(file_path, "r", encoding=encoding) as f:
data = json.load(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]: 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 文件路径 - `file_path: str`: 指定 toml 文件路径
- ``encoding: str``: 指定 toml 文件编码 - `encoding: str`: 指定 toml 文件编码
:返回: :返回:
- ``Set[Plugin]`` - `Set[Plugin]`
""" """
with open(file_path, "r", encoding=encoding) as f: with open(file_path, "r", encoding=encoding) as f:
data = tomlkit.parse(f.read()) # type: ignore 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}") 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], []) 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) plugin = get_plugin(name) or load_plugin(name)
if not plugin: if not plugin:

428
nonebot/plugin/on.py
View File

@ -59,18 +59,18 @@ def on(
:参数: :参数:
* ``type: str``: 事件响应器类型 * `type: str`: 事件响应器类型
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
matcher = Matcher.new( matcher = Matcher.new(
type, type,
@ -103,16 +103,16 @@ def on_metaevent(
:参数: :参数:
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
matcher = Matcher.new( matcher = Matcher.new(
"meta_event", "meta_event",
@ -146,17 +146,17 @@ def on_message(
:参数: :参数:
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
matcher = Matcher.new( matcher = Matcher.new(
"message", "message",
@ -189,16 +189,16 @@ def on_notice(
:参数: :参数:
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
matcher = Matcher.new( matcher = Matcher.new(
"notice", "notice",
@ -231,16 +231,16 @@ def on_request(
:参数: :参数:
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
matcher = Matcher.new( matcher = Matcher.new(
"request", "request",
@ -270,19 +270,19 @@ def on_startswith(
:参数: :参数:
* ``msg: Union[str, Tuple[str, ...]]``: 指定消息开头内容 * `msg: Union[str, Tuple[str, ...]]`: 指定消息开头内容
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``ignorecase: bool``: 是否忽略大小写 * `ignorecase: bool`: 是否忽略大小写
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
return on_message(startswith(msg, ignorecase) & rule, **kwargs, _depth=_depth + 1) return on_message(startswith(msg, ignorecase) & rule, **kwargs, _depth=_depth + 1)
@ -299,19 +299,19 @@ def on_endswith(
:参数: :参数:
* ``msg: Union[str, Tuple[str, ...]]``: 指定消息结尾内容 * `msg: Union[str, Tuple[str, ...]]`: 指定消息结尾内容
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``ignorecase: bool``: 是否忽略大小写 * `ignorecase: bool`: 是否忽略大小写
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
return on_message(endswith(msg, ignorecase) & rule, **kwargs, _depth=_depth + 1) return on_message(endswith(msg, ignorecase) & rule, **kwargs, _depth=_depth + 1)
@ -327,18 +327,18 @@ def on_keyword(
:参数: :参数:
* ``keywords: Set[str]``: 关键词列表 * `keywords: Set[str]`: 关键词列表
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
return on_message(keyword(*keywords) & rule, **kwargs, _depth=_depth + 1) return on_message(keyword(*keywords) & rule, **kwargs, _depth=_depth + 1)
@ -357,19 +357,19 @@ def on_command(
:参数: :参数:
* ``cmd: Union[str, Tuple[str, ...]]``: 指定命令内容 * `cmd: Union[str, Tuple[str, ...]]`: 指定命令内容
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``aliases: Optional[Set[Union[str, Tuple[str, ...]]]]``: 命令别名 * `aliases: Optional[Set[Union[str, Tuple[str, ...]]]]`: 命令别名
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
commands = set([cmd]) | (aliases or set()) commands = set([cmd]) | (aliases or set())
@ -388,28 +388,28 @@ def on_shell_command(
**kwargs, **kwargs,
) -> Type[Matcher]: ) -> 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, ...]]``: 指定命令内容 * `cmd: Union[str, Tuple[str, ...]]`: 指定命令内容
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``aliases: Optional[Set[Union[str, Tuple[str, ...]]]]``: 命令别名 * `aliases: Optional[Set[Union[str, Tuple[str, ...]]]]`: 命令别名
* ``parser: Optional[ArgumentParser]``: ``nonebot.rule.ArgumentParser`` 对象 * `parser: Optional[ArgumentParser]`: `nonebot.rule.ArgumentParser` 对象
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
commands = set([cmd]) | (aliases or set()) commands = set([cmd]) | (aliases or set())
@ -434,19 +434,19 @@ def on_regex(
:参数: :参数:
* ``pattern: str``: 正则表达式 * `pattern: str`: 正则表达式
* ``flags: Union[int, re.RegexFlag]``: 正则匹配标志 * `flags: Union[int, re.RegexFlag]`: 正则匹配标志
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
return on_message(regex(pattern, flags) & rule, **kwargs, _depth=_depth + 1) return on_message(regex(pattern, flags) & rule, **kwargs, _depth=_depth + 1)
@ -458,8 +458,8 @@ class CommandGroup:
""" """
:参数: :参数:
* ``cmd: Union[str, Tuple[str, ...]]``: 命令前缀 * `cmd: Union[str, Tuple[str, ...]]`: 命令前缀
* ``**kwargs``: 其他传递给 ``on_command`` 的参数默认值，参考 `on_command <#on-command-cmd-rule-none-aliases-none-kwargs>`_ * `**kwargs`: 其他传递给 `on_command` 的参数默认值，参考 `on_command <#on-command-cmd-rule-none-aliases-none-kwargs>`_
""" """
self.basecmd: Tuple[str, ...] = (cmd,) if isinstance(cmd, str) else cmd self.basecmd: Tuple[str, ...] = (cmd,) if isinstance(cmd, str) else cmd
""" """
@ -469,7 +469,7 @@ class CommandGroup:
del kwargs["aliases"] del kwargs["aliases"]
self.base_kwargs: Dict[str, Any] = kwargs self.base_kwargs: Dict[str, Any] = kwargs
""" """
其他传递给 ``on_command`` 的参数默认值 其他传递给 `on_command` 的参数默认值
""" """
def command(self, cmd: Union[str, Tuple[str, ...]], **kwargs) -> Type[Matcher]: def command(self, cmd: Union[str, Tuple[str, ...]], **kwargs) -> Type[Matcher]:
@ -478,12 +478,12 @@ class CommandGroup:
:参数: :参数:
* ``cmd: Union[str, Tuple[str, ...]]``: 命令前缀 * `cmd: Union[str, Tuple[str, ...]]`: 命令前缀
* ``**kwargs``: 其他传递给 ``on_command`` 的参数，将会覆盖命令组默认值 * `**kwargs`: 其他传递给 `on_command` 的参数，将会覆盖命令组默认值
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
sub_cmd = (cmd,) if isinstance(cmd, str) else cmd sub_cmd = (cmd,) if isinstance(cmd, str) else cmd
cmd = self.basecmd + sub_cmd cmd = self.basecmd + sub_cmd
@ -500,12 +500,12 @@ class CommandGroup:
:参数: :参数:
* ``cmd: Union[str, Tuple[str, ...]]``: 命令前缀 * `cmd: Union[str, Tuple[str, ...]]`: 命令前缀
* ``**kwargs``: 其他传递给 ``on_shell_command`` 的参数，将会覆盖命令组默认值 * `**kwargs`: 其他传递给 `on_shell_command` 的参数，将会覆盖命令组默认值
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
sub_cmd = (cmd,) if isinstance(cmd, str) else cmd sub_cmd = (cmd,) if isinstance(cmd, str) else cmd
cmd = self.basecmd + sub_cmd cmd = self.basecmd + sub_cmd
@ -516,11 +516,11 @@ class CommandGroup:
class MatcherGroup: class MatcherGroup:
"""事件响应器组合，统一管理。为 ``Matcher`` 创建提供默认属性。""" """事件响应器组合，统一管理。为 `Matcher` 创建提供默认属性。"""
def __init__(self, **kwargs): def __init__(self, **kwargs):
""" """
创建一个事件响应器组合，参数为默认值，与 ``on`` 一致 创建一个事件响应器组合，参数为默认值，与 `on` 一致
""" """
self.matchers: List[Type[Matcher]] = [] self.matchers: List[Type[Matcher]] = []
""" """
@ -528,7 +528,7 @@ class MatcherGroup:
""" """
self.base_kwargs: Dict[str, Any] = kwargs self.base_kwargs: Dict[str, Any] = kwargs
""" """
其他传递给 ``on`` 的参数默认值 其他传递给 `on` 的参数默认值
""" """
def on(self, **kwargs) -> Type[Matcher]: def on(self, **kwargs) -> Type[Matcher]:
@ -537,18 +537,18 @@ class MatcherGroup:
:参数: :参数:
* ``type: str``: 事件响应器类型 * `type: str`: 事件响应器类型
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
final_kwargs = self.base_kwargs.copy() final_kwargs = self.base_kwargs.copy()
final_kwargs.update(kwargs) final_kwargs.update(kwargs)
@ -562,16 +562,16 @@ class MatcherGroup:
:参数: :参数:
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
final_kwargs = self.base_kwargs.copy() final_kwargs = self.base_kwargs.copy()
final_kwargs.update(kwargs) final_kwargs.update(kwargs)
@ -587,17 +587,17 @@ class MatcherGroup:
:参数: :参数:
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
final_kwargs = self.base_kwargs.copy() final_kwargs = self.base_kwargs.copy()
final_kwargs.update(kwargs) final_kwargs.update(kwargs)
@ -612,16 +612,16 @@ class MatcherGroup:
:参数: :参数:
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
final_kwargs = self.base_kwargs.copy() final_kwargs = self.base_kwargs.copy()
final_kwargs.update(kwargs) final_kwargs.update(kwargs)
@ -636,16 +636,16 @@ class MatcherGroup:
:参数: :参数:
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
final_kwargs = self.base_kwargs.copy() final_kwargs = self.base_kwargs.copy()
final_kwargs.update(kwargs) final_kwargs.update(kwargs)
@ -662,19 +662,19 @@ class MatcherGroup:
:参数: :参数:
* ``msg: Union[str, Tuple[str, ...]]``: 指定消息开头内容 * `msg: Union[str, Tuple[str, ...]]`: 指定消息开头内容
* ``ignorecase: bool``: 是否忽略大小写 * `ignorecase: bool`: 是否忽略大小写
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
final_kwargs = self.base_kwargs.copy() final_kwargs = self.base_kwargs.copy()
final_kwargs.update(kwargs) final_kwargs.update(kwargs)
@ -689,19 +689,19 @@ class MatcherGroup:
:参数: :参数:
* ``msg: Union[str, Tuple[str, ...]]``: 指定消息结尾内容 * `msg: Union[str, Tuple[str, ...]]`: 指定消息结尾内容
* ``ignorecase: bool``: 是否忽略大小写 * `ignorecase: bool`: 是否忽略大小写
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
final_kwargs = self.base_kwargs.copy() final_kwargs = self.base_kwargs.copy()
final_kwargs.update(kwargs) final_kwargs.update(kwargs)
@ -716,18 +716,18 @@ class MatcherGroup:
:参数: :参数:
* ``keywords: Set[str]``: 关键词列表 * `keywords: Set[str]`: 关键词列表
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
final_kwargs = self.base_kwargs.copy() final_kwargs = self.base_kwargs.copy()
final_kwargs.update(kwargs) final_kwargs.update(kwargs)
@ -749,19 +749,19 @@ class MatcherGroup:
:参数: :参数:
* ``cmd: Union[str, Tuple[str, ...]]``: 指定命令内容 * `cmd: Union[str, Tuple[str, ...]]`: 指定命令内容
* ``aliases: Optional[Set[Union[str, Tuple[str, ...]]]]``: 命令别名 * `aliases: Optional[Set[Union[str, Tuple[str, ...]]]]`: 命令别名
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
final_kwargs = self.base_kwargs.copy() final_kwargs = self.base_kwargs.copy()
final_kwargs.update(kwargs) final_kwargs.update(kwargs)
@ -778,28 +778,28 @@ class MatcherGroup:
**kwargs, **kwargs,
) -> Type[Matcher]: ) -> 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, ...]]``: 指定命令内容 * `cmd: Union[str, Tuple[str, ...]]`: 指定命令内容
* ``aliases: Optional[Set[Union[str, Tuple[str, ...]]]]``: 命令别名 * `aliases: Optional[Set[Union[str, Tuple[str, ...]]]]`: 命令别名
* ``parser: Optional[ArgumentParser]``: ``nonebot.rule.ArgumentParser`` 对象 * `parser: Optional[ArgumentParser]`: `nonebot.rule.ArgumentParser` 对象
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
final_kwargs = self.base_kwargs.copy() final_kwargs = self.base_kwargs.copy()
final_kwargs.update(kwargs) final_kwargs.update(kwargs)
@ -820,19 +820,19 @@ class MatcherGroup:
:参数: :参数:
* ``pattern: str``: 正则表达式 * `pattern: str`: 正则表达式
* ``flags: Union[int, re.RegexFlag]``: 正则匹配标志 * `flags: Union[int, re.RegexFlag]`: 正则匹配标志
* ``rule: Optional[Union[Rule, T_RuleChecker]]``: 事件响应规则 * `rule: Optional[Union[Rule, T_RuleChecker]]`: 事件响应规则
* ``permission: Optional[Union[Permission, T_PermissionChecker]] =]]``: 事件响应权限 * `permission: Optional[Union[Permission, T_PermissionChecker]] =]]`: 事件响应权限
* ``handlers: Optional[List[Union[T_Handler, Dependent]]]``: 事件处理函数列表 * `handlers: Optional[List[Union[T_Handler, Dependent]]]`: 事件处理函数列表
* ``temp: bool``: 是否为临时事件响应器（仅执行一次） * `temp: bool`: 是否为临时事件响应器（仅执行一次）
* ``priority: int``: 事件响应器优先级 * `priority: int`: 事件响应器优先级
* ``block: bool``: 是否阻止事件向更低优先级传递 * `block: bool`: 是否阻止事件向更低优先级传递
* ``state: Optional[T_State]``: 默认 state * `state: Optional[T_State]`: 默认 state
:返回: :返回:
- ``Type[Matcher]`` - `Type[Matcher]`
""" """
final_kwargs = self.base_kwargs.copy() final_kwargs = self.base_kwargs.copy()
final_kwargs.update(kwargs) final_kwargs.update(kwargs)

8
nonebot/plugin/plugin.py
View File

@ -40,7 +40,7 @@ class Plugin(object):
""" """
matcher: Set[Type[Matcher]] = field(default_factory=set) matcher: Set[Type[Matcher]] = field(default_factory=set)
""" """
插件内定义的 ``Matcher`` 插件内定义的 `Matcher`
""" """
parent_plugin: Optional["Plugin"] = None 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) return plugins.get(name)
@ -73,7 +73,7 @@ def get_loaded_plugins() -> Set[Plugin]:
:返回: :返回:
- ``Set[Plugin]`` - `Set[Plugin]`
""" """
return set(plugins.values()) return set(plugins.values())

66
nonebot/rule.py
View File

@ -2,10 +2,10 @@ r"""
规则 规则
==== ====
每个事件响应器 ``Matcher`` 拥有一个匹配规则 ``Rule`` ，其中是 ``RuleChecker`` 的集合，只有当所有 ``RuleChecker`` 检查结果为 ``True`` 时继续运行。 每个事件响应器 `Matcher` 拥有一个匹配规则 `Rule` ，其中是 `RuleChecker` 的集合，只有当所有 `RuleChecker` 检查结果为 `True` 时继续运行。
\:\:\:tip 提示 \:\:\:tip 提示
``RuleChecker`` 既可以是 async function 也可以是 sync function `RuleChecker` 既可以是 async function 也可以是 sync function
\:\:\: \:\:\:
""" """
@ -63,7 +63,7 @@ CMD_RESULT = TypedDict(
class Rule: 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( self.checkers: Set[Dependent[bool]] = set(
@ -101,7 +101,7 @@ class Rule:
for checker in checkers for checker in checkers
) )
""" """
存储 ``RuleChecker`` 存储 `RuleChecker`
""" """
async def __call__( async def __call__(
@ -117,15 +117,15 @@ class Rule:
:参数: :参数:
* ``bot: Bot``: Bot 对象 * `bot: Bot`: Bot 对象
* ``event: Event``: Event 对象 * `event: Event`: Event 对象
* ``state: T_State``: 当前 State * `state: T_State`: 当前 State
* ``stack: Optional[AsyncExitStack]``: 异步上下文栈 * `stack: Optional[AsyncExitStack]`: 异步上下文栈
* ``dependency_cache: Optional[CacheDict[T_Handler, Any]]``: 依赖缓存 * `dependency_cache: Optional[CacheDict[T_Handler, Any]]`: 依赖缓存
:返回: :返回:
- ``bool`` - `bool`
""" """
if not self.checkers: if not self.checkers:
return True 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): if isinstance(msg, str):
msg = (msg,) 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): if isinstance(msg, str):
msg = (msg,) msg = (msg,)
@ -277,7 +277,7 @@ def keyword(*keywords: str) -> Rule:
:参数: :参数:
* ``*keywords: str``: 关键词 * `*keywords: str`: 关键词
""" """
return Rule(KeywordsRule(*keywords)) return Rule(KeywordsRule(*keywords))
@ -296,20 +296,20 @@ class CommandRule:
def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule: def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule:
r""" 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",)` 可以匹配：`/test` 开头的消息
命令 ``("test", "sub")`` 可以匹配”``/test.sub`` 开头的消息 命令 `("test", "sub")` 可以匹配”`/test.sub` 开头的消息
\:\:\:tip 提示 \:\:\:tip 提示
命令内容与后续消息间无需空格！ 命令内容与后续消息间无需空格！
@ -338,7 +338,7 @@ def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule:
class ArgumentParser(ArgParser): class ArgumentParser(ArgParser):
""" """
``shell_like`` 命令参数解析器，解析出错时不会退出程序。 `shell_like` 命令参数解析器，解析出错时不会退出程序。
""" """
def _print_message(self, message, file=None): def _print_message(self, message, file=None):
@ -392,22 +392,22 @@ def shell_command(
*cmds: Union[str, Tuple[str, ...]], parser: Optional[ArgumentParser] = None *cmds: Union[str, Tuple[str, ...]], parser: Optional[ArgumentParser] = None
) -> Rule: ) -> Rule:
r""" 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, ...]]``: 命令内容 * `*cmds: Union[str, Tuple[str, ...]]`: 命令内容
* ``parser: Optional[ArgumentParser]``: ``nonebot.rule.ArgumentParser`` 对象 * `parser: Optional[ArgumentParser]`: `nonebot.rule.ArgumentParser` 对象
:示例: :示例:
使用默认 ``command_start``, ``command_sep`` 配置，更多示例参考 ``argparse`` 标准库文档。 使用默认 `command_start`, `command_sep` 配置，更多示例参考 `argparse` 标准库文档。
.. code-block:: python .. code-block:: python
@ -472,16 +472,16 @@ def regex(regex: str, flags: Union[int, re.RegexFlag] = 0) -> Rule:
r""" r"""
根据正则表达式进行匹配。 根据正则表达式进行匹配。
可以通过 ``state["_matched"]`` ``state["_matched_groups"]`` ``state["_matched_dict"]`` 可以通过 `state["_matched"]` `state["_matched_groups"]` `state["_matched_dict"]`
获取正则表达式匹配成功的文本。 获取正则表达式匹配成功的文本。
:参数: :参数:
* ``regex: str``: 正则表达式 * `regex: str`: 正则表达式
* ``flags: Union[int, re.RegexFlag]``: 正则标志 * `flags: Union[int, re.RegexFlag]`: 正则标志
\:\:\:tip 提示 \:\:\:tip 提示
正则表达式匹配使用 search 而非 match，如需从头匹配请使用 ``r"^xxx"`` 来确保匹配开头 正则表达式匹配使用 search 而非 match，如需从头匹配请使用 `r"^xxx"` 来确保匹配开头
\:\:\: \:\:\:
""" """
@ -495,7 +495,7 @@ class ToMeRule:
def to_me() -> Rule: def to_me() -> Rule:
""" """
通过 ``event.is_tome()`` 判断事件是否与机器人有关 通过 `event.is_tome()` 判断事件是否与机器人有关
:参数: :参数:

94
nonebot/typing.py
View File

@ -60,24 +60,24 @@ Bot 连接断开时执行的函数
""" """
T_CallingAPIHook = Callable[["Bot", str, Dict[str, Any]], Awaitable[None]] T_CallingAPIHook = Callable[["Bot", str, Dict[str, Any]], Awaitable[None]]
""" """
``bot.call_api`` 时执行的函数 `bot.call_api` 时执行的函数
""" """
T_CalledAPIHook = Callable[ T_CalledAPIHook = Callable[
["Bot", Optional[Exception], str, Dict[str, Any], Any], Awaitable[None] ["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]]] T_EventPreProcessor = Callable[..., Union[None, Awaitable[None]]]
""" """
:依赖参数: :依赖参数:
* ``DependParam``: 子依赖参数 * `DependParam`: 子依赖参数
* ``BotParam``: Bot 对象 * `BotParam`: Bot 对象
* ``EventParam``: Event 对象 * `EventParam`: Event 对象
* ``StateParam``: State 对象 * `StateParam`: State 对象
* ``DefaultParam``: 带有默认值的参数 * `DefaultParam`: 带有默认值的参数
事件预处理函数 EventPreProcessor 类型 事件预处理函数 EventPreProcessor 类型
""" """
@ -85,11 +85,11 @@ T_EventPostProcessor = Callable[..., Union[None, Awaitable[None]]]
""" """
:依赖参数: :依赖参数:
* ``DependParam``: 子依赖参数 * `DependParam`: 子依赖参数
* ``BotParam``: Bot 对象 * `BotParam`: Bot 对象
* ``EventParam``: Event 对象 * `EventParam`: Event 对象
* ``StateParam``: State 对象 * `StateParam`: State 对象
* ``DefaultParam``: 带有默认值的参数 * `DefaultParam`: 带有默认值的参数
事件预处理函数 EventPostProcessor 类型 事件预处理函数 EventPostProcessor 类型
""" """
@ -97,12 +97,12 @@ T_RunPreProcessor = Callable[..., Union[None, Awaitable[None]]]
""" """
:依赖参数: :依赖参数:
* ``DependParam``: 子依赖参数 * `DependParam`: 子依赖参数
* ``BotParam``: Bot 对象 * `BotParam`: Bot 对象
* ``EventParam``: Event 对象 * `EventParam`: Event 对象
* ``StateParam``: State 对象 * `StateParam`: State 对象
* ``MatcherParam``: Matcher 对象 * `MatcherParam`: Matcher 对象
* ``DefaultParam``: 带有默认值的参数 * `DefaultParam`: 带有默认值的参数
事件响应器运行前预处理函数 RunPreProcessor 类型 事件响应器运行前预处理函数 RunPreProcessor 类型
""" """
@ -110,13 +110,13 @@ T_RunPostProcessor = Callable[..., Union[None, Awaitable[None]]]
""" """
:依赖参数: :依赖参数:
* ``DependParam``: 子依赖参数 * `DependParam`: 子依赖参数
* ``BotParam``: Bot 对象 * `BotParam`: Bot 对象
* ``EventParam``: Event 对象 * `EventParam`: Event 对象
* ``StateParam``: State 对象 * `StateParam`: State 对象
* ``MatcherParam``: Matcher 对象 * `MatcherParam`: Matcher 对象
* ``ExceptionParam``: 异常对象（可能为 None） * `ExceptionParam`: 异常对象（可能为 None）
* ``DefaultParam``: 带有默认值的参数 * `DefaultParam`: 带有默认值的参数
事件响应器运行前预处理函数 RunPostProcessor 类型，第二个参数为运行时产生的错误（如果存在） 事件响应器运行前预处理函数 RunPostProcessor 类型，第二个参数为运行时产生的错误（如果存在）
""" """
@ -125,11 +125,11 @@ T_RuleChecker = Callable[..., Union[bool, Awaitable[bool]]]
""" """
:依赖参数: :依赖参数:
* ``DependParam``: 子依赖参数 * `DependParam`: 子依赖参数
* ``BotParam``: Bot 对象 * `BotParam`: Bot 对象
* ``EventParam``: Event 对象 * `EventParam`: Event 对象
* ``StateParam``: State 对象 * `StateParam`: State 对象
* ``DefaultParam``: 带有默认值的参数 * `DefaultParam`: 带有默认值的参数
RuleChecker 即判断是否响应事件的处理函数。 RuleChecker 即判断是否响应事件的处理函数。
""" """
@ -137,10 +137,10 @@ T_PermissionChecker = Callable[..., Union[bool, Awaitable[bool]]]
""" """
:依赖参数: :依赖参数:
* ``DependParam``: 子依赖参数 * `DependParam`: 子依赖参数
* ``BotParam``: Bot 对象 * `BotParam`: Bot 对象
* ``EventParam``: Event 对象 * `EventParam`: Event 对象
* ``DefaultParam``: 带有默认值的参数 * `DefaultParam`: 带有默认值的参数
RuleChecker 即判断是否响应消息的处理函数。 RuleChecker 即判断是否响应消息的处理函数。
""" """
@ -153,25 +153,25 @@ T_TypeUpdater = Callable[..., Union[str, Awaitable[str]]]
""" """
:依赖参数: :依赖参数:
* ``DependParam``: 子依赖参数 * `DependParam`: 子依赖参数
* ``BotParam``: Bot 对象 * `BotParam`: Bot 对象
* ``EventParam``: Event 对象 * `EventParam`: Event 对象
* ``StateParam``: State 对象 * `StateParam`: State 对象
* ``MatcherParam``: Matcher 对象 * `MatcherParam`: Matcher 对象
* ``DefaultParam``: 带有默认值的参数 * `DefaultParam`: 带有默认值的参数
TypeUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新响应的事件类型。默认会更新为 ``message``。 TypeUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新响应的事件类型。默认会更新为 `message`。
""" """
T_PermissionUpdater = Callable[..., Union["Permission", Awaitable["Permission"]]] T_PermissionUpdater = Callable[..., Union["Permission", Awaitable["Permission"]]]
""" """
:依赖参数: :依赖参数:
* ``DependParam``: 子依赖参数 * `DependParam`: 子依赖参数
* ``BotParam``: Bot 对象 * `BotParam`: Bot 对象
* ``EventParam``: Event 对象 * `EventParam`: Event 对象
* ``StateParam``: State 对象 * `StateParam`: State 对象
* ``MatcherParam``: Matcher 对象 * `MatcherParam`: Matcher 对象
* ``DefaultParam``: 带有默认值的参数 * `DefaultParam`: 带有默认值的参数
PermissionUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新会话对象权限。默认会更新为当前事件的触发对象。 PermissionUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新会话对象权限。默认会更新为当前事件的触发对象。
""" """

18
nonebot/utils.py
View File

@ -31,15 +31,15 @@ V = TypeVar("V")
def escape_tag(s: str) -> str: def escape_tag(s: str) -> str:
""" """
用于记录带颜色日志时转义 ``<tag>`` 类型特殊标签 用于记录带颜色日志时转义 `<tag>` 类型特殊标签
:参数: :参数:
* ``s: str``: 需要转义的字符串 * `s: str`: 需要转义的字符串
:返回: :返回:
- ``str`` - `str`
""" """
return re.sub(r"</?((?:[fb]g\s)?[^<>\s]*)>", r"\\\g<0>", s) return re.sub(r"</?((?:[fb]g\s)?[^<>\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) @wraps(call)
@ -131,7 +131,7 @@ def get_name(obj: Any) -> str:
class DataclassEncoder(json.JSONEncoder): class DataclassEncoder(json.JSONEncoder):
""" """
在JSON序列化 ``Message`` (List[Dataclass]) 时使用的 ``JSONEncoder`` 在JSON序列化 `Message` (List[Dataclass]) 时使用的 `JSONEncoder`
""" """
@overrides(json.JSONEncoder) @overrides(json.JSONEncoder)
@ -147,9 +147,9 @@ def logger_wrapper(logger_name: str):
:log 参数: :log 参数:
* ``level: Literal["CRITICAL", "WARNING", "INFO", "DEBUG", "TRACE"]``: 日志等级 * `level: Literal["CRITICAL", "WARNING", "INFO", "DEBUG", "TRACE"]`: 日志等级
* ``message: str``: 日志信息 * `message: str`: 日志信息
* ``exception: Optional[Exception]``: 异常信息 * `exception: Optional[Exception]`: 异常信息
""" """
def log(level: str, message: str, exception: Optional[Exception] = None): def log(level: str, message: str, exception: Optional[Exception] = None):