🎨 format code using black and isort

2025-07-27 00:01:27 +00:00 · 2021-11-22 23:21:26 +08:00
parent 602185a34e
commit a98d98cd12
86 changed files with 2893 additions and 2095 deletions
--- a/nonebot/plugin/init.py
+++ b/nonebot/plugin/init.py
@ -9,8 +9,9 @@ from typing import List, Optional
 from contextvars import ContextVar

 _managers: List["PluginManager"] = []
-_current_plugin: ContextVar[Optional["Plugin"]] = ContextVar("_current_plugin",
-                                                             default=None)
+_current_plugin: ContextVar[Optional["Plugin"]] = ContextVar(
+    "_current_plugin", default=None
+)

 from .on import on as on
 from .manager import PluginManager
--- a/nonebot/plugin/export.py
+++ b/nonebot/plugin/export.py
@ -33,8 +33,7 @@ class Export(dict):
        return func

    def __setitem__(self, key, value):
-        super().__setitem__(key,
-                            Export(value) if isinstance(value, dict) else value)
+        super().__setitem__(key, Export(value) if isinstance(value, dict) else value)

    def __setattr__(self, name, value):
        self[name] = Export(value) if isinstance(value, dict) else value
--- a/nonebot/plugin/load.py
+++ b/nonebot/plugin/load.py
@ -49,8 +49,9 @@ def load_plugins(*plugin_dir: str) -> Set[Plugin]:
    return manager.load_all_plugins()


-def load_all_plugins(module_path: Iterable[str],
-                     plugin_dir: Iterable[str]) -> Set[Plugin]:
+def load_all_plugins(
+    module_path: Iterable[str], plugin_dir: Iterable[str]
+) -> Set[Plugin]:
    """
    :说明:

@ -90,8 +91,7 @@ def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]:
    plugins = data.get("plugins")
    plugin_dirs = data.get("plugin_dirs")
    assert isinstance(plugins, list), "plugins must be a list of plugin name"
-    assert isinstance(plugin_dirs,
-                      list), "plugin_dirs must be a list of directories"
+    assert isinstance(plugin_dirs, list), "plugin_dirs must be a list of directories"
    return load_all_plugins(set(plugins), set(plugin_dirs))


@ -120,14 +120,14 @@ def load_from_toml(file_path: str, encoding: str = "utf-8") -> Set[Plugin]:
        if nonebot_data:
            warnings.warn(
                "[nonebot.plugins] table are now deprecated. Use [tool.nonebot] instead.",
-                DeprecationWarning)
+                DeprecationWarning,
+            )
        else:
            raise ValueError("Cannot find '[tool.nonebot]' in given toml file!")
    plugins = nonebot_data.get("plugins", [])
    plugin_dirs = nonebot_data.get("plugin_dirs", [])
    assert isinstance(plugins, list), "plugins must be a list of plugin name"
-    assert isinstance(plugin_dirs,
-                      list), "plugin_dirs must be a list of directories"
+    assert isinstance(plugin_dirs, list), "plugin_dirs must be a list of directories"
    return load_all_plugins(plugins, plugin_dirs)


@ -163,5 +163,5 @@ def require(name: str) -> Export:
    """
    plugin = get_plugin(name) or load_plugin(name)
    if not plugin:
-        raise RuntimeError(f"Cannot load plugin \"{name}\"!")
+        raise RuntimeError(f'Cannot load plugin "{name}"!')
    return plugin.export
--- a/nonebot/plugin/manager.py
+++ b/nonebot/plugin/manager.py
@ -15,7 +15,6 @@ from . import _managers, _current_plugin


 class PluginManager:
-
    def __init__(
        self,
        plugins: Optional[Iterable[str]] = None,
@ -39,14 +38,15 @@ class PluginManager:
    def _previous_plugins(self) -> List[str]:
        _pre_managers: List[PluginManager]
        if self in _managers:
-            _pre_managers = _managers[:_managers.index(self)]
+            _pre_managers = _managers[: _managers.index(self)]
        else:
            _pre_managers = _managers[:]

        return [
            *chain.from_iterable(
                [*manager.plugins, *manager.searched_plugins.keys()]
-                for manager in _pre_managers)
+                for manager in _pre_managers
+            )
        ]

    def list_plugins(self) -> Set[str]:
@ -57,13 +57,14 @@ class PluginManager:
        for module_info in pkgutil.iter_modules(self.search_path):
            if module_info.name.startswith("_"):
                continue
-            if module_info.name in searched_plugins.keys(
-            ) or module_info.name in previous_plugins:
+            if (
+                module_info.name in searched_plugins.keys()
+                or module_info.name in previous_plugins
+            ):
                raise RuntimeError(
                    f"Plugin already exists: {module_info.name}! Check your plugin name"
                )
-            module_spec = module_info.module_finder.find_spec(
-                module_info.name, None)
+            module_spec = module_info.module_finder.find_spec(module_info.name, None)
            if not module_spec:
                continue
            module_path = module_spec.origin
@ -80,14 +81,15 @@ class PluginManager:
            if name in self.plugins:
                module = importlib.import_module(name)
            elif name not in self.searched_plugins:
-                raise RuntimeError(
-                    f"Plugin not found: {name}! Check your plugin name")
+                raise RuntimeError(f"Plugin not found: {name}! Check your plugin name")
            else:
                module = importlib.import_module(
-                    self._path_to_module_name(self.searched_plugins[name]))
+                    self._path_to_module_name(self.searched_plugins[name])
+                )

            logger.opt(colors=True).success(
-                f'Succeeded to import "<y>{escape_tag(name)}</y>"')
+                f'Succeeded to import "<y>{escape_tag(name)}</y>"'
+            )
            return getattr(module, "__plugin__", None)
        except Exception as e:
            logger.opt(colors=True, exception=e).error(
@ -96,16 +98,17 @@ class PluginManager:

    def load_all_plugins(self) -> Set[Plugin]:
        return set(
-            filter(None,
-                   (self.load_plugin(name) for name in self.list_plugins())))
+            filter(None, (self.load_plugin(name) for name in self.list_plugins()))
+        )


 class PluginFinder(MetaPathFinder):
-
-    def find_spec(self,
-                  fullname: str,
-                  path: Optional[Sequence[Union[bytes, str]]],
-                  target: Optional[ModuleType] = None):
+    def find_spec(
+        self,
+        fullname: str,
+        path: Optional[Sequence[Union[bytes, str]]],
+        target: Optional[ModuleType] = None,
+    ):
        if _managers:
            index = -1
            module_spec = PathFinder.find_spec(fullname, path, target)
@ -119,10 +122,11 @@ class PluginFinder(MetaPathFinder):
            while -index <= len(_managers):
                manager = _managers[index]

-                if fullname in manager.plugins or module_path in manager.searched_plugins.values(
+                if (
+                    fullname in manager.plugins
+                    or module_path in manager.searched_plugins.values()
                ):
-                    module_spec.loader = PluginLoader(manager, fullname,
-                                                      module_origin)
+                    module_spec.loader = PluginLoader(manager, fullname, module_origin)
                    return module_spec

                index -= 1
@ -130,7 +134,6 @@ class PluginFinder(MetaPathFinder):


 class PluginLoader(SourceFileLoader):
-
    def __init__(self, manager: PluginManager, fullname: str, path) -> None:
        self.manager = manager
        self.loaded = False
--- a/nonebot/plugin/on.py
+++ b/nonebot/plugin/on.py
@ -10,8 +10,18 @@ from nonebot.matcher import Matcher
 from .manager import _current_plugin
 from nonebot.permission import Permission
 from nonebot.typing import T_State, T_Handler, T_RuleChecker, T_StateFactory
-from nonebot.rule import (PREFIX_KEY, RAW_CMD_KEY, Rule, ArgumentParser, regex,
-                          command, keyword, endswith, startswith, shell_command)
+from nonebot.rule import (
+    PREFIX_KEY,
+    RAW_CMD_KEY,
+    Rule,
+    ArgumentParser,
+    regex,
+    command,
+    keyword,
+    endswith,
+    startswith,
+    shell_command,
+)


 def _store_matcher(matcher: Type[Matcher]) -> None:
@ -30,17 +40,19 @@ def _get_matcher_module(depth: int = 1) -> Optional[ModuleType]:
    return sys.modules.get(module_name)


-def on(type: str = "",
-       rule: Optional[Union[Rule, T_RuleChecker]] = None,
-       permission: Optional[Permission] = None,
-       *,
-       handlers: Optional[List[Union[T_Handler, Handler]]] = None,
-       temp: bool = False,
-       priority: int = 1,
-       block: bool = False,
-       state: Optional[T_State] = None,
-       state_factory: Optional[T_StateFactory] = None,
-       _depth: int = 0) -> Type[Matcher]:
+def on(
+    type: str = "",
+    rule: Optional[Union[Rule, T_RuleChecker]] = None,
+    permission: Optional[Permission] = None,
+    *,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = None,
+    temp: bool = False,
+    priority: int = 1,
+    block: bool = False,
+    state: Optional[T_State] = None,
+    state_factory: Optional[T_StateFactory] = None,
+    _depth: int = 0,
+) -> Type[Matcher]:
    """
    :说明:

@ -62,30 +74,34 @@ def on(type: str = "",

      - ``Type[Matcher]``
    """
-    matcher = Matcher.new(type,
-                          Rule() & rule,
-                          permission or Permission(),
-                          temp=temp,
-                          priority=priority,
-                          block=block,
-                          handlers=handlers,
-                          plugin=_current_plugin.get(),
-                          module=_get_matcher_module(_depth + 1),
-                          default_state=state,
-                          default_state_factory=state_factory)
+    matcher = Matcher.new(
+        type,
+        Rule() & rule,
+        permission or Permission(),
+        temp=temp,
+        priority=priority,
+        block=block,
+        handlers=handlers,
+        plugin=_current_plugin.get(),
+        module=_get_matcher_module(_depth + 1),
+        default_state=state,
+        default_state_factory=state_factory,
+    )
    _store_matcher(matcher)
    return matcher


-def on_metaevent(rule: Optional[Union[Rule, T_RuleChecker]] = None,
-                 *,
-                 handlers: Optional[List[Union[T_Handler, Handler]]] = None,
-                 temp: bool = False,
-                 priority: int = 1,
-                 block: bool = False,
-                 state: Optional[T_State] = None,
-                 state_factory: Optional[T_StateFactory] = None,
-                 _depth: int = 0) -> Type[Matcher]:
+def on_metaevent(
+    rule: Optional[Union[Rule, T_RuleChecker]] = None,
+    *,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = None,
+    temp: bool = False,
+    priority: int = 1,
+    block: bool = False,
+    state: Optional[T_State] = None,
+    state_factory: Optional[T_StateFactory] = None,
+    _depth: int = 0,
+) -> Type[Matcher]:
    """
    :说明:

@ -105,31 +121,35 @@ def on_metaevent(rule: Optional[Union[Rule, T_RuleChecker]] = None,

      - ``Type[Matcher]``
    """
-    matcher = Matcher.new("meta_event",
-                          Rule() & rule,
-                          Permission(),
-                          temp=temp,
-                          priority=priority,
-                          block=block,
-                          handlers=handlers,
-                          plugin=_current_plugin.get(),
-                          module=_get_matcher_module(_depth + 1),
-                          default_state=state,
-                          default_state_factory=state_factory)
+    matcher = Matcher.new(
+        "meta_event",
+        Rule() & rule,
+        Permission(),
+        temp=temp,
+        priority=priority,
+        block=block,
+        handlers=handlers,
+        plugin=_current_plugin.get(),
+        module=_get_matcher_module(_depth + 1),
+        default_state=state,
+        default_state_factory=state_factory,
+    )
    _store_matcher(matcher)
    return matcher


-def on_message(rule: Optional[Union[Rule, T_RuleChecker]] = None,
-               permission: Optional[Permission] = None,
-               *,
-               handlers: Optional[List[Union[T_Handler, Handler]]] = None,
-               temp: bool = False,
-               priority: int = 1,
-               block: bool = True,
-               state: Optional[T_State] = None,
-               state_factory: Optional[T_StateFactory] = None,
-               _depth: int = 0) -> Type[Matcher]:
+def on_message(
+    rule: Optional[Union[Rule, T_RuleChecker]] = None,
+    permission: Optional[Permission] = None,
+    *,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = None,
+    temp: bool = False,
+    priority: int = 1,
+    block: bool = True,
+    state: Optional[T_State] = None,
+    state_factory: Optional[T_StateFactory] = None,
+    _depth: int = 0,
+) -> Type[Matcher]:
    """
    :说明:

@ -150,30 +170,34 @@ def on_message(rule: Optional[Union[Rule, T_RuleChecker]] = None,

      - ``Type[Matcher]``
    """
-    matcher = Matcher.new("message",
-                          Rule() & rule,
-                          permission or Permission(),
-                          temp=temp,
-                          priority=priority,
-                          block=block,
-                          handlers=handlers,
-                          plugin=_current_plugin.get(),
-                          module=_get_matcher_module(_depth + 1),
-                          default_state=state,
-                          default_state_factory=state_factory)
+    matcher = Matcher.new(
+        "message",
+        Rule() & rule,
+        permission or Permission(),
+        temp=temp,
+        priority=priority,
+        block=block,
+        handlers=handlers,
+        plugin=_current_plugin.get(),
+        module=_get_matcher_module(_depth + 1),
+        default_state=state,
+        default_state_factory=state_factory,
+    )
    _store_matcher(matcher)
    return matcher


-def on_notice(rule: Optional[Union[Rule, T_RuleChecker]] = None,
-              *,
-              handlers: Optional[List[Union[T_Handler, Handler]]] = None,
-              temp: bool = False,
-              priority: int = 1,
-              block: bool = False,
-              state: Optional[T_State] = None,
-              state_factory: Optional[T_StateFactory] = None,
-              _depth: int = 0) -> Type[Matcher]:
+def on_notice(
+    rule: Optional[Union[Rule, T_RuleChecker]] = None,
+    *,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = None,
+    temp: bool = False,
+    priority: int = 1,
+    block: bool = False,
+    state: Optional[T_State] = None,
+    state_factory: Optional[T_StateFactory] = None,
+    _depth: int = 0,
+) -> Type[Matcher]:
    """
    :说明:

@ -193,30 +217,34 @@ def on_notice(rule: Optional[Union[Rule, T_RuleChecker]] = None,

      - ``Type[Matcher]``
    """
-    matcher = Matcher.new("notice",
-                          Rule() & rule,
-                          Permission(),
-                          temp=temp,
-                          priority=priority,
-                          block=block,
-                          handlers=handlers,
-                          plugin=_current_plugin.get(),
-                          module=_get_matcher_module(_depth + 1),
-                          default_state=state,
-                          default_state_factory=state_factory)
+    matcher = Matcher.new(
+        "notice",
+        Rule() & rule,
+        Permission(),
+        temp=temp,
+        priority=priority,
+        block=block,
+        handlers=handlers,
+        plugin=_current_plugin.get(),
+        module=_get_matcher_module(_depth + 1),
+        default_state=state,
+        default_state_factory=state_factory,
+    )
    _store_matcher(matcher)
    return matcher


-def on_request(rule: Optional[Union[Rule, T_RuleChecker]] = None,
-               *,
-               handlers: Optional[List[Union[T_Handler, Handler]]] = None,
-               temp: bool = False,
-               priority: int = 1,
-               block: bool = False,
-               state: Optional[T_State] = None,
-               state_factory: Optional[T_StateFactory] = None,
-               _depth: int = 0) -> Type[Matcher]:
+def on_request(
+    rule: Optional[Union[Rule, T_RuleChecker]] = None,
+    *,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = None,
+    temp: bool = False,
+    priority: int = 1,
+    block: bool = False,
+    state: Optional[T_State] = None,
+    state_factory: Optional[T_StateFactory] = None,
+    _depth: int = 0,
+) -> Type[Matcher]:
    """
    :说明:

@ -236,26 +264,30 @@ def on_request(rule: Optional[Union[Rule, T_RuleChecker]] = None,

      - ``Type[Matcher]``
    """
-    matcher = Matcher.new("request",
-                          Rule() & rule,
-                          Permission(),
-                          temp=temp,
-                          priority=priority,
-                          block=block,
-                          handlers=handlers,
-                          plugin=_current_plugin.get(),
-                          module=_get_matcher_module(_depth + 1),
-                          default_state=state,
-                          default_state_factory=state_factory)
+    matcher = Matcher.new(
+        "request",
+        Rule() & rule,
+        Permission(),
+        temp=temp,
+        priority=priority,
+        block=block,
+        handlers=handlers,
+        plugin=_current_plugin.get(),
+        module=_get_matcher_module(_depth + 1),
+        default_state=state,
+        default_state_factory=state_factory,
+    )
    _store_matcher(matcher)
    return matcher


-def on_startswith(msg: Union[str, Tuple[str, ...]],
-                  rule: Optional[Optional[Union[Rule, T_RuleChecker]]] = None,
-                  ignorecase: bool = False,
-                  _depth: int = 0,
-                  **kwargs) -> Type[Matcher]:
+def on_startswith(
+    msg: Union[str, Tuple[str, ...]],
+    rule: Optional[Optional[Union[Rule, T_RuleChecker]]] = None,
+    ignorecase: bool = False,
+    _depth: int = 0,
+    **kwargs,
+) -> Type[Matcher]:
    """
    :说明:

@ -278,16 +310,16 @@ def on_startswith(msg: Union[str, Tuple[str, ...]],

      - ``Type[Matcher]``
    """
-    return on_message(startswith(msg, ignorecase) & rule,
-                      **kwargs,
-                      _depth=_depth + 1)
+    return on_message(startswith(msg, ignorecase) & rule, **kwargs, _depth=_depth + 1)


-def on_endswith(msg: Union[str, Tuple[str, ...]],
-                rule: Optional[Optional[Union[Rule, T_RuleChecker]]] = None,
-                ignorecase: bool = False,
-                _depth: int = 0,
-                **kwargs) -> Type[Matcher]:
+def on_endswith(
+    msg: Union[str, Tuple[str, ...]],
+    rule: Optional[Optional[Union[Rule, T_RuleChecker]]] = None,
+    ignorecase: bool = False,
+    _depth: int = 0,
+    **kwargs,
+) -> Type[Matcher]:
    """
    :说明:

@ -310,15 +342,15 @@ def on_endswith(msg: Union[str, Tuple[str, ...]],

      - ``Type[Matcher]``
    """
-    return on_message(endswith(msg, ignorecase) & rule,
-                      **kwargs,
-                      _depth=_depth + 1)
+    return on_message(endswith(msg, ignorecase) & rule, **kwargs, _depth=_depth + 1)


-def on_keyword(keywords: Set[str],
-               rule: Optional[Union[Rule, T_RuleChecker]] = None,
-               _depth: int = 0,
-               **kwargs) -> Type[Matcher]:
+def on_keyword(
+    keywords: Set[str],
+    rule: Optional[Union[Rule, T_RuleChecker]] = None,
+    _depth: int = 0,
+    **kwargs,
+) -> Type[Matcher]:
    """
    :说明:

@ -343,11 +375,13 @@ def on_keyword(keywords: Set[str],
    return on_message(keyword(*keywords) & rule, **kwargs, _depth=_depth + 1)


-def on_command(cmd: Union[str, Tuple[str, ...]],
-               rule: Optional[Union[Rule, T_RuleChecker]] = None,
-               aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = None,
-               _depth: int = 0,
-               **kwargs) -> Type[Matcher]:
+def on_command(
+    cmd: Union[str, Tuple[str, ...]],
+    rule: Optional[Union[Rule, T_RuleChecker]] = None,
+    aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = None,
+    _depth: int = 0,
+    **kwargs,
+) -> Type[Matcher]:
    """
    :说明:

@ -382,7 +416,8 @@ def on_command(cmd: Union[str, Tuple[str, ...]],
        if not segment_text.startswith(state[PREFIX_KEY][RAW_CMD_KEY]):
            return
        new_message = message.__class__(
-            segment_text[len(state[PREFIX_KEY][RAW_CMD_KEY]):].lstrip())
+            segment_text[len(state[PREFIX_KEY][RAW_CMD_KEY]) :].lstrip()
+        )
        for new_segment in reversed(new_message):
            message.insert(0, new_segment)

@ -390,18 +425,19 @@ def on_command(cmd: Union[str, Tuple[str, ...]],
    handlers.insert(0, _strip_cmd)

    commands = set([cmd]) | (aliases or set())
-    return on_message(command(*commands) & rule,
-                      handlers=handlers,
-                      **kwargs,
-                      _depth=_depth + 1)
+    return on_message(
+        command(*commands) & rule, handlers=handlers, **kwargs, _depth=_depth + 1
+    )


-def on_shell_command(cmd: Union[str, Tuple[str, ...]],
-                     rule: Optional[Union[Rule, T_RuleChecker]] = None,
-                     aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = None,
-                     parser: Optional[ArgumentParser] = None,
-                     _depth: int = 0,
-                     **kwargs) -> Type[Matcher]:
+def on_shell_command(
+    cmd: Union[str, Tuple[str, ...]],
+    rule: Optional[Union[Rule, T_RuleChecker]] = None,
+    aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = None,
+    parser: Optional[ArgumentParser] = None,
+    _depth: int = 0,
+    **kwargs,
+) -> Type[Matcher]:
    """
    :说明:

@ -434,7 +470,8 @@ def on_shell_command(cmd: Union[str, Tuple[str, ...]],
        message = event.get_message()
        segment = message.pop(0)
        new_message = message.__class__(
-            str(segment)[len(state[PREFIX_KEY][RAW_CMD_KEY]):].strip())
+            str(segment)[len(state[PREFIX_KEY][RAW_CMD_KEY]) :].strip()
+        )
        for new_segment in reversed(new_message):
            message.insert(0, new_segment)

@ -442,17 +479,21 @@ def on_shell_command(cmd: Union[str, Tuple[str, ...]],
    handlers.insert(0, _strip_cmd)

    commands = set([cmd]) | (aliases or set())
-    return on_message(shell_command(*commands, parser=parser) & rule,
-                      handlers=handlers,
-                      **kwargs,
-                      _depth=_depth + 1)
+    return on_message(
+        shell_command(*commands, parser=parser) & rule,
+        handlers=handlers,
+        **kwargs,
+        _depth=_depth + 1,
+    )


-def on_regex(pattern: str,
-             flags: Union[int, re.RegexFlag] = 0,
-             rule: Optional[Union[Rule, T_RuleChecker]] = None,
-             _depth: int = 0,
-             **kwargs) -> Type[Matcher]:
+def on_regex(
+    pattern: str,
+    flags: Union[int, re.RegexFlag] = 0,
+    rule: Optional[Union[Rule, T_RuleChecker]] = None,
+    _depth: int = 0,
+    **kwargs,
+) -> Type[Matcher]:
    """
    :说明:

@ -503,8 +544,7 @@ class CommandGroup:
        - **说明**: 其他传递给 ``on_command`` 的参数默认值
        """

-    def command(self, cmd: Union[str, Tuple[str, ...]],
-                **kwargs) -> Type[Matcher]:
+    def command(self, cmd: Union[str, Tuple[str, ...]], **kwargs) -> Type[Matcher]:
        """
        :说明:

@ -526,8 +566,9 @@ class CommandGroup:
        final_kwargs.update(kwargs)
        return on_command(cmd, **final_kwargs, _depth=1)

-    def shell_command(self, cmd: Union[str, Tuple[str, ...]],
-                      **kwargs) -> Type[Matcher]:
+    def shell_command(
+        self, cmd: Union[str, Tuple[str, ...]], **kwargs
+    ) -> Type[Matcher]:
        """
        :说明:

@ -708,8 +749,9 @@ class MatcherGroup:
        self.matchers.append(matcher)
        return matcher

-    def on_startswith(self, msg: Union[str, Tuple[str, ...]],
-                      **kwargs) -> Type[Matcher]:
+    def on_startswith(
+        self, msg: Union[str, Tuple[str, ...]], **kwargs
+    ) -> Type[Matcher]:
        """
        :说明:

@ -739,8 +781,7 @@ class MatcherGroup:
        self.matchers.append(matcher)
        return matcher

-    def on_endswith(self, msg: Union[str, Tuple[str, ...]],
-                    **kwargs) -> Type[Matcher]:
+    def on_endswith(self, msg: Union[str, Tuple[str, ...]], **kwargs) -> Type[Matcher]:
        """
        :说明:

@ -799,10 +840,12 @@ class MatcherGroup:
        self.matchers.append(matcher)
        return matcher

-    def on_command(self,
-                   cmd: Union[str, Tuple[str, ...]],
-                   aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = None,
-                   **kwargs) -> Type[Matcher]:
+    def on_command(
+        self,
+        cmd: Union[str, Tuple[str, ...]],
+        aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = None,
+        **kwargs,
+    ) -> Type[Matcher]:
        """
        :说明:

@ -834,12 +877,13 @@ class MatcherGroup:
        self.matchers.append(matcher)
        return matcher

-    def on_shell_command(self,
-                         cmd: Union[str, Tuple[str, ...]],
-                         aliases: Optional[Set[Union[str, Tuple[str,
-                                                                ...]]]] = None,
-                         parser: Optional[ArgumentParser] = None,
-                         **kwargs) -> Type[Matcher]:
+    def on_shell_command(
+        self,
+        cmd: Union[str, Tuple[str, ...]],
+        aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = None,
+        parser: Optional[ArgumentParser] = None,
+        **kwargs,
+    ) -> Type[Matcher]:
        """
        :说明:

@ -870,18 +914,15 @@ class MatcherGroup:
        final_kwargs = self.base_kwargs.copy()
        final_kwargs.update(kwargs)
        final_kwargs.pop("type", None)
-        matcher = on_shell_command(cmd,
-                                   aliases=aliases,
-                                   parser=parser,
-                                   **final_kwargs,
-                                   _depth=1)
+        matcher = on_shell_command(
+            cmd, aliases=aliases, parser=parser, **final_kwargs, _depth=1
+        )
        self.matchers.append(matcher)
        return matcher

-    def on_regex(self,
-                 pattern: str,
-                 flags: Union[int, re.RegexFlag] = 0,
-                 **kwargs) -> Type[Matcher]:
+    def on_regex(
+        self, pattern: str, flags: Union[int, re.RegexFlag] = 0, **kwargs
+    ) -> Type[Matcher]:
        """
        :说明:

--- a/nonebot/plugin/on.pyi
+++ b/nonebot/plugin/on.pyi
@ -7,361 +7,335 @@ from nonebot.permission import Permission
 from nonebot.rule import Rule, ArgumentParser
 from nonebot.typing import T_State, T_Handler, T_RuleChecker, T_StateFactory

-
-def on(type: str = "",
-       rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-       permission: Optional[Permission] = ...,
-       *,
-       handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-       temp: bool = ...,
-       priority: int = ...,
-       block: bool = ...,
-       state: Optional[T_State] = ...,
-       state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-    ...
-
-
+def on(
+    type: str = "",
+    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    permission: Optional[Permission] = ...,
+    *,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+    temp: bool = ...,
+    priority: int = ...,
+    block: bool = ...,
+    state: Optional[T_State] = ...,
+    state_factory: Optional[T_StateFactory] = ...,
+) -> Type[Matcher]: ...
 def on_metaevent(
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        *,
-        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-        temp: bool = ...,
-        priority: int = ...,
-        block: bool = ...,
-        state: Optional[T_State] = ...,
-        state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-    ...
-
-
-def on_message(rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-               permission: Optional[Permission] = ...,
-               *,
-               handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-               temp: bool = ...,
-               priority: int = ...,
-               block: bool = ...,
-               state: Optional[T_State] = ...,
-               state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-    ...
-
-
-def on_notice(rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-              *,
-              handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-              temp: bool = ...,
-              priority: int = ...,
-              block: bool = ...,
-              state: Optional[T_State] = ...,
-              state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-    ...
-
-
-def on_request(rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-               *,
-               handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-               temp: bool = ...,
-               priority: int = ...,
-               block: bool = ...,
-               state: Optional[T_State] = ...,
-               state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-    ...
-
-
+    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    *,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+    temp: bool = ...,
+    priority: int = ...,
+    block: bool = ...,
+    state: Optional[T_State] = ...,
+    state_factory: Optional[T_StateFactory] = ...,
+) -> Type[Matcher]: ...
+def on_message(
+    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    permission: Optional[Permission] = ...,
+    *,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+    temp: bool = ...,
+    priority: int = ...,
+    block: bool = ...,
+    state: Optional[T_State] = ...,
+    state_factory: Optional[T_StateFactory] = ...,
+) -> Type[Matcher]: ...
+def on_notice(
+    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    *,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+    temp: bool = ...,
+    priority: int = ...,
+    block: bool = ...,
+    state: Optional[T_State] = ...,
+    state_factory: Optional[T_StateFactory] = ...,
+) -> Type[Matcher]: ...
+def on_request(
+    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    *,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+    temp: bool = ...,
+    priority: int = ...,
+    block: bool = ...,
+    state: Optional[T_State] = ...,
+    state_factory: Optional[T_StateFactory] = ...,
+) -> Type[Matcher]: ...
 def on_startswith(
-        msg: Union[str, Tuple[str, ...]],
-        rule: Optional[Optional[Union[Rule, T_RuleChecker]]] = ...,
-        ignorecase: bool = ...,
+    msg: Union[str, Tuple[str, ...]],
+    rule: Optional[Optional[Union[Rule, T_RuleChecker]]] = ...,
+    ignorecase: bool = ...,
+    *,
+    permission: Optional[Permission] = ...,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+    temp: bool = ...,
+    priority: int = ...,
+    block: bool = ...,
+    state: Optional[T_State] = ...,
+    state_factory: Optional[T_StateFactory] = ...,
+) -> Type[Matcher]: ...
+def on_endswith(
+    msg: Union[str, Tuple[str, ...]],
+    rule: Optional[Optional[Union[Rule, T_RuleChecker]]] = ...,
+    ignorecase: bool = ...,
+    *,
+    permission: Optional[Permission] = ...,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+    temp: bool = ...,
+    priority: int = ...,
+    block: bool = ...,
+    state: Optional[T_State] = ...,
+    state_factory: Optional[T_StateFactory] = ...,
+) -> Type[Matcher]: ...
+def on_keyword(
+    keywords: Set[str],
+    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    *,
+    permission: Optional[Permission] = ...,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+    temp: bool = ...,
+    priority: int = ...,
+    block: bool = ...,
+    state: Optional[T_State] = ...,
+    state_factory: Optional[T_StateFactory] = ...,
+) -> Type[Matcher]: ...
+def on_command(
+    cmd: Union[str, Tuple[str, ...]],
+    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
+    *,
+    permission: Optional[Permission] = ...,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+    temp: bool = ...,
+    priority: int = ...,
+    block: bool = ...,
+    state: Optional[T_State] = ...,
+    state_factory: Optional[T_StateFactory] = ...,
+) -> Type[Matcher]: ...
+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] = ...,
+    *,
+    permission: Optional[Permission] = ...,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+    temp: bool = ...,
+    priority: int = ...,
+    block: bool = ...,
+    state: Optional[T_State] = ...,
+    state_factory: Optional[T_StateFactory] = ...,
+) -> Type[Matcher]: ...
+def on_regex(
+    pattern: str,
+    flags: Union[int, re.RegexFlag] = ...,
+    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    *,
+    permission: Optional[Permission] = ...,
+    handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+    temp: bool = ...,
+    priority: int = ...,
+    block: bool = ...,
+    state: Optional[T_State] = ...,
+    state_factory: Optional[T_StateFactory] = ...,
+) -> Type[Matcher]: ...
+
+class CommandGroup:
+    def __init__(
+        self,
+        cmd: Union[str, Tuple[str, ...]],
        *,
+        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
        permission: Optional[Permission] = ...,
        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
        temp: bool = ...,
        priority: int = ...,
        block: bool = ...,
        state: Optional[T_State] = ...,
-        state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-    ...
-
-
-def on_endswith(msg: Union[str, Tuple[str, ...]],
-                rule: Optional[Optional[Union[Rule, T_RuleChecker]]] = ...,
-                ignorecase: bool = ...,
-                *,
-                permission: Optional[Permission] = ...,
-                handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-                temp: bool = ...,
-                priority: int = ...,
-                block: bool = ...,
-                state: Optional[T_State] = ...,
-                state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-    ...
-
-
-def on_keyword(keywords: Set[str],
-               rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-               *,
-               permission: Optional[Permission] = ...,
-               handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-               temp: bool = ...,
-               priority: int = ...,
-               block: bool = ...,
-               state: Optional[T_State] = ...,
-               state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-    ...
-
-
-def on_command(cmd: Union[str, Tuple[str, ...]],
-               rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-               aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
-               *,
-               permission: Optional[Permission] = ...,
-               handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-               temp: bool = ...,
-               priority: int = ...,
-               block: bool = ...,
-               state: Optional[T_State] = ...,
-               state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-    ...
-
-
-def on_shell_command(
+        state_factory: Optional[T_StateFactory] = ...,
+    ): ...
+    def command(
+        self,
        cmd: Union[str, Tuple[str, ...]],
+        *,
+        aliases: Optional[Set[Union[str, Tuple[str, ...]]]],
        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        permission: Optional[Permission] = ...,
+        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+        temp: bool = ...,
+        priority: int = ...,
+        block: bool = ...,
+        state: Optional[T_State] = ...,
+        state_factory: Optional[T_StateFactory] = ...,
+    ) -> Type[Matcher]: ...
+    def shell_command(
+        self,
+        cmd: Union[str, Tuple[str, ...]],
+        *,
+        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        aliases: Optional[Set[Union[str, Tuple[str, ...]]]],
+        parser: Optional[ArgumentParser] = ...,
+        permission: Optional[Permission] = ...,
+        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+        temp: bool = ...,
+        priority: int = ...,
+        block: bool = ...,
+        state: Optional[T_State] = ...,
+        state_factory: Optional[T_StateFactory] = ...,
+    ) -> Type[Matcher]: ...
+
+class MatcherGroup:
+    def __init__(
+        self,
+        *,
+        type: str = ...,
+        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        permission: Optional[Permission] = ...,
+        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+        temp: bool = ...,
+        priority: int = ...,
+        block: bool = ...,
+        state: Optional[T_State] = ...,
+        state_factory: Optional[T_StateFactory] = ...,
+    ): ...
+    def on(
+        self,
+        *,
+        type: str = ...,
+        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        permission: Optional[Permission] = ...,
+        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+        temp: bool = ...,
+        priority: int = ...,
+        block: bool = ...,
+        state: Optional[T_State] = ...,
+        state_factory: Optional[T_StateFactory] = ...,
+    ) -> Type[Matcher]: ...
+    def on_metaevent(
+        self,
+        *,
+        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+        temp: bool = ...,
+        priority: int = ...,
+        block: bool = ...,
+        state: Optional[T_State] = ...,
+        state_factory: Optional[T_StateFactory] = ...,
+    ) -> Type[Matcher]: ...
+    def on_message(
+        self,
+        *,
+        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        permission: Optional[Permission] = ...,
+        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+        temp: bool = ...,
+        priority: int = ...,
+        block: bool = ...,
+        state: Optional[T_State] = ...,
+        state_factory: Optional[T_StateFactory] = ...,
+    ) -> Type[Matcher]: ...
+    def on_notice(
+        self,
+        *,
+        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+        temp: bool = ...,
+        priority: int = ...,
+        block: bool = ...,
+        state: Optional[T_State] = ...,
+        state_factory: Optional[T_StateFactory] = ...,
+    ) -> Type[Matcher]: ...
+    def on_request(
+        self,
+        *,
+        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+        temp: bool = ...,
+        priority: int = ...,
+        block: bool = ...,
+        state: Optional[T_State] = ...,
+        state_factory: Optional[T_StateFactory] = ...,
+    ) -> Type[Matcher]: ...
+    def on_startswith(
+        self,
+        msg: Union[str, Tuple[str, ...]],
+        *,
+        ignorecase: bool = ...,
+        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        permission: Optional[Permission] = ...,
+        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+        temp: bool = ...,
+        priority: int = ...,
+        block: bool = ...,
+        state: Optional[T_State] = ...,
+        state_factory: Optional[T_StateFactory] = ...,
+    ) -> Type[Matcher]: ...
+    def on_endswith(
+        self,
+        msg: Union[str, Tuple[str, ...]],
+        *,
+        ignorecase: bool = ...,
+        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        permission: Optional[Permission] = ...,
+        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+        temp: bool = ...,
+        priority: int = ...,
+        block: bool = ...,
+        state: Optional[T_State] = ...,
+        state_factory: Optional[T_StateFactory] = ...,
+    ) -> Type[Matcher]: ...
+    def on_keyword(
+        self,
+        keywords: Set[str],
+        *,
+        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        permission: Optional[Permission] = ...,
+        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+        temp: bool = ...,
+        priority: int = ...,
+        block: bool = ...,
+        state: Optional[T_State] = ...,
+        state_factory: Optional[T_StateFactory] = ...,
+    ) -> Type[Matcher]: ...
+    def on_command(
+        self,
+        cmd: Union[str, Tuple[str, ...]],
+        aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
+        *,
+        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        permission: Optional[Permission] = ...,
+        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+        temp: bool = ...,
+        priority: int = ...,
+        block: bool = ...,
+        state: Optional[T_State] = ...,
+        state_factory: Optional[T_StateFactory] = ...,
+    ) -> Type[Matcher]: ...
+    def on_shell_command(
+        self,
+        cmd: Union[str, Tuple[str, ...]],
        aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
        parser: Optional[ArgumentParser] = ...,
        *,
+        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
        permission: Optional[Permission] = ...,
        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
        temp: bool = ...,
        priority: int = ...,
        block: bool = ...,
        state: Optional[T_State] = ...,
-        state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-    ...
-
-
-def on_regex(pattern: str,
-             flags: Union[int, re.RegexFlag] = ...,
-             rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-             *,
-             permission: Optional[Permission] = ...,
-             handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-             temp: bool = ...,
-             priority: int = ...,
-             block: bool = ...,
-             state: Optional[T_State] = ...,
-             state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-    ...
-
-
-class CommandGroup:
-
-    def __init__(self,
-                 cmd: Union[str, Tuple[str, ...]],
-                 *,
-                 rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-                 permission: Optional[Permission] = ...,
-                 handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-                 temp: bool = ...,
-                 priority: int = ...,
-                 block: bool = ...,
-                 state: Optional[T_State] = ...,
-                 state_factory: Optional[T_StateFactory] = ...):
-        ...
-
-    def command(self,
-                cmd: Union[str, Tuple[str, ...]],
-                *,
-                aliases: Optional[Set[Union[str, Tuple[str, ...]]]],
-                rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-                permission: Optional[Permission] = ...,
-                handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-                temp: bool = ...,
-                priority: int = ...,
-                block: bool = ...,
-                state: Optional[T_State] = ...,
-                state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-        ...
-
-    def shell_command(
-            self,
-            cmd: Union[str, Tuple[str, ...]],
-            *,
-            rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-            aliases: Optional[Set[Union[str, Tuple[str, ...]]]],
-            parser: Optional[ArgumentParser] = ...,
-            permission: Optional[Permission] = ...,
-            handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-            temp: bool = ...,
-            priority: int = ...,
-            block: bool = ...,
-            state: Optional[T_State] = ...,
-            state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-        ...
-
-
-class MatcherGroup:
-
-    def __init__(self,
-                 *,
-                 type: str = ...,
-                 rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-                 permission: Optional[Permission] = ...,
-                 handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-                 temp: bool = ...,
-                 priority: int = ...,
-                 block: bool = ...,
-                 state: Optional[T_State] = ...,
-                 state_factory: Optional[T_StateFactory] = ...):
-        ...
-
-    def on(self,
-           *,
-           type: str = ...,
-           rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-           permission: Optional[Permission] = ...,
-           handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-           temp: bool = ...,
-           priority: int = ...,
-           block: bool = ...,
-           state: Optional[T_State] = ...,
-           state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-        ...
-
-    def on_metaevent(
-            self,
-            *,
-            rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-            handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-            temp: bool = ...,
-            priority: int = ...,
-            block: bool = ...,
-            state: Optional[T_State] = ...,
-            state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-        ...
-
-    def on_message(
-            self,
-            *,
-            rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-            permission: Optional[Permission] = ...,
-            handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-            temp: bool = ...,
-            priority: int = ...,
-            block: bool = ...,
-            state: Optional[T_State] = ...,
-            state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-        ...
-
-    def on_notice(
-            self,
-            *,
-            rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-            handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-            temp: bool = ...,
-            priority: int = ...,
-            block: bool = ...,
-            state: Optional[T_State] = ...,
-            state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-        ...
-
-    def on_request(
-            self,
-            *,
-            rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-            handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-            temp: bool = ...,
-            priority: int = ...,
-            block: bool = ...,
-            state: Optional[T_State] = ...,
-            state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-        ...
-
-    def on_startswith(
-            self,
-            msg: Union[str, Tuple[str, ...]],
-            *,
-            ignorecase: bool = ...,
-            rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-            permission: Optional[Permission] = ...,
-            handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-            temp: bool = ...,
-            priority: int = ...,
-            block: bool = ...,
-            state: Optional[T_State] = ...,
-            state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-        ...
-
-    def on_endswith(
-            self,
-            msg: Union[str, Tuple[str, ...]],
-            *,
-            ignorecase: bool = ...,
-            rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-            permission: Optional[Permission] = ...,
-            handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-            temp: bool = ...,
-            priority: int = ...,
-            block: bool = ...,
-            state: Optional[T_State] = ...,
-            state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-        ...
-
-    def on_keyword(
-            self,
-            keywords: Set[str],
-            *,
-            rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-            permission: Optional[Permission] = ...,
-            handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-            temp: bool = ...,
-            priority: int = ...,
-            block: bool = ...,
-            state: Optional[T_State] = ...,
-            state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-        ...
-
-    def on_command(
-            self,
-            cmd: Union[str, Tuple[str, ...]],
-            aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
-            *,
-            rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-            permission: Optional[Permission] = ...,
-            handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-            temp: bool = ...,
-            priority: int = ...,
-            block: bool = ...,
-            state: Optional[T_State] = ...,
-            state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-        ...
-
-    def on_shell_command(
-            self,
-            cmd: Union[str, Tuple[str, ...]],
-            aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
-            parser: Optional[ArgumentParser] = ...,
-            *,
-            rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-            permission: Optional[Permission] = ...,
-            handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-            temp: bool = ...,
-            priority: int = ...,
-            block: bool = ...,
-            state: Optional[T_State] = ...,
-            state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-        ...
-
+        state_factory: Optional[T_StateFactory] = ...,
+    ) -> Type[Matcher]: ...
    def on_regex(
-            self,
-            pattern: str,
-            flags: Union[int, re.RegexFlag] = ...,
-            *,
-            rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-            permission: Optional[Permission] = ...,
-            handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
-            temp: bool = ...,
-            priority: int = ...,
-            block: bool = ...,
-            state: Optional[T_State] = ...,
-            state_factory: Optional[T_StateFactory] = ...) -> Type[Matcher]:
-        ...
+        self,
+        pattern: str,
+        flags: Union[int, re.RegexFlag] = ...,
+        *,
+        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        permission: Optional[Permission] = ...,
+        handlers: Optional[List[Union[T_Handler, Handler]]] = ...,
+        temp: bool = ...,
+        priority: int = ...,
+        block: bool = ...,
+        state: Optional[T_State] = ...,
+        state_factory: Optional[T_StateFactory] = ...,
+    ) -> Type[Matcher]: ...
--- a/nonebot/plugin/plugin.py
+++ b/nonebot/plugin/plugin.py
@ -15,6 +15,7 @@ plugins: Dict[str, "Plugin"] = {}
@dataclass(eq=False)
 class Plugin(object):
    """存储插件信息"""
+
    name: str
    """
    - **类型**: ``str``