🔖 Release 2.0.0rc3

Co-authored-by: Su <wxlxy316@163.com>

.devcontainer/Dockerfile

@@ -1,20 +0,0 @@
-# See here for image contents: https://github.com/microsoft/vscode-dev-containers/tree/v0.233.0/containers/codespaces-linux/.devcontainer/base.Dockerfile
-
-FROM mcr.microsoft.com/vscode/devcontainers/universal:linux
-
-# ** [Optional] Uncomment this section to install additional packages. **
-# USER root
-#
-# RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
-#     && apt-get -y install --no-install-recommends <your-package-list-here>
-
-USER codespace
-
-# [Required] Poetry
-RUN curl -sSL https://install.python-poetry.org | python - -y
-RUN poetry config virtualenvs.in-project true
-
-# [Required] Gitmoji CLI
-# Deprecated: Maybe removed once nonemoji is done
-RUN yarn global add gitmoji-cli
-ENV PATH="$PATH:/home/codespace/.yarn/bin"

.devcontainer/devcontainer.json

@@ -1,83 +1,53 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the README at:
-// https://github.com/microsoft/vscode-dev-containers/tree/v0.233.0/containers/codespaces-linux
 {
-  "name": "NoneBot",
-  "build": {
-    "dockerfile": "Dockerfile",
-    "context": ".."
+  "name": "Default Linux Universal",
+  "image": "mcr.microsoft.com/devcontainers/universal:2-linux",
+  "features": {
+    "ghcr.io/devcontainers-contrib/features/poetry:1": {}
   },
-  "settings": {
-    "go.toolsManagement.checkForUpdates": "local",
-    "go.useLanguageServer": true,
-    "go.gopath": "/go",
-    "python.defaultInterpreterPath": "/opt/python/latest/bin/python",
-    "python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8",
-    "python.formatting.blackPath": "/usr/local/py-utils/bin/black",
-    "python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf",
-    "python.linting.banditPath": "/usr/local/py-utils/bin/bandit",
-    "python.linting.flake8Path": "/usr/local/py-utils/bin/flake8",
-    "python.linting.mypyPath": "/usr/local/py-utils/bin/mypy",
-    "python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle",
-    "python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle",
-    "python.linting.pylintPath": "/usr/local/py-utils/bin/pylint",
-    "python.analysis.diagnosticMode": "workspace",
-    "python.analysis.typeCheckingMode": "basic",
-    "[python]":{
-      "editor.defaultFormatter": "ms-python.black-formatter",
-      "editor.codeActionsOnSave": {
-        "source.organizeImports": true
-      }
-    },
-    "[javascript]": {
-      "editor.defaultFormatter": "esbenp.prettier-vscode"
-    },
-    "[html]": {
-      "editor.defaultFormatter": "esbenp.prettier-vscode"
-    },
-    "[typescript]": {
-      "editor.defaultFormatter": "esbenp.prettier-vscode"
-    },
-    "[javascriptreact]": {
-      "editor.defaultFormatter": "esbenp.prettier-vscode"
-    },
-    "[typescriptreact]": {
-      "editor.defaultFormatter": "esbenp.prettier-vscode"
-    },
-    "lldb.executable": "/usr/bin/lldb",
-    "files.exclude": {
-      "**/__pycache__": true
-    },
-    "files.watcherExclude": {
-      "**/target/**": true,
-      "**/__pycache__": true
+  "postCreateCommand": "poetry config virtualenvs.in-project true && poetry install -E all && poetry run pre-commit install && yarn install",
+  "customizations": {
+    "vscode": {
+      "settings": {
+        "python.analysis.diagnosticMode": "workspace",
+        "python.analysis.typeCheckingMode": "basic",
+        "[python]": {
+          "editor.defaultFormatter": "ms-python.black-formatter",
+          "editor.codeActionsOnSave": {
+            "source.organizeImports": true
+          }
+        },
+        "[javascript]": {
+          "editor.defaultFormatter": "esbenp.prettier-vscode"
+        },
+        "[html]": {
+          "editor.defaultFormatter": "esbenp.prettier-vscode"
+        },
+        "[typescript]": {
+          "editor.defaultFormatter": "esbenp.prettier-vscode"
+        },
+        "[javascriptreact]": {
+          "editor.defaultFormatter": "esbenp.prettier-vscode"
+        },
+        "[typescriptreact]": {
+          "editor.defaultFormatter": "esbenp.prettier-vscode"
+        },
+        "files.exclude": {
+          "**/__pycache__": true
+        },
+        "files.watcherExclude": {
+          "**/target/**": true,
+          "**/__pycache__": true
+        }
+      },
+      "extensions": [
+        "ms-python.python",
+        "ms-python.vscode-pylance",
+        "ms-python.isort",
+        "ms-python.black-formatter",
+        "EditorConfig.EditorConfig",
+        "esbenp.prettier-vscode",
+        "bradlc.vscode-tailwindcss"
+      ]
     }
-  },
-  "remoteUser": "codespace",
-  "overrideCommand": false,
-  "mounts": ["source=codespaces-linux-var-lib-docker,target=/var/lib/docker,type=volume"],
-  "runArgs": [
-    "--cap-add=SYS_PTRACE",
-    "--security-opt",
-    "seccomp=unconfined",
-    "--privileged",
-    "--init"
-  ],
-
-  // Add the IDs of extensions you want installed when the container is created.
-  "extensions": [
-    "GitHub.vscode-pull-request-github",
-    "ms-python.python",
-    "ms-python.vscode-pylance",
-    "ms-python.isort",
-    "ms-python.black-formatter",
-    "EditorConfig.EditorConfig",
-    "esbenp.prettier-vscode",
-    "bradlc.vscode-tailwindcss"
-  ],
-
-  // Use 'forwardPorts' to make a list of ports inside the container available locally.
-  // "forwardPorts": [],
-
-  // "oryx build" will automatically install your dependencies and attempt to build your project
-  "postCreateCommand": "poetry install -E all && poetry run pre-commit install && yarn install"
+  }
 }

.github/actions/setup-node/action.yml

@@ -9,10 +9,10 @@ runs:
         node-version: "16"
 
     - id: yarn-cache-dir-path
-      run: echo "::set-output name=dir::$(yarn cache dir)"
+      run: echo "dir=$(yarn cache dir)" >> $GITHUB_OUTPUT
       shell: bash
 
-    - uses: actions/cache@v2
+    - uses: actions/cache@v3
       with:
         path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
         key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}

.github/actions/setup-python/action.yml

@@ -5,22 +5,20 @@ inputs:
   python-version:
     description: Python version
     required: false
-    default: "3.9"
+    default: "3.10"
 
 runs:
   using: "composite"
   steps:
-    - uses: actions/setup-python@v2
+    - name: Install poetry
+      run: pipx install poetry
+      shell: bash
+
+    - uses: actions/setup-python@v4
       with:
         python-version: ${{ inputs.python-version }}
         architecture: "x64"
-
-    - uses: Gr1N/setup-poetry@v7
-
-    - uses: actions/cache@v2
-      with:
-        path: ~/.cache/pypoetry/virtualenvs
-        key: ${{ runner.os }}-poetry-${{ inputs.python-version }}-${{ hashFiles('**/poetry.lock') }}
+        cache: "poetry"
 
     - run: poetry install -E all
       shell: bash

.github/workflows/codecov.yml

@@ -5,6 +5,10 @@ on:
     branches:
       - master
   pull_request:
+    paths:
+      - "nonebot/**"
+      - "packages/**"
+      - "tests/**"
 
 jobs:
   test:
@@ -15,7 +19,7 @@ jobs:
       cancel-in-progress: true
     strategy:
       matrix:
-        python-version: ["3.7", "3.8", "3.9", "3.10"]
+        python-version: ["3.8", "3.9", "3.10", "3.11"]
         os: [ubuntu-latest, windows-latest, macos-latest]
       fail-fast: false
     env:

.github/workflows/publish-bot.yml

@@ -5,17 +5,45 @@ on:
     types: [opened, reopened, edited]
   pull_request_target:
     types: [closed]
+  issue_comment:
+    types: [created]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.issue.number || github.run_id }}
+  cancel-in-progress: true
 
 jobs:
+  plugin_test:
+    runs-on: ubuntu-latest
+    name: nonebot2 plugin test
+    if: github.event_name != 'issue_comment' || !github.event.issue.pull_request
+    permissions:
+      issues: read
+    outputs:
+      result: ${{ steps.plugin-test.outputs.RESULT }}
+      output: ${{ steps.plugin-test.outputs.OUTPUT }}
+    steps:
+      - name: Install Poetry
+        if: ${{ !startsWith(github.event_name, 'pull_request') }}
+        run: pipx install poetry
+      - name: Setup Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+      - name: Test Plugin
+        id: plugin-test
+        run: |
+          curl -sSL https://raw.githubusercontent.com/nonebot/nonebot2-publish-bot/main/plugin_test.py -o plugin_test.py
+          python plugin_test.py
   publish_bot:
     runs-on: ubuntu-latest
     name: nonebot2 publish bot
+    needs: plugin_test
     steps:
-      - name: Checkout code
+      - name: Checkout Code
         uses: actions/checkout@v3
         with:
           token: ${{ secrets.GH_TOKEN }}
-
       - name: NoneBot2 Publish Bot
         uses: docker://ghcr.io/nonebot/nonebot2-publish-bot:main
         with:
@@ -27,3 +55,6 @@ jobs:
               "bot_path": "website/static/bots.json",
               "adapter_path": "website/static/adapters.json"
             }
+        env:
+          PLUGIN_TEST_RESULT: ${{ needs.plugin_test.outputs.result }}
+          PLUGIN_TEST_OUTPUT: ${{ needs.plugin_test.outputs.output }}

.github/workflows/release-drafter.yml

@@ -35,7 +35,7 @@ jobs:
         with:
           changelog_file: website/src/pages/changelog.md
           latest_changes_position: '# 更新日志\n\n'
-          latest_changes_title: '## 最近更新'
+          latest_changes_title: "## 最近更新"
           replace_regex: '(?<=## 最近更新\n)[\s\S]*?(?=\n## )'
           changelog_body: ${{ steps.release-drafter.outputs.body }}
           commit_and_push: false
@@ -49,7 +49,6 @@ jobs:
           git diff-index --quiet HEAD || git commit -m ":memo: Update changelog"
           git push
 
-
   release:
     if: startsWith(github.ref, 'refs/tags/')
     runs-on: ubuntu-latest

.github/workflows/website-deploy.yml

@@ -31,7 +31,7 @@ jobs:
         run: echo "BRANCH_NAME=$(echo ${GITHUB_REF#refs/heads/})" >> $GITHUB_ENV
 
       - name: Deploy to Netlify
-        uses: nwtgck/actions-netlify@v1
+        uses: nwtgck/actions-netlify@v2
         with:
           publish-dir: "./website/build"
           production-deploy: true

.github/workflows/website-preview.yml

@@ -32,7 +32,7 @@ jobs:
           echo "DEPLOY_NAME=deploy-preview-${{ github.event.number }}" >> $GITHUB_ENV
 
       - name: Deploy to Netlify
-        uses: nwtgck/actions-netlify@v1
+        uses: nwtgck/actions-netlify@v2
         with:
           publish-dir: "./website/build"
           production-deploy: false

.markdownlint.yaml

@@ -0,0 +1,4 @@
+MD013: false
+MD024: # 重复标题
+  siblings_only: true
+MD033: false # 允许 html

.pre-commit-config.yaml

@@ -1,3 +1,4 @@
+default_install_hook_types: [pre-commit, prepare-commit-msg]
 ci:
   autofix_commit_msg: ":rotating_light: auto fix by pre-commit hooks"
   autofix_prs: true
@@ -5,18 +6,33 @@ ci:
   autoupdate_schedule: monthly
   autoupdate_commit_msg: ":arrow_up: auto update by pre-commit hooks"
 repos:
+  - repo: https://github.com/hadialqattan/pycln
+    rev: v2.1.2
+    hooks:
+      - id: pycln
+        args: [--config, pyproject.toml]
+
   - repo: https://github.com/pycqa/isort
-    rev: 5.10.1
+    rev: 5.11.4
     hooks:
       - id: isort
+        stages: [commit]
 
   - repo: https://github.com/psf/black
-    rev: 22.3.0
+    rev: 22.12.0
     hooks:
       - id: black
+        stages: [commit]
 
   - repo: https://github.com/pre-commit/mirrors-prettier
-    rev: v2.6.2
+    rev: v3.0.0-alpha.4
     hooks:
       - id: prettier
-        types_or: [javascript, jsx, ts, tsx, markdown]
+        types_or: [javascript, jsx, ts, tsx, markdown, yaml, json]
+        stages: [commit]
+
+  - repo: https://github.com/nonebot/nonemoji
+    rev: v0.1.3
+    hooks:
+      - id: nonemoji
+        stages: [prepare-commit-msg]

CONTRIBUTING.md

@@ -29,14 +29,11 @@ NoneBot 使用 [poetry](https://python-poetry.org/) 管理项目依赖，由于
 poetry install
 # 安装 pre-commit git hook
 pre-commit install
-# 安装 gitmoji git hook
-yarn global add gitmoji-cli
-gitmoji -i
 ```
 
-### 使用 GitHub Codespaces (Dev Container)
+### 使用 GitHub Codespaces（Dev Container）
 
-使用 GitHub Codespaces 选择 `NoneBot2` 项目，然后选择 `.devcontainer/devcontainer.json` 配置即可。
+[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://github.com/codespaces/new?hide_repo_select=true&ref=master&repo=289605524)
 
 ### Commit 规范
 
@@ -44,12 +41,22 @@ gitmoji -i
 
 NoneBot 的 commit message 格式遵循 [gitmoji](https://gitmoji.dev/) 规范，在创建 commit 时请牢记这一点。
 
+或者使用 [nonemoji](https://github.com/nonebot/nonemoji) 代替 git 进行 commit，nonemoji 已默认作为项目开发依赖安装。
+
+```bash
+nonemoji commit [-e EMOJI] [-m MESSAGE] [-- ...]
+```
+
+### 工作流概述
+
+`master` 分支为 NoneBot 的开发分支，在任何情况下都请不要直接修改 `master` 分支，而是创建一个目标分支为 `nonebot:master` 的 Pull Request 来提交修改。Pull Request 标题请尽量更改成中文，以便自动生成更新日志。
+
+如果你不是 NoneBot 团队的成员，可在 fork 本仓库后，向本仓库的 `master` 分支发起 Pull Request，注意遵循先前提到的 commit message 规范创建 commit。我们将在 code review 通过后通过 squash merge 方式将您的贡献合并到主分支。
+
 ### 撰写文档
 
 NoneBot2 的文档使用 [docusaurus](https://docusaurus.io/)，它有一些 [Markdown 特性](https://docusaurus.io/zh-CN/docs/markdown-features) 可能会帮助到你。
 
-NoneBot2 文档并没有具体的行文风格规范，但我们建议你尽量写得简单易懂。
-
 如果你需要在本地预览修改后的文档，可以使用 yarn 安装文档依赖后启动 dev server，如下所示：
 
 ```bash
@@ -57,6 +64,19 @@ yarn install
 yarn start
 ```
 
+NoneBot2 文档并没有具体的行文风格规范，但我们建议你尽量写得简单易懂。
+
+以下是比较重要的排版规范。目前 NoneBot2 文档中仍有部分文档不完全遵守此规范，如果在阅读时发现欢迎提交 PR。
+
+1. 中文与英文、数字、半角符号之间需要有空格。例：`NoneBot2 是一个可扩展的 Python 异步机器人框架。`
+2. 若非英文整句，使用全角标点符号。例：`现在你可以看到机器人回复你：“Hello, World !”。`
+3. 直引号`「」`和弯引号`“”`都可接受，但同一份文件里应使用同种引号。
+4. **不要使用斜体**，你不需要一种与粗体不同的强调。除此之外，你也可以考虑使用 docusaurus 提供的[告示](https://docusaurus.io/zh-CN/docs/markdown-features/admonitions)功能。
+
+这是社区创始人 richardchien 的中文排版规范，可供参考：<https://stdrc.cc/style-guides/chinese>。
+
+如果你需要编辑器提示 Markdown 规范，可以安装 VSCode 上的 markdownlint 插件。
+
 ### 参与开发
 
 NoneBot2 的代码风格遵循 [PEP 8](https://www.python.org/dev/peps/pep-0008/) 与 [PEP 484](https://www.python.org/dev/peps/pep-0484/) 规范，请确保你的代码风格和项目已有的代码保持一致，变量命名清晰，有适当的注释与测试代码。
@@ -70,9 +90,3 @@ NoneBot2 的代码风格遵循 [PEP 8](https://www.python.org/dev/peps/pep-0008/
 虽然对插件的内容没有严格限制，但我们还是建议在上架插件之前先查看商店有无功能一致的插件。如果你想要上架商店的插件功能与现有插件不完全重合，请在插件说明中补充其与现有插件的区别。
 
 同时，如果你参考或基于他人发行的代码进行开发，请注意遵守各代码所使用的开源许可协议。
-
-## Git 工作流
-
-`master` 分支为 NoneBot 的开发分支，请在任何情况下都不要直接修改 `master` 分支，而是创建一个目标分支为 `nonebot:master` 的 Pull Request 来提交修改。
-
-如果你不是 NoneBot 团队的成员，可在 fork 本仓库后，向本仓库的 `master` 分支发起 Pull Request，注意遵循先前提到的 commit message 规范创建 commit。我们将在 code review 通过后通过 squash merge 方式将您的贡献合并到主分支。

README.md

@@ -21,7 +21,7 @@ _✨ 跨平台 Python 异步机器人框架 ✨_
   <a href="https://pypi.python.org/pypi/nonebot2">
     <img src="https://img.shields.io/pypi/v/nonebot2" alt="pypi">
   </a>
-  <img src="https://img.shields.io/badge/python-3.7.3+-blue" alt="python">
+  <img src="https://img.shields.io/badge/python-3.8+-blue" alt="python">
   <a href="https://codecov.io/gh/nonebot/nonebot2">
     <img src="https://codecov.io/gh/nonebot/nonebot2/branch/master/graph/badge.svg?token=2P0G0VS7N4" alt="codecov"/>
   </a>
@@ -29,23 +29,29 @@ _✨ 跨平台 Python 异步机器人框架 ✨_
     <img src="https://github.com/nonebot/nonebot2/actions/workflows/website-deploy.yml/badge.svg?branch=master&event=push" alt="site"/>
   </a>
   <a href="https://results.pre-commit.ci/latest/github/nonebot/nonebot2/master">
-    <img src="https://results.pre-commit.ci/badge/github/nonebot/nonebot2/master.svg" />
+    <img src="https://results.pre-commit.ci/badge/github/nonebot/nonebot2/master.svg" alt="pre-commit" />
   </a>
   <br />
   <a href="https://onebot.dev/">
-    <img src="https://img.shields.io/badge/OneBot-v11-black?style=social&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABABAMAAABYR2ztAAAAIVBMVEUAAAAAAAADAwMHBwceHh4UFBQNDQ0ZGRkoKCgvLy8iIiLWSdWYAAAAAXRSTlMAQObYZgAAAQVJREFUSMftlM0RgjAQhV+0ATYK6i1Xb+iMd0qgBEqgBEuwBOxU2QDKsjvojQPvkJ/ZL5sXkgWrFirK4MibYUdE3OR2nEpuKz1/q8CdNxNQgthZCXYVLjyoDQftaKuniHHWRnPh2GCUetR2/9HsMAXyUT4/3UHwtQT2AggSCGKeSAsFnxBIOuAggdh3AKTL7pDuCyABcMb0aQP7aM4AnAbc/wHwA5D2wDHTTe56gIIOUA/4YYV2e1sg713PXdZJAuncdZMAGkAukU9OAn40O849+0ornPwT93rphWF0mgAbauUrEOthlX8Zu7P5A6kZyKCJy75hhw1Mgr9RAUvX7A3csGqZegEdniCx30c3agAAAABJRU5ErkJggg==" alt="cqhttp">
+    <img src="https://img.shields.io/badge/OneBot-v11-black?style=social&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABABAMAAABYR2ztAAAAIVBMVEUAAAAAAAADAwMHBwceHh4UFBQNDQ0ZGRkoKCgvLy8iIiLWSdWYAAAAAXRSTlMAQObYZgAAAQVJREFUSMftlM0RgjAQhV+0ATYK6i1Xb+iMd0qgBEqgBEuwBOxU2QDKsjvojQPvkJ/ZL5sXkgWrFirK4MibYUdE3OR2nEpuKz1/q8CdNxNQgthZCXYVLjyoDQftaKuniHHWRnPh2GCUetR2/9HsMAXyUT4/3UHwtQT2AggSCGKeSAsFnxBIOuAggdh3AKTL7pDuCyABcMb0aQP7aM4AnAbc/wHwA5D2wDHTTe56gIIOUA/4YYV2e1sg713PXdZJAuncdZMAGkAukU9OAn40O849+0ornPwT93rphWF0mgAbauUrEOthlX8Zu7P5A6kZyKCJy75hhw1Mgr9RAUvX7A3csGqZegEdniCx30c3agAAAABJRU5ErkJggg==" alt="onebot">
   </a>
-  <a href="https://ding-doc.dingtalk.com/document#/org-dev-guide/elzz1p">
-    <img src="https://img.shields.io/badge/%E9%92%89%E9%92%89-Bot-lightgrey?style=social&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAMAAACdt4HsAAAAnFBMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4jUzeAAAAM3RSTlMAQKSRaA+/f0YyFevh29R3cyklIfrlyrGsn41tVUs48c/HqJm9uZdhX1otGwkF9IN8V1CX0Q+IAAABY0lEQVRYw+3V2W7CMBAF0JuNQAhhX9OEfYdu9///rUVWpagE27Ef2gfO+0zGozsKnv6bMGzAhkNytIe5gDdzrwtTCwrbI8x4/NF668NAxgI3Q3UtFi3TyPwNQtPLUUmDd8YfqGLNe4v22XwEYb5zoOuF5baHq2UHtsKe5ivWfGAwrWu2mC34QM0PoCAuqZdOmiwV+5BLyMRtZ7dTSEcs48rzWfzwptMLyzpApka1SJ5FtR4kfCqNIBPEVDmqoqgwUYY5plQOlf6UEjNoOPnuKB6wzDyCrks///TDza8+PnR109WQdxLo8RKWq0PPnuXG0OXKQ6wWLFnCg75uYYbhmMIVVdQ709q33aHbGIj6Duz+2k1HQFX9VwqmY8xYsEJll2ahvhWgsjYLHFRXvIi2Qb0jzMQCzC3FAoydxCma88UCzE3JCWwkjCNYyMUCzHX4DiuTMawEwwhW6hnshPhjZzzJfAH0YacpbmRd7QAAAABJRU5ErkJggg==" alt="ding">
+  <a href="https://onebot.dev/">
+    <img src="https://img.shields.io/badge/OneBot-v12-black?style=social&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABABAMAAABYR2ztAAAAIVBMVEUAAAAAAAADAwMHBwceHh4UFBQNDQ0ZGRkoKCgvLy8iIiLWSdWYAAAAAXRSTlMAQObYZgAAAQVJREFUSMftlM0RgjAQhV+0ATYK6i1Xb+iMd0qgBEqgBEuwBOxU2QDKsjvojQPvkJ/ZL5sXkgWrFirK4MibYUdE3OR2nEpuKz1/q8CdNxNQgthZCXYVLjyoDQftaKuniHHWRnPh2GCUetR2/9HsMAXyUT4/3UHwtQT2AggSCGKeSAsFnxBIOuAggdh3AKTL7pDuCyABcMb0aQP7aM4AnAbc/wHwA5D2wDHTTe56gIIOUA/4YYV2e1sg713PXdZJAuncdZMAGkAukU9OAn40O849+0ornPwT93rphWF0mgAbauUrEOthlX8Zu7P5A6kZyKCJy75hhw1Mgr9RAUvX7A3csGqZegEdniCx30c3agAAAABJRU5ErkJggg==" alt="onebot">
   </a>
   <a href="https://core.telegram.org/bots/api">
-    <img src="https://img.shields.io/badge/telegram-Bot-lightgrey?style=social&logo=telegram">
+    <img src="https://img.shields.io/badge/telegram-Bot-lightgrey?style=social&logo=telegram" alt="telegram">
   </a>
   <a href="https://open.feishu.cn/document/home/index">
-    <img src="https://img.shields.io/badge/%E9%A3%9E%E4%B9%A6-Bot-lightgrey?style=social&logo=data:image/png;base64,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" alt="feishu">
+    <img src="https://img.shields.io/badge/%E9%A3%9E%E4%B9%A6-Bot-lightgrey?style=social&logo=data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz48c3ZnIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgdmlld0JveD0iMCAwIDQ4IDQ4IiBmaWxsPSJub25lIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPjxwYXRoIGQ9Ik0xNyAyOUMyMSAyOSAyNSAyNi45MzM5IDI4IDIzLjQwNjVDMzYgMTQgNDEuNDI0MiAxNi44MTY2IDQ0IDE3Ljk5OThDMzguNSAyMC45OTk4IDQwLjUgMjkuNjIzMyAzMyAzNS45OTk4QzI4LjM4MiAzOS45MjU5IDIzLjQ5NDUgNDEuMDE0IDE5IDQxQzEyLjUyMzEgNDAuOTc5OSA2Ljg2MjI2IDM3Ljc2MzcgNCAzNS40MDYzVjE2Ljk5OTgiIHN0cm9rZT0iIzMzMyIgc3Ryb2tlLXdpZHRoPSI0IiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiLz48cGF0aCBkPSJNNS42NDgwOCAxNS44NjY5QzUuMDIyMzEgMTQuOTU2NyAzLjc3NzE1IDE0LjcyNjEgMi44NjY5NCAxNS4zNTE5QzEuOTU2NzMgMTUuOTc3NyAxLjcyNjE1IDE3LjIyMjggMi4zNTE5MiAxOC4xMzMxTDUuNjQ4MDggMTUuODY2OVpNMzYuMDAyMSAzNS43MzA5QzM2Ljk1OCAzNS4xNzc0IDM3LjI4NDMgMzMuOTUzOSAzNi43MzA5IDMyLjk5NzlDMzYuMTc3NCAzMi4wNDIgMzQuOTUzOSAzMS43MTU3IDMzLjk5NzkgMzIuMjY5MUwzNi4wMDIxIDM1LjczMDlaTTIuMzUxOTIgMTguMTMzMUM1LjI0MzUgMjIuMzM5IDEwLjc5OTIgMjguMTQ0IDE2Ljg4NjUgMzIuMjIzOUMxOS45MzQ1IDM0LjI2NjcgMjMuMjE3IDM1Ljk0NiAyNi40NDkgMzYuNzMyNEMyOS42OTQ2IDM3LjUyMiAzMy4wNDUxIDM3LjQ0MjggMzYuMDAyMSAzNS43MzA5TDMzLjk5NzkgMzIuMjY5MUMzMi4yMDQ5IDMzLjMwNzIgMjkuOTkyOSAzMy40NzggMjcuMzk0NyAzMi44NDU4QzI0Ljc4MyAzMi4yMTAzIDIxLjk0MDUgMzAuNzk1OCAxOS4xMTM1IDI4LjkwMTFDMTMuNDUwOCAyNS4xMDYgOC4yNTY1IDE5LjY2MSA1LjY0ODA4IDE1Ljg2NjlMMi4zNTE5MiAxOC4xMzMxWiIgZmlsbD0iIzMzMyIvPjxwYXRoIGQ9Ik0zMy41OTQ1IDE3QzMyLjgzOTggMTQuNzAyNyAzMC44NTQ5IDkuOTQwNTQgMjcuNTk0NSA3SDExLjU5NDVDMTUuMjE3MSAxMC42NzU3IDIzIDE2IDI3IDI0IiBzdHJva2U9IiMzMzMiIHN0cm9rZS13aWR0aD0iNCIgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIiBzdHJva2UtbGluZWpvaW49InJvdW5kIi8+PC9zdmc+" alt="feishu">
+  </a>
+  <a href="https://docs.github.com/en/developers/apps">
+    <img src="https://img.shields.io/badge/GitHub-Bot-181717?style=social&logo=github" alt="github"/>
   </a>
   <a href="https://bot.q.qq.com/wiki/">
-    <img src="https://img.shields.io/badge/QQ%E9%A2%91%E9%81%93-Bot-lightgrey?style=social&logo=data:image/png;base64,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" alt="QQ频道">
+    <img src="https://img.shields.io/badge/QQ%E9%A2%91%E9%81%93-Bot-lightgrey?style=social&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMTIuODIgMTMwLjg5Ij48ZyBkYXRhLW5hbWU9IuWbvuWxgiAyIj48ZyBkYXRhLW5hbWU9IuWbvuWxgiAxIj48cGF0aCBkPSJNNTUuNjMgMTMwLjhjLTcgMC0xMy45LjA4LTIwLjg2IDAtMTkuMTUtLjI1LTMxLjcxLTExLjQtMzQuMjItMzAuMy00LjA3LTMwLjY2IDE0LjkzLTU5LjIgNDQuODMtNjYuNjQgMi0uNTEgNS4yMS0uMzEgNS4yMS0xLjYzIDAtMi4xMy4xNC0yLjEzLjE0LTUuNTcgMC0uODktMS4zLTEuNDYtMi4yMi0yLjMxLTYuNzMtNi4yMy03LjY3LTEzLjQxLTEtMjAuMTggNS40LTUuNTIgMTEuODctNS40IDE3LjgtLjU5IDYuNDkgNS4yNiA2LjMxIDEzLjA4LS44NiAyMS0uNjguNzQtMS43OCAxLjYtMS43OCAyLjY3djQuMjFjMCAxLjM1IDIuMiAxLjYyIDQuNzkgMi4zNSAzMS4wOSA4LjY1IDQ4LjE3IDM0LjEzIDQ1IDY2LjM3LTEuNzYgMTguMTUtMTQuNTYgMzAuMjMtMzIuNyAzMC42My04LjAyLjE5LTE2LjA3LS4wMS0yNC4xMy0uMDF6IiBmaWxsPSIjMDI5OWZlIi8+PHBhdGggZD0iTTMxLjQ2IDExOC4zOGMtMTAuNS0uNjktMTYuOC02Ljg2LTE4LjM4LTE3LjI3LTMtMTkuNDIgMi43OC0zNS44NiAxOC40Ni00Ny44MyAxNC4xNi0xMC44IDI5Ljg3LTEyIDQ1LjM4LTMuMTkgMTcuMjUgOS44NCAyNC41OSAyNS44MSAyNCA0NS4yOS0uNDkgMTUuOS04LjQyIDIzLjE0LTI0LjM4IDIzLjUtNi41OS4xNC0xMy4xOSAwLTE5Ljc5IDAiIGZpbGw9IiNmZWZlZmUiLz48cGF0aCBkPSJNNDYuMDUgNzkuNThjLjA5IDUgLjIzIDkuODItNyA5Ljc3LTcuODItLjA2LTYuMS01LjY5LTYuMjQtMTAuMTktLjE1LTQuODItLjczLTEwIDYuNzMtOS44NHM2LjM3IDUuNTUgNi41MSAxMC4yNnoiIGZpbGw9IiMxMDlmZmUiLz48cGF0aCBkPSJNODAuMjcgNzkuMjdjLS41MyAzLjkxIDEuNzUgOS42NC01Ljg4IDEwLTcuNDcuMzctNi44MS00LjgyLTYuNjEtOS41LjItNC4zMi0xLjgzLTEwIDUuNzgtMTAuNDJzNi41OSA0Ljg5IDYuNzEgOS45MnoiIGZpbGw9IiMwODljZmUiLz48L2c+PC9nPjwvc3ZnPg==" alt="QQ频道">
+  <a href="https://ding-doc.dingtalk.com/document#/org-dev-guide/elzz1p">
+    <img src="https://img.shields.io/badge/%E9%92%89%E9%92%89-Bot-lightgrey?style=social&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAMAAACdt4HsAAAAnFBMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4jUzeAAAAM3RSTlMAQKSRaA+/f0YyFevh29R3cyklIfrlyrGsn41tVUs48c/HqJm9uZdhX1otGwkF9IN8V1CX0Q+IAAABY0lEQVRYw+3V2W7CMBAF0JuNQAhhX9OEfYdu9///rUVWpagE27Ef2gfO+0zGozsKnv6bMGzAhkNytIe5gDdzrwtTCwrbI8x4/NF668NAxgI3Q3UtFi3TyPwNQtPLUUmDd8YfqGLNe4v22XwEYb5zoOuF5baHq2UHtsKe5ivWfGAwrWu2mC34QM0PoCAuqZdOmiwV+5BLyMRtZ7dTSEcs48rzWfzwptMLyzpApka1SJ5FtR4kfCqNIBPEVDmqoqgwUYY5plQOlf6UEjNoOPnuKB6wzDyCrks///TDza8+PnR109WQdxLo8RKWq0PPnuXG0OXKQ6wWLFnCg75uYYbhmMIVVdQ709q33aHbGIj6Duz+2k1HQFX9VwqmY8xYsEJll2ahvhWgsjYLHFRXvIi2Qb0jzMQCzC3FAoydxCma88UCzE3JCWwkjCNYyMUCzHX4DiuTMawEwwhW6hnshPhjZzzJfAH0YacpbmRd7QAAAABJRU5ErkJggg==" alt="dingtalk">
+  </a>
   </a>
   <br />
   <a href="https://jq.qq.com/?_wv=1027&k=5OFifDh">
@@ -89,17 +95,31 @@ NoneBot2 是一个现代、跨平台、可扩展的 Python 聊天机器人框架
 - 生而可靠：100% 类型注解覆盖，配合编辑器的类型推导功能，能将绝大多数的 Bug 杜绝在编辑器中 ([编辑器支持](https://v2.nonebot.dev/docs/start/editor-support))
 - 社区丰富：社区用户众多，直接和间接用户超过十万人，每天都有大量的活跃用户 ([社区资源](#社区资源))
 - 海纳百川：一个框架，支持多个聊天软件平台，可自定义通信协议
-  - [OneBot 协议](https://onebot.dev/) (QQ 等)
-  - [钉钉](https://ding-doc.dingtalk.com/document#/org-dev-guide/elzz1p)
-  - [Telegram](https://core.telegram.org/bots/api)
-  - [飞书](https://open.feishu.cn/document/home/index)
-  - [QQ 频道](https://bot.q.qq.com/wiki/)
-- 坚实后盾：支持多种 web 框架，可自定义替换
-  - [FastAPI](https://fastapi.tiangolo.com/)
-  - [Quart](https://pgjones.gitlab.io/quart/) (异步 Flask)
-  - [aiohttp](https://docs.aiohttp.org/en/stable/)
-  - [httpx](https://www.python-httpx.org/)
-  - [websockets](https://websockets.readthedocs.io/en/stable/)
+
+  |                                 协议名称                                  | 状态 |                                注释                                |
+  | :-----------------------------------------------------------------------: | :--: | :----------------------------------------------------------------: |
+  |                    [OneBot 协议](https://onebot.dev/)                     |  ✅  | 支持 QQ、TG、微信公众号等[平台](https://onebot.dev/ecosystem.html) |
+  |              [Telegram](https://core.telegram.org/bots/api)               |  ✅  |                                                                    |
+  |            [飞书](https://open.feishu.cn/document/home/index)             |  ✅  |                                                                    |
+  |           [GitHub](https://docs.github.com/en/developers/apps)            |  ✅  |                       GitHub APP & OAuth APP                       |
+  |                   [QQ 频道](https://bot.q.qq.com/wiki/)                   |  ✅  |                          官方接口调整较多                          |
+  |                [钉钉](https://open.dingtalk.com/document/)                |  🤗  |                          寻找 Maintainer                           |
+  |                                  Console                                  |  ✅  |                             控制台交互                             |
+  |                  [开黑啦](https://developer.kookapp.cn/)                  |  ↗️  |                             由社区贡献                             |
+  |           [Mirai](https://docs.mirai.mamoe.net/mirai-api-http/)           |  ↗️  |                             由社区贡献                             |
+  |        [Ntchat](https://github.com/JustUndertaker/adapter-ntchat)         |  ↗️  |                             由社区贡献                             |
+  | [MineCraft (Spigot)](https://github.com/17TheWord/nonebot-adapter-spigot) |  ↗️  |                             由社区贡献                             |
+  |        [BiliBili Live](https://github.com/wwweww/adapter-bilibili)        |  ↗️  |                             由社区贡献                             |
+
+- 坚实后盾：支持多种 web 框架，可自定义替换、组合
+
+  |                          驱动框架                          |  类型  |
+  | :--------------------------------------------------------: | :----: |
+  |          [FastAPI](https://fastapi.tiangolo.com/)          | 服务端 |
+  |   [Quart](https://pgjones.gitlab.io/quart/) (异步 Flask)   | 服务端 |
+  |       [aiohttp](https://docs.aiohttp.org/en/stable/)       | 客户端 |
+  |           [httpx](https://www.python-httpx.org/)           | 客户端 |
+  | [websockets](https://websockets.readthedocs.io/en/stable/) | 客户端 |
 
 更多：[概览](https://v2.nonebot.dev/docs/)
 
@@ -117,12 +137,17 @@ NoneBot2 不是 NoneBot1 的替代品。事实上，它们都在被积极的维
 
 懒得看文档？下面是快速安装指南：
 
-1. (**强烈建议**)使用你喜欢的 Python 环境管理工具创建新的虚拟环境。
-
-2. 使用 `pip` (或其他) 安装 NoneBot 脚手架。
+1. 安装 [pipx](https://pypa.github.io/pipx/)
 
    ```bash
-   pip install nb-cli
+   python -m pip install --user pipx
+   python -m pipx ensurepath
+   ```
+
+2. 安装脚手架
+
+   ```bash
+   pipx install nb-cli
    ```
 
 3. 使用脚手架创建项目
@@ -131,6 +156,12 @@ NoneBot2 不是 NoneBot1 的替代品。事实上，它们都在被积极的维
    nb create
    ```
 
+4. 运行项目
+
+   ```bash
+   nb run
+   ```
+
 ## 社区资源
 
 ### 常见问题
@@ -183,5 +214,5 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 感谢以下开发者对 NoneBot2 作出的贡献：
 
 <a href="https://github.com/nonebot/nonebot2/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=nonebot/nonebot2" />
+  <img src="https://contrib.rocks/image?repo=nonebot/nonebot2&max=1000" />
 </a>

nonebot/__init__.py

@@ -16,6 +16,7 @@
 - `on_command` => {ref}``on_command` <nonebot.plugin.on.on_command>`
 - `on_shell_command` => {ref}``on_shell_command` <nonebot.plugin.on.on_shell_command>`
 - `on_regex` => {ref}``on_regex` <nonebot.plugin.on.on_regex>`
+- `on_type` => {ref}``on_type` <nonebot.plugin.on.on_type>`
 - `CommandGroup` => {ref}``CommandGroup` <nonebot.plugin.on.CommandGroup>`
 - `Matchergroup` => {ref}``MatcherGroup` <nonebot.plugin.on.MatcherGroup>`
 - `load_plugin` => {ref}``load_plugin` <nonebot.plugin.load.load_plugin>`
@@ -25,9 +26,10 @@
 - `load_from_toml` => {ref}``load_from_toml` <nonebot.plugin.load.load_from_toml>`
 - `load_builtin_plugin` => {ref}``load_builtin_plugin` <nonebot.plugin.load.load_builtin_plugin>`
 - `load_builtin_plugins` => {ref}``load_builtin_plugins` <nonebot.plugin.load.load_builtin_plugins>`
-- `get_plugin` => {ref}``get_plugin` <nonebot.plugin.plugin.get_plugin>`
-- `get_loaded_plugins` => {ref}``get_loaded_plugins` <nonebot.plugin.plugin.get_loaded_plugins>`
-- `export` => {ref}``export` <nonebot.plugin.export.export>`
+- `get_plugin` => {ref}``get_plugin` <nonebot.plugin.get_plugin>`
+- `get_plugin_by_module_name` => {ref}``get_plugin_by_module_name` <nonebot.plugin.get_plugin_by_module_name>`
+- `get_loaded_plugins` => {ref}``get_loaded_plugins` <nonebot.plugin.get_loaded_plugins>`
+- `get_available_plugin_names` => {ref}``get_available_plugin_names` <nonebot.plugin.get_available_plugin_names>`
 - `require` => {ref}``require` <nonebot.plugin.load.require>`
 
 FrontMatter:
@@ -35,24 +37,24 @@ FrontMatter:
     description: nonebot 模块
 """
 
+import os
 import importlib
+from importlib.metadata import version
 from typing import Any, Dict, Type, Optional
 
-import pkg_resources
+import loguru
+from pydantic.env_settings import DotenvType
 
 from nonebot.adapters import Bot
 from nonebot.utils import escape_tag
 from nonebot.config import Env, Config
-from nonebot.log import logger, default_filter
+from nonebot.log import logger as logger
 from nonebot.drivers import Driver, ReverseDriver, combine_driver
 
 try:
-    _dist: pkg_resources.Distribution = pkg_resources.get_distribution("nonebot2")
-    __version__ = _dist.version
-    VERSION = _dist.parsed_version
-except pkg_resources.DistributionNotFound:  # pragma: no cover
+    __version__ = version("nonebot2")
+except Exception:  # pragma: no cover
     __version__ = None
-    VERSION = None
 
 _driver: Optional[Driver] = None
 
@@ -170,8 +172,7 @@ def get_bots() -> Dict[str, Bot]:
         bots = nonebot.get_bots()
         ```
     """
-    driver = get_driver()
-    return driver.bots
+    return get_driver().bots
 
 
 def _resolve_dot_notation(
@@ -205,7 +206,16 @@ def _resolve_combine_expr(obj_str: str) -> Type[Driver]:
     return combine_driver(DriverClass, *mixins)
 
 
-def init(*, _env_file: Optional[str] = None, **kwargs: Any) -> None:
+def _log_patcher(record: "loguru.Record"):
+    record["name"] = (
+        plugin.name
+        if (module_name := record["name"])
+        and (plugin := get_plugin_by_module_name(module_name))
+        else (module_name and module_name.split(".")[0])
+    )
+
+
+def init(*, _env_file: Optional[DotenvType] = None, **kwargs: Any) -> None:
     """初始化 NoneBot 以及 全局 {ref}`nonebot.drivers.Driver` 对象。
 
     NoneBot 将会从 .env 文件中读取环境信息，并使用相应的 env 文件配置。
@@ -225,13 +235,17 @@ def init(*, _env_file: Optional[str] = None, **kwargs: Any) -> None:
     if not _driver:
         logger.success("NoneBot is initializing...")
         env = Env()
+        _env_file = _env_file or f".env.{env.environment}"
         config = Config(
             **kwargs,
-            _common_config=env.dict(),
-            _env_file=_env_file or f".env.{env.environment}",
+            _env_file=(".env", _env_file)
+            if isinstance(_env_file, (str, os.PathLike))
+            else _env_file,
         )
 
-        default_filter.level = config.log_level
+        logger.configure(
+            extra={"nonebot_log_level": config.log_level}, patcher=_log_patcher
+        )
         logger.opt(colors=True).info(
             f"Current <y><b>Env: {escape_tag(env.environment)}</b></y>"
         )
@@ -239,7 +253,7 @@ def init(*, _env_file: Optional[str] = None, **kwargs: Any) -> None:
             f"Loaded <y><b>Config</b></y>: {escape_tag(str(config.dict()))}"
         )
 
-        DriverClass: Type[Driver] = _resolve_combine_expr(config.driver)
+        DriverClass = _resolve_combine_expr(config.driver)
         _driver = DriverClass(env, config)
 
 
@@ -260,7 +274,7 @@ def run(*args: Any, **kwargs: Any) -> None:
 
 
 from nonebot.plugin import on as on
-from nonebot.plugin import export as export
+from nonebot.plugin import on_type as on_type
 from nonebot.plugin import require as require
 from nonebot.plugin import on_regex as on_regex
 from nonebot.plugin import on_notice as on_notice
@@ -284,5 +298,7 @@ from nonebot.plugin import on_shell_command as on_shell_command
 from nonebot.plugin import get_loaded_plugins as get_loaded_plugins
 from nonebot.plugin import load_builtin_plugin as load_builtin_plugin
 from nonebot.plugin import load_builtin_plugins as load_builtin_plugins
+from nonebot.plugin import get_plugin_by_module_name as get_plugin_by_module_name
+from nonebot.plugin import get_available_plugin_names as get_available_plugin_names
 
 __autodoc__ = {"internal": False}

nonebot/adapters/__init__.py

@@ -7,21 +7,6 @@ FrontMatter:
     description: nonebot.adapters 模块
 """
 
-from typing import Iterable
-
-try:
-    import pkg_resources
-
-    pkg_resources.declare_namespace(__name__)
-    del pkg_resources
-except ImportError:
-    import pkgutil
-
-    __path__: Iterable[str] = pkgutil.extend_path(__path__, __name__)  # type: ignore
-    del pkgutil
-except Exception:
-    pass
-
 from nonebot.internal.adapter import Bot as Bot
 from nonebot.internal.adapter import Event as Event
 from nonebot.internal.adapter import Adapter as Adapter

nonebot/config.py

@@ -9,23 +9,21 @@ FrontMatter:
     description: nonebot.config 模块
 """
 import os
-from pathlib import Path
 from datetime import timedelta
 from ipaddress import IPv4Address
 from typing import TYPE_CHECKING, Any, Set, Dict, Tuple, Union, Mapping, Optional
 
-from pydantic import BaseSettings, IPvAnyAddress
+from pydantic.utils import deep_update
+from pydantic import Extra, BaseSettings, IPvAnyAddress
 from pydantic.env_settings import (
+    DotenvType,
     SettingsError,
     EnvSettingsSource,
     InitSettingsSource,
     SettingsSourceCallable,
-    read_env_file,
-    env_file_sentinel,
 )
 
 from nonebot.log import logger
-from nonebot.utils import escape_tag
 
 
 class CustomEnvSettings(EnvSettingsSource):
@@ -33,33 +31,15 @@ class CustomEnvSettings(EnvSettingsSource):
         """
         Build environment variables suitable for passing to the Model.
         """
-        d: Dict[str, Optional[str]] = {}
+        d: Dict[str, Any] = {}
 
         if settings.__config__.case_sensitive:
             env_vars: Mapping[str, Optional[str]] = os.environ  # pragma: no cover
         else:
             env_vars = {k.lower(): v for k, v in os.environ.items()}
 
-        env_file_vars: Dict[str, Optional[str]] = {}
-        env_file = (
-            self.env_file
-            if self.env_file != env_file_sentinel
-            else settings.__config__.env_file
-        )
-        env_file_encoding = (
-            self.env_file_encoding
-            if self.env_file_encoding is not None
-            else settings.__config__.env_file_encoding
-        )
-        if env_file is not None:
-            env_path = Path(env_file)
-            if env_path.is_file():
-                env_file_vars = read_env_file(
-                    env_path,
-                    encoding=env_file_encoding,  # type: ignore
-                    case_sensitive=settings.__config__.case_sensitive,
-                )
-                env_vars = {**env_file_vars, **env_vars}
+        env_file_vars = self._read_env_files(settings.__config__.case_sensitive)
+        env_vars = {**env_file_vars, **env_vars}
 
         for field in settings.__fields__.values():
             env_val: Optional[str] = None
@@ -70,30 +50,56 @@ class CustomEnvSettings(EnvSettingsSource):
                 if env_val is not None:
                     break
 
-            if env_val is None:
-                continue
+            is_complex, allow_parse_failure = self.field_is_complex(field)
+            if is_complex:
+                if env_val is None:
+                    if env_val_built := self.explode_env_vars(field, env_vars):
+                        d[field.alias] = env_val_built
+                else:
+                    # field is complex and there's a value, decode that as JSON, then add explode_env_vars
+                    try:
+                        env_val = settings.__config__.parse_env_var(field.name, env_val)
+                    except ValueError as e:
+                        if not allow_parse_failure:
+                            raise SettingsError(
+                                f'error parsing env var "{env_name}"'  # type: ignore
+                            ) from e
 
-            if field.is_complex():
-                try:
-                    env_val = settings.__config__.json_loads(env_val)
-                except ValueError as e:  # pragma: no cover
-                    raise SettingsError(
-                        f'error parsing JSON for "{env_name}"'  # type: ignore
-                    ) from e
-            d[field.alias] = env_val
+                    if isinstance(env_val, dict):
+                        d[field.alias] = deep_update(
+                            env_val, self.explode_env_vars(field, env_vars)
+                        )
+                    else:
+                        d[field.alias] = env_val
+            elif env_val is not None:
+                # simplest case, field is not complex, we only need to add the value if it was found
+                d[field.alias] = env_val
 
-        if env_file_vars:
-            for env_name, env_val in env_file_vars.items():
-                if (env_val is None or len(env_val) == 0) and env_name in env_vars:
-                    env_val = env_vars[env_name]
+        # remain user custom config
+        for env_name in env_file_vars:
+            env_val = env_vars[env_name]
+            if env_val and (val_striped := env_val.strip()):
+                # there's a value, decode that as JSON
                 try:
-                    if env_val:
-                        env_val = settings.__config__.json_loads(env_val.strip())
+                    env_val = settings.__config__.parse_env_var(env_name, val_striped)
                 except ValueError as e:
-                    logger.opt(colors=True, exception=e).trace(
-                        f"Error while parsing JSON for {escape_tag(env_name)}. Assumed as string."
+                    logger.trace(
+                        "Error while parsing JSON for "
+                        f"{env_name!r}={val_striped!r}. "
+                        "Assumed as string."
                     )
 
+            # explode value when it's a nested dict
+            env_name, *nested_keys = env_name.split(self.env_nested_delimiter)
+            if nested_keys and (env_name not in d or isinstance(d[env_name], dict)):
+                result = {}
+                *keys, last_key = nested_keys
+                _tmp = result
+                for key in keys:
+                    _tmp = _tmp.setdefault(key, {})
+                _tmp[last_key] = env_val
+                d[env_name] = deep_update(d.get(env_name, {}), result)
+            elif not nested_keys:
                 d[env_name] = env_val
 
         return d
@@ -106,6 +112,9 @@ class BaseConfig(BaseSettings):
             return self.__dict__.get(name)
 
     class Config:
+        extra = Extra.allow
+        env_nested_delimiter = "__"
+
         @classmethod
         def customise_sources(
             cls,
@@ -117,7 +126,10 @@ class BaseConfig(BaseSettings):
             return (
                 init_settings,
                 CustomEnvSettings(
-                    env_settings.env_file, env_settings.env_file_encoding
+                    env_settings.env_file,
+                    env_settings.env_file_encoding,
+                    env_settings.env_nested_delimiter,
+                    env_settings.env_prefix_len,
                 ),
                 InitSettingsSource(common_config),
                 file_secret_settings,
@@ -137,7 +149,6 @@ class Env(BaseConfig):
     """
 
     class Config:
-        extra = "allow"
         env_file = ".env"
 
 
@@ -150,8 +161,7 @@ class Config(BaseConfig):
     配置方法参考: [配置](https://v2.nonebot.dev/docs/tutorial/configuration)
     """
 
-    _env_file: str = ".env"
-    _common_config: Dict[str, Any] = {}
+    _env_file: DotenvType = ".env", ".env.prod"
 
     # nonebot configs
     driver: str = "~fastapi"
@@ -231,8 +241,7 @@ class Config(BaseConfig):
     # or from env file using json loads
 
     class Config:
-        extra = "allow"
-        env_file = ".env.prod"
+        env_file = ".env", ".env.prod"
 
 
 __autodoc__ = {

nonebot/consts.py

@@ -4,7 +4,7 @@ FrontMatter:
     sidebar_position: 9
     description: nonebot.consts 模块
 """
-from typing_extensions import Literal
+from typing import Literal
 
 # used by Matcher
 RECEIVE_KEY: Literal["_receive_{id}"] = "_receive_{id}"
@@ -38,7 +38,17 @@ SHELL_ARGV: Literal["_argv"] = "_argv"
 
 REGEX_MATCHED: Literal["_matched"] = "_matched"
 """正则匹配结果存储 key"""
+REGEX_STR: Literal["_matched_str"] = "_matched_str"
+"""正则匹配文本存储 key"""
 REGEX_GROUP: Literal["_matched_groups"] = "_matched_groups"
 """正则匹配 group 元组存储 key"""
 REGEX_DICT: Literal["_matched_dict"] = "_matched_dict"
 """正则匹配 group 字典存储 key"""
+STARTSWITH_KEY: Literal["_startswith"] = "_startswith"
+"""响应触发前缀 key"""
+ENDSWITH_KEY: Literal["_endswith"] = "_endswith"
+"""响应触发后缀 key"""
+FULLMATCH_KEY: Literal["_fullmatch"] = "_fullmatch"
+"""响应触发完整消息 key"""
+KEYWORD_KEY: Literal["_keyword"] = "_keyword"
+"""响应触发关键字 key"""

nonebot/dependencies/__init__.py

@@ -6,15 +6,31 @@ FrontMatter:
 """
 
 import abc
+import asyncio
 import inspect
-from typing import Any, Dict, List, Type, Generic, TypeVar, Callable, Optional
+from dataclasses import field, dataclass
+from typing import (
+    Any,
+    Dict,
+    List,
+    Type,
+    Tuple,
+    Generic,
+    TypeVar,
+    Callable,
+    Iterable,
+    Optional,
+    Awaitable,
+    cast,
+)
 
 from pydantic import BaseConfig
 from pydantic.schema import get_annotation_from_field_info
 from pydantic.fields import Required, FieldInfo, Undefined, ModelField
 
 from nonebot.log import logger
-from nonebot.exception import TypeMisMatch
+from nonebot.typing import _DependentCallable
+from nonebot.exception import SkippedException
 from nonebot.utils import run_sync, is_coroutine_callable
 
 from .utils import check_field_type, get_typed_signature
@@ -31,25 +47,29 @@ class Param(abc.ABC, FieldInfo):
 
     @classmethod
     def _check_param(
-        cls, dependent: "Dependent", name: str, param: inspect.Parameter
+        cls, param: inspect.Parameter, allow_types: Tuple[Type["Param"], ...]
     ) -> Optional["Param"]:
-        return None
+        return
 
     @classmethod
     def _check_parameterless(
-        cls, dependent: "Dependent", value: Any
+        cls, value: Any, allow_types: Tuple[Type["Param"], ...]
     ) -> Optional["Param"]:
-        return None
+        return
 
     @abc.abstractmethod
     async def _solve(self, **kwargs: Any) -> Any:
         raise NotImplementedError
 
+    async def _check(self, **kwargs: Any) -> None:
+        return
+
 
 class CustomConfig(BaseConfig):
     arbitrary_types_allowed = True
 
 
+@dataclass(frozen=True)
 class Dependent(Generic[R]):
     """依赖注入容器
 
@@ -61,101 +81,70 @@ class Dependent(Generic[R]):
         allow_types: 允许的参数类型
     """
 
-    def __init__(
-        self,
-        *,
-        call: Callable[..., Any],
-        pre_checkers: Optional[List[Param]] = None,
-        params: Optional[List[ModelField]] = None,
-        parameterless: Optional[List[Param]] = None,
-        allow_types: Optional[List[Type[Param]]] = None,
-    ) -> None:
-        self.call = call
-        self.pre_checkers = pre_checkers or []
-        self.params = params or []
-        self.parameterless = parameterless or []
-        self.allow_types = allow_types or []
+    call: _DependentCallable[R]
+    params: Tuple[ModelField] = field(default_factory=tuple)
+    parameterless: Tuple[Param] = field(default_factory=tuple)
 
     def __repr__(self) -> str:
+        if inspect.isfunction(self.call) or inspect.isclass(self.call):
+            call_str = self.call.__name__
+        else:
+            call_str = repr(self.call)
         return (
-            f"<Dependent call={self.call}, params={self.params},"
-            f" parameterless={self.parameterless}>"
+            f"Dependent(call={call_str}"
+            + (f", parameterless={self.parameterless}" if self.parameterless else "")
+            + ")"
         )
 
-    def __str__(self) -> str:
-        return self.__repr__()
-
     async def __call__(self, **kwargs: Any) -> R:
+        # do pre-check
+        await self.check(**kwargs)
+
+        # solve param values
         values = await self.solve(**kwargs)
 
+        # call function
         if is_coroutine_callable(self.call):
-            return await self.call(**values)
+            return await cast(Callable[..., Awaitable[R]], self.call)(**values)
         else:
-            return await run_sync(self.call)(**values)
+            return await run_sync(cast(Callable[..., R], self.call))(**values)
 
-    def parse_param(self, name: str, param: inspect.Parameter) -> Param:
-        for allow_type in self.allow_types:
-            field_info = allow_type._check_param(self, name, param)
-            if field_info:
-                return field_info
-        else:
-            raise ValueError(
-                f"Unknown parameter {name} for function {self.call} with type {param.annotation}"
-            )
+    @staticmethod
+    def parse_params(
+        call: _DependentCallable[R], allow_types: Tuple[Type[Param], ...]
+    ) -> Tuple[ModelField]:
+        fields: List[ModelField] = []
+        params = get_typed_signature(call).parameters.values()
 
-    def parse_parameterless(self, value: Any) -> Param:
-        for allow_type in self.allow_types:
-            field_info = allow_type._check_parameterless(self, value)
-            if field_info:
-                return field_info
-        else:
-            raise ValueError(
-                f"Unknown parameterless {value} for function {self.call} with type {type(value)}"
-            )
-
-    def prepend_parameterless(self, value: Any) -> None:
-        self.parameterless.insert(0, self.parse_parameterless(value))
-
-    def append_parameterless(self, value: Any) -> None:
-        self.parameterless.append(self.parse_parameterless(value))
-
-    @classmethod
-    def parse(
-        cls: Type[T],
-        *,
-        call: Callable[..., Any],
-        parameterless: Optional[List[Any]] = None,
-        allow_types: Optional[List[Type[Param]]] = None,
-    ) -> T:
-        signature = get_typed_signature(call)
-        params = signature.parameters
-        dependent = cls(
-            call=call,
-            allow_types=allow_types,
-        )
-
-        for param_name, param in params.items():
+        for param in params:
             default_value = Required
             if param.default != param.empty:
                 default_value = param.default
 
             if isinstance(default_value, Param):
                 field_info = default_value
-                default_value = field_info.default
             else:
-                field_info = dependent.parse_param(param_name, param)
-                default_value = field_info.default
+                for allow_type in allow_types:
+                    if field_info := allow_type._check_param(param, allow_types):
+                        break
+                else:
+                    raise ValueError(
+                        f"Unknown parameter {param.name} for function {call} with type {param.annotation}"
+                    )
+
+            default_value = field_info.default
 
             annotation: Any = Any
             required = default_value == Required
             if param.annotation != param.empty:
                 annotation = param.annotation
             annotation = get_annotation_from_field_info(
-                annotation, field_info, param_name
+                annotation, field_info, param.name
             )
-            dependent.params.append(
+
+            fields.append(
                 ModelField(
-                    name=param_name,
+                    name=param.name,
                     type_=annotation,
                     class_validators=None,
                     model_config=CustomConfig,
@@ -165,49 +154,72 @@ class Dependent(Generic[R]):
                 )
             )
 
-        parameterless_params = [
-            dependent.parse_parameterless(param) for param in (parameterless or [])
-        ]
-        dependent.parameterless.extend(parameterless_params)
+        return tuple(fields)
 
-        logger.trace(
-            f"Parsed dependent with call={call}, "
-            f"params={[param.field_info for param in dependent.params]}, "
-            f"parameterless={dependent.parameterless}"
+    @staticmethod
+    def parse_parameterless(
+        parameterless: Tuple[Any, ...], allow_types: Tuple[Type[Param], ...]
+    ) -> Tuple[Param, ...]:
+        parameterless_params: List[Param] = []
+        for value in parameterless:
+            for allow_type in allow_types:
+                if param := allow_type._check_parameterless(value, allow_types):
+                    break
+            else:
+                raise ValueError(f"Unknown parameterless {value}")
+            parameterless_params.append(param)
+        return tuple(parameterless_params)
+
+    @classmethod
+    def parse(
+        cls,
+        *,
+        call: _DependentCallable[R],
+        parameterless: Optional[Iterable[Any]] = None,
+        allow_types: Iterable[Type[Param]],
+    ) -> "Dependent[R]":
+        allow_types = tuple(allow_types)
+
+        params = cls.parse_params(call, allow_types)
+        parameterless_params = (
+            tuple()
+            if parameterless is None
+            else cls.parse_parameterless(tuple(parameterless), allow_types)
         )
 
-        return dependent
+        return cls(call, params, parameterless_params)
 
-    async def solve(
-        self,
-        **params: Any,
-    ) -> Dict[str, Any]:
-        values: Dict[str, Any] = {}
+    async def check(self, **params: Any) -> None:
+        try:
+            await asyncio.gather(
+                *(param._check(**params) for param in self.parameterless)
+            )
+            await asyncio.gather(
+                *(
+                    cast(Param, param.field_info)._check(**params)
+                    for param in self.params
+                )
+            )
+        except SkippedException as e:
+            logger.trace(f"{self} skipped due to {e}")
+            raise
 
-        for checker in self.pre_checkers:
-            await checker._solve(**params)
+    async def _solve_field(self, field: ModelField, params: Dict[str, Any]) -> Any:
+        value = await cast(Param, field.field_info)._solve(**params)
+        if value is Undefined:
+            value = field.get_default()
+        return check_field_type(field, value)
 
+    async def solve(self, **params: Any) -> Dict[str, Any]:
+        # solve parameterless
         for param in self.parameterless:
             await param._solve(**params)
 
-        for field in self.params:
-            field_info = field.field_info
-            assert isinstance(field_info, Param), "Params must be subclasses of Param"
-            value = await field_info._solve(**params)
-            if value is Undefined:
-                value = field.get_default()
-
-            try:
-                values[field.name] = check_field_type(field, value)
-            except TypeMisMatch:
-                logger.debug(
-                    f"{field_info} "
-                    f"type {type(value)} not match depends {self.call} "
-                    f"annotation {field._type_display()}, ignored"
-                )
-                raise
-
-        return values
+        # solve param values
+        values = await asyncio.gather(
+            *(self._solve_field(field, params) for field in self.params)
+        )
+        return {field.name: value for field, value in zip(self.params, values)}
 
 
 __autodoc__ = {"CustomConfig": False}

nonebot/dependencies/utils.py

@@ -4,11 +4,11 @@ FrontMatter:
     description: nonebot.dependencies.utils 模块
 """
 import inspect
-from typing import Any, Dict, TypeVar, Callable
+from typing import Any, Dict, TypeVar, Callable, ForwardRef
 
 from loguru import logger
 from pydantic.fields import ModelField
-from pydantic.typing import ForwardRef, evaluate_forwardref
+from pydantic.typing import evaluate_forwardref
 
 from nonebot.exception import TypeMisMatch
 
@@ -28,8 +28,7 @@ def get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
         )
         for param in signature.parameters.values()
     ]
-    typed_signature = inspect.Signature(typed_params)
-    return typed_signature
+    return inspect.Signature(typed_params)
 
 
 def get_typed_annotation(param: inspect.Parameter, globalns: Dict[str, Any]) -> Any:

nonebot/drivers/aiohttp.py

@@ -21,13 +21,13 @@ from contextlib import asynccontextmanager
 from nonebot.typing import overrides
 from nonebot.drivers import Request, Response
 from nonebot.exception import WebSocketClosed
-from nonebot.drivers._block_driver import BlockDriver
+from nonebot.drivers.none import Driver as NoneDriver
 from nonebot.drivers import WebSocket as BaseWebSocket
 from nonebot.drivers import HTTPVersion, ForwardMixin, ForwardDriver, combine_driver
 
 try:
     import aiohttp
-except ImportError:
+except ImportError:  # pragma: no cover
     raise ImportError(
         "Please install aiohttp first to use this driver. `pip install nonebot2[aiohttp]`"
     ) from None
@@ -56,7 +56,13 @@ class Mixin(ForwardMixin):
             files = aiohttp.FormData()
             for name, file in setup.files:
                 files.add_field(name, file[1], content_type=file[2], filename=file[0])
-        async with aiohttp.ClientSession(version=version, trust_env=True) as session:
+
+        cookies = {
+            cookie.name: cookie.value for cookie in setup.cookies if cookie.value
+        }
+        async with aiohttp.ClientSession(
+            cookies=cookies, version=version, trust_env=True
+        ) as session:
             async with session.request(
                 setup.method,
                 setup.url,
@@ -66,13 +72,12 @@ class Mixin(ForwardMixin):
                 timeout=timeout,
                 proxy=setup.proxy,
             ) as response:
-                res = Response(
+                return Response(
                     response.status,
                     headers=response.headers.copy(),
                     content=await response.read(),
                     request=setup,
                 )
-                return res
 
     @overrides(ForwardMixin)
     @asynccontextmanager
@@ -92,8 +97,7 @@ class Mixin(ForwardMixin):
                 headers=setup.headers,
                 proxy=setup.proxy,
             ) as ws:
-                websocket = WebSocket(request=setup, session=session, websocket=ws)
-                yield websocket
+                yield WebSocket(request=setup, session=session, websocket=ws)
 
 
 class WebSocket(BaseWebSocket):
@@ -166,5 +170,5 @@ class WebSocket(BaseWebSocket):
         await self.websocket.send_bytes(data)
 
 
-Driver: Type[ForwardDriver] = combine_driver(BlockDriver, Mixin)  # type: ignore
+Driver: Type[ForwardDriver] = combine_driver(NoneDriver, Mixin)  # type: ignore
 """AIOHTTP Driver"""

nonebot/drivers/fastapi.py

@@ -1,5 +1,11 @@
 """[FastAPI](https://fastapi.tiangolo.com/) 驱动适配
 
+```bash
+nb driver install fastapi
+# 或者
+pip install nonebot2[fastapi]
+```
+
 :::tip 提示
 本驱动仅支持服务端连接
 :::
@@ -9,15 +15,13 @@ FrontMatter:
     description: nonebot.drivers.fastapi 模块
 """
 
-import logging
-from functools import wraps
-from typing import Any, List, Tuple, Union, Callable, Optional
 
-import uvicorn
+import logging
+import contextlib
+from functools import wraps
+from typing import Any, Dict, List, Tuple, Union, Callable, Optional
+
 from pydantic import BaseSettings
-from fastapi.responses import Response
-from fastapi import FastAPI, Request, UploadFile, status
-from starlette.websockets import WebSocket, WebSocketState, WebSocketDisconnect
 
 from nonebot.config import Env
 from nonebot.typing import overrides
@@ -28,6 +32,16 @@ from nonebot.drivers import Request as BaseRequest
 from nonebot.drivers import WebSocket as BaseWebSocket
 from nonebot.drivers import ReverseDriver, HTTPServerSetup, WebSocketServerSetup
 
+try:
+    import uvicorn
+    from fastapi.responses import Response
+    from fastapi import FastAPI, Request, UploadFile, status
+    from starlette.websockets import WebSocket, WebSocketState, WebSocketDisconnect
+except ImportError:  # pragma: no cover
+    raise ImportError(
+        "Please install FastAPI by using `pip install nonebot2[fastapi]`"
+    ) from None
+
 
 def catch_closed(func):
     @wraps(func)
@@ -57,12 +71,14 @@ class Config(BaseSettings):
     """开启/关闭冷重载"""
     fastapi_reload_dirs: Optional[List[str]] = None
     """重载监控文件夹列表，默认为 uvicorn 默认值"""
-    fastapi_reload_delay: Optional[float] = None
+    fastapi_reload_delay: float = 0.25
     """重载延迟，默认为 uvicorn 默认值"""
     fastapi_reload_includes: Optional[List[str]] = None
     """要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值"""
     fastapi_reload_excludes: Optional[List[str]] = None
     """不要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值"""
+    fastapi_extra: Dict[str, Any] = {}
+    """传递给 `FastAPI` 的其他参数。"""
 
     class Config:
         extra = "ignore"
@@ -80,6 +96,7 @@ class Driver(ReverseDriver):
             openapi_url=self.fastapi_config.fastapi_openapi_url,
             docs_url=self.fastapi_config.fastapi_docs_url,
             redoc_url=self.fastapi_config.fastapi_redoc_url,
+            **self.fastapi_config.fastapi_extra,
         )
 
     @property
@@ -186,14 +203,12 @@ class Driver(ReverseDriver):
         setup: HTTPServerSetup,
     ) -> Response:
         json: Any = None
-        try:
+        with contextlib.suppress(Exception):
             json = await request.json()
-        except Exception:
-            pass
 
         data: Optional[dict] = None
         files: Optional[List[Tuple[str, FileTypes]]] = None
-        try:
+        with contextlib.suppress(Exception):
             form = await request.form()
             data = {}
             files = []
@@ -204,8 +219,7 @@ class Driver(ReverseDriver):
                     )
                 else:
                     data[key] = value
-        except Exception:
-            pass
+
         http_request = BaseRequest(
             request.method,
             str(request.url),
@@ -219,7 +233,9 @@ class Driver(ReverseDriver):
         )
 
         response = await setup.handle_func(http_request)
-        return Response(response.content, response.status_code, dict(response.headers))
+        return Response(
+            response.content, response.status_code, dict(response.headers.items())
+        )
 
     async def _handle_ws(self, websocket: WebSocket, setup: WebSocketServerSetup):
         request = BaseRequest(
@@ -261,7 +277,7 @@ class FastAPIWebSocket(BaseWebSocket):
     async def close(
         self, code: int = status.WS_1000_NORMAL_CLOSURE, reason: str = ""
     ) -> None:
-        await self.websocket.close(code)
+        await self.websocket.close(code, reason)
 
     @overrides(BaseWebSocket)
     async def receive(self) -> Union[str, bytes]:

nonebot/drivers/httpx.py

@@ -18,7 +18,7 @@ from typing import Type, AsyncGenerator
 from contextlib import asynccontextmanager
 
 from nonebot.typing import overrides
-from nonebot.drivers._block_driver import BlockDriver
+from nonebot.drivers.none import Driver as NoneDriver
 from nonebot.drivers import (
     Request,
     Response,
@@ -31,7 +31,7 @@ from nonebot.drivers import (
 
 try:
     import httpx
-except ImportError:
+except ImportError:  # pragma: no cover
     raise ImportError(
         "Please install httpx by using `pip install nonebot2[httpx]`"
     ) from None
@@ -48,17 +48,18 @@ class Mixin(ForwardMixin):
     @overrides(ForwardMixin)
     async def request(self, setup: Request) -> Response:
         async with httpx.AsyncClient(
+            cookies=setup.cookies.jar,
             http2=setup.version == HTTPVersion.H2,
-            proxies=setup.proxy,  # type: ignore
+            proxies=setup.proxy,
             follow_redirects=True,
         ) as client:
             response = await client.request(
                 setup.method,
                 str(setup.url),
-                content=setup.content,  # type: ignore
-                data=setup.data,  # type: ignore
+                content=setup.content,
+                data=setup.data,
                 json=setup.json,
-                files=setup.files,  # type: ignore
+                files=setup.files,
                 headers=tuple(setup.headers.items()),
                 timeout=setup.timeout,
             )
@@ -76,5 +77,5 @@ class Mixin(ForwardMixin):
             yield ws
 
 
-Driver: Type[ForwardDriver] = combine_driver(BlockDriver, Mixin)  # type: ignore
+Driver: Type[ForwardDriver] = combine_driver(NoneDriver, Mixin)  # type: ignore
 """HTTPX Driver"""

nonebot/drivers/none.py

@@ -1,75 +1,94 @@
+"""None 驱动适配
+
+:::tip 提示
+本驱动不支持任何服务器或客户端连接
+:::
+
+FrontMatter:
+    sidebar_position: 6
+    description: nonebot.drivers.none 模块
+"""
+
+
 import signal
 import asyncio
 import threading
-from typing import Set, Callable, Awaitable
+from typing import Set, Union, Callable, Awaitable, cast
 
 from nonebot.log import logger
-from nonebot.drivers import Driver
 from nonebot.typing import overrides
 from nonebot.config import Env, Config
+from nonebot.drivers import Driver as BaseDriver
+from nonebot.utils import run_sync, is_coroutine_callable
 
-STARTUP_FUNC = Callable[[], Awaitable[None]]
-SHUTDOWN_FUNC = Callable[[], Awaitable[None]]
+HOOK_FUNC = Union[Callable[[], None], Callable[[], Awaitable[None]]]
 HANDLED_SIGNALS = (
     signal.SIGINT,  # Unix signal 2. Sent by Ctrl+C.
     signal.SIGTERM,  # Unix signal 15. Sent by `kill <pid>`.
 )
 
 
-class BlockDriver(Driver):
+class Driver(BaseDriver):
+    """None 驱动框架"""
+
     def __init__(self, env: Env, config: Config):
         super().__init__(env, config)
-        self.startup_funcs: Set[STARTUP_FUNC] = set()
-        self.shutdown_funcs: Set[SHUTDOWN_FUNC] = set()
+        self.startup_funcs: Set[HOOK_FUNC] = set()
+        self.shutdown_funcs: Set[HOOK_FUNC] = set()
         self.should_exit: asyncio.Event = asyncio.Event()
         self.force_exit: bool = False
 
     @property
-    @overrides(Driver)
+    @overrides(BaseDriver)
     def type(self) -> str:
-        """驱动名称: `block_driver`"""
-        return "block_driver"
+        """驱动名称: `none`"""
+        return "none"
 
     @property
-    @overrides(Driver)
+    @overrides(BaseDriver)
     def logger(self):
-        """block driver 使用的 logger"""
+        """none driver 使用的 logger"""
         return logger
 
-    @overrides(Driver)
-    def on_startup(self, func: STARTUP_FUNC) -> STARTUP_FUNC:
+    @overrides(BaseDriver)
+    def on_startup(self, func: HOOK_FUNC) -> HOOK_FUNC:
         """
         注册一个启动时执行的函数
         """
         self.startup_funcs.add(func)
         return func
 
-    @overrides(Driver)
-    def on_shutdown(self, func: SHUTDOWN_FUNC) -> SHUTDOWN_FUNC:
+    @overrides(BaseDriver)
+    def on_shutdown(self, func: HOOK_FUNC) -> HOOK_FUNC:
         """
         注册一个停止时执行的函数
         """
         self.shutdown_funcs.add(func)
         return func
 
-    @overrides(Driver)
+    @overrides(BaseDriver)
     def run(self, *args, **kwargs):
-        """启动 block driver"""
+        """启动 none driver"""
         super().run(*args, **kwargs)
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self.serve())
+        loop.run_until_complete(self._serve())
 
-    async def serve(self):
-        self.install_signal_handlers()
-        await self.startup()
+    async def _serve(self):
+        self._install_signal_handlers()
+        await self._startup()
         if self.should_exit.is_set():
             return
-        await self.main_loop()
-        await self.shutdown()
+        await self._main_loop()
+        await self._shutdown()
 
-    async def startup(self):
+    async def _startup(self):
         # run startup
-        cors = [startup() for startup in self.startup_funcs]
+        cors = [
+            cast(Callable[..., Awaitable[None]], startup)()
+            if is_coroutine_callable(startup)
+            else run_sync(startup)()
+            for startup in self.startup_funcs
+        ]
         if cors:
             try:
                 await asyncio.gather(*cors)
@@ -81,15 +100,20 @@ class BlockDriver(Driver):
 
         logger.info("Application startup completed.")
 
-    async def main_loop(self):
+    async def _main_loop(self):
         await self.should_exit.wait()
 
-    async def shutdown(self):
+    async def _shutdown(self):
         logger.info("Shutting down")
 
         logger.info("Waiting for application shutdown.")
         # run shutdown
-        cors = [shutdown() for shutdown in self.shutdown_funcs]
+        cors = [
+            cast(Callable[..., Awaitable[None]], shutdown)()
+            if is_coroutine_callable(shutdown)
+            else run_sync(shutdown)()
+            for shutdown in self.shutdown_funcs
+        ]
         if cors:
             try:
                 await asyncio.gather(*cors)
@@ -120,7 +144,7 @@ class BlockDriver(Driver):
         loop = asyncio.get_event_loop()
         loop.stop()
 
-    def install_signal_handlers(self) -> None:
+    def _install_signal_handlers(self) -> None:
         if threading.current_thread() is not threading.main_thread():
             # Signals can only be listened to from the main thread.
             return
@@ -129,13 +153,13 @@ class BlockDriver(Driver):
 
         try:
             for sig in HANDLED_SIGNALS:
-                loop.add_signal_handler(sig, self.handle_exit, sig, None)
+                loop.add_signal_handler(sig, self._handle_exit, sig, None)
         except NotImplementedError:
             # Windows
             for sig in HANDLED_SIGNALS:
-                signal.signal(sig, self.handle_exit)
+                signal.signal(sig, self._handle_exit)
 
-    def handle_exit(self, sig, frame):
+    def _handle_exit(self, sig, frame):
         if self.should_exit.is_set():
             self.force_exit = True
         else:

nonebot/drivers/quart.py

@@ -17,9 +17,8 @@ FrontMatter:
 
 import asyncio
 from functools import wraps
-from typing import List, Tuple, Union, TypeVar, Callable, Optional, Coroutine
+from typing import Any, Dict, List, Tuple, Union, TypeVar, Callable, Optional, Coroutine
 
-import uvicorn
 from pydantic import BaseSettings
 
 from nonebot.config import Env
@@ -32,12 +31,13 @@ from nonebot.drivers import WebSocket as BaseWebSocket
 from nonebot.drivers import ReverseDriver, HTTPServerSetup, WebSocketServerSetup
 
 try:
+    import uvicorn
     from quart import request as _request
     from quart import websocket as _websocket
     from quart import Quart, Request, Response
     from quart.datastructures import FileStorage
     from quart import Websocket as QuartWebSocket
-except ImportError:
+except ImportError:  # pragma: no cover
     raise ImportError(
         "Please install Quart by using `pip install nonebot2[quart]`"
     ) from None
@@ -63,12 +63,14 @@ class Config(BaseSettings):
     """开启/关闭冷重载"""
     quart_reload_dirs: Optional[List[str]] = None
     """重载监控文件夹列表，默认为 uvicorn 默认值"""
-    quart_reload_delay: Optional[float] = None
+    quart_reload_delay: float = 0.25
     """重载延迟，默认为 uvicorn 默认值"""
     quart_reload_includes: Optional[List[str]] = None
     """要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值"""
     quart_reload_excludes: Optional[List[str]] = None
     """不要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值"""
+    quart_extra: Dict[str, Any] = {}
+    """传递给 `Quart` 的其他参数。"""
 
     class Config:
         extra = "ignore"
@@ -82,7 +84,9 @@ class Driver(ReverseDriver):
 
         self.quart_config = Config(**config.dict())
 
-        self._server_app = Quart(self.__class__.__qualname__)
+        self._server_app = Quart(
+            self.__class__.__qualname__, **self.quart_config.quart_extra
+        )
 
     @property
     @overrides(ReverseDriver)

nonebot/drivers/websockets.py

@@ -23,17 +23,17 @@ from nonebot.typing import overrides
 from nonebot.log import LoguruHandler
 from nonebot.drivers import Request, Response
 from nonebot.exception import WebSocketClosed
-from nonebot.drivers._block_driver import BlockDriver
+from nonebot.drivers.none import Driver as NoneDriver
 from nonebot.drivers import WebSocket as BaseWebSocket
 from nonebot.drivers import ForwardMixin, ForwardDriver, combine_driver
 
 try:
     from websockets.exceptions import ConnectionClosed
     from websockets.legacy.client import Connect, WebSocketClientProtocol
-except ImportError:
+except ImportError:  # pragma: no cover
     raise ImportError(
         "Please install websockets by using `pip install nonebot2[websockets]`"
-    )
+    ) from None
 
 logger = logging.Logger("websockets.client", "INFO")
 logger.addHandler(LoguruHandler())
@@ -70,7 +70,7 @@ class Mixin(ForwardMixin):
     async def websocket(self, setup: Request) -> AsyncGenerator["WebSocket", None]:
         connection = Connect(
             str(setup.url),
-            extra_headers=setup.headers.items(),
+            extra_headers={**setup.headers, **setup.cookies.as_header(setup)},
             open_timeout=setup.timeout,
         )
         async with connection as ws:
@@ -101,8 +101,7 @@ class WebSocket(BaseWebSocket):
     @overrides(BaseWebSocket)
     @catch_closed
     async def receive(self) -> Union[str, bytes]:
-        msg = await self.websocket.recv()
-        return msg
+        return await self.websocket.recv()
 
     @overrides(BaseWebSocket)
     @catch_closed
@@ -129,5 +128,5 @@ class WebSocket(BaseWebSocket):
         await self.websocket.send(data)
 
 
-Driver: Type[ForwardDriver] = combine_driver(BlockDriver, Mixin)  # type: ignore
+Driver: Type[ForwardDriver] = combine_driver(NoneDriver, Mixin)  # type: ignore
 """Websockets Driver"""

nonebot/exception.py

@@ -37,6 +37,9 @@ from pydantic.fields import ModelField
 class NoneBotException(Exception):
     """所有 NoneBot 发生的异常基类。"""
 
+    def __str__(self) -> str:
+        return self.__repr__()
+
 
 # Rule Exception
 class ParserExit(NoneBotException):
@@ -46,11 +49,12 @@ class ParserExit(NoneBotException):
         self.status = status
         self.message = message
 
-    def __repr__(self):
-        return f"<ParserExit status={self.status} message={self.message}>"
-
-    def __str__(self):
-        return self.__repr__()
+    def __repr__(self) -> str:
+        return (
+            f"ParserExit(status={self.status}"
+            + (f", message={self.message!r}" if self.message else "")
+            + ")"
+        )
 
 
 # Processor Exception
@@ -68,11 +72,8 @@ class IgnoredException(ProcessException):
     def __init__(self, reason: Any):
         self.reason: Any = reason
 
-    def __repr__(self):
-        return f"<IgnoredException, reason={self.reason}>"
-
-    def __str__(self):
-        return self.__repr__()
+    def __repr__(self) -> str:
+        return f"IgnoredException(reason={self.reason!r})"
 
 
 class SkippedException(ProcessException):
@@ -99,11 +100,11 @@ class TypeMisMatch(SkippedException):
         self.param: ModelField = param
         self.value: Any = value
 
-    def __repr__(self):
-        return f"<TypeMisMatch, param={self.param}, value={self.value}>"
-
-    def __str__(self):
-        self.__repr__()
+    def __repr__(self) -> str:
+        return (
+            f"TypeMisMatch(param={self.param.name}, "
+            f"type={self.param._type_display()}, value={self.value!r}>"
+        )
 
 
 class MockApiException(ProcessException):
@@ -116,11 +117,8 @@ class MockApiException(ProcessException):
     def __init__(self, result: Any):
         self.result = result
 
-    def __repr__(self):
-        return f"<ApiCancelledException, result={self.result}>"
-
-    def __str__(self):
-        return self.__repr__()
+    def __repr__(self) -> str:
+        return f"MockApiException(result={self.result!r})"
 
 
 class StopPropagation(ProcessException):
@@ -195,7 +193,8 @@ class AdapterException(NoneBotException):
         adapter_name: 标识 adapter
     """
 
-    def __init__(self, adapter_name: str) -> None:
+    def __init__(self, adapter_name: str, *args: object) -> None:
+        super().__init__(*args)
         self.adapter_name: str = adapter_name
 
 
@@ -231,4 +230,8 @@ class WebSocketClosed(DriverException):
         self.reason = reason
 
     def __repr__(self) -> str:
-        return f"<WebSocketClosed code={self.code} reason={self.reason}>"
+        return (
+            f"WebSocketClosed(code={self.code}"
+            + (f", reason={self.reason!r}" if self.reason else "")
+            + ")"
+        )

nonebot/internal/adapter/adapter.py

@@ -33,6 +33,9 @@ class Adapter(abc.ABC):
         self.bots: Dict[str, Bot] = {}
         """本协议适配器已建立连接的 {ref}`nonebot.adapters.Bot` 实例"""
 
+    def __repr__(self) -> str:
+        return f"Adapter(name={self.get_name()!r})"
+
     @classmethod
     @abc.abstractmethod
     def get_name(cls) -> str:

nonebot/internal/adapter/bot.py

@@ -1,8 +1,7 @@
 import abc
 import asyncio
 from functools import partial
-from typing_extensions import Protocol
-from typing import TYPE_CHECKING, Any, Set, Union, Optional
+from typing import TYPE_CHECKING, Any, Set, Union, Optional, Protocol
 
 from nonebot.log import logger
 from nonebot.config import Config
@@ -14,10 +13,9 @@ if TYPE_CHECKING:
     from .adapter import Adapter
     from .message import Message, MessageSegment
 
-
-class _ApiCall(Protocol):
-    async def __call__(self, **kwargs: Any) -> Any:
-        ...
+    class _ApiCall(Protocol):
+        async def __call__(self, **kwargs: Any) -> Any:
+            ...
 
 
 class Bot(abc.ABC):
@@ -41,7 +39,14 @@ class Bot(abc.ABC):
         self.self_id: str = self_id
         """机器人 ID"""
 
-    def __getattr__(self, name: str) -> _ApiCall:
+    def __repr__(self) -> str:
+        return f"Bot(type={self.type!r}, self_id={self.self_id!r})"
+
+    def __getattr__(self, name: str) -> "_ApiCall":
+        if name.startswith("__") and name.endswith("__"):
+            raise AttributeError(
+                f"'{self.__class__.__name__}' object has no attribute '{name}'"
+            )
         return partial(self.call_api, name)
 
     @property
@@ -72,8 +77,7 @@ class Bot(abc.ABC):
         skip_calling_api: bool = False
         exception: Optional[Exception] = None
 
-        coros = list(map(lambda x: x(self, api, data), self._calling_api_hook))
-        if coros:
+        if coros := [hook(self, api, data) for hook in self._calling_api_hook]:
             try:
                 logger.debug("Running CallingAPI hooks...")
                 await asyncio.gather(*coros)
@@ -95,10 +99,9 @@ class Bot(abc.ABC):
             except Exception as e:
                 exception = e
 
-        coros = list(
-            map(lambda x: x(self, exception, api, data, result), self._called_api_hook)
-        )
-        if coros:
+        if coros := [
+            hook(self, exception, api, data, result) for hook in self._called_api_hook
+        ]:
             try:
                 logger.debug("Running CalledAPI hooks...")
                 await asyncio.gather(*coros)

nonebot/internal/adapter/event.py

@@ -1,4 +1,5 @@
 import abc
+from typing import Any, Type, TypeVar
 
 from pydantic import BaseModel
 
@@ -6,6 +7,8 @@ from nonebot.utils import DataclassEncoder
 
 from .message import Message
 
+E = TypeVar("E", bound="Event")
+
 
 class Event(abc.ABC, BaseModel):
     """Event 基类。提供获取关键信息的方法，其余信息可直接获取。"""
@@ -14,6 +17,12 @@ class Event(abc.ABC, BaseModel):
         extra = "allow"
         json_encoders = {Message: DataclassEncoder}
 
+    @classmethod
+    def validate(cls: Type["E"], value: Any) -> "E":
+        if isinstance(value, Event) and not isinstance(value, cls):
+            raise TypeError(f"{value} is incompatible with Event type {cls}")
+        return super().validate(value)
+
     @abc.abstractmethod
     def get_type(self) -> str:
         """获取事件类型的方法，类型通常为 NoneBot 内置的四种类型。"""

nonebot/internal/adapter/message.py

@@ -66,7 +66,11 @@ class MessageSegment(abc.ABC, Generic[TM]):
             return value
         if not isinstance(value, dict):
             raise ValueError(f"Expected dict for MessageSegment, got {type(value)}")
-        return cls(**value)
+        if "type" not in value:
+            raise ValueError(
+                f"Expected dict with 'type' for MessageSegment, got {value}"
+            )
+        return cls(type=value["type"], data=value.get("data", {}))
 
     def get(self, key: str, default: Any = None):
         return asdict(self).get(key, default)
@@ -182,7 +186,7 @@ class Message(List[TMS], abc.ABC):
         elif isinstance(other, Iterable):
             self.extend(other)
         else:
-            raise ValueError(f"Unsupported type: {type(other)}")  # pragma: no cover
+            raise TypeError(f"Unsupported type {type(other)!r}")
         return self
 
     @overload

nonebot/internal/adapter/template.py

@@ -49,13 +49,16 @@ class MessageTemplate(Formatter, Generic[TF]):
     ) -> None:
         ...
 
-    def __init__(  # type:ignore
-        self, template, factory=str
-    ) -> None:  # TODO: fix type hint here
-        self.template: TF = template
-        self.factory: Type[TF] = factory
+    def __init__(
+        self, template: Union[str, TM], factory: Union[Type[str], Type[TM]] = str
+    ) -> None:
+        self.template: TF = template  # type: ignore
+        self.factory: Type[TF] = factory  # type: ignore
         self.format_specs: Dict[str, FormatSpecFunc] = {}
 
+    def __repr__(self) -> str:
+        return f"MessageTemplate({self.template!r}, factory={self.factory!r})"
+
     def add_format_spec(
         self, spec: FormatSpecFunc_T, name: Optional[str] = None
     ) -> FormatSpecFunc_T:
@@ -95,7 +98,7 @@ class MessageTemplate(Formatter, Generic[TF]):
         else:
             raise TypeError("template must be a string or instance of Message!")
 
-        self.check_unused_args(list(used_args), args, kwargs)
+        self.check_unused_args(used_args, args, kwargs)
         return cast(TF, full_message)
 
     def vformat(

nonebot/internal/driver/driver.py

@@ -40,12 +40,18 @@ class Driver(abc.ABC):
         """环境名称"""
         self.config: Config = config
         """全局配置对象"""
-        self._clients: Dict[str, "Bot"] = {}
+        self._bots: Dict[str, "Bot"] = {}
+
+    def __repr__(self) -> str:
+        return (
+            f"Driver(type={self.type!r}, "
+            f"adapters={len(self._adapters)}, bots={len(self._bots)})"
+        )
 
     @property
     def bots(self) -> Dict[str, "Bot"]:
         """获取当前所有已连接的 Bot"""
-        return self._clients
+        return self._bots
 
     def register_adapter(self, adapter: Type["Adapter"], **kwargs) -> None:
         """注册一个协议适配器
@@ -124,9 +130,9 @@ class Driver(abc.ABC):
 
     def _bot_connect(self, bot: "Bot") -> None:
         """在连接成功后，调用该函数来注册 bot 对象"""
-        if bot.self_id in self._clients:
+        if bot.self_id in self._bots:
             raise RuntimeError(f"Duplicate bot connection with id {bot.self_id}")
-        self._clients[bot.self_id] = bot
+        self._bots[bot.self_id] = bot
 
         async def _run_hook(bot: "Bot") -> None:
             coros = list(
@@ -148,8 +154,8 @@ class Driver(abc.ABC):
 
     def _bot_disconnect(self, bot: "Bot") -> None:
         """在连接断开后，调用该函数来注销 bot 对象"""
-        if bot.self_id in self._clients:
-            del self._clients[bot.self_id]
+        if bot.self_id in self._bots:
+            del self._bots[bot.self_id]
 
         async def _run_hook(bot: "Bot") -> None:
             coros = list(
@@ -233,13 +239,11 @@ def combine_driver(driver: Type[Driver], *mixins: Type[ForwardMixin]) -> Type[Dr
     if not mixins:
         return driver
 
-    class CombinedDriver(*mixins, driver, ForwardDriver):  # type: ignore
-        @property
-        def type(self) -> str:
-            return (
-                driver.type.__get__(self)
-                + "+"
-                + "+".join(map(lambda x: x.type.__get__(self), mixins))
-            )
+    def type_(self: ForwardDriver) -> str:
+        return (
+            driver.type.__get__(self)
+            + "+"
+            + "+".join(map(lambda x: x.type.__get__(self), mixins))
+        )
 
-    return CombinedDriver
+    return type("CombinedDriver", (*mixins, driver, ForwardDriver), {"type": property(type_)})  # type: ignore

nonebot/internal/driver/model.py

@@ -1,4 +1,5 @@
 import abc
+import urllib.request
 from enum import Enum
 from dataclasses import dataclass
 from http.cookiejar import Cookie, CookieJar
@@ -105,12 +106,9 @@ class Request:
         self.url: URL = url
 
         # headers
-        self.headers: CIMultiDict[str]
-        if headers is not None:
-            self.headers = CIMultiDict(headers)
-        else:
-            self.headers = CIMultiDict()
-
+        self.headers: CIMultiDict[str] = (
+            CIMultiDict(headers) if headers is not None else CIMultiDict()
+        )
         # cookies
         self.cookies = Cookies(cookies)
 
@@ -131,9 +129,7 @@ class Request:
                     self.files.append((name, file_info))  # type: ignore
 
     def __repr__(self) -> str:
-        class_name = self.__class__.__name__
-        url = str(self.url)
-        return f"<{class_name}({self.method!r}, {url!r})>"
+        return f"{self.__class__.__name__}(method={self.method!r}, url='{self.url!s}')"
 
 
 class Response:
@@ -149,24 +145,27 @@ class Response:
         self.status_code: int = status_code
 
         # headers
-        self.headers: CIMultiDict[str]
-        if headers is not None:
-            self.headers = CIMultiDict(headers)
-        else:
-            self.headers = CIMultiDict()
-
+        self.headers: CIMultiDict[str] = (
+            CIMultiDict(headers) if headers is not None else CIMultiDict()
+        )
         # body
         self.content: ContentTypes = content
 
         # request
         self.request: Optional[Request] = request
 
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(status_code={self.status_code!r})"
+
 
 class WebSocket(abc.ABC):
     def __init__(self, *, request: Request):
         # request
         self.request: Request = request
 
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}('{self.request.url!s}')"
+
     @property
     @abc.abstractmethod
     def closed(self) -> bool:
@@ -304,6 +303,11 @@ class Cookies(MutableMapping):
         for cookie in cookies.jar:
             self.jar.set_cookie(cookie)
 
+    def as_header(self, request: Request) -> Dict[str, str]:
+        urllib_request = self._CookieCompatRequest(request)
+        self.jar.add_cookie_header(urllib_request)
+        return urllib_request.added_headers
+
     def __setitem__(self, name: str, value: str) -> None:
         return self.set(name, value)
 
@@ -320,17 +324,28 @@ class Cookies(MutableMapping):
         return len(self.jar)
 
     def __iter__(self) -> Iterator[Cookie]:
-        return (cookie for cookie in self.jar)
+        return iter(self.jar)
 
     def __repr__(self) -> str:
         cookies_repr = ", ".join(
-            [
-                f"<Cookie {cookie.name}={cookie.value} for {cookie.domain} />"
-                for cookie in self.jar
-            ]
+            f"Cookie({cookie.name}={cookie.value} for {cookie.domain})"
+            for cookie in self.jar
         )
+        return f"{self.__class__.__name__}({cookies_repr})"
 
-        return f"<Cookies [{cookies_repr}]>"
+    class _CookieCompatRequest(urllib.request.Request):
+        def __init__(self, request: Request) -> None:
+            super().__init__(
+                url=str(request.url),
+                headers=dict(request.headers),
+                method=request.method,
+            )
+            self.request = request
+            self.added_headers: Dict[str, str] = {}
+
+        def add_unredirected_header(self, key: str, value: str) -> None:
+            super().add_unredirected_header(key, value)
+            self.added_headers[key] = value
 
 
 @dataclass

nonebot/internal/matcher/__init__.py

@@ -0,0 +1,11 @@
+from .manager import MatcherManager as MatcherManager
+from .provider import MatcherProvider as MatcherProvider
+from .provider import DEFAULT_PROVIDER_CLASS as DEFAULT_PROVIDER_CLASS
+
+matchers = MatcherManager()
+
+from .matcher import Matcher as Matcher
+from .matcher import current_bot as current_bot
+from .matcher import current_event as current_event
+from .matcher import current_handler as current_handler
+from .matcher import current_matcher as current_matcher

nonebot/internal/matcher/manager.py

@@ -0,0 +1,104 @@
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    List,
+    Type,
+    Tuple,
+    Union,
+    TypeVar,
+    Iterator,
+    KeysView,
+    Optional,
+    ItemsView,
+    ValuesView,
+    MutableMapping,
+    overload,
+)
+
+from .provider import DEFAULT_PROVIDER_CLASS, MatcherProvider
+
+if TYPE_CHECKING:
+    from .matcher import Matcher
+
+T = TypeVar("T")
+
+
+class MatcherManager(MutableMapping[int, List[Type["Matcher"]]]):
+    """事件响应器管理器
+
+    实现了常用字典操作，用于管理事件响应器。
+    """
+
+    def __init__(self):
+        self.provider: MatcherProvider = DEFAULT_PROVIDER_CLASS({})
+
+    def __repr__(self) -> str:
+        return f"MatcherManager(provider={self.provider!r})"
+
+    def __contains__(self, o: object) -> bool:
+        return o in self.provider
+
+    def __iter__(self) -> Iterator[int]:
+        return iter(self.provider)
+
+    def __len__(self) -> int:
+        return len(self.provider)
+
+    def __getitem__(self, key: int) -> List[Type["Matcher"]]:
+        return self.provider[key]
+
+    def __setitem__(self, key: int, value: List[Type["Matcher"]]) -> None:
+        self.provider[key] = value
+
+    def __delitem__(self, key: int) -> None:
+        del self.provider[key]
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, MatcherManager) and self.provider == other.provider
+
+    def keys(self) -> KeysView[int]:
+        return self.provider.keys()
+
+    def values(self) -> ValuesView[List[Type["Matcher"]]]:
+        return self.provider.values()
+
+    def items(self) -> ItemsView[int, List[Type["Matcher"]]]:
+        return self.provider.items()
+
+    @overload
+    def get(self, key: int) -> Optional[List[Type["Matcher"]]]:
+        ...
+
+    @overload
+    def get(self, key: int, default: T) -> Union[List[Type["Matcher"]], T]:
+        ...
+
+    def get(
+        self, key: int, default: Optional[T] = None
+    ) -> Optional[Union[List[Type["Matcher"]], T]]:
+        return self.provider.get(key, default)
+
+    def pop(self, key: int) -> List[Type["Matcher"]]:
+        return self.provider.pop(key)
+
+    def popitem(self) -> Tuple[int, List[Type["Matcher"]]]:
+        return self.provider.popitem()
+
+    def clear(self) -> None:
+        self.provider.clear()
+
+    def update(self, __m: MutableMapping[int, List[Type["Matcher"]]]) -> None:
+        self.provider.update(__m)
+
+    def setdefault(
+        self, key: int, default: List[Type["Matcher"]]
+    ) -> List[Type["Matcher"]]:
+        return self.provider.setdefault(key, default)
+
+    def set_provider(self, provider_class: Type[MatcherProvider]) -> None:
+        """设置事件响应器存储器
+
+        参数:
+            provider_class: 事件响应器存储器类
+        """
+        self.provider = provider_class(self.provider)

nonebot/internal/matcher/matcher.py

@@ -1,23 +1,32 @@
 from types import ModuleType
-from datetime import datetime
 from contextvars import ContextVar
-from collections import defaultdict
-from contextlib import AsyncExitStack
+from datetime import datetime, timedelta
+from contextlib import AsyncExitStack, contextmanager
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
     List,
     Type,
     Union,
     TypeVar,
     Callable,
+    Iterable,
     NoReturn,
     Optional,
+    overload,
 )
 
 from nonebot.log import logger
+from nonebot.internal.rule import Rule
 from nonebot.dependencies import Dependent
+from nonebot.internal.permission import USER, User, Permission
+from nonebot.internal.adapter import (
+    Bot,
+    Event,
+    Message,
+    MessageSegment,
+    MessageTemplate,
+)
 from nonebot.consts import (
     ARG_KEY,
     RECEIVE_KEY,
@@ -34,18 +43,13 @@ from nonebot.typing import (
     T_PermissionUpdater,
 )
 from nonebot.exception import (
-    TypeMisMatch,
     PausedException,
     StopPropagation,
     SkippedException,
     FinishedException,
     RejectedException,
 )
-
-from .rule import Rule
-from .permission import USER, Permission
-from .adapter import Bot, Event, Message, MessageSegment, MessageTemplate
-from .params import (
+from nonebot.internal.params import (
     Depends,
     ArgParam,
     BotParam,
@@ -56,13 +60,13 @@ from .params import (
     MatcherParam,
 )
 
+from . import matchers
+
 if TYPE_CHECKING:
     from nonebot.plugin import Plugin
 
 T = TypeVar("T")
 
-matchers: Dict[int, List[Type["Matcher"]]] = defaultdict(list)
-"""用于存储当前所有的事件响应器"""
 current_bot: ContextVar[Bot] = ContextVar("current_bot")
 current_event: ContextVar[Event] = ContextVar("current_event")
 current_matcher: ContextVar["Matcher"] = ContextVar("current_matcher")
@@ -71,29 +75,16 @@ current_handler: ContextVar[Dependent] = ContextVar("current_handler")
 
 class MatcherMeta(type):
     if TYPE_CHECKING:
-        module: Optional[str]
-        plugin_name: Optional[str]
         module_name: Optional[str]
-        module_prefix: Optional[str]
         type: str
-        rule: Rule
-        permission: Permission
-        handlers: List[T_Handler]
-        priority: int
-        block: bool
-        temp: bool
-        expire_time: Optional[datetime]
 
     def __repr__(self) -> str:
         return (
-            f"<Matcher from {self.module_name or 'unknown'}, "
-            f"type={self.type}, priority={self.priority}, "
-            f"temp={self.temp}>"
+            f"Matcher(type={self.type!r}"
+            + (f", module={self.module_name}" if self.module_name else "")
+            + ")"
         )
 
-    def __str__(self) -> str:
-        return repr(self)
-
 
 class Matcher(metaclass=MatcherMeta):
     """事件响应器类"""
@@ -132,7 +123,7 @@ class Matcher(metaclass=MatcherMeta):
     _default_permission_updater: Optional[Dependent[Permission]] = None
     """事件响应器权限更新函数"""
 
-    HANDLER_PARAM_TYPES = [
+    HANDLER_PARAM_TYPES = (
         DependParam,
         BotParam,
         EventParam,
@@ -140,7 +131,7 @@ class Matcher(metaclass=MatcherMeta):
         ArgParam,
         MatcherParam,
         DefaultParam,
-    ]
+    )
 
     def __init__(self):
         self.handlers = self.handlers.copy()
@@ -148,13 +139,11 @@ class Matcher(metaclass=MatcherMeta):
 
     def __repr__(self) -> str:
         return (
-            f"<Matcher from {self.module_name or 'unknown'}, type={self.type}, "
-            f"priority={self.priority}, temp={self.temp}>"
+            f"Matcher(type={self.type!r}"
+            + (f", module={self.module_name}" if self.module_name else "")
+            + ")"
         )
 
-    def __str__(self) -> str:
-        return repr(self)
-
     @classmethod
     def new(
         cls,
@@ -168,7 +157,7 @@ class Matcher(metaclass=MatcherMeta):
         *,
         plugin: Optional["Plugin"] = None,
         module: Optional[ModuleType] = None,
-        expire_time: Optional[datetime] = None,
+        expire_time: Optional[Union[datetime, timedelta]] = None,
         default_state: Optional[T_State] = None,
         default_type_updater: Optional[Union[T_TypeUpdater, Dependent[str]]] = None,
         default_permission_updater: Optional[
@@ -216,25 +205,37 @@ class Matcher(metaclass=MatcherMeta):
                 if handlers
                 else [],
                 "temp": temp,
-                "expire_time": expire_time,
+                "expire_time": (
+                    expire_time
+                    and (
+                        expire_time
+                        if isinstance(expire_time, datetime)
+                        else datetime.now() + expire_time
+                    )
+                ),
                 "priority": priority,
                 "block": block,
                 "_default_state": default_state or {},
                 "_default_type_updater": (
                     default_type_updater
-                    if isinstance(default_type_updater, Dependent)
-                    else default_type_updater
-                    and Dependent[str].parse(
-                        call=default_type_updater, allow_types=cls.HANDLER_PARAM_TYPES
+                    and (
+                        default_type_updater
+                        if isinstance(default_type_updater, Dependent)
+                        else Dependent[str].parse(
+                            call=default_type_updater,
+                            allow_types=cls.HANDLER_PARAM_TYPES,
+                        )
                     )
                 ),
                 "_default_permission_updater": (
                     default_permission_updater
-                    if isinstance(default_permission_updater, Dependent)
-                    else default_permission_updater
-                    and Dependent[Permission].parse(
-                        call=default_permission_updater,
-                        allow_types=cls.HANDLER_PARAM_TYPES,
+                    and (
+                        default_permission_updater
+                        if isinstance(default_permission_updater, Dependent)
+                        else Dependent[Permission].parse(
+                            call=default_permission_updater,
+                            allow_types=cls.HANDLER_PARAM_TYPES,
+                        )
                     )
                 ),
             },
@@ -246,6 +247,11 @@ class Matcher(metaclass=MatcherMeta):
 
         return NewMatcher
 
+    @classmethod
+    def destroy(cls) -> None:
+        """销毁当前的事件响应器"""
+        matchers[cls.priority].remove(cls)
+
     @classmethod
     async def check_perm(
         cls,
@@ -322,7 +328,7 @@ class Matcher(metaclass=MatcherMeta):
 
     @classmethod
     def append_handler(
-        cls, handler: T_Handler, parameterless: Optional[List[Any]] = None
+        cls, handler: T_Handler, parameterless: Optional[Iterable[Any]] = None
     ) -> Dependent[Any]:
         handler_ = Dependent[Any].parse(
             call=handler,
@@ -334,7 +340,7 @@ class Matcher(metaclass=MatcherMeta):
 
     @classmethod
     def handle(
-        cls, parameterless: Optional[List[Any]] = None
+        cls, parameterless: Optional[Iterable[Any]] = None
     ) -> Callable[[T_Handler], T_Handler]:
         """装饰一个函数来向事件响应器直接添加一个处理函数
 
@@ -350,7 +356,7 @@ class Matcher(metaclass=MatcherMeta):
 
     @classmethod
     def receive(
-        cls, id: str = "", parameterless: Optional[List[Any]] = None
+        cls, id: str = "", parameterless: Optional[Iterable[Any]] = None
     ) -> Callable[[T_Handler], T_Handler]:
         """装饰一个函数来指示 NoneBot 在接收用户新的一条消息后继续运行该函数
 
@@ -368,14 +374,21 @@ class Matcher(metaclass=MatcherMeta):
                 return
             await matcher.reject()
 
-        _parameterless = [Depends(_receive), *(parameterless or [])]
+        _parameterless = (Depends(_receive), *(parameterless or tuple()))
 
         def _decorator(func: T_Handler) -> T_Handler:
 
             if cls.handlers and cls.handlers[-1].call is func:
                 func_handler = cls.handlers[-1]
-                for depend in reversed(_parameterless):
-                    func_handler.prepend_parameterless(depend)
+                new_handler = Dependent(
+                    call=func_handler.call,
+                    params=func_handler.params,
+                    parameterless=Dependent.parse_parameterless(
+                        tuple(_parameterless), cls.HANDLER_PARAM_TYPES
+                    )
+                    + func_handler.parameterless,
+                )
+                cls.handlers[-1] = new_handler
             else:
                 cls.append_handler(func, parameterless=_parameterless)
 
@@ -388,7 +401,7 @@ class Matcher(metaclass=MatcherMeta):
         cls,
         key: str,
         prompt: Optional[Union[str, Message, MessageSegment, MessageTemplate]] = None,
-        parameterless: Optional[List[Any]] = None,
+        parameterless: Optional[Iterable[Any]] = None,
     ) -> Callable[[T_Handler], T_Handler]:
         """装饰一个函数来指示 NoneBot 获取一个参数 `key`
 
@@ -409,17 +422,21 @@ class Matcher(metaclass=MatcherMeta):
                 return
             await matcher.reject(prompt)
 
-        _parameterless = [
-            Depends(_key_getter),
-            *(parameterless or []),
-        ]
+        _parameterless = (Depends(_key_getter), *(parameterless or tuple()))
 
         def _decorator(func: T_Handler) -> T_Handler:
 
             if cls.handlers and cls.handlers[-1].call is func:
                 func_handler = cls.handlers[-1]
-                for depend in reversed(_parameterless):
-                    func_handler.prepend_parameterless(depend)
+                new_handler = Dependent(
+                    call=func_handler.call,
+                    params=func_handler.params,
+                    parameterless=Dependent.parse_parameterless(
+                        tuple(_parameterless), cls.HANDLER_PARAM_TYPES
+                    )
+                    + func_handler.parameterless,
+                )
+                cls.handlers[-1] = new_handler
             else:
                 cls.append_handler(func, parameterless=_parameterless)
 
@@ -547,7 +564,17 @@ class Matcher(metaclass=MatcherMeta):
         """
         raise SkippedException
 
-    def get_receive(self, id: str, default: T = None) -> Union[Event, T]:
+    @overload
+    def get_receive(self, id: str) -> Union[Event, None]:
+        ...
+
+    @overload
+    def get_receive(self, id: str, default: T) -> Union[Event, T]:
+        ...
+
+    def get_receive(
+        self, id: str, default: Optional[T] = None
+    ) -> Optional[Union[Event, T]]:
         """获取一个 `receive` 事件
 
         如果没有找到对应的事件，返回 `default` 值
@@ -559,14 +586,34 @@ class Matcher(metaclass=MatcherMeta):
         self.state[RECEIVE_KEY.format(id=id)] = event
         self.state[LAST_RECEIVE_KEY] = event
 
-    def get_last_receive(self, default: T = None) -> Union[Event, T]:
+    @overload
+    def get_last_receive(self) -> Union[Event, None]:
+        ...
+
+    @overload
+    def get_last_receive(self, default: T) -> Union[Event, T]:
+        ...
+
+    def get_last_receive(
+        self, default: Optional[T] = None
+    ) -> Optional[Union[Event, T]]:
         """获取最近一次 `receive` 事件
 
         如果没有事件，返回 `default` 值
         """
         return self.state.get(LAST_RECEIVE_KEY, default)
 
-    def get_arg(self, key: str, default: T = None) -> Union[Message, T]:
+    @overload
+    def get_arg(self, key: str) -> Union[Message, None]:
+        ...
+
+    @overload
+    def get_arg(self, key: str, default: T) -> Union[Message, T]:
+        ...
+
+    def get_arg(
+        self, key: str, default: Optional[T] = None
+    ) -> Optional[Union[Message, T]]:
         """获取一个 `got` 消息
 
         如果没有找到对应的消息，返回 `default` 值
@@ -583,7 +630,15 @@ class Matcher(metaclass=MatcherMeta):
         else:
             self.state[REJECT_TARGET] = target
 
-    def get_target(self, default: T = None) -> Union[str, T]:
+    @overload
+    def get_target(self) -> Union[str, None]:
+        ...
+
+    @overload
+    def get_target(self, default: T) -> Union[str, T]:
+        ...
+
+    def get_target(self, default: Optional[T] = None) -> Optional[Union[str, T]]:
         return self.state.get(REJECT_TARGET, default)
 
     def stop_propagation(self):
@@ -592,15 +647,21 @@ class Matcher(metaclass=MatcherMeta):
 
     async def update_type(self, bot: Bot, event: Event) -> str:
         updater = self.__class__._default_type_updater
-        if not updater:
-            return "message"
-        return await updater(bot=bot, event=event, state=self.state, matcher=self)
+        return (
+            await updater(bot=bot, event=event, state=self.state, matcher=self)
+            if updater
+            else "message"
+        )
 
     async def update_permission(self, bot: Bot, event: Event) -> Permission:
-        updater = self.__class__._default_permission_updater
-        if not updater:
-            return USER(event.get_session_id(), perm=self.permission)
-        return await updater(bot=bot, event=event, state=self.state, matcher=self)
+        if updater := self.__class__._default_permission_updater:
+            return await updater(bot=bot, event=event, state=self.state, matcher=self)
+        permission = self.permission
+        if len(permission.checkers) == 1 and isinstance(
+            user_perm := tuple(permission.checkers)[0].call, User
+        ):
+            permission = user_perm.perm
+        return USER(event.get_session_id(), perm=permission)
 
     async def resolve_reject(self):
         handler = current_handler.get()
@@ -608,6 +669,18 @@ class Matcher(metaclass=MatcherMeta):
         if REJECT_CACHE_TARGET in self.state:
             self.state[REJECT_TARGET] = self.state[REJECT_CACHE_TARGET]
 
+    @contextmanager
+    def ensure_context(self, bot: Bot, event: Event):
+        b_t = current_bot.set(bot)
+        e_t = current_event.set(event)
+        m_t = current_matcher.set(self)
+        try:
+            yield
+        finally:
+            current_bot.reset(b_t)
+            current_event.reset(e_t)
+            current_matcher.reset(m_t)
+
     async def simple_run(
         self,
         bot: Bot,
@@ -617,43 +690,34 @@ class Matcher(metaclass=MatcherMeta):
         dependency_cache: Optional[T_DependencyCache] = None,
     ):
         logger.trace(
-            f"Matcher {self} run with incoming args: "
-            f"bot={bot}, event={event}, state={state}"
+            f"{self} run with incoming args: "
+            f"bot={bot}, event={event!r}, state={state!r}"
         )
-        b_t = current_bot.set(bot)
-        e_t = current_event.set(event)
-        m_t = current_matcher.set(self)
-        try:
-            # Refresh preprocess state
-            self.state.update(state)
 
-            while self.handlers:
-                handler = self.handlers.pop(0)
-                current_handler.set(handler)
-                logger.debug(f"Running handler {handler}")
-                try:
-                    await handler(
-                        matcher=self,
-                        bot=bot,
-                        event=event,
-                        state=self.state,
-                        stack=stack,
-                        dependency_cache=dependency_cache,
-                    )
-                except TypeMisMatch as e:
-                    logger.debug(
-                        f"Handler {handler} param {e.param.name} value {e.value} "
-                        f"mismatch type {e.param._type_display()}, skipped"
-                    )
-                except SkippedException as e:
-                    logger.debug(f"Handler {handler} skipped")
-        except StopPropagation:
-            self.block = True
-        finally:
-            logger.info(f"Matcher {self} running complete")
-            current_bot.reset(b_t)
-            current_event.reset(e_t)
-            current_matcher.reset(m_t)
+        with self.ensure_context(bot, event):
+            try:
+                # Refresh preprocess state
+                self.state.update(state)
+
+                while self.handlers:
+                    handler = self.handlers.pop(0)
+                    current_handler.set(handler)
+                    logger.debug(f"Running handler {handler}")
+                    try:
+                        await handler(
+                            matcher=self,
+                            bot=bot,
+                            event=event,
+                            state=self.state,
+                            stack=stack,
+                            dependency_cache=dependency_cache,
+                        )
+                    except SkippedException:
+                        logger.debug(f"Handler {handler} skipped")
+            except StopPropagation:
+                self.block = True
+            finally:
+                logger.info(f"{self} running complete")
 
     # 运行handlers
     async def run(
@@ -682,7 +746,7 @@ class Matcher(metaclass=MatcherMeta):
                 block=True,
                 plugin=self.plugin,
                 module=self.module,
-                expire_time=datetime.now() + bot.config.session_expire_timeout,
+                expire_time=bot.config.session_expire_timeout,
                 default_state=self.state,
                 default_type_updater=self.__class__._default_type_updater,
                 default_permission_updater=self.__class__._default_permission_updater,
@@ -701,21 +765,10 @@ class Matcher(metaclass=MatcherMeta):
                 block=True,
                 plugin=self.plugin,
                 module=self.module,
-                expire_time=datetime.now() + bot.config.session_expire_timeout,
+                expire_time=bot.config.session_expire_timeout,
                 default_state=self.state,
                 default_type_updater=self.__class__._default_type_updater,
                 default_permission_updater=self.__class__._default_permission_updater,
             )
         except FinishedException:
             pass
-
-
-__autodoc__ = {
-    "MatcherMeta": False,
-    "Matcher.get_target": False,
-    "Matcher.set_target": False,
-    "Matcher.update_type": False,
-    "Matcher.update_permission": False,
-    "Matcher.resolve_reject": False,
-    "Matcher.simple_run": False,
-}

nonebot/internal/matcher/provider.py

@@ -0,0 +1,27 @@
+import abc
+from collections import defaultdict
+from typing import TYPE_CHECKING, List, Type, Mapping, MutableMapping
+
+if TYPE_CHECKING:
+    from .matcher import Matcher
+
+
+class MatcherProvider(abc.ABC, MutableMapping[int, List[Type["Matcher"]]]):
+    """事件响应器存储器基类
+
+    参数:
+        matchers: 当前存储器中已有的事件响应器
+    """
+
+    @abc.abstractmethod
+    def __init__(self, matchers: Mapping[int, List[Type["Matcher"]]]):
+        raise NotImplementedError
+
+
+class _DictProvider(defaultdict, MatcherProvider):
+    def __init__(self, matchers: Mapping[int, List[Type["Matcher"]]]):
+        super().__init__(list, matchers)
+
+
+DEFAULT_PROVIDER_CLASS = _DictProvider
+"""默认存储器类型"""

nonebot/internal/params.py

@@ -1,14 +1,11 @@
 import asyncio
 import inspect
-import warnings
-from typing_extensions import Literal
-from typing import TYPE_CHECKING, Any, Callable, Optional, cast
 from contextlib import AsyncExitStack, contextmanager, asynccontextmanager
+from typing import TYPE_CHECKING, Any, Type, Tuple, Literal, Callable, Optional, cast
 
 from pydantic.fields import Required, Undefined, ModelField
 
-from nonebot.log import logger
-from nonebot.exception import TypeMisMatch
+from nonebot.dependencies.utils import check_field_type
 from nonebot.dependencies import Param, Dependent, CustomConfig
 from nonebot.typing import T_State, T_Handler, T_DependencyCache
 from nonebot.utils import (
@@ -39,7 +36,7 @@ class DependsInner:
     def __repr__(self) -> str:
         dep = get_name(self.dependency)
         cache = "" if self.use_cache else ", use_cache=False"
-        return f"{self.__class__.__name__}({dep}{cache})"
+        return f"DependsInner({dep}{cache})"
 
 
 def Depends(
@@ -74,12 +71,12 @@ def Depends(
 class DependParam(Param):
     """子依赖参数"""
 
+    def __repr__(self) -> str:
+        return f"Depends({self.extra['dependent']})"
+
     @classmethod
     def _check_param(
-        cls,
-        dependent: Dependent,
-        name: str,
-        param: inspect.Parameter,
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
     ) -> Optional["DependParam"]:
         if isinstance(param.default, DependsInner):
             dependency: T_Handler
@@ -90,22 +87,20 @@ class DependParam(Param):
                 dependency = param.default.dependency
             sub_dependent = Dependent[Any].parse(
                 call=dependency,
-                allow_types=dependent.allow_types,
+                allow_types=allow_types,
             )
-            dependent.pre_checkers.extend(sub_dependent.pre_checkers)
-            sub_dependent.pre_checkers.clear()
             return cls(
                 Required, use_cache=param.default.use_cache, dependent=sub_dependent
             )
 
     @classmethod
     def _check_parameterless(
-        cls, dependent: "Dependent", value: Any
+        cls, value: Any, allow_types: Tuple[Type[Param], ...]
     ) -> Optional["Param"]:
         if isinstance(value, DependsInner):
             assert value.dependency, "Dependency cannot be empty"
             dependent = Dependent[Any].parse(
-                call=value.dependency, allow_types=dependent.allow_types
+                call=value.dependency, allow_types=allow_types
             )
             return cls(Required, use_cache=value.use_cache, dependent=dependent)
 
@@ -119,8 +114,7 @@ class DependParam(Param):
         dependency_cache = {} if dependency_cache is None else dependency_cache
 
         sub_dependent: Dependent = self.extra["dependent"]
-        sub_dependent.call = cast(Callable[..., Any], sub_dependent.call)
-        call = sub_dependent.call
+        call = cast(Callable[..., Any], sub_dependent.call)
 
         # solve sub dependency with current cache
         sub_values = await sub_dependent.solve(
@@ -132,7 +126,7 @@ class DependParam(Param):
         # run dependency function
         task: asyncio.Task[Any]
         if use_cache and call in dependency_cache:
-            solved = await dependency_cache[call]
+            return await dependency_cache[call]
         elif is_gen_callable(call) or is_async_gen_callable(call):
             assert isinstance(
                 stack, AsyncExitStack
@@ -143,134 +137,124 @@ class DependParam(Param):
                 cm = asynccontextmanager(call)(**sub_values)
             task = asyncio.create_task(stack.enter_async_context(cm))
             dependency_cache[call] = task
-            solved = await task
+            return await task
         elif is_coroutine_callable(call):
             task = asyncio.create_task(call(**sub_values))
             dependency_cache[call] = task
-            solved = await task
+            return await task
         else:
             task = asyncio.create_task(run_sync(call)(**sub_values))
             dependency_cache[call] = task
-            solved = await task
+            return await task
 
-        return solved
-
-
-class _BotChecker(Param):
-    async def _solve(self, bot: "Bot", **kwargs: Any) -> Any:
-        field: ModelField = self.extra["field"]
-        if isinstance(bot, field.type_):
-            return bot
-        else:
-            logger.debug(
-                f"Bot type {type(bot)} not match "
-                f"annotation {field._type_display()}, ignored"
-            )
-            raise TypeMisMatch(field, bot)
+    async def _check(self, **kwargs: Any) -> None:
+        # run sub dependent pre-checkers
+        sub_dependent: Dependent = self.extra["dependent"]
+        await sub_dependent.check(**kwargs)
 
 
 class BotParam(Param):
     """{ref}`nonebot.adapters.Bot` 参数"""
 
+    def __repr__(self) -> str:
+        return (
+            "BotParam("
+            + (
+                repr(cast(ModelField, checker).type_)
+                if (checker := self.extra.get("checker"))
+                else ""
+            )
+            + ")"
+        )
+
     @classmethod
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
     ) -> Optional["BotParam"]:
         from nonebot.adapters import Bot
 
         if param.default == param.empty:
             if generic_check_issubclass(param.annotation, Bot):
+                checker: Optional[ModelField] = None
                 if param.annotation is not Bot:
-                    dependent.pre_checkers.append(
-                        _BotChecker(
-                            Required,
-                            field=ModelField(
-                                name=name,
-                                type_=param.annotation,
-                                class_validators=None,
-                                model_config=CustomConfig,
-                                default=None,
-                                required=True,
-                            ),
-                        )
+                    checker = ModelField(
+                        name=param.name,
+                        type_=param.annotation,
+                        class_validators=None,
+                        model_config=CustomConfig,
+                        default=None,
+                        required=True,
                     )
-                return cls(Required)
-            elif param.annotation == param.empty and name == "bot":
+                return cls(Required, checker=checker)
+            elif param.annotation == param.empty and param.name == "bot":
                 return cls(Required)
 
     async def _solve(self, bot: "Bot", **kwargs: Any) -> Any:
         return bot
 
-
-class _EventChecker(Param):
-    async def _solve(self, event: "Event", **kwargs: Any) -> Any:
-        field: ModelField = self.extra["field"]
-        if isinstance(event, field.type_):
-            return event
-        else:
-            logger.debug(
-                f"Event type {type(event)} not match "
-                f"annotation {field._type_display()}, ignored"
-            )
-            raise TypeMisMatch(field, event)
+    async def _check(self, bot: "Bot", **kwargs: Any) -> None:
+        if checker := self.extra.get("checker"):
+            check_field_type(checker, bot)
 
 
 class EventParam(Param):
     """{ref}`nonebot.adapters.Event` 参数"""
 
+    def __repr__(self) -> str:
+        return (
+            "EventParam("
+            + (
+                repr(cast(ModelField, checker).type_)
+                if (checker := self.extra.get("checker"))
+                else ""
+            )
+            + ")"
+        )
+
     @classmethod
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
     ) -> Optional["EventParam"]:
         from nonebot.adapters import Event
 
         if param.default == param.empty:
             if generic_check_issubclass(param.annotation, Event):
+                checker: Optional[ModelField] = None
                 if param.annotation is not Event:
-                    dependent.pre_checkers.append(
-                        _EventChecker(
-                            Required,
-                            field=ModelField(
-                                name=name,
-                                type_=param.annotation,
-                                class_validators=None,
-                                model_config=CustomConfig,
-                                default=None,
-                                required=True,
-                            ),
-                        )
+                    checker = ModelField(
+                        name=param.name,
+                        type_=param.annotation,
+                        class_validators=None,
+                        model_config=CustomConfig,
+                        default=None,
+                        required=True,
                     )
-                return cls(Required)
-            elif param.annotation == param.empty and name == "event":
+                return cls(Required, checker=checker)
+            elif param.annotation == param.empty and param.name == "event":
                 return cls(Required)
 
     async def _solve(self, event: "Event", **kwargs: Any) -> Any:
         return event
 
-
-class StateInner(T_State):
-    ...
-
-
-def State() -> T_State:
-    """**Deprecated**: 事件处理状态参数，请直接使用 {ref}`nonebot.typing.T_State`"""
-    warnings.warn("State() is deprecated, use `T_State` instead", DeprecationWarning)
-    return StateInner()
+    async def _check(self, event: "Event", **kwargs: Any) -> Any:
+        if checker := self.extra.get("checker", None):
+            check_field_type(checker, event)
 
 
 class StateParam(Param):
     """事件处理状态参数"""
 
+    def __repr__(self) -> str:
+        return "StateParam()"
+
     @classmethod
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
     ) -> Optional["StateParam"]:
-        if isinstance(param.default, StateInner):
-            return cls(Required)
-        elif param.default == param.empty:
+        if param.default == param.empty:
             if param.annotation is T_State:
                 return cls(Required)
-            elif param.annotation == param.empty and name == "state":
+            elif param.annotation == param.empty and param.name == "state":
                 return cls(Required)
 
     async def _solve(self, state: T_State, **kwargs: Any) -> Any:
@@ -280,14 +264,17 @@ class StateParam(Param):
 class MatcherParam(Param):
     """事件响应器实例参数"""
 
+    def __repr__(self) -> str:
+        return "MatcherParam()"
+
     @classmethod
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
     ) -> Optional["MatcherParam"]:
         from nonebot.matcher import Matcher
 
         if generic_check_issubclass(param.annotation, Matcher) or (
-            param.annotation == param.empty and name == "matcher"
+            param.annotation == param.empty and param.name == "matcher"
         ):
             return cls(Required)
 
@@ -302,6 +289,9 @@ class ArgInner:
         self.key = key
         self.type = type
 
+    def __repr__(self) -> str:
+        return f"ArgInner(key={self.key!r}, type={self.type!r})"
+
 
 def Arg(key: Optional[str] = None) -> Any:
     """`got` 的 Arg 参数消息"""
@@ -321,12 +311,17 @@ def ArgPlainText(key: Optional[str] = None) -> str:
 class ArgParam(Param):
     """`got` 的 Arg 参数"""
 
+    def __repr__(self) -> str:
+        return f"ArgParam(key={self.extra['key']!r}, type={self.extra['type']!r})"
+
     @classmethod
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
     ) -> Optional["ArgParam"]:
         if isinstance(param.default, ArgInner):
-            return cls(Required, key=param.default.key or name, type=param.default.type)
+            return cls(
+                Required, key=param.default.key or param.name, type=param.default.type
+            )
 
     async def _solve(self, matcher: "Matcher", **kwargs: Any) -> Any:
         message = matcher.get_arg(self.extra["key"])
@@ -343,12 +338,15 @@ class ArgParam(Param):
 class ExceptionParam(Param):
     """`run_postprocessor` 的异常参数"""
 
+    def __repr__(self) -> str:
+        return "ExceptionParam()"
+
     @classmethod
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
     ) -> Optional["ExceptionParam"]:
         if generic_check_issubclass(param.annotation, Exception) or (
-            param.annotation == param.empty and name == "exception"
+            param.annotation == param.empty and param.name == "exception"
         ):
             return cls(Required)
 
@@ -359,9 +357,12 @@ class ExceptionParam(Param):
 class DefaultParam(Param):
     """默认值参数"""
 
+    def __repr__(self) -> str:
+        return f"DefaultParam(default={self.default!r})"
+
     @classmethod
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
     ) -> Optional["DefaultParam"]:
         if param.default != param.empty:
             return cls(param.default)

nonebot/internal/permission.py

@@ -1,6 +1,6 @@
 import asyncio
 from contextlib import AsyncExitStack
-from typing import Any, Set, Tuple, Union, NoReturn, Optional, Coroutine
+from typing import Set, Tuple, Union, NoReturn, Optional
 
 from nonebot.dependencies import Dependent
 from nonebot.utils import run_coro_with_catch
@@ -37,16 +37,19 @@ class Permission:
     ]
 
     def __init__(self, *checkers: Union[T_PermissionChecker, Dependent[bool]]) -> None:
-        self.checkers: Set[Dependent[bool]] = set(
+        self.checkers: Set[Dependent[bool]] = {
             checker
             if isinstance(checker, Dependent)
             else Dependent[bool].parse(
                 call=checker, allow_types=self.HANDLER_PARAM_TYPES
             )
             for checker in checkers
-        )
+        }
         """存储 `PermissionChecker`"""
 
+    def __repr__(self) -> str:
+        return f"Permission({', '.join(repr(checker) for checker in self.checkers)})"
+
     async def __call__(
         self,
         bot: Bot,
@@ -121,10 +124,20 @@ class User:
         self.users = users
         self.perm = perm
 
+    def __repr__(self) -> str:
+        return (
+            f"User(users={self.users}"
+            + (f", permission={self.perm})" if self.perm else "")
+            + ")"
+        )
+
     async def __call__(self, bot: Bot, event: Event) -> bool:
+        try:
+            session = event.get_session_id()
+        except Exception:
+            return False
         return bool(
-            event.get_session_id() in self.users
-            and (self.perm is None or await self.perm(bot, event))
+            session in self.users and (self.perm is None or await self.perm(bot, event))
         )
 
 

nonebot/internal/rule.py

@@ -37,16 +37,19 @@ class Rule:
     ]
 
     def __init__(self, *checkers: Union[T_RuleChecker, Dependent[bool]]) -> None:
-        self.checkers: Set[Dependent[bool]] = set(
+        self.checkers: Set[Dependent[bool]] = {
             checker
             if isinstance(checker, Dependent)
             else Dependent[bool].parse(
                 call=checker, allow_types=self.HANDLER_PARAM_TYPES
             )
             for checker in checkers
-        )
+        }
         """存储 `RuleChecker`"""
 
+    def __repr__(self) -> str:
+        return f"Rule({', '.join(repr(checker) for checker in self.checkers)})"
+
     async def __call__(
         self,
         bot: Bot,

nonebot/log.py

@@ -14,16 +14,14 @@ FrontMatter:
 
 import sys
 import logging
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 import loguru
 
 if TYPE_CHECKING:
     # avoid sphinx autodoc resolve annotation failed
     # because loguru module do not have `Logger` class actually
-    from loguru import Logger
-
-    from nonebot.plugin import Plugin
+    from loguru import Logger, Record
 
 # logger = logging.getLogger("nonebot")
 logger: "Logger" = loguru.logger
@@ -47,26 +45,10 @@ logger: "Logger" = loguru.logger
 # logger.addHandler(default_handler)
 
 
-class Filter:
-    def __init__(self) -> None:
-        self.level: Union[int, str] = "INFO"
-
-    def __call__(self, record):
-        module_name: str = record["name"]
-        # TODO: get plugin name instead of module name
-        # module = sys.modules.get(module_name)
-        # if module and hasattr(module, "__plugin__"):
-        #     plugin: "Plugin" = getattr(module, "__plugin__")
-        #     module_name = plugin.module_name
-        record["name"] = module_name.split(".")[0]
-        levelno = (
-            logger.level(self.level).no if isinstance(self.level, str) else self.level
-        )
-        return record["level"].no >= levelno
-
-
 class LoguruHandler(logging.Handler):  # pragma: no cover
-    def emit(self, record):
+    """logging 与 loguru 之间的桥梁，将 logging 的日志转发到 loguru。"""
+
+    def emit(self, record: logging.LogRecord):
         try:
             level = logger.level(record.levelname).name
         except ValueError:
@@ -82,9 +64,13 @@ class LoguruHandler(logging.Handler):  # pragma: no cover
         )
 
 
-logger.remove()
-default_filter: Filter = Filter()
-"""默认日志等级过滤器"""
+def default_filter(record: "Record"):
+    """默认的日志过滤器，根据 `config.log_level` 配置改变日志等级。"""
+    log_level = record["extra"].get("nonebot_log_level", "INFO")
+    levelno = logger.level(log_level).no if isinstance(log_level, str) else log_level
+    return record["level"].no >= levelno
+
+
 default_format: str = (
     "<g>{time:MM-DD HH:mm:ss}</g> "
     "[<lvl>{level}</lvl>] "
@@ -93,13 +79,14 @@ default_format: str = (
     "{message}"
 )
 """默认日志格式"""
+
+logger.remove()
 logger_id = logger.add(
     sys.stdout,
     level=0,
-    colorize=True,
     diagnose=False,
     filter=default_filter,
     format=default_format,
 )
 
-__autodoc__ = {"Filter": False, "LoguruHandler": False}
+__autodoc__ = {"logger_id": False}

nonebot/matcher.py

@@ -9,10 +9,16 @@ from nonebot.internal.matcher import Matcher as Matcher
 from nonebot.internal.matcher import matchers as matchers
 from nonebot.internal.matcher import current_bot as current_bot
 from nonebot.internal.matcher import current_event as current_event
+from nonebot.internal.matcher import MatcherManager as MatcherManager
+from nonebot.internal.matcher import MatcherProvider as MatcherProvider
 from nonebot.internal.matcher import current_handler as current_handler
 from nonebot.internal.matcher import current_matcher as current_matcher
+from nonebot.internal.matcher import DEFAULT_PROVIDER_CLASS as DEFAULT_PROVIDER_CLASS
 
 __autodoc__ = {
     "Matcher": True,
     "matchers": True,
+    "MatcherManager": True,
+    "MatcherProvider": True,
+    "DEFAULT_PROVIDER_CLASS": True,
 }

nonebot/message.py

@@ -8,9 +8,10 @@ FrontMatter:
 """
 
 import asyncio
+import contextlib
 from datetime import datetime
 from contextlib import AsyncExitStack
-from typing import TYPE_CHECKING, Any, Set, Dict, Type, Optional, Coroutine
+from typing import TYPE_CHECKING, Any, Set, Dict, Type, Optional
 
 from nonebot.log import logger
 from nonebot.rule import TrieRule
@@ -50,14 +51,14 @@ _event_postprocessors: Set[Dependent[Any]] = set()
 _run_preprocessors: Set[Dependent[Any]] = set()
 _run_postprocessors: Set[Dependent[Any]] = set()
 
-EVENT_PCS_PARAMS = [
+EVENT_PCS_PARAMS = (
     DependParam,
     BotParam,
     EventParam,
     StateParam,
     DefaultParam,
-]
-RUN_PREPCS_PARAMS = [
+)
+RUN_PREPCS_PARAMS = (
     DependParam,
     BotParam,
     EventParam,
@@ -65,8 +66,8 @@ RUN_PREPCS_PARAMS = [
     ArgParam,
     MatcherParam,
     DefaultParam,
-]
-RUN_POSTPCS_PARAMS = [
+)
+RUN_POSTPCS_PARAMS = (
     DependParam,
     ExceptionParam,
     BotParam,
@@ -75,7 +76,7 @@ RUN_POSTPCS_PARAMS = [
     ArgParam,
     MatcherParam,
     DefaultParam,
-]
+)
 
 
 def event_preprocessor(func: T_EventPreProcessor) -> T_EventPreProcessor:
@@ -111,7 +112,6 @@ def run_postprocessor(func: T_RunPostProcessor) -> T_RunPostProcessor:
 
 
 async def _check_matcher(
-    priority: int,
     Matcher: Type[Matcher],
     bot: "Bot",
     event: "Event",
@@ -120,10 +120,8 @@ async def _check_matcher(
     dependency_cache: Optional[T_DependencyCache] = None,
 ) -> None:
     if Matcher.expire_time and datetime.now() > Matcher.expire_time:
-        try:
-            matchers[priority].remove(Matcher)
-        except Exception:
-            pass
+        with contextlib.suppress(Exception):
+            Matcher.destroy()
         return
 
     try:
@@ -138,11 +136,8 @@ async def _check_matcher(
         return
 
     if Matcher.temp:
-        try:
-            matchers[priority].remove(Matcher)
-        except Exception:
-            pass
-
+        with contextlib.suppress(Exception):
+            Matcher.destroy()
     await _run_matcher(Matcher, bot, event, state, stack, dependency_cache)
 
 
@@ -157,73 +152,68 @@ async def _run_matcher(
     logger.info(f"Event will be handled by {Matcher}")
 
     matcher = Matcher()
-
-    coros = list(
-        map(
-            lambda x: run_coro_with_catch(
-                x(
-                    matcher=matcher,
-                    bot=bot,
-                    event=event,
-                    state=state,
-                    stack=stack,
-                    dependency_cache=dependency_cache,
-                ),
-                (SkippedException,),
+    if coros := [
+        run_coro_with_catch(
+            proc(
+                matcher=matcher,
+                bot=bot,
+                event=event,
+                state=state,
+                stack=stack,
+                dependency_cache=dependency_cache,
             ),
-            _run_preprocessors,
+            (SkippedException,),
         )
-    )
-    if coros:
-        try:
-            await asyncio.gather(*coros)
-        except IgnoredException:
-            logger.opt(colors=True).info(
-                f"Matcher {matcher} running is <b>cancelled</b>"
-            )
-            return
-        except Exception as e:
-            logger.opt(colors=True, exception=e).error(
-                "<r><bg #f8bbd0>Error when running RunPreProcessors. "
-                "Running cancelled!</bg #f8bbd0></r>"
-            )
-            return
+        for proc in _run_preprocessors
+    ]:
+        # ensure matcher function can be correctly called
+        with matcher.ensure_context(bot, event):
+            try:
+                await asyncio.gather(*coros)
+            except IgnoredException:
+                logger.opt(colors=True).info(f"{matcher} running is <b>cancelled</b>")
+                return
+            except Exception as e:
+                logger.opt(colors=True, exception=e).error(
+                    "<r><bg #f8bbd0>Error when running RunPreProcessors. Running cancelled!</bg #f8bbd0></r>"
+                )
+
+                return
 
     exception = None
 
     try:
-        logger.debug(f"Running matcher {matcher}")
+        logger.debug(f"Running {matcher}")
         await matcher.run(bot, event, state, stack, dependency_cache)
     except Exception as e:
         logger.opt(colors=True, exception=e).error(
-            f"<r><bg #f8bbd0>Running matcher {matcher} failed.</bg #f8bbd0></r>"
+            f"<r><bg #f8bbd0>Running {matcher} failed.</bg #f8bbd0></r>"
         )
         exception = e
 
-    coros = list(
-        map(
-            lambda x: run_coro_with_catch(
-                x(
-                    matcher=matcher,
-                    exception=exception,
-                    bot=bot,
-                    event=event,
-                    state=state,
-                    stack=stack,
-                    dependency_cache=dependency_cache,
-                ),
-                (SkippedException,),
+    if coros := [
+        run_coro_with_catch(
+            proc(
+                matcher=matcher,
+                exception=exception,
+                bot=bot,
+                event=event,
+                state=matcher.state,
+                stack=stack,
+                dependency_cache=dependency_cache,
             ),
-            _run_postprocessors,
+            (SkippedException,),
         )
-    )
-    if coros:
-        try:
-            await asyncio.gather(*coros)
-        except Exception as e:
-            logger.opt(colors=True, exception=e).error(
-                "<r><bg #f8bbd0>Error when running RunPostProcessors</bg #f8bbd0></r>"
-            )
+        for proc in _run_postprocessors
+    ]:
+        # ensure matcher function can be correctly called
+        with matcher.ensure_context(bot, event):
+            try:
+                await asyncio.gather(*coros)
+            except Exception as e:
+                logger.opt(colors=True, exception=e).error(
+                    "<r><bg #f8bbd0>Error when running RunPostProcessors</bg #f8bbd0></r>"
+                )
 
     if matcher.block:
         raise StopPropagation
@@ -244,7 +234,7 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
         ```
     """
     show_log = True
-    log_msg = f"<m>{escape_tag(bot.type.upper())} {escape_tag(bot.self_id)}</m> | "
+    log_msg = f"<m>{escape_tag(bot.type)} {escape_tag(bot.self_id)}</m> | "
     try:
         log_msg += event.get_log_string()
     except NoLogException:
@@ -256,22 +246,19 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
     dependency_cache: T_DependencyCache = {}
 
     async with AsyncExitStack() as stack:
-        coros = list(
-            map(
-                lambda x: run_coro_with_catch(
-                    x(
-                        bot=bot,
-                        event=event,
-                        state=state,
-                        stack=stack,
-                        dependency_cache=dependency_cache,
-                    ),
-                    (SkippedException,),
+        if coros := [
+            run_coro_with_catch(
+                proc(
+                    bot=bot,
+                    event=event,
+                    state=state,
+                    stack=stack,
+                    dependency_cache=dependency_cache,
                 ),
-                _event_preprocessors,
+                (SkippedException,),
             )
-        )
-        if coros:
+            for proc in _event_preprocessors
+        ]:
             try:
                 if show_log:
                     logger.debug("Running PreProcessors...")
@@ -306,7 +293,7 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
 
             pending_tasks = [
                 _check_matcher(
-                    priority, matcher, bot, event, state.copy(), stack, dependency_cache
+                    matcher, bot, event, state.copy(), stack, dependency_cache
                 )
                 for matcher in matchers[priority]
             ]
@@ -324,22 +311,22 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
                         "<r><bg #f8bbd0>Error when checking Matcher.</bg #f8bbd0></r>"
                     )
 
-        coros = list(
-            map(
-                lambda x: run_coro_with_catch(
-                    x(
-                        bot=bot,
-                        event=event,
-                        state=state,
-                        stack=stack,
-                        dependency_cache=dependency_cache,
-                    ),
-                    (SkippedException,),
+        if show_log:
+            logger.debug("Checking for matchers completed")
+
+        if coros := [
+            run_coro_with_catch(
+                proc(
+                    bot=bot,
+                    event=event,
+                    state=state,
+                    stack=stack,
+                    dependency_cache=dependency_cache,
                 ),
-                _event_postprocessors,
+                (SkippedException,),
             )
-        )
-        if coros:
+            for proc in _event_postprocessors
+        ]:
             try:
                 if show_log:
                     logger.debug("Running PostProcessors...")

nonebot/params.py

@@ -5,17 +5,17 @@ FrontMatter:
     description: nonebot.params 模块
 """
 
-from typing import Any, Dict, List, Tuple, Optional
+import warnings
+from typing import Any, Dict, List, Tuple, Union, Optional
 
 from nonebot.typing import T_State
 from nonebot.matcher import Matcher
-from nonebot.adapters import Event, Message
 from nonebot.internal.params import Arg as Arg
-from nonebot.internal.params import State as State
 from nonebot.internal.params import ArgStr as ArgStr
 from nonebot.internal.params import Depends as Depends
 from nonebot.internal.params import ArgParam as ArgParam
 from nonebot.internal.params import BotParam as BotParam
+from nonebot.adapters import Event, Message, MessageSegment
 from nonebot.internal.params import EventParam as EventParam
 from nonebot.internal.params import StateParam as StateParam
 from nonebot.internal.params import DependParam as DependParam
@@ -25,15 +25,20 @@ from nonebot.internal.params import MatcherParam as MatcherParam
 from nonebot.internal.params import ExceptionParam as ExceptionParam
 from nonebot.consts import (
     CMD_KEY,
+    REGEX_STR,
     PREFIX_KEY,
     REGEX_DICT,
     SHELL_ARGS,
     SHELL_ARGV,
     CMD_ARG_KEY,
+    KEYWORD_KEY,
     RAW_CMD_KEY,
     REGEX_GROUP,
+    ENDSWITH_KEY,
     CMD_START_KEY,
+    FULLMATCH_KEY,
     REGEX_MATCHED,
+    STARTSWITH_KEY,
 )
 
 
@@ -110,15 +115,15 @@ def CommandStart() -> str:
 
 
 def _shell_command_args(state: T_State) -> Any:
-    return state[SHELL_ARGS]
+    return state[SHELL_ARGS]  # Namespace or ParserExit
 
 
-def ShellCommandArgs():
+def ShellCommandArgs() -> Any:
     """shell 命令解析后的参数字典"""
     return Depends(_shell_command_args, use_cache=False)
 
 
-def _shell_command_argv(state: T_State) -> List[str]:
+def _shell_command_argv(state: T_State) -> List[Union[str, MessageSegment]]:
     return state[SHELL_ARGV]
 
 
@@ -133,10 +138,25 @@ def _regex_matched(state: T_State) -> str:
 
 def RegexMatched() -> str:
     """正则匹配结果"""
+    warnings.warn(
+        '"RegexMatched()" will be changed to "re.Match" object, '
+        'use "RegexStr()" instead. '
+        "See https://github.com/nonebot/nonebot2/pull/1453 .",
+        DeprecationWarning,
+    )
     return Depends(_regex_matched, use_cache=False)
 
 
-def _regex_group(state: T_State):
+def _regex_str(state: T_State) -> str:
+    return state[REGEX_STR]
+
+
+def RegexStr() -> str:
+    """正则匹配结果文本"""
+    return Depends(_regex_str, use_cache=False)
+
+
+def _regex_group(state: T_State) -> Tuple[Any, ...]:
     return state[REGEX_GROUP]
 
 
@@ -145,7 +165,7 @@ def RegexGroup() -> Tuple[Any, ...]:
     return Depends(_regex_group, use_cache=False)
 
 
-def _regex_dict(state: T_State):
+def _regex_dict(state: T_State) -> Dict[str, Any]:
     return state[REGEX_DICT]
 
 
@@ -154,10 +174,46 @@ def RegexDict() -> Dict[str, Any]:
     return Depends(_regex_dict, use_cache=False)
 
 
+def _startswith(state: T_State) -> str:
+    return state[STARTSWITH_KEY]
+
+
+def Startswith() -> str:
+    """响应触发前缀"""
+    return Depends(_startswith, use_cache=False)
+
+
+def _endswith(state: T_State) -> str:
+    return state[ENDSWITH_KEY]
+
+
+def Endswith() -> str:
+    """响应触发后缀"""
+    return Depends(_endswith, use_cache=False)
+
+
+def _fullmatch(state: T_State) -> str:
+    return state[FULLMATCH_KEY]
+
+
+def Fullmatch() -> str:
+    """响应触发完整消息"""
+    return Depends(_fullmatch, use_cache=False)
+
+
+def _keyword(state: T_State) -> str:
+    return state[KEYWORD_KEY]
+
+
+def Keyword() -> str:
+    """响应触发关键字"""
+    return Depends(_keyword, use_cache=False)
+
+
 def Received(id: Optional[str] = None, default: Any = None) -> Any:
     """`receive` 事件参数"""
 
-    def _received(matcher: "Matcher"):
+    def _received(matcher: "Matcher") -> Any:
         return matcher.get_receive(id or "", default)
 
     return Depends(_received, use_cache=False)
@@ -174,7 +230,6 @@ def LastReceived(default: Any = None) -> Any:
 
 __autodoc__ = {
     "Arg": True,
-    "State": True,
     "ArgStr": True,
     "Depends": True,
     "ArgParam": True,

nonebot/permission.py

@@ -20,6 +20,9 @@ class Message:
 
     __slots__ = ()
 
+    def __repr__(self) -> str:
+        return "Message()"
+
     async def __call__(self, type: str = EventType()) -> bool:
         return type == "message"
 
@@ -29,6 +32,9 @@ class Notice:
 
     __slots__ = ()
 
+    def __repr__(self) -> str:
+        return "Notice()"
+
     async def __call__(self, type: str = EventType()) -> bool:
         return type == "notice"
 
@@ -38,6 +44,9 @@ class Request:
 
     __slots__ = ()
 
+    def __repr__(self) -> str:
+        return "Request()"
+
     async def __call__(self, type: str = EventType()) -> bool:
         return type == "request"
 
@@ -47,6 +56,9 @@ class MetaEvent:
 
     __slots__ = ()
 
+    def __repr__(self) -> str:
+        return "MetaEvent()"
+
     async def __call__(self, type: str = EventType()) -> bool:
         return type == "meta_event"
 
@@ -78,16 +90,23 @@ class SuperUser:
 
     __slots__ = ()
 
+    def __repr__(self) -> str:
+        return "Superuser()"
+
     async def __call__(self, bot: Bot, event: Event) -> bool:
-        return event.get_type() == "message" and (
-            f"{bot.adapter.get_name().split(maxsplit=1)[0].lower()}:{event.get_user_id()}"
+        try:
+            user_id = event.get_user_id()
+        except Exception:
+            return False
+        return (
+            f"{bot.adapter.get_name().split(maxsplit=1)[0].lower()}:{user_id}"
             in bot.config.superusers
-            or event.get_user_id() in bot.config.superusers  # 兼容旧配置
+            or user_id in bot.config.superusers  # 兼容旧配置
         )
 
 
 SUPERUSER: Permission = Permission(SuperUser())
-"""匹配任意超级用户消息类型事件"""
+"""匹配任意超级用户事件"""
 
 __autodoc__ = {
     "Permission": True,

nonebot/plugin/__init__.py

@@ -16,6 +16,7 @@
 - `on_command` => {ref}``on_command` <nonebot.plugin.on.on_command>`
 - `on_shell_command` => {ref}``on_shell_command` <nonebot.plugin.on.on_shell_command>`
 - `on_regex` => {ref}``on_regex` <nonebot.plugin.on.on_regex>`
+- `on_type` => {ref}``on_type` <nonebot.plugin.on.on_type>`
 - `CommandGroup` => {ref}``CommandGroup` <nonebot.plugin.on.CommandGroup>`
 - `Matchergroup` => {ref}``MatcherGroup` <nonebot.plugin.on.MatcherGroup>`
 - `load_plugin` => {ref}``load_plugin` <nonebot.plugin.load.load_plugin>`
@@ -25,28 +26,89 @@
 - `load_from_toml` => {ref}``load_from_toml` <nonebot.plugin.load.load_from_toml>`
 - `load_builtin_plugin` => {ref}``load_builtin_plugin` <nonebot.plugin.load.load_builtin_plugin>`
 - `load_builtin_plugins` => {ref}``load_builtin_plugins` <nonebot.plugin.load.load_builtin_plugins>`
-- `get_plugin` => {ref}``get_plugin` <nonebot.plugin.plugin.get_plugin>`
-- `get_loaded_plugins` => {ref}``get_loaded_plugins` <nonebot.plugin.plugin.get_loaded_plugins>`
-- `export` => {ref}``export` <nonebot.plugin.export.export>`
 - `require` => {ref}``require` <nonebot.plugin.load.require>`
+- `PluginMetadata` => {ref}``PluginMetadata` <nonebot.plugin.plugin.PluginMetadata>`
 
 FrontMatter:
     sidebar_position: 0
     description: nonebot.plugin 模块
 """
 
-from typing import List, Optional
+from itertools import chain
+from types import ModuleType
 from contextvars import ContextVar
+from typing import Set, Dict, List, Tuple, Optional
 
+_plugins: Dict[str, "Plugin"] = {}
 _managers: List["PluginManager"] = []
-_current_plugin: ContextVar[Optional["Plugin"]] = ContextVar(
-    "_current_plugin", default=None
+_current_plugin_chain: ContextVar[Tuple["Plugin", ...]] = ContextVar(
+    "_current_plugin_chain", default=tuple()
 )
 
+
+def _module_name_to_plugin_name(module_name: str) -> str:
+    return module_name.rsplit(".", 1)[-1]
+
+
+def _new_plugin(
+    module_name: str, module: ModuleType, manager: "PluginManager"
+) -> "Plugin":
+    plugin_name = _module_name_to_plugin_name(module_name)
+    if plugin_name in _plugins:
+        raise RuntimeError("Plugin already exists! Check your plugin name.")
+    plugin = Plugin(plugin_name, module, module_name, manager)
+    _plugins[plugin_name] = plugin
+    return plugin
+
+
+def _revert_plugin(plugin: "Plugin") -> None:
+    if plugin.name not in _plugins:
+        raise RuntimeError("Plugin not found!")
+    del _plugins[plugin.name]
+    if parent_plugin := plugin.parent_plugin:
+        parent_plugin.sub_plugins.remove(plugin)
+
+
+def get_plugin(name: str) -> Optional["Plugin"]:
+    """获取已经导入的某个插件。
+
+    如果为 `load_plugins` 文件夹导入的插件，则为文件(夹)名。
+
+    参数:
+        name: 插件名，即 {ref}`nonebot.plugin.plugin.Plugin.name`。
+    """
+    return _plugins.get(name)
+
+
+def get_plugin_by_module_name(module_name: str) -> Optional["Plugin"]:
+    """通过模块名获取已经导入的某个插件。
+
+    如果提供的模块名为某个插件的子模块，同样会返回该插件。
+
+    参数:
+        module_name: 模块名，即 {ref}`nonebot.plugin.plugin.Plugin.module_name`。
+    """
+    loaded = {plugin.module_name: plugin for plugin in _plugins.values()}
+    has_parent = True
+    while has_parent:
+        if module_name in loaded:
+            return loaded[module_name]
+        module_name, *has_parent = module_name.rsplit(".", 1)
+
+
+def get_loaded_plugins() -> Set["Plugin"]:
+    """获取当前已导入的所有插件。"""
+    return set(_plugins.values())
+
+
+def get_available_plugin_names() -> Set[str]:
+    """获取当前所有可用的插件名（包含尚未加载的插件）。"""
+    return {*chain.from_iterable(manager.available_plugins for manager in _managers)}
+
+
 from .on import on as on
 from .manager import PluginManager
-from .export import Export as Export
-from .export import export as export
+from .on import on_type as on_type
 from .load import require as require
 from .on import on_regex as on_regex
 from .plugin import Plugin as Plugin
@@ -61,13 +123,12 @@ from .on import CommandGroup as CommandGroup
 from .on import MatcherGroup as MatcherGroup
 from .on import on_fullmatch as on_fullmatch
 from .on import on_metaevent as on_metaevent
-from .plugin import get_plugin as get_plugin
 from .load import load_plugins as load_plugins
 from .on import on_startswith as on_startswith
 from .load import load_from_json as load_from_json
 from .load import load_from_toml as load_from_toml
 from .on import on_shell_command as on_shell_command
+from .plugin import PluginMetadata as PluginMetadata
 from .load import load_all_plugins as load_all_plugins
 from .load import load_builtin_plugin as load_builtin_plugin
-from .plugin import get_loaded_plugins as get_loaded_plugins
 from .load import load_builtin_plugins as load_builtin_plugins

nonebot/plugin/export.py

@@ -1,64 +0,0 @@
-"""本模块定义了插件导出的内容对象。
-
-在新版插件系统中，推荐优先使用直接 import 所需要的插件内容。
-
-FrontMatter:
-    sidebar_position: 4
-    description: nonebot.plugin.export 模块
-"""
-
-import warnings
-
-from . import _current_plugin
-
-
-class Export(dict):
-    """插件导出内容以使得其他插件可以获得。
-
-    用法:
-        ```python
-        nonebot.export().default = "bar"
-
-        @nonebot.export()
-        def some_function():
-            pass
-
-        # this doesn't work before python 3.9
-        # use
-        # export = nonebot.export(); @export.sub
-        # instead
-        # See also PEP-614: https://www.python.org/dev/peps/pep-0614/
-        @nonebot.export().sub
-        def something_else():
-            pass
-        ```
-    """
-
-    def __call__(self, func, **kwargs):
-        self[func.__name__] = func
-        self.update(kwargs)
-        return func
-
-    def __setitem__(self, key, 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
-
-    def __getattr__(self, name):
-        if name not in self:
-            self[name] = Export()
-        return self[name]
-
-
-def export() -> Export:
-    """获取当前插件的导出内容对象"""
-    warnings.warn(
-        "nonebot.export() is deprecated. "
-        "See https://github.com/nonebot/nonebot2/issues/935.",
-        DeprecationWarning,
-    )
-    plugin = _current_plugin.get()
-    if not plugin:
-        raise RuntimeError("Export outside of the plugin!")
-    return plugin.export

nonebot/plugin/load.py

@@ -5,24 +5,30 @@ FrontMatter:
     description: nonebot.plugin.load 模块
 """
 import json
-import warnings
-from typing import Set, Iterable, Optional
+from pathlib import Path
+from types import ModuleType
+from typing import Set, Union, Iterable, Optional
 
 import tomlkit
 
-from . import _managers
-from .export import Export
+from nonebot.utils import path_to_module_name
+
+from .plugin import Plugin
 from .manager import PluginManager
-from .plugin import Plugin, get_plugin
+from . import _managers, get_plugin, _module_name_to_plugin_name
 
 
-def load_plugin(module_path: str) -> Optional[Plugin]:
+def load_plugin(module_path: Union[str, Path]) -> Optional[Plugin]:
     """加载单个插件，可以是本地插件或是通过 `pip` 安装的插件。
 
     参数:
-        module_path: 插件名称 `path.to.your.plugin`
+        module_path: 插件名称 `path.to.your.plugin` 或插件路径 `pathlib.Path(path/to/your/plugin)`
     """
-
+    module_path = (
+        path_to_module_name(module_path)
+        if isinstance(module_path, Path)
+        else module_path
+    )
     manager = PluginManager([module_path])
     _managers.append(manager)
     return manager.load_plugin(module_path)
@@ -74,6 +80,8 @@ def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]:
     """
     with open(file_path, "r", encoding=encoding) as f:
         data = json.load(f)
+    if not isinstance(data, dict):
+        raise TypeError("json file must contains a dict!")
     plugins = data.get("plugins")
     plugin_dirs = data.get("plugin_dirs")
     assert isinstance(plugins, list), "plugins must be a list of plugin name"
@@ -103,15 +111,10 @@ def load_from_toml(file_path: str, encoding: str = "utf-8") -> Set[Plugin]:
         data = tomlkit.parse(f.read())  # type: ignore
 
     nonebot_data = data.get("tool", {}).get("nonebot")
-    if not nonebot_data:
-        nonebot_data = data.get("nonebot", {}).get("plugins")
-        if nonebot_data:
-            warnings.warn(
-                "[nonebot.plugins] table is deprecated. Use [tool.nonebot] instead.",
-                DeprecationWarning,
-            )
-        else:
-            raise ValueError("Cannot find '[tool.nonebot]' in given toml file!")
+    if nonebot_data is None:
+        raise ValueError("Cannot find '[tool.nonebot]' in given toml file!")
+    if not isinstance(nonebot_data, dict):
+        raise TypeError("'[tool.nonebot]' must be a Table!")
     plugins = nonebot_data.get("plugins", [])
     plugin_dirs = nonebot_data.get("plugin_dirs", [])
     assert isinstance(plugins, list), "plugins must be a list of plugin name"
@@ -128,7 +131,7 @@ def load_builtin_plugin(name: str) -> Optional[Plugin]:
     return load_plugin(f"nonebot.plugins.{name}")
 
 
-def load_builtin_plugins(*plugins) -> Set[Plugin]:
+def load_builtin_plugins(*plugins: str) -> Set[Plugin]:
     """导入多个 NoneBot 内置插件。
 
     参数:
@@ -143,7 +146,7 @@ def _find_manager_by_name(name: str) -> Optional[PluginManager]:
             return manager
 
 
-def require(name: str) -> Export:
+def require(name: str) -> ModuleType:
     """获取一个插件的导出内容。
 
     如果为 `load_plugins` 文件夹导入的插件，则为文件(夹)名。
@@ -154,13 +157,12 @@ def require(name: str) -> Export:
     异常:
         RuntimeError: 插件无法加载
     """
-    plugin = get_plugin(name.rsplit(".", 1)[-1])
+    plugin = get_plugin(_module_name_to_plugin_name(name))
     if not plugin:
-        manager = _find_manager_by_name(name)
-        if manager:
+        if manager := _find_manager_by_name(name):
             plugin = manager.load_plugin(name)
         else:
             plugin = load_plugin(name)
-        if not plugin:
-            raise RuntimeError(f'Cannot load plugin "{name}"!')
-    return plugin.export
+    if not plugin:
+        raise RuntimeError(f'Cannot load plugin "{name}"!')
+    return plugin.module

nonebot/plugin/manager.py

@@ -14,97 +14,136 @@ from itertools import chain
 from types import ModuleType
 from importlib.abc import MetaPathFinder
 from importlib.machinery import PathFinder, SourceFileLoader
-from typing import Set, Dict, List, Union, Iterable, Optional, Sequence
+from typing import Set, Dict, List, Iterable, Optional, Sequence
 
 from nonebot.log import logger
-from nonebot.utils import escape_tag
+from nonebot.utils import escape_tag, path_to_module_name
 
-from . import _managers, _current_plugin
-from .plugin import Plugin, _new_plugin, _confirm_plugin
+from .plugin import Plugin, PluginMetadata
+from . import (
+    _managers,
+    _new_plugin,
+    _revert_plugin,
+    _current_plugin_chain,
+    _module_name_to_plugin_name,
+)
 
 
 class PluginManager:
+    """插件管理器。
+
+    参数:
+        plugins: 独立插件模块名集合。
+        search_path: 插件搜索路径（文件夹）。
+    """
+
     def __init__(
         self,
         plugins: Optional[Iterable[str]] = None,
         search_path: Optional[Iterable[str]] = None,
     ):
-
         # simple plugin not in search path
         self.plugins: Set[str] = set(plugins or [])
         self.search_path: Set[str] = set(search_path or [])
+
         # cache plugins
-        self.searched_plugins: Dict[str, Path] = {}
-        self.list_plugins()
+        self._third_party_plugin_names: Dict[str, str] = {}
+        self._searched_plugin_names: Dict[str, Path] = {}
+        self.prepare_plugins()
 
-    def _path_to_module_name(self, path: Path) -> str:
-        rel_path = path.resolve().relative_to(Path(".").resolve())
-        if rel_path.stem == "__init__":
-            return ".".join(rel_path.parts[:-1])
-        else:
-            return ".".join(rel_path.parts[:-1] + (rel_path.stem,))
+    def __repr__(self) -> str:
+        return f"PluginManager(plugins={self.plugins}, search_path={self.search_path})"
 
-    def _previous_plugins(self) -> List[str]:
+    @property
+    def third_party_plugins(self) -> Set[str]:
+        """返回所有独立插件名称。"""
+        return set(self._third_party_plugin_names.keys())
+
+    @property
+    def searched_plugins(self) -> Set[str]:
+        """返回已搜索到的插件名称。"""
+        return set(self._searched_plugin_names.keys())
+
+    @property
+    def available_plugins(self) -> Set[str]:
+        """返回当前插件管理器中可用的插件名称。"""
+        return self.third_party_plugins | self.searched_plugins
+
+    def _previous_plugins(self) -> Set[str]:
         _pre_managers: List[PluginManager]
         if self in _managers:
             _pre_managers = _managers[: _managers.index(self)]
         else:
             _pre_managers = _managers[:]
 
-        return [
-            *chain.from_iterable(
-                [
-                    *map(lambda x: x.rsplit(".", 1)[-1], manager.plugins),
-                    *manager.searched_plugins.keys(),
-                ]
-                for manager in _pre_managers
-            )
-        ]
+        return {
+            *chain.from_iterable(manager.available_plugins for manager in _pre_managers)
+        }
 
-    def list_plugins(self) -> Set[str]:
+    def prepare_plugins(self) -> Set[str]:
+        """搜索插件并缓存插件名称。"""
         # get all previous ready to load plugins
         previous_plugins = self._previous_plugins()
         searched_plugins: Dict[str, Path] = {}
-        third_party_plugins: Set[str] = set()
+        third_party_plugins: Dict[str, str] = {}
 
+        # check third party plugins
         for plugin in self.plugins:
-            name = plugin.rsplit(".", 1)[-1]
+            name = _module_name_to_plugin_name(plugin)
             if name in third_party_plugins or name in previous_plugins:
                 raise RuntimeError(
                     f"Plugin already exists: {name}! Check your plugin name"
                 )
-            third_party_plugins.add(plugin)
+            third_party_plugins[name] = plugin
 
+        self._third_party_plugin_names = third_party_plugins
+
+        # check plugins in search path
         for module_info in pkgutil.iter_modules(self.search_path):
+            # ignore if startswith "_"
             if module_info.name.startswith("_"):
                 continue
+
             if (
-                module_info.name in searched_plugins.keys()
+                module_info.name in searched_plugins
                 or module_info.name in previous_plugins
                 or module_info.name in third_party_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)
-            if not module_spec:
+
+            if not (
+                module_spec := module_info.module_finder.find_spec(
+                    module_info.name, None
+                )
+            ):
                 continue
-            module_path = module_spec.origin
-            if not module_path:
+            if not (module_path := module_spec.origin):
                 continue
             searched_plugins[module_info.name] = Path(module_path).resolve()
 
-        self.searched_plugins = searched_plugins
+        self._searched_plugin_names = searched_plugins
 
-        return third_party_plugins | set(self.searched_plugins.keys())
+        return self.available_plugins
 
     def load_plugin(self, name: str) -> Optional[Plugin]:
+        """加载指定插件。
+
+        对于独立插件，可以使用完整插件模块名或者插件名称。
+
+        参数:
+            name: 插件名称。
+        """
+
         try:
             if name in self.plugins:
                 module = importlib.import_module(name)
-            elif name in self.searched_plugins:
+            elif name in self._third_party_plugin_names:
+                module = importlib.import_module(self._third_party_plugin_names[name])
+            elif name in self._searched_plugin_names:
                 module = importlib.import_module(
-                    self._path_to_module_name(self.searched_plugins[name])
+                    path_to_module_name(self._searched_plugin_names[name])
                 )
             else:
                 raise RuntimeError(f"Plugin not found: {name}! Check your plugin name")
@@ -112,8 +151,7 @@ class PluginManager:
             logger.opt(colors=True).success(
                 f'Succeeded to import "<y>{escape_tag(name)}</y>"'
             )
-            plugin = getattr(module, "__plugin__", None)
-            if plugin is None:
+            if (plugin := getattr(module, "__plugin__", None)) is None:
                 raise RuntimeError(
                     f"Module {module.__name__} is not loaded as a plugin! "
                     "Make sure not to import it before loading."
@@ -125,8 +163,10 @@ 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.available_plugins))
         )
 
 
@@ -134,7 +174,7 @@ class PluginFinder(MetaPathFinder):
     def find_spec(
         self,
         fullname: str,
-        path: Optional[Sequence[Union[bytes, str]]],
+        path: Optional[Sequence[str]],
         target: Optional[ModuleType] = None,
     ):
         if _managers:
@@ -147,9 +187,10 @@ class PluginFinder(MetaPathFinder):
             module_path = Path(module_origin).resolve()
 
             for manager in reversed(_managers):
+                # use path instead of name in case of submodule name conflict
                 if (
                     fullname in manager.plugins
-                    or module_path in manager.searched_plugins.values()
+                    or module_path in manager._searched_plugin_names.values()
                 ):
                     module_spec.loader = PluginLoader(manager, fullname, module_origin)
                     return module_spec
@@ -173,29 +214,34 @@ class PluginLoader(SourceFileLoader):
         if self.loaded:
             return
 
+        # create plugin before executing
         plugin = _new_plugin(self.name, module, self.manager)
-        parent_plugin = _current_plugin.get()
-        if parent_plugin and _managers.index(parent_plugin.manager) < _managers.index(
-            self.manager
-        ):
-            plugin.parent_plugin = parent_plugin
-            parent_plugin.sub_plugins.add(plugin)
-
-        _plugin_token = _current_plugin.set(plugin)
-
         setattr(module, "__plugin__", plugin)
 
-        # try:
-        #     super().exec_module(module)
-        # except Exception as e:
-        #     raise ImportError(
-        #         f"Error when executing module {module_name} from {module.__file__}."
-        #     ) from e
-        super().exec_module(module)
+        # detect parent plugin before entering current plugin context
+        parent_plugins = _current_plugin_chain.get()
+        for pre_plugin in reversed(parent_plugins):
+            if _managers.index(pre_plugin.manager) < _managers.index(self.manager):
+                plugin.parent_plugin = pre_plugin
+                pre_plugin.sub_plugins.add(plugin)
+                break
 
-        _confirm_plugin(plugin)
+        # enter plugin context
+        _plugin_token = _current_plugin_chain.set(parent_plugins + (plugin,))
+
+        try:
+            super().exec_module(module)
+        except Exception:
+            _revert_plugin(plugin)
+            raise
+        finally:
+            # leave plugin context
+            _current_plugin_chain.reset(_plugin_token)
+
+        # get plugin metadata
+        metadata: Optional[PluginMetadata] = getattr(module, "__plugin_meta__", None)
+        plugin.metadata = metadata
 
-        _current_plugin.reset(_plugin_token)
         return
 
 

nonebot/plugin/on.py

@@ -5,11 +5,12 @@ FrontMatter:
     description: nonebot.plugin.on 模块
 """
 import re
-import sys
 import inspect
 from types import ModuleType
+from datetime import datetime, timedelta
 from typing import Any, Set, Dict, List, Type, Tuple, Union, Optional
 
+from nonebot.adapters import Event
 from nonebot.matcher import Matcher
 from nonebot.permission import Permission
 from nonebot.dependencies import Dependent
@@ -19,6 +20,7 @@ from nonebot.rule import (
     ArgumentParser,
     regex,
     command,
+    is_type,
     keyword,
     endswith,
     fullmatch,
@@ -26,14 +28,13 @@ from nonebot.rule import (
     shell_command,
 )
 
-from .manager import _current_plugin
+from .manager import _current_plugin_chain
 
 
 def _store_matcher(matcher: Type[Matcher]) -> None:
-    plugin = _current_plugin.get()
     # only store the matcher defined in the plugin
-    if plugin:
-        plugin.matcher.add(matcher)
+    if plugins := _current_plugin_chain.get():
+        plugins[-1].matcher.add(matcher)
 
 
 def _get_matcher_module(depth: int = 1) -> Optional[ModuleType]:
@@ -41,8 +42,7 @@ def _get_matcher_module(depth: int = 1) -> Optional[ModuleType]:
     if current_frame is None:
         return None
     frame = inspect.getouterframes(current_frame)[depth + 1].frame
-    module_name = frame.f_globals["__name__"]
-    return sys.modules.get(module_name)
+    return inspect.getmodule(frame)
 
 
 def on(
@@ -52,13 +52,13 @@ def on(
     *,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = None,
     temp: bool = False,
+    expire_time: Optional[Union[datetime, timedelta]] = None,
     priority: int = 1,
     block: bool = False,
     state: Optional[T_State] = None,
     _depth: int = 0,
 ) -> Type[Matcher]:
-    """
-    注册一个基础事件响应器，可自定义类型。
+    """注册一个基础事件响应器，可自定义类型。
 
     参数:
         type: 事件响应器类型
@@ -66,19 +66,22 @@ def on(
         permission: 事件响应权限
         handlers: 事件处理函数列表
         temp: 是否为临时事件响应器（仅执行一次）
+        expire_time: 事件响应器最终有效时间点，过时即被删除
         priority: 事件响应器优先级
         block: 是否阻止事件向更低优先级传递
         state: 默认 state
     """
+    plugin_chain = _current_plugin_chain.get()
     matcher = Matcher.new(
         type,
         Rule() & rule,
         Permission() | permission,
         temp=temp,
+        expire_time=expire_time,
         priority=priority,
         block=block,
         handlers=handlers,
-        plugin=_current_plugin.get(),
+        plugin=plugin_chain[-1] if plugin_chain else None,
         module=_get_matcher_module(_depth + 1),
         default_state=state,
     )
@@ -91,31 +94,34 @@ def on_metaevent(
     *,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = None,
     temp: bool = False,
+    expire_time: Optional[Union[datetime, timedelta]] = None,
     priority: int = 1,
     block: bool = False,
     state: Optional[T_State] = None,
     _depth: int = 0,
 ) -> Type[Matcher]:
-    """
-    注册一个元事件响应器。
+    """注册一个元事件响应器。
 
     参数:
         rule: 事件响应规则
         handlers: 事件处理函数列表
         temp: 是否为临时事件响应器（仅执行一次）
+        expire_time: 事件响应器最终有效时间点，过时即被删除
         priority: 事件响应器优先级
         block: 是否阻止事件向更低优先级传递
         state: 默认 state
     """
+    plugin_chain = _current_plugin_chain.get()
     matcher = Matcher.new(
         "meta_event",
         Rule() & rule,
         Permission(),
         temp=temp,
+        expire_time=expire_time,
         priority=priority,
         block=block,
         handlers=handlers,
-        plugin=_current_plugin.get(),
+        plugin=plugin_chain[-1] if plugin_chain else None,
         module=_get_matcher_module(_depth + 1),
         default_state=state,
     )
@@ -129,32 +135,35 @@ def on_message(
     *,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = None,
     temp: bool = False,
+    expire_time: Optional[Union[datetime, timedelta]] = None,
     priority: int = 1,
     block: bool = True,
     state: Optional[T_State] = None,
     _depth: int = 0,
 ) -> Type[Matcher]:
-    """
-    注册一个消息事件响应器。
+    """注册一个消息事件响应器。
 
     参数:
         rule: 事件响应规则
         permission: 事件响应权限
         handlers: 事件处理函数列表
         temp: 是否为临时事件响应器（仅执行一次）
+        expire_time: 事件响应器最终有效时间点，过时即被删除
         priority: 事件响应器优先级
         block: 是否阻止事件向更低优先级传递
         state: 默认 state
     """
+    plugin_chain = _current_plugin_chain.get()
     matcher = Matcher.new(
         "message",
         Rule() & rule,
         Permission() | permission,
         temp=temp,
+        expire_time=expire_time,
         priority=priority,
         block=block,
         handlers=handlers,
-        plugin=_current_plugin.get(),
+        plugin=plugin_chain[-1] if plugin_chain else None,
         module=_get_matcher_module(_depth + 1),
         default_state=state,
     )
@@ -167,31 +176,34 @@ def on_notice(
     *,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = None,
     temp: bool = False,
+    expire_time: Optional[Union[datetime, timedelta]] = None,
     priority: int = 1,
     block: bool = False,
     state: Optional[T_State] = None,
     _depth: int = 0,
 ) -> Type[Matcher]:
-    """
-    注册一个通知事件响应器。
+    """注册一个通知事件响应器。
 
     参数:
         rule: 事件响应规则
         handlers: 事件处理函数列表
         temp: 是否为临时事件响应器（仅执行一次）
+        expire_time: 事件响应器最终有效时间点，过时即被删除
         priority: 事件响应器优先级
         block: 是否阻止事件向更低优先级传递
         state: 默认 state
     """
+    plugin_chain = _current_plugin_chain.get()
     matcher = Matcher.new(
         "notice",
         Rule() & rule,
         Permission(),
         temp=temp,
+        expire_time=expire_time,
         priority=priority,
         block=block,
         handlers=handlers,
-        plugin=_current_plugin.get(),
+        plugin=plugin_chain[-1] if plugin_chain else None,
         module=_get_matcher_module(_depth + 1),
         default_state=state,
     )
@@ -204,31 +216,34 @@ def on_request(
     *,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = None,
     temp: bool = False,
+    expire_time: Optional[Union[datetime, timedelta]] = None,
     priority: int = 1,
     block: bool = False,
     state: Optional[T_State] = None,
     _depth: int = 0,
 ) -> Type[Matcher]:
-    """
-    注册一个请求事件响应器。
+    """注册一个请求事件响应器。
 
     参数:
         rule: 事件响应规则
         handlers: 事件处理函数列表
         temp: 是否为临时事件响应器（仅执行一次）
+        expire_time: 事件响应器最终有效时间点，过时即被删除
         priority: 事件响应器优先级
         block: 是否阻止事件向更低优先级传递
         state: 默认 state
     """
+    plugin_chain = _current_plugin_chain.get()
     matcher = Matcher.new(
         "request",
         Rule() & rule,
         Permission(),
         temp=temp,
+        expire_time=expire_time,
         priority=priority,
         block=block,
         handlers=handlers,
-        plugin=_current_plugin.get(),
+        plugin=plugin_chain[-1] if plugin_chain else None,
         module=_get_matcher_module(_depth + 1),
         default_state=state,
     )
@@ -243,8 +258,7 @@ def on_startswith(
     _depth: int = 0,
     **kwargs,
 ) -> Type[Matcher]:
-    """
-    注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。
+    """注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。
 
     参数:
         msg: 指定消息开头内容
@@ -253,6 +267,7 @@ def on_startswith(
         permission: 事件响应权限
         handlers: 事件处理函数列表
         temp: 是否为临时事件响应器（仅执行一次）
+        expire_time: 事件响应器最终有效时间点，过时即被删除
         priority: 事件响应器优先级
         block: 是否阻止事件向更低优先级传递
         state: 默认 state
@@ -267,8 +282,7 @@ def on_endswith(
     _depth: int = 0,
     **kwargs,
 ) -> Type[Matcher]:
-    """
-    注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。
+    """注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。
 
     参数:
         msg: 指定消息结尾内容
@@ -277,6 +291,7 @@ def on_endswith(
         permission: 事件响应权限
         handlers: 事件处理函数列表
         temp: 是否为临时事件响应器（仅执行一次）
+        expire_time: 事件响应器最终有效时间点，过时即被删除
         priority: 事件响应器优先级
         block: 是否阻止事件向更低优先级传递
         state: 默认 state
@@ -291,8 +306,7 @@ def on_fullmatch(
     _depth: int = 0,
     **kwargs,
 ) -> Type[Matcher]:
-    """
-    注册一个消息事件响应器，并且当消息的**文本部分**与指定内容完全一致时响应。
+    """注册一个消息事件响应器，并且当消息的**文本部分**与指定内容完全一致时响应。
 
     参数:
         msg: 指定消息全匹配内容
@@ -301,6 +315,7 @@ def on_fullmatch(
         permission: 事件响应权限
         handlers: 事件处理函数列表
         temp: 是否为临时事件响应器（仅执行一次）
+        expire_time: 事件响应器最终有效时间点，过时即被删除
         priority: 事件响应器优先级
         block: 是否阻止事件向更低优先级传递
         state: 默认 state
@@ -314,8 +329,7 @@ def on_keyword(
     _depth: int = 0,
     **kwargs,
 ) -> Type[Matcher]:
-    """
-    注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。
+    """注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。
 
     参数:
         keywords: 关键词列表
@@ -323,6 +337,7 @@ def on_keyword(
         permission: 事件响应权限
         handlers: 事件处理函数列表
         temp: 是否为临时事件响应器（仅执行一次）
+        expire_time: 事件响应器最终有效时间点，过时即被删除
         priority: 事件响应器优先级
         block: 是否阻止事件向更低优先级传递
         state: 默认 state
@@ -337,8 +352,7 @@ def on_command(
     _depth: int = 0,
     **kwargs,
 ) -> Type[Matcher]:
-    """
-    注册一个消息事件响应器，并且当消息以指定命令开头时响应。
+    """注册一个消息事件响应器，并且当消息以指定命令开头时响应。
 
     命令匹配规则参考: `命令形式匹配 <rule.md#command-command>`_
 
@@ -349,12 +363,13 @@ def on_command(
         permission: 事件响应权限
         handlers: 事件处理函数列表
         temp: 是否为临时事件响应器（仅执行一次）
+        expire_time: 事件响应器最终有效时间点，过时即被删除
         priority: 事件响应器优先级
         block: 是否阻止事件向更低优先级传递
         state: 默认 state
     """
 
-    commands = set([cmd]) | (aliases or set())
+    commands = {cmd} | (aliases or set())
     block = kwargs.pop("block", False)
     return on_message(
         command(*commands) & rule, block=block, **kwargs, _depth=_depth + 1
@@ -369,8 +384,7 @@ def on_shell_command(
     _depth: int = 0,
     **kwargs,
 ) -> Type[Matcher]:
-    """
-    注册一个支持 `shell_like` 解析参数的命令消息事件响应器。
+    """注册一个支持 `shell_like` 解析参数的命令消息事件响应器。
 
     与普通的 `on_command` 不同的是，在添加 `parser` 参数时, 响应器会自动处理消息。
 
@@ -384,12 +398,13 @@ def on_shell_command(
         permission: 事件响应权限
         handlers: 事件处理函数列表
         temp: 是否为临时事件响应器（仅执行一次）
+        expire_time: 事件响应器最终有效时间点，过时即被删除
         priority: 事件响应器优先级
         block: 是否阻止事件向更低优先级传递
         state: 默认 state
     """
 
-    commands = set([cmd]) | (aliases or set())
+    commands = {cmd} | (aliases or set())
     return on_message(
         shell_command(*commands, parser=parser) & rule,
         **kwargs,
@@ -404,8 +419,7 @@ def on_regex(
     _depth: int = 0,
     **kwargs,
 ) -> Type[Matcher]:
-    """
-    注册一个消息事件响应器，并且当消息匹配正则表达式时响应。
+    """注册一个消息事件响应器，并且当消息匹配正则表达式时响应。
 
     命令匹配规则参考: `正则匹配 <rule.md#regex-regex-flags-0>`_
 
@@ -416,6 +430,7 @@ def on_regex(
         permission: 事件响应权限
         handlers: 事件处理函数列表
         temp: 是否为临时事件响应器（仅执行一次）
+        expire_time: 事件响应器最终有效时间点，过时即被删除
         priority: 事件响应器优先级
         block: 是否阻止事件向更低优先级传递
         state: 默认 state
@@ -423,78 +438,134 @@ def on_regex(
     return on_message(regex(pattern, flags) & rule, **kwargs, _depth=_depth + 1)
 
 
-class CommandGroup:
-    """命令组，用于声明一组有相同名称前缀的命令。"""
+def on_type(
+    types: Union[Type[Event], Tuple[Type[Event], ...]],
+    rule: Optional[Union[Rule, T_RuleChecker]] = None,
+    *,
+    _depth: int = 0,
+    **kwargs,
+) -> Type[Matcher]:
+    """注册一个事件响应器，并且当事件为指定类型时响应。
+
+    参数:
+        types: 事件类型
+        rule: 事件响应规则
+        permission: 事件响应权限
+        handlers: 事件处理函数列表
+        temp: 是否为临时事件响应器（仅执行一次）
+        expire_time: 事件响应器最终有效时间点，过时即被删除
+        priority: 事件响应器优先级
+        block: 是否阻止事件向更低优先级传递
+        state: 默认 state
+    """
+    event_types = types if isinstance(types, tuple) else (types,)
+    return on(rule=is_type(*event_types) & rule, **kwargs, _depth=_depth + 1)
+
+
+class _Group:
+    def __init__(self, **kwargs):
+        """创建一个事件响应器组合，参数为默认值，与 `on` 一致"""
+        self.matchers: List[Type[Matcher]] = []
+        """组内事件响应器列表"""
+        self.base_kwargs: Dict[str, Any] = kwargs
+        """其他传递给 `on` 的参数默认值"""
+
+    def _get_final_kwargs(
+        self, update: Dict[str, Any], *, exclude: Optional[Set[str]] = None
+    ) -> Dict[str, Any]:
+        """获取最终传递给 `on` 的参数
+
+        参数:
+            update: 更新的关键字参数
+            exclude: 需要排除的参数
+        """
+        final_kwargs = self.base_kwargs.copy()
+        final_kwargs.update(update)
+        if exclude:
+            for key in exclude:
+                final_kwargs.pop(key, None)
+        final_kwargs["_depth"] = 1
+        return final_kwargs
+
+
+class CommandGroup(_Group):
+    """命令组，用于声明一组有相同名称前缀的命令。
+
+    参数:
+        cmd: 指定命令内容
+        rule: 事件响应规则
+        permission: 事件响应权限
+        handlers: 事件处理函数列表
+        temp: 是否为临时事件响应器（仅执行一次）
+        expire_time: 事件响应器最终有效时间点，过时即被删除
+        priority: 事件响应器优先级
+        block: 是否阻止事件向更低优先级传递
+        state: 默认 state
+    """
 
     def __init__(self, cmd: Union[str, Tuple[str, ...]], **kwargs):
-        """
-        参数:
-            cmd: 命令前缀
-            **kwargs: `on_command` 的参数默认值，参考 `on_command <#on-command-cmd-rule-none-aliases-none-kwargs>`_
-        """
+        """命令前缀"""
+        super().__init__(**kwargs)
         self.basecmd: Tuple[str, ...] = (cmd,) if isinstance(cmd, str) else cmd
-        """
-        命令前缀
-        """
-        if "aliases" in kwargs:
-            del kwargs["aliases"]
-        self.base_kwargs: Dict[str, Any] = kwargs
-        """
-        其他传递给 `on_command` 的参数默认值
-        """
+        self.base_kwargs.pop("aliases", None)
+
+    def __repr__(self) -> str:
+        return f"CommandGroup(cmd={self.basecmd}, matchers={len(self.matchers)})"
 
     def command(self, cmd: Union[str, Tuple[str, ...]], **kwargs) -> Type[Matcher]:
-        """
-        注册一个新的命令。
+        """注册一个新的命令。新参数将会覆盖命令组默认值
 
         参数:
-            cmd: 命令前缀
-            **kwargs: `on_command` 的参数，将会覆盖命令组默认值
+            cmd: 指定命令内容
+            aliases: 命令别名
+            rule: 事件响应规则
+            permission: 事件响应权限
+            handlers: 事件处理函数列表
+            temp: 是否为临时事件响应器（仅执行一次）
+            expire_time: 事件响应器最终有效时间点，过时即被删除
+            priority: 事件响应器优先级
+            block: 是否阻止事件向更低优先级传递
+            state: 默认 state
         """
         sub_cmd = (cmd,) if isinstance(cmd, str) else cmd
         cmd = self.basecmd + sub_cmd
-
-        final_kwargs = self.base_kwargs.copy()
-        final_kwargs.update(kwargs)
-        return on_command(cmd, **final_kwargs, _depth=1)
+        matcher = on_command(cmd, **self._get_final_kwargs(kwargs))
+        self.matchers.append(matcher)
+        return matcher
 
     def shell_command(
         self, cmd: Union[str, Tuple[str, ...]], **kwargs
     ) -> Type[Matcher]:
-        """
-        注册一个新的命令。
+        """注册一个新的 `shell_like` 命令。新参数将会覆盖命令组默认值
 
         参数:
-            cmd: 命令前缀
-            **kwargs: `on_shell_command` 的参数，将会覆盖命令组默认值
+            cmd: 指定命令内容
+            rule: 事件响应规则
+            aliases: 命令别名
+            parser: `nonebot.rule.ArgumentParser` 对象
+            permission: 事件响应权限
+            handlers: 事件处理函数列表
+            temp: 是否为临时事件响应器（仅执行一次）
+            expire_time: 事件响应器最终有效时间点，过时即被删除
+            priority: 事件响应器优先级
+            block: 是否阻止事件向更低优先级传递
+            state: 默认 state
         """
         sub_cmd = (cmd,) if isinstance(cmd, str) else cmd
         cmd = self.basecmd + sub_cmd
-
-        final_kwargs = self.base_kwargs.copy()
-        final_kwargs.update(kwargs)
-        return on_shell_command(cmd, **final_kwargs, _depth=1)
+        matcher = on_shell_command(cmd, **self._get_final_kwargs(kwargs))
+        self.matchers.append(matcher)
+        return matcher
 
 
-class MatcherGroup:
+class MatcherGroup(_Group):
     """事件响应器组合，统一管理。为 `Matcher` 创建提供默认属性。"""
 
-    def __init__(self, **kwargs):
-        """
-        创建一个事件响应器组合，参数为默认值，与 `on` 一致
-        """
-        self.matchers: List[Type[Matcher]] = []
-        """
-        组内事件响应器列表
-        """
-        self.base_kwargs: Dict[str, Any] = kwargs
-        """
-        其他传递给 `on` 的参数默认值
-        """
+    def __repr__(self) -> str:
+        return f"MatcherGroup(matchers={len(self.matchers)})"
 
     def on(self, **kwargs) -> Type[Matcher]:
-        """
-        注册一个基础事件响应器，可自定义类型。
+        """注册一个基础事件响应器，可自定义类型。
 
         参数:
             type: 事件响应器类型
@@ -502,99 +573,88 @@ class MatcherGroup:
             permission: 事件响应权限
             handlers: 事件处理函数列表
             temp: 是否为临时事件响应器（仅执行一次）
+            expire_time: 事件响应器最终有效时间点，过时即被删除
             priority: 事件响应器优先级
             block: 是否阻止事件向更低优先级传递
             state: 默认 state
         """
-        final_kwargs = self.base_kwargs.copy()
-        final_kwargs.update(kwargs)
-        matcher = on(**final_kwargs, _depth=1)
+        matcher = on(**self._get_final_kwargs(kwargs))
         self.matchers.append(matcher)
         return matcher
 
     def on_metaevent(self, **kwargs) -> Type[Matcher]:
-        """
-        注册一个元事件响应器。
+        """注册一个元事件响应器。
 
         参数:
             rule: 事件响应规则
             handlers: 事件处理函数列表
             temp: 是否为临时事件响应器（仅执行一次）
+            expire_time: 事件响应器最终有效时间点，过时即被删除
             priority: 事件响应器优先级
             block: 是否阻止事件向更低优先级传递
             state: 默认 state
         """
-        final_kwargs = self.base_kwargs.copy()
-        final_kwargs.update(kwargs)
-        final_kwargs.pop("type", None)
-        final_kwargs.pop("permission", None)
-        matcher = on_metaevent(**final_kwargs, _depth=1)
+        final_kwargs = self._get_final_kwargs(kwargs, exclude={"type", "permission"})
+        matcher = on_metaevent(**final_kwargs)
         self.matchers.append(matcher)
         return matcher
 
     def on_message(self, **kwargs) -> Type[Matcher]:
-        """
-        注册一个消息事件响应器。
+        """注册一个消息事件响应器。
 
         参数:
             rule: 事件响应规则
             permission: 事件响应权限
             handlers: 事件处理函数列表
             temp: 是否为临时事件响应器（仅执行一次）
+            expire_time: 事件响应器最终有效时间点，过时即被删除
             priority: 事件响应器优先级
             block: 是否阻止事件向更低优先级传递
             state: 默认 state
         """
-        final_kwargs = self.base_kwargs.copy()
-        final_kwargs.update(kwargs)
-        final_kwargs.pop("type", None)
-        matcher = on_message(**final_kwargs, _depth=1)
+        final_kwargs = self._get_final_kwargs(kwargs, exclude={"type"})
+        matcher = on_message(**final_kwargs)
         self.matchers.append(matcher)
         return matcher
 
     def on_notice(self, **kwargs) -> Type[Matcher]:
-        """
-        注册一个通知事件响应器。
+        """注册一个通知事件响应器。
 
         参数:
             rule: 事件响应规则
             handlers: 事件处理函数列表
             temp: 是否为临时事件响应器（仅执行一次）
+            expire_time: 事件响应器最终有效时间点，过时即被删除
             priority: 事件响应器优先级
             block: 是否阻止事件向更低优先级传递
             state: 默认 state
         """
-        final_kwargs = self.base_kwargs.copy()
-        final_kwargs.update(kwargs)
-        final_kwargs.pop("type", None)
-        matcher = on_notice(**final_kwargs, _depth=1)
+        final_kwargs = self._get_final_kwargs(kwargs, exclude={"type", "permission"})
+        matcher = on_notice(**final_kwargs)
         self.matchers.append(matcher)
         return matcher
 
     def on_request(self, **kwargs) -> Type[Matcher]:
-        """
-        注册一个请求事件响应器。
+        """注册一个请求事件响应器。
 
         参数:
             rule: 事件响应规则
             handlers: 事件处理函数列表
             temp: 是否为临时事件响应器（仅执行一次）
+            expire_time: 事件响应器最终有效时间点，过时即被删除
             priority: 事件响应器优先级
             block: 是否阻止事件向更低优先级传递
             state: 默认 state
         """
-        final_kwargs = self.base_kwargs.copy()
-        final_kwargs.update(kwargs)
-        final_kwargs.pop("type", None)
-        matcher = on_request(**final_kwargs, _depth=1)
+        final_kwargs = self._get_final_kwargs(kwargs, exclude={"type", "permission"})
+        matcher = on_request(**final_kwargs)
         self.matchers.append(matcher)
         return matcher
 
     def on_startswith(
         self, msg: Union[str, Tuple[str, ...]], **kwargs
     ) -> Type[Matcher]:
-        """
-        注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。
+        """注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。
 
         参数:
             msg: 指定消息开头内容
@@ -603,20 +663,18 @@ class MatcherGroup:
             permission: 事件响应权限
             handlers: 事件处理函数列表
             temp: 是否为临时事件响应器（仅执行一次）
+            expire_time: 事件响应器最终有效时间点，过时即被删除
             priority: 事件响应器优先级
             block: 是否阻止事件向更低优先级传递
             state: 默认 state
         """
-        final_kwargs = self.base_kwargs.copy()
-        final_kwargs.update(kwargs)
-        final_kwargs.pop("type", None)
-        matcher = on_startswith(msg, **final_kwargs, _depth=1)
+        final_kwargs = self._get_final_kwargs(kwargs, exclude={"type"})
+        matcher = on_startswith(msg, **final_kwargs)
         self.matchers.append(matcher)
         return matcher
 
     def on_endswith(self, msg: Union[str, Tuple[str, ...]], **kwargs) -> Type[Matcher]:
-        """
-        注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。
+        """注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。
 
         参数:
             msg: 指定消息结尾内容
@@ -625,20 +683,18 @@ class MatcherGroup:
             permission: 事件响应权限
             handlers: 事件处理函数列表
             temp: 是否为临时事件响应器（仅执行一次）
+            expire_time: 事件响应器最终有效时间点，过时即被删除
             priority: 事件响应器优先级
             block: 是否阻止事件向更低优先级传递
             state: 默认 state
         """
-        final_kwargs = self.base_kwargs.copy()
-        final_kwargs.update(kwargs)
-        final_kwargs.pop("type", None)
-        matcher = on_endswith(msg, **final_kwargs, _depth=1)
+        final_kwargs = self._get_final_kwargs(kwargs, exclude={"type"})
+        matcher = on_endswith(msg, **final_kwargs)
         self.matchers.append(matcher)
         return matcher
 
     def on_fullmatch(self, msg: Union[str, Tuple[str, ...]], **kwargs) -> Type[Matcher]:
-        """
-        注册一个消息事件响应器，并且当消息的**文本部分**与指定内容完全一致时响应。
+        """注册一个消息事件响应器，并且当消息的**文本部分**与指定内容完全一致时响应。
 
         参数:
             msg: 指定消息全匹配内容
@@ -647,20 +703,18 @@ class MatcherGroup:
             permission: 事件响应权限
             handlers: 事件处理函数列表
             temp: 是否为临时事件响应器（仅执行一次）
+            expire_time: 事件响应器最终有效时间点，过时即被删除
             priority: 事件响应器优先级
             block: 是否阻止事件向更低优先级传递
             state: 默认 state
         """
-        final_kwargs = self.base_kwargs.copy()
-        final_kwargs.update(kwargs)
-        final_kwargs.pop("type", None)
-        matcher = on_fullmatch(msg, **final_kwargs, _depth=1)
+        final_kwargs = self._get_final_kwargs(kwargs, exclude={"type"})
+        matcher = on_fullmatch(msg, **final_kwargs)
         self.matchers.append(matcher)
         return matcher
 
     def on_keyword(self, keywords: Set[str], **kwargs) -> Type[Matcher]:
-        """
-        注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。
+        """注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。
 
         参数:
             keywords: 关键词列表
@@ -668,14 +722,13 @@ class MatcherGroup:
             permission: 事件响应权限
             handlers: 事件处理函数列表
             temp: 是否为临时事件响应器（仅执行一次）
+            expire_time: 事件响应器最终有效时间点，过时即被删除
             priority: 事件响应器优先级
             block: 是否阻止事件向更低优先级传递
             state: 默认 state
         """
-        final_kwargs = self.base_kwargs.copy()
-        final_kwargs.update(kwargs)
-        final_kwargs.pop("type", None)
-        matcher = on_keyword(keywords, **final_kwargs, _depth=1)
+        final_kwargs = self._get_final_kwargs(kwargs, exclude={"type"})
+        matcher = on_keyword(keywords, **final_kwargs)
         self.matchers.append(matcher)
         return matcher
 
@@ -685,8 +738,7 @@ class MatcherGroup:
         aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = None,
         **kwargs,
     ) -> Type[Matcher]:
-        """
-        注册一个消息事件响应器，并且当消息以指定命令开头时响应。
+        """注册一个消息事件响应器，并且当消息以指定命令开头时响应。
 
         命令匹配规则参考: `命令形式匹配 <rule.md#command-command>`_
 
@@ -697,14 +749,13 @@ class MatcherGroup:
             permission: 事件响应权限
             handlers: 事件处理函数列表
             temp: 是否为临时事件响应器（仅执行一次）
+            expire_time: 事件响应器最终有效时间点，过时即被删除
             priority: 事件响应器优先级
             block: 是否阻止事件向更低优先级传递
             state: 默认 state
         """
-        final_kwargs = self.base_kwargs.copy()
-        final_kwargs.update(kwargs)
-        final_kwargs.pop("type", None)
-        matcher = on_command(cmd, aliases=aliases, **final_kwargs, _depth=1)
+        final_kwargs = self._get_final_kwargs(kwargs, exclude={"type"})
+        matcher = on_command(cmd, aliases=aliases, **final_kwargs)
         self.matchers.append(matcher)
         return matcher
 
@@ -715,8 +766,7 @@ class MatcherGroup:
         parser: Optional[ArgumentParser] = None,
         **kwargs,
     ) -> Type[Matcher]:
-        """
-        注册一个支持 `shell_like` 解析参数的命令消息事件响应器。
+        """注册一个支持 `shell_like` 解析参数的命令消息事件响应器。
 
         与普通的 `on_command` 不同的是，在添加 `parser` 参数时, 响应器会自动处理消息。
 
@@ -730,24 +780,20 @@ class MatcherGroup:
             permission: 事件响应权限
             handlers: 事件处理函数列表
             temp: 是否为临时事件响应器（仅执行一次）
+            expire_time: 事件响应器最终有效时间点，过时即被删除
             priority: 事件响应器优先级
             block: 是否阻止事件向更低优先级传递
             state: 默认 state
         """
-        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
-        )
+        final_kwargs = self._get_final_kwargs(kwargs, exclude={"type"})
+        matcher = on_shell_command(cmd, aliases=aliases, parser=parser, **final_kwargs)
         self.matchers.append(matcher)
         return matcher
 
     def on_regex(
         self, pattern: str, flags: Union[int, re.RegexFlag] = 0, **kwargs
     ) -> Type[Matcher]:
-        """
-        注册一个消息事件响应器，并且当消息匹配正则表达式时响应。
+        """注册一个消息事件响应器，并且当消息匹配正则表达式时响应。
 
         命令匹配规则参考: `正则匹配 <rule.md#regex-regex-flags-0>`_
 
@@ -758,13 +804,33 @@ class MatcherGroup:
             permission: 事件响应权限
             handlers: 事件处理函数列表
             temp: 是否为临时事件响应器（仅执行一次）
+            expire_time: 事件响应器最终有效时间点，过时即被删除
             priority: 事件响应器优先级
             block: 是否阻止事件向更低优先级传递
             state: 默认 state
         """
-        final_kwargs = self.base_kwargs.copy()
-        final_kwargs.update(kwargs)
-        final_kwargs.pop("type", None)
-        matcher = on_regex(pattern, flags=flags, **final_kwargs, _depth=1)
+        final_kwargs = self._get_final_kwargs(kwargs, exclude={"type"})
+        matcher = on_regex(pattern, flags=flags, **final_kwargs)
+        self.matchers.append(matcher)
+        return matcher
+
+    def on_type(
+        self, types: Union[Type[Event], Tuple[Type[Event]]], **kwargs
+    ) -> Type[Matcher]:
+        """注册一个事件响应器，并且当事件为指定类型时响应。
+
+        参数:
+            types: 事件类型
+            rule: 事件响应规则
+            permission: 事件响应权限
+            handlers: 事件处理函数列表
+            temp: 是否为临时事件响应器（仅执行一次）
+            expire_time: 事件响应器最终有效时间点，过时即被删除
+            priority: 事件响应器优先级
+            block: 是否阻止事件向更低优先级传递
+            state: 默认 state
+        """
+        final_kwargs = self._get_final_kwargs(kwargs, exclude={"type"})
+        matcher = on_type(types, **final_kwargs)
         self.matchers.append(matcher)
         return matcher

nonebot/plugin/on.pyi

@@ -1,6 +1,8 @@
 import re
+from datetime import datetime, timedelta
 from typing import Set, List, Type, Tuple, Union, Optional
 
+from nonebot.adapters import Event
 from nonebot.matcher import Matcher
 from nonebot.permission import Permission
 from nonebot.dependencies import Dependent
@@ -14,6 +16,7 @@ def on(
     *,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
     temp: bool = ...,
+    expire_time: Optional[Union[datetime, timedelta]] = ...,
     priority: int = ...,
     block: bool = ...,
     state: Optional[T_State] = ...,
@@ -23,6 +26,7 @@ def on_metaevent(
     *,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
     temp: bool = ...,
+    expire_time: Optional[Union[datetime, timedelta]] = ...,
     priority: int = ...,
     block: bool = ...,
     state: Optional[T_State] = ...,
@@ -33,6 +37,7 @@ def on_message(
     *,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
     temp: bool = ...,
+    expire_time: Optional[Union[datetime, timedelta]] = ...,
     priority: int = ...,
     block: bool = ...,
     state: Optional[T_State] = ...,
@@ -42,6 +47,7 @@ def on_notice(
     *,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
     temp: bool = ...,
+    expire_time: Optional[Union[datetime, timedelta]] = ...,
     priority: int = ...,
     block: bool = ...,
     state: Optional[T_State] = ...,
@@ -51,6 +57,7 @@ def on_request(
     *,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
     temp: bool = ...,
+    expire_time: Optional[Union[datetime, timedelta]] = ...,
     priority: int = ...,
     block: bool = ...,
     state: Optional[T_State] = ...,
@@ -63,6 +70,7 @@ def on_startswith(
     permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
     temp: bool = ...,
+    expire_time: Optional[Union[datetime, timedelta]] = ...,
     priority: int = ...,
     block: bool = ...,
     state: Optional[T_State] = ...,
@@ -75,6 +83,7 @@ def on_endswith(
     permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
     temp: bool = ...,
+    expire_time: Optional[Union[datetime, timedelta]] = ...,
     priority: int = ...,
     block: bool = ...,
     state: Optional[T_State] = ...,
@@ -87,6 +96,7 @@ def on_fullmatch(
     permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
     temp: bool = ...,
+    expire_time: Optional[Union[datetime, timedelta]] = ...,
     priority: int = ...,
     block: bool = ...,
     state: Optional[T_State] = ...,
@@ -98,6 +108,7 @@ def on_keyword(
     permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
     temp: bool = ...,
+    expire_time: Optional[Union[datetime, timedelta]] = ...,
     priority: int = ...,
     block: bool = ...,
     state: Optional[T_State] = ...,
@@ -110,6 +121,7 @@ def on_command(
     permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
     temp: bool = ...,
+    expire_time: Optional[Union[datetime, timedelta]] = ...,
     priority: int = ...,
     block: bool = ...,
     state: Optional[T_State] = ...,
@@ -123,6 +135,7 @@ def on_shell_command(
     permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
     temp: bool = ...,
+    expire_time: Optional[Union[datetime, timedelta]] = ...,
     priority: int = ...,
     block: bool = ...,
     state: Optional[T_State] = ...,
@@ -135,6 +148,19 @@ def on_regex(
     permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
     handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
     temp: bool = ...,
+    expire_time: Optional[Union[datetime, timedelta]] = ...,
+    priority: int = ...,
+    block: bool = ...,
+    state: Optional[T_State] = ...,
+) -> Type[Matcher]: ...
+def on_type(
+    types: Union[Type[Event], Tuple[Type[Event], ...]],
+    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    *,
+    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+    handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+    temp: bool = ...,
+    expire_time: Optional[Union[datetime, timedelta]] = ...,
     priority: int = ...,
     block: bool = ...,
     state: Optional[T_State] = ...,
@@ -149,6 +175,7 @@ class CommandGroup:
         permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,
@@ -157,11 +184,12 @@ class CommandGroup:
         self,
         cmd: Union[str, Tuple[str, ...]],
         *,
-        aliases: Optional[Set[Union[str, Tuple[str, ...]]]],
         rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
         permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,
@@ -171,11 +199,12 @@ class CommandGroup:
         cmd: Union[str, Tuple[str, ...]],
         *,
         rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        aliases: Optional[Set[Union[str, Tuple[str, ...]]]],
+        aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
         parser: Optional[ArgumentParser] = ...,
         permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,
@@ -190,6 +219,7 @@ class MatcherGroup:
         permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,
@@ -202,6 +232,7 @@ class MatcherGroup:
         permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,
@@ -212,6 +243,7 @@ class MatcherGroup:
         rule: Optional[Union[Rule, T_RuleChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,
@@ -223,6 +255,7 @@ class MatcherGroup:
         permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,
@@ -233,6 +266,7 @@ class MatcherGroup:
         rule: Optional[Union[Rule, T_RuleChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,
@@ -243,6 +277,7 @@ class MatcherGroup:
         rule: Optional[Union[Rule, T_RuleChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,
@@ -256,6 +291,7 @@ class MatcherGroup:
         permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,
@@ -269,6 +305,7 @@ class MatcherGroup:
         permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,
@@ -282,6 +319,7 @@ class MatcherGroup:
         permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,
@@ -294,6 +332,7 @@ class MatcherGroup:
         permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,
@@ -307,6 +346,7 @@ class MatcherGroup:
         permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,
@@ -321,6 +361,7 @@ class MatcherGroup:
         permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,
@@ -334,6 +375,20 @@ class MatcherGroup:
         permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
         handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
         temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
+        priority: int = ...,
+        block: bool = ...,
+        state: Optional[T_State] = ...,
+    ) -> Type[Matcher]: ...
+    def on_type(
+        self,
+        types: Union[Type[Event], Tuple[Type[Event]]],
+        *,
+        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        temp: bool = ...,
+        expire_time: Optional[Union[datetime, timedelta]] = ...,
         priority: int = ...,
         block: bool = ...,
         state: Optional[T_State] = ...,

nonebot/plugin/plugin.py

@@ -6,66 +6,50 @@ FrontMatter:
 """
 from types import ModuleType
 from dataclasses import field, dataclass
-from typing import TYPE_CHECKING, Set, Dict, Type, Optional
+from typing import TYPE_CHECKING, Any, Set, Dict, Type, Optional
+
+from pydantic import BaseModel
 
 from nonebot.matcher import Matcher
 
-from .export import Export
+# FIXME: backport for nonebug
+from . import _plugins as plugins  # nopycln: import
 
 if TYPE_CHECKING:
     from .manager import PluginManager
 
-plugins: Dict[str, "Plugin"] = {}
-"""已加载的插件"""
+
+@dataclass(eq=False)
+class PluginMetadata:
+    """插件元信息，由插件编写者提供"""
+
+    name: str
+    """插件可阅读名称"""
+    description: str
+    """插件功能介绍"""
+    usage: str
+    """插件使用方法"""
+    config: Optional[Type[BaseModel]] = None
+    """插件配置项"""
+    extra: Dict[Any, Any] = field(default_factory=dict)
 
 
 @dataclass(eq=False)
-class Plugin(object):
+class Plugin:
     """存储插件信息"""
 
     name: str
-    """插件名称，使用 文件/文件夹 名称作为插件名"""
+    """插件索引标识，NoneBot 使用 文件/文件夹 名称作为标识符"""
     module: ModuleType
     """插件模块对象"""
     module_name: str
     """点分割模块路径"""
     manager: "PluginManager"
     """导入该插件的插件管理器"""
-    export: Export = field(default_factory=Export)
-    """插件内定义的导出内容"""
     matcher: Set[Type[Matcher]] = field(default_factory=set)
     """插件内定义的 `Matcher`"""
     parent_plugin: Optional["Plugin"] = None
     """父插件"""
     sub_plugins: Set["Plugin"] = field(default_factory=set)
     """子插件集合"""
-
-
-def get_plugin(name: str) -> Optional[Plugin]:
-    """获取已经导入的某个插件。
-
-    如果为 `load_plugins` 文件夹导入的插件，则为文件(夹)名。
-
-    参数:
-        name: 插件名，即 {ref}`nonebot.plugin.plugin.Plugin.name`。
-    """
-    return plugins.get(name)
-
-
-def get_loaded_plugins() -> Set[Plugin]:
-    """获取当前已导入的所有插件。"""
-    return set(plugins.values())
-
-
-def _new_plugin(fullname: str, module: ModuleType, manager: "PluginManager") -> Plugin:
-    name = fullname.rsplit(".", 1)[-1] if "." in fullname else fullname
-    if name in plugins:
-        raise RuntimeError("Plugin already exists! Check your plugin name.")
-    plugin = Plugin(name, module, fullname, manager)
-    return plugin
-
-
-def _confirm_plugin(plugin: Plugin) -> None:
-    if plugin.name in plugins:
-        raise RuntimeError("Plugin already exists! Check your plugin name.")
-    plugins[plugin.name] = plugin
+    metadata: Optional[PluginMetadata] = None

nonebot/plugins/echo.py

@@ -7,5 +7,5 @@ echo = on_command("echo", to_me())
 
 
 @echo.handle()
-async def echo_escape(message: Message = CommandArg()):
+async def handle_echo(message: Message = CommandArg()):
     await echo.send(message=message)

nonebot/plugins/single_session.py

@@ -15,8 +15,7 @@ async def matcher_mutex(event: Event) -> AsyncGenerator[bool, None]:
         yield result
     else:
         current_event_id = id(event)
-        event_id = _running_matcher.get(session_id, None)
-        if event_id:
+        if event_id := _running_matcher.get(session_id, None):
             result = event_id != current_event_id
         else:
             _running_matcher[session_id] = current_event_id

nonebot/rule.py

@@ -10,11 +10,27 @@ FrontMatter:
 
 import re
 import shlex
-from itertools import product
-from argparse import Namespace
-from typing_extensions import TypedDict
+from argparse import Action
+from argparse import ArgumentError
+from contextvars import ContextVar
+from itertools import chain, product
+from argparse import Namespace as Namespace
 from argparse import ArgumentParser as ArgParser
-from typing import Any, List, Tuple, Union, Optional, Sequence, NamedTuple
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    List,
+    Type,
+    Tuple,
+    Union,
+    TypeVar,
+    Optional,
+    Sequence,
+    TypedDict,
+    NamedTuple,
+    cast,
+    overload,
+)
 
 from pygtrie import CharTrie
 
@@ -23,28 +39,28 @@ from nonebot.log import logger
 from nonebot.typing import T_State
 from nonebot.exception import ParserExit
 from nonebot.internal.rule import Rule as Rule
+from nonebot.params import Command, EventToMe, CommandArg
 from nonebot.adapters import Bot, Event, Message, MessageSegment
-from nonebot.params import (
-    Command,
-    EventToMe,
-    EventType,
-    CommandArg,
-    EventMessage,
-    EventPlainText,
-)
 from nonebot.consts import (
     CMD_KEY,
+    REGEX_STR,
     PREFIX_KEY,
     REGEX_DICT,
     SHELL_ARGS,
     SHELL_ARGV,
     CMD_ARG_KEY,
+    KEYWORD_KEY,
     RAW_CMD_KEY,
     REGEX_GROUP,
+    ENDSWITH_KEY,
     CMD_START_KEY,
+    FULLMATCH_KEY,
     REGEX_MATCHED,
+    STARTSWITH_KEY,
 )
 
+T = TypeVar("T")
+
 CMD_RESULT = TypedDict(
     "CMD_RESULT",
     {
@@ -59,6 +75,8 @@ TRIE_VALUE = NamedTuple(
     "TRIE_VALUE", [("command_start", str), ("command", Tuple[str, ...])]
 )
 
+parser_message: ContextVar[str] = ContextVar("parser_message")
+
 
 class TrieRule:
     prefix: CharTrie = CharTrie()
@@ -83,8 +101,7 @@ class TrieRule:
         message_seg: MessageSegment = message[0]
         if message_seg.is_text():
             segment_text = str(message_seg).lstrip()
-            pf = cls.prefix.longest_prefix(segment_text)
-            if pf:
+            if pf := cls.prefix.longest_prefix(segment_text):
                 value: TRIE_VALUE = pf.value
                 prefix[RAW_CMD_KEY] = pf.key
                 prefix[CMD_START_KEY] = value.command_start
@@ -113,19 +130,35 @@ class StartswithRule:
         self.msg = msg
         self.ignorecase = ignorecase
 
-    async def __call__(
-        self, type: str = EventType(), text: str = EventPlainText()
-    ) -> Any:
-        if type != "message":
-            return False
-        return bool(
-            re.match(
-                f"^(?:{'|'.join(re.escape(prefix) for prefix in self.msg)})",
-                text,
-                re.IGNORECASE if self.ignorecase else 0,
-            )
+    def __repr__(self) -> str:
+        return f"Startswith(msg={self.msg}, ignorecase={self.ignorecase})"
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, StartswithRule)
+            and frozenset(self.msg) == frozenset(other.msg)
+            and self.ignorecase == other.ignorecase
         )
 
+    def __hash__(self) -> int:
+        return hash((frozenset(self.msg), self.ignorecase))
+
+    async def __call__(self, event: Event, state: T_State) -> bool:
+        if event.get_type() != "message":
+            return False
+        try:
+            text = event.get_plaintext()
+        except Exception:
+            return False
+        if match := re.match(
+            f"^(?:{'|'.join(re.escape(prefix) for prefix in self.msg)})",
+            text,
+            re.IGNORECASE if self.ignorecase else 0,
+        ):
+            state[STARTSWITH_KEY] = match.group()
+            return True
+        return False
+
 
 def startswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule:
     """匹配消息纯文本开头。
@@ -154,19 +187,35 @@ class EndswithRule:
         self.msg = msg
         self.ignorecase = ignorecase
 
-    async def __call__(
-        self, type: str = EventType(), text: str = EventPlainText()
-    ) -> Any:
-        if type != "message":
-            return False
-        return bool(
-            re.search(
-                f"(?:{'|'.join(re.escape(prefix) for prefix in self.msg)})$",
-                text,
-                re.IGNORECASE if self.ignorecase else 0,
-            )
+    def __repr__(self) -> str:
+        return f"Endswith(msg={self.msg}, ignorecase={self.ignorecase})"
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, EndswithRule)
+            and frozenset(self.msg) == frozenset(other.msg)
+            and self.ignorecase == other.ignorecase
         )
 
+    def __hash__(self) -> int:
+        return hash((frozenset(self.msg), self.ignorecase))
+
+    async def __call__(self, event: Event, state: T_State) -> bool:
+        if event.get_type() != "message":
+            return False
+        try:
+            text = event.get_plaintext()
+        except Exception:
+            return False
+        if match := re.search(
+            f"(?:{'|'.join(re.escape(suffix) for suffix in self.msg)})$",
+            text,
+            re.IGNORECASE if self.ignorecase else 0,
+        ):
+            state[ENDSWITH_KEY] = match.group()
+            return True
+        return False
+
 
 def endswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule:
     """匹配消息纯文本结尾。
@@ -192,17 +241,37 @@ class FullmatchRule:
     __slots__ = ("msg", "ignorecase")
 
     def __init__(self, msg: Tuple[str, ...], ignorecase: bool = False):
-        self.msg = frozenset(map(str.casefold, msg) if ignorecase else msg)
+        self.msg = tuple(map(str.casefold, msg) if ignorecase else msg)
         self.ignorecase = ignorecase
 
-    async def __call__(
-        self, type_: str = EventType(), text: str = EventPlainText()
-    ) -> bool:
+    def __repr__(self) -> str:
+        return f"Fullmatch(msg={self.msg}, ignorecase={self.ignorecase})"
+
+    def __eq__(self, other: object) -> bool:
         return (
-            type_ == "message"
-            and (text.casefold() if self.ignorecase else text) in self.msg
+            isinstance(other, FullmatchRule)
+            and frozenset(self.msg) == frozenset(other.msg)
+            and self.ignorecase == other.ignorecase
         )
 
+    def __hash__(self) -> int:
+        return hash((frozenset(self.msg), self.ignorecase))
+
+    async def __call__(self, event: Event, state: T_State) -> bool:
+        if event.get_type() != "message":
+            return False
+        try:
+            text = event.get_plaintext()
+        except Exception:
+            return False
+        if not text:
+            return False
+        text = text.casefold() if self.ignorecase else text
+        if text in self.msg:
+            state[FULLMATCH_KEY] = text
+            return True
+        return False
+
 
 def fullmatch(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule:
     """完全匹配消息。
@@ -229,12 +298,30 @@ class KeywordsRule:
     def __init__(self, *keywords: str):
         self.keywords = keywords
 
-    async def __call__(
-        self, type: str = EventType(), text: str = EventPlainText()
-    ) -> bool:
-        if type != "message":
+    def __repr__(self) -> str:
+        return f"Keywords(keywords={self.keywords})"
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, KeywordsRule) and frozenset(
+            self.keywords
+        ) == frozenset(other.keywords)
+
+    def __hash__(self) -> int:
+        return hash(frozenset(self.keywords))
+
+    async def __call__(self, event: Event, state: T_State) -> bool:
+        if event.get_type() != "message":
             return False
-        return bool(text and any(keyword in text for keyword in self.keywords))
+        try:
+            text = event.get_plaintext()
+        except Exception:
+            return False
+        if not text:
+            return False
+        if key := next((k for k in self.keywords if k in text), None):
+            state[KEYWORD_KEY] = key
+            return True
+        return False
 
 
 def keyword(*keywords: str) -> Rule:
@@ -257,14 +344,22 @@ class CommandRule:
     __slots__ = ("cmds",)
 
     def __init__(self, cmds: List[Tuple[str, ...]]):
-        self.cmds = cmds
+        self.cmds = tuple(cmds)
+
+    def __repr__(self) -> str:
+        return f"Command(cmds={self.cmds})"
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, CommandRule) and frozenset(self.cmds) == frozenset(
+            other.cmds
+        )
+
+    def __hash__(self) -> int:
+        return hash((frozenset(self.cmds),))
 
     async def __call__(self, cmd: Optional[Tuple[str, ...]] = Command()) -> bool:
         return cmd in self.cmds
 
-    def __repr__(self):
-        return f"<Command {self.cmds}>"
-
 
 def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule:
     """匹配消息命令。
@@ -320,25 +415,50 @@ class ArgumentParser(ArgParser):
         参考文档: [argparse](https://docs.python.org/3/library/argparse.html)
     """
 
-    def _print_message(self, message, file=None):
-        old_message: str = getattr(self, "message", "")
-        if old_message:
-            old_message += "\n"
-        old_message += message
-        setattr(self, "message", old_message)
+    if TYPE_CHECKING:
 
-    def exit(self, status: int = 0, message: Optional[str] = None):
-        raise ParserExit(
-            status=status, message=message or getattr(self, "message", None)
+        @overload
+        def parse_args(
+            self, args: Optional[Sequence[Union[str, MessageSegment]]] = ...
+        ) -> Namespace:
+            ...
+
+        @overload
+        def parse_args(
+            self, args: Optional[Sequence[Union[str, MessageSegment]]], namespace: None
+        ) -> Namespace:
+            ...  # type: ignore[misc]
+
+        @overload
+        def parse_args(
+            self, args: Optional[Sequence[Union[str, MessageSegment]]], namespace: T
+        ) -> T:
+            ...
+
+        def parse_args(
+            self,
+            args: Optional[Sequence[Union[str, MessageSegment]]] = None,
+            namespace: Optional[T] = None,
+        ) -> Union[Namespace, T]:
+            ...
+
+    def _parse_optional(
+        self, arg_string: Union[str, MessageSegment]
+    ) -> Optional[Tuple[Optional[Action], str, Optional[str]]]:
+        return (
+            super()._parse_optional(arg_string) if isinstance(arg_string, str) else None
         )
 
-    def parse_args(
-        self,
-        args: Optional[Sequence[str]] = None,
-        namespace: Optional[Namespace] = None,
-    ) -> Namespace:
-        setattr(self, "message", "")
-        return super().parse_args(args=args, namespace=namespace)  # type: ignore
+    def _print_message(self, message: str, file: Optional[IO[str]] = None):
+        if (msg := parser_message.get(None)) is not None:
+            parser_message.set(msg + message)
+        else:
+            super()._print_message(message, file)
+
+    def exit(self, status: int = 0, message: Optional[str] = None):
+        if message:
+            self._print_message(message)
+        raise ParserExit(status=status, message=parser_message.get(None))
 
 
 class ShellCommandRule:
@@ -352,28 +472,51 @@ class ShellCommandRule:
     __slots__ = ("cmds", "parser")
 
     def __init__(self, cmds: List[Tuple[str, ...]], parser: Optional[ArgumentParser]):
-        self.cmds = cmds
+        self.cmds = tuple(cmds)
         self.parser = parser
 
+    def __repr__(self) -> str:
+        return f"ShellCommand(cmds={self.cmds}, parser={self.parser})"
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, ShellCommandRule)
+            and frozenset(self.cmds) == frozenset(other.cmds)
+            and self.parser is other.parser
+        )
+
+    def __hash__(self) -> int:
+        return hash((frozenset(self.cmds), self.parser))
+
     async def __call__(
         self,
         state: T_State,
         cmd: Optional[Tuple[str, ...]] = Command(),
         msg: Optional[Message] = CommandArg(),
     ) -> bool:
-        if cmd in self.cmds and msg is not None:
-            message = str(msg)
-            state[SHELL_ARGV] = shlex.split(message)
-            if self.parser:
-                try:
-                    args = self.parser.parse_args(state[SHELL_ARGV])
-                    state[SHELL_ARGS] = args
-                except ParserExit as e:
-                    state[SHELL_ARGS] = e
-            return True
-        else:
+        if cmd not in self.cmds or msg is None:
             return False
 
+        state[SHELL_ARGV] = list(
+            chain.from_iterable(
+                shlex.split(str(seg)) if cast(MessageSegment, seg).is_text() else (seg,)
+                for seg in msg
+            )
+        )
+
+        if self.parser:
+            t = parser_message.set("")
+            try:
+                args = self.parser.parse_args(state[SHELL_ARGV])
+                state[SHELL_ARGS] = args
+            except ArgumentError as e:
+                state[SHELL_ARGS] = ParserExit(status=2, message=str(e))
+            except ParserExit as e:
+                state[SHELL_ARGS] = e
+            finally:
+                parser_message.reset(t)
+        return True
+
 
 def shell_command(
     *cmds: Union[str, Tuple[str, ...]], parser: Optional[ArgumentParser] = None
@@ -452,17 +595,29 @@ class RegexRule:
         self.regex = regex
         self.flags = flags
 
-    async def __call__(
-        self,
-        state: T_State,
-        type: str = EventType(),
-        msg: Message = EventMessage(),
-    ) -> bool:
-        if type != "message":
+    def __repr__(self) -> str:
+        return f"Regex(regex={self.regex!r}, flags={self.flags})"
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, RegexRule)
+            and self.regex == other.regex
+            and self.flags == other.flags
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.regex, self.flags))
+
+    async def __call__(self, event: Event, state: T_State) -> bool:
+        if event.get_type() != "message":
             return False
-        matched = re.search(self.regex, str(msg), self.flags)
-        if matched:
+        try:
+            msg = event.get_message()
+        except Exception:
+            return False
+        if matched := re.search(self.regex, str(msg), self.flags):
             state[REGEX_MATCHED] = matched.group()
+            state[REGEX_STR] = matched.group()
             state[REGEX_GROUP] = matched.groups()
             state[REGEX_DICT] = matched.groupdict()
             return True
@@ -473,7 +628,7 @@ class RegexRule:
 def regex(regex: str, flags: Union[int, re.RegexFlag] = 0) -> Rule:
     """匹配符合正则表达式的消息字符串。
 
-    可以通过 {ref}`nonebot.params.RegexMatched` 获取匹配成功的字符串，
+    可以通过 {ref}`nonebot.params.RegexStr` 获取匹配成功的字符串，
     通过 {ref}`nonebot.params.RegexGroup` 获取匹配成功的 group 元组，
     通过 {ref}`nonebot.params.RegexDict` 获取匹配成功的 group 字典。
 
@@ -498,6 +653,15 @@ class ToMeRule:
 
     __slots__ = ()
 
+    def __repr__(self) -> str:
+        return "ToMe()"
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, ToMeRule)
+
+    def __hash__(self) -> int:
+        return hash((self.__class__,))
+
     async def __call__(self, to_me: bool = EventToMe()) -> bool:
         return to_me
 
@@ -508,6 +672,37 @@ def to_me() -> Rule:
     return Rule(ToMeRule())
 
 
+class IsTypeRule:
+    """检查事件类型是否为指定类型。"""
+
+    __slots__ = ("types",)
+
+    def __init__(self, *types: Type[Event]):
+        self.types = types
+
+    def __repr__(self) -> str:
+        return f"IsType(types={tuple(type.__name__ for type in self.types)})"
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, IsTypeRule) and self.types == other.types
+
+    def __hash__(self) -> int:
+        return hash((self.types,))
+
+    async def __call__(self, event: Event) -> bool:
+        return isinstance(event, self.types)
+
+
+def is_type(*types: Type[Event]) -> Rule:
+    """匹配事件类型。
+
+    参数:
+        types: 事件类型
+    """
+
+    return Rule(IsTypeRule(*types))
+
+
 __autodoc__ = {
     "Rule": True,
     "Rule.__call__": True,

nonebot/typing.py

@@ -11,6 +11,7 @@ FrontMatter:
     sidebar_position: 11
     description: nonebot.typing 模块
 """
+
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -28,6 +29,8 @@ if TYPE_CHECKING:
     from nonebot.adapters import Bot
     from nonebot.permission import Permission
 
+T = TypeVar("T")
+
 T_Wrapped = TypeVar("T_Wrapped", bound=Callable)
 
 
@@ -41,10 +44,14 @@ def overrides(InterfaceClass: object) -> Callable[[T_Wrapped], T_Wrapped]:
     return overrider
 
 
+# state
 T_State = Dict[Any, Any]
 """事件处理状态 State 类型"""
 
-T_BotConnectionHook = Callable[..., Awaitable[Any]]
+_DependentCallable = Union[Callable[..., T], Callable[..., Awaitable[T]]]
+
+# driver hooks
+T_BotConnectionHook = _DependentCallable[Any]
 """Bot 连接建立时钩子函数
 
 依赖参数:
@@ -53,7 +60,7 @@ T_BotConnectionHook = Callable[..., Awaitable[Any]]
 - BotParam: Bot 对象
 - DefaultParam: 带有默认值的参数
 """
-T_BotDisconnectionHook = Callable[..., Awaitable[Any]]
+T_BotDisconnectionHook = _DependentCallable[Any]
 """Bot 连接断开时钩子函数
 
 依赖参数:
@@ -62,6 +69,8 @@ T_BotDisconnectionHook = Callable[..., Awaitable[Any]]
 - BotParam: Bot 对象
 - DefaultParam: 带有默认值的参数
 """
+
+# api hooks
 T_CallingAPIHook = Callable[["Bot", str, Dict[str, Any]], Awaitable[Any]]
 """`bot.call_api` 钩子函数"""
 T_CalledAPIHook = Callable[
@@ -69,7 +78,8 @@ T_CalledAPIHook = Callable[
 ]
 """`bot.call_api` 后执行的函数，参数分别为 bot, exception, api, data, result"""
 
-T_EventPreProcessor = Callable[..., Union[Any, Awaitable[Any]]]
+# event hooks
+T_EventPreProcessor = _DependentCallable[Any]
 """事件预处理函数 EventPreProcessor 类型
 
 依赖参数:
@@ -80,7 +90,7 @@ T_EventPreProcessor = Callable[..., Union[Any, Awaitable[Any]]]
 - StateParam: State 对象
 - DefaultParam: 带有默认值的参数
 """
-T_EventPostProcessor = Callable[..., Union[Any, Awaitable[Any]]]
+T_EventPostProcessor = _DependentCallable[Any]
 """事件预处理函数 EventPostProcessor 类型
 
 依赖参数:
@@ -91,7 +101,9 @@ T_EventPostProcessor = Callable[..., Union[Any, Awaitable[Any]]]
 - StateParam: State 对象
 - DefaultParam: 带有默认值的参数
 """
-T_RunPreProcessor = Callable[..., Union[Any, Awaitable[Any]]]
+
+# matcher run hooks
+T_RunPreProcessor = _DependentCallable[Any]
 """事件响应器运行前预处理函数 RunPreProcessor 类型
 
 依赖参数:
@@ -103,8 +115,8 @@ T_RunPreProcessor = Callable[..., Union[Any, Awaitable[Any]]]
 - MatcherParam: Matcher 对象
 - DefaultParam: 带有默认值的参数
 """
-T_RunPostProcessor = Callable[..., Union[Any, Awaitable[Any]]]
-"""事件响应器运行前预处理函数 RunPostProcessor 类型
+T_RunPostProcessor = _DependentCallable[Any]
+"""事件响应器运行后后处理函数 RunPostProcessor 类型
 
 依赖参数:
 
@@ -117,7 +129,8 @@ T_RunPostProcessor = Callable[..., Union[Any, Awaitable[Any]]]
 - DefaultParam: 带有默认值的参数
 """
 
-T_RuleChecker = Callable[..., Union[bool, Awaitable[bool]]]
+# rule, permission
+T_RuleChecker = _DependentCallable[bool]
 """RuleChecker 即判断是否响应事件的处理函数。
 
 依赖参数:
@@ -128,7 +141,7 @@ T_RuleChecker = Callable[..., Union[bool, Awaitable[bool]]]
 - StateParam: State 对象
 - DefaultParam: 带有默认值的参数
 """
-T_PermissionChecker = Callable[..., Union[bool, Awaitable[bool]]]
+T_PermissionChecker = _DependentCallable[bool]
 """PermissionChecker 即判断事件是否满足权限的处理函数。
 
 依赖参数:
@@ -139,9 +152,9 @@ T_PermissionChecker = Callable[..., Union[bool, Awaitable[bool]]]
 - DefaultParam: 带有默认值的参数
 """
 
-T_Handler = Callable[..., Any]
+T_Handler = _DependentCallable[Any]
 """Handler 处理函数。"""
-T_TypeUpdater = Callable[..., Union[str, Awaitable[str]]]
+T_TypeUpdater = _DependentCallable[str]
 """TypeUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新响应的事件类型。默认会更新为 `message`。
 
 依赖参数:
@@ -153,7 +166,7 @@ T_TypeUpdater = Callable[..., Union[str, Awaitable[str]]]
 - MatcherParam: Matcher 对象
 - DefaultParam: 带有默认值的参数
 """
-T_PermissionUpdater = Callable[..., Union["Permission", Awaitable["Permission"]]]
+T_PermissionUpdater = _DependentCallable["Permission"]
 """PermissionUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新会话对象权限。默认会更新为当前事件的触发对象。
 
 依赖参数:
@@ -165,5 +178,5 @@ T_PermissionUpdater = Callable[..., Union["Permission", Awaitable["Permission"]]
 - MatcherParam: Matcher 对象
 - DefaultParam: 带有默认值的参数
 """
-T_DependencyCache = Dict[Callable[..., Any], "Task[Any]"]
+T_DependencyCache = Dict[_DependentCallable[Any], "Task[Any]"]
 """依赖缓存, 用于存储依赖函数的返回值"""

nonebot/utils.py

@@ -10,6 +10,7 @@ import json
 import asyncio
 import inspect
 import dataclasses
+from pathlib import Path
 from functools import wraps, partial
 from contextlib import asynccontextmanager
 from typing_extensions import ParamSpec, get_args, get_origin
@@ -24,6 +25,7 @@ from typing import (
     Coroutine,
     AsyncGenerator,
     ContextManager,
+    overload,
 )
 
 from pydantic.typing import is_union, is_none_type
@@ -62,12 +64,10 @@ def generic_check_issubclass(
     except TypeError:
         origin = get_origin(cls)
         if is_union(origin):
-            for type_ in get_args(cls):
-                if not is_none_type(type_) and not generic_check_issubclass(
-                    type_, class_or_tuple
-                ):
-                    return False
-            return True
+            return all(
+                is_none_type(type_) or generic_check_issubclass(type_, class_or_tuple)
+                for type_ in get_args(cls)
+            )
         elif origin:
             return issubclass(origin, class_or_tuple)
         return False
@@ -131,11 +131,28 @@ async def run_sync_ctx_manager(
         await run_sync(cm.__exit__)(None, None, None)
 
 
+@overload
 async def run_coro_with_catch(
     coro: Coroutine[Any, Any, T],
     exc: Tuple[Type[Exception], ...],
-    return_on_err: R = None,
+) -> Union[T, None]:
+    ...
+
+
+@overload
+async def run_coro_with_catch(
+    coro: Coroutine[Any, Any, T],
+    exc: Tuple[Type[Exception], ...],
+    return_on_err: R,
 ) -> Union[T, R]:
+    ...
+
+
+async def run_coro_with_catch(
+    coro: Coroutine[Any, Any, T],
+    exc: Tuple[Type[Exception], ...],
+    return_on_err: Optional[R] = None,
+) -> Optional[Union[T, R]]:
     try:
         return await coro
     except exc:
@@ -149,6 +166,14 @@ def get_name(obj: Any) -> str:
     return obj.__class__.__name__
 
 
+def path_to_module_name(path: Path) -> str:
+    rel_path = path.resolve().relative_to(Path(".").resolve())
+    if rel_path.stem == "__init__":
+        return ".".join(rel_path.parts[:-1])
+    else:
+        return ".".join(rel_path.parts[:-1] + (rel_path.stem,))
+
+
 class DataclassEncoder(json.JSONEncoder):
     """在JSON序列化 {re}`nonebot.adapters._message.Message` (List[Dataclass]) 时使用的 `JSONEncoder`"""
 
@@ -175,7 +200,7 @@ def logger_wrapper(logger_name: str):
 
     def log(level: str, message: str, exception: Optional[Exception] = None):
         logger.opt(colors=True, exception=exception).log(
-            level, f"<m>{escape_tag(logger_name)}</m> | " + message
+            level, f"<m>{escape_tag(logger_name)}</m> | {message}"
         )
 
     return log

package.json

@@ -11,7 +11,7 @@
     "start": "yarn workspace nonebot start",
     "serve": "yarn workspace nonebot serve",
     "clear": "yarn workspace nonebot clear",
-    "prettier": "prettier --config ./.prettierrc --write \"./website/**/*.md\""
+    "prettier": "prettier --config ./.prettierrc --write \"./website/\""
   },
   "devDependencies": {
     "cross-env": "^7.0.3",

packages/nonebot-plugin-docs/README.md

@@ -17,7 +17,7 @@ _✨ NoneBot 本地文档插件 ✨_
   <a href="https://pypi.python.org/pypi/nonebot-plugin-docs">
     <img src="https://img.shields.io/pypi/v/nonebot-plugin-docs.svg" alt="pypi">
   </a>
-  <img src="https://img.shields.io/badge/python-3.7+-blue.svg" alt="python">
+  <img src="https://img.shields.io/badge/python-3.8+-blue.svg" alt="python">
 </p>
 
 ## 使用方式

packages/nonebot-plugin-docs/pyproject.toml

@@ -12,7 +12,7 @@ include = ["nonebot_plugin_docs/dist/**/*"]
 
 
 [tool.poetry.dependencies]
-python = "^3.7.3"
+python = "^3.8"
 nonebot2 = "^2.0.0-beta.1"
 
 [tool.poetry.dev-dependencies]

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "nonebot2"
-version = "2.0.0-beta.3"
+version = "2.0.0rc3"
 description = "An asynchronous python bot framework."
 authors = ["yanyongyu <yyy@nonebot.dev>"]
 license = "MIT"
@@ -22,49 +22,56 @@ packages = [
 include = ["nonebot/py.typed"]
 
 [tool.poetry.dependencies]
-python = "^3.7.3"
+python = "^3.8"
 yarl = "^1.7.2"
 loguru = "^0.6.0"
 pygtrie = "^2.4.1"
-tomlkit = "^0.10.0"
-fastapi = "^0.78.0"
+tomlkit = ">=0.10.0,<1.0.0"
 typing-extensions = ">=3.10.0,<5.0.0"
-Quart = { version = "^0.17.0", optional = true }
-websockets = { version="^10.0", optional = true }
-pydantic = { version = "~1.9.0", extras = ["dotenv"] }
-uvicorn = { version = "^0.17.0", extras = ["standard"] }
-aiohttp = { version = "^3.7.4", extras = ["speedups"], optional = true }
-httpx = { version = ">=0.20.0, <1.0.0", extras = ["http2"], optional = true }
+pydantic = { version = "^1.10.0", extras = ["dotenv"] }
 
-[tool.poetry.dev-dependencies]
+websockets = { version = "^10.0", optional = true }
+Quart = { version = ">=0.18.0,<1.0.0", optional = true }
+fastapi = { version = ">=0.87.0,!=0.89.0,<1.0.0", optional = true }
+aiohttp = { version = "^3.7.4", extras = ["speedups"], optional = true }
+httpx = { version = ">=0.20.0,<1.0.0", extras = ["http2"], optional = true }
+uvicorn = { version = ">=0.20.0,<1.0.0", extras = ["standard"], optional = true }
+
+[tool.poetry.group.dev.dependencies]
+pycln = "^2.1.2"
 isort = "^5.10.1"
 black = "^22.1.0"
-pytest-cov = "^3.0.0"
+nonemoji = "^0.1.2"
 pre-commit = "^2.16.0"
-pytest-xdist = "^2.5.0"
-pytest-asyncio = "^0.18.1"
+
+[tool.poetry.group.test.dependencies]
+pytest-cov = "^4.0.0"
+pytest-xdist = "^3.0.2"
+pytest-asyncio = "^0.20.0"
 nonebug = { git = "https://github.com/nonebot/nonebug.git" }
+
+[tool.poetry.group.docs.dependencies]
 nb-autodoc = { git = "https://github.com/nonebot/nb-autodoc.git" }
 
 [tool.poetry.extras]
-quart = ["quart"]
 httpx = ["httpx"]
 aiohttp = ["aiohttp"]
 websockets = ["websockets"]
-all = ["quart", "aiohttp", "httpx", "websockets"]
-
-# [[tool.poetry.source]]
-# name = "aliyun"
-# url = "https://mirrors.aliyun.com/pypi/simple/"
-# default = true
+quart = ["quart", "uvicorn"]
+fastapi = ["fastapi", "uvicorn"]
+all = ["fastapi", "quart", "aiohttp", "httpx", "websockets", "uvicorn"]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"
 addopts = "--cov=nonebot --cov-report=term-missing"
+filterwarnings = [
+    "error",
+    "ignore::DeprecationWarning",
+]
 
 [tool.black]
 line-length = 88
-target-version = ["py37", "py38", "py39", "py310"]
+target-version = ["py38", "py39", "py310", "py311"]
 include = '\.pyi?$'
 extend-exclude = '''
 '''
@@ -78,6 +85,20 @@ force_sort_within_sections = true
 src_paths = ["nonebot", "tests"]
 extra_standard_library = ["typing_extensions"]
 
+[tool.pycln]
+path = "."
+all = false
+
+[tool.pyright]
+reportShadowedImports = false
+pythonVersion = "3.8"
+pythonPlatform = "All"
+executionEnvironments = [
+  { root = "./tests", extraPaths = ["./"] },
+  { root = "./" },
+]
+
+
 [build-system]
 requires = ["poetry_core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"

tests/.coveragerc

@@ -1,6 +1,7 @@
 [report]
 exclude_lines =
   def __repr__
+  def __str__
   pragma: no cover
   if TYPE_CHECKING:
   @(abc\.)?abstractmethod

tests/.env

@@ -1,2 +1,3 @@
 ENVIRONMENT=test
 COMMON_CONFIG=common
+COMMON_OVERRIDE=old

tests/.env.test

@@ -1,4 +1,13 @@
 LOG_LEVEL=TRACE
 NICKNAME=["test"]
 SUPERUSERS=["test", "fake:faketest"]
+COMMON_OVERRIDE=new
 CONFIG_FROM_ENV=
+CONFIG_OVERRIDE=old
+NESTED_DICT={"a": 1}
+NESTED_DICT__B=2
+NESTED_DICT__C__D=3
+NESTED_MISSING_DICT__A=1
+NESTED_MISSING_DICT__B__C=2
+NOT_NESTED=some string
+NOT_NESTED__A=1

tests/bad_plugins/bad_plugin.py

@@ -0,0 +1,6 @@
+import nonebot
+
+plugin = nonebot.get_plugin("bad_plugin")
+assert plugin
+
+x = 1 / 0

tests/plugins.invalid.json

@@ -0,0 +1 @@
+[]

tests/plugins.invalid.toml

@@ -0,0 +1,2 @@
+[tool]
+nonebot = []

tests/plugins.json

@@ -0,0 +1,4 @@
+{
+  "plugins": [],
+  "plugin_dirs": ["plugins"]
+}

tests/plugins.toml

@@ -0,0 +1,3 @@
+[tool.nonebot]
+plugins = []
+plugin_dirs = ["plugins"]

tests/plugins/_hidden.py

@@ -0,0 +1 @@
+assert False

tests/plugins/export.py

@@ -1,6 +1,2 @@
-from nonebot import export
-
-
-@export()
 def test():
-    ...
+    return "export"

tests/plugins/matcher/matcher_expire.py

@@ -0,0 +1,9 @@
+from datetime import datetime, timedelta
+
+from nonebot.matcher import Matcher
+
+test_temp_matcher = Matcher.new("test", temp=True)
+test_datetime_matcher = Matcher.new(
+    "test", expire_time=datetime.now() - timedelta(seconds=1)
+)
+test_timedelta_matcher = Matcher.new("test", expire_time=timedelta(seconds=-1))

tests/plugins/matcher/matcher_permission.py

@@ -1,10 +1,14 @@
 from nonebot.matcher import Matcher
-from nonebot.permission import Permission
+from nonebot.permission import USER, Permission
 
 default_permission = Permission()
 
 test_permission_updater = Matcher.new(permission=default_permission)
 
+test_user_permission_updater = Matcher.new(
+    permission=USER("test", perm=default_permission)
+)
+
 test_custom_updater = Matcher.new(permission=default_permission)
 
 

tests/plugins/metadata.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel
+
+from nonebot.plugin import PluginMetadata
+
+
+class Config(BaseModel):
+    custom: str = ""
+
+
+__plugin_meta__ = PluginMetadata(
+    name="测试插件",
+    description="测试插件元信息",
+    usage="无法使用",
+    config=Config,
+    extra={"author": "NoneBot"},
+)

tests/plugins/nested/__init__.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+
+import nonebot
+from nonebot.plugin import PluginManager, _managers
+
+manager = PluginManager(
+    search_path=[str((Path(__file__).parent / "plugins").resolve())]
+)
+_managers.append(manager)
+
+# test load nested plugin with require
+manager.load_plugin("nested_subplugin")
+manager.load_plugin("nested_subplugin2")

tests/plugins/nested/plugins/nested_subplugin.py

@@ -0,0 +1 @@
+from .nested_subplugin2 import a  # nopycln: import

tests/plugins/nested/plugins/nested_subplugin2.py

@@ -0,0 +1 @@
+a = "required by another subplugin"

tests/plugins/param/param_bot.py

@@ -1,3 +1,5 @@
+from typing import Union
+
 from nonebot.adapters import Bot
 
 
@@ -5,9 +7,29 @@ async def get_bot(b: Bot) -> Bot:
     return b
 
 
-class SubBot(Bot):
+async def legacy_bot(bot):
+    return bot
+
+
+async def not_legacy_bot(bot: int):
     ...
 
 
-async def sub_bot(b: SubBot) -> SubBot:
+class FooBot(Bot):
+    ...
+
+
+async def sub_bot(b: FooBot) -> FooBot:
     return b
+
+
+class BarBot(Bot):
+    ...
+
+
+async def union_bot(b: Union[FooBot, BarBot]) -> Union[FooBot, BarBot]:
+    return b
+
+
+async def not_bot(b: Union[int, Bot]):
+    ...

tests/plugins/param/param_event.py

@@ -1,3 +1,5 @@
+from typing import Union
+
 from nonebot.adapters import Event, Message
 from nonebot.params import EventToMe, EventType, EventMessage, EventPlainText
 
@@ -6,14 +8,34 @@ async def event(e: Event) -> Event:
     return e
 
 
-class SubEvent(Event):
+async def legacy_event(event):
+    return event
+
+
+async def not_legacy_event(event: int):
     ...
 
 
-async def sub_event(e: SubEvent) -> SubEvent:
+class FooEvent(Event):
+    ...
+
+
+async def sub_event(e: FooEvent) -> FooEvent:
     return e
 
 
+class BarEvent(Event):
+    ...
+
+
+async def union_event(e: Union[FooEvent, BarEvent]) -> Union[FooEvent, BarEvent]:
+    return e
+
+
+async def not_event(e: Union[int, Event]):
+    ...
+
+
 async def event_type(t: str = EventType()) -> str:
     return t
 

tests/plugins/param/param_state.py

@@ -4,10 +4,15 @@ from nonebot.typing import T_State
 from nonebot.adapters import Message
 from nonebot.params import (
     Command,
+    Keyword,
+    Endswith,
+    RegexStr,
+    Fullmatch,
     RegexDict,
     CommandArg,
     RawCommand,
     RegexGroup,
+    Startswith,
     CommandStart,
     RegexMatched,
     ShellCommandArgs,
@@ -19,6 +24,14 @@ async def state(x: T_State) -> T_State:
     return x
 
 
+async def legacy_state(state):
+    return state
+
+
+async def not_legacy_state(state: int):
+    ...
+
+
 async def command(cmd: Tuple[str, ...] = Command()) -> Tuple[str, ...]:
     return cmd
 
@@ -57,3 +70,23 @@ async def regex_group(regex_group: Tuple = RegexGroup()) -> Tuple:
 
 async def regex_matched(regex_matched: str = RegexMatched()) -> str:
     return regex_matched
+
+
+async def regex_str(regex_matched: str = RegexStr()) -> str:
+    return regex_matched
+
+
+async def startswith(startswith: str = Startswith()) -> str:
+    return startswith
+
+
+async def endswith(endswith: str = Endswith()) -> str:
+    return endswith
+
+
+async def fullmatch(fullmatch: str = Fullmatch()) -> str:
+    return fullmatch
+
+
+async def keyword(keyword: str = Keyword()) -> str:
+    return keyword

tests/plugins/plugin/__init__.py

@@ -0,0 +1 @@
+from . import matchers

tests/plugins/plugin/matchers.py

@@ -0,0 +1,243 @@
+from datetime import datetime, timezone
+
+from nonebot.adapters import Event
+from nonebot import (
+    CommandGroup,
+    MatcherGroup,
+    on,
+    on_type,
+    on_regex,
+    on_notice,
+    on_command,
+    on_keyword,
+    on_message,
+    on_request,
+    on_endswith,
+    on_fullmatch,
+    on_metaevent,
+    on_startswith,
+    on_shell_command,
+)
+
+
+async def rule() -> bool:
+    return True
+
+
+async def permission() -> bool:
+    return True
+
+
+async def handler():
+    return
+
+
+expire_time = datetime.now(timezone.utc)
+priority = 100
+state = {"test": "test"}
+
+
+matcher_on = on(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_metaevent = on_metaevent(
+    rule=rule,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_message = on_message(
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_notice = on_notice(
+    rule=rule,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_request = on_request(
+    rule=rule,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_startswith = on_startswith(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_endswith = on_endswith(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_fullmatch = on_fullmatch(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_keyword = on_keyword(
+    {"test"},
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_command = on_command(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_shell_command = on_shell_command(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+matcher_on_regex = on_regex(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+class TestEvent(Event):
+    ...
+
+
+matcher_on_type = on_type(
+    TestEvent,
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+
+
+cmd_group = CommandGroup(
+    "test",
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+matcher_sub_cmd = cmd_group.command("sub")
+matcher_sub_shell_cmd = cmd_group.shell_command("sub")
+
+
+matcher_group = MatcherGroup(
+    rule=rule,
+    permission=permission,
+    handlers=[handler],
+    temp=True,
+    expire_time=expire_time,
+    priority=priority,
+    block=True,
+    state=state,
+)
+matcher_group_on = matcher_group.on(type="test")
+matcher_group_on_metaevent = matcher_group.on_metaevent()
+matcher_group_on_message = matcher_group.on_message()
+matcher_group_on_notice = matcher_group.on_notice()
+matcher_group_on_request = matcher_group.on_request()
+matcher_group_on_startswith = matcher_group.on_startswith("test")
+matcher_group_on_endswith = matcher_group.on_endswith("test")
+matcher_group_on_fullmatch = matcher_group.on_fullmatch("test")
+matcher_group_on_keyword = matcher_group.on_keyword({"test"})
+matcher_group_on_command = matcher_group.on_command("test")
+matcher_group_on_shell_command = matcher_group.on_shell_command("test")
+matcher_group_on_regex = matcher_group.on_regex("test")
+matcher_group_on_type = matcher_group.on_type(TestEvent)

tests/plugins/require.py

@@ -1,8 +1,7 @@
 from nonebot import require
-from plugins.export import test
-
-from .export import test as test_related
 
 test_require = require("export").test
 
-assert test is test_related and test is test_require, "Export Require Error"
+from plugins.export import test
+
+assert test is test_require and test() == "export", "Export Require Error"

tests/test_adapters/test_message.py

@@ -1,3 +1,4 @@
+import pytest
 from pydantic import ValidationError, parse_obj_as
 
 from utils import make_fake_message
@@ -29,14 +30,15 @@ def test_segment_validate():
     MessageSegment = Message.get_segment_class()
 
     assert parse_obj_as(
-        MessageSegment, {"type": "text", "data": {"text": "text"}}
+        MessageSegment,
+        {"type": "text", "data": {"text": "text"}, "extra": "should be ignored"},
     ) == MessageSegment.text("text")
 
-    try:
+    with pytest.raises(ValidationError):
         parse_obj_as(MessageSegment, "some str")
-        assert False
-    except ValidationError:
-        assert True
+
+    with pytest.raises(ValidationError):
+        parse_obj_as(MessageSegment, {"data": {}})
 
 
 def test_segment():
@@ -129,11 +131,8 @@ def test_message_validate():
 
     assert parse_obj_as(Message, Message([])) == Message([])
 
-    try:
+    with pytest.raises(ValidationError):
         parse_obj_as(Message, Message_([]))
-        assert False
-    except ValidationError:
-        assert True
 
     assert parse_obj_as(Message, "text") == Message([MessageSegment.text("text")])
 
@@ -146,8 +145,5 @@ def test_message_validate():
         [MessageSegment.text("text"), {"type": "text", "data": {"text": "text"}}],
     ) == Message([MessageSegment.text("text"), MessageSegment.text("text")])
 
-    try:
+    with pytest.raises(ValidationError):
         parse_obj_as(Message, object())
-        assert False
-    except ValidationError:
-        assert True

tests/test_adapters/test_template.py

@@ -11,11 +11,11 @@ def test_template_basis():
 
 def test_template_message():
     Message = make_fake_message()
-    template = Message.template("{a:custom}{b:text}{c:image}")
+    template = Message.template("{a:custom}{b:text}{c:image}/{d}")
 
     @template.add_format_spec
     def custom(input: str) -> str:
-        return input + "-custom!"
+        return f"{input}-custom!"
 
     try:
         template.add_format_spec(custom)
@@ -24,12 +24,17 @@ def test_template_message():
     else:
         raise AssertionError("Should raise ValueError")
 
-    format_args = {"a": "custom", "b": "text", "c": "https://example.com/test"}
+    format_args = {
+        "a": "custom",
+        "b": "text",
+        "c": "https://example.com/test",
+        "d": 114,
+    }
     formatted = template.format(**format_args)
 
     assert template.format_map(format_args) == formatted
-    assert formatted.extract_plain_text() == "custom-custom!text"
-    assert str(formatted) == "custom-custom!text[fake:image]"
+    assert formatted.extract_plain_text() == "custom-custom!text/114"
+    assert str(formatted) == "custom-custom!text[fake:image]/114"
 
 
 def test_rich_template_message():

tests/test_driver.py

@@ -1,3 +1,5 @@
+import json
+import asyncio
 from typing import cast
 
 import pytest
@@ -78,3 +80,83 @@ async def test_reverse_driver(app: App):
             assert await ws.receive_bytes() == b"pong"
 
             await ws.close()
+
+    await asyncio.sleep(1)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "nonebug_init",
+    [
+        pytest.param({"driver": "nonebot.drivers.httpx:Driver"}, id="httpx"),
+        pytest.param({"driver": "nonebot.drivers.aiohttp:Driver"}, id="aiohttp"),
+    ],
+    indirect=True,
+)
+async def test_http_driver(app: App):
+    import nonebot
+    from nonebot.drivers import Request, ForwardDriver
+
+    driver = cast(ForwardDriver, nonebot.get_driver())
+
+    request = Request(
+        "POST",
+        "https://httpbin.org/post",
+        params={"param": "test"},
+        headers={"X-Test": "test"},
+        cookies={"session": "test"},
+        content="test",
+    )
+    response = await driver.request(request)
+    assert response.status_code == 200 and response.content
+    data = json.loads(response.content)
+    assert data["args"] == {"param": "test"}
+    assert data["headers"].get("X-Test") == "test"
+    assert data["headers"].get("Cookie") == "session=test"
+    assert data["data"] == "test"
+
+    request = Request("POST", "https://httpbin.org/post", data={"form": "test"})
+    response = await driver.request(request)
+    assert response.status_code == 200 and response.content
+    data = json.loads(response.content)
+    assert data["form"] == {"form": "test"}
+
+    request = Request("POST", "https://httpbin.org/post", json={"json": "test"})
+    response = await driver.request(request)
+    assert response.status_code == 200 and response.content
+    data = json.loads(response.content)
+    assert data["json"] == {"json": "test"}
+
+    request = Request(
+        "POST", "https://httpbin.org/post", files={"test": ("test.txt", b"test")}
+    )
+    response = await driver.request(request)
+    assert response.status_code == 200 and response.content
+    data = json.loads(response.content)
+    assert data["files"] == {"test": "test"}
+
+    await asyncio.sleep(1)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "nonebug_init, driver_type",
+    [
+        pytest.param(
+            {"driver": "nonebot.drivers.fastapi:Driver+nonebot.drivers.aiohttp:Mixin"},
+            "fastapi+aiohttp",
+            id="fastapi+aiohttp",
+        ),
+        pytest.param(
+            {"driver": "~httpx:Driver+~websockets"},
+            "none+httpx+websockets",
+            id="httpx+websockets",
+        ),
+    ],
+    indirect=["nonebug_init"],
+)
+async def test_combine_driver(app: App, driver_type: str):
+    import nonebot
+
+    driver = nonebot.get_driver()
+    assert driver.type == driver_type

tests/test_init.py

@@ -3,6 +3,7 @@ import os
 import pytest
 
 os.environ["CONFIG_FROM_ENV"] = '{"test": "test"}'
+os.environ["CONFIG_OVERRIDE"] = "new"
 
 
 @pytest.mark.asyncio
@@ -25,8 +26,13 @@ async def test_init(nonebug_init):
 
     config = get_driver().config
     assert config.config_from_env == {"test": "test"}
+    assert config.config_override == "new"
     assert config.config_from_init == "init"
     assert config.common_config == "common"
+    assert config.common_override == "new"
+    assert config.nested_dict == {"a": 1, "b": 2, "c": {"d": 3}}
+    assert config.nested_missing_dict == {"a": 1, "b": {"c": 2}}
+    assert config.not_nested == "some string"
 
 
 @pytest.mark.asyncio
@@ -59,7 +65,7 @@ async def test_get(monkeypatch: pytest.MonkeyPatch, nonebug_clear):
     with pytest.raises(ValueError):
         get_bot()
 
-    monkeypatch.setattr(driver, "_clients", {"test": "test"})
+    monkeypatch.setattr(driver, "_bots", {"test": "test"})
     assert get_bot() == "test"
     assert get_bot("test") == "test"
     assert get_bots() == {"test": "test"}

tests/test_matcher/test_matcher.py

@@ -104,6 +104,7 @@ async def test_permission_updater(app: App, load_plugin):
         default_permission,
         test_custom_updater,
         test_permission_updater,
+        test_user_permission_updater,
     )
 
     event = make_fake_event(_session_id="test")()
@@ -119,6 +120,19 @@ async def test_permission_updater(app: App, load_plugin):
         assert checker.users == ("test",)
         assert checker.perm is default_permission
 
+    user_permission = list(test_user_permission_updater.permission.checkers)[0].call
+    assert isinstance(user_permission, User)
+    assert user_permission.perm is default_permission
+    async with app.test_api() as ctx:
+        bot = ctx.create_bot()
+        matcher = test_user_permission_updater()
+        new_perm = await matcher.update_permission(bot, event)
+        assert len(new_perm.checkers) == 1
+        checker = list(new_perm.checkers)[0].call
+        assert isinstance(checker, User)
+        assert checker.users == ("test",)
+        assert checker.perm is default_permission
+
     assert test_custom_updater.permission is default_permission
     async with app.test_api() as ctx:
         bot = ctx.create_bot()
@@ -157,3 +171,35 @@ async def test_run(app: App):
         await test_pause().run(bot, event, {})
         assert len(matchers[0]) == 1
         assert len(matchers[0][0].handlers) == 0
+
+
+@pytest.mark.asyncio
+async def test_expire(app: App, load_plugin):
+    from nonebot.matcher import matchers
+    from nonebot.message import _check_matcher
+    from plugins.matcher.matcher_expire import (
+        test_temp_matcher,
+        test_datetime_matcher,
+        test_timedelta_matcher,
+    )
+
+    event = make_fake_event(_type="test")()
+    async with app.test_api() as ctx:
+        bot = ctx.create_bot()
+        assert test_temp_matcher in matchers[test_temp_matcher.priority]
+        await _check_matcher(test_temp_matcher, bot, event, {})
+        assert test_temp_matcher not in matchers[test_temp_matcher.priority]
+
+    event = make_fake_event()()
+    async with app.test_api() as ctx:
+        bot = ctx.create_bot()
+        assert test_datetime_matcher in matchers[test_datetime_matcher.priority]
+        await _check_matcher(test_datetime_matcher, bot, event, {})
+        assert test_datetime_matcher not in matchers[test_datetime_matcher.priority]
+
+    event = make_fake_event()()
+    async with app.test_api() as ctx:
+        bot = ctx.create_bot()
+        assert test_timedelta_matcher in matchers[test_timedelta_matcher.priority]
+        await _check_matcher(test_timedelta_matcher, bot, event, {})
+        assert test_timedelta_matcher not in matchers[test_timedelta_matcher.priority]

tests/test_matcher/test_provider.py

@@ -0,0 +1,11 @@
+import pytest
+from nonebug import App
+
+
+@pytest.mark.asyncio
+async def test_manager(app: App, load_plugin):
+    from nonebot.matcher import DEFAULT_PROVIDER_CLASS, matchers
+
+    default_provider = matchers.provider
+    matchers.set_provider(DEFAULT_PROVIDER_CLASS)
+    assert matchers.provider == default_provider

tests/test_param.py

@@ -37,15 +37,32 @@ async def test_depend(app: App, load_plugin):
 async def test_bot(app: App, load_plugin):
     from nonebot.params import BotParam
     from nonebot.exception import TypeMisMatch
-    from plugins.param.param_bot import SubBot, get_bot, sub_bot
+    from plugins.param.param_bot import (
+        FooBot,
+        get_bot,
+        not_bot,
+        sub_bot,
+        union_bot,
+        legacy_bot,
+        not_legacy_bot,
+    )
 
     async with app.test_dependent(get_bot, allow_types=[BotParam]) as ctx:
         bot = ctx.create_bot()
         ctx.pass_params(bot=bot)
         ctx.should_return(bot)
 
+    async with app.test_dependent(legacy_bot, allow_types=[BotParam]) as ctx:
+        bot = ctx.create_bot()
+        ctx.pass_params(bot=bot)
+        ctx.should_return(bot)
+
+    with pytest.raises(ValueError):
+        async with app.test_dependent(not_legacy_bot, allow_types=[BotParam]) as ctx:
+            ...
+
     async with app.test_dependent(sub_bot, allow_types=[BotParam]) as ctx:
-        bot = ctx.create_bot(base=SubBot)
+        bot = ctx.create_bot(base=FooBot)
         ctx.pass_params(bot=bot)
         ctx.should_return(bot)
 
@@ -54,37 +71,68 @@ async def test_bot(app: App, load_plugin):
             bot = ctx.create_bot()
             ctx.pass_params(bot=bot)
 
+    async with app.test_dependent(union_bot, allow_types=[BotParam]) as ctx:
+        bot = ctx.create_bot(base=FooBot)
+        ctx.pass_params(bot=bot)
+        ctx.should_return(bot)
+
+    with pytest.raises(ValueError):
+        async with app.test_dependent(not_bot, allow_types=[BotParam]) as ctx:
+            ...
+
 
 @pytest.mark.asyncio
 async def test_event(app: App, load_plugin):
     from nonebot.exception import TypeMisMatch
     from nonebot.params import EventParam, DependParam
     from plugins.param.param_event import (
-        SubEvent,
+        FooEvent,
         event,
+        not_event,
         sub_event,
         event_type,
         event_to_me,
+        union_event,
+        legacy_event,
         event_message,
         event_plain_text,
+        not_legacy_event,
     )
 
     fake_message = make_fake_message()("text")
     fake_event = make_fake_event(_message=fake_message)()
-    fake_subevent = make_fake_event(_base=SubEvent)()
+    fake_fooevent = make_fake_event(_base=FooEvent)()
 
     async with app.test_dependent(event, allow_types=[EventParam]) as ctx:
         ctx.pass_params(event=fake_event)
         ctx.should_return(fake_event)
 
+    async with app.test_dependent(legacy_event, allow_types=[EventParam]) as ctx:
+        ctx.pass_params(event=fake_event)
+        ctx.should_return(fake_event)
+
+    with pytest.raises(ValueError):
+        async with app.test_dependent(
+            not_legacy_event, allow_types=[EventParam]
+        ) as ctx:
+            ...
+
     async with app.test_dependent(sub_event, allow_types=[EventParam]) as ctx:
-        ctx.pass_params(event=fake_subevent)
-        ctx.should_return(fake_subevent)
+        ctx.pass_params(event=fake_fooevent)
+        ctx.should_return(fake_fooevent)
 
     with pytest.raises(TypeMisMatch):
         async with app.test_dependent(sub_event, allow_types=[EventParam]) as ctx:
             ctx.pass_params(event=fake_event)
 
+    async with app.test_dependent(union_event, allow_types=[EventParam]) as ctx:
+        ctx.pass_params(event=fake_fooevent)
+        ctx.should_return(fake_event)
+
+    with pytest.raises(ValueError):
+        async with app.test_dependent(not_event, allow_types=[EventParam]) as ctx:
+            ...
+
     async with app.test_dependent(
         event_type, allow_types=[EventParam, DependParam]
     ) as ctx:
@@ -115,25 +163,37 @@ async def test_state(app: App, load_plugin):
     from nonebot.params import StateParam, DependParam
     from nonebot.consts import (
         CMD_KEY,
+        REGEX_STR,
         PREFIX_KEY,
         REGEX_DICT,
         SHELL_ARGS,
         SHELL_ARGV,
         CMD_ARG_KEY,
+        KEYWORD_KEY,
         RAW_CMD_KEY,
         REGEX_GROUP,
+        ENDSWITH_KEY,
         CMD_START_KEY,
+        FULLMATCH_KEY,
         REGEX_MATCHED,
+        STARTSWITH_KEY,
     )
     from plugins.param.param_state import (
         state,
         command,
+        keyword,
+        endswith,
+        fullmatch,
+        regex_str,
         regex_dict,
+        startswith,
         command_arg,
         raw_command,
         regex_group,
+        legacy_state,
         command_start,
         regex_matched,
+        not_legacy_state,
         shell_command_args,
         shell_command_argv,
     )
@@ -149,14 +209,29 @@ async def test_state(app: App, load_plugin):
         SHELL_ARGV: ["-h"],
         SHELL_ARGS: {"help": True},
         REGEX_MATCHED: "[cq:test,arg=value]",
+        REGEX_STR: "[cq:test,arg=value]",
         REGEX_GROUP: ("test", "arg=value"),
         REGEX_DICT: {"type": "test", "arg": "value"},
+        STARTSWITH_KEY: "startswith",
+        ENDSWITH_KEY: "endswith",
+        FULLMATCH_KEY: "fullmatch",
+        KEYWORD_KEY: "keyword",
     }
 
     async with app.test_dependent(state, allow_types=[StateParam]) as ctx:
         ctx.pass_params(state=fake_state)
         ctx.should_return(fake_state)
 
+    async with app.test_dependent(legacy_state, allow_types=[StateParam]) as ctx:
+        ctx.pass_params(state=fake_state)
+        ctx.should_return(fake_state)
+
+    with pytest.raises(ValueError):
+        async with app.test_dependent(
+            not_legacy_state, allow_types=[StateParam]
+        ) as ctx:
+            ...
+
     async with app.test_dependent(
         command, allow_types=[StateParam, DependParam]
     ) as ctx:
@@ -199,6 +274,12 @@ async def test_state(app: App, load_plugin):
         ctx.pass_params(state=fake_state)
         ctx.should_return(fake_state[REGEX_MATCHED])
 
+    async with app.test_dependent(
+        regex_str, allow_types=[StateParam, DependParam]
+    ) as ctx:
+        ctx.pass_params(state=fake_state)
+        ctx.should_return(fake_state[REGEX_STR])
+
     async with app.test_dependent(
         regex_group, allow_types=[StateParam, DependParam]
     ) as ctx:
@@ -211,6 +292,30 @@ async def test_state(app: App, load_plugin):
         ctx.pass_params(state=fake_state)
         ctx.should_return(fake_state[REGEX_DICT])
 
+    async with app.test_dependent(
+        startswith, allow_types=[StateParam, DependParam]
+    ) as ctx:
+        ctx.pass_params(state=fake_state)
+        ctx.should_return(fake_state[STARTSWITH_KEY])
+
+    async with app.test_dependent(
+        endswith, allow_types=[StateParam, DependParam]
+    ) as ctx:
+        ctx.pass_params(state=fake_state)
+        ctx.should_return(fake_state[ENDSWITH_KEY])
+
+    async with app.test_dependent(
+        fullmatch, allow_types=[StateParam, DependParam]
+    ) as ctx:
+        ctx.pass_params(state=fake_state)
+        ctx.should_return(fake_state[FULLMATCH_KEY])
+
+    async with app.test_dependent(
+        keyword, allow_types=[StateParam, DependParam]
+    ) as ctx:
+        ctx.pass_params(state=fake_state)
+        ctx.should_return(fake_state[KEYWORD_KEY])
+
 
 @pytest.mark.asyncio
 async def test_matcher(app: App, load_plugin):

tests/test_permission.py

@@ -1,3 +1,5 @@
+from typing import Tuple, Optional
+
 import pytest
 from nonebug import App
 
@@ -142,10 +144,11 @@ async def test_metaevent(
         ("message", "test", True),
         ("message", "foo", False),
         ("message", "faketest", True),
-        ("notice", "test", False),
+        ("message", None, False),
+        ("notice", "test", True),
     ],
 )
-async def test_startswith(
+async def test_superuser(
     app: App,
     type: str,
     user_id: str,
@@ -163,3 +166,29 @@ async def test_startswith(
     async with app.test_api() as ctx:
         bot = ctx.create_bot()
         assert await dependent(bot=bot, event=event) == expected
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "session_ids,session_id,expected",
+    [
+        (("user", "foo"), "user", True),
+        (("user", "foo"), "bar", False),
+        (("user", "foo"), None, False),
+    ],
+)
+async def test_user(
+    app: App, session_ids: Tuple[str, ...], session_id: Optional[str], expected: bool
+):
+    from nonebot.permission import USER, User
+
+    dependent = list(USER(*session_ids).checkers)[0]
+    checker = dependent.call
+
+    assert isinstance(checker, User)
+
+    event = make_fake_event(_session_id=session_id)()
+
+    async with app.test_api() as ctx:
+        bot = ctx.create_bot()
+        assert await dependent(bot=bot, event=event) == expected

tests/test_plugin/test_get.py

@@ -0,0 +1,39 @@
+from typing import TYPE_CHECKING, Set
+
+import pytest
+from nonebug import App
+
+if TYPE_CHECKING:
+    from nonebot.plugin import Plugin
+
+
+@pytest.mark.asyncio
+async def test_get_plugin(app: App, load_plugin: Set["Plugin"]):
+    import nonebot
+
+    # check simple plugin
+    plugin = nonebot.get_plugin("export")
+    assert plugin
+    assert plugin.module_name == "plugins.export"
+
+    # check sub plugin
+    plugin = nonebot.get_plugin("nested_subplugin")
+    assert plugin
+    assert plugin.module_name == "plugins.nested.plugins.nested_subplugin"
+
+    # check get plugin by module name
+    plugin = nonebot.get_plugin_by_module_name("plugins.nested.utils")
+    assert plugin
+    assert plugin.module_name == "plugins.nested"
+
+
+@pytest.mark.asyncio
+async def test_get_available_plugin(app: App):
+    import nonebot
+    from nonebot.plugin import PluginManager, _managers
+
+    _managers.append(PluginManager(["plugins.export", "plugin.require"]))
+
+    # check get available plugins
+    plugin_names = nonebot.get_available_plugin_names()
+    assert plugin_names == {"export", "require"}

tests/test_plugin/test_load.py

@@ -1,4 +1,6 @@
 import sys
+from pathlib import Path
+from dataclasses import asdict
 from typing import TYPE_CHECKING, Set
 
 import pytest
@@ -9,25 +11,88 @@ if TYPE_CHECKING:
 
 
 @pytest.mark.asyncio
-async def test_load_plugin(load_plugin: Set["Plugin"]):
+async def test_load_plugin(app: App):
     import nonebot
 
-    loaded_plugins = set(
+    # check regular
+    assert nonebot.load_plugin("plugins.metadata")
+
+    # check path
+    assert nonebot.load_plugin(Path("plugins/export"))
+
+    # check not found
+    assert nonebot.load_plugin("some_plugin_not_exist") is None
+
+
+@pytest.mark.asyncio
+async def test_load_plugins(app: App, load_plugin: Set["Plugin"]):
+    import nonebot
+    from nonebot.plugin import PluginManager
+
+    loaded_plugins = {
         plugin for plugin in nonebot.get_loaded_plugins() if not plugin.parent_plugin
-    )
+    }
     assert loaded_plugins == load_plugin
-    plugin = nonebot.get_plugin("export")
-    assert plugin
-    assert plugin.module_name == "plugins.export"
+
+    # check simple plugin
     assert "plugins.export" in sys.modules
 
-    try:
-        nonebot.load_plugin("plugins.export")
-        assert False
-    except RuntimeError:
-        assert True
+    # check sub plugin
+    plugin = nonebot.get_plugin("nested_subplugin")
+    assert plugin
+    assert "plugins.nested.plugins.nested_subplugin" in sys.modules
+    assert plugin.parent_plugin == nonebot.get_plugin("nested")
 
-    assert nonebot.load_plugin("some_plugin_not_exist") is None
+    # check load again
+    with pytest.raises(RuntimeError):
+        PluginManager(plugins=["plugins.export"]).load_all_plugins()
+    with pytest.raises(RuntimeError):
+        PluginManager(search_path=["plugins"]).load_all_plugins()
+
+
+@pytest.mark.asyncio
+async def test_load_nested_plugin(app: App, load_plugin: Set["Plugin"]):
+    import nonebot
+
+    parent_plugin = nonebot.get_plugin("nested")
+    sub_plugin = nonebot.get_plugin("nested_subplugin")
+    sub_plugin2 = nonebot.get_plugin("nested_subplugin2")
+    assert parent_plugin and sub_plugin and sub_plugin2
+    assert sub_plugin.parent_plugin is parent_plugin
+    assert sub_plugin2.parent_plugin is parent_plugin
+    assert parent_plugin.sub_plugins == {sub_plugin, sub_plugin2}
+
+
+@pytest.mark.asyncio
+async def test_load_json(app: App):
+    import nonebot
+
+    nonebot.load_from_json("./plugins.json")
+
+    with pytest.raises(TypeError):
+        nonebot.load_from_json("./plugins.invalid.json")
+
+
+@pytest.mark.asyncio
+async def test_load_toml(app: App):
+    import nonebot
+
+    nonebot.load_from_toml("./plugins.toml")
+
+    with pytest.raises(ValueError):
+        nonebot.load_from_toml("./plugins.empty.toml")
+
+    with pytest.raises(TypeError):
+        nonebot.load_from_toml("./plugins.invalid.toml")
+
+
+@pytest.mark.asyncio
+async def test_bad_plugin(app: App):
+    import nonebot
+
+    nonebot.load_plugins("bad_plugins")
+
+    assert nonebot.get_plugin("bad_plugins") is None
 
 
 @pytest.mark.asyncio
@@ -47,8 +112,7 @@ async def test_require_loaded(app: App, monkeypatch: pytest.MonkeyPatch):
 @pytest.mark.asyncio
 async def test_require_not_loaded(app: App, monkeypatch: pytest.MonkeyPatch):
     import nonebot
-    from nonebot.plugin import _managers
-    from nonebot.plugin.manager import PluginManager
+    from nonebot.plugin import PluginManager, _managers
 
     m = PluginManager(["plugins.export"])
     _managers.append(m)
@@ -80,10 +144,23 @@ async def test_require_not_declared(app: App):
 @pytest.mark.asyncio
 async def test_require_not_found(app: App):
     import nonebot
-    from nonebot.plugin import _managers
 
-    try:
+    with pytest.raises(RuntimeError):
         nonebot.require("some_plugin_not_exist")
-        assert False
-    except RuntimeError:
-        assert True
+
+
+@pytest.mark.asyncio
+async def test_plugin_metadata(app: App, load_plugin: Set["Plugin"]):
+    import nonebot
+    from plugins.metadata import Config
+
+    plugin = nonebot.get_plugin("metadata")
+    assert plugin
+    assert plugin.metadata
+    assert asdict(plugin.metadata) == {
+        "name": "测试插件",
+        "description": "测试插件元信息",
+        "usage": "无法使用",
+        "config": Config,
+        "extra": {"author": "NoneBot"},
+    }

tests/test_plugin/test_manager.py

@@ -0,0 +1,12 @@
+import pytest
+from nonebug import App
+
+
+@pytest.mark.asyncio
+async def test_load_plugin_name(app: App):
+    from nonebot.plugin import PluginManager
+
+    m = PluginManager(plugins=["plugins.export"])
+    module1 = m.load_plugin("export")
+    module2 = m.load_plugin("plugins.export")
+    assert module1 is module2

tests/test_plugin/test_on.py

@@ -0,0 +1,116 @@
+from typing import Type, Optional
+
+import pytest
+from nonebug import App
+
+
+@pytest.mark.asyncio
+async def test_on(app: App, load_plugin):
+    import nonebot
+    import plugins.plugin.matchers as module
+    from nonebot.typing import T_RuleChecker
+    from nonebot.matcher import Matcher, matchers
+    from nonebot.rule import (
+        RegexRule,
+        IsTypeRule,
+        CommandRule,
+        EndswithRule,
+        KeywordsRule,
+        FullmatchRule,
+        StartswithRule,
+        ShellCommandRule,
+    )
+    from plugins.plugin.matchers import (
+        TestEvent,
+        rule,
+        state,
+        handler,
+        priority,
+        matcher_on,
+        permission,
+        expire_time,
+        matcher_on_type,
+        matcher_sub_cmd,
+        matcher_group_on,
+        matcher_on_regex,
+        matcher_on_notice,
+        matcher_on_command,
+        matcher_on_keyword,
+        matcher_on_message,
+        matcher_on_request,
+        matcher_on_endswith,
+        matcher_on_fullmatch,
+        matcher_on_metaevent,
+        matcher_group_on_type,
+        matcher_on_startswith,
+        matcher_sub_shell_cmd,
+        matcher_group_on_regex,
+        matcher_group_on_notice,
+        matcher_group_on_command,
+        matcher_group_on_keyword,
+        matcher_group_on_message,
+        matcher_group_on_request,
+        matcher_on_shell_command,
+        matcher_group_on_endswith,
+        matcher_group_on_fullmatch,
+        matcher_group_on_metaevent,
+        matcher_group_on_startswith,
+        matcher_group_on_shell_command,
+    )
+
+    plugin = nonebot.get_plugin("plugin")
+
+    def _check(
+        matcher: Type[Matcher],
+        pre_rule: Optional[T_RuleChecker],
+        has_permission: bool,
+    ):
+        assert {dependent.call for dependent in matcher.rule.checkers} == (
+            {pre_rule, rule} if pre_rule else {rule}
+        )
+        if has_permission:
+            assert {dependent.call for dependent in matcher.permission.checkers} == {
+                permission
+            }
+        else:
+            assert not matcher.permission.checkers
+        assert [dependent.call for dependent in matcher.handlers] == [handler]
+        assert matcher.temp is True
+        assert matcher.expire_time == expire_time
+        assert matcher in matchers[priority]
+        assert matcher.block is True
+        assert matcher._default_state == state
+
+        assert matcher.plugin is plugin
+        assert matcher.module is module
+        assert matcher.plugin_name == "plugin"
+        assert matcher.module_name == "plugins.plugin.matchers"
+
+    _check(matcher_on, None, True)
+    _check(matcher_on_metaevent, None, False)
+    _check(matcher_on_message, None, True)
+    _check(matcher_on_notice, None, False)
+    _check(matcher_on_request, None, False)
+    _check(matcher_on_startswith, StartswithRule(("test",)), True)
+    _check(matcher_on_endswith, EndswithRule(("test",)), True)
+    _check(matcher_on_fullmatch, FullmatchRule(("test",)), True)
+    _check(matcher_on_keyword, KeywordsRule("test"), True)
+    _check(matcher_on_command, CommandRule([("test",)]), True)
+    _check(matcher_on_shell_command, ShellCommandRule([("test",)], None), True)
+    _check(matcher_on_regex, RegexRule("test"), True)
+    _check(matcher_on_type, IsTypeRule(TestEvent), True)
+    _check(matcher_sub_cmd, CommandRule([("test", "sub")]), True)
+    _check(matcher_sub_shell_cmd, ShellCommandRule([("test", "sub")], None), True)
+    _check(matcher_group_on, None, True)
+    _check(matcher_group_on_metaevent, None, False)
+    _check(matcher_group_on_message, None, True)
+    _check(matcher_group_on_notice, None, False)
+    _check(matcher_group_on_request, None, False)
+    _check(matcher_group_on_startswith, StartswithRule(("test",)), True)
+    _check(matcher_group_on_endswith, EndswithRule(("test",)), True)
+    _check(matcher_group_on_fullmatch, FullmatchRule(("test",)), True)
+    _check(matcher_group_on_keyword, KeywordsRule("test"), True)
+    _check(matcher_group_on_command, CommandRule([("test",)]), True)
+    _check(matcher_group_on_shell_command, ShellCommandRule([("test",)], None), True)
+    _check(matcher_group_on_regex, RegexRule("test"), True)
+    _check(matcher_group_on_type, IsTypeRule(TestEvent), True)

tests/test_rule.py

@@ -1,4 +1,5 @@
-from typing import Tuple, Union
+import sys
+from typing import Dict, Tuple, Union, Optional
 
 import pytest
 from nonebug import App
@@ -51,6 +52,7 @@ async def test_rule(app: App):
         ("prefix", True, "message", "Prefix_", True),
         ("prefix", False, "message", "prefoo", False),
         ("prefix", False, "message", "fooprefix", False),
+        ("prefix", False, "message", None, False),
         (("prefix", "foo"), False, "message", "fooprefix", True),
         ("prefix", False, "notice", "foo", False),
     ],
@@ -60,22 +62,27 @@ async def test_startswith(
     msg: Union[str, Tuple[str, ...]],
     ignorecase: bool,
     type: str,
-    text: str,
+    text: Optional[str],
     expected: bool,
 ):
+    from nonebot.consts import STARTSWITH_KEY
     from nonebot.rule import StartswithRule, startswith
 
     test_startswith = startswith(msg, ignorecase)
     dependent = list(test_startswith.checkers)[0]
     checker = dependent.call
 
+    msg = (msg,) if isinstance(msg, str) else msg
+
     assert isinstance(checker, StartswithRule)
-    assert checker.msg == (msg,) if isinstance(msg, str) else msg
+    assert checker.msg == msg
     assert checker.ignorecase == ignorecase
 
-    message = make_fake_message()(text)
+    message = text if text is None else make_fake_message()(text)
     event = make_fake_event(_type=type, _message=message)()
-    assert await dependent(event=event) == expected
+    for prefix in msg:
+        state = {STARTSWITH_KEY: prefix}
+        assert await dependent(event=event, state=state) == expected
 
 
 @pytest.mark.asyncio
@@ -88,6 +95,7 @@ async def test_startswith(
         ("suffix", True, "message", "_Suffix", True),
         ("suffix", False, "message", "suffoo", False),
         ("suffix", False, "message", "suffixfoo", False),
+        ("suffix", False, "message", None, False),
         (("suffix", "foo"), False, "message", "suffixfoo", True),
         ("suffix", False, "notice", "foo", False),
     ],
@@ -97,22 +105,27 @@ async def test_endswith(
     msg: Union[str, Tuple[str, ...]],
     ignorecase: bool,
     type: str,
-    text: str,
+    text: Optional[str],
     expected: bool,
 ):
+    from nonebot.consts import ENDSWITH_KEY
     from nonebot.rule import EndswithRule, endswith
 
     test_endswith = endswith(msg, ignorecase)
     dependent = list(test_endswith.checkers)[0]
     checker = dependent.call
 
+    msg = (msg,) if isinstance(msg, str) else msg
+
     assert isinstance(checker, EndswithRule)
-    assert checker.msg == (msg,) if isinstance(msg, str) else msg
+    assert checker.msg == msg
     assert checker.ignorecase == ignorecase
 
-    message = make_fake_message()(text)
+    message = text if text is None else make_fake_message()(text)
     event = make_fake_event(_type=type, _message=message)()
-    assert await dependent(event=event) == expected
+    for suffix in msg:
+        state = {ENDSWITH_KEY: suffix}
+        assert await dependent(event=event, state=state) == expected
 
 
 @pytest.mark.asyncio
@@ -125,6 +138,7 @@ async def test_endswith(
         ("fullmatch", True, "message", "Fullmatch", True),
         ("fullmatch", False, "message", "fullfoo", False),
         ("fullmatch", False, "message", "_fullmatch_", False),
+        ("fullmatch", False, "message", None, False),
         (("fullmatch", "foo"), False, "message", "fullmatchfoo", False),
         ("fullmatch", False, "notice", "foo", False),
     ],
@@ -134,22 +148,27 @@ async def test_fullmatch(
     msg: Union[str, Tuple[str, ...]],
     ignorecase: bool,
     type: str,
-    text: str,
+    text: Optional[str],
     expected: bool,
 ):
+    from nonebot.consts import FULLMATCH_KEY
     from nonebot.rule import FullmatchRule, fullmatch
 
     test_fullmatch = fullmatch(msg, ignorecase)
     dependent = list(test_fullmatch.checkers)[0]
     checker = dependent.call
 
+    msg = (msg,) if isinstance(msg, str) else msg
+
     assert isinstance(checker, FullmatchRule)
-    assert checker.msg == {msg} if isinstance(msg, str) else {*msg}
+    assert checker.msg == msg
     assert checker.ignorecase == ignorecase
 
-    message = make_fake_message()(text)
+    message = text if text is None else make_fake_message()(text)
     event = make_fake_event(_type=type, _message=message)()
-    assert await dependent(event=event) == expected
+    for full in msg:
+        state = {FULLMATCH_KEY: full}
+        assert await dependent(event=event, state=state) == expected
 
 
 @pytest.mark.asyncio
@@ -158,16 +177,19 @@ async def test_fullmatch(
     [
         (("key",), "message", "_key_", True),
         (("key", "foo"), "message", "_foo_", True),
+        (("key",), "message", None, False),
         (("key",), "notice", "foo", False),
+        (("key",), "message", "foo", False),
     ],
 )
 async def test_keyword(
     app: App,
     kws: Tuple[str, ...],
     type: str,
-    text: str,
+    text: Optional[str],
     expected: bool,
 ):
+    from nonebot.consts import KEYWORD_KEY
     from nonebot.rule import KeywordsRule, keyword
 
     test_keyword = keyword(*kws)
@@ -177,9 +199,11 @@ async def test_keyword(
     assert isinstance(checker, KeywordsRule)
     assert checker.keywords == kws
 
-    message = make_fake_message()(text)
+    message = text if text is None else make_fake_message()(text)
     event = make_fake_event(_type=type, _message=message)()
-    assert await dependent(event=event) == expected
+    for kw in kws:
+        state = {KEYWORD_KEY: kw}
+        assert await dependent(event=event, state=state) == expected
 
 
 @pytest.mark.asyncio
@@ -195,16 +219,161 @@ async def test_command(app: App, cmds: Tuple[Tuple[str, ...]]):
     checker = dependent.call
 
     assert isinstance(checker, CommandRule)
-    assert checker.cmds == list(cmds)
+    assert checker.cmds == cmds
 
     for cmd in cmds:
         state = {PREFIX_KEY: {CMD_KEY: cmd}}
         assert await dependent(state=state)
 
 
-# TODO: shell command
+@pytest.mark.asyncio
+async def test_shell_command(app: App):
+    from nonebot.typing import T_State
+    from nonebot.exception import ParserExit
+    from nonebot.consts import CMD_KEY, PREFIX_KEY, SHELL_ARGS, SHELL_ARGV, CMD_ARG_KEY
+    from nonebot.rule import Namespace, ArgumentParser, ShellCommandRule, shell_command
 
-# TODO: regex
+    state: T_State
+    CMD = ("test",)
+    Message = make_fake_message()
+    MessageSegment = Message.get_segment_class()
+
+    test_not_cmd = shell_command(CMD)
+    dependent = list(test_not_cmd.checkers)[0]
+    checker = dependent.call
+    assert isinstance(checker, ShellCommandRule)
+    message = Message()
+    event = make_fake_event(_message=message)()
+    state = {PREFIX_KEY: {CMD_KEY: ("not",), CMD_ARG_KEY: message}}
+    assert not await dependent(event=event, state=state)
+
+    test_no_parser = shell_command(CMD)
+    dependent = list(test_no_parser.checkers)[0]
+    checker = dependent.call
+    assert isinstance(checker, ShellCommandRule)
+    message = Message()
+    event = make_fake_event(_message=message)()
+    state = {PREFIX_KEY: {CMD_KEY: CMD, CMD_ARG_KEY: message}}
+    assert await dependent(event=event, state=state)
+    assert state[SHELL_ARGV] == []
+    assert SHELL_ARGS not in state
+
+    parser = ArgumentParser("test")
+    parser.add_argument("-a", required=True)
+
+    test_simple_parser = shell_command(CMD, parser=parser)
+    dependent = list(test_simple_parser.checkers)[0]
+    checker = dependent.call
+    assert isinstance(checker, ShellCommandRule)
+    message = Message("-a 1")
+    event = make_fake_event(_message=message)()
+    state = {PREFIX_KEY: {CMD_KEY: CMD, CMD_ARG_KEY: message}}
+    assert await dependent(event=event, state=state)
+    assert state[SHELL_ARGV] == ["-a", "1"]
+    assert state[SHELL_ARGS] == Namespace(a="1")
+
+    test_parser_help = shell_command(CMD, parser=parser)
+    dependent = list(test_parser_help.checkers)[0]
+    checker = dependent.call
+    assert isinstance(checker, ShellCommandRule)
+    message = Message("-h")
+    event = make_fake_event(_message=message)()
+    state = {PREFIX_KEY: {CMD_KEY: CMD, CMD_ARG_KEY: message}}
+    assert await dependent(event=event, state=state)
+    assert state[SHELL_ARGV] == ["-h"]
+    assert isinstance(state[SHELL_ARGS], ParserExit)
+    assert state[SHELL_ARGS].status == 0
+    assert state[SHELL_ARGS].message == parser.format_help()
+
+    test_parser_error = shell_command(CMD, parser=parser)
+    dependent = list(test_parser_error.checkers)[0]
+    checker = dependent.call
+    assert isinstance(checker, ShellCommandRule)
+    message = Message()
+    event = make_fake_event(_message=message)()
+    state = {PREFIX_KEY: {CMD_KEY: CMD, CMD_ARG_KEY: message}}
+    assert await dependent(event=event, state=state)
+    assert state[SHELL_ARGV] == []
+    assert isinstance(state[SHELL_ARGS], ParserExit)
+    assert state[SHELL_ARGS].status != 0
+    assert state[SHELL_ARGS].message.startswith(parser.format_usage() + "test: error:")
+
+    test_message_parser = shell_command(CMD, parser=parser)
+    dependent = list(test_message_parser.checkers)[0]
+    checker = dependent.call
+    assert isinstance(checker, ShellCommandRule)
+    message = MessageSegment.text("-a") + MessageSegment.image("test")
+    event = make_fake_event(_message=message)()
+    state = {PREFIX_KEY: {CMD_KEY: CMD, CMD_ARG_KEY: message}}
+    assert await dependent(event=event, state=state)
+    assert state[SHELL_ARGV] == ["-a", MessageSegment.image("test")]
+    assert state[SHELL_ARGS] == Namespace(a=MessageSegment.image("test"))
+
+    if sys.version_info >= (3, 9):
+        parser = ArgumentParser("test", exit_on_error=False)
+        parser.add_argument("-a", required=True)
+
+        test_not_exit = shell_command(CMD, parser=parser)
+        dependent = list(test_not_exit.checkers)[0]
+        checker = dependent.call
+        assert isinstance(checker, ShellCommandRule)
+        message = Message()
+        event = make_fake_event(_message=message)()
+        state = {PREFIX_KEY: {CMD_KEY: CMD, CMD_ARG_KEY: message}}
+        assert await dependent(event=event, state=state)
+        assert state[SHELL_ARGV] == []
+        assert isinstance(state[SHELL_ARGS], ParserExit)
+        assert state[SHELL_ARGS].status != 0
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "pattern,type,text,expected,matched,string,group,dict",
+    [
+        (
+            r"(?P<key>key\d)",
+            "message",
+            "_key1_",
+            True,
+            "key1",
+            "key1",
+            ("key1",),
+            {"key": "key1"},
+        ),
+        (r"foo", "message", None, False, None, None, None, None),
+        (r"foo", "notice", "foo", False, None, None, None, None),
+    ],
+)
+async def test_regex(
+    app: App,
+    pattern: str,
+    type: str,
+    text: Optional[str],
+    expected: bool,
+    matched: Optional[str],
+    string: Optional[str],
+    group: Optional[Tuple[str, ...]],
+    dict: Optional[Dict[str, str]],
+):
+    from nonebot.typing import T_State
+    from nonebot.rule import RegexRule, regex
+    from nonebot.consts import REGEX_STR, REGEX_DICT, REGEX_GROUP, REGEX_MATCHED
+
+    test_regex = regex(pattern)
+    dependent = list(test_regex.checkers)[0]
+    checker = dependent.call
+
+    assert isinstance(checker, RegexRule)
+    assert checker.regex == pattern
+
+    message = text if text is None else make_fake_message()(text)
+    event = make_fake_event(_type=type, _message=message)()
+    state = {}
+    assert await dependent(event=event, state=state) == expected
+    assert state.get(REGEX_MATCHED) == matched
+    assert state.get(REGEX_STR) == string
+    assert state.get(REGEX_GROUP) == group
+    assert state.get(REGEX_DICT) == dict
 
 
 @pytest.mark.asyncio
@@ -212,11 +381,32 @@ async def test_command(app: App, cmds: Tuple[Tuple[str, ...]]):
 async def test_to_me(app: App, expected: bool):
     from nonebot.rule import ToMeRule, to_me
 
-    test_keyword = to_me()
-    dependent = list(test_keyword.checkers)[0]
+    test_to_me = to_me()
+    dependent = list(test_to_me.checkers)[0]
     checker = dependent.call
 
     assert isinstance(checker, ToMeRule)
 
     event = make_fake_event(_to_me=expected)()
     assert await dependent(event=event) == expected
+
+
+@pytest.mark.asyncio
+async def test_is_type(app: App):
+    from nonebot.rule import IsTypeRule, is_type
+
+    Event1 = make_fake_event()
+    Event2 = make_fake_event()
+    Event3 = make_fake_event()
+
+    test_type = is_type(Event1, Event2)
+    dependent = list(test_type.checkers)[0]
+    checker = dependent.call
+
+    assert isinstance(checker, IsTypeRule)
+
+    event = Event1()
+    assert await dependent(event=event)
+
+    event = Event3()
+    assert not await dependent(event=event)

tests/utils.py

@@ -65,7 +65,7 @@ def make_fake_event(
     _type: str = "message",
     _name: str = "test",
     _description: str = "test",
-    _user_id: str = "test",
+    _user_id: Optional[str] = "test",
     _session_id: Optional[str] = "test",
     _message: Optional["Message"] = None,
     _to_me: bool = True,
@@ -86,7 +86,9 @@ def make_fake_event(
             return _description
 
         def get_user_id(self) -> str:
-            return _user_id
+            if _user_id is not None:
+                return _user_id
+            raise NotImplementedError
 
         def get_session_id(self) -> str:
             if _session_id is not None:

website/docs/README.md

@@ -8,7 +8,7 @@ slug: /
 
 NoneBot2 是一个现代、跨平台、可扩展的 Python 聊天机器人框架，它基于 Python 的类型注解和异步特性，能够为你的需求实现提供便捷灵活的支持。
 
-需要注意的是，NoneBot2 仅支持 **Python 3.7.3 以上版本**
+需要注意的是，NoneBot2 仅支持 **Python 3.8 以上版本**
 
 ## 特色