🔖 Release 2.1.0

Co-authored-by: Ju4tCode <42488585+yanyongyu@users.noreply.github.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,56 @@
-// 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",
+  "name": "Default Linux Universal",
-  "build": {
+  "image": "mcr.microsoft.com/devcontainers/universal:2-linux",
-    "dockerfile": "Dockerfile",
+  "features": {
-    "context": ".."
+    "ghcr.io/devcontainers-contrib/features/poetry:2": {}
   },
-  "settings": {
+  "postCreateCommand": "poetry config virtualenvs.in-project true && poetry install -E all && poetry run pre-commit install && yarn install",
-    "go.toolsManagement.checkForUpdates": "local",
+  "customizations": {
-    "go.useLanguageServer": true,
+    "vscode": {
-    "go.gopath": "/go",
+      "settings": {
-    "python.defaultInterpreterPath": "/opt/python/latest/bin/python",
+        "python.analysis.diagnosticMode": "workspace",
-    "python.formatting.autopep8Path": "/usr/local/py-utils/bin/autopep8",
+        "python.analysis.typeCheckingMode": "basic",
-    "python.formatting.blackPath": "/usr/local/py-utils/bin/black",
+        "ruff.organizeImports": false,
-    "python.formatting.yapfPath": "/usr/local/py-utils/bin/yapf",
+        "[python]": {
-    "python.linting.banditPath": "/usr/local/py-utils/bin/bandit",
+          "editor.defaultFormatter": "ms-python.black-formatter",
-    "python.linting.flake8Path": "/usr/local/py-utils/bin/flake8",
+          "editor.codeActionsOnSave": {
-    "python.linting.mypyPath": "/usr/local/py-utils/bin/mypy",
+            "source.fixAll.ruff": true,
-    "python.linting.pycodestylePath": "/usr/local/py-utils/bin/pycodestyle",
+            "source.organizeImports": true
-    "python.linting.pydocstylePath": "/usr/local/py-utils/bin/pydocstyle",
+          }
-    "python.linting.pylintPath": "/usr/local/py-utils/bin/pylint",
+        },
-    "python.analysis.diagnosticMode": "workspace",
+        "[javascript]": {
-    "python.analysis.typeCheckingMode": "basic",
+          "editor.defaultFormatter": "esbenp.prettier-vscode"
-    "[python]":{
+        },
-      "editor.defaultFormatter": "ms-python.black-formatter",
+        "[html]": {
-      "editor.codeActionsOnSave": {
+          "editor.defaultFormatter": "esbenp.prettier-vscode"
-        "source.organizeImports": true
+        },
-      }
+        "[typescript]": {
-    },
+          "editor.defaultFormatter": "esbenp.prettier-vscode"
-    "[javascript]": {
+        },
-      "editor.defaultFormatter": "esbenp.prettier-vscode"
+        "[javascriptreact]": {
-    },
+          "editor.defaultFormatter": "esbenp.prettier-vscode"
-    "[html]": {
+        },
-      "editor.defaultFormatter": "esbenp.prettier-vscode"
+        "[typescriptreact]": {
-    },
+          "editor.defaultFormatter": "esbenp.prettier-vscode"
-    "[typescript]": {
+        },
-      "editor.defaultFormatter": "esbenp.prettier-vscode"
+        "files.exclude": {
-    },
+          "**/__pycache__": true
-    "[javascriptreact]": {
+        },
-      "editor.defaultFormatter": "esbenp.prettier-vscode"
+        "files.watcherExclude": {
-    },
+          "**/target/**": true,
-    "[typescriptreact]": {
+          "**/__pycache__": true
-      "editor.defaultFormatter": "esbenp.prettier-vscode"
+        }
-    },
+      },
-    "lldb.executable": "/usr/bin/lldb",
+      "extensions": [
-    "files.exclude": {
+        "ms-python.python",
-      "**/__pycache__": true
+        "ms-python.vscode-pylance",
-    },
+        "ms-python.isort",
-    "files.watcherExclude": {
+        "ms-python.black-formatter",
-      "**/target/**": true,
+        "charliermarsh.ruff",
-      "**/__pycache__": true
+        "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"
 }

.gitattributes

@@ -0,0 +1 @@
+website/versioned_*/** linguist-documentation

.github/ISSUE_TEMPLATE/adapter_publish.yml

@@ -0,0 +1,57 @@
+name: 发布适配器
+title: "Adapter: {name}"
+description: 发布适配器到 NoneBot 官方商店
+labels: ["Adapter"]
+body:
+  - type: input
+    id: name
+    attributes:
+      label: 适配器名称
+      description: 适配器名称
+    validations:
+      required: true
+
+  - type: input
+    id: description
+    attributes:
+      label: 适配器描述
+      description: 适配器描述
+    validations:
+      required: true
+
+  - type: input
+    id: pypi
+    attributes:
+      label: PyPI 项目名
+      description: PyPI 项目名
+      placeholder: e.g. nonebot-adapter-xxx
+    validations:
+      required: true
+
+  - type: input
+    id: module
+    attributes:
+      label: 适配器 import 包名
+      description: 适配器 import 包名
+      placeholder: e.g. nonebot_adapter_xxx
+    validations:
+      required: true
+
+  - type: input
+    id: homepage
+    attributes:
+      label: 适配器项目仓库/主页链接
+      description: 适配器项目仓库/主页链接
+      placeholder: e.g. https://github.com/xxx/xxx
+    validations:
+      required: true
+
+  - type: input
+    id: tags
+    attributes:
+      label: 标签
+      description: 标签
+      placeholder: 'e.g. [{"label": "标签名", "color": "#ea5252"}]'
+      value: "[]"
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/bot_publish.yml

@@ -0,0 +1,37 @@
+name: 发布机器人
+title: "Bot: {name}"
+description: 发布机器人到 NoneBot 官方商店
+labels: ["Bot"]
+body:
+  - type: input
+    id: name
+    attributes:
+      label: 机器人名称
+      description: 机器人名称
+    validations:
+      required: true
+
+  - type: input
+    id: description
+    attributes:
+      label: 机器人描述
+      description: 机器人描述
+    validations:
+      required: true
+
+  - type: input
+    id: homepage
+    attributes:
+      label: 机器人项目仓库/主页链接
+      description: 机器人项目仓库/主页链接
+      placeholder: e.g. https://github.com/xxx/xxx
+
+  - type: input
+    id: tags
+    attributes:
+      label: 标签
+      description: 标签
+      placeholder: 'e.g. [{"label": "标签名", "color": "#ea5252"}]'
+      value: "[]"
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/bug-report.md

@@ -1,38 +0,0 @@
----
-name: Bug report
-about: Create a bug report to help us improve
-title: 'Bug: Something went wrong'
-labels: bug
-assignees: ''
-
----
-
-**描述问题：**
-
-A clear and concise description of what the bug is.
-
-**如何复现？**
-
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**期望的结果**
-
-A clear and concise description of what you expected to happen.
-
-**环境信息：**
-
- - OS: [e.g. Linux]
- - Python Version: [e.g. 3.8]
- - Nonebot Version: [e.g. 2.0.0]
-
-**协议端信息：**
-
- - 协议端: [e.g. go-cqhttp]
- - 协议端版本: [e.g. 1.0.0]
-
-**截图或日志**
-
-If applicable, add screenshots to help explain your problem.

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,85 @@
+name: Bug 反馈
+title: "Bug: 出现异常"
+description: 提交 Bug 反馈以帮助我们改进代码
+labels: ["bug"]
+body:
+  - type: dropdown
+    id: env-os
+    attributes:
+      label: 操作系统
+      description: 选择运行 NoneBot 的系统
+      options:
+        - Windows
+        - MacOS
+        - Linux
+        - Other
+    validations:
+      required: true
+
+  - type: input
+    id: env-python-ver
+    attributes:
+      label: Python 版本
+      description: 填写运行 NoneBot 的 Python 版本
+      placeholder: e.g. 3.11.0
+    validations:
+      required: true
+
+  - type: input
+    id: env-nb-ver
+    attributes:
+      label: NoneBot 版本
+      description: 填写 NoneBot 版本
+      placeholder: e.g. 2.0.0
+    validations:
+      required: true
+
+  - type: input
+    id: env-adapter
+    attributes:
+      label: 适配器
+      description: 填写使用的适配器以及版本
+      placeholder: e.g. OneBot v11 2.2.2
+    validations:
+      required: true
+
+  - type: input
+    id: env-protocol
+    attributes:
+      label: 协议端
+      description: 填写连接 NoneBot 的协议端及版本
+      placeholder: e.g. go-cqhttp 1.0.0
+    validations:
+      required: true
+
+  - type: textarea
+    id: describe
+    attributes:
+      label: 描述问题
+      description: 清晰简洁地说明问题是什么
+    validations:
+      required: true
+
+  - type: textarea
+    id: reproduction
+    attributes:
+      label: 复现步骤
+      description: 提供能复现此问题的详细操作步骤
+      placeholder: |
+        1. 首先……
+        2. 然后……
+        3. 发生……
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected
+    attributes:
+      label: 期望的结果
+      description: 清晰简洁地描述你期望发生的事情
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: 截图或日志
+      description: 提供有助于诊断问题的任何日志和截图

.github/ISSUE_TEMPLATE/config.yml

@@ -1,14 +1,5 @@
 blank_issues_enabled: false
 contact_links:
-  - name: Question
+  - name: NoneBot 论坛
     url: https://discussions.nonebot.dev/
-    about: Ask questions about nonebot
+    about: 前往 NoneBot 论坛提问
-  - name: Plugin Publish
-    url: https://v2.nonebot.dev/store
-    about: Publish your plugin to nonebot homepage and nb-cli
-  - name: Adapter Publish
-    url: https://v2.nonebot.dev/store
-    about: Publish your adapter to nonebot homepage and nb-cli
-  - name: Bot Publish
-    url: https://v2.nonebot.dev/store
-    about: Publish your bot to nonebot homepage and nb-cli

.github/ISSUE_TEMPLATE/document.md

@@ -1,17 +0,0 @@
----
-name: Document improvement
-about: Feedback on documentation, including errors and ideas
-title: 'Docs: some description'
-labels: documentation
-assignees: ''
-
----
-
-**描述问题或主题：**
-
-
-**需做出的修改：**
-
-* [ ]  一些修改
-* [ ]  一些修改
-* [ ]  一些修改

.github/ISSUE_TEMPLATE/document.yml

@@ -0,0 +1,18 @@
+name: 文档改进
+title: "Docs: 描述"
+description: 文档错误及改进意见反馈
+labels: ["documentation"]
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: 描述问题或主题
+    validations:
+      required: true
+
+  - type: textarea
+    id: improve
+    attributes:
+      label: 需做出的修改
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,16 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: 'Feature: Something you want'
-labels: enhancement
-assignees: ''
-
----
-
-**是否在使用中遇到某些问题而需要新的特性？请描述：**
-
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**描述你所需要的特性：**
-
-A clear and concise description of what you want to happen.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,20 @@
+name: 功能建议
+title: "Feature: 功能描述"
+description: 提出关于项目新功能的想法
+labels: ["enhancement"]
+body:
+  - type: textarea
+    id: problem
+    attributes:
+      label: 希望能解决的问题
+      description: 在使用中遇到什么问题而需要新的功能？
+    validations:
+      required: true
+
+  - type: textarea
+    id: feature
+    attributes:
+      label: 描述所需要的功能
+      description: 请说明需要的功能或解决方法
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/plugin_publish.yml

@@ -0,0 +1,43 @@
+name: 发布插件
+title: "Plugin: {name}"
+description: 发布插件到 NoneBot 官方商店
+labels: ["Plugin"]
+body:
+  - type: input
+    id: pypi
+    attributes:
+      label: PyPI 项目名
+      description: PyPI 项目名
+      placeholder: e.g. nonebot-plugin-xxx
+    validations:
+      required: true
+
+  - type: input
+    id: module
+    attributes:
+      label: 插件 import 包名
+      description: 插件 import 包名
+      placeholder: e.g. nonebot_plugin_xxx
+    validations:
+      required: true
+
+  - type: input
+    id: tags
+    attributes:
+      label: 标签
+      description: 标签
+      placeholder: 'e.g. [{"label": "标签名", "color": "#ea5252"}]'
+      value: "[]"
+    validations:
+      required: true
+
+  - type: textarea
+    id: config
+    attributes:
+      label: 插件配置项
+      description: 插件配置项
+      render: dotenv
+      placeholder: |
+        # e.g.
+        # KEY=VALUE
+        # KEY2=VALUE2

.github/actions/build-api-doc/action.yml

@@ -5,7 +5,10 @@ runs:
   using: "composite"
   steps:
     - run: |
-        poetry run nb-autodoc nonebot
+        poetry run nb-autodoc nonebot \
+          -s nonebot.plugins \
+          -u nonebot.internal \
+          -u nonebot.internal.*
         cp -r ./build/nonebot/* ./website/docs/api/
         yarn prettier
       shell: bash

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

@@ -4,15 +4,15 @@ description: Setup Node
 runs:
   using: "composite"
   steps:
-    - uses: actions/setup-node@v2
+    - uses: actions/setup-node@v3
       with:
-        node-version: "16"
+        node-version: "18"
 
     - 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,27 +5,20 @@ inputs:
   python-version:
     description: Python version
     required: false
-    default: "3.9"
+    default: "3.10"
 
 runs:
   using: "composite"
   steps:
-    - id: python
+    - name: Install poetry
-      uses: actions/setup-python@v2
+      run: pipx install poetry
+      shell: bash
+
+    - uses: actions/setup-python@v4
       with:
         python-version: ${{ inputs.python-version }}
         architecture: "x64"
-
+        cache: "poetry"
-    - uses: Gr1N/setup-poetry@v7
-
-    - id: poetry-cache
-      run: echo "::set-output name=dir::$(poetry config virtualenvs.path)"
-      shell: bash
-
-    - uses: actions/cache@v2
-      with:
-        path: ${{ steps.poetry-cache.outputs.dir }}
-        key: ${{ runner.os }}-poetry-${{ steps.python.outputs.python-version }}-${{ hashFiles('**/poetry.lock') }}
 
     - run: poetry install -E all
       shell: bash

.github/dependabot.yml

@@ -4,3 +4,18 @@ updates:
     directory: "/"
     schedule:
       interval: daily
+
+  - package-ecosystem: github-actions
+    directory: "/.github/actions/build-api-doc"
+    schedule:
+      interval: daily
+
+  - package-ecosystem: github-actions
+    directory: "/.github/actions/setup-node"
+    schedule:
+      interval: daily
+
+  - package-ecosystem: github-actions
+    directory: "/.github/actions/setup-python"
+    schedule:
+      interval: daily

.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:
@@ -23,7 +27,7 @@ jobs:
       PYTHON_VERSION: ${{ matrix.python-version }}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup Python environment
         uses: ./.github/actions/setup-python

.github/workflows/noneflow.yml

@@ -0,0 +1,100 @@
+name: NoneFlow
+
+on:
+  issues:
+    types: [opened, reopened, edited]
+  pull_request_target:
+    types: [closed]
+  issue_comment:
+    types: [created]
+  pull_request_review:
+    types: [submitted]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.issue.number || github.run_id }}
+  cancel-in-progress: false
+
+jobs:
+  plugin_test:
+    runs-on: ubuntu-latest
+    name: nonebot2 plugin test
+    if: |
+      !(
+        (
+          github.event.pull_request &&
+          (
+            github.event.pull_request.head.repo.fork ||
+            !(
+              contains(github.event.pull_request.labels.*.name, 'Plugin') ||
+              contains(github.event.pull_request.labels.*.name, 'Adapter') ||
+              contains(github.event.pull_request.labels.*.name, 'Bot')
+            )
+          )
+        ) ||
+        (
+          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 }}
+      metadata: ${{ steps.plugin-test.outputs.METADATA }}
+    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.x"
+
+      - name: Test Plugin
+        id: plugin-test
+        run: |
+          curl -sSL https://github.com/nonebot/noneflow/releases/latest/download/plugin_test.py | python -
+  noneflow:
+    runs-on: ubuntu-latest
+    name: noneflow
+    needs: plugin_test
+    steps:
+      - name: Generate token
+        id: generate-token
+        uses: tibdex/github-app-token@v1
+        with:
+          app_id: ${{ secrets.APP_ID }}
+          private_key: ${{ secrets.APP_KEY }}
+
+      - name: Checkout Code
+        uses: actions/checkout@v4
+        with:
+          token: ${{ steps.generate-token.outputs.token }}
+
+      - name: Cache pre-commit hooks
+        uses: actions/cache@v3
+        with:
+          path: .cache/.pre-commit
+          key: noneflow-${{ runner.os }}-${{ hashFiles('.pre-commit-config.yaml') }}
+
+      - name: NoneFlow
+        uses: docker://ghcr.io/nonebot/noneflow:latest
+        with:
+          config: >
+            {
+              "base": "master",
+              "plugin_path": "website/static/plugins.json",
+              "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 }}
+          PLUGIN_TEST_METADATA: ${{ needs.plugin_test.outputs.metadata }}
+          APP_ID: ${{ secrets.APP_ID }}
+          PRIVATE_KEY: ${{ secrets.APP_KEY }}
+          PRE_COMMIT_HOME: /github/workspace/.cache/.pre-commit
+
+      - name: Fix permission
+        run: sudo chown -R $(whoami):$(id -ng) .cache/.pre-commit

.github/workflows/publish-bot.yml

@@ -1,29 +0,0 @@
-name: NoneBot2 Publish Bot
-
-on:
-  issues:
-    types: [opened, reopened, edited]
-  pull_request_target:
-    types: [closed]
-
-jobs:
-  publish_bot:
-    runs-on: ubuntu-latest
-    name: nonebot2 publish bot
-    steps:
-      - 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:
-          token: ${{ secrets.GH_TOKEN }}
-          config: >
-            {
-              "base": "master",
-              "plugin_path": "website/static/plugins.json",
-              "bot_path": "website/static/bots.json",
-              "adapter_path": "website/static/adapters.json"
-            }

.github/workflows/pyright.yml

@@ -0,0 +1,26 @@
+name: Pyright Lint
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    paths:
+      - "nonebot/**"
+      - "packages/**"
+      - "tests/**"
+
+jobs:
+  pyright:
+    name: Pyright Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Python environment
+        uses: ./.github/actions/setup-python
+
+      - run: echo "$(poetry env info --path)/bin" >> $GITHUB_PATH
+
+      - name: Run Pyright
+        uses: jakebailey/pyright-action@v1

.github/workflows/release-drafter.yml

@@ -18,9 +18,16 @@ jobs:
       group: pull-request-changelog
       cancel-in-progress: true
     steps:
-      - uses: actions/checkout@v3
+      - name: Generate token
+        id: generate-token
+        uses: tibdex/github-app-token@v1
         with:
-          token: ${{ secrets.GH_TOKEN }}
+          app_id: ${{ secrets.APP_ID }}
+          private_key: ${{ secrets.APP_KEY }}
+
+      - uses: actions/checkout@v4
+        with:
+          token: ${{ steps.generate-token.outputs.token }}
 
       - name: Setup Node Environment
         uses: ./.github/actions/setup-node
@@ -35,7 +42,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
@@ -43,18 +50,17 @@ jobs:
       - name: Commit and Push
         run: |
           yarn prettier
-          git config user.name github-actions[bot]
+          git config user.name noneflow[bot]
-          git config user.email github-actions[bot]@users.noreply.github.com
+          git config user.email 129742071+noneflow[bot]@users.noreply.github.com
           git add .
           git diff-index --quiet HEAD || git commit -m ":memo: Update changelog"
           git push
 
-
   release:
     if: startsWith(github.ref, 'refs/tags/')
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup Python Environment
         uses: ./.github/actions/setup-python

.github/workflows/release.yml

@@ -6,12 +6,17 @@ on:
 jobs:
   build:
     runs-on: ubuntu-latest
-
     steps:
-      - uses: actions/checkout@v3
+      - name: Generate token
+        id: generate-token
+        uses: tibdex/github-app-token@v1
         with:
-          ref: master
+          app_id: ${{ secrets.APP_ID }}
-          token: ${{ secrets.GH_TOKEN }}
+          private_key: ${{ secrets.APP_KEY }}
+
+      - uses: actions/checkout@v4
+        with:
+          token: ${{ steps.generate-token.outputs.token }}
 
       - name: Setup Python Environment
         uses: ./.github/actions/setup-python
@@ -39,8 +44,8 @@ jobs:
 
       - name: Push Tag
         run: |
-          git config user.name github-actions[bot]
+          git config user.name noneflow[bot]
-          git config user.email github-actions[bot]@users.noreply.github.com
+          git config user.email 129742071+noneflow[bot]@users.noreply.github.com
           git add .
           git commit -m ":bookmark: Release $(poetry version -s)"
           git tag ${{ env.TAG_NAME }}

.github/workflows/ruff.yml

@@ -0,0 +1,21 @@
+name: Ruff Lint
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    paths:
+      - "nonebot/**"
+      - "packages/**"
+      - "tests/**"
+
+jobs:
+  ruff:
+    name: Ruff Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Run Ruff Lint
+        uses: chartboost/ruff-action@v1

.github/workflows/website-deploy.yml

@@ -13,7 +13,9 @@ jobs:
       cancel-in-progress: true
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
 
       - name: Setup Python Environment
         uses: ./.github/actions/setup-python
@@ -31,7 +33,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

@@ -11,9 +11,10 @@ jobs:
       cancel-in-progress: true
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           ref: ${{ github.event.pull_request.head.sha }}
+          fetch-depth: 0
 
       - name: Setup Python Environment
         uses: ./.github/actions/setup-python
@@ -32,7 +33,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

.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,34 @@ ci:
   autoupdate_schedule: monthly
   autoupdate_commit_msg: ":arrow_up: auto update by pre-commit hooks"
 repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.0.287
+    hooks:
+      - id: ruff
+        args: [--fix, --exit-non-zero-on-fix]
+        stages: [commit]
+
   - repo: https://github.com/pycqa/isort
-    rev: 5.10.1
+    rev: 5.12.0
     hooks:
       - id: isort
+        stages: [commit]
 
   - repo: https://github.com/psf/black
-    rev: 22.3.0
+    rev: 23.7.0
     hooks:
       - id: black
+        stages: [commit]
 
   - repo: https://github.com/pre-commit/mirrors-prettier
-    rev: v2.6.2
+    rev: v3.0.3
     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.4
+    hooks:
+      - id: nonemoji
+        stages: [prepare-commit-msg]

CHANGELOG.md

@@ -1,3 +1,3 @@
 # Changelog
 
-See [changelog.md](./website/src/pages/changelog.md) or <https://v2.nonebot.dev/changelog>
+See [changelog.md](./website/src/pages/changelog.md) or <https://nonebot.dev/changelog>

CONTRIBUTING.md

@@ -10,12 +10,10 @@
 
 ### 报告问题、故障与漏洞
 
-NoneBot2 仍然是一个不够稳定的开发中项目，如果你在使用过程中发现问题并确信是由 NoneBot2 引起的，欢迎提交 Issue。
+如果你在使用过程中发现问题并确信是由 NoneBot2 引起的，欢迎提交 Issue。
 
 ### 建议功能
 
-NoneBot2 还未进入正式版，欢迎在 Issue 中提议要加入哪些新功能。
-
 为了让开发者更好地理解你的意图，请认真描述你所需要的特性，可能的话可以提出你认为可行的解决方案。
 
 ## Pull Request
@@ -29,14 +27,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 选择 `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,6 +39,12 @@ 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 标题请尽量更改成中文，以便自动生成更新日志。
@@ -63,16 +64,17 @@ yarn start
 
 NoneBot2 文档并没有具体的行文风格规范，但我们建议你尽量写得简单易懂。
 
-以下是比较重要的排版规范。目前 NoneBot2 文档中仍有部分文档不完全遵守此规范，如果在阅读时发现欢迎提交 PR。
+以下是比较重要的编写与排版规范。目前 NoneBot2 文档中仍有部分文档不完全遵守此规范，如果在阅读时发现欢迎提交 PR。
 
 1. 中文与英文、数字、半角符号之间需要有空格。例：`NoneBot2 是一个可扩展的 Python 异步机器人框架。`
 2. 若非英文整句，使用全角标点符号。例：`现在你可以看到机器人回复你：“Hello, World !”。`
 3. 直引号`「」`和弯引号`“”`都可接受，但同一份文件里应使用同种引号。
 4. **不要使用斜体**，你不需要一种与粗体不同的强调。除此之外，你也可以考虑使用 docusaurus 提供的[告示](https://docusaurus.io/zh-CN/docs/markdown-features/admonitions)功能。
+5. 文档中应以“我们”指代机器人开发者，以“机器人用户”指代机器人的使用者。
 
-这是社区创始人 richardchien 的中文排版规范，可供参考：<https://stdrc.cc/style-guides/chinese>。
+以上由[社区创始人 richardchien 的中文排版规范](https://stdrc.cc/style-guides/chinese)补充修改得到。
 
-如果你需要编辑器提示 Markdown 规范，可以安装 VSCode 上的 markdownlint 插件。
+如果你需要编辑器检查 Markdown 规范，可以在 VSCode 中安装 markdownlint 扩展。
 
 ### 参与开发
 
@@ -80,7 +82,7 @@ NoneBot2 的代码风格遵循 [PEP 8](https://www.python.org/dev/peps/pep-0008/
 
 ## 为社区做贡献
 
-你可以在 NoneBot 商店上架自己的适配器、插件、机器人，具体步骤可参考 [发布插件](https://v2.nonebot.dev/docs/advanced/publish-plugin) 一节。
+你可以在 NoneBot 商店上架自己的适配器、插件、机器人，具体步骤可参考 [发布插件](https://nonebot.dev/docs/developer/plugin-publishing) 一节。
 
 我们仅对插件的兼容性进行简单测试，并会在下一个版本发布前对与该版本不兼容的插件作出处理。
 

README.md

@@ -1,6 +1,6 @@
 <!-- markdownlint-disable MD033 MD041 -->
 <p align="center">
-  <a href="https://v2.nonebot.dev/"><img src="https://v2.nonebot.dev/logo.png" width="200" height="200" alt="nonebot"></a>
+  <a href="https://nonebot.dev/"><img src="https://nonebot.dev/logo.png" width="200" height="200" alt="nonebot"></a>
 </p>
 
 <div align="center">
@@ -19,9 +19,19 @@ _✨ 跨平台 Python 异步机器人框架 ✨_
     <img src="https://img.shields.io/github/license/nonebot/nonebot2" alt="license">
   </a>
   <a href="https://pypi.python.org/pypi/nonebot2">
-    <img src="https://img.shields.io/pypi/v/nonebot2" alt="pypi">
+    <img src="https://img.shields.io/pypi/v/nonebot2?logo=python&logoColor=edb641" 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?logo=python&logoColor=edb641" alt="python">
+  <a href="https://github.com/psf/black">
+    <img src="https://img.shields.io/badge/code%20style-black-000000.svg?logo=python&logoColor=edb641" alt="black">
+  </a>
+  <a href="https://github.com/Microsoft/pyright">
+    <img src="https://img.shields.io/badge/types-pyright-797952.svg?logo=python&logoColor=edb641" alt="pyright">
+  </a>
+  <a href="https://github.com/astral-sh/ruff">
+    <img src="https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json" alt="ruff">
+  </a>
+  <br />
   <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,24 +39,36 @@ _✨ 跨平台 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>
+  <a href="https://github.com/nonebot/nonebot2/actions/workflows/pyright.yml">
+    <img src="https://github.com/nonebot/nonebot2/actions/workflows/pyright.yml/badge.svg?branch=master&event=push" alt="pyright">
+  </a>
+  <a href="https://github.com/nonebot/nonebot2/actions/workflows/ruff.yml">
+    <img src="https://github.com/nonebot/nonebot2/actions/workflows/ruff.yml/badge.svg?branch=master&event=push" alt="ruff">
   </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">
+  <a href="https://onebot.dev/">
-    <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">
+    <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/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMTIuODIgMTMwLjg5Ij48ZyBkYXRhLW5hbWU9IuWbvuWxgiAyIj48ZyBkYXRhLW5hbWU9IuWbvuWxgiAxIj48cGF0aCBkPSJNNTUuNjMgMTMwLjhjLTcgMC0xMy45LjA4LTIwLjg2IDAtMTkuMTUtLjI1LTMxLjcxLTExLjQtMzQuMjItMzAuMy00LjA3LTMwLjY2IDE0LjkzLTU5LjIgNDQuODMtNjYuNjQgMi0uNTEgNS4yMS0uMzEgNS4yMS0xLjYzIDAtMi4xMy4xNC0yLjEzLjE0LTUuNTcgMC0uODktMS4zLTEuNDYtMi4yMi0yLjMxLTYuNzMtNi4yMy03LjY3LTEzLjQxLTEtMjAuMTggNS40LTUuNTIgMTEuODctNS40IDE3LjgtLjU5IDYuNDkgNS4yNiA2LjMxIDEzLjA4LS44NiAyMS0uNjguNzQtMS43OCAxLjYtMS43OCAyLjY3djQuMjFjMCAxLjM1IDIuMiAxLjYyIDQuNzkgMi4zNSAzMS4wOSA4LjY1IDQ4LjE3IDM0LjEzIDQ1IDY2LjM3LTEuNzYgMTguMTUtMTQuNTYgMzAuMjMtMzIuNyAzMC42My04LjAyLjE5LTE2LjA3LS4wMS0yNC4xMy0uMDF6IiBmaWxsPSIjMDI5OWZlIi8+PHBhdGggZD0iTTMxLjQ2IDExOC4zOGMtMTAuNS0uNjktMTYuOC02Ljg2LTE4LjM4LTE3LjI3LTMtMTkuNDIgMi43OC0zNS44NiAxOC40Ni00Ny44MyAxNC4xNi0xMC44IDI5Ljg3LTEyIDQ1LjM4LTMuMTkgMTcuMjUgOS44NCAyNC41OSAyNS44MSAyNCA0NS4yOS0uNDkgMTUuOS04LjQyIDIzLjE0LTI0LjM4IDIzLjUtNi41OS4xNC0xMy4xOSAwLTE5Ljc5IDAiIGZpbGw9IiNmZWZlZmUiLz48cGF0aCBkPSJNNDYuMDUgNzkuNThjLjA5IDUgLjIzIDkuODItNyA5Ljc3LTcuODItLjA2LTYuMS01LjY5LTYuMjQtMTAuMTktLjE1LTQuODItLjczLTEwIDYuNzMtOS44NHM2LjM3IDUuNTUgNi41MSAxMC4yNnoiIGZpbGw9IiMxMDlmZmUiLz48cGF0aCBkPSJNODAuMjcgNzkuMjdjLS41MyAzLjkxIDEuNzUgOS42NC01Ljg4IDEwLTcuNDcuMzctNi44MS00LjgyLTYuNjEtOS41LjItNC4zMi0xLjgzLTEwIDUuNzgtMTAuNDJzNi41OSA0Ljg5IDYuNzEgOS45MnoiIGZpbGw9IiMwODljZmUiLz48L2c+PC9nPjwvc3ZnPg==" alt="QQ频道">
   </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="dingtalk"> -->
+  </a>
   <br />
   <a href="https://jq.qq.com/?_wv=1027&k=5OFifDh">
     <img src="https://img.shields.io/badge/QQ%E7%BE%A4-768887710-orange?style=flat-square" alt="QQ Chat Group">
@@ -63,18 +85,16 @@ _✨ 跨平台 Python 异步机器人框架 ✨_
 </p>
 
 <p align="center">
-  <a href="https://v2.nonebot.dev/">文档</a>
+  <a href="https://nonebot.dev/">文档</a>
   ·
-  <a href="https://v2.nonebot.dev/docs/start/installation">安装</a>
+  <a href="https://nonebot.dev/docs/quick-start">快速上手</a>
-  ·
-  <a href="https://v2.nonebot.dev/docs/tutorial/create-project">开始使用</a>
   ·
   <a href="#插件">文档打不开？</a>
 </p>
 
 <p align="center">
-  <a href="https://asciinema.org/a/464654">
+  <a href="https://asciinema.org/a/569440">
-    <img src="https://v2.nonebot.dev/img/setup.svg">
+    <img src="https://nonebot.dev/img/setup.svg">
   </a>
 </p>
 
@@ -86,22 +106,40 @@ NoneBot2 是一个现代、跨平台、可扩展的 Python 聊天机器人框架
 
 - 异步优先：基于 Python 的异步特性，即使是~~非常~~大量的消息，也能吞吐自如
 - 易于开发：配合 NB-CLI 脚手架，代码编写上手简单，没有过多的冗余代码，可以让开发者专注于业务逻辑
-- 生而可靠：100% 类型注解覆盖，配合编辑器的类型推导功能，能将绝大多数的 Bug 杜绝在编辑器中 ([编辑器支持](https://v2.nonebot.dev/docs/start/editor-support))
+- 生而可靠：100% 类型注解覆盖，配合编辑器的类型推导功能，能将绝大多数的 Bug 杜绝在编辑器中 ([编辑器支持](https://nonebot.dev/docs/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/)
 
-更多：[概览](https://v2.nonebot.dev/docs/)
+  |                                                           协议名称                                                           | 状态 |                                   注释                                    |
+  | :--------------------------------------------------------------------------------------------------------------------------: | :--: | :-----------------------------------------------------------------------: |
+  |                   OneBot（[仓库](https://github.com/nonebot/adapter-onebot)，[协议](https://onebot.dev/)）                   |  ✅  | 支持 QQ、TG、微信公众号、KOOK 等[平台](https://onebot.dev/ecosystem.html) |
+  |         Telegram（[仓库](https://github.com/nonebot/adapter-telegram)，[协议](https://core.telegram.org/bots/api)）          |  ✅  |                                                                           |
+  |        飞书（[仓库](https://github.com/nonebot/adapter-feishu)，[协议](https://open.feishu.cn/document/home/index)）         |  ✅  |                                                                           |
+  |             GitHub（[仓库](https://github.com/nonebot/adapter-github)，[协议](https://docs.github.com/en/apps)）             |  ✅  |                          GitHub APP & OAuth APP                           |
+  |              QQ 频道（[仓库](https://github.com/nonebot/adapter-qqguild)，[协议](https://bot.q.qq.com/wiki/)）               |  ✅  |                             官方接口调整较多                              |
+  |             钉钉（[仓库](https://github.com/nonebot/adapter-ding)，[协议](https://open.dingtalk.com/document/)）             |  🤗  |                        寻找 Maintainer（暂不可用）                        |
+  |                                Console（[仓库](https://github.com/nonebot/adapter-console)）                                 |  ✅  |                                控制台交互                                 |
+  |        Red （[仓库](https://github.com/nonebot/adapter-red)，[协议](https://chrononeko.github.io/QQNTRedProtocol/)）         |  ✅  |                                  QQ 协议                                  |
+  |      Discord （[仓库](https://github.com/nonebot/adapter-discord)，[协议](https://discord.com/developers/docs/intro)）       |  ✅  |                             Discord Bot 协议                              |
+  |        开黑啦（[仓库](https://github.com/Tian-que/nonebot-adapter-kaiheila)，[协议](https://developer.kookapp.cn/)）         |  ↗️  |                                由社区贡献                                 |
+  |    Mirai（[仓库](https://github.com/ieew/nonebot_adapter_mirai2)，[协议](https://docs.mirai.mamoe.net/mirai-api-http/)）     |  ↗️  |                            QQ 协议，由社区贡献                            |
+  |                              Ntchat（[仓库](https://github.com/JustUndertaker/adapter-ntchat)）                              |  ↗️  |                           微信协议，由社区贡献                            |
+  |                         MineCraft（[仓库](https://github.com/17TheWord/nonebot-adapter-minecraft)）                          |  ↗️  |                                由社区贡献                                 |
+  |                             BiliBili Live（[仓库](https://github.com/wwweww/adapter-bilibili)）                              |  ↗️  |                                由社区贡献                                 |
+  |                          Walle-Q（[仓库](https://github.com/onebot-walle/nonebot_adapter_walleq)）                           |  ↗️  |                            QQ 协议，由社区贡献                            |
+  | Villa（[仓库](https://github.com/CMHopeSunshine/nonebot-adapter-villa)，[协议](https://webstatic.mihoyo.com/vila/bot/doc/)） |  ↗️  |                     米游社大别野 Bot 协议，由社区贡献                     |
+
+- 坚实后盾：支持多种 web 框架，可自定义替换、组合
+
+  |                              驱动框架                               |  类型  |
+  | :-----------------------------------------------------------------: | :----: |
+  |              [FastAPI](https://fastapi.tiangolo.com/)               | 服务端 |
+  | [Quart](https://quart.palletsprojects.com/en/latest/)（异步 Flask） | 服务端 |
+  |           [aiohttp](https://docs.aiohttp.org/en/stable/)            | 客户端 |
+  |               [httpx](https://www.python-httpx.org/)                | 客户端 |
+  |     [websockets](https://websockets.readthedocs.io/en/stable/)      | 客户端 |
+
+更多：[概览](https://nonebot.dev/docs/)
 
 ## 什么不是 NoneBot2
 
@@ -113,16 +151,21 @@ NoneBot2 不是 NoneBot1 的替代品。事实上，它们都在被积极的维
 
 ## 即刻开始
 
-~~完整~~文档可以在 [这里](https://v2.nonebot.dev/) 查看。
+~~完整~~文档可以在 [这里](https://nonebot.dev/) 查看。
 
 懒得看文档？下面是快速安装指南：
 
-1. (**强烈建议**)使用你喜欢的 Python 环境管理工具创建新的虚拟环境。
+1. 安装 [pipx](https://pypa.github.io/pipx/)
-
-2. 使用 `pip` (或其他) 安装 NoneBot 脚手架。
 
    ```bash
-   pip install nb-cli
+   python -m pip install --user pipx
+   python -m pipx ensurepath
+   ```
+
+2. 安装脚手架
+
+   ```bash
+   pipx install nb-cli
    ```
 
 3. 使用脚手架创建项目
@@ -131,6 +174,12 @@ NoneBot2 不是 NoneBot1 的替代品。事实上，它们都在被积极的维
    nb create
    ```
 
+4. 运行项目
+
+   ```bash
+   nb run
+   ```
+
 ## 社区资源
 
 ### 常见问题
@@ -159,7 +208,7 @@ NoneBot2 不是 NoneBot1 的替代品。事实上，它们都在被积极的维
   - [文档镜像(中国境内)](https://nb2.baka.icu)
   - [文档镜像(Vercel)](https://nonebot2-vercel-mirror.vercel.app)
 
-- 其他插件请查看 [商店](https://v2.nonebot.dev/store)
+- 其他插件请查看 [商店](https://nonebot.dev/store)
 
 ## 许可证
 
@@ -183,5 +232,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>`
@@ -23,13 +24,17 @@
 - `load_all_plugins` => {ref}``load_all_plugins` <nonebot.plugin.load.load_all_plugins>`
 - `load_from_json` => {ref}``load_from_json` <nonebot.plugin.load.load_from_json>`
 - `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_plugin` =>
-- `load_builtin_plugins` => {ref}``load_builtin_plugins` <nonebot.plugin.load.load_builtin_plugins>`
+  {ref}``load_builtin_plugin` <nonebot.plugin.load.load_builtin_plugin>`
-- `get_plugin` => {ref}``get_plugin` <nonebot.plugin.plugin.get_plugin>`
+- `load_builtin_plugins` =>
-- `get_plugin_by_module_name` => {ref}``get_plugin_by_module_name` <nonebot.plugin.plugin.get_plugin_by_module_name>`
+  {ref}``load_builtin_plugins` <nonebot.plugin.load.load_builtin_plugins>`
-- `get_loaded_plugins` => {ref}``get_loaded_plugins` <nonebot.plugin.plugin.get_loaded_plugins>`
+- `get_plugin` => {ref}``get_plugin` <nonebot.plugin.get_plugin>`
-- `get_available_plugin_names` => {ref}``get_available_plugin_names` <nonebot.plugin.plugin.get_available_plugin_names>`
+- `get_plugin_by_module_name` =>
-- `export` => {ref}``export` <nonebot.plugin.export.export>`
+  {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:
@@ -37,24 +42,25 @@ FrontMatter:
     description: nonebot 模块
 """
 
-import importlib
+import os
-from typing import Any, Dict, Type, Optional
+from importlib.metadata import version
+from typing import Any, Dict, Type, Union, TypeVar, Optional, overload
 
-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
+from nonebot.adapters import Bot, Adapter
+from nonebot.utils import escape_tag, resolve_dot_notation
+from nonebot.drivers import Driver, ASGIMixin, combine_driver
 
 try:
-    _dist: pkg_resources.Distribution = pkg_resources.get_distribution("nonebot2")
+    __version__ = version("nonebot2")
-    __version__ = _dist.version
+except Exception:  # pragma: no cover
-    VERSION = _dist.parsed_version
-except pkg_resources.DistributionNotFound:  # pragma: no cover
     __version__ = None
-    VERSION = None
+
+A = TypeVar("A", bound=Adapter)
 
 _driver: Optional[Driver] = None
 
@@ -68,7 +74,8 @@ def get_driver() -> Driver:
         全局 {ref}`nonebot.drivers.Driver` 对象
 
     异常:
-        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化 ({ref}`nonebot.init <nonebot.init>` 尚未调用)
+        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化
+            ({ref}`nonebot.init <nonebot.init>` 尚未调用)
 
     用法:
         ```python
@@ -80,15 +87,77 @@ def get_driver() -> Driver:
     return _driver
 
 
+@overload
+def get_adapter(name: str) -> Adapter:
+    """
+    参数:
+        name: 适配器名称
+
+    返回:
+        指定名称的 {ref}`nonebot.adapters.Adapter` 对象
+    """
+
+
+@overload
+def get_adapter(name: Type[A]) -> A:
+    """
+    参数:
+        name: 适配器类型
+
+    返回:
+        指定类型的 {ref}`nonebot.adapters.Adapter` 对象
+    """
+
+
+def get_adapter(name: Union[str, Type[Adapter]]) -> Adapter:
+    """获取已注册的 {ref}`nonebot.adapters.Adapter` 实例。
+
+    异常:
+        ValueError: 指定的 {ref}`nonebot.adapters.Adapter` 未注册
+        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化
+            ({ref}`nonebot.init <nonebot.init>` 尚未调用)
+
+    用法:
+        ```python
+        from nonebot.adapters.console import Adapter
+        adapter = nonebot.get_adapter(Adapter)
+        ```
+    """
+    adapters = get_adapters()
+    target = name if isinstance(name, str) else name.get_name()
+    if target not in adapters:
+        raise ValueError(f"Adapter {target} not registered.")
+    return adapters[target]
+
+
+def get_adapters() -> Dict[str, Adapter]:
+    """获取所有已注册的 {ref}`nonebot.adapters.Adapter` 实例。
+
+    返回:
+        所有 {ref}`nonebot.adapters.Adapter` 实例字典
+
+    异常:
+        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化
+            ({ref}`nonebot.init <nonebot.init>` 尚未调用)
+
+    用法:
+        ```python
+        adapters = nonebot.get_adapters()
+        ```
+    """
+    return get_driver()._adapters.copy()
+
+
 def get_app() -> Any:
-    """获取全局 {ref}`nonebot.drivers.ReverseDriver` 对应的 Server App 对象。
+    """获取全局 {ref}`nonebot.drivers.ASGIMixin` 对应的 Server App 对象。
 
     返回:
         Server App 对象
 
     异常:
-        AssertionError: 全局 Driver 对象不是 {ref}`nonebot.drivers.ReverseDriver` 类型
+        AssertionError: 全局 Driver 对象不是 {ref}`nonebot.drivers.ASGIMixin` 类型
-        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化 ({ref}`nonebot.init <nonebot.init>` 尚未调用)
+        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化
+            ({ref}`nonebot.init <nonebot.init>` 尚未调用)
 
     用法:
         ```python
@@ -96,21 +165,21 @@ def get_app() -> Any:
         ```
     """
     driver = get_driver()
-    assert isinstance(
+    assert isinstance(driver, ASGIMixin), "app object is only available for asgi driver"
-        driver, ReverseDriver
-    ), "app object is only available for reverse driver"
     return driver.server_app
 
 
 def get_asgi() -> Any:
-    """获取全局 {ref}`nonebot.drivers.ReverseDriver` 对应 [ASGI](https://asgi.readthedocs.io/) 对象。
+    """获取全局 {ref}`nonebot.drivers.ASGIMixin` 对应
+    [ASGI](https://asgi.readthedocs.io/) 对象。
 
     返回:
         ASGI 对象
 
     异常:
-        AssertionError: 全局 Driver 对象不是 {ref}`nonebot.drivers.ReverseDriver` 类型
+        AssertionError: 全局 Driver 对象不是 {ref}`nonebot.drivers.ASGIMixin` 类型
-        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化 ({ref}`nonebot.init <nonebot.init>` 尚未调用)
+        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化
+            ({ref}`nonebot.init <nonebot.init>` 尚未调用)
 
     用法:
         ```python
@@ -119,7 +188,7 @@ def get_asgi() -> Any:
     """
     driver = get_driver()
     assert isinstance(
-        driver, ReverseDriver
+        driver, ASGIMixin
     ), "asgi object is only available for reverse driver"
     return driver.asgi
 
@@ -131,7 +200,8 @@ def get_bot(self_id: Optional[str] = None) -> Bot:
     当不提供时，返回一个 {ref}`nonebot.adapters.Bot`。
 
     参数:
-        self_id: 用来识别 {ref}`nonebot.adapters.Bot` 的 {ref}`nonebot.adapters.Bot.self_id` 属性
+        self_id: 用来识别 {ref}`nonebot.adapters.Bot` 的
+            {ref}`nonebot.adapters.Bot.self_id` 属性
 
     返回:
         {ref}`nonebot.adapters.Bot` 对象
@@ -139,7 +209,8 @@ def get_bot(self_id: Optional[str] = None) -> Bot:
     异常:
         KeyError: 对应 self_id 的 Bot 不存在
         ValueError: 没有传入 self_id 且没有 Bot 可用
-        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化 ({ref}`nonebot.init <nonebot.init>` 尚未调用)
+        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化
+            ({ref}`nonebot.init <nonebot.init>` 尚未调用)
 
     用法:
         ```python
@@ -162,52 +233,47 @@ def get_bots() -> Dict[str, Bot]:
     """获取所有连接到 NoneBot 的 {ref}`nonebot.adapters.Bot` 对象。
 
     返回:
-        一个以 {ref}`nonebot.adapters.Bot.self_id` 为键，{ref}`nonebot.adapters.Bot` 对象为值的字典
+        一个以 {ref}`nonebot.adapters.Bot.self_id` 为键
+        {ref}`nonebot.adapters.Bot` 对象为值的字典
 
     异常:
-        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化 ({ref}`nonebot.init <nonebot.init>` 尚未调用)
+        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化
+            ({ref}`nonebot.init <nonebot.init>` 尚未调用)
 
     用法:
         ```python
         bots = nonebot.get_bots()
         ```
     """
-    driver = get_driver()
+    return get_driver().bots
-    return driver.bots
-
-
-def _resolve_dot_notation(
-    obj_str: str, default_attr: str, default_prefix: Optional[str] = None
-) -> Any:
-    modulename, _, cls = obj_str.partition(":")
-    if default_prefix is not None and modulename.startswith("~"):
-        modulename = default_prefix + modulename[1:]
-    module = importlib.import_module(modulename)
-    if not cls:
-        return getattr(module, default_attr)
-    instance = module
-    for attr_str in cls.split("."):
-        instance = getattr(instance, attr_str)
-    return instance
 
 
 def _resolve_combine_expr(obj_str: str) -> Type[Driver]:
     drivers = obj_str.split("+")
-    DriverClass = _resolve_dot_notation(
+    DriverClass = resolve_dot_notation(
         drivers[0], "Driver", default_prefix="nonebot.drivers."
     )
     if len(drivers) == 1:
         logger.trace(f"Detected driver {DriverClass} with no mixins.")
         return DriverClass
     mixins = [
-        _resolve_dot_notation(mixin, "Mixin", default_prefix="nonebot.drivers.")
+        resolve_dot_notation(mixin, "Mixin", default_prefix="nonebot.drivers.")
         for mixin in drivers[1:]
     ]
     logger.trace(f"Detected driver {DriverClass} with mixins {mixins}.")
     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 文件配置。
@@ -227,13 +293,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", _env_file)
-            _env_file=_env_file or f".env.{env.environment}",
+            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>"
         )
@@ -241,7 +311,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)
 
 
@@ -262,7 +332,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

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
@@ -34,6 +19,11 @@ __autodoc__ = {
     "Event": True,
     "Adapter": True,
     "Message": True,
+    "Message.__getitem__": True,
+    "Message.__contains__": True,
+    "Message._construct": True,
     "MessageSegment": True,
+    "MessageSegment.__str__": True,
+    "MessageSegment.__add__": True,
     "MessageTemplate": True,
 }

nonebot/config.py

@@ -1,98 +1,113 @@
 """本模块定义了 NoneBot 本身运行所需的配置项。
 
-NoneBot 使用 [`pydantic`](https://pydantic-docs.helpmanual.io/) 以及 [`python-dotenv`](https://saurabh-kumar.com/python-dotenv/) 来读取配置。
+NoneBot 使用 [`pydantic`](https://pydantic-docs.helpmanual.io/) 以及
+[`python-dotenv`](https://saurabh-kumar.com/python-dotenv/) 来读取配置。
 
-配置项需符合特殊格式或 json 序列化格式。详情见 [`pydantic Field Type`](https://pydantic-docs.helpmanual.io/usage/types/) 文档。
+配置项需符合特殊格式或 json 序列化格式
+详情见 [`pydantic Field Type`](https://pydantic-docs.helpmanual.io/usage/types/) 文档。
 
 FrontMatter:
     sidebar_position: 1
     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.fields import Undefined, UndefinedType
+from pydantic import Extra, Field, 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):
     def __call__(self, settings: BaseSettings) -> Dict[str, Any]:
-        """
+        """从环境变量和 dotenv 配置文件中读取配置项。"""
-        Build environment variables suitable for passing to the Model.
+
-        """
+        d: Dict[str, Any] = {}
-        d: Dict[str, Optional[str]] = {}
 
         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_vars = self._read_env_files(settings.__config__.case_sensitive)
-        env_file = (
+        env_vars = {**env_file_vars, **env_vars}
-            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}
 
         for field in settings.__fields__.values():
-            env_val: Optional[str] = None
+            env_val: Union[str, None, UndefinedType] = Undefined
             for env_name in field.field_info.extra["env_names"]:
-                env_val = env_vars.get(env_name)
+                env_val = env_vars.get(env_name, Undefined)
                 if env_name in env_file_vars:
                     del env_file_vars[env_name]
-                if env_val is not None:
+                if env_val is not Undefined:
                     break
 
-            if env_val is None:
+            is_complex, allow_parse_failure = self.field_is_complex(field)
-                continue
+            if is_complex:
+                if isinstance(env_val, UndefinedType):
+                    # field is complex but no value found so far, try explode_env_vars
+                    if env_val_built := self.explode_env_vars(field, env_vars):
+                        d[field.alias] = env_val_built
+                elif env_val is None:
+                    d[field.alias] = env_val
+                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():
+                    if isinstance(env_val, dict):
-                try:
+                        d[field.alias] = deep_update(
-                    env_val = settings.__config__.json_loads(env_val)
+                            env_val, self.explode_env_vars(field, env_vars)
-                except ValueError as e:  # pragma: no cover
+                        )
-                    raise SettingsError(
+                    else:
-                        f'error parsing JSON for "{env_name}"'  # type: ignore
+                        d[field.alias] = env_val
-                    ) from e
+            elif not isinstance(env_val, UndefinedType):
-            d[field.alias] = env_val
+                # 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:
+        # remain user custom config
-            for env_name in env_file_vars.keys():
+        for env_name in env_file_vars:
-                env_val = env_vars[env_name]
+            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__.parse_env_var(env_name, val_striped)
-                        env_val = settings.__config__.json_loads(env_val.strip())
+                except ValueError:
-                except ValueError as e:
+                    logger.trace(
-                    logger.opt(colors=True, exception=e).trace(
+                        "Error while parsing JSON for "
-                        f"Error while parsing JSON for {escape_tag(env_name)}. Assumed as string."
+                        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
@@ -105,6 +120,9 @@ class BaseConfig(BaseSettings):
             return self.__dict__.get(name)
 
     class Config:
+        extra = Extra.allow
+        env_nested_delimiter = "__"
+
         @classmethod
         def customise_sources(
             cls,
@@ -116,7 +134,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,
@@ -126,7 +147,7 @@ class BaseConfig(BaseSettings):
 class Env(BaseConfig):
     """运行环境配置。大小写不敏感。
 
-    将会从 `环境变量` > `.env 环境配置文件` 的优先级读取环境信息。
+    将会从 **环境变量** > **dotenv 配置文件** 的优先级读取环境信息。
     """
 
     environment: str = "prod"
@@ -136,7 +157,6 @@ class Env(BaseConfig):
     """
 
     class Config:
-        extra = "allow"
         env_file = ".env"
 
 
@@ -146,11 +166,10 @@ class Config(BaseConfig):
     除了 NoneBot 的配置项外，还可以自行添加配置项到 `.env.{environment}` 文件中。
     这些配置将会在 json 反序列化后一起带入 `Config` 类中。
 
-    配置方法参考: [配置](https://v2.nonebot.dev/docs/tutorial/configuration)
+    配置方法参考: [配置](https://nonebot.dev/docs/appendices/config)
     """
 
-    _env_file: str = ".env"
+    _env_file: DotenvType = ".env", ".env.prod"
-    _common_config: Dict[str, Any] = {}
 
     # nonebot configs
     driver: str = "~fastapi"
@@ -159,15 +178,17 @@ class Config(BaseConfig):
     配置格式为 `<module>[:<Driver>][+<module>[:<Mixin>]]*`。
 
     `~` 为 `nonebot.drivers.` 的缩写。
+
+    配置方法参考: [配置驱动器](https://nonebot.dev/docs/advanced/driver#%E9%85%8D%E7%BD%AE%E9%A9%B1%E5%8A%A8%E5%99%A8)
     """
     host: IPvAnyAddress = IPv4Address("127.0.0.1")  # type: ignore
     """NoneBot {ref}`nonebot.drivers.ReverseDriver` 服务端监听的 IP/主机名。"""
-    port: int = 8080
+    port: int = Field(default=8080, ge=1, le=65535)
     """NoneBot {ref}`nonebot.drivers.ReverseDriver` 服务端监听的端口。"""
     log_level: Union[int, str] = "INFO"
-    """NoneBot 日志输出等级，可以为 `int` 类型等级或等级名称
+    """NoneBot 日志输出等级，可以为 `int` 类型等级或等级名称。
 
-    参考 [`loguru 日志等级`](https://loguru.readthedocs.io/en/stable/api/logger.html#levels)。
+    参考 [记录日志](https://nonebot.dev/docs/appendices/log)，[loguru 日志等级](https://loguru.readthedocs.io/en/stable/api/logger.html#levels)。
 
     :::tip 提示
     日志等级名称应为大写，如 `INFO`。
@@ -198,6 +219,8 @@ class Config(BaseConfig):
     command_start: Set[str] = {"/"}
     """命令的起始标记，用于判断一条消息是不是命令。
 
+    参考[命令响应规则](https://nonebot.dev/docs/advanced/matcher#command)。
+
     用法:
         ```conf
         COMMAND_START=["/", ""]
@@ -206,6 +229,8 @@ class Config(BaseConfig):
     command_sep: Set[str] = {"."}
     """命令的分隔标记，用于将文本形式的命令切分为元组（实际的命令名）。
 
+    参考[命令响应规则](https://nonebot.dev/docs/advanced/matcher#command)。
+
     用法:
         ```conf
         COMMAND_SEP=["."]
@@ -230,8 +255,7 @@ class Config(BaseConfig):
     # or from env file using json loads
 
     class Config:
-        extra = "allow"
+        env_file = ".env", ".env.prod"
-        env_file = ".env.prod"
 
 
 __autodoc__ = {

nonebot/consts.py

@@ -4,7 +4,10 @@ FrontMatter:
     sidebar_position: 9
     description: nonebot.consts 模块
 """
-from typing_extensions import Literal
+
+import os
+import sys
+from typing import Literal
 
 # used by Matcher
 RECEIVE_KEY: Literal["_receive_{id}"] = "_receive_{id}"
@@ -30,6 +33,8 @@ CMD_ARG_KEY: Literal["command_arg"] = "command_arg"
 """命令参数存储 key"""
 CMD_START_KEY: Literal["command_start"] = "command_start"
 """命令开头存储 key"""
+CMD_WHITESPACE_KEY: Literal["command_whitespace"] = "command_whitespace"
+"""命令与参数间空白符存储 key"""
 
 SHELL_ARGS: Literal["_args"] = "_args"
 """shell 命令 parse 后参数字典存储 key"""
@@ -38,7 +43,13 @@ SHELL_ARGV: Literal["_argv"] = "_argv"
 
 REGEX_MATCHED: Literal["_matched"] = "_matched"
 """正则匹配结果存储 key"""
-REGEX_GROUP: Literal["_matched_groups"] = "_matched_groups"
+STARTSWITH_KEY: Literal["_startswith"] = "_startswith"
-"""正则匹配 group 元组存储 key"""
+"""响应触发前缀 key"""
-REGEX_DICT: Literal["_matched_dict"] = "_matched_dict"
+ENDSWITH_KEY: Literal["_endswith"] = "_endswith"
-"""正则匹配 group 字典存储 key"""
+"""响应触发后缀 key"""
+FULLMATCH_KEY: Literal["_fullmatch"] = "_fullmatch"
+"""响应触发完整消息 key"""
+KEYWORD_KEY: Literal["_keyword"] = "_keyword"
+"""响应触发关键字 key"""
+
+WINDOWS = sys.platform.startswith("win") or (sys.platform == "cli" and os.name == "nt")

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
@@ -29,27 +45,35 @@ class Param(abc.ABC, FieldInfo):
     继承自 `pydantic.fields.FieldInfo`，用于描述参数信息（不包括参数名）。
     """
 
+    def __init__(self, *args, validate: bool = False, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.validate = validate
+
     @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 +85,75 @@ class Dependent(Generic[R]):
         allow_types: 允许的参数类型
     """
 
-    def __init__(
+    call: _DependentCallable[R]
-        self,
+    params: Tuple[ModelField, ...] = field(default_factory=tuple)
-        *,
+    parameterless: Tuple[Param, ...] = field(default_factory=tuple)
-        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 []
 
     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"Dependent(call={call_str}"
-            f" parameterless={self.parameterless}>"
+            + (f", parameterless={self.parameterless}" if self.parameterless else "")
+            + ")"
         )
 
-    def __str__(self) -> str:
-        return self.__repr__()
-
     async def __call__(self, **kwargs: Any) -> R:
-        values = await self.solve(**kwargs)
+        try:
+            # do pre-check
+            await self.check(**kwargs)
 
-        if is_coroutine_callable(self.call):
+            # solve param values
-            return await self.call(**values)
+            values = await self.solve(**kwargs)
-        else:
-            return await run_sync(self.call)(**values)
 
-    def parse_param(self, name: str, param: inspect.Parameter) -> Param:
+            # call function
-        for allow_type in self.allow_types:
+            if is_coroutine_callable(self.call):
-            field_info = allow_type._check_param(self, name, param)
+                return await cast(Callable[..., Awaitable[R]], self.call)(**values)
-            if field_info:
+            else:
-                return field_info
+                return await run_sync(cast(Callable[..., R], self.call))(**values)
-        else:
+        except SkippedException as e:
-            raise ValueError(
+            logger.trace(f"{self} skipped due to {e}")
-                f"Unknown parameter {name} for function {self.call} with type {param.annotation}"
+            raise
-            )
 
-    def parse_parameterless(self, value: Any) -> Param:
+    @staticmethod
-        for allow_type in self.allow_types:
+    def parse_params(
-            field_info = allow_type._check_parameterless(self, value)
+        call: _DependentCallable[R], allow_types: Tuple[Type[Param], ...]
-            if field_info:
+    ) -> Tuple[ModelField, ...]:
-                return field_info
+        fields: List[ModelField] = []
-        else:
+        params = get_typed_signature(call).parameters.values()
-            raise ValueError(
-                f"Unknown parameterless {value} for function {self.call} with type {type(value)}"
-            )
 
-    def prepend_parameterless(self, value: Any) -> None:
+        for param in params:
-        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():
             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)
+                for allow_type in allow_types:
-                default_value = field_info.default
+                    if field_info := allow_type._check_param(param, allow_types):
+                        break
+                else:
+                    raise ValueError(
+                        f"Unknown parameter {param.name} "
+                        f"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 +163,65 @@ class Dependent(Generic[R]):
                 )
             )
 
-        parameterless_params = [
+        return tuple(fields)
-            dependent.parse_parameterless(param) for param in (parameterless or [])
-        ]
-        dependent.parameterless.extend(parameterless_params)
 
-        logger.trace(
+    @staticmethod
-            f"Parsed dependent with call={call}, "
+    def parse_parameterless(
-            f"params={[param.field_info for param in dependent.params]}, "
+        parameterless: Tuple[Any, ...], allow_types: Tuple[Type[Param], ...]
-            f"parameterless={dependent.parameterless}"
+    ) -> 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 = (
+            ()
+            if parameterless is None
+            else cls.parse_parameterless(tuple(parameterless), allow_types)
         )
 
-        return dependent
+        return cls(call, params, parameterless_params)
 
-    async def solve(
+    async def check(self, **params: Any) -> None:
-        self,
+        await asyncio.gather(*(param._check(**params) for param in self.parameterless))
-        **params: Any,
+        await asyncio.gather(
-    ) -> Dict[str, Any]:
+            *(cast(Param, param.field_info)._check(**params) for param in self.params)
-        values: Dict[str, Any] = {}
+        )
 
-        for checker in self.pre_checkers:
+    async def _solve_field(self, field: ModelField, params: Dict[str, Any]) -> Any:
-            await checker._solve(**params)
+        param = cast(Param, field.field_info)
+        value = await param._solve(**params)
+        if value is Undefined:
+            value = field.get_default()
+        v = check_field_type(field, value)
+        return v if param.validate else 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:
+        # solve param values
-            field_info = field.field_info
+        values = await asyncio.gather(
-            assert isinstance(field_info, Param), "Params must be subclasses of Param"
+            *(self._solve_field(field, params) for field in self.params)
-            value = await field_info._solve(**params)
+        )
-            if value is Undefined:
+        return {field.name: value for field, value in zip(self.params, values)}
-                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
 
 
 __autodoc__ = {"CustomConfig": False}

nonebot/dependencies/utils.py

@@ -3,20 +3,20 @@ FrontMatter:
     sidebar_position: 1
     description: nonebot.dependencies.utils 模块
 """
+
 import inspect
-from typing import Any, Dict, TypeVar, Callable
+from typing import Any, Dict, 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
 
-V = TypeVar("V")
-
 
 def get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
     """获取可调用对象签名"""
+
     signature = inspect.signature(call)
     globalns = getattr(call, "__globals__", {})
     typed_params = [
@@ -28,12 +28,12 @@ def get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
         )
         for param in signature.parameters.values()
     ]
-    typed_signature = inspect.Signature(typed_params)
+    return inspect.Signature(typed_params)
-    return typed_signature
 
 
 def get_typed_annotation(param: inspect.Parameter, globalns: Dict[str, Any]) -> Any:
     """获取参数的类型注解"""
+
     annotation = param.annotation
     if isinstance(annotation, str):
         annotation = ForwardRef(annotation)
@@ -47,8 +47,10 @@ def get_typed_annotation(param: inspect.Parameter, globalns: Dict[str, Any]) ->
     return annotation
 
 
-def check_field_type(field: ModelField, value: V) -> V:
+def check_field_type(field: ModelField, value: Any) -> Any:
-    _, errs_ = field.validate(value, {}, loc=())
+    """检查字段类型是否匹配"""
+
+    v, errs_ = field.validate(value, {}, loc=())
     if errs_:
         raise TypeMisMatch(field, value)
-    return value
+    return v

nonebot/drivers/__init__.py

@@ -8,30 +8,40 @@ FrontMatter:
 """
 
 from nonebot.internal.driver import URL as URL
+from nonebot.internal.driver import Mixin as Mixin
 from nonebot.internal.driver import Driver as Driver
 from nonebot.internal.driver import Cookies as Cookies
 from nonebot.internal.driver import Request as Request
 from nonebot.internal.driver import Response as Response
+from nonebot.internal.driver import ASGIMixin as ASGIMixin
 from nonebot.internal.driver import WebSocket as WebSocket
 from nonebot.internal.driver import HTTPVersion as HTTPVersion
 from nonebot.internal.driver import ForwardMixin as ForwardMixin
+from nonebot.internal.driver import ReverseMixin as ReverseMixin
 from nonebot.internal.driver import ForwardDriver as ForwardDriver
 from nonebot.internal.driver import ReverseDriver as ReverseDriver
 from nonebot.internal.driver import combine_driver as combine_driver
+from nonebot.internal.driver import HTTPClientMixin as HTTPClientMixin
 from nonebot.internal.driver import HTTPServerSetup as HTTPServerSetup
+from nonebot.internal.driver import WebSocketClientMixin as WebSocketClientMixin
 from nonebot.internal.driver import WebSocketServerSetup as WebSocketServerSetup
 
 __autodoc__ = {
     "URL": True,
-    "Driver": True,
     "Cookies": True,
     "Request": True,
     "Response": True,
     "WebSocket": True,
     "HTTPVersion": True,
+    "Driver": True,
+    "Mixin": True,
     "ForwardMixin": True,
     "ForwardDriver": True,
+    "HTTPClientMixin": True,
+    "WebSocketClientMixin": True,
+    "ReverseMixin": True,
     "ReverseDriver": True,
+    "ASGIMixin": True,
     "combine_driver": True,
     "HTTPServerSetup": True,
     "WebSocketServerSetup": True,

nonebot/drivers/_block_driver.py

@@ -1,142 +0,0 @@
-import signal
-import asyncio
-import threading
-from typing import Set, Callable, Awaitable
-
-from nonebot.log import logger
-from nonebot.drivers import Driver
-from nonebot.typing import overrides
-from nonebot.config import Env, Config
-
-STARTUP_FUNC = Callable[[], Awaitable[None]]
-SHUTDOWN_FUNC = 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):
-    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.should_exit: asyncio.Event = asyncio.Event()
-        self.force_exit: bool = False
-
-    @property
-    @overrides(Driver)
-    def type(self) -> str:
-        """驱动名称: `block_driver`"""
-        return "block_driver"
-
-    @property
-    @overrides(Driver)
-    def logger(self):
-        """block driver 使用的 logger"""
-        return logger
-
-    @overrides(Driver)
-    def on_startup(self, func: STARTUP_FUNC) -> STARTUP_FUNC:
-        """
-        注册一个启动时执行的函数
-        """
-        self.startup_funcs.add(func)
-        return func
-
-    @overrides(Driver)
-    def on_shutdown(self, func: SHUTDOWN_FUNC) -> SHUTDOWN_FUNC:
-        """
-        注册一个停止时执行的函数
-        """
-        self.shutdown_funcs.add(func)
-        return func
-
-    @overrides(Driver)
-    def run(self, *args, **kwargs):
-        """启动 block driver"""
-        super().run(*args, **kwargs)
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(self.serve())
-
-    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()
-
-    async def startup(self):
-        # run startup
-        cors = [startup() for startup in self.startup_funcs]
-        if cors:
-            try:
-                await asyncio.gather(*cors)
-            except Exception as e:
-                logger.opt(colors=True, exception=e).error(
-                    "<r><bg #f8bbd0>Error when running startup function. "
-                    "Ignored!</bg #f8bbd0></r>"
-                )
-
-        logger.info("Application startup completed.")
-
-    async def main_loop(self):
-        await self.should_exit.wait()
-
-    async def shutdown(self):
-        logger.info("Shutting down")
-
-        logger.info("Waiting for application shutdown.")
-        # run shutdown
-        cors = [shutdown() for shutdown in self.shutdown_funcs]
-        if cors:
-            try:
-                await asyncio.gather(*cors)
-            except Exception as e:
-                logger.opt(colors=True, exception=e).error(
-                    "<r><bg #f8bbd0>Error when running shutdown function. "
-                    "Ignored!</bg #f8bbd0></r>"
-                )
-
-        for task in asyncio.all_tasks():
-            if task is not asyncio.current_task() and not task.done():
-                task.cancel()
-        await asyncio.sleep(0.1)
-
-        tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
-        if tasks and not self.force_exit:
-            logger.info("Waiting for tasks to finish. (CTRL+C to force quit)")
-        while tasks and not self.force_exit:
-            await asyncio.sleep(0.1)
-            tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
-
-        for task in tasks:
-            task.cancel()
-
-        await asyncio.gather(*tasks, return_exceptions=True)
-
-        logger.info("Application shutdown complete.")
-        loop = asyncio.get_event_loop()
-        loop.stop()
-
-    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
-
-        loop = asyncio.get_event_loop()
-
-        try:
-            for sig in HANDLED_SIGNALS:
-                loop.add_signal_handler(sig, self.handle_exit, sig, None)
-        except NotImplementedError:
-            # Windows
-            for sig in HANDLED_SIGNALS:
-                signal.signal(sig, self.handle_exit)
-
-    def handle_exit(self, sig, frame):
-        if self.should_exit.is_set():
-            self.force_exit = True
-        else:
-            self.should_exit.set()

nonebot/drivers/_lifespan.py

@@ -0,0 +1,46 @@
+from typing_extensions import TypeAlias
+from typing import Any, List, Union, Callable, Awaitable, cast
+
+from nonebot.utils import run_sync, is_coroutine_callable
+
+SYNC_LIFESPAN_FUNC: TypeAlias = Callable[[], Any]
+ASYNC_LIFESPAN_FUNC: TypeAlias = Callable[[], Awaitable[Any]]
+LIFESPAN_FUNC: TypeAlias = Union[SYNC_LIFESPAN_FUNC, ASYNC_LIFESPAN_FUNC]
+
+
+class Lifespan:
+    def __init__(self) -> None:
+        self._startup_funcs: List[LIFESPAN_FUNC] = []
+        self._shutdown_funcs: List[LIFESPAN_FUNC] = []
+
+    def on_startup(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
+        self._startup_funcs.append(func)
+        return func
+
+    def on_shutdown(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
+        self._shutdown_funcs.append(func)
+        return func
+
+    @staticmethod
+    async def _run_lifespan_func(
+        funcs: List[LIFESPAN_FUNC],
+    ) -> None:
+        for func in funcs:
+            if is_coroutine_callable(func):
+                await cast(ASYNC_LIFESPAN_FUNC, func)()
+            else:
+                await run_sync(cast(SYNC_LIFESPAN_FUNC, func))()
+
+    async def startup(self) -> None:
+        if self._startup_funcs:
+            await self._run_lifespan_func(self._startup_funcs)
+
+    async def shutdown(self) -> None:
+        if self._shutdown_funcs:
+            await self._run_lifespan_func(self._shutdown_funcs)
+
+    async def __aenter__(self) -> None:
+        await self.startup()
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        await self.shutdown()

nonebot/drivers/aiohttp.py

@@ -15,33 +15,39 @@ FrontMatter:
     description: nonebot.drivers.aiohttp 模块
 """
 
-from typing import Type, AsyncGenerator
+from typing_extensions import override
 from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, AsyncGenerator
 
-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
+from nonebot.drivers import (
+    HTTPVersion,
+    HTTPClientMixin,
+    WebSocketClientMixin,
+    combine_driver,
+)
 
 try:
     import aiohttp
-except ImportError:
+except ModuleNotFoundError as e:  # pragma: no cover
     raise ImportError(
-        "Please install aiohttp first to use this driver. `pip install nonebot2[aiohttp]`"
+        "Please install aiohttp first to use this driver. "
-    ) from None
+        "Install with pip: `pip install nonebot2[aiohttp]`"
+    ) from e
 
 
-class Mixin(ForwardMixin):
+class Mixin(HTTPClientMixin, WebSocketClientMixin):
     """AIOHTTP Mixin"""
 
     @property
-    @overrides(ForwardMixin)
+    @override
     def type(self) -> str:
         return "aiohttp"
 
-    @overrides(ForwardMixin)
+    @override
     async def request(self, setup: Request) -> Response:
         if setup.version == HTTPVersion.H10:
             version = aiohttp.HttpVersion10
@@ -51,30 +57,36 @@ class Mixin(ForwardMixin):
             raise RuntimeError(f"Unsupported HTTP version: {setup.version}")
 
         timeout = aiohttp.ClientTimeout(setup.timeout)
-        files = None
+
+        data = setup.data
         if setup.files:
-            files = aiohttp.FormData()
+            data = aiohttp.FormData(data or {})
             for name, file in setup.files:
-                files.add_field(name, file[1], content_type=file[2], filename=file[0])
+                data.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,
-                data=setup.content or setup.data or files,
+                data=setup.content or data,
                 json=setup.json,
                 headers=setup.headers,
                 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)
+    @override
     @asynccontextmanager
     async def websocket(self, setup: Request) -> AsyncGenerator["WebSocket", None]:
         if setup.version == HTTPVersion.H10:
@@ -92,8 +104,7 @@ class Mixin(ForwardMixin):
                 headers=setup.headers,
                 proxy=setup.proxy,
             ) as ws:
-                websocket = WebSocket(request=setup, session=session, websocket=ws)
+                yield WebSocket(request=setup, session=session, websocket=ws)
-                yield websocket
 
 
 class WebSocket(BaseWebSocket):
@@ -111,15 +122,15 @@ class WebSocket(BaseWebSocket):
         self.websocket = websocket
 
     @property
-    @overrides(BaseWebSocket)
+    @override
     def closed(self):
         return self.websocket.closed
 
-    @overrides(BaseWebSocket)
+    @override
     async def accept(self):
         raise NotImplementedError
 
-    @overrides(BaseWebSocket)
+    @override
     async def close(self, code: int = 1000):
         await self.websocket.close(code=code)
         await self.session.close()
@@ -130,7 +141,7 @@ class WebSocket(BaseWebSocket):
             raise WebSocketClosed(self.websocket.close_code or 1006)
         return msg
 
-    @overrides(BaseWebSocket)
+    @override
     async def receive(self) -> str:
         msg = await self._receive()
         if msg.type not in (aiohttp.WSMsgType.TEXT, aiohttp.WSMsgType.BINARY):
@@ -139,7 +150,7 @@ class WebSocket(BaseWebSocket):
             )
         return msg.data
 
-    @overrides(BaseWebSocket)
+    @override
     async def receive_text(self) -> str:
         msg = await self._receive()
         if msg.type != aiohttp.WSMsgType.TEXT:
@@ -148,7 +159,7 @@ class WebSocket(BaseWebSocket):
             )
         return msg.data
 
-    @overrides(BaseWebSocket)
+    @override
     async def receive_bytes(self) -> bytes:
         msg = await self._receive()
         if msg.type != aiohttp.WSMsgType.BINARY:
@@ -157,14 +168,20 @@ class WebSocket(BaseWebSocket):
             )
         return msg.data
 
-    @overrides(BaseWebSocket)
+    @override
     async def send_text(self, data: str) -> None:
         await self.websocket.send_str(data)
 
-    @overrides(BaseWebSocket)
+    @override
     async def send_bytes(self, data: bytes) -> None:
         await self.websocket.send_bytes(data)
 
 
-Driver: Type[ForwardDriver] = combine_driver(BlockDriver, Mixin)  # type: ignore
+if TYPE_CHECKING:
-"""AIOHTTP Driver"""
+
+    class Driver(Mixin, NoneDriver):
+        ...
+
+else:
+    Driver = combine_driver(NoneDriver, Mixin)
+    """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,24 +15,37 @@ 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_extensions import override
+from typing import Any, Dict, List, Tuple, Union, 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
+from nonebot.drivers import ASGIMixin
 from nonebot.exception import WebSocketClosed
 from nonebot.internal.driver import FileTypes
+from nonebot.drivers import Driver as BaseDriver
 from nonebot.config import Config as NoneBotConfig
 from nonebot.drivers import Request as BaseRequest
 from nonebot.drivers import WebSocket as BaseWebSocket
-from nonebot.drivers import ReverseDriver, HTTPServerSetup, WebSocketServerSetup
+from nonebot.drivers import HTTPServerSetup, WebSocketServerSetup
+
+from ._lifespan import LIFESPAN_FUNC, Lifespan
+
+try:
+    import uvicorn
+    from fastapi.responses import Response
+    from fastapi import FastAPI, Request, UploadFile, status
+    from starlette.websockets import WebSocket, WebSocketState, WebSocketDisconnect
+except ModuleNotFoundError as e:  # pragma: no cover
+    raise ImportError(
+        "Please install FastAPI first to use this driver. "
+        "Install with pip: `pip install nonebot2[fastapi]`"
+    ) from e
 
 
 def catch_closed(func):
@@ -57,56 +76,62 @@ 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"
 
 
-class Driver(ReverseDriver):
+class Driver(BaseDriver, ASGIMixin):
     """FastAPI 驱动框架。"""
 
     def __init__(self, env: Env, config: NoneBotConfig):
-        super(Driver, self).__init__(env, config)
+        super().__init__(env, config)
 
         self.fastapi_config: Config = Config(**config.dict())
 
+        self._lifespan = Lifespan()
+
         self._server_app = FastAPI(
+            lifespan=self._lifespan_manager,
             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
-    @overrides(ReverseDriver)
+    @override
     def type(self) -> str:
         """驱动名称: `fastapi`"""
         return "fastapi"
 
     @property
-    @overrides(ReverseDriver)
+    @override
     def server_app(self) -> FastAPI:
         """`FastAPI APP` 对象"""
         return self._server_app
 
     @property
-    @overrides(ReverseDriver)
+    @override
     def asgi(self) -> FastAPI:
         """`FastAPI APP` 对象"""
         return self._server_app
 
     @property
-    @overrides(ReverseDriver)
+    @override
     def logger(self) -> logging.Logger:
         """fastapi 使用的 logger"""
         return logging.getLogger("fastapi")
 
-    @overrides(ReverseDriver)
+    @override
     def setup_http_server(self, setup: HTTPServerSetup):
         async def _handle(request: Request) -> Response:
             return await self._handle_http(request, setup)
@@ -119,7 +144,7 @@ class Driver(ReverseDriver):
             include_in_schema=self.fastapi_config.fastapi_include_adapter_schema,
         )
 
-    @overrides(ReverseDriver)
+    @override
     def setup_websocket_server(self, setup: WebSocketServerSetup) -> None:
         async def _handle(websocket: WebSocket) -> None:
             await self._handle_ws(websocket, setup)
@@ -130,17 +155,23 @@ class Driver(ReverseDriver):
             name=setup.name,
         )
 
-    @overrides(ReverseDriver)
+    @override
-    def on_startup(self, func: Callable) -> Callable:
+    def on_startup(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
-        """参考文档: `Events <https://fastapi.tiangolo.com/advanced/events/#startup-event>`_"""
+        return self._lifespan.on_startup(func)
-        return self.server_app.on_event("startup")(func)
 
-    @overrides(ReverseDriver)
+    @override
-    def on_shutdown(self, func: Callable) -> Callable:
+    def on_shutdown(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
-        """参考文档: `Events <https://fastapi.tiangolo.com/advanced/events/#shutdown-event>`_"""
+        return self._lifespan.on_shutdown(func)
-        return self.server_app.on_event("shutdown")(func)
 
-    @overrides(ReverseDriver)
+    @contextlib.asynccontextmanager
+    async def _lifespan_manager(self, app: FastAPI):
+        await self._lifespan.startup()
+        try:
+            yield
+        finally:
+            await self._lifespan.shutdown()
+
+    @override
     def run(
         self,
         host: Optional[str] = None,
@@ -150,7 +181,7 @@ class Driver(ReverseDriver):
         **kwargs,
     ):
         """使用 `uvicorn` 启动 FastAPI"""
-        super().run(host, port, app, **kwargs)
+        super().run(host, port, app=app, **kwargs)
         LOGGING_CONFIG = {
             "version": 1,
             "disable_existing_loggers": False,
@@ -186,14 +217,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 +233,7 @@ class Driver(ReverseDriver):
                     )
                 else:
                     data[key] = value
-        except Exception:
+
-            pass
         http_request = BaseRequest(
             request.method,
             str(request.url),
@@ -219,7 +247,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(
@@ -240,30 +270,30 @@ class Driver(ReverseDriver):
 class FastAPIWebSocket(BaseWebSocket):
     """FastAPI WebSocket Wrapper"""
 
-    @overrides(BaseWebSocket)
+    @override
     def __init__(self, *, request: BaseRequest, websocket: WebSocket):
         super().__init__(request=request)
         self.websocket = websocket
 
     @property
-    @overrides(BaseWebSocket)
+    @override
     def closed(self) -> bool:
         return (
             self.websocket.client_state == WebSocketState.DISCONNECTED
             or self.websocket.application_state == WebSocketState.DISCONNECTED
         )
 
-    @overrides(BaseWebSocket)
+    @override
     async def accept(self) -> None:
         await self.websocket.accept()
 
-    @overrides(BaseWebSocket)
+    @override
     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)
+    @override
     async def receive(self) -> Union[str, bytes]:
         # assert self.websocket.application_state == WebSocketState.CONNECTED
         msg = await self.websocket.receive()
@@ -271,21 +301,21 @@ class FastAPIWebSocket(BaseWebSocket):
             raise WebSocketClosed(msg["code"])
         return msg["text"] if "text" in msg else msg["bytes"]
 
-    @overrides(BaseWebSocket)
+    @override
     @catch_closed
     async def receive_text(self) -> str:
         return await self.websocket.receive_text()
 
-    @overrides(BaseWebSocket)
+    @override
     @catch_closed
     async def receive_bytes(self) -> bytes:
         return await self.websocket.receive_bytes()
 
-    @overrides(BaseWebSocket)
+    @override
     async def send_text(self, data: str) -> None:
         await self.websocket.send({"type": "websocket.send", "text": data})
 
-    @overrides(BaseWebSocket)
+    @override
     async def send_bytes(self, data: bytes) -> None:
         await self.websocket.send({"type": "websocket.send", "bytes": data})
 

nonebot/drivers/httpx.py

@@ -14,51 +14,51 @@ FrontMatter:
     sidebar_position: 3
     description: nonebot.drivers.httpx 模块
 """
-from typing import Type, AsyncGenerator
-from contextlib import asynccontextmanager
 
-from nonebot.typing import overrides
+from typing import TYPE_CHECKING
-from nonebot.drivers._block_driver import BlockDriver
+from typing_extensions import override
+
+from nonebot.drivers.none import Driver as NoneDriver
 from nonebot.drivers import (
     Request,
     Response,
-    WebSocket,
     HTTPVersion,
-    ForwardMixin,
+    HTTPClientMixin,
-    ForwardDriver,
     combine_driver,
 )
 
 try:
     import httpx
-except ImportError:
+except ModuleNotFoundError as e:  # pragma: no cover
     raise ImportError(
-        "Please install httpx by using `pip install nonebot2[httpx]`"
+        "Please install httpx first to use this driver. "
-    ) from None
+        "Install with pip: `pip install nonebot2[httpx]`"
+    ) from e
 
 
-class Mixin(ForwardMixin):
+class Mixin(HTTPClientMixin):
     """HTTPX Mixin"""
 
     @property
-    @overrides(ForwardMixin)
+    @override
     def type(self) -> str:
         return "httpx"
 
-    @overrides(ForwardMixin)
+    @override
     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
+                content=setup.content,
-                data=setup.data,  # type: ignore
+                data=setup.data,
                 json=setup.json,
-                files=setup.files,  # type: ignore
+                files=setup.files,
                 headers=tuple(setup.headers.items()),
                 timeout=setup.timeout,
             )
@@ -69,12 +69,12 @@ class Mixin(ForwardMixin):
                 request=setup,
             )
 
-    @overrides(ForwardMixin)
-    @asynccontextmanager
-    async def websocket(self, setup: Request) -> AsyncGenerator[WebSocket, None]:
-        async with super(Mixin, self).websocket(setup) as ws:
-            yield ws
 
+if TYPE_CHECKING:
 
-Driver: Type[ForwardDriver] = combine_driver(BlockDriver, Mixin)  # type: ignore
+    class Driver(Mixin, NoneDriver):
-"""HTTPX Driver"""
+        ...
+
+else:
+    Driver = combine_driver(NoneDriver, Mixin)
+    """HTTPX Driver"""

nonebot/drivers/none.py

@@ -0,0 +1,155 @@
+"""None 驱动适配
+
+:::tip 提示
+本驱动不支持任何服务器或客户端连接
+:::
+
+FrontMatter:
+    sidebar_position: 6
+    description: nonebot.drivers.none 模块
+"""
+
+import signal
+import asyncio
+import threading
+from typing_extensions import override
+
+from nonebot.log import logger
+from nonebot.consts import WINDOWS
+from nonebot.config import Env, Config
+from nonebot.drivers import Driver as BaseDriver
+
+from ._lifespan import LIFESPAN_FUNC, Lifespan
+
+HANDLED_SIGNALS = (
+    signal.SIGINT,  # Unix signal 2. Sent by Ctrl+C.
+    signal.SIGTERM,  # Unix signal 15. Sent by `kill <pid>`.
+)
+if WINDOWS:  # pragma: py-win32
+    HANDLED_SIGNALS += (signal.SIGBREAK,)  # Windows signal 21. Sent by Ctrl+Break.
+
+
+class Driver(BaseDriver):
+    """None 驱动框架"""
+
+    def __init__(self, env: Env, config: Config):
+        super().__init__(env, config)
+
+        self._lifespan = Lifespan()
+
+        self.should_exit: asyncio.Event = asyncio.Event()
+        self.force_exit: bool = False
+
+    @property
+    @override
+    def type(self) -> str:
+        """驱动名称: `none`"""
+        return "none"
+
+    @property
+    @override
+    def logger(self):
+        """none driver 使用的 logger"""
+        return logger
+
+    @override
+    def on_startup(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
+        """注册一个启动时执行的函数"""
+        return self._lifespan.on_startup(func)
+
+    @override
+    def on_shutdown(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
+        """注册一个停止时执行的函数"""
+        return self._lifespan.on_shutdown(func)
+
+    @override
+    def run(self, *args, **kwargs):
+        """启动 none driver"""
+        super().run(*args, **kwargs)
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(self._serve())
+
+    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()
+
+    async def _startup(self):
+        try:
+            await self._lifespan.startup()
+        except Exception as e:
+            logger.opt(colors=True, exception=e).error(
+                "<r><bg #f8bbd0>Error when running startup function. "
+                "Ignored!</bg #f8bbd0></r>"
+            )
+
+        logger.info("Application startup completed.")
+
+    async def _main_loop(self):
+        await self.should_exit.wait()
+
+    async def _shutdown(self):
+        logger.info("Shutting down")
+
+        logger.info("Waiting for application shutdown.")
+
+        try:
+            await self._lifespan.shutdown()
+        except Exception as e:
+            logger.opt(colors=True, exception=e).error(
+                "<r><bg #f8bbd0>Error when running shutdown function. "
+                "Ignored!</bg #f8bbd0></r>"
+            )
+
+        for task in asyncio.all_tasks():
+            if task is not asyncio.current_task() and not task.done():
+                task.cancel()
+        await asyncio.sleep(0.1)
+
+        tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
+        if tasks and not self.force_exit:
+            logger.info("Waiting for tasks to finish. (CTRL+C to force quit)")
+        while tasks and not self.force_exit:
+            await asyncio.sleep(0.1)
+            tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
+
+        for task in tasks:
+            task.cancel()
+
+        await asyncio.gather(*tasks, return_exceptions=True)
+
+        logger.info("Application shutdown complete.")
+        loop = asyncio.get_event_loop()
+        loop.stop()
+
+    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
+
+        loop = asyncio.get_event_loop()
+
+        try:
+            for sig in HANDLED_SIGNALS:
+                loop.add_signal_handler(sig, self._handle_exit, sig, None)
+        except NotImplementedError:
+            # Windows
+            for sig in HANDLED_SIGNALS:
+                signal.signal(sig, self._handle_exit)
+
+    def _handle_exit(self, sig, frame):
+        self.exit(force=self.should_exit.is_set())
+
+    def exit(self, force: bool = False):
+        """退出 none driver
+
+        参数:
+            force: 强制退出
+        """
+        if not self.should_exit.is_set():
+            self.should_exit.set()
+        if force:
+            self.force_exit = True

nonebot/drivers/quart.py

@@ -17,30 +17,45 @@ FrontMatter:
 
 import asyncio
 from functools import wraps
-from typing import List, Tuple, Union, TypeVar, Callable, Optional, Coroutine
+from typing_extensions import override
+from typing import (
+    Any,
+    Dict,
+    List,
+    Tuple,
+    Union,
+    TypeVar,
+    Callable,
+    Optional,
+    Coroutine,
+    cast,
+)
 
-import uvicorn
 from pydantic import BaseSettings
 
 from nonebot.config import Env
-from nonebot.typing import overrides
+from nonebot.drivers import ASGIMixin
 from nonebot.exception import WebSocketClosed
 from nonebot.internal.driver import FileTypes
+from nonebot.drivers import Driver as BaseDriver
 from nonebot.config import Config as NoneBotConfig
 from nonebot.drivers import Request as BaseRequest
 from nonebot.drivers import WebSocket as BaseWebSocket
-from nonebot.drivers import ReverseDriver, HTTPServerSetup, WebSocketServerSetup
+from nonebot.drivers import HTTPServerSetup, WebSocketServerSetup
 
 try:
+    import uvicorn
     from quart import request as _request
-    from quart import websocket as _websocket
+    from quart.ctx import WebsocketContext
+    from quart.globals import websocket_ctx
     from quart import Quart, Request, Response
     from quart.datastructures import FileStorage
     from quart import Websocket as QuartWebSocket
-except ImportError:
+except ModuleNotFoundError as e:  # pragma: no cover
     raise ImportError(
-        "Please install Quart by using `pip install nonebot2[quart]`"
+        "Please install Quart first to use this driver. "
-    ) from None
+        "Install with pip: `pip install nonebot2[quart]`"
+    ) from e
 
 _AsyncCallable = TypeVar("_AsyncCallable", bound=Callable[..., Coroutine])
 
@@ -63,18 +78,20 @@ 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"
 
 
-class Driver(ReverseDriver):
+class Driver(BaseDriver, ASGIMixin):
     """Quart 驱动框架"""
 
     def __init__(self, env: Env, config: NoneBotConfig):
@@ -82,33 +99,35 @@ 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)
+    @override
     def type(self) -> str:
         """驱动名称: `quart`"""
         return "quart"
 
     @property
-    @overrides(ReverseDriver)
+    @override
     def server_app(self) -> Quart:
         """`Quart` 对象"""
         return self._server_app
 
     @property
-    @overrides(ReverseDriver)
+    @override
     def asgi(self):
         """`Quart` 对象"""
         return self._server_app
 
     @property
-    @overrides(ReverseDriver)
+    @override
     def logger(self):
         """Quart 使用的 logger"""
         return self._server_app.logger
 
-    @overrides(ReverseDriver)
+    @override
     def setup_http_server(self, setup: HTTPServerSetup):
         async def _handle() -> Response:
             return await self._handle_http(setup)
@@ -120,7 +139,7 @@ class Driver(ReverseDriver):
             view_func=_handle,
         )
 
-    @overrides(ReverseDriver)
+    @override
     def setup_websocket_server(self, setup: WebSocketServerSetup) -> None:
         async def _handle() -> None:
             return await self._handle_ws(setup)
@@ -131,17 +150,17 @@ class Driver(ReverseDriver):
             view_func=_handle,
         )
 
-    @overrides(ReverseDriver)
+    @override
     def on_startup(self, func: _AsyncCallable) -> _AsyncCallable:
         """参考文档: [`Startup and Shutdown`](https://pgjones.gitlab.io/quart/how_to_guides/startup_shutdown.html)"""
         return self.server_app.before_serving(func)  # type: ignore
 
-    @overrides(ReverseDriver)
+    @override
     def on_shutdown(self, func: _AsyncCallable) -> _AsyncCallable:
         """参考文档: [`Startup and Shutdown`](https://pgjones.gitlab.io/quart/how_to_guides/startup_shutdown.html)"""
         return self.server_app.after_serving(func)  # type: ignore
 
-    @overrides(ReverseDriver)
+    @override
     def run(
         self,
         host: Optional[str] = None,
@@ -184,9 +203,7 @@ class Driver(ReverseDriver):
     async def _handle_http(self, setup: HTTPServerSetup) -> Response:
         request: Request = _request
 
-        json = None
+        json = await request.get_json() if request.is_json else None
-        if request.is_json:
-            json = await request.get_json()
 
         data = await request.form
         files_dict = await request.files
@@ -219,7 +236,8 @@ class Driver(ReverseDriver):
         )
 
     async def _handle_ws(self, setup: WebSocketServerSetup) -> None:
-        websocket: QuartWebSocket = _websocket
+        ctx = cast(WebsocketContext, websocket_ctx.copy())
+        websocket = websocket_ctx.websocket
 
         http_request = BaseRequest(
             websocket.method,
@@ -229,7 +247,7 @@ class Driver(ReverseDriver):
             version=websocket.http_version,
         )
 
-        ws = WebSocket(request=http_request, websocket=websocket)
+        ws = WebSocket(request=http_request, websocket_ctx=ctx)
 
         await setup.handle_func(ws)
 
@@ -237,30 +255,34 @@ class Driver(ReverseDriver):
 class WebSocket(BaseWebSocket):
     """Quart WebSocket Wrapper"""
 
-    def __init__(self, *, request: BaseRequest, websocket: QuartWebSocket):
+    def __init__(self, *, request: BaseRequest, websocket_ctx: WebsocketContext):
         super().__init__(request=request)
-        self.websocket = websocket
+        self.websocket_ctx = websocket_ctx
 
     @property
-    @overrides(BaseWebSocket)
+    def websocket(self) -> QuartWebSocket:
+        return self.websocket_ctx.websocket
+
+    @property
+    @override
     def closed(self):
         # FIXME
         return True
 
-    @overrides(BaseWebSocket)
+    @override
     async def accept(self):
         await self.websocket.accept()
 
-    @overrides(BaseWebSocket)
+    @override
     async def close(self, code: int = 1000, reason: str = ""):
         await self.websocket.close(code, reason)
 
-    @overrides(BaseWebSocket)
+    @override
     @catch_closed
     async def receive(self) -> Union[str, bytes]:
         return await self.websocket.receive()
 
-    @overrides(BaseWebSocket)
+    @override
     @catch_closed
     async def receive_text(self) -> str:
         msg = await self.websocket.receive()
@@ -268,7 +290,7 @@ class WebSocket(BaseWebSocket):
             raise TypeError("WebSocket received unexpected frame type: bytes")
         return msg
 
-    @overrides(BaseWebSocket)
+    @override
     @catch_closed
     async def receive_bytes(self) -> bytes:
         msg = await self.websocket.receive()
@@ -276,11 +298,11 @@ class WebSocket(BaseWebSocket):
             raise TypeError("WebSocket received unexpected frame type: str")
         return msg
 
-    @overrides(BaseWebSocket)
+    @override
     async def send_text(self, data: str):
         await self.websocket.send(data)
 
-    @overrides(BaseWebSocket)
+    @override
     async def send_bytes(self, data: bytes):
         await self.websocket.send(data)
 

nonebot/drivers/websockets.py

@@ -14,34 +14,39 @@ FrontMatter:
     sidebar_position: 4
     description: nonebot.drivers.websockets 模块
 """
+
 import logging
 from functools import wraps
 from contextlib import asynccontextmanager
-from typing import Type, Union, AsyncGenerator
+from typing_extensions import ParamSpec, override
+from typing import TYPE_CHECKING, Union, TypeVar, Callable, Awaitable, AsyncGenerator
 
-from nonebot.typing import overrides
+from nonebot.drivers import Request
 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
+from nonebot.drivers import WebSocketClientMixin, combine_driver
 
 try:
     from websockets.exceptions import ConnectionClosed
     from websockets.legacy.client import Connect, WebSocketClientProtocol
-except ImportError:
+except ModuleNotFoundError as e:  # pragma: no cover
     raise ImportError(
-        "Please install websockets by using `pip install nonebot2[websockets]`"
+        "Please install websockets first to use this driver. "
-    )
+        "Install with pip: `pip install nonebot2[websockets]`"
+    ) from e
+
+T = TypeVar("T")
+P = ParamSpec("P")
 
 logger = logging.Logger("websockets.client", "INFO")
 logger.addHandler(LoguruHandler())
 
 
-def catch_closed(func):
+def catch_closed(func: Callable[P, Awaitable[T]]) -> Callable[P, Awaitable[T]]:
     @wraps(func)
-    async def decorator(*args, **kwargs):
+    async def decorator(*args: P.args, **kwargs: P.kwargs) -> T:
         try:
             return await func(*args, **kwargs)
         except ConnectionClosed as e:
@@ -53,24 +58,20 @@ def catch_closed(func):
     return decorator
 
 
-class Mixin(ForwardMixin):
+class Mixin(WebSocketClientMixin):
     """Websockets Mixin"""
 
     @property
-    @overrides(ForwardMixin)
+    @override
     def type(self) -> str:
         return "websockets"
 
-    @overrides(ForwardMixin)
+    @override
-    async def request(self, setup: Request) -> Response:
-        return await super(Mixin, self).request(setup)
-
-    @overrides(ForwardMixin)
     @asynccontextmanager
     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:
@@ -80,31 +81,30 @@ class Mixin(ForwardMixin):
 class WebSocket(BaseWebSocket):
     """Websockets WebSocket Wrapper"""
 
-    @overrides(BaseWebSocket)
+    @override
     def __init__(self, *, request: Request, websocket: WebSocketClientProtocol):
         super().__init__(request=request)
         self.websocket = websocket
 
     @property
-    @overrides(BaseWebSocket)
+    @override
     def closed(self) -> bool:
         return self.websocket.closed
 
-    @overrides(BaseWebSocket)
+    @override
     async def accept(self):
         raise NotImplementedError
 
-    @overrides(BaseWebSocket)
+    @override
     async def close(self, code: int = 1000, reason: str = ""):
         await self.websocket.close(code, reason)
 
-    @overrides(BaseWebSocket)
+    @override
     @catch_closed
     async def receive(self) -> Union[str, bytes]:
-        msg = await self.websocket.recv()
+        return await self.websocket.recv()
-        return msg
 
-    @overrides(BaseWebSocket)
+    @override
     @catch_closed
     async def receive_text(self) -> str:
         msg = await self.websocket.recv()
@@ -112,7 +112,7 @@ class WebSocket(BaseWebSocket):
             raise TypeError("WebSocket received unexpected frame type: bytes")
         return msg
 
-    @overrides(BaseWebSocket)
+    @override
     @catch_closed
     async def receive_bytes(self) -> bytes:
         msg = await self.websocket.recv()
@@ -120,14 +120,20 @@ class WebSocket(BaseWebSocket):
             raise TypeError("WebSocket received unexpected frame type: str")
         return msg
 
-    @overrides(BaseWebSocket)
+    @override
     async def send_text(self, data: str) -> None:
         await self.websocket.send(data)
 
-    @overrides(BaseWebSocket)
+    @override
     async def send_bytes(self, data: bytes) -> None:
         await self.websocket.send(data)
 
 
-Driver: Type[ForwardDriver] = combine_driver(BlockDriver, Mixin)  # type: ignore
+if TYPE_CHECKING:
-"""Websockets Driver"""
+
+    class Driver(Mixin, NoneDriver):
+        ...
+
+else:
+    Driver = combine_driver(NoneDriver, Mixin)
+    """Websockets Driver"""

nonebot/exception.py

@@ -37,20 +37,24 @@ from pydantic.fields import ModelField
 class NoneBotException(Exception):
     """所有 NoneBot 发生的异常基类。"""
 
+    def __str__(self) -> str:
+        return self.__repr__()
+
 
 # Rule Exception
 class ParserExit(NoneBotException):
-    """{ref}`nonebot.rule.shell_command` 处理消息失败时返回的异常"""
+    """{ref}`nonebot.rule.shell_command` 处理消息失败时返回的异常。"""
 
-    def __init__(self, status: int = 0, message: Optional[str] = None):
+    def __init__(self, status: int = 0, message: Optional[str] = None) -> None:
         self.status = status
         self.message = message
 
-    def __repr__(self):
+    def __repr__(self) -> str:
-        return f"<ParserExit status={self.status} message={self.message}>"
+        return (
-
+            f"ParserExit(status={self.status}"
-    def __str__(self):
+            + (f", message={self.message!r}" if self.message else "")
-        return self.__repr__()
+            + ")"
+        )
 
 
 # Processor Exception
@@ -65,14 +69,11 @@ class IgnoredException(ProcessException):
         reason: 忽略事件的原因
     """
 
-    def __init__(self, reason: Any):
+    def __init__(self, reason: Any) -> None:
         self.reason: Any = reason
 
-    def __repr__(self):
+    def __repr__(self) -> str:
-        return f"<IgnoredException, reason={self.reason}>"
+        return f"IgnoredException(reason={self.reason!r})"
-
-    def __str__(self):
-        return self.__repr__()
 
 
 class SkippedException(ProcessException):
@@ -95,19 +96,20 @@ class SkippedException(ProcessException):
 class TypeMisMatch(SkippedException):
     """当前 `Handler` 的参数类型不匹配。"""
 
-    def __init__(self, param: ModelField, value: Any):
+    def __init__(self, param: ModelField, value: Any) -> None:
         self.param: ModelField = param
         self.value: Any = value
 
-    def __repr__(self):
+    def __repr__(self) -> str:
-        return f"<TypeMisMatch, param={self.param}, value={self.value}>"
+        return (
-
+            f"TypeMisMatch(param={self.param.name}, "
-    def __str__(self):
+            f"type={self.param._type_display()}, value={self.value!r}>"
-        self.__repr__()
+        )
 
 
 class MockApiException(ProcessException):
-    """指示 NoneBot 阻止本次 API 调用或修改本次调用返回值，并返回自定义内容。可由 api hook 抛出。
+    """指示 NoneBot 阻止本次 API 调用或修改本次调用返回值，并返回自定义内容。
+    可由 api hook 抛出。
 
     参数:
         result: 返回的内容
@@ -116,11 +118,8 @@ class MockApiException(ProcessException):
     def __init__(self, result: Any):
         self.result = result
 
-    def __repr__(self):
+    def __repr__(self) -> str:
-        return f"<ApiCancelledException, result={self.result}>"
+        return f"MockApiException(result={self.result!r})"
-
-    def __str__(self):
-        return self.__repr__()
 
 
 class StopPropagation(ProcessException):
@@ -146,7 +145,8 @@ class MatcherException(NoneBotException):
 
 
 class PausedException(MatcherException):
-    """指示 NoneBot 结束当前 `Handler` 并等待下一条消息后继续下一个 `Handler`。可用于用户输入新信息。
+    """指示 NoneBot 结束当前 `Handler` 并等待下一条消息后继续下一个 `Handler`。
+    可用于用户输入新信息。
 
     可以在 `Handler` 中通过 {ref}`nonebot.matcher.Matcher.pause` 抛出。
 
@@ -160,7 +160,8 @@ class PausedException(MatcherException):
 
 
 class RejectedException(MatcherException):
-    """指示 NoneBot 结束当前 `Handler` 并等待下一条消息后重新运行当前 `Handler`。可用于用户重新输入。
+    """指示 NoneBot 结束当前 `Handler` 并等待下一条消息后重新运行当前 `Handler`。
+    可用于用户重新输入。
 
     可以在 `Handler` 中通过 {ref}`nonebot.matcher.Matcher.reject` 抛出。
 
@@ -189,13 +190,14 @@ class FinishedException(MatcherException):
 
 # Adapter Exceptions
 class AdapterException(NoneBotException):
-    """代表 `Adapter` 抛出的异常，所有的 `Adapter` 都要在内部继承自这个 `Exception`
+    """代表 `Adapter` 抛出的异常，所有的 `Adapter` 都要在内部继承自这个 `Exception`。
 
     参数:
         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
 
 
@@ -211,7 +213,9 @@ class ApiNotAvailable(AdapterException):
 
 
 class NetworkError(AdapterException):
-    """在网络出现问题时抛出，如: API 请求地址不正确, API 请求无返回或返回状态非正常等。"""
+    """在网络出现问题时抛出，
+    如: API 请求地址不正确, API 请求无返回或返回状态非正常等。
+    """
 
 
 class ActionFailed(AdapterException):
@@ -220,15 +224,19 @@ class ActionFailed(AdapterException):
 
 # Driver Exceptions
 class DriverException(NoneBotException):
-    """`Driver` 抛出的异常基类"""
+    """`Driver` 抛出的异常基类。"""
 
 
 class WebSocketClosed(DriverException):
-    """WebSocket 连接已关闭"""
+    """WebSocket 连接已关闭。"""
 
-    def __init__(self, code: int, reason: Optional[str] = None):
+    def __init__(self, code: int, reason: Optional[str] = None) -> None:
         self.code = code
         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

@@ -7,10 +7,11 @@ from nonebot.internal.driver import (
     Driver,
     Request,
     Response,
+    ASGIMixin,
     WebSocket,
-    ForwardDriver,
+    HTTPClientMixin,
-    ReverseDriver,
     HTTPServerSetup,
+    WebSocketClientMixin,
     WebSocketServerSetup,
 )
 
@@ -33,6 +34,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:
@@ -63,31 +67,32 @@ class Adapter(abc.ABC):
         参数:
             bot: {ref}`nonebot.adapters.Bot` 实例
         """
+        if self.bots.pop(bot.self_id, None) is None:
+            raise RuntimeError(f"{bot} not found in adapter {self.get_name()}")
         self.driver._bot_disconnect(bot)
-        self.bots.pop(bot.self_id, None)
 
     def setup_http_server(self, setup: HTTPServerSetup):
         """设置一个 HTTP 服务器路由配置"""
-        if not isinstance(self.driver, ReverseDriver):
+        if not isinstance(self.driver, ASGIMixin):
             raise TypeError("Current driver does not support http server")
         self.driver.setup_http_server(setup)
 
     def setup_websocket_server(self, setup: WebSocketServerSetup):
         """设置一个 WebSocket 服务器路由配置"""
-        if not isinstance(self.driver, ReverseDriver):
+        if not isinstance(self.driver, ASGIMixin):
             raise TypeError("Current driver does not support websocket server")
         self.driver.setup_websocket_server(setup)
 
     async def request(self, setup: Request) -> Response:
         """进行一个 HTTP 客户端请求"""
-        if not isinstance(self.driver, ForwardDriver):
+        if not isinstance(self.driver, HTTPClientMixin):
             raise TypeError("Current driver does not support http client")
         return await self.driver.request(setup)
 
     @asynccontextmanager
     async def websocket(self, setup: Request) -> AsyncGenerator[WebSocket, None]:
         """建立一个 WebSocket 客户端连接请求"""
-        if not isinstance(self.driver, ForwardDriver):
+        if not isinstance(self.driver, WebSocketClientMixin):
             raise TypeError("Current driver does not support websocket client")
         async with self.driver.websocket(setup) as ws:
             yield ws

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, Protocol
-from typing import TYPE_CHECKING, Any, Set, Union, Optional
 
 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):
-class _ApiCall(Protocol):
+        async def __call__(self, **kwargs: Any) -> Any:
-    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 := [hook(self, api, data) for hook in self._calling_api_hook]:
-        if coros:
             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(
+        if coros := [
-            map(lambda x: x(self, exception, api, data, result), self._called_api_hook)
+            hook(self, exception, api, data, result) for hook in self._called_api_hook
-        )
+        ]:
-        if coros:
             try:
                 logger.debug("Running CalledAPI hooks...")
                 await asyncio.gather(*coros)

nonebot/internal/adapter/event.py

@@ -44,10 +44,11 @@ class Event(abc.ABC, BaseModel):
     def get_log_string(self) -> str:
         """获取事件日志信息的方法。
 
-        通常你不需要修改这个方法，只有当希望 NoneBot 隐藏该事件日志时，可以抛出 `NoLogException` 异常。
+        通常你不需要修改这个方法，只有当希望 NoneBot 隐藏该事件日志时，
+        可以抛出 `NoLogException` 异常。
 
         异常:
-            NoLogException
+            NoLogException: 希望 NoneBot 隐藏该事件日志
         """
         return f"[{self.get_event_name()}]: {self.get_event_description()}"
 
@@ -58,7 +59,9 @@ class Event(abc.ABC, BaseModel):
 
     @abc.abstractmethod
     def get_session_id(self) -> str:
-        """获取会话 id 的方法，用于判断当前事件属于哪一个会话，通常是用户 id、群组 id 组合。"""
+        """获取会话 id 的方法，用于判断当前事件属于哪一个会话，
+        通常是用户 id、群组 id 组合。
+        """
         raise NotImplementedError
 
     @abc.abstractmethod

nonebot/internal/adapter/message.py

@@ -1,5 +1,6 @@
 import abc
 from copy import deepcopy
+from typing_extensions import Self
 from dataclasses import field, asdict, dataclass
 from typing import (
     Any,
@@ -12,6 +13,7 @@ from typing import (
     TypeVar,
     Iterable,
     Optional,
+    SupportsIndex,
     overload,
 )
 
@@ -19,7 +21,6 @@ from pydantic import parse_obj_as
 
 from .template import MessageTemplate
 
-T = TypeVar("T")
 TMS = TypeVar("TMS", bound="MessageSegment")
 TM = TypeVar("TM", bound="Message")
 
@@ -47,7 +48,7 @@ class MessageSegment(abc.ABC, Generic[TM]):
     def __len__(self) -> int:
         return len(str(self))
 
-    def __ne__(self: T, other: T) -> bool:
+    def __ne__(self, other: Self) -> bool:
         return not self == other
 
     def __add__(self: TMS, other: Union[str, TMS, Iterable[TMS]]) -> TM:
@@ -61,7 +62,7 @@ class MessageSegment(abc.ABC, Generic[TM]):
         yield cls._validate
 
     @classmethod
-    def _validate(cls, value):
+    def _validate(cls, value) -> Self:
         if isinstance(value, cls):
             return value
         if not isinstance(value, dict):
@@ -84,7 +85,10 @@ class MessageSegment(abc.ABC, Generic[TM]):
     def items(self):
         return asdict(self).items()
 
-    def copy(self: T) -> T:
+    def join(self: TMS, iterable: Iterable[Union[TMS, TM]]) -> TM:
+        return self.get_message_class()(self).join(iterable)
+
+    def copy(self) -> Self:
         return deepcopy(self)
 
     @abc.abstractmethod
@@ -94,7 +98,7 @@ class MessageSegment(abc.ABC, Generic[TM]):
 
 
 class Message(List[TMS], abc.ABC):
-    """消息数组
+    """消息序列
 
     参数:
         message: 消息内容
@@ -117,12 +121,12 @@ class Message(List[TMS], abc.ABC):
             self.extend(self._construct(message))  # pragma: no cover
 
     @classmethod
-    def template(cls: Type[TM], format_string: Union[str, TM]) -> MessageTemplate[TM]:
+    def template(cls, format_string: Union[str, TM]) -> MessageTemplate[Self]:
         """创建消息模板。
 
-        用法和 `str.format` 大致相同, 但是可以输出消息对象, 并且支持以 `Message` 对象作为消息模板
+        用法和 `str.format` 大致相同，支持以 `Message` 对象作为消息模板并输出消息对象。
-
+        并且提供了拓展的格式化控制符，
-        并且提供了拓展的格式化控制符, 可以用适用于该消息类型的 `MessageSegment` 的工厂方法创建消息
+        可以通过该消息类型的 `MessageSegment` 工厂方法创建消息。
 
         参数:
             format_string: 格式化模板
@@ -146,7 +150,7 @@ class Message(List[TMS], abc.ABC):
         yield cls._validate
 
     @classmethod
-    def _validate(cls, value):
+    def _validate(cls, value) -> Self:
         if isinstance(value, cls):
             return value
         elif isinstance(value, Message):
@@ -169,16 +173,16 @@ class Message(List[TMS], abc.ABC):
         """构造消息数组"""
         raise NotImplementedError
 
-    def __add__(self: TM, other: Union[str, TMS, Iterable[TMS]]) -> TM:
+    def __add__(self, other: Union[str, TMS, Iterable[TMS]]) -> Self:
         result = self.copy()
         result += other
         return result
 
-    def __radd__(self: TM, other: Union[str, TMS, Iterable[TMS]]) -> TM:
+    def __radd__(self, other: Union[str, TMS, Iterable[TMS]]) -> Self:
         result = self.__class__(other)
         return result + self
 
-    def __iadd__(self: TM, other: Union[str, TMS, Iterable[TMS]]) -> TM:
+    def __iadd__(self, other: Union[str, TMS, Iterable[TMS]]) -> Self:
         if isinstance(other, str):
             self.extend(self._construct(other))
         elif isinstance(other, MessageSegment):
@@ -186,61 +190,66 @@ 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
-    def __getitem__(self: TM, __args: str) -> TM:
+    def __getitem__(self, args: str) -> Self:
-        """
+        """获取仅包含指定消息段类型的消息
+
         参数:
-            __args: 消息段类型
+            args: 消息段类型
 
         返回:
-            所有类型为 `__args` 的消息段
+            所有类型为 `args` 的消息段
         """
 
     @overload
-    def __getitem__(self, __args: Tuple[str, int]) -> TMS:
+    def __getitem__(self, args: Tuple[str, int]) -> TMS:
-        """
+        """索引指定类型的消息段
+
         参数:
-            __args: 消息段类型和索引
+            args: 消息段类型和索引
 
         返回:
-            类型为 `__args[0]` 的消息段第 `__args[1]` 个
+            类型为 `args[0]` 的消息段第 `args[1]` 个
         """
 
     @overload
-    def __getitem__(self: TM, __args: Tuple[str, slice]) -> TM:
+    def __getitem__(self, args: Tuple[str, slice]) -> Self:
-        """
+        """切片指定类型的消息段
+
         参数:
-            __args: 消息段类型和切片
+            args: 消息段类型和切片
 
         返回:
-            类型为 `__args[0]` 的消息段切片 `__args[1]`
+            类型为 `args[0]` 的消息段切片 `args[1]`
         """
 
     @overload
-    def __getitem__(self, __args: int) -> TMS:
+    def __getitem__(self, args: int) -> TMS:
-        """
+        """索引消息段
+
         参数:
-            __args: 索引
+            args: 索引
 
         返回:
-            第 `__args` 个消息段
+            第 `args` 个消息段
         """
 
     @overload
-    def __getitem__(self: TM, __args: slice) -> TM:
+    def __getitem__(self, args: slice) -> Self:
-        """
+        """切片消息段
+
         参数:
-            __args: 切片
+            args: 切片
 
         返回:
-            消息切片 `__args`
+            消息切片 `args`
         """
 
     def __getitem__(
-        self: TM,
+        self,
         args: Union[
             str,
             Tuple[str, int],
@@ -248,7 +257,7 @@ class Message(List[TMS], abc.ABC):
             int,
             slice,
         ],
-    ) -> Union[TMS, TM]:
+    ) -> Union[TMS, Self]:
         arg1, arg2 = args if isinstance(args, tuple) else (args, None)
         if isinstance(arg1, int) and arg2 is None:
             return super().__getitem__(arg1)
@@ -263,15 +272,52 @@ class Message(List[TMS], abc.ABC):
         else:
             raise ValueError("Incorrect arguments to slice")  # pragma: no cover
 
-    def index(self, value: Union[TMS, str], *args) -> int:
+    def __contains__(self, value: Union[TMS, str]) -> bool:
+        """检查消息段是否存在
+
+        参数:
+            value: 消息段或消息段类型
+        返回:
+            消息内是否存在给定消息段或给定类型的消息段
+        """
+        if isinstance(value, str):
+            return bool(next((seg for seg in self if seg.type == value), None))
+        return super().__contains__(value)
+
+    def has(self, value: Union[TMS, str]) -> bool:
+        """与 {ref}``__contains__` <nonebot.adapters.Message.__contains__>` 相同"""
+        return value in self
+
+    def index(self, value: Union[TMS, str], *args: SupportsIndex) -> int:
+        """索引消息段
+
+        参数:
+            value: 消息段或者消息段类型
+            arg: start 与 end
+
+        返回:
+            索引 index
+
+        异常:
+            ValueError: 消息段不存在
+        """
         if isinstance(value, str):
             first_segment = next((seg for seg in self if seg.type == value), None)
             if first_segment is None:
-                raise ValueError(f"Segment with type {value} is not in message")
+                raise ValueError(f"Segment with type {value!r} is not in message")
             return super().index(first_segment, *args)
         return super().index(value, *args)
 
-    def get(self: TM, type_: str, count: Optional[int] = None) -> TM:
+    def get(self, type_: str, count: Optional[int] = None) -> Self:
+        """获取指定类型的消息段
+
+        参数:
+            type_: 消息段类型
+            count: 获取个数
+
+        返回:
+            构建的新消息
+        """
         if count is None:
             return self[type_]
 
@@ -286,9 +332,30 @@ class Message(List[TMS], abc.ABC):
         return filtered
 
     def count(self, value: Union[TMS, str]) -> int:
+        """计算指定消息段的个数
+
+        参数:
+            value: 消息段或消息段类型
+
+        返回:
+            个数
+        """
         return len(self[value]) if isinstance(value, str) else super().count(value)
 
-    def append(self: TM, obj: Union[str, TMS]) -> TM:
+    def only(self, value: Union[TMS, str]) -> bool:
+        """检查消息中是否仅包含指定消息段
+
+        参数:
+            value: 指定消息段或消息段类型
+
+        返回:
+            是否仅包含指定消息段
+        """
+        if isinstance(value, str):
+            return all(seg.type == value for seg in self)
+        return all(seg == value for seg in self)
+
+    def append(self, obj: Union[str, TMS]) -> Self:
         """添加一个消息段到消息数组末尾。
 
         参数:
@@ -302,7 +369,7 @@ class Message(List[TMS], abc.ABC):
             raise ValueError(f"Unexpected type: {type(obj)} {obj}")  # pragma: no cover
         return self
 
-    def extend(self: TM, obj: Union[TM, Iterable[TMS]]) -> TM:
+    def extend(self, obj: Union[Self, Iterable[TMS]]) -> Self:
         """拼接一个消息数组或多个消息段到消息数组末尾。
 
         参数:
@@ -312,18 +379,52 @@ class Message(List[TMS], abc.ABC):
             self.append(segment)
         return self
 
-    def copy(self: TM) -> TM:
+    def join(self, iterable: Iterable[Union[TMS, Self]]) -> Self:
+        """将多个消息连接并将自身作为分割
+
+        参数:
+            iterable: 要连接的消息
+
+        返回:
+            连接后的消息
+        """
+        ret = self.__class__()
+        for index, msg in enumerate(iterable):
+            if index != 0:
+                ret.extend(self)
+            if isinstance(msg, MessageSegment):
+                ret.append(msg.copy())
+            else:
+                ret.extend(msg.copy())
+        return ret
+
+    def copy(self) -> Self:
+        """深拷贝消息"""
         return deepcopy(self)
 
+    def include(self, *types: str) -> Self:
+        """过滤消息
+
+        参数:
+            types: 包含的消息段类型
+
+        返回:
+            新构造的消息
+        """
+        return self.__class__(seg for seg in self if seg.type in types)
+
+    def exclude(self, *types: str) -> Self:
+        """过滤消息
+
+        参数:
+            types: 不包含的消息段类型
+
+        返回:
+            新构造的消息
+        """
+        return self.__class__(seg for seg in self if seg.type not in types)
+
     def extract_plain_text(self) -> str:
         """提取消息内纯文本消息"""
 
         return "".join(str(seg) for seg in self if seg.is_text())
-
-
-__autodoc__ = {
-    "MessageSegment.__str__": True,
-    "MessageSegment.__add__": True,
-    "Message.__getitem__": True,
-    "Message._construct": True,
-}

nonebot/internal/adapter/template.py

@@ -1,5 +1,6 @@
 import functools
 from string import Formatter
+from typing_extensions import TypeAlias
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -25,7 +26,7 @@ if TYPE_CHECKING:
 TM = TypeVar("TM", bound="Message")
 TF = TypeVar("TF", str, "Message")
 
-FormatSpecFunc = Callable[[Any], str]
+FormatSpecFunc: TypeAlias = Callable[[Any], str]
 FormatSpecFunc_T = TypeVar("FormatSpecFunc_T", bound=FormatSpecFunc)
 
 
@@ -49,13 +50,16 @@ class MessageTemplate(Formatter, Generic[TF]):
     ) -> None:
         ...
 
-    def __init__(  # type:ignore
+    def __init__(
-        self, template, factory=str
+        self, template: Union[str, TM], factory: Union[Type[str], Type[TM]] = str
-    ) -> None:  # TODO: fix type hint here
+    ) -> None:
-        self.template: TF = template
+        self.template: TF = template  # type: ignore
-        self.factory: Type[TF] = factory
+        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 +99,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(
@@ -116,10 +120,9 @@ class MessageTemplate(Formatter, Generic[TF]):
     ) -> Tuple[TF, int]:
         results: List[Any] = [self.factory()]
 
-        for (literal_text, field_name, format_spec, conversion) in self.parse(
+        for literal_text, field_name, format_spec, conversion in self.parse(
             format_string
         ):
-
             # output the literal text
             if literal_text:
                 results.append(literal_text)

nonebot/internal/driver/__init__.py

@@ -1,4 +1,5 @@
 from .model import URL as URL
+from .driver import Mixin as Mixin
 from .model import RawURL as RawURL
 from .driver import Driver as Driver
 from .model import Cookies as Cookies
@@ -8,6 +9,7 @@ from .model import Response as Response
 from .model import DataTypes as DataTypes
 from .model import FileTypes as FileTypes
 from .model import WebSocket as WebSocket
+from .driver import ASGIMixin as ASGIMixin
 from .model import FilesTypes as FilesTypes
 from .model import QueryTypes as QueryTypes
 from .model import CookieTypes as CookieTypes
@@ -17,9 +19,12 @@ from .model import HeaderTypes as HeaderTypes
 from .model import SimpleQuery as SimpleQuery
 from .model import ContentTypes as ContentTypes
 from .driver import ForwardMixin as ForwardMixin
+from .driver import ReverseMixin as ReverseMixin
 from .model import QueryVariable as QueryVariable
 from .driver import ForwardDriver as ForwardDriver
 from .driver import ReverseDriver as ReverseDriver
 from .driver import combine_driver as combine_driver
 from .model import HTTPServerSetup as HTTPServerSetup
+from .driver import HTTPClientMixin as HTTPClientMixin
 from .model import WebSocketServerSetup as WebSocketServerSetup
+from .driver import WebSocketClientMixin as WebSocketClientMixin

nonebot/internal/driver/driver.py

@@ -1,15 +1,31 @@
 import abc
 import asyncio
-from contextlib import asynccontextmanager
+from typing_extensions import TypeAlias
-from typing import TYPE_CHECKING, Any, Set, Dict, Type, Callable, AsyncGenerator
+from contextlib import AsyncExitStack, asynccontextmanager
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Set,
+    Dict,
+    Type,
+    Union,
+    TypeVar,
+    Callable,
+    AsyncGenerator,
+    overload,
+)
 
 from nonebot.log import logger
 from nonebot.config import Env, Config
 from nonebot.dependencies import Dependent
 from nonebot.exception import SkippedException
 from nonebot.utils import escape_tag, run_coro_with_catch
-from nonebot.typing import T_BotConnectionHook, T_BotDisconnectionHook
 from nonebot.internal.params import BotParam, DependParam, DefaultParam
+from nonebot.typing import (
+    T_DependencyCache,
+    T_BotConnectionHook,
+    T_BotDisconnectionHook,
+)
 
 from .model import Request, Response, WebSocket, HTTPServerSetup, WebSocketServerSetup
 
@@ -17,11 +33,15 @@ if TYPE_CHECKING:
     from nonebot.internal.adapter import Bot, Adapter
 
 
+D = TypeVar("D", bound="Driver")
+
 BOT_HOOK_PARAMS = [DependParam, BotParam, DefaultParam]
 
 
 class Driver(abc.ABC):
-    """Driver 基类。
+    """驱动器基类。
+
+    驱动器控制框架的启动和停止，适配器的注册，以及机器人生命周期管理。
 
     参数:
         env: 包含环境信息的 Env 对象
@@ -40,12 +60,19 @@ class Driver(abc.ABC):
         """环境名称"""
         self.config: Config = config
         """全局配置对象"""
-        self._clients: Dict[str, "Bot"] = {}
+        self._bots: Dict[str, "Bot"] = {}
+        self._bot_tasks: Set[asyncio.Task] = set()
+
+    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:
         """注册一个协议适配器
@@ -79,13 +106,13 @@ class Driver(abc.ABC):
 
     @abc.abstractmethod
     def run(self, *args, **kwargs):
-        """
+        """启动驱动框架"""
-        启动驱动框架
-        """
         logger.opt(colors=True).debug(
             f"<g>Loaded adapters: {escape_tag(', '.join(self._adapters))}</g>"
         )
 
+        self.on_shutdown(self._cleanup)
+
     @abc.abstractmethod
     def on_startup(self, func: Callable) -> Callable:
         """注册一个在驱动器启动时执行的函数"""
@@ -124,66 +151,102 @@ 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(
+            dependency_cache: T_DependencyCache = {}
-                map(
+            async with AsyncExitStack() as stack:
-                    lambda x: run_coro_with_catch(x(bot=bot), (SkippedException,)),
+                if coros := [
-                    self._bot_connection_hook,
+                    run_coro_with_catch(
-                )
+                        hook(bot=bot, stack=stack, dependency_cache=dependency_cache),
-            )
+                        (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 WebSocketConnection hook. "
-                        "Running cancelled!</bg #f8bbd0></r>"
                     )
+                    for hook in self._bot_connection_hook
+                ]:
+                    try:
+                        await asyncio.gather(*coros)
+                    except Exception as e:
+                        logger.opt(colors=True, exception=e).error(
+                            "<r><bg #f8bbd0>"
+                            "Error when running WebSocketConnection hook. "
+                            "Running cancelled!"
+                            "</bg #f8bbd0></r>"
+                        )
 
-        asyncio.create_task(_run_hook(bot))
+        task = asyncio.create_task(_run_hook(bot))
+        task.add_done_callback(self._bot_tasks.discard)
+        self._bot_tasks.add(task)
 
     def _bot_disconnect(self, bot: "Bot") -> None:
         """在连接断开后，调用该函数来注销 bot 对象"""
-        if bot.self_id in self._clients:
+        if bot.self_id in self._bots:
-            del self._clients[bot.self_id]
+            del self._bots[bot.self_id]
 
         async def _run_hook(bot: "Bot") -> None:
-            coros = list(
+            dependency_cache: T_DependencyCache = {}
-                map(
+            async with AsyncExitStack() as stack:
-                    lambda x: run_coro_with_catch(x(bot=bot), (SkippedException,)),
+                if coros := [
-                    self._bot_disconnection_hook,
+                    run_coro_with_catch(
-                )
+                        hook(bot=bot, stack=stack, dependency_cache=dependency_cache),
-            )
+                        (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 WebSocketDisConnection hook. "
-                        "Running cancelled!</bg #f8bbd0></r>"
                     )
+                    for hook in self._bot_disconnection_hook
+                ]:
+                    try:
+                        await asyncio.gather(*coros)
+                    except Exception as e:
+                        logger.opt(colors=True, exception=e).error(
+                            "<r><bg #f8bbd0>"
+                            "Error when running WebSocketDisConnection hook. "
+                            "Running cancelled!"
+                            "</bg #f8bbd0></r>"
+                        )
 
-        asyncio.create_task(_run_hook(bot))
+        task = asyncio.create_task(_run_hook(bot))
+        task.add_done_callback(self._bot_tasks.discard)
+        self._bot_tasks.add(task)
+
+    async def _cleanup(self) -> None:
+        """清理驱动器资源"""
+        if self._bot_tasks:
+            logger.opt(colors=True).debug(
+                "<y>Waiting for running bot connection hooks...</y>"
+            )
+            await asyncio.gather(*self._bot_tasks, return_exceptions=True)
 
 
-class ForwardMixin(abc.ABC):
+class Mixin(abc.ABC):
-    """客户端混入基类。"""
+    """可与其他驱动器共用的混入基类。"""
 
     @property
     @abc.abstractmethod
     def type(self) -> str:
-        """客户端驱动类型名称"""
+        """混入驱动类型名称"""
         raise NotImplementedError
 
+
+class ForwardMixin(Mixin):
+    """客户端混入基类。"""
+
+
+class ReverseMixin(Mixin):
+    """服务端混入基类。"""
+
+
+class HTTPClientMixin(ForwardMixin):
+    """HTTP 客户端混入基类。"""
+
     @abc.abstractmethod
     async def request(self, setup: Request) -> Response:
         """发送一个 HTTP 请求"""
         raise NotImplementedError
 
+
+class WebSocketClientMixin(ForwardMixin):
+    """WebSocket 客户端混入基类。"""
+
     @abc.abstractmethod
     @asynccontextmanager
     async def websocket(self, setup: Request) -> AsyncGenerator[WebSocket, None]:
@@ -192,12 +255,11 @@ class ForwardMixin(abc.ABC):
         yield  # used for static type checking's generator detection
 
 
-class ForwardDriver(Driver, ForwardMixin):
+class ASGIMixin(ReverseMixin):
-    """客户端基类。将客户端框架封装，以满足适配器使用。"""
+    """ASGI 服务端基类。
 
-
+    将后端框架封装，以满足适配器使用。
-class ReverseDriver(Driver):
+    """
-    """服务端基类。将后端框架封装，以满足适配器使用。"""
 
     @property
     @abc.abstractmethod
@@ -222,24 +284,55 @@ class ReverseDriver(Driver):
         raise NotImplementedError
 
 
-def combine_driver(driver: Type[Driver], *mixins: Type[ForwardMixin]) -> Type[Driver]:
+ForwardDriver: TypeAlias = ForwardMixin
+"""支持客户端请求的驱动器。
+
+**Deprecated**，请使用 {ref}`nonebot.drivers.ForwardMixin` 或其子类代替。
+"""
+
+ReverseDriver: TypeAlias = ReverseMixin
+"""支持服务端请求的驱动器。
+
+**Deprecated**，请使用 {ref}`nonebot.drivers.ReverseMixin` 或其子类代替。
+"""
+
+
+if TYPE_CHECKING:
+
+    class CombinedDriver(Driver, Mixin):
+        ...
+
+
+@overload
+def combine_driver(driver: Type[D]) -> Type[D]:
+    ...
+
+
+@overload
+def combine_driver(driver: Type[D], *mixins: Type[Mixin]) -> Type["CombinedDriver"]:
+    ...
+
+
+def combine_driver(
+    driver: Type[D], *mixins: Type[Mixin]
+) -> Union[Type[D], Type["CombinedDriver"]]:
     """将一个驱动器和多个混入类合并。"""
     # check first
     assert issubclass(driver, Driver), "`driver` must be subclass of Driver"
     assert all(
-        map(lambda m: issubclass(m, ForwardMixin), mixins)
+        issubclass(m, Mixin) for m in mixins
-    ), "`mixins` must be subclass of ForwardMixin"
+    ), "`mixins` must be subclass of Mixin"
 
     if not mixins:
         return driver
 
-    class CombinedDriver(*mixins, driver, ForwardDriver):  # type: ignore
+    def type_(self: "CombinedDriver") -> str:
-        @property
+        return (
-        def type(self) -> str:
+            driver.type.__get__(self)
-            return (
+            + "+"
-                driver.type.__get__(self)
+            + "+".join(x.type.__get__(self) for x in mixins)
-                + "+"
+        )
-                + "+".join(map(lambda x: x.type.__get__(self), mixins))
-            )
 
-    return CombinedDriver
+    return type(
+        "CombinedDriver", (*mixins, driver), {"type": property(type_)}
+    )  # type: ignore

nonebot/internal/driver/model.py

@@ -1,6 +1,8 @@
 import abc
+import urllib.request
 from enum import Enum
 from dataclasses import dataclass
+from typing_extensions import TypeAlias
 from http.cookiejar import Cookie, CookieJar
 from typing import (
     IO,
@@ -20,28 +22,30 @@ from typing import (
 from yarl import URL as URL
 from multidict import CIMultiDict
 
-RawURL = Tuple[bytes, bytes, Optional[int], bytes]
+RawURL: TypeAlias = Tuple[bytes, bytes, Optional[int], bytes]
 
-SimpleQuery = Union[str, int, float]
+SimpleQuery: TypeAlias = Union[str, int, float]
-QueryVariable = Union[SimpleQuery, List[SimpleQuery]]
+QueryVariable: TypeAlias = Union[SimpleQuery, List[SimpleQuery]]
-QueryTypes = Union[
+QueryTypes: TypeAlias = Union[
     None, str, Mapping[str, QueryVariable], List[Tuple[str, QueryVariable]]
 ]
 
-HeaderTypes = Union[
+HeaderTypes: TypeAlias = Union[
     None,
     CIMultiDict[str],
     Dict[str, str],
     List[Tuple[str, str]],
 ]
 
-CookieTypes = Union[None, "Cookies", CookieJar, Dict[str, str], List[Tuple[str, str]]]
+CookieTypes: TypeAlias = Union[
+    None, "Cookies", CookieJar, Dict[str, str], List[Tuple[str, str]]
+]
 
-ContentTypes = Union[str, bytes, None]
+ContentTypes: TypeAlias = Union[str, bytes, None]
-DataTypes = Union[dict, None]
+DataTypes: TypeAlias = Union[dict, None]
-FileContent = Union[IO[bytes], bytes]
+FileContent: TypeAlias = Union[IO[bytes], bytes]
-FileType = Tuple[Optional[str], FileContent, Optional[str]]
+FileType: TypeAlias = Tuple[Optional[str], FileContent, Optional[str]]
-FileTypes = Union[
+FileTypes: TypeAlias = Union[
     # file (or bytes)
     FileContent,
     # (filename, file (or bytes))
@@ -49,7 +53,7 @@ FileTypes = Union[
     # (filename, file (or bytes), content_type)
     FileType,
 ]
-FilesTypes = Union[Dict[str, FileTypes], List[Tuple[str, FileTypes]], None]
+FilesTypes: TypeAlias = Union[Dict[str, FileTypes], List[Tuple[str, FileTypes]], None]
 
 
 class HTTPVersion(Enum):
@@ -105,12 +109,9 @@ class Request:
         self.url: URL = url
 
         # headers
-        self.headers: CIMultiDict[str]
+        self.headers: CIMultiDict[str] = (
-        if headers is not None:
+            CIMultiDict(headers) if headers is not None else CIMultiDict()
-            self.headers = CIMultiDict(headers)
+        )
-        else:
-            self.headers = CIMultiDict()
-
         # cookies
         self.cookies = Cookies(cookies)
 
@@ -124,16 +125,14 @@ class Request:
             files_ = files.items() if isinstance(files, dict) else files
             for name, file_info in files_:
                 if not isinstance(file_info, tuple):
-                    self.files.append((name, (None, file_info, None)))
+                    self.files.append((name, (name, file_info, None)))
                 elif len(file_info) == 2:
                     self.files.append((name, (file_info[0], file_info[1], None)))
                 else:
                     self.files.append((name, file_info))  # type: ignore
 
     def __repr__(self) -> str:
-        class_name = self.__class__.__name__
+        return f"{self.__class__.__name__}(method={self.method!r}, url='{self.url!s}')"
-        url = str(self.url)
-        return f"<{class_name}({self.method!r}, {url!r})>"
 
 
 class Response:
@@ -149,30 +148,30 @@ class Response:
         self.status_code: int = status_code
 
         # headers
-        self.headers: CIMultiDict[str]
+        self.headers: CIMultiDict[str] = (
-        if headers is not None:
+            CIMultiDict(headers) if headers is not None else CIMultiDict()
-            self.headers = CIMultiDict(headers)
+        )
-        else:
-            self.headers = 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:
-        """
+        """连接是否已经关闭"""
-        连接是否已经关闭
-        """
         raise NotImplementedError
 
     @abc.abstractmethod
@@ -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})"
-                f"<Cookie {cookie.name}={cookie.value} for {cookie.domain} />"
+            for cookie in self.jar
-                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,12 @@
+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 MatcherSource as MatcherSource
+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,103 @@
+from typing import (
+    TYPE_CHECKING,
+    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: object) -> 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,48 @@
+import sys
+import inspect
+import warnings
+from pathlib import Path
 from types import ModuleType
-from datetime import datetime
+from dataclasses import dataclass
 from contextvars import ContextVar
-from collections import defaultdict
+from typing_extensions import Self
-from contextlib import AsyncExitStack
+from datetime import datetime, timedelta
+from contextlib import AsyncExitStack, contextmanager
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
     List,
     Type,
+    Tuple,
     Union,
     TypeVar,
     Callable,
+    ClassVar,
+    Iterable,
     NoReturn,
     Optional,
+    overload,
 )
 
 from nonebot.log import logger
-from nonebot.dependencies import Dependent
+from nonebot.internal.rule import Rule
+from nonebot.utils import classproperty
+from nonebot.dependencies import Param, Dependent
+from nonebot.internal.permission import User, Permission
+from nonebot.internal.adapter import (
+    Bot,
+    Event,
+    Message,
+    MessageSegment,
+    MessageTemplate,
+)
+from nonebot.typing import (
+    T_State,
+    T_Handler,
+    T_TypeUpdater,
+    T_DependencyCache,
+    T_PermissionUpdater,
+)
 from nonebot.consts import (
     ARG_KEY,
     RECEIVE_KEY,
@@ -25,27 +50,14 @@ from nonebot.consts import (
     LAST_RECEIVE_KEY,
     REJECT_CACHE_TARGET,
 )
-from nonebot.typing import (
-    Any,
-    T_State,
-    T_Handler,
-    T_TypeUpdater,
-    T_DependencyCache,
-    T_PermissionUpdater,
-)
 from nonebot.exception import (
-    TypeMisMatch,
     PausedException,
     StopPropagation,
     SkippedException,
     FinishedException,
     RejectedException,
 )
-
+from nonebot.internal.params import (
-from .rule import Rule
-from .permission import USER, Permission
-from .adapter import Bot, Event, Message, MessageSegment, MessageTemplate
-from .params import (
     Depends,
     ArgParam,
     BotParam,
@@ -56,83 +68,99 @@ 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")
 current_handler: ContextVar[Dependent] = ContextVar("current_handler")
 
 
+@dataclass
+class MatcherSource:
+    """Matcher 源代码上下文信息"""
+
+    plugin_name: Optional[str] = None
+    """事件响应器所在插件名称"""
+    module_name: Optional[str] = None
+    """事件响应器所在插件模块的路径名"""
+    lineno: Optional[int] = None
+    """事件响应器所在行号"""
+
+    @property
+    def plugin(self) -> Optional["Plugin"]:
+        """事件响应器所在插件"""
+        from nonebot.plugin import get_plugin
+
+        if self.plugin_name is not None:
+            return get_plugin(self.plugin_name)
+
+    @property
+    def module(self) -> Optional[ModuleType]:
+        if self.module_name is not None:
+            return sys.modules.get(self.module_name)
+
+    @property
+    def file(self) -> Optional[Path]:
+        if self.module is not None and (file := inspect.getsourcefile(self.module)):
+            return Path(file).absolute()
+
+
 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
+        _source: Optional[MatcherSource]
-        permission: Permission
+        module_name: Optional[str]
-        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"{self.__name__}(type={self.type!r}"
-            f"type={self.type}, priority={self.priority}, "
+            + (f", module={self.module_name}" if self.module_name else "")
-            f"temp={self.temp}>"
+            + (
+                f", lineno={self._source.lineno}"
+                if self._source and self._source.lineno is not None
+                else ""
+            )
+            + ")"
         )
 
-    def __str__(self) -> str:
-        return repr(self)
-
 
 class Matcher(metaclass=MatcherMeta):
     """事件响应器类"""
 
-    plugin: Optional["Plugin"] = None
+    _source: ClassVar[Optional[MatcherSource]] = None
-    """事件响应器所在插件"""
-    module: Optional[ModuleType] = None
-    """事件响应器所在插件模块"""
-    plugin_name: Optional[str] = None
-    """事件响应器所在插件名"""
-    module_name: Optional[str] = None
-    """事件响应器所在点分割插件模块路径"""
 
-    type: str = ""
+    type: ClassVar[str] = ""
     """事件响应器类型"""
-    rule: Rule = Rule()
+    rule: ClassVar[Rule] = Rule()
     """事件响应器匹配规则"""
-    permission: Permission = Permission()
+    permission: ClassVar[Permission] = Permission()
     """事件响应器触发权限"""
     handlers: List[Dependent[Any]] = []
     """事件响应器拥有的事件处理函数列表"""
-    priority: int = 1
+    priority: ClassVar[int] = 1
     """事件响应器优先级"""
     block: bool = False
     """事件响应器是否阻止事件传播"""
-    temp: bool = False
+    temp: ClassVar[bool] = False
     """事件响应器是否为临时"""
-    expire_time: Optional[datetime] = None
+    expire_time: ClassVar[Optional[datetime]] = None
     """事件响应器过期时间点"""
 
-    _default_state: T_State = {}
+    _default_state: ClassVar[T_State] = {}
     """事件响应器默认状态"""
 
-    _default_type_updater: Optional[Dependent[str]] = None
+    _default_type_updater: ClassVar[Optional[Dependent[str]]] = None
     """事件响应器类型更新函数"""
-    _default_permission_updater: Optional[Dependent[Permission]] = None
+    _default_permission_updater: ClassVar[Optional[Dependent[Permission]]] = None
     """事件响应器权限更新函数"""
 
-    HANDLER_PARAM_TYPES = [
+    HANDLER_PARAM_TYPES: ClassVar[Tuple[Type[Param], ...]] = (
         DependParam,
         BotParam,
         EventParam,
@@ -140,7 +168,7 @@ class Matcher(metaclass=MatcherMeta):
         ArgParam,
         MatcherParam,
         DefaultParam,
-    ]
+    )
 
     def __init__(self):
         self.handlers = self.handlers.copy()
@@ -148,13 +176,16 @@ class Matcher(metaclass=MatcherMeta):
 
     def __repr__(self) -> str:
         return (
-            f"<Matcher from {self.module_name or 'unknown'}, type={self.type}, "
+            f"{self.__class__.__name__}(type={self.type!r}"
-            f"priority={self.priority}, temp={self.temp}>"
+            + (f", module={self.module_name}" if self.module_name else "")
+            + (
+                f", lineno={self._source.lineno}"
+                if self._source and self._source.lineno is not None
+                else ""
+            )
+            + ")"
         )
 
-    def __str__(self) -> str:
-        return repr(self)
-
     @classmethod
     def new(
         cls,
@@ -168,13 +199,14 @@ class Matcher(metaclass=MatcherMeta):
         *,
         plugin: Optional["Plugin"] = None,
         module: Optional[ModuleType] = None,
-        expire_time: Optional[datetime] = None,
+        source: Optional[MatcherSource] = 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[
             Union[T_PermissionUpdater, Dependent[Permission]]
         ] = None,
-    ) -> Type["Matcher"]:
+    ) -> Type[Self]:
         """
         创建一个新的事件响应器，并存储至 `matchers <#matchers>`_
 
@@ -186,22 +218,47 @@ class Matcher(metaclass=MatcherMeta):
             temp: 是否为临时事件响应器，即触发一次后删除
             priority: 响应优先级
             block: 是否阻止事件向更低优先级的响应器传播
-            plugin: 事件响应器所在插件
+            plugin: **Deprecated.** 事件响应器所在插件
-            module: 事件响应器所在模块
+            module: **Deprecated.** 事件响应器所在模块
-            default_state: 默认状态 `state`
+            source: 事件响应器源代码上下文信息
             expire_time: 事件响应器最终有效时间点，过时即被删除
+            default_state: 默认状态 `state`
+            default_type_updater: 默认事件类型更新函数
+            default_permission_updater: 默认会话权限更新函数
 
         返回:
             Type[Matcher]: 新的事件响应器类
         """
+        if plugin is not None:
+            warnings.warn(
+                (
+                    "Pass `plugin` context info to create Matcher is deprecated. "
+                    "Use `source` instead."
+                ),
+                DeprecationWarning,
+            )
+        if module is not None:
+            warnings.warn(
+                (
+                    "Pass `module` context info to create Matcher is deprecated. "
+                    "Use `source` instead."
+                ),
+                DeprecationWarning,
+            )
+        source = source or (
+            MatcherSource(
+                plugin_name=plugin and plugin.name,
+                module_name=module and module.__name__,
+            )
+            if plugin is not None or module is not None
+            else None
+        )
+
         NewMatcher = type(
-            "Matcher",
+            cls.__name__,
-            (Matcher,),
+            (cls,),
             {
-                "plugin": plugin,
+                "_source": source,
-                "module": module,
-                "plugin_name": plugin and plugin.name,
-                "module_name": module and module.__name__,
                 "type": type_,
                 "rule": rule or Rule(),
                 "permission": permission or Permission(),
@@ -216,25 +273,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)
+                    and (
-                    else default_type_updater
+                        default_type_updater
-                    and Dependent[str].parse(
+                        if isinstance(default_type_updater, Dependent)
-                        call=default_type_updater, allow_types=cls.HANDLER_PARAM_TYPES
+                        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)
+                    and (
-                    else default_permission_updater
+                        default_permission_updater
-                    and Dependent[Permission].parse(
+                        if isinstance(default_permission_updater, Dependent)
-                        call=default_permission_updater,
+                        else Dependent[Permission].parse(
-                        allow_types=cls.HANDLER_PARAM_TYPES,
+                            call=default_permission_updater,
+                            allow_types=cls.HANDLER_PARAM_TYPES,
+                        )
                     )
                 ),
             },
@@ -246,6 +315,31 @@ class Matcher(metaclass=MatcherMeta):
 
         return NewMatcher
 
+    @classmethod
+    def destroy(cls) -> None:
+        """销毁当前的事件响应器"""
+        matchers[cls.priority].remove(cls)
+
+    @classproperty
+    def plugin(cls) -> Optional["Plugin"]:
+        """事件响应器所在插件"""
+        return cls._source and cls._source.plugin
+
+    @classproperty
+    def module(cls) -> Optional[ModuleType]:
+        """事件响应器所在插件模块"""
+        return cls._source and cls._source.module
+
+    @classproperty
+    def plugin_name(cls) -> Optional[str]:
+        """事件响应器所在插件名"""
+        return cls._source and cls._source.plugin_name
+
+    @classproperty
+    def module_name(cls) -> Optional[str]:
+        """事件响应器所在插件模块路径"""
+        return cls._source and cls._source.module_name
+
     @classmethod
     async def check_perm(
         cls,
@@ -322,7 +416,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 +428,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 +444,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 +462,20 @@ class Matcher(metaclass=MatcherMeta):
                 return
             await matcher.reject()
 
-        _parameterless = [Depends(_receive), *(parameterless or [])]
+        _parameterless = (Depends(_receive), *(parameterless or ()))
 
         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):
+                new_handler = Dependent(
-                    func_handler.prepend_parameterless(depend)
+                    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,11 +488,12 @@ 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`
 
-        当要获取的 `key` 不存在时接收用户新的一条消息再运行该函数，如果 `key` 已存在则直接继续运行
+        当要获取的 `key` 不存在时接收用户新的一条消息再运行该函数，
+        如果 `key` 已存在则直接继续运行
 
         参数:
             key: 参数名
@@ -409,17 +510,20 @@ class Matcher(metaclass=MatcherMeta):
                 return
             await matcher.reject(prompt)
 
-        _parameterless = [
+        _parameterless = (Depends(_key_getter), *(parameterless or ()))
-            Depends(_key_getter),
-            *(parameterless or []),
-        ]
 
         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):
+                new_handler = Dependent(
-                    func_handler.prepend_parameterless(depend)
+                    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)
 
@@ -437,7 +541,8 @@ class Matcher(metaclass=MatcherMeta):
 
         参数:
             message: 消息内容
-            kwargs: {ref}`nonebot.adapters.Bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
+            kwargs: {ref}`nonebot.adapters.Bot.send` 的参数，
+                请参考对应 adapter 的 bot 对象 api
         """
         bot = current_bot.get()
         event = current_event.get()
@@ -458,7 +563,8 @@ class Matcher(metaclass=MatcherMeta):
 
         参数:
             message: 消息内容
-            kwargs: {ref}`nonebot.adapters.Bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
+            kwargs: {ref}`nonebot.adapters.Bot.send` 的参数，
+                请参考对应 adapter 的 bot 对象 api
         """
         if message is not None:
             await cls.send(message, **kwargs)
@@ -474,7 +580,8 @@ class Matcher(metaclass=MatcherMeta):
 
         参数:
             prompt: 消息内容
-            kwargs: {ref}`nonebot.adapters.Bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
+            kwargs: {ref}`nonebot.adapters.Bot.send` 的参数，
+                请参考对应 adapter 的 bot 对象 api
         """
         if prompt is not None:
             await cls.send(prompt, **kwargs)
@@ -491,7 +598,8 @@ class Matcher(metaclass=MatcherMeta):
 
         参数:
             prompt: 消息内容
-            kwargs: {ref}`nonebot.adapters.Bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
+            kwargs: {ref}`nonebot.adapters.Bot.send` 的参数，
+                请参考对应 adapter 的 bot 对象 api
         """
         if prompt is not None:
             await cls.send(prompt, **kwargs)
@@ -510,7 +618,8 @@ class Matcher(metaclass=MatcherMeta):
         参数:
             key: 参数名
             prompt: 消息内容
-            kwargs: {ref}`nonebot.adapters.Bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
+            kwargs: {ref}`nonebot.adapters.Bot.send` 的参数，
+                请参考对应 adapter 的 bot 对象 api
         """
         matcher = current_matcher.get()
         matcher.set_target(ARG_KEY.format(key=key))
@@ -531,7 +640,8 @@ class Matcher(metaclass=MatcherMeta):
         参数:
             id: 消息 id
             prompt: 消息内容
-            kwargs: {ref}`nonebot.adapters.Bot.send` 的参数，请参考对应 adapter 的 bot 对象 api
+            kwargs: {ref}`nonebot.adapters.Bot.send` 的参数，
+                请参考对应 adapter 的 bot 对象 api
         """
         matcher = current_matcher.get()
         matcher.set_target(RECEIVE_KEY.format(id=id))
@@ -547,7 +657,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 +679,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,24 +723,59 @@ 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):
         """阻止事件传播"""
         self.block = True
 
-    async def update_type(self, bot: Bot, event: Event) -> str:
+    async def update_type(
+        self,
+        bot: Bot,
+        event: Event,
+        stack: Optional[AsyncExitStack] = None,
+        dependency_cache: Optional[T_DependencyCache] = None,
+    ) -> str:
         updater = self.__class__._default_type_updater
-        if not updater:
+        return (
-            return "message"
+            await updater(
-        return await updater(bot=bot, event=event, state=self.state, matcher=self)
+                bot=bot,
+                event=event,
+                state=self.state,
+                matcher=self,
+                stack=stack,
+                dependency_cache=dependency_cache,
+            )
+            if updater
+            else "message"
+        )
 
-    async def update_permission(self, bot: Bot, event: Event) -> Permission:
+    async def update_permission(
-        updater = self.__class__._default_permission_updater
+        self,
-        if not updater:
+        bot: Bot,
-            return USER(event.get_session_id(), perm=self.permission)
+        event: Event,
-        return await updater(bot=bot, event=event, state=self.state, matcher=self)
+        stack: Optional[AsyncExitStack] = None,
+        dependency_cache: Optional[T_DependencyCache] = None,
+    ) -> Permission:
+        if updater := self.__class__._default_permission_updater:
+            return await updater(
+                bot=bot,
+                event=event,
+                state=self.state,
+                matcher=self,
+                stack=stack,
+                dependency_cache=dependency_cache,
+            )
+        return Permission(User.from_event(event, perm=self.permission))
 
     async def resolve_reject(self):
         handler = current_handler.get()
@@ -608,6 +783,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 +804,34 @@ class Matcher(metaclass=MatcherMeta):
         dependency_cache: Optional[T_DependencyCache] = None,
     ):
         logger.trace(
-            f"Matcher {self} run with incoming args: "
+            f"{self} run with incoming args: "
-            f"bot={bot}, event={event}, state={state}"
+            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:
+        with self.ensure_context(bot, event):
-                handler = self.handlers.pop(0)
+            try:
-                current_handler.set(handler)
+                # Refresh preprocess state
-                logger.debug(f"Running handler {handler}")
+                self.state.update(state)
-                try:
+
-                    await handler(
+                while self.handlers:
-                        matcher=self,
+                    handler = self.handlers.pop(0)
-                        bot=bot,
+                    current_handler.set(handler)
-                        event=event,
+                    logger.debug(f"Running handler {handler}")
-                        state=self.state,
+                    try:
-                        stack=stack,
+                        await handler(
-                        dependency_cache=dependency_cache,
+                            matcher=self,
-                    )
+                            bot=bot,
-                except TypeMisMatch as e:
+                            event=event,
-                    logger.debug(
+                            state=self.state,
-                        f"Handler {handler} param {e.param.name} value {e.value} "
+                            stack=stack,
-                        f"mismatch type {e.param._type_display()}, skipped"
+                            dependency_cache=dependency_cache,
-                    )
+                        )
-                except SkippedException as e:
+                    except SkippedException:
-                    logger.debug(f"Handler {handler} skipped")
+                        logger.debug(f"Handler {handler} skipped")
-        except StopPropagation:
+            except StopPropagation:
-            self.block = True
+                self.block = True
-        finally:
+            finally:
-            logger.info(f"Matcher {self} running complete")
+                logger.info(f"{self} running complete")
-            current_bot.reset(b_t)
-            current_event.reset(e_t)
-            current_matcher.reset(m_t)
 
     # 运行handlers
     async def run(
@@ -669,10 +847,12 @@ class Matcher(metaclass=MatcherMeta):
 
         except RejectedException:
             await self.resolve_reject()
-            type_ = await self.update_type(bot, event)
+            type_ = await self.update_type(bot, event, stack, dependency_cache)
-            permission = await self.update_permission(bot, event)
+            permission = await self.update_permission(
+                bot, event, stack, dependency_cache
+            )
 
-            Matcher.new(
+            self.new(
                 type_,
                 Rule(),
                 permission,
@@ -680,18 +860,19 @@ class Matcher(metaclass=MatcherMeta):
                 temp=True,
                 priority=0,
                 block=True,
-                plugin=self.plugin,
+                source=self.__class__._source,
-                module=self.module,
+                expire_time=bot.config.session_expire_timeout,
-                expire_time=datetime.now() + 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 PausedException:
-            type_ = await self.update_type(bot, event)
+            type_ = await self.update_type(bot, event, stack, dependency_cache)
-            permission = await self.update_permission(bot, event)
+            permission = await self.update_permission(
+                bot, event, stack, dependency_cache
+            )
 
-            Matcher.new(
+            self.new(
                 type_,
                 Rule(),
                 permission,
@@ -699,23 +880,11 @@ class Matcher(metaclass=MatcherMeta):
                 temp=True,
                 priority=0,
                 block=True,
-                plugin=self.plugin,
+                source=self.__class__._source,
-                module=self.module,
+                expire_time=bot.config.session_expire_timeout,
-                expire_time=datetime.now() + 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,22 @@
 import asyncio
 import inspect
-import warnings
+from typing_extensions import Self, Annotated, override
-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,
+    Union,
+    Literal,
+    Callable,
+    Optional,
+    cast,
+)
 
-from pydantic.fields import Required, Undefined, ModelField
+from pydantic.typing import get_args, get_origin
+from pydantic.fields import Required, FieldInfo, 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
@@ -26,6 +34,23 @@ if TYPE_CHECKING:
     from nonebot.matcher import Matcher
     from nonebot.adapters import Bot, Event
 
+EXTRA_FIELD_INFO = (
+    "gt",
+    "lt",
+    "ge",
+    "le",
+    "multiple_of",
+    "allow_inf_nan",
+    "max_digits",
+    "decimal_places",
+    "min_items",
+    "max_items",
+    "unique_items",
+    "min_length",
+    "max_length",
+    "regex",
+)
+
 
 class DependsInner:
     def __init__(
@@ -33,26 +58,31 @@ class DependsInner:
         dependency: Optional[T_Handler] = None,
         *,
         use_cache: bool = True,
+        validate: Union[bool, FieldInfo] = False,
     ) -> None:
         self.dependency = dependency
         self.use_cache = use_cache
+        self.validate = validate
 
     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})"
+        validate = f", validate={self.validate}" if self.validate else ""
+        return f"DependsInner({dep}{cache}{validate})"
 
 
 def Depends(
     dependency: Optional[T_Handler] = None,
     *,
     use_cache: bool = True,
+    validate: Union[bool, FieldInfo] = False,
 ) -> Any:
     """子依赖装饰器
 
     参数:
         dependency: 依赖函数。默认为参数的类型注释。
         use_cache: 是否使用缓存。默认为 `True`。
+        validate: 是否使用 Pydantic 类型校验。默认为 `False`。
 
     用法:
         ```python
@@ -65,51 +95,96 @@ def Depends(
             finally:
                 ...
 
-        async def handler(param_name: Any = Depends(depend_func), gen: Any = Depends(depend_gen_func)):
+        async def handler(
+            param_name: Any = Depends(depend_func),
+            gen: Any = Depends(depend_gen_func),
+        ):
             ...
         ```
     """
-    return DependsInner(dependency, use_cache=use_cache)
+    return DependsInner(dependency, use_cache=use_cache, validate=validate)
 
 
 class DependParam(Param):
-    """子依赖参数"""
+    """子依赖注入参数。
+
+    本注入解析所有子依赖注入，然后将它们的返回值作为参数值传递给父依赖。
+
+    本注入应该具有最高优先级，因此应该在其他参数之前检查。
+    """
+
+    def __repr__(self) -> str:
+        return f"Depends({self.extra['dependent']})"
 
     @classmethod
+    def _from_field(
+        cls, sub_dependent: Dependent, use_cache: bool, validate: Union[bool, FieldInfo]
+    ) -> Self:
+        kwargs = {}
+        if isinstance(validate, FieldInfo):
+            kwargs.update((k, getattr(validate, k)) for k in EXTRA_FIELD_INFO)
+
+        return cls(
+            Required,
+            validate=bool(validate),
+            **kwargs,
+            dependent=sub_dependent,
+            use_cache=use_cache,
+        )
+
+    @classmethod
+    @override
     def _check_param(
-        cls,
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
-        dependent: Dependent,
+    ) -> Optional[Self]:
-        name: str,
+        type_annotation, depends_inner = param.annotation, None
-        param: inspect.Parameter,
+        # extract type annotation and dependency from Annotated
-    ) -> Optional["DependParam"]:
+        if get_origin(param.annotation) is Annotated:
-        if isinstance(param.default, DependsInner):
+            type_annotation, *extra_args = get_args(param.annotation)
-            dependency: T_Handler
+            depends_inner = next(
-            if param.default.dependency is None:
+                (x for x in extra_args if isinstance(x, DependsInner)), None
-                assert param.annotation is not param.empty, "Dependency cannot be empty"
-                dependency = param.annotation
-            else:
-                dependency = param.default.dependency
-            sub_dependent = Dependent[Any].parse(
-                call=dependency,
-                allow_types=dependent.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
             )
 
+        # param default value takes higher priority
+        depends_inner = (
+            param.default if isinstance(param.default, DependsInner) else depends_inner
+        )
+        # not a dependent
+        if depends_inner is None:
+            return
+
+        dependency: T_Handler
+        # sub dependency is not specified, use type annotation
+        if depends_inner.dependency is None:
+            assert (
+                type_annotation is not inspect.Signature.empty
+            ), "Dependency cannot be empty"
+            dependency = type_annotation
+        else:
+            dependency = depends_inner.dependency
+        # parse sub dependency
+        sub_dependent = Dependent[Any].parse(
+            call=dependency,
+            allow_types=allow_types,
+        )
+
+        return cls._from_field(
+            sub_dependent, depends_inner.use_cache, depends_inner.validate
+        )
+
     @classmethod
+    @override
     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)
+            return cls._from_field(dependent, value.use_cache, value.validate)
 
+    @override
     async def _solve(
         self,
         stack: Optional[AsyncExitStack] = None,
@@ -120,8 +195,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 = cast(Callable[..., Any], sub_dependent.call)
-        call = sub_dependent.call
 
         # solve sub dependency with current cache
         sub_values = await sub_dependent.solve(
@@ -133,7 +207,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
@@ -144,157 +218,201 @@ 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
+    @override
-
+    async def _check(self, **kwargs: Any) -> None:
-
+        # run sub dependent pre-checkers
-class _BotChecker(Param):
+        sub_dependent: Dependent = self.extra["dependent"]
-    async def _solve(self, bot: "Bot", **kwargs: Any) -> Any:
+        await sub_dependent.check(**kwargs)
-        field: ModelField = self.extra["field"]
-        try:
-            return check_field_type(field, bot)
-        except TypeMisMatch:
-            logger.debug(
-                f"Bot type {type(bot)} not match "
-                f"annotation {field._type_display()}, ignored"
-            )
-            raise
 
 
 class BotParam(Param):
-    """{ref}`nonebot.adapters.Bot` 参数"""
+    """{ref}`nonebot.adapters.Bot` 注入参数。
+
+    本注入解析所有类型为且仅为 {ref}`nonebot.adapters.Bot` 及其子类或 `None` 的参数。
+
+    为保证兼容性，本注入还会解析名为 `bot` 且没有类型注解的参数。
+    """
+
+    def __repr__(self) -> str:
+        return (
+            "BotParam("
+            + (
+                repr(cast(ModelField, checker).type_)
+                if (checker := self.extra.get("checker"))
+                else ""
+            )
+            + ")"
+        )
 
     @classmethod
+    @override
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
-    ) -> Optional["BotParam"]:
+    ) -> Optional[Self]:
         from nonebot.adapters import Bot
 
-        if param.default == param.empty:
+        # param type is Bot(s) or subclass(es) of Bot or None
-            if generic_check_issubclass(param.annotation, Bot):
+        if generic_check_issubclass(param.annotation, Bot):
-                if param.annotation is not Bot:
+            checker: Optional[ModelField] = None
-                    dependent.pre_checkers.append(
+            if param.annotation is not Bot:
-                        _BotChecker(
+                checker = ModelField(
-                            Required,
+                    name=param.name,
-                            field=ModelField(
+                    type_=param.annotation,
-                                name=name,
+                    class_validators=None,
-                                type_=param.annotation,
+                    model_config=CustomConfig,
-                                class_validators=None,
+                    default=None,
-                                model_config=CustomConfig,
+                    required=True,
-                                default=None,
+                )
-                                required=True,
+            return cls(Required, checker=checker)
-                            ),
+        # legacy: param is named "bot" and has no type annotation
-                        )
+        elif param.annotation == param.empty and param.name == "bot":
-                    )
+            return cls(Required)
-                return cls(Required)
-            elif param.annotation == param.empty and name == "bot":
-                return cls(Required)
 
+    @override
     async def _solve(self, bot: "Bot", **kwargs: Any) -> Any:
         return bot
 
-
+    @override
-class _EventChecker(Param):
+    async def _check(self, bot: "Bot", **kwargs: Any) -> None:
-    async def _solve(self, event: "Event", **kwargs: Any) -> Any:
+        if checker := self.extra.get("checker"):
-        field: ModelField = self.extra["field"]
+            check_field_type(checker, bot)
-        try:
-            return check_field_type(field, event)
-        except TypeMisMatch:
-            logger.debug(
-                f"Event type {type(event)} not match "
-                f"annotation {field._type_display()}, ignored"
-            )
-            raise
 
 
 class EventParam(Param):
-    """{ref}`nonebot.adapters.Event` 参数"""
+    """{ref}`nonebot.adapters.Event` 注入参数
+
+    本注入解析所有类型为且仅为 {ref}`nonebot.adapters.Event` 及其子类或 `None` 的参数。
+
+    为保证兼容性，本注入还会解析名为 `event` 且没有类型注解的参数。
+    """
+
+    def __repr__(self) -> str:
+        return (
+            "EventParam("
+            + (
+                repr(cast(ModelField, checker).type_)
+                if (checker := self.extra.get("checker"))
+                else ""
+            )
+            + ")"
+        )
 
     @classmethod
+    @override
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
-    ) -> Optional["EventParam"]:
+    ) -> Optional[Self]:
         from nonebot.adapters import Event
 
-        if param.default == param.empty:
+        # param type is Event(s) or subclass(es) of Event or None
-            if generic_check_issubclass(param.annotation, Event):
+        if generic_check_issubclass(param.annotation, Event):
-                if param.annotation is not Event:
+            checker: Optional[ModelField] = None
-                    dependent.pre_checkers.append(
+            if param.annotation is not Event:
-                        _EventChecker(
+                checker = ModelField(
-                            Required,
+                    name=param.name,
-                            field=ModelField(
+                    type_=param.annotation,
-                                name=name,
+                    class_validators=None,
-                                type_=param.annotation,
+                    model_config=CustomConfig,
-                                class_validators=None,
+                    default=None,
-                                model_config=CustomConfig,
+                    required=True,
-                                default=None,
+                )
-                                required=True,
+            return cls(Required, checker=checker)
-                            ),
+        # legacy: param is named "event" and has no type annotation
-                        )
+        elif param.annotation == param.empty and param.name == "event":
-                    )
+            return cls(Required)
-                return cls(Required)
-            elif param.annotation == param.empty and name == "event":
-                return cls(Required)
 
+    @override
     async def _solve(self, event: "Event", **kwargs: Any) -> Any:
         return event
 
-
+    @override
-class StateInner(T_State):
+    async def _check(self, event: "Event", **kwargs: Any) -> Any:
-    ...
+        if checker := self.extra.get("checker", None):
-
+            check_field_type(checker, event)
-
-def State() -> T_State:
-    """**Deprecated**: 事件处理状态参数，请直接使用 {ref}`nonebot.typing.T_State`"""
-    warnings.warn("State() is deprecated, use `T_State` instead", DeprecationWarning)
-    return StateInner()
 
 
 class StateParam(Param):
-    """事件处理状态参数"""
+    """事件处理状态注入参数
+
+    本注入解析所有类型为 `T_State` 的参数。
+
+    为保证兼容性，本注入还会解析名为 `state` 且没有类型注解的参数。
+    """
+
+    def __repr__(self) -> str:
+        return "StateParam()"
 
     @classmethod
+    @override
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
-    ) -> Optional["StateParam"]:
+    ) -> Optional[Self]:
-        if isinstance(param.default, StateInner):
+        # param type is T_State
+        if param.annotation is T_State:
+            return cls(Required)
+        # legacy: param is named "state" and has no type annotation
+        elif param.annotation == param.empty and param.name == "state":
             return cls(Required)
-        elif param.default == param.empty:
-            if param.annotation is T_State:
-                return cls(Required)
-            elif param.annotation == param.empty and name == "state":
-                return cls(Required)
 
+    @override
     async def _solve(self, state: T_State, **kwargs: Any) -> Any:
         return state
 
 
 class MatcherParam(Param):
-    """事件响应器实例参数"""
+    """事件响应器实例注入参数
+
+    本注入解析所有类型为且仅为 {ref}`nonebot.matcher.Matcher` 及其子类或 `None` 的参数。
+
+    为保证兼容性，本注入还会解析名为 `matcher` 且没有类型注解的参数。
+    """
+
+    def __repr__(self) -> str:
+        return "MatcherParam()"
 
     @classmethod
+    @override
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
-    ) -> Optional["MatcherParam"]:
+    ) -> Optional[Self]:
         from nonebot.matcher import Matcher
 
-        if generic_check_issubclass(param.annotation, Matcher) or (
+        # param type is Matcher(s) or subclass(es) of Matcher or None
-            param.annotation == param.empty and name == "matcher"
+        if generic_check_issubclass(param.annotation, Matcher):
-        ):
+            checker: Optional[ModelField] = None
+            if param.annotation is not Matcher:
+                checker = ModelField(
+                    name=param.name,
+                    type_=param.annotation,
+                    class_validators=None,
+                    model_config=CustomConfig,
+                    default=None,
+                    required=True,
+                )
+            return cls(Required, checker=checker)
+        # legacy: param is named "matcher" and has no type annotation
+        elif param.annotation == param.empty and param.name == "matcher":
             return cls(Required)
 
+    @override
     async def _solve(self, matcher: "Matcher", **kwargs: Any) -> Any:
         return matcher
 
+    @override
+    async def _check(self, matcher: "Matcher", **kwargs: Any) -> Any:
+        if checker := self.extra.get("checker", None):
+            check_field_type(checker, matcher)
+
 
 class ArgInner:
     def __init__(
@@ -303,34 +421,54 @@ 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 参数消息"""
+    """Arg 参数消息"""
     return ArgInner(key, "message")
 
 
 def ArgStr(key: Optional[str] = None) -> str:
-    """`got` 的 Arg 参数消息文本"""
+    """Arg 参数消息文本"""
     return ArgInner(key, "str")  # type: ignore
 
 
 def ArgPlainText(key: Optional[str] = None) -> str:
-    """`got` 的 Arg 参数消息纯文本"""
+    """Arg 参数消息纯文本"""
     return ArgInner(key, "plaintext")  # type: ignore
 
 
 class ArgParam(Param):
-    """`got` 的 Arg 参数"""
+    """Arg 注入参数
+
+    本注入解析事件响应器操作 `got` 所获取的参数。
+
+    可以通过 `Arg`、`ArgStr`、`ArgPlainText` 等函数参数 `key` 指定获取的参数，
+    留空则会根据参数名称获取。
+    """
+
+    def __repr__(self) -> str:
+        return f"ArgParam(key={self.extra['key']!r}, type={self.extra['type']!r})"
 
     @classmethod
+    @override
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
-    ) -> Optional["ArgParam"]:
+    ) -> Optional[Self]:
         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
+            )
+        elif get_origin(param.annotation) is Annotated:
+            for arg in get_args(param.annotation):
+                if isinstance(arg, ArgInner):
+                    return cls(Required, key=arg.key or param.name, type=arg.type)
 
     async def _solve(self, matcher: "Matcher", **kwargs: Any) -> Any:
-        message = matcher.get_arg(self.extra["key"])
+        key: str = self.extra["key"]
+        message = matcher.get_arg(key)
         if message is None:
             return message
         if self.extra["type"] == "message":
@@ -342,31 +480,53 @@ class ArgParam(Param):
 
 
 class ExceptionParam(Param):
-    """`run_postprocessor` 的异常参数"""
+    """{ref}`nonebot.message.run_postprocessor` 的异常注入参数
+
+    本注入解析所有类型为 `Exception` 或 `None` 的参数。
+
+    为保证兼容性，本注入还会解析名为 `exception` 且没有类型注解的参数。
+    """
+
+    def __repr__(self) -> str:
+        return "ExceptionParam()"
 
     @classmethod
+    @override
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
-    ) -> Optional["ExceptionParam"]:
+    ) -> Optional[Self]:
-        if generic_check_issubclass(param.annotation, Exception) or (
+        # param type is Exception(s) or subclass(es) of Exception or None
-            param.annotation == param.empty and name == "exception"
+        if generic_check_issubclass(param.annotation, Exception):
-        ):
+            return cls(Required)
+        # legacy: param is named "exception" and has no type annotation
+        elif param.annotation == param.empty and param.name == "exception":
             return cls(Required)
 
+    @override
     async def _solve(self, exception: Optional[Exception] = None, **kwargs: Any) -> Any:
         return exception
 
 
 class DefaultParam(Param):
-    """默认值参数"""
+    """默认值注入参数
+
+    本注入解析所有剩余未能解析且具有默认值的参数。
+
+    本注入参数应该具有最低优先级，因此应该在所有其他注入参数之后使用。
+    """
+
+    def __repr__(self) -> str:
+        return f"DefaultParam(default={self.default!r})"
 
     @classmethod
+    @override
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
+        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
-    ) -> Optional["DefaultParam"]:
+    ) -> Optional[Self]:
         if param.default != param.empty:
             return cls(param.default)
 
+    @override
     async def _solve(self, **kwargs: Any) -> Any:
         return Undefined
 

nonebot/internal/permission.py

@@ -1,6 +1,7 @@
 import asyncio
+from typing_extensions import Self
 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 +38,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,
@@ -54,7 +58,7 @@ class Permission:
         stack: Optional[AsyncExitStack] = None,
         dependency_cache: Optional[T_DependencyCache] = None,
     ) -> bool:
-        """检查是否满足某个权限
+        """检查是否满足某个权限。
 
         参数:
             bot: Bot 对象
@@ -106,7 +110,7 @@ class Permission:
 
 
 class User:
-    """检查当前事件是否属于指定会话
+    """检查当前事件是否属于指定会话。
 
     参数:
         users: 会话 ID 元组
@@ -121,19 +125,63 @@ class User:
         self.users = users
         self.perm = perm
 
-    async def __call__(self, bot: Bot, event: Event) -> bool:
+    def __repr__(self) -> str:
-        return bool(
+        return (
-            event.get_session_id() in self.users
+            f"User(users={self.users}"
-            and (self.perm is None or await self.perm(bot, event))
+            + (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(
+            session in self.users and (self.perm is None or await self.perm(bot, event))
+        )
+
+    @classmethod
+    def _clean_permission(cls, perm: Permission) -> Optional[Permission]:
+        if len(perm.checkers) == 1 and isinstance(
+            user_perm := tuple(perm.checkers)[0].call, cls
+        ):
+            return user_perm.perm
+        return perm
+
+    @classmethod
+    def from_event(cls, event: Event, perm: Optional[Permission] = None) -> Self:
+        """从事件中获取会话 ID。
+
+        如果 `perm` 中仅有 `User` 类型的权限检查函数，则会去除原有的会话 ID 限制。
+
+        参数:
+            event: Event 对象
+            perm: 需同时满足的权限
+        """
+        return cls((event.get_session_id(),), perm=perm and cls._clean_permission(perm))
+
+    @classmethod
+    def from_permission(cls, *users: str, perm: Optional[Permission] = None) -> Self:
+        """指定会话与权限。
+
+        如果 `perm` 中仅有 `User` 类型的权限检查函数，则会去除原有的会话 ID 限制。
+
+        参数:
+            users: 会话白名单
+            perm: 需同时满足的权限
+        """
+        return cls(users, perm=perm and cls._clean_permission(perm))
+
 
 def USER(*users: str, perm: Optional[Permission] = None):
-    """匹配当前事件属于指定会话
+    """匹配当前事件属于指定会话。
+
+    如果 `perm` 中仅有 `User` 类型的权限检查函数，则会去除原有检查函数的会话 ID 限制。
 
     参数:
         user: 会话白名单
         perm: 需要同时满足的权限
     """
 
-    return Permission(User(users, perm))
+    return Permission(User.from_permission(*users, perm=perm))

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

@@ -2,7 +2,7 @@
 
 NoneBot 使用 [`loguru`][loguru] 来记录日志信息。
 
-自定义 logger 请参考 [自定义日志](https://v2.nonebot.dev/docs/tutorial/custom-logger)
+自定义 logger 请参考 [自定义日志](https://nonebot.dev/docs/appendices/log)
 以及 [`loguru`][loguru] 文档。
 
 [loguru]: https://github.com/Delgan/loguru
@@ -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 loguru import Logger, Record
-
-    from nonebot.plugin import Plugin
 
 # logger = logging.getLogger("nonebot")
 logger: "Logger" = loguru.logger
@@ -47,32 +45,16 @@ 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:
             level = record.levelno
 
-        frame, depth = logging.currentframe(), 2
+        frame, depth = sys._getframe(6), 6
         while frame and frame.f_code.co_filename == logging.__file__:
             frame = frame.f_back
             depth += 1
@@ -82,9 +64,13 @@ class LoguruHandler(logging.Handler):  # pragma: no cover
         )
 
 
-logger.remove()
+def default_filter(record: "Record"):
-default_filter: Filter = Filter()
+    """默认的日志过滤器，根据 `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,6 +79,8 @@ default_format: str = (
     "{message}"
 )
 """默认日志格式"""
+
+logger.remove()
 logger_id = logger.add(
     sys.stdout,
     level=0,
@@ -100,5 +88,6 @@ logger_id = logger.add(
     filter=default_filter,
     format=default_format,
 )
+"""默认日志处理器 id"""
 
-__autodoc__ = {"Filter": False, "LoguruHandler": False}
+__autodoc__ = {"logger_id": False}

nonebot/matcher.py

@@ -8,11 +8,18 @@ FrontMatter:
 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 MatcherSource as MatcherSource
 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,11 +76,14 @@ RUN_POSTPCS_PARAMS = [
     ArgParam,
     MatcherParam,
     DefaultParam,
-]
+)
 
 
 def event_preprocessor(func: T_EventPreProcessor) -> T_EventPreProcessor:
-    """事件预处理。装饰一个函数，使它在每次接收到事件并分发给各响应器之前执行。"""
+    """事件预处理。
+
+    装饰一个函数，使它在每次接收到事件并分发给各响应器之前执行。
+    """
     _event_preprocessors.add(
         Dependent[Any].parse(call=func, allow_types=EVENT_PCS_PARAMS)
     )
@@ -87,7 +91,10 @@ def event_preprocessor(func: T_EventPreProcessor) -> T_EventPreProcessor:
 
 
 def event_postprocessor(func: T_EventPostProcessor) -> T_EventPostProcessor:
-    """事件后处理。装饰一个函数，使它在每次接收到事件并分发给各响应器之后执行。"""
+    """事件后处理。
+
+    装饰一个函数，使它在每次接收到事件并分发给各响应器之后执行。
+    """
     _event_postprocessors.add(
         Dependent[Any].parse(call=func, allow_types=EVENT_PCS_PARAMS)
     )
@@ -95,7 +102,10 @@ def event_postprocessor(func: T_EventPostProcessor) -> T_EventPostProcessor:
 
 
 def run_preprocessor(func: T_RunPreProcessor) -> T_RunPreProcessor:
-    """运行预处理。装饰一个函数，使它在每次事件响应器运行前执行。"""
+    """运行预处理。
+
+    装饰一个函数，使它在每次事件响应器运行前执行。
+    """
     _run_preprocessors.add(
         Dependent[Any].parse(call=func, allow_types=RUN_PREPCS_PARAMS)
     )
@@ -103,47 +113,262 @@ def run_preprocessor(func: T_RunPreProcessor) -> T_RunPreProcessor:
 
 
 def run_postprocessor(func: T_RunPostProcessor) -> T_RunPostProcessor:
-    """运行后处理。装饰一个函数，使它在每次事件响应器运行后执行。"""
+    """运行后处理。
+
+    装饰一个函数，使它在每次事件响应器运行后执行。
+    """
     _run_postprocessors.add(
         Dependent[Any].parse(call=func, allow_types=RUN_POSTPCS_PARAMS)
     )
     return func
 
 
+async def _apply_event_preprocessors(
+    bot: "Bot",
+    event: "Event",
+    state: T_State,
+    stack: Optional[AsyncExitStack] = None,
+    dependency_cache: Optional[T_DependencyCache] = None,
+    show_log: bool = True,
+) -> bool:
+    """运行事件预处理。
+
+    参数:
+        bot: Bot 对象
+        event: Event 对象
+        state: 会话状态
+        stack: 异步上下文栈
+        dependency_cache: 依赖缓存
+        show_log: 是否显示日志
+
+    返回:
+        是否继续处理事件
+    """
+    if not _event_preprocessors:
+        return True
+
+    if show_log:
+        logger.debug("Running PreProcessors...")
+
+    try:
+        await asyncio.gather(
+            *(
+                run_coro_with_catch(
+                    proc(
+                        bot=bot,
+                        event=event,
+                        state=state,
+                        stack=stack,
+                        dependency_cache=dependency_cache,
+                    ),
+                    (SkippedException,),
+                )
+                for proc in _event_preprocessors
+            )
+        )
+    except IgnoredException:
+        logger.opt(colors=True).info(
+            f"Event {escape_tag(event.get_event_name())} is <b>ignored</b>"
+        )
+        return False
+    except Exception as e:
+        logger.opt(colors=True, exception=e).error(
+            "<r><bg #f8bbd0>Error when running EventPreProcessors. "
+            "Event ignored!</bg #f8bbd0></r>"
+        )
+        return False
+
+    return True
+
+
+async def _apply_event_postprocessors(
+    bot: "Bot",
+    event: "Event",
+    state: T_State,
+    stack: Optional[AsyncExitStack] = None,
+    dependency_cache: Optional[T_DependencyCache] = None,
+    show_log: bool = True,
+) -> None:
+    """运行事件后处理。
+
+    参数:
+        bot: Bot 对象
+        event: Event 对象
+        state: 会话状态
+        stack: 异步上下文栈
+        dependency_cache: 依赖缓存
+        show_log: 是否显示日志
+    """
+    if not _event_postprocessors:
+        return
+
+    if show_log:
+        logger.debug("Running PostProcessors...")
+
+    try:
+        await asyncio.gather(
+            *(
+                run_coro_with_catch(
+                    proc(
+                        bot=bot,
+                        event=event,
+                        state=state,
+                        stack=stack,
+                        dependency_cache=dependency_cache,
+                    ),
+                    (SkippedException,),
+                )
+                for proc in _event_postprocessors
+            )
+        )
+    except Exception as e:
+        logger.opt(colors=True, exception=e).error(
+            "<r><bg #f8bbd0>Error when running EventPostProcessors</bg #f8bbd0></r>"
+        )
+
+
+async def _apply_run_preprocessors(
+    bot: "Bot",
+    event: "Event",
+    state: T_State,
+    matcher: Matcher,
+    stack: Optional[AsyncExitStack] = None,
+    dependency_cache: Optional[T_DependencyCache] = None,
+) -> bool:
+    """运行事件响应器运行前处理。
+
+    参数:
+        bot: Bot 对象
+        event: Event 对象
+        state: 会话状态
+        matcher: 事件响应器
+        stack: 异步上下文栈
+        dependency_cache: 依赖缓存
+
+    返回:
+        是否继续处理事件
+    """
+    if not _run_preprocessors:
+        return True
+
+    # ensure matcher function can be correctly called
+    with matcher.ensure_context(bot, event):
+        try:
+            await asyncio.gather(
+                *(
+                    run_coro_with_catch(
+                        proc(
+                            matcher=matcher,
+                            bot=bot,
+                            event=event,
+                            state=state,
+                            stack=stack,
+                            dependency_cache=dependency_cache,
+                        ),
+                        (SkippedException,),
+                    )
+                    for proc in _run_preprocessors
+                )
+            )
+        except IgnoredException:
+            logger.opt(colors=True).info(f"{matcher} running is <b>cancelled</b>")
+            return False
+        except Exception as e:
+            logger.opt(colors=True, exception=e).error(
+                "<r><bg #f8bbd0>Error when running RunPreProcessors. "
+                "Running cancelled!</bg #f8bbd0></r>"
+            )
+            return False
+
+    return True
+
+
+async def _apply_run_postprocessors(
+    bot: "Bot",
+    event: "Event",
+    matcher: Matcher,
+    exception: Optional[Exception] = None,
+    stack: Optional[AsyncExitStack] = None,
+    dependency_cache: Optional[T_DependencyCache] = None,
+) -> None:
+    """运行事件响应器运行后处理。
+
+    参数:
+        bot: Bot 对象
+        event: Event 对象
+        matcher: 事件响应器
+        exception: 事件响应器运行异常
+        stack: 异步上下文栈
+        dependency_cache: 依赖缓存
+    """
+    if not _run_postprocessors:
+        return
+
+    with matcher.ensure_context(bot, event):
+        try:
+            await asyncio.gather(
+                *(
+                    run_coro_with_catch(
+                        proc(
+                            matcher=matcher,
+                            exception=exception,
+                            bot=bot,
+                            event=event,
+                            state=matcher.state,
+                            stack=stack,
+                            dependency_cache=dependency_cache,
+                        ),
+                        (SkippedException,),
+                    )
+                    for proc in _run_postprocessors
+                )
+            )
+        except Exception as e:
+            logger.opt(colors=True, exception=e).error(
+                "<r><bg #f8bbd0>Error when running RunPostProcessors</bg #f8bbd0></r>"
+            )
+
+
 async def _check_matcher(
-    priority: int,
     Matcher: Type[Matcher],
     bot: "Bot",
     event: "Event",
     state: T_State,
     stack: Optional[AsyncExitStack] = None,
     dependency_cache: Optional[T_DependencyCache] = None,
-) -> None:
+) -> bool:
+    """检查事件响应器是否符合运行条件。
+
+    请注意，过时的事件响应器将被**销毁**。对于未过时的事件响应器，将会一次检查其响应类型、权限和规则。
+
+    参数:
+        Matcher: 要检查的事件响应器
+        bot: Bot 对象
+        event: Event 对象
+        state: 会话状态
+        stack: 异步上下文栈
+        dependency_cache: 依赖缓存
+
+    返回:
+        bool: 是否符合运行条件
+    """
     if Matcher.expire_time and datetime.now() > Matcher.expire_time:
-        try:
+        with contextlib.suppress(Exception):
-            matchers[priority].remove(Matcher)
+            Matcher.destroy()
-        except Exception:
+        return False
-            pass
-        return
 
     try:
         if not await Matcher.check_perm(
             bot, event, stack, dependency_cache
         ) or not await Matcher.check_rule(bot, event, state, stack, dependency_cache):
-            return
+            return False
     except Exception as e:
         logger.opt(colors=True, exception=e).error(
             f"<r><bg #f8bbd0>Rule check failed for {Matcher}.</bg #f8bbd0></r>"
         )
-        return
+        return False
 
-    if Matcher.temp:
+    return True
-        try:
-            matchers[priority].remove(Matcher)
-        except Exception:
-            pass
-
-    await _run_matcher(Matcher, bot, event, state, stack, dependency_cache)
 
 
 async def _run_matcher(
@@ -154,80 +379,99 @@ async def _run_matcher(
     stack: Optional[AsyncExitStack] = None,
     dependency_cache: Optional[T_DependencyCache] = None,
 ) -> None:
+    """运行事件响应器。
+
+    临时事件响应器将在运行前被**销毁**。
+
+    参数:
+        Matcher: 事件响应器
+        bot: Bot 对象
+        event: Event 对象
+        state: 会话状态
+        stack: 异步上下文栈
+        dependency_cache: 依赖缓存
+
+    异常:
+        StopPropagation: 阻止事件继续传播
+    """
     logger.info(f"Event will be handled by {Matcher}")
 
+    if Matcher.temp:
+        with contextlib.suppress(Exception):
+            Matcher.destroy()
+
     matcher = Matcher()
 
-    coros = list(
+    if not await _apply_run_preprocessors(
-        map(
+        bot=bot,
-            lambda x: run_coro_with_catch(
+        event=event,
-                x(
+        state=state,
-                    matcher=matcher,
+        matcher=matcher,
-                    bot=bot,
+        stack=stack,
-                    event=event,
+        dependency_cache=dependency_cache,
-                    state=state,
+    ):
-                    stack=stack,
+        return
-                    dependency_cache=dependency_cache,
-                ),
-                (SkippedException,),
-            ),
-            _run_preprocessors,
-        )
-    )
-    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
 
     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(
+    await _apply_run_postprocessors(
-        map(
+        bot=bot,
-            lambda x: run_coro_with_catch(
+        event=event,
-                x(
+        matcher=matcher,
-                    matcher=matcher,
+        exception=exception,
-                    exception=exception,
+        stack=stack,
-                    bot=bot,
+        dependency_cache=dependency_cache,
-                    event=event,
-                    state=state,
-                    stack=stack,
-                    dependency_cache=dependency_cache,
-                ),
-                (SkippedException,),
-            ),
-            _run_postprocessors,
-        )
     )
-    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>"
-            )
 
     if matcher.block:
         raise StopPropagation
-    return
+
+
+async def check_and_run_matcher(
+    Matcher: Type[Matcher],
+    bot: "Bot",
+    event: "Event",
+    state: T_State,
+    stack: Optional[AsyncExitStack] = None,
+    dependency_cache: Optional[T_DependencyCache] = None,
+) -> None:
+    """检查并运行事件响应器。
+
+    参数:
+        Matcher: 事件响应器
+        bot: Bot 对象
+        event: Event 对象
+        state: 会话状态
+        stack: 异步上下文栈
+        dependency_cache: 依赖缓存
+    """
+    if not await _check_matcher(
+        Matcher=Matcher,
+        bot=bot,
+        event=event,
+        state=state,
+        stack=stack,
+        dependency_cache=dependency_cache,
+    ):
+        return
+
+    await _run_matcher(
+        Matcher=Matcher,
+        bot=bot,
+        event=event,
+        state=state,
+        stack=stack,
+        dependency_cache=dependency_cache,
+    )
 
 
 async def handle_event(bot: "Bot", event: "Event") -> None:
@@ -244,7 +488,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:
@@ -255,38 +499,16 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
     state: Dict[Any, Any] = {}
     dependency_cache: T_DependencyCache = {}
 
+    # create event scope context
     async with AsyncExitStack() as stack:
-        coros = list(
+        if not await _apply_event_preprocessors(
-            map(
+            bot=bot,
-                lambda x: run_coro_with_catch(
+            event=event,
-                    x(
+            state=state,
-                        bot=bot,
+            stack=stack,
-                        event=event,
+            dependency_cache=dependency_cache,
-                        state=state,
+        ):
-                        stack=stack,
+            return
-                        dependency_cache=dependency_cache,
-                    ),
-                    (SkippedException,),
-                ),
-                _event_preprocessors,
-            )
-        )
-        if coros:
-            try:
-                if show_log:
-                    logger.debug("Running PreProcessors...")
-                await asyncio.gather(*coros)
-            except IgnoredException as e:
-                logger.opt(colors=True).info(
-                    f"Event {escape_tag(event.get_event_name())} is <b>ignored</b>"
-                )
-                return
-            except Exception as e:
-                logger.opt(colors=True, exception=e).error(
-                    "<r><bg #f8bbd0>Error when running EventPreProcessors. "
-                    "Event ignored!</bg #f8bbd0></r>"
-                )
-                return
 
         # Trie Match
         try:
@@ -297,6 +519,7 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
             )
 
         break_flag = False
+        # iterate through all priority until stop propagation
         for priority in sorted(matchers.keys()):
             if break_flag:
                 break
@@ -305,14 +528,12 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
                 logger.debug(f"Checking for matchers in priority {priority}...")
 
             pending_tasks = [
-                _check_matcher(
+                check_and_run_matcher(
-                    priority, matcher, bot, event, state.copy(), stack, dependency_cache
+                    matcher, bot, event, state.copy(), stack, dependency_cache
                 )
                 for matcher in matchers[priority]
             ]
-
             results = await asyncio.gather(*pending_tasks, return_exceptions=True)
-
             for result in results:
                 if not isinstance(result, Exception):
                     continue
@@ -324,27 +545,7 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
                         "<r><bg #f8bbd0>Error when checking Matcher.</bg #f8bbd0></r>"
                     )
 
-        coros = list(
+        if show_log:
-            map(
+            logger.debug("Checking for matchers completed")
-                lambda x: run_coro_with_catch(
+
-                    x(
+        await _apply_event_postprocessors(bot, event, state, stack, dependency_cache)
-                        bot=bot,
-                        event=event,
-                        state=state,
-                        stack=stack,
-                        dependency_cache=dependency_cache,
-                    ),
-                    (SkippedException,),
-                ),
-                _event_postprocessors,
-            )
-        )
-        if coros:
-            try:
-                if show_log:
-                    logger.debug("Running PostProcessors...")
-                await asyncio.gather(*coros)
-            except Exception as e:
-                logger.opt(colors=True, exception=e).error(
-                    "<r><bg #f8bbd0>Error when running EventPostProcessors</bg #f8bbd0></r>"
-                )

nonebot/params.py

@@ -5,17 +5,16 @@ FrontMatter:
     description: nonebot.params 模块
 """
 
-from typing import Any, Dict, List, Tuple, Optional
+from typing import Any, Dict, List, Match, 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
@@ -26,14 +25,17 @@ from nonebot.internal.params import ExceptionParam as ExceptionParam
 from nonebot.consts import (
     CMD_KEY,
     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,
+    CMD_WHITESPACE_KEY,
 )
 
 
@@ -109,16 +111,25 @@ def CommandStart() -> str:
     return Depends(_command_start)
 
 
+def _command_whitespace(state: T_State) -> str:
+    return state[PREFIX_KEY][CMD_WHITESPACE_KEY]
+
+
+def CommandWhitespace() -> str:
+    """消息命令与参数之间的空白"""
+    return Depends(_command_whitespace)
+
+
 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]
 
 
@@ -127,17 +138,26 @@ def ShellCommandArgv() -> Any:
     return Depends(_shell_command_argv, use_cache=False)
 
 
-def _regex_matched(state: T_State) -> str:
+def _regex_matched(state: T_State) -> Match[str]:
     return state[REGEX_MATCHED]
 
 
-def RegexMatched() -> str:
+def RegexMatched() -> Match[str]:
     """正则匹配结果"""
     return Depends(_regex_matched, use_cache=False)
 
 
-def _regex_group(state: T_State):
+def _regex_str(state: T_State) -> str:
-    return state[REGEX_GROUP]
+    return _regex_matched(state).group()
+
+
+def RegexStr() -> str:
+    """正则匹配结果文本"""
+    return Depends(_regex_str, use_cache=False)
+
+
+def _regex_group(state: T_State) -> Tuple[Any, ...]:
+    return _regex_matched(state).groups()
 
 
 def RegexGroup() -> Tuple[Any, ...]:
@@ -145,8 +165,8 @@ 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]
+    return _regex_matched(state).groupdict()
 
 
 def RegexDict() -> Dict[str, Any]:
@@ -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

@@ -1,7 +1,8 @@
 """本模块是 {ref}`nonebot.matcher.Matcher.permission` 的类型定义。
 
-每个 {ref}`nonebot.matcher.Matcher` 拥有一个 {ref}`nonebot.permission.Permission` ，
+每个{ref}`事件响应器 <nonebot.matcher.Matcher>`
-其中是 `PermissionChecker` 的集合，只要有一个 `PermissionChecker` 检查结果为 `True` 时就会继续运行。
+拥有一个 {ref}`nonebot.permission.Permission`，其中是 `PermissionChecker` 的集合。
+只要有一个 `PermissionChecker` 检查结果为 `True` 时就会继续运行。
 
 FrontMatter:
     sidebar_position: 6
@@ -20,6 +21,9 @@ class Message:
 
     __slots__ = ()
 
+    def __repr__(self) -> str:
+        return "Message()"
+
     async def __call__(self, type: str = EventType()) -> bool:
         return type == "message"
 
@@ -29,6 +33,9 @@ class Notice:
 
     __slots__ = ()
 
+    def __repr__(self) -> str:
+        return "Notice()"
+
     async def __call__(self, type: str = EventType()) -> bool:
         return type == "notice"
 
@@ -38,6 +45,9 @@ class Request:
 
     __slots__ = ()
 
+    def __repr__(self) -> str:
+        return "Request()"
+
     async def __call__(self, type: str = EventType()) -> bool:
         return type == "request"
 
@@ -47,6 +57,9 @@ class MetaEvent:
 
     __slots__ = ()
 
+    def __repr__(self) -> str:
+        return "MetaEvent()"
+
     async def __call__(self, type: str = EventType()) -> bool:
         return type == "meta_event"
 
@@ -78,16 +91,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 (
+        try:
-            f"{bot.adapter.get_name().split(maxsplit=1)[0].lower()}:{event.get_user_id()}"
+            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>`
@@ -23,12 +24,12 @@
 - `load_all_plugins` => {ref}``load_all_plugins` <nonebot.plugin.load.load_all_plugins>`
 - `load_from_json` => {ref}``load_from_json` <nonebot.plugin.load.load_from_json>`
 - `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_plugin` =>
-- `load_builtin_plugins` => {ref}``load_builtin_plugins` <nonebot.plugin.load.load_builtin_plugins>`
+  {ref}``load_builtin_plugin` <nonebot.plugin.load.load_builtin_plugin>`
-- `get_plugin` => {ref}``get_plugin` <nonebot.plugin.plugin.get_plugin>`
+- `load_builtin_plugins` =>
-- `get_loaded_plugins` => {ref}``get_loaded_plugins` <nonebot.plugin.plugin.get_loaded_plugins>`
+  {ref}``load_builtin_plugins` <nonebot.plugin.load.load_builtin_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
@@ -38,12 +39,12 @@ FrontMatter:
 from itertools import chain
 from types import ModuleType
 from contextvars import ContextVar
-from typing import Set, Dict, List, Optional
+from typing import Set, Dict, List, Tuple, Optional
 
 _plugins: Dict[str, "Plugin"] = {}
 _managers: List["PluginManager"] = []
-_current_plugin: ContextVar[Optional["Plugin"]] = ContextVar(
+_current_plugin_chain: ContextVar[Tuple["Plugin", ...]] = ContextVar(
-    "_current_plugin", default=None
+    "_current_plugin_chain", default=()
 )
 
 
@@ -66,6 +67,8 @@ 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"]:
@@ -87,13 +90,12 @@ def get_plugin_by_module_name(module_name: str) -> Optional["Plugin"]:
     参数:
         module_name: 模块名，即 {ref}`nonebot.plugin.plugin.Plugin.module_name`。
     """
-    splits = module_name.split(".")
     loaded = {plugin.module_name: plugin for plugin in _plugins.values()}
-    while splits:
+    has_parent = True
-        name = ".".join(splits)
+    while has_parent:
-        if name in loaded:
+        if module_name in loaded:
-            return loaded[name]
+            return loaded[module_name]
-        splits.pop()
+        module_name, *has_parent = module_name.rsplit(".", 1)
 
 
 def get_loaded_plugins() -> Set["Plugin"]:
@@ -108,8 +110,7 @@ def get_available_plugin_names() -> Set[str]:
 
 from .on import on as on
 from .manager import PluginManager
-from .export import Export as Export
+from .on import on_type as on_type
-from .export import export as export
 from .load import require as require
 from .on import on_regex as on_regex
 from .plugin import Plugin as Plugin
@@ -133,3 +134,4 @@ 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 .load import load_builtin_plugins as load_builtin_plugins
+from .load import inherit_supported_adapters as inherit_supported_adapters

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

@@ -4,25 +4,36 @@ FrontMatter:
     sidebar_position: 1
     description: nonebot.plugin.load 模块
 """
+
 import json
-import warnings
+from pathlib import Path
-from typing import Set, Iterable, Optional
+from types import ModuleType
+from typing import Set, Union, Iterable, Optional
 
-import tomlkit
+from nonebot.utils import path_to_module_name
 
-from .export import Export
 from .plugin import Plugin
 from .manager import PluginManager
-from . import _managers, get_plugin, _module_name_to_plugin_name
+from . import _managers, get_plugin, _current_plugin_chain, _module_name_to_plugin_name
+
+try:  # pragma: py-gte-311
+    import tomllib  # pyright: ignore[reportMissingImports]
+except ModuleNotFoundError:  # pragma: py-lt-311
+    import tomli as tomllib
 
 
-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`
+            或插件路径 `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)
@@ -54,7 +65,8 @@ def load_all_plugins(
 
 
 def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]:
-    """导入指定 json 文件中的 `plugins` 以及 `plugin_dirs` 下多个插件，以 `_` 开头的插件不会被导入!
+    """导入指定 json 文件中的 `plugins` 以及 `plugin_dirs` 下多个插件。
+    以 `_` 开头的插件不会被导入!
 
     参数:
         file_path: 指定 json 文件路径
@@ -72,8 +84,10 @@ def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]:
         nonebot.load_from_json("plugins.json")
         ```
     """
-    with open(file_path, "r", encoding=encoding) as f:
+    with open(file_path, 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"
@@ -82,7 +96,9 @@ def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]:
 
 
 def load_from_toml(file_path: str, encoding: str = "utf-8") -> Set[Plugin]:
-    """导入指定 toml 文件 `[tool.nonebot]` 中的 `plugins` 以及 `plugin_dirs` 下多个插件，以 `_` 开头的插件不会被导入!
+    """导入指定 toml 文件 `[tool.nonebot]` 中的
+    `plugins` 以及 `plugin_dirs` 下多个插件。
+    以 `_` 开头的插件不会被导入!
 
     参数:
         file_path: 指定 toml 文件路径
@@ -99,19 +115,14 @@ def load_from_toml(file_path: str, encoding: str = "utf-8") -> Set[Plugin]:
         nonebot.load_from_toml("pyproject.toml")
         ```
     """
-    with open(file_path, "r", encoding=encoding) as f:
+    with open(file_path, encoding=encoding) as f:
-        data = tomlkit.parse(f.read())  # type: ignore
+        data = tomllib.loads(f.read())
 
     nonebot_data = data.get("tool", {}).get("nonebot")
-    if not nonebot_data:
+    if nonebot_data is None:
-        nonebot_data = data.get("nonebot", {}).get("plugins")
+        raise ValueError("Cannot find '[tool.nonebot]' in given toml file!")
-        if nonebot_data:
+    if not isinstance(nonebot_data, dict):
-            warnings.warn(
+        raise TypeError("'[tool.nonebot]' must be a Table!")
-                "[nonebot.plugins] table is deprecated. Use [tool.nonebot] instead.",
-                DeprecationWarning,
-            )
-        else:
-            raise ValueError("Cannot find '[tool.nonebot]' in given toml file!")
     plugins = nonebot_data.get("plugins", [])
     plugin_dirs = nonebot_data.get("plugin_dirs", [])
     assert isinstance(plugins, list), "plugins must be a list of plugin name"
@@ -143,7 +154,7 @@ def _find_manager_by_name(name: str) -> Optional[PluginManager]:
             return manager
 
 
-def require(name: str) -> Export:
+def require(name: str) -> ModuleType:
     """获取一个插件的导出内容。
 
     如果为 `load_plugins` 文件夹导入的插件，则为文件(夹)名。
@@ -155,12 +166,55 @@ def require(name: str) -> Export:
         RuntimeError: 插件无法加载
     """
     plugin = get_plugin(_module_name_to_plugin_name(name))
+    # if plugin not loaded
     if not plugin:
-        manager = _find_manager_by_name(name)
+        # plugin already declared
-        if manager:
+        if manager := _find_manager_by_name(name):
             plugin = manager.load_plugin(name)
+        # plugin not declared, try to declare and load it
         else:
-            plugin = load_plugin(name)
+            # clear current plugin chain, ensure plugin loaded in a new context
-        if not plugin:
+            _t = _current_plugin_chain.set(())
-            raise RuntimeError(f'Cannot load plugin "{name}"!')
+            try:
-    return plugin.export
+                plugin = load_plugin(name)
+            finally:
+                _current_plugin_chain.reset(_t)
+    if not plugin:
+        raise RuntimeError(f'Cannot load plugin "{name}"!')
+    return plugin.module
+
+
+def inherit_supported_adapters(*names: str) -> Optional[Set[str]]:
+    """获取已加载插件的适配器支持状态集合。
+
+    如果传入了多个插件名称，返回值会自动取交集。
+
+    参数:
+        names: 插件名称列表。
+
+    异常:
+        RuntimeError: 插件未加载
+        ValueError: 插件缺少元数据
+    """
+    final_supported: Optional[Set[str]] = None
+
+    for name in names:
+        plugin = get_plugin(_module_name_to_plugin_name(name))
+        if plugin is None:
+            raise RuntimeError(f'Plugin "{name}" is not loaded!')
+        meta = plugin.metadata
+        if meta is None:
+            raise ValueError(f'Plugin "{name}" has no metadata!')
+        support = meta.supported_adapters
+        if support is None:
+            continue
+        final_supported = (
+            support if final_supported is None else (final_supported & support)
+        )
+
+    return final_supported and {
+        f"nonebot.adapters.{adapter_name[1:]}"
+        if adapter_name.startswith("~")
+        else adapter_name
+        for adapter_name in final_supported
+    }

nonebot/plugin/manager.py

@@ -6,6 +6,7 @@ FrontMatter:
     sidebar_position: 5
     description: nonebot.plugin.manager 模块
 """
+
 import sys
 import pkgutil
 import importlib
@@ -14,17 +15,17 @@ 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 .plugin import Plugin, PluginMetadata
 from . import (
     _managers,
     _new_plugin,
     _revert_plugin,
-    _current_plugin,
+    _current_plugin_chain,
     _module_name_to_plugin_name,
 )
 
@@ -51,6 +52,9 @@ class PluginManager:
         self._searched_plugin_names: Dict[str, Path] = {}
         self.prepare_plugins()
 
+    def __repr__(self) -> str:
+        return f"PluginManager(plugins={self.plugins}, search_path={self.search_path})"
+
     @property
     def third_party_plugins(self) -> Set[str]:
         """返回所有独立插件名称。"""
@@ -66,13 +70,6 @@ class PluginManager:
         """返回当前插件管理器中可用的插件名称。"""
         return self.third_party_plugins | self.searched_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 _previous_plugins(self) -> Set[str]:
         _pre_managers: List[PluginManager]
         if self in _managers:
@@ -86,7 +83,6 @@ class PluginManager:
 
     def prepare_plugins(self) -> Set[str]:
         """搜索插件并缓存插件名称。"""
-
         # get all previous ready to load plugins
         previous_plugins = self._previous_plugins()
         searched_plugins: Dict[str, Path] = {}
@@ -118,11 +114,13 @@ class PluginManager:
                     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 (
-            if not module_spec:
+                module_spec := module_info.module_finder.find_spec(
+                    module_info.name, None
+                )
+            ):
                 continue
-            module_path = module_spec.origin
+            if not (module_path := module_spec.origin):
-            if not module_path:
                 continue
             searched_plugins[module_info.name] = Path(module_path).resolve()
 
@@ -146,20 +144,26 @@ class PluginManager:
                 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_plugin_names[name])
+                    path_to_module_name(self._searched_plugin_names[name])
                 )
             else:
                 raise RuntimeError(f"Plugin not found: {name}! Check your plugin name")
 
-            logger.opt(colors=True).success(
+            if (
-                f'Succeeded to import "<y>{escape_tag(name)}</y>"'
+                plugin := getattr(module, "__plugin__", None)
-            )
+            ) is None or not isinstance(plugin, Plugin):
-            plugin = getattr(module, "__plugin__", None)
-            if plugin is None:
                 raise RuntimeError(
                     f"Module {module.__name__} is not loaded as a plugin! "
                     "Make sure not to import it before loading."
                 )
+            logger.opt(colors=True).success(
+                f'Succeeded to load plugin "<y>{escape_tag(plugin.name)}</y>"'
+                + (
+                    f' from "<m>{escape_tag(plugin.module_name)}</m>"'
+                    if plugin.module_name != plugin.name
+                    else ""
+                )
+            )
             return plugin
         except Exception as e:
             logger.opt(colors=True, exception=e).error(
@@ -178,7 +182,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:
@@ -223,15 +227,16 @@ class PluginLoader(SourceFileLoader):
         setattr(module, "__plugin__", plugin)
 
         # detect parent plugin before entering current plugin context
-        parent_plugin = _current_plugin.get()
+        parent_plugins = _current_plugin_chain.get()
-        if parent_plugin and _managers.index(parent_plugin.manager) < _managers.index(
+        for pre_plugin in reversed(parent_plugins):
-            self.manager
+            # ensure parent plugin is declared before current plugin
-        ):
+            if _managers.index(pre_plugin.manager) < _managers.index(self.manager):
-            plugin.parent_plugin = parent_plugin
+                plugin.parent_plugin = pre_plugin
-            parent_plugin.sub_plugins.add(plugin)
+                pre_plugin.sub_plugins.add(plugin)
+                break
 
         # enter plugin context
-        _plugin_token = _current_plugin.set(plugin)
+        _plugin_token = _current_plugin_chain.set(parent_plugins + (plugin,))
 
         try:
             super().exec_module(module)
@@ -240,7 +245,7 @@ class PluginLoader(SourceFileLoader):
             raise
         finally:
             # leave plugin context
-            _current_plugin.reset(_plugin_token)
+            _current_plugin_chain.reset(_plugin_token)
 
         # get plugin metadata
         metadata: Optional[PluginMetadata] = getattr(module, "__plugin_meta__", None)

nonebot/plugin/on.pyi

@@ -1,340 +1,421 @@
 import re
-from typing import Set, List, Type, Tuple, Union, Optional
+from typing import Any
+from types import ModuleType
+from datetime import datetime, timedelta
 
-from nonebot.matcher import Matcher
+from nonebot.adapters import Event
 from nonebot.permission import Permission
 from nonebot.dependencies import Dependent
 from nonebot.rule import Rule, ArgumentParser
+from nonebot.matcher import Matcher, MatcherSource
 from nonebot.typing import T_State, T_Handler, T_RuleChecker, T_PermissionChecker
 
+from .plugin import Plugin
+
+def store_matcher(matcher: type[Matcher]) -> None: ...
+def get_matcher_plugin(depth: int = ...) -> Plugin | None: ...
+def get_matcher_module(depth: int = ...) -> ModuleType | None: ...
+def get_matcher_source(depth: int = ...) -> MatcherSource | None: ...
 def on(
     type: str = "",
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    rule: Rule | T_RuleChecker | None = ...,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+    permission: Permission | T_PermissionChecker | None = ...,
     *,
-    handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+    handlers: list[T_Handler | Dependent] | None = ...,
     temp: bool = ...,
+    expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
     block: bool = ...,
-    state: Optional[T_State] = ...,
+    state: T_State | None = ...,
-) -> Type[Matcher]: ...
+) -> type[Matcher]: ...
 def on_metaevent(
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    rule: Rule | T_RuleChecker | None = ...,
+    permission: Permission | T_PermissionChecker | None = ...,
     *,
-    handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+    handlers: list[T_Handler | Dependent] | None = ...,
     temp: bool = ...,
+    expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
     block: bool = ...,
-    state: Optional[T_State] = ...,
+    state: T_State | None = ...,
-) -> Type[Matcher]: ...
+) -> type[Matcher]: ...
 def on_message(
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    rule: Rule | T_RuleChecker | None = ...,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+    permission: Permission | T_PermissionChecker | None = ...,
     *,
-    handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+    handlers: list[T_Handler | Dependent] | None = ...,
     temp: bool = ...,
+    expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
     block: bool = ...,
-    state: Optional[T_State] = ...,
+    state: T_State | None = ...,
-) -> Type[Matcher]: ...
+) -> type[Matcher]: ...
 def on_notice(
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    rule: Rule | T_RuleChecker | None = ...,
+    permission: Permission | T_PermissionChecker | None = ...,
     *,
-    handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+    handlers: list[T_Handler | Dependent] | None = ...,
     temp: bool = ...,
+    expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
     block: bool = ...,
-    state: Optional[T_State] = ...,
+    state: T_State | None = ...,
-) -> Type[Matcher]: ...
+) -> type[Matcher]: ...
 def on_request(
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    rule: Rule | T_RuleChecker | None = ...,
+    permission: Permission | T_PermissionChecker | None = ...,
     *,
-    handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+    handlers: list[T_Handler | Dependent] | None = ...,
     temp: bool = ...,
+    expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
     block: bool = ...,
-    state: Optional[T_State] = ...,
+    state: T_State | None = ...,
-) -> Type[Matcher]: ...
+) -> type[Matcher]: ...
 def on_startswith(
-    msg: Union[str, Tuple[str, ...]],
+    msg: str | tuple[str, ...],
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    rule: Rule | T_RuleChecker | None = ...,
     ignorecase: bool = ...,
     *,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+    permission: Permission | T_PermissionChecker | None = ...,
-    handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+    handlers: list[T_Handler | Dependent] | None = ...,
     temp: bool = ...,
+    expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
     block: bool = ...,
-    state: Optional[T_State] = ...,
+    state: T_State | None = ...,
-) -> Type[Matcher]: ...
+) -> type[Matcher]: ...
 def on_endswith(
-    msg: Union[str, Tuple[str, ...]],
+    msg: str | tuple[str, ...],
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    rule: Rule | T_RuleChecker | None = ...,
     ignorecase: bool = ...,
     *,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+    permission: Permission | T_PermissionChecker | None = ...,
-    handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+    handlers: list[T_Handler | Dependent] | None = ...,
     temp: bool = ...,
+    expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
     block: bool = ...,
-    state: Optional[T_State] = ...,
+    state: T_State | None = ...,
-) -> Type[Matcher]: ...
+) -> type[Matcher]: ...
 def on_fullmatch(
-    msg: Union[str, Tuple[str, ...]],
+    msg: str | tuple[str, ...],
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    rule: Rule | T_RuleChecker | None = ...,
     ignorecase: bool = ...,
     *,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+    permission: Permission | T_PermissionChecker | None = ...,
-    handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+    handlers: list[T_Handler | Dependent] | None = ...,
     temp: bool = ...,
+    expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
     block: bool = ...,
-    state: Optional[T_State] = ...,
+    state: T_State | None = ...,
-) -> Type[Matcher]: ...
+) -> type[Matcher]: ...
 def on_keyword(
-    keywords: Set[str],
+    keywords: set[str],
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    rule: Rule | T_RuleChecker | None = ...,
     *,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+    permission: Permission | T_PermissionChecker | None = ...,
-    handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+    handlers: list[T_Handler | Dependent] | None = ...,
     temp: bool = ...,
+    expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
     block: bool = ...,
-    state: Optional[T_State] = ...,
+    state: T_State | None = ...,
-) -> Type[Matcher]: ...
+) -> type[Matcher]: ...
 def on_command(
-    cmd: Union[str, Tuple[str, ...]],
+    cmd: str | tuple[str, ...],
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    rule: Rule | T_RuleChecker | None = ...,
-    aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
+    aliases: set[str | tuple[str, ...]] | None = ...,
+    force_whitespace: str | bool | None = ...,
     *,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+    permission: Permission | T_PermissionChecker | None = ...,
-    handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+    handlers: list[T_Handler | Dependent] | None = ...,
     temp: bool = ...,
+    expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
     block: bool = ...,
-    state: Optional[T_State] = ...,
+    state: T_State | None = ...,
-) -> Type[Matcher]: ...
+) -> type[Matcher]: ...
 def on_shell_command(
-    cmd: Union[str, Tuple[str, ...]],
+    cmd: str | tuple[str, ...],
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    rule: Rule | T_RuleChecker | None = ...,
-    aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
+    aliases: set[str | tuple[str, ...]] | None = ...,
-    parser: Optional[ArgumentParser] = ...,
+    parser: ArgumentParser | None = ...,
     *,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+    permission: Permission | T_PermissionChecker | None = ...,
-    handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+    handlers: list[T_Handler | Dependent] | None = ...,
     temp: bool = ...,
+    expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
     block: bool = ...,
-    state: Optional[T_State] = ...,
+    state: T_State | None = ...,
-) -> Type[Matcher]: ...
+) -> type[Matcher]: ...
 def on_regex(
     pattern: str,
-    flags: Union[int, re.RegexFlag] = ...,
+    flags: int | re.RegexFlag = ...,
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    rule: Rule | T_RuleChecker | None = ...,
     *,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+    permission: Permission | T_PermissionChecker | None = ...,
-    handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+    handlers: list[T_Handler | Dependent] | None = ...,
     temp: bool = ...,
+    expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
     block: bool = ...,
-    state: Optional[T_State] = ...,
+    state: T_State | None = ...,
-) -> Type[Matcher]: ...
+) -> type[Matcher]: ...
+def on_type(
+    types: type[Event] | tuple[type[Event], ...],
+    rule: Rule | T_RuleChecker | None = ...,
+    *,
+    permission: Permission | T_PermissionChecker | None = ...,
+    handlers: list[T_Handler | Dependent] | None = ...,
+    temp: bool = ...,
+    expire_time: datetime | timedelta | None = ...,
+    priority: int = ...,
+    block: bool = ...,
+    state: T_State | None = ...,
+) -> type[Matcher]: ...
 
-class CommandGroup:
+class _Group:
+    matchers: list[type[Matcher]] = ...
+    base_kwargs: dict[str, Any] = ...
+    def _get_final_kwargs(
+        self, update: dict[str, Any], *, exclude: set[str] | None = None
+    ) -> dict[str, Any]: ...
+
+class CommandGroup(_Group):
+    basecmd: tuple[str, ...] = ...
+    prefix_aliases: bool = ...
     def __init__(
         self,
-        cmd: Union[str, Tuple[str, ...]],
+        cmd: str | tuple[str, ...],
+        prefix_aliases: bool = ...,
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
     ): ...
     def command(
         self,
-        cmd: Union[str, Tuple[str, ...]],
+        cmd: str | tuple[str, ...],
         *,
-        aliases: Optional[Set[Union[str, Tuple[str, ...]]]],
+        rule: Rule | T_RuleChecker | None = ...,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        aliases: set[str | tuple[str, ...]] | None = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+        force_whitespace: str | bool | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
-    ) -> Type[Matcher]: ...
+    ) -> type[Matcher]: ...
     def shell_command(
         self,
-        cmd: Union[str, Tuple[str, ...]],
+        cmd: str | tuple[str, ...],
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
-        aliases: Optional[Set[Union[str, Tuple[str, ...]]]],
+        aliases: set[str | tuple[str, ...]] | None = ...,
-        parser: Optional[ArgumentParser] = ...,
+        parser: ArgumentParser | None = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
-    ) -> Type[Matcher]: ...
+    ) -> type[Matcher]: ...
 
-class MatcherGroup:
+class MatcherGroup(_Group):
     def __init__(
         self,
         *,
         type: str = ...,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
     ): ...
     def on(
         self,
         *,
         type: str = ...,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
-    ) -> Type[Matcher]: ...
+    ) -> type[Matcher]: ...
     def on_metaevent(
         self,
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
-    ) -> Type[Matcher]: ...
+    ) -> type[Matcher]: ...
     def on_message(
         self,
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
-    ) -> Type[Matcher]: ...
+    ) -> type[Matcher]: ...
     def on_notice(
         self,
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
-    ) -> Type[Matcher]: ...
+    ) -> type[Matcher]: ...
     def on_request(
         self,
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
-    ) -> Type[Matcher]: ...
+    ) -> type[Matcher]: ...
     def on_startswith(
         self,
-        msg: Union[str, Tuple[str, ...]],
+        msg: str | tuple[str, ...],
         *,
         ignorecase: bool = ...,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
-    ) -> Type[Matcher]: ...
+    ) -> type[Matcher]: ...
     def on_endswith(
         self,
-        msg: Union[str, Tuple[str, ...]],
+        msg: str | tuple[str, ...],
         *,
         ignorecase: bool = ...,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
-    ) -> Type[Matcher]: ...
+    ) -> type[Matcher]: ...
     def on_fullmatch(
         self,
-        msg: Union[str, Tuple[str, ...]],
+        msg: str | tuple[str, ...],
         *,
         ignorecase: bool = ...,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
-    ) -> Type[Matcher]: ...
+    ) -> type[Matcher]: ...
     def on_keyword(
         self,
-        keywords: Set[str],
+        keywords: set[str],
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
-    ) -> Type[Matcher]: ...
+    ) -> type[Matcher]: ...
     def on_command(
         self,
-        cmd: Union[str, Tuple[str, ...]],
+        cmd: str | tuple[str, ...],
-        aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
+        aliases: set[str | tuple[str, ...]] | None = ...,
+        force_whitespace: str | bool | None = ...,
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
-    ) -> Type[Matcher]: ...
+    ) -> type[Matcher]: ...
     def on_shell_command(
         self,
-        cmd: Union[str, Tuple[str, ...]],
+        cmd: str | tuple[str, ...],
-        aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
+        aliases: set[str | tuple[str, ...]] | None = ...,
-        parser: Optional[ArgumentParser] = ...,
+        parser: ArgumentParser | None = ...,
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
-    ) -> Type[Matcher]: ...
+    ) -> type[Matcher]: ...
     def on_regex(
         self,
         pattern: str,
-        flags: Union[int, re.RegexFlag] = ...,
+        flags: int | re.RegexFlag = ...,
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
         temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
         block: bool = ...,
-        state: Optional[T_State] = ...,
+        state: T_State | None = ...,
-    ) -> Type[Matcher]: ...
+    ) -> type[Matcher]: ...
+    def on_type(
+        self,
+        types: type[Event] | tuple[type[Event]],
+        *,
+        rule: Rule | T_RuleChecker | None = ...,
+        permission: Permission | T_PermissionChecker | None = ...,
+        handlers: list[T_Handler | Dependent] | None = ...,
+        temp: bool = ...,
+        expire_time: datetime | timedelta | None = ...,
+        priority: int = ...,
+        block: bool = ...,
+        state: T_State | None = ...,
+    ) -> type[Matcher]: ...

nonebot/plugin/plugin.py

@@ -1,9 +1,11 @@
-"""本模块定义插件对象。
+"""本模块定义插件相关信息。
 
 FrontMatter:
     sidebar_position: 3
     description: nonebot.plugin.plugin 模块
 """
+
+import contextlib
 from types import ModuleType
 from dataclasses import field, dataclass
 from typing import TYPE_CHECKING, Any, Set, Dict, Type, Optional
@@ -11,11 +13,11 @@ from typing import TYPE_CHECKING, Any, Set, Dict, Type, Optional
 from pydantic import BaseModel
 
 from nonebot.matcher import Matcher
-
+from nonebot.utils import resolve_dot_notation
-from .export import Export
-from . import _plugins as plugins  # FIXME: backport for nonebug
 
 if TYPE_CHECKING:
+    from nonebot.adapters import Adapter
+
     from .manager import PluginManager
 
 
@@ -24,14 +26,39 @@ class PluginMetadata:
     """插件元信息，由插件编写者提供"""
 
     name: str
-    """插件可阅读名称"""
+    """插件名称"""
     description: str
     """插件功能介绍"""
     usage: str
     """插件使用方法"""
+    type: Optional[str] = None
+    """插件类型，用于商店分类"""
+    homepage: Optional[str] = None
+    """插件主页"""
     config: Optional[Type[BaseModel]] = None
     """插件配置项"""
+    supported_adapters: Optional[Set[str]] = None
+    """插件支持的适配器模块路径
+
+    格式为 `<module>[:<Adapter>]`，`~` 为 `nonebot.adapters.` 的缩写。
+
+    `None` 表示支持**所有适配器**。
+    """
     extra: Dict[Any, Any] = field(default_factory=dict)
+    """插件额外信息，可由插件编写者自由扩展定义"""
+
+    def get_supported_adapters(self) -> Optional[Set[Type["Adapter"]]]:
+        """获取当前已安装的插件支持适配器类列表"""
+        if self.supported_adapters is None:
+            return None
+
+        adapters = set()
+        for adapter in self.supported_adapters:
+            with contextlib.suppress(ModuleNotFoundError, AttributeError):
+                adapters.add(
+                    resolve_dot_notation(adapter, "Adapter", "nonebot.adapters.")
+                )
+        return adapters
 
 
 @dataclass(eq=False)
@@ -46,10 +73,8 @@ class Plugin:
     """点分割模块路径"""
     manager: "PluginManager"
     """导入该插件的插件管理器"""
-    export: Export = field(default_factory=Export)
-    """**Deprecated:** 插件内定义的导出内容"""
     matcher: Set[Type[Matcher]] = field(default_factory=set)
-    """插件内定义的 `Matcher`"""
+    """插件加载时定义的 `Matcher`"""
     parent_plugin: Optional["Plugin"] = None
     """父插件"""
     sub_plugins: Set["Plugin"] = field(default_factory=set)

nonebot/plugins/echo.py

@@ -1,11 +1,22 @@
+from nonebot import on_command
 from nonebot.rule import to_me
 from nonebot.adapters import Message
 from nonebot.params import CommandArg
-from nonebot.plugin import on_command
+from nonebot.plugin import PluginMetadata
+
+__plugin_meta__ = PluginMetadata(
+    name="echo",
+    description="重复你说的话",
+    usage="/echo [text]",
+    type="application",
+    homepage="https://github.com/nonebot/nonebot2/blob/master/nonebot/plugins/echo.py",
+    config=None,
+    supported_adapters=None,
+)
 
 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

@@ -2,8 +2,19 @@ from typing import Dict, AsyncGenerator
 
 from nonebot.adapters import Event
 from nonebot.params import Depends
+from nonebot.plugin import PluginMetadata
 from nonebot.message import IgnoredException, event_preprocessor
 
+__plugin_meta__ = PluginMetadata(
+    name="唯一会话",
+    description="限制同一会话内同时只能运行一个响应器",
+    usage="加载插件后自动生效",
+    type="application",
+    homepage="https://github.com/nonebot/nonebot2/blob/master/nonebot/plugins/single_session.py",
+    config=None,
+    supported_adapters=None,
+)
+
 _running_matcher: Dict[str, int] = {}
 
 
@@ -15,8 +26,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 := _running_matcher.get(session_id):
-        if event_id:
             result = event_id != current_event_id
         else:
             _running_matcher[session_id] = current_event_id

nonebot/rule.py

@@ -1,7 +1,8 @@
 """本模块是 {ref}`nonebot.matcher.Matcher.rule` 的类型定义。
 
-每个事件响应器 {ref}`nonebot.matcher.Matcher` 拥有一个匹配规则 {ref}`nonebot.rule.Rule`
+每个{ref}`事件响应器 <nonebot.matcher.Matcher>`拥有一个
-其中是 `RuleChecker` 的集合，只有当所有 `RuleChecker` 检查结果为 `True` 时继续运行。
+{ref}`nonebot.rule.Rule`，其中是 `RuleChecker` 的集合。
+只有当所有 `RuleChecker` 检查结果为 `True` 时继续运行。
 
 FrontMatter:
     sidebar_position: 5
@@ -10,11 +11,28 @@ FrontMatter:
 
 import re
 import shlex
-from itertools import product
+from argparse import Action
-from argparse import Namespace
+from gettext import gettext
-from typing_extensions import TypedDict
+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
 
@@ -24,40 +42,40 @@ from nonebot.typing import T_State
 from nonebot.exception import ParserExit
 from nonebot.internal.rule import Rule as Rule
 from nonebot.adapters import Bot, Event, Message, MessageSegment
-from nonebot.params import (
+from nonebot.params import Command, EventToMe, CommandArg, CommandWhitespace
-    Command,
-    EventToMe,
-    EventType,
-    CommandArg,
-    EventMessage,
-    EventPlainText,
-)
 from nonebot.consts import (
     CMD_KEY,
     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,
+    CMD_WHITESPACE_KEY,
 )
 
-CMD_RESULT = TypedDict(
+T = TypeVar("T")
-    "CMD_RESULT",
-    {
-        "command": Optional[Tuple[str, ...]],
-        "raw_command": Optional[str],
-        "command_arg": Optional[Message[MessageSegment]],
-        "command_start": Optional[str],
-    },
-)
 
-TRIE_VALUE = NamedTuple(
+
-    "TRIE_VALUE", [("command_start", str), ("command", Tuple[str, ...])]
+class CMD_RESULT(TypedDict):
-)
+    command: Optional[Tuple[str, ...]]
+    raw_command: Optional[str]
+    command_arg: Optional[Message]
+    command_start: Optional[str]
+    command_whitespace: Optional[str]
+
+
+class TRIE_VALUE(NamedTuple):
+    command_start: str
+    command: Tuple[str, ...]
+
+
+parser_message: ContextVar[str] = ContextVar("parser_message")
 
 
 class TrieRule:
@@ -73,7 +91,11 @@ class TrieRule:
     @classmethod
     def get_value(cls, bot: Bot, event: Event, state: T_State) -> CMD_RESULT:
         prefix = CMD_RESULT(
-            command=None, raw_command=None, command_arg=None, command_start=None
+            command=None,
+            raw_command=None,
+            command_arg=None,
+            command_start=None,
+            command_whitespace=None,
         )
         state[PREFIX_KEY] = prefix
         if event.get_type() != "message":
@@ -83,17 +105,30 @@ 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 := cls.prefix.longest_prefix(segment_text):
-            if pf:
                 value: TRIE_VALUE = pf.value
                 prefix[RAW_CMD_KEY] = pf.key
                 prefix[CMD_START_KEY] = value.command_start
                 prefix[CMD_KEY] = value.command
+
                 msg = message.copy()
                 msg.pop(0)
-                new_message = msg.__class__(segment_text[len(pf.key) :].lstrip())
+
-                for new_segment in reversed(new_message):
+                # check whitespace
-                    msg.insert(0, new_segment)
+                arg_str = segment_text[len(pf.key) :]
+                arg_str_stripped = arg_str.lstrip()
+                has_arg = arg_str_stripped or msg
+                if (
+                    has_arg
+                    and (stripped_len := len(arg_str) - len(arg_str_stripped)) > 0
+                ):
+                    prefix[CMD_WHITESPACE_KEY] = arg_str[:stripped_len]
+
+                # construct command arg
+                if arg_str_stripped:
+                    new_message = msg.__class__(arg_str_stripped)
+                    for new_segment in reversed(new_message):
+                        msg.insert(0, new_segment)
                 prefix[CMD_ARG_KEY] = msg
 
         return prefix
@@ -113,19 +148,33 @@ class StartswithRule:
         self.msg = msg
         self.ignorecase = ignorecase
 
-    async def __call__(
+    def __repr__(self) -> str:
-        self, type: str = EventType(), text: str = EventPlainText()
+        return f"Startswith(msg={self.msg}, ignorecase={self.ignorecase})"
-    ) -> Any:
+
-        if type != "message":
+    def __eq__(self, other: object) -> bool:
-            return False
+        return (
-        return bool(
+            isinstance(other, StartswithRule)
-            re.match(
+            and frozenset(self.msg) == frozenset(other.msg)
-                f"^(?:{'|'.join(re.escape(prefix) for prefix in self.msg)})",
+            and self.ignorecase == other.ignorecase
-                text,
-                re.IGNORECASE if self.ignorecase else 0,
-            )
         )
 
+    def __hash__(self) -> int:
+        return hash((frozenset(self.msg), self.ignorecase))
+
+    async def __call__(self, event: Event, state: T_State) -> bool:
+        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 +203,33 @@ class EndswithRule:
         self.msg = msg
         self.ignorecase = ignorecase
 
-    async def __call__(
+    def __repr__(self) -> str:
-        self, type: str = EventType(), text: str = EventPlainText()
+        return f"Endswith(msg={self.msg}, ignorecase={self.ignorecase})"
-    ) -> Any:
+
-        if type != "message":
+    def __eq__(self, other: object) -> bool:
-            return False
+        return (
-        return bool(
+            isinstance(other, EndswithRule)
-            re.search(
+            and frozenset(self.msg) == frozenset(other.msg)
-                f"(?:{'|'.join(re.escape(prefix) for prefix in self.msg)})$",
+            and self.ignorecase == other.ignorecase
-                text,
-                re.IGNORECASE if self.ignorecase else 0,
-            )
         )
 
+    def __hash__(self) -> int:
+        return hash((frozenset(self.msg), self.ignorecase))
+
+    async def __call__(self, event: Event, state: T_State) -> bool:
+        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 +255,35 @@ 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__(
+    def __repr__(self) -> str:
-        self, type_: str = EventType(), text: str = EventPlainText()
+        return f"Fullmatch(msg={self.msg}, ignorecase={self.ignorecase})"
-    ) -> bool:
+
+    def __eq__(self, other: object) -> bool:
         return (
-            type_ == "message"
+            isinstance(other, FullmatchRule)
-            and (text.casefold() if self.ignorecase else text) in self.msg
+            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:
+        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 +310,28 @@ class KeywordsRule:
     def __init__(self, *keywords: str):
         self.keywords = keywords
 
-    async def __call__(
+    def __repr__(self) -> str:
-        self, type: str = EventType(), text: str = EventPlainText()
+        return f"Keywords(keywords={self.keywords})"
-    ) -> bool:
+
-        if type != "message":
+    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:
+        try:
+            text = event.get_plaintext()
+        except Exception:
             return False
-        return bool(text and any(keyword in text for keyword in self.keywords))
+        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:
@@ -252,21 +349,49 @@ class CommandRule:
 
     参数:
         cmds: 指定命令元组列表
+        force_whitespace: 是否强制命令后必须有指定空白符
     """
 
-    __slots__ = ("cmds",)
+    __slots__ = ("cmds", "force_whitespace")
 
-    def __init__(self, cmds: List[Tuple[str, ...]]):
+    def __init__(
-        self.cmds = cmds
+        self,
+        cmds: List[Tuple[str, ...]],
+        force_whitespace: Optional[Union[str, bool]] = None,
+    ):
+        self.cmds = tuple(cmds)
+        self.force_whitespace = force_whitespace
 
-    async def __call__(self, cmd: Optional[Tuple[str, ...]] = Command()) -> bool:
+    def __repr__(self) -> str:
-        return cmd in self.cmds
+        return f"Command(cmds={self.cmds})"
 
-    def __repr__(self):
+    def __eq__(self, other: object) -> bool:
-        return f"<Command {self.cmds}>"
+        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(),
+        cmd_arg: Optional[Message] = CommandArg(),
+        cmd_whitespace: Optional[str] = CommandWhitespace(),
+    ) -> bool:
+        if cmd not in self.cmds:
+            return False
+        if self.force_whitespace is None or not cmd_arg:
+            return True
+        if isinstance(self.force_whitespace, str):
+            return self.force_whitespace == cmd_whitespace
+        return self.force_whitespace == (cmd_whitespace is not None)
 
 
-def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule:
+def command(
+    *cmds: Union[str, Tuple[str, ...]],
+    force_whitespace: Optional[Union[str, bool]] = None,
+) -> Rule:
     """匹配消息命令。
 
     根据配置里提供的 {ref}``command_start` <nonebot.config.Config.command_start>`,
@@ -278,9 +403,10 @@ def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule:
 
     参数:
         cmds: 命令文本或命令元组
+        force_whitespace: 是否强制命令后必须有指定空白符
 
     用法:
-        使用默认 `command_start`, `command_sep` 配置
+        使用默认 `command_start`, `command_sep` 配置情况下：
 
         命令 `("test",)` 可以匹配: `/test` 开头的消息
         命令 `("test", "sub")` 可以匹配: `/test.sub` 开头的消息
@@ -309,36 +435,94 @@ def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule:
                     f"{start}{sep.join(command)}", TRIE_VALUE(start, command)
                 )
 
-    return Rule(CommandRule(commands))
+    return Rule(CommandRule(commands, force_whitespace))
 
 
 class ArgumentParser(ArgParser):
     """`shell_like` 命令参数解析器，解析出错时不会退出程序。
 
+    支持 {ref}`nonebot.adapters.Message` 富文本解析。
+
     用法:
         用法与 `argparse.ArgumentParser` 相同，
         参考文档: [argparse](https://docs.python.org/3/library/argparse.html)
     """
 
-    def _print_message(self, message, file=None):
+    if TYPE_CHECKING:
-        old_message: str = getattr(self, "message", "")
-        if old_message:
-            old_message += "\n"
-        old_message += message
-        setattr(self, "message", old_message)
 
-    def exit(self, status: int = 0, message: Optional[str] = None):
+        @overload
-        raise ParserExit(
+        def parse_known_args(
-            status=status, message=message or getattr(self, "message", None)
+            self,
-        )
+            args: Optional[Sequence[Union[str, MessageSegment]]] = None,
+            namespace: None = None,
+        ) -> Tuple[Namespace, List[Union[str, MessageSegment]]]:
+            ...
+
+        @overload
+        def parse_known_args(
+            self, args: Optional[Sequence[Union[str, MessageSegment]]], namespace: T
+        ) -> Tuple[T, List[Union[str, MessageSegment]]]:
+            ...
+
+        @overload
+        def parse_known_args(
+            self, *, namespace: T
+        ) -> Tuple[T, List[Union[str, MessageSegment]]]:
+            ...
+
+        def parse_known_args(
+            self,
+            args: Optional[Sequence[Union[str, MessageSegment]]] = None,
+            namespace: Optional[T] = None,
+        ) -> Tuple[Union[Namespace, T], List[Union[str, MessageSegment]]]:
+            ...
+
+    @overload
+    def parse_args(
+        self,
+        args: Optional[Sequence[Union[str, MessageSegment]]] = None,
+        namespace: None = None,
+    ) -> Namespace:
+        ...
+
+    @overload
+    def parse_args(
+        self, args: Optional[Sequence[Union[str, MessageSegment]]], namespace: T
+    ) -> T:
+        ...
+
+    @overload
+    def parse_args(self, *, namespace: T) -> T:
+        ...
 
     def parse_args(
         self,
-        args: Optional[Sequence[str]] = None,
+        args: Optional[Sequence[Union[str, MessageSegment]]] = None,
-        namespace: Optional[Namespace] = None,
+        namespace: Optional[T] = None,
-    ) -> Namespace:
+    ) -> Union[Namespace, T]:
-        setattr(self, "message", "")
+        result, argv = self.parse_known_args(args, namespace)
-        return super().parse_args(args=args, namespace=namespace)  # type: ignore
+        if argv:
+            msg = gettext("unrecognized arguments: %s")
+            self.error(msg % " ".join(map(str, argv)))
+        return cast(Union[Namespace, T], result)
+
+    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 _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 +536,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:
+        if cmd not in self.cmds or msg is 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:
             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:  # pragma: py-gte-39
+                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
@@ -383,10 +590,14 @@ def shell_command(
     根据配置里提供的 {ref}``command_start` <nonebot.config.Config.command_start>`,
     {ref}``command_sep` <nonebot.config.Config.command_sep>` 判断消息是否为命令。
 
-    可以通过 {ref}`nonebot.params.Command` 获取匹配成功的命令（例: `("test",)`），
+    可以通过 {ref}`nonebot.params.Command` 获取匹配成功的命令
-    通过 {ref}`nonebot.params.RawCommand` 获取匹配成功的原始命令文本（例: `"/test"`），
+    （例: `("test",)`），
-    通过 {ref}`nonebot.params.ShellCommandArgv` 获取解析前的参数列表（例: `["arg", "-h"]`），
+    通过 {ref}`nonebot.params.RawCommand` 获取匹配成功的原始命令文本
-    通过 {ref}`nonebot.params.ShellCommandArgs` 获取解析后的参数字典（例: `{"arg": "arg", "h": True}`）。
+    （例: `"/test"`），
+    通过 {ref}`nonebot.params.ShellCommandArgv` 获取解析前的参数列表
+    （例: `["arg", "-h"]`），
+    通过 {ref}`nonebot.params.ShellCommandArgs` 获取解析后的参数字典
+    （例: `{"arg": "arg", "h": True}`）。
 
     :::warning 警告
     如果参数解析失败，则通过 {ref}`nonebot.params.ShellCommandArgs`
@@ -398,7 +609,8 @@ def shell_command(
         parser: {ref}`nonebot.rule.ArgumentParser` 对象
 
     用法:
-        使用默认 `command_start`, `command_sep` 配置，更多示例参考 `argparse` 标准库文档。
+        使用默认 `command_start`, `command_sep` 配置，更多示例参考
+        [argparse](https://docs.python.org/3/library/argparse.html) 标准库文档。
 
         ```python
         from nonebot.rule import ArgumentParser
@@ -452,19 +664,26 @@ class RegexRule:
         self.regex = regex
         self.flags = flags
 
-    async def __call__(
+    def __repr__(self) -> str:
-        self,
+        return f"Regex(regex={self.regex!r}, flags={self.flags})"
-        state: T_State,
+
-        type: str = EventType(),
+    def __eq__(self, other: object) -> bool:
-        msg: Message = EventMessage(),
+        return (
-    ) -> bool:
+            isinstance(other, RegexRule)
-        if type != "message":
+            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:
+        try:
+            msg = event.get_message()
+        except Exception:
             return False
-        matched = re.search(self.regex, str(msg), self.flags)
+        if matched := re.search(self.regex, str(msg), self.flags):
-        if matched:
+            state[REGEX_MATCHED] = matched
-            state[REGEX_MATCHED] = matched.group()
-            state[REGEX_GROUP] = matched.groups()
-            state[REGEX_DICT] = matched.groupdict()
             return True
         else:
             return False
@@ -473,7 +692,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 字典。
 
@@ -486,7 +705,8 @@ def regex(regex: str, flags: Union[int, re.RegexFlag] = 0) -> Rule:
     :::
 
     :::tip 提示
-    正则表达式匹配使用 `EventMessage` 的 `str` 字符串，而非 `EventMessage` 的 `PlainText` 纯文本字符串
+    正则表达式匹配使用 `EventMessage` 的 `str` 字符串，
+    而非 `EventMessage` 的 `PlainText` 纯文本字符串
     :::
     """
 
@@ -498,6 +718,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 +737,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

@@ -1,16 +1,17 @@
 """本模块定义了 NoneBot 模块中共享的一些类型。
 
-下面的文档中，「类型」部分使用 Python 的 Type Hint 语法，
+使用 Python 的 Type Hint 语法，
 参考 [`PEP 484`](https://www.python.org/dev/peps/pep-0484/),
 [`PEP 526`](https://www.python.org/dev/peps/pep-0526/) 和
 [`typing`](https://docs.python.org/3/library/typing.html)。
 
-除了 Python 内置的类型，下面还出现了如下 NoneBot 自定类型，实际上它们是 Python 内置类型的别名。
-
 FrontMatter:
     sidebar_position: 11
     description: nonebot.typing 模块
 """
+
+import warnings
+from typing_extensions import ParamSpec, TypeAlias, override
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -28,23 +29,32 @@ if TYPE_CHECKING:
     from nonebot.adapters import Bot
     from nonebot.permission import Permission
 
-T_Wrapped = TypeVar("T_Wrapped", bound=Callable)
+T = TypeVar("T")
+P = ParamSpec("P")
+
+T_Wrapped: TypeAlias = Callable[P, T]
 
 
-def overrides(InterfaceClass: object) -> Callable[[T_Wrapped], T_Wrapped]:
+def overrides(InterfaceClass: object):
     """标记一个方法为父类 interface 的 implement"""
 
-    def overrider(func: T_Wrapped) -> T_Wrapped:
+    warnings.warn(
-        assert func.__name__ in dir(InterfaceClass), f"Error method: {func.__name__}"
+        "overrides is deprecated and will be removed in a future version, "
-        return func
+        "use @typing_extensions.override instead. "
-
+        "See [PEP 698](https://peps.python.org/pep-0698/) for more details.",
-    return overrider
+        DeprecationWarning,
+    )
+    return override
 
 
-T_State = Dict[Any, Any]
+# state
+T_State: TypeAlias = Dict[Any, Any]
 """事件处理状态 State 类型"""
 
-T_BotConnectionHook = Callable[..., Awaitable[Any]]
+_DependentCallable: TypeAlias = Union[Callable[..., T], Callable[..., Awaitable[T]]]
+
+# driver hooks
+T_BotConnectionHook: TypeAlias = _DependentCallable[Any]
 """Bot 连接建立时钩子函数
 
 依赖参数:
@@ -53,7 +63,7 @@ T_BotConnectionHook = Callable[..., Awaitable[Any]]
 - BotParam: Bot 对象
 - DefaultParam: 带有默认值的参数
 """
-T_BotDisconnectionHook = Callable[..., Awaitable[Any]]
+T_BotDisconnectionHook: TypeAlias = _DependentCallable[Any]
 """Bot 连接断开时钩子函数
 
 依赖参数:
@@ -62,14 +72,17 @@ T_BotDisconnectionHook = Callable[..., Awaitable[Any]]
 - BotParam: Bot 对象
 - DefaultParam: 带有默认值的参数
 """
-T_CallingAPIHook = Callable[["Bot", str, Dict[str, Any]], Awaitable[Any]]
+
+# api hooks
+T_CallingAPIHook: TypeAlias = Callable[["Bot", str, Dict[str, Any]], Awaitable[Any]]
 """`bot.call_api` 钩子函数"""
-T_CalledAPIHook = Callable[
+T_CalledAPIHook: TypeAlias = Callable[
     ["Bot", Optional[Exception], str, Dict[str, Any], Any], Awaitable[Any]
 ]
 """`bot.call_api` 后执行的函数，参数分别为 bot, exception, api, data, result"""
 
-T_EventPreProcessor = Callable[..., Union[Any, Awaitable[Any]]]
+# event hooks
+T_EventPreProcessor: TypeAlias = _DependentCallable[Any]
 """事件预处理函数 EventPreProcessor 类型
 
 依赖参数:
@@ -80,7 +93,7 @@ T_EventPreProcessor = Callable[..., Union[Any, Awaitable[Any]]]
 - StateParam: State 对象
 - DefaultParam: 带有默认值的参数
 """
-T_EventPostProcessor = Callable[..., Union[Any, Awaitable[Any]]]
+T_EventPostProcessor: TypeAlias = _DependentCallable[Any]
 """事件预处理函数 EventPostProcessor 类型
 
 依赖参数:
@@ -91,7 +104,9 @@ T_EventPostProcessor = Callable[..., Union[Any, Awaitable[Any]]]
 - StateParam: State 对象
 - DefaultParam: 带有默认值的参数
 """
-T_RunPreProcessor = Callable[..., Union[Any, Awaitable[Any]]]
+
+# matcher run hooks
+T_RunPreProcessor: TypeAlias = _DependentCallable[Any]
 """事件响应器运行前预处理函数 RunPreProcessor 类型
 
 依赖参数:
@@ -103,8 +118,8 @@ T_RunPreProcessor = Callable[..., Union[Any, Awaitable[Any]]]
 - MatcherParam: Matcher 对象
 - DefaultParam: 带有默认值的参数
 """
-T_RunPostProcessor = Callable[..., Union[Any, Awaitable[Any]]]
+T_RunPostProcessor: TypeAlias = _DependentCallable[Any]
-"""事件响应器运行前预处理函数 RunPostProcessor 类型
+"""事件响应器运行后后处理函数 RunPostProcessor 类型
 
 依赖参数:
 
@@ -117,7 +132,8 @@ T_RunPostProcessor = Callable[..., Union[Any, Awaitable[Any]]]
 - DefaultParam: 带有默认值的参数
 """
 
-T_RuleChecker = Callable[..., Union[bool, Awaitable[bool]]]
+# rule, permission
+T_RuleChecker: TypeAlias = _DependentCallable[bool]
 """RuleChecker 即判断是否响应事件的处理函数。
 
 依赖参数:
@@ -128,7 +144,7 @@ T_RuleChecker = Callable[..., Union[bool, Awaitable[bool]]]
 - StateParam: State 对象
 - DefaultParam: 带有默认值的参数
 """
-T_PermissionChecker = Callable[..., Union[bool, Awaitable[bool]]]
+T_PermissionChecker: TypeAlias = _DependentCallable[bool]
 """PermissionChecker 即判断事件是否满足权限的处理函数。
 
 依赖参数:
@@ -139,10 +155,11 @@ T_PermissionChecker = Callable[..., Union[bool, Awaitable[bool]]]
 - DefaultParam: 带有默认值的参数
 """
 
-T_Handler = Callable[..., Any]
+T_Handler: TypeAlias = _DependentCallable[Any]
 """Handler 处理函数。"""
-T_TypeUpdater = Callable[..., Union[str, Awaitable[str]]]
+T_TypeUpdater: TypeAlias = _DependentCallable[str]
-"""TypeUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新响应的事件类型。默认会更新为 `message`。
+"""TypeUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新响应的事件类型。
+默认会更新为 `message`。
 
 依赖参数:
 
@@ -153,8 +170,9 @@ T_TypeUpdater = Callable[..., Union[str, Awaitable[str]]]
 - MatcherParam: Matcher 对象
 - DefaultParam: 带有默认值的参数
 """
-T_PermissionUpdater = Callable[..., Union["Permission", Awaitable["Permission"]]]
+T_PermissionUpdater: TypeAlias = _DependentCallable["Permission"]
-"""PermissionUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新会话对象权限。默认会更新为当前事件的触发对象。
+"""PermissionUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新会话对象权限。
+默认会更新为当前事件的触发对象。
 
 依赖参数:
 
@@ -165,5 +183,5 @@ T_PermissionUpdater = Callable[..., Union["Permission", Awaitable["Permission"]]
 - MatcherParam: Matcher 对象
 - DefaultParam: 带有默认值的参数
 """
-T_DependencyCache = Dict[Callable[..., Any], "Task[Any]"]
+T_DependencyCache: TypeAlias = Dict[_DependentCallable[Any], "Task[Any]"]
 """依赖缓存, 用于存储依赖函数的返回值"""

nonebot/utils.py

@@ -9,27 +9,31 @@ import re
 import json
 import asyncio
 import inspect
+import importlib
 import dataclasses
+from pathlib import Path
+from contextvars import copy_context
 from functools import wraps, partial
 from contextlib import asynccontextmanager
-from typing_extensions import ParamSpec, get_args, get_origin
+from typing_extensions import ParamSpec, get_args, override, get_origin
 from typing import (
     Any,
     Type,
     Tuple,
     Union,
+    Generic,
     TypeVar,
     Callable,
     Optional,
     Coroutine,
     AsyncGenerator,
     ContextManager,
+    overload,
 )
 
 from pydantic.typing import is_union, is_none_type
 
 from nonebot.log import logger
-from nonebot.typing import overrides
 
 P = ParamSpec("P")
 R = TypeVar("R")
@@ -54,8 +58,13 @@ def generic_check_issubclass(
 ) -> bool:
     """检查 cls 是否是 class_or_tuple 中的一个类型子类。
 
-    特别的，如果 cls 是 `typing.Union` 或 `types.UnionType` 类型，
+    特别的：
-    则会检查其中的类型是否是 class_or_tuple 中的一个类型子类。（None 会被忽略）
+
+    - 如果 cls 是 `typing.Union` 或 `types.UnionType` 类型，
+      则会检查其中的所有类型是否是 class_or_tuple 中一个类型的子类或 None。
+    - 如果 cls 是 `typing.TypeVar` 类型，
+      则会检查其 `__bound__` 或 `__constraints__`
+      是否是 class_or_tuple 中一个类型的子类或 None。
     """
     try:
         return issubclass(cls, class_or_tuple)
@@ -66,8 +75,18 @@ def generic_check_issubclass(
                 is_none_type(type_) or generic_check_issubclass(type_, class_or_tuple)
                 for type_ in get_args(cls)
             )
+        # ensure generic List, Dict can be checked
         elif origin:
             return issubclass(origin, class_or_tuple)
+        elif isinstance(cls, TypeVar):
+            if cls.__constraints__:
+                return all(
+                    is_none_type(type_)
+                    or generic_check_issubclass(type_, class_or_tuple)
+                    for type_ in cls.__constraints__
+                )
+            elif cls.__bound__:
+                return generic_check_issubclass(cls.__bound__, class_or_tuple)
         return False
 
 
@@ -108,7 +127,8 @@ def run_sync(call: Callable[P, R]) -> Callable[P, Coroutine[None, None, R]]:
     async def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
         loop = asyncio.get_running_loop()
         pfunc = partial(call, *args, **kwargs)
-        result = await loop.run_in_executor(None, pfunc)
+        context = copy_context()
+        result = await loop.run_in_executor(None, partial(context.run, pfunc))
         return result
 
     return _wrapper
@@ -129,11 +149,40 @@ 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,
+    return_on_err: None = 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]]:
+    """运行协程并当遇到指定异常时返回指定值。
+
+    参数:
+        coro: 要运行的协程
+        exc: 要捕获的异常
+        return_on_err: 当发生异常时返回的值
+
+    返回:
+        协程的返回值或发生异常时的指定值
+    """
+
     try:
         return await coro
     except exc:
@@ -147,10 +196,45 @@ def get_name(obj: Any) -> str:
     return obj.__class__.__name__
 
 
-class DataclassEncoder(json.JSONEncoder):
+def path_to_module_name(path: Path) -> str:
-    """在JSON序列化 {re}`nonebot.adapters._message.Message` (List[Dataclass]) 时使用的 `JSONEncoder`"""
+    """转换路径为模块名"""
+    rel_path = path.resolve().relative_to(Path.cwd().resolve())
+    if rel_path.stem == "__init__":
+        return ".".join(rel_path.parts[:-1])
+    else:
+        return ".".join(rel_path.parts[:-1] + (rel_path.stem,))
 
-    @overrides(json.JSONEncoder)
+
+def resolve_dot_notation(
+    obj_str: str, default_attr: str, default_prefix: Optional[str] = None
+) -> Any:
+    """解析并导入点分表示法的对象"""
+    modulename, _, cls = obj_str.partition(":")
+    if default_prefix is not None and modulename.startswith("~"):
+        modulename = default_prefix + modulename[1:]
+    module = importlib.import_module(modulename)
+    if not cls:
+        return getattr(module, default_attr)
+    instance = module
+    for attr_str in cls.split("."):
+        instance = getattr(instance, attr_str)
+    return instance
+
+
+class classproperty(Generic[T]):
+    """类属性装饰器"""
+
+    def __init__(self, func: Callable[[Any], T]) -> None:
+        self.func = func
+
+    def __get__(self, instance: Any, owner: Optional[Type[Any]] = None) -> T:
+        return self.func(type(instance) if owner is None else owner)
+
+
+class DataclassEncoder(json.JSONEncoder):
+    """可以序列化 {ref}`nonebot.adapters.Message`(List[Dataclass]) 的 `JSONEncoder`"""
+
+    @override
     def default(self, o):
         if dataclasses.is_dataclass(o):
             return {f.name: getattr(o, f.name) for f in dataclasses.fields(o)}
@@ -166,14 +250,16 @@ def logger_wrapper(logger_name: str):
     返回:
         日志记录函数
 
-            - level: 日志等级
+        日志记录函数的参数:
-            - message: 日志信息
+
-            - exception: 异常信息
+        - level: 日志等级
+        - message: 日志信息
+        - exception: 异常信息
     """
 
     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,10 +11,12 @@
     "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/\"",
+    "pyright": "pyright"
   },
   "devDependencies": {
     "cross-env": "^7.0.3",
-    "prettier": "^2.5.0"
+    "prettier": "^2.5.0",
+    "pyright": "^1.1.317"
   }
 }

packages/nonebot-plugin-docs/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <a href="https://v2.nonebot.dev/"><img src="https://raw.githubusercontent.com/nonebot/nonebot2/master/docs/.vuepress/public/logo.png" width="200" height="200" alt="nonebot"></a>
+  <a href="https://nonebot.dev/"><img src="https://nonebot.dev/logo.png" width="200" height="200" alt="nonebot"></a>
 </p>
 
 <div align="center">
@@ -17,11 +17,11 @@ _✨ 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>
 
 ## 使用方式
 
-加载插件并启动 Bot ，在浏览器内打开 `http://host:port/docs/`。
+加载插件并启动 Bot ，在浏览器内打开 `http://host:port/website/`。
 
 具体网址会在控制台内输出。

packages/nonebot-plugin-docs/nonebot_plugin_docs/__init__.py

@@ -2,6 +2,17 @@ import importlib
 
 import nonebot
 from nonebot.log import logger
+from nonebot.plugin import PluginMetadata
+
+__plugin_meta__ = PluginMetadata(
+    name="NoneBot 离线文档",
+    description="在本地查看 NoneBot 文档",
+    usage="启动机器人后访问 http://localhost:port/website/ 查看文档",
+    type="application",
+    homepage="https://github.com/nonebot/nonebot2/blob/master/packages/nonebot-plugin-docs",
+    config=None,
+    supported_adapters=None,
+)
 
 
 def init():
@@ -17,7 +28,7 @@ def init():
     register_route(driver)
     host = str(driver.config.host)
     port = driver.config.port
-    if host in ["0.0.0.0", "127.0.0.1"]:
+    if host in {"0.0.0.0", "127.0.0.1"}:
         host = "localhost"
     logger.opt(colors=True).info(
         f"Nonebot docs will be running at: "

packages/nonebot-plugin-docs/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "nonebot-plugin-docs"
-version = "2.0.0-beta.1"
+version = "2.0.0"
 description = "View NoneBot2 Docs Locally"
 authors = ["yanyongyu <yyy@nonebot.dev>"]
 license = "MIT"
@@ -12,8 +12,8 @@ include = ["nonebot_plugin_docs/dist/**/*"]
 
 
 [tool.poetry.dependencies]
-python = "^3.7.3"
+python = "^3.8"
-nonebot2 = "^2.0.0-beta.1"
+nonebot2 = "^2.0.0"
 
 [tool.poetry.dev-dependencies]
 

pyproject.toml

@@ -1,74 +1,81 @@
 [tool.poetry]
 name = "nonebot2"
-version = "2.0.0-beta.4"
+version = "2.1.0"
 description = "An asynchronous python bot framework."
 authors = ["yanyongyu <yyy@nonebot.dev>"]
 license = "MIT"
 readme = "README.md"
-homepage = "https://v2.nonebot.dev/"
+homepage = "https://nonebot.dev/"
 repository = "https://github.com/nonebot/nonebot2"
-documentation = "https://v2.nonebot.dev/"
+documentation = "https://nonebot.dev/"
 keywords = ["bot", "qq", "qqbot", "mirai", "coolq"]
 classifiers = [
   "Development Status :: 5 - Production/Stable",
   "Framework :: Robot Framework",
   "Framework :: Robot Framework :: Library",
   "Operating System :: OS Independent",
-  "Programming Language :: Python :: 3"
+  "Programming Language :: Python :: 3",
-]
-packages = [
-  { include = "nonebot" },
 ]
+packages = [{ include = "nonebot" }]
 include = ["nonebot/py.typed"]
 
-[tool.poetry.dependencies]
+[tool.poetry.urls]
-python = "^3.7.3"
+"Bug Tracker" = "https://github.com/nonebot/nonebot2/issues"
-yarl = "^1.7.2"
+"Changelog" = "https://nonebot.dev/changelog"
-loguru = "^0.6.0"
+"Funding" = "https://afdian.net/@nonebot"
-pygtrie = "^2.4.1"
-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 }
 
-[tool.poetry.dev-dependencies]
+[tool.poetry.dependencies]
+python = "^3.8"
+yarl = "^1.7.2"
+pygtrie = "^2.4.1"
+loguru = ">=0.6.0,<1.0.0"
+typing-extensions = ">=4.4.0,<5.0.0"
+tomli = { version = "^2.0.1", python = "<3.11" }
+pydantic = { version = "^1.10.0", extras = ["dotenv"] }
+
+websockets = { version = ">=10.0", optional = true }
+Quart = { version = ">=0.18.0,<1.0.0", optional = true }
+fastapi = { version = ">=0.93.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]
 isort = "^5.10.1"
-black = "^22.1.0"
+black = "^23.1.0"
-pytest-cov = "^3.0.0"
+nonemoji = "^0.1.2"
-pre-commit = "^2.16.0"
+pre-commit = "^3.0.0"
-pytest-xdist = "^2.5.0"
+ruff = ">=0.0.272,<1.0.0"
-pytest-asyncio = "^0.18.1"
+
-nonebug = { git = "https://github.com/nonebot/nonebug.git" }
+[tool.poetry.group.test.dependencies]
-nb-autodoc = { git = "https://github.com/nonebot/nb-autodoc.git" }
+nonebug = "^0.3.0"
+werkzeug = "^2.3.6"
+pytest-cov = "^4.0.0"
+pytest-xdist = "^3.0.2"
+pytest-asyncio = "^0.21.0"
+coverage-conditional-plugin = "^0.9.0"
+
+[tool.poetry.group.docs.dependencies]
+nb-autodoc = "^1.0.0a5"
 
 [tool.poetry.extras]
-quart = ["quart"]
 httpx = ["httpx"]
 aiohttp = ["aiohttp"]
 websockets = ["websockets"]
-all = ["quart", "aiohttp", "httpx", "websockets"]
+quart = ["quart", "uvicorn"]
-
+fastapi = ["fastapi", "uvicorn"]
-# [[tool.poetry.source]]
+all = ["fastapi", "quart", "aiohttp", "httpx", "websockets", "uvicorn"]
-# name = "aliyun"
-# url = "https://mirrors.aliyun.com/pypi/simple/"
-# default = true
 
 [tool.pytest.ini_options]
-asyncio_mode = "auto"
+asyncio_mode = "strict"
-addopts = "--cov=nonebot --cov-report=term-missing"
+addopts = "--cov=nonebot --cov-append --cov-report=term-missing"
-filterwarnings = [
+filterwarnings = ["error", "ignore::DeprecationWarning"]
-    "error",
-    "ignore::DeprecationWarning",
-]
 
 [tool.black]
 line-length = 88
-target-version = ["py37", "py38", "py39", "py310"]
+target-version = ["py38", "py39", "py310", "py311"]
 include = '\.pyi?$'
 extend-exclude = '''
 '''
@@ -82,6 +89,31 @@ force_sort_within_sections = true
 src_paths = ["nonebot", "tests"]
 extra_standard_library = ["typing_extensions"]
 
+[tool.ruff]
+select = ["E", "W", "F", "UP", "C", "T", "PYI", "PT", "Q"]
+ignore = ["E402", "C901", "UP037"]
+
+line-length = 88
+target-version = "py38"
+
+[tool.ruff.flake8-pytest-style]
+fixture-parentheses = false
+mark-parentheses = false
+
+[tool.pyright]
+pythonVersion = "3.8"
+pythonPlatform = "All"
+executionEnvironments = [
+  { root = "./tests", extraPaths = [
+    "./",
+  ] },
+  { root = "./" },
+]
+
+typeCheckingMode = "basic"
+reportShadowedImports = false
+
+
 [build-system]
 requires = ["poetry_core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"

tests/.coveragerc

@@ -1,8 +1,26 @@
+[run]
+plugins =
+  coverage_conditional_plugin
+
 [report]
 exclude_lines =
-  def __repr__
   pragma: no cover
-  if TYPE_CHECKING:
+  def __repr__
+  def __str__
+  @(typing\.)?overload
+  if (typing\.)?TYPE_CHECKING( is True)?:
   @(abc\.)?abstractmethod
   raise NotImplementedError
+  warnings\.warn
+  \.\.\.
+  pass
   if __name__ == .__main__.:
+
+[coverage_conditional_plugin]
+rules =
+  "sys_platform != 'win32'": py-win32
+  "sys_platform != 'linux'": py-linux
+  "sys_platform != 'darwin'": py-darwin
+  "sys_version_info < (3, 9)": py-gte-39
+  "sys_version_info < (3, 11)": py-gte-311
+  "sys_version_info >= (3, 11)": py-lt-311

tests/.env

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

tests/.env.test

@@ -1,5 +1,15 @@
 LOG_LEVEL=TRACE
 NICKNAME=["test"]
 SUPERUSERS=["test", "fake:faketest"]
+API_TIMEOUT
+SIMPLE_NONE
+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/conftest.py

@@ -1,21 +1,64 @@
+import os
+import threading
 from pathlib import Path
-from typing import TYPE_CHECKING, Set
+from typing import TYPE_CHECKING, Set, Generator
 
 import pytest
+from nonebug import NONEBOT_INIT_KWARGS
+from werkzeug.serving import BaseWSGIServer, make_server
+
+import nonebot
+from nonebot.config import Env
+from fake_server import request_handler
+from nonebot.drivers import URL, Driver
+from nonebot import _resolve_combine_expr
+
+os.environ["CONFIG_FROM_ENV"] = '{"test": "test"}'
+os.environ["CONFIG_OVERRIDE"] = "new"
 
 if TYPE_CHECKING:
     from nonebot.plugin import Plugin
 
 
-@pytest.fixture
+def pytest_configure(config: pytest.Config) -> None:
-def load_plugin(nonebug_init: None) -> Set["Plugin"]:
+    config.stash[NONEBOT_INIT_KWARGS] = {"config_from_init": "init"}
-    import nonebot
 
+
+@pytest.fixture(name="driver")
+def load_driver(request: pytest.FixtureRequest) -> Driver:
+    driver_name = getattr(request, "param", None)
+    global_driver = nonebot.get_driver()
+    if driver_name is None:
+        return global_driver
+
+    DriverClass = _resolve_combine_expr(driver_name)
+    return DriverClass(Env(environment=global_driver.env), global_driver.config)
+
+
+@pytest.fixture(scope="session", autouse=True)
+def load_plugin(nonebug_init: None) -> Set["Plugin"]:
+    # preload global plugins
     return nonebot.load_plugins(str(Path(__file__).parent / "plugins"))
 
 
-@pytest.fixture
+@pytest.fixture(scope="session", autouse=True)
-def load_example(nonebug_init: None) -> Set["Plugin"]:
+def load_builtin_plugin(nonebug_init: None) -> Set["Plugin"]:
-    import nonebot
+    # preload builtin plugins
+    return nonebot.load_builtin_plugins("echo", "single_session")
 
-    return nonebot.load_plugins(str(Path(__file__).parent / "examples"))
+
+@pytest.fixture(scope="session", autouse=True)
+def server() -> Generator[BaseWSGIServer, None, None]:
+    server = make_server("127.0.0.1", 0, app=request_handler)
+    thread = threading.Thread(target=server.serve_forever)
+    thread.start()
+    try:
+        yield server
+    finally:
+        server.shutdown()
+        thread.join()
+
+
+@pytest.fixture(scope="session")
+def server_url(server: BaseWSGIServer) -> URL:
+    return URL(f"http://{server.host}:{server.port}")

tests/examples/weather.py

@@ -1,29 +0,0 @@
-from nonebot import on_command
-from nonebot.rule import to_me
-from nonebot.matcher import Matcher
-from nonebot.adapters import Message
-from nonebot.params import Arg, CommandArg, ArgPlainText
-
-weather = on_command("weather", rule=to_me(), aliases={"天气", "天气预报"}, priority=5)
-
-
-@weather.handle()
-async def handle_first_receive(matcher: Matcher, args: Message = CommandArg()):
-    plain_text = args.extract_plain_text()  # 首次发送命令时跟随的参数，例：/天气 上海，则args为上海
-    if plain_text:
-        matcher.set_arg("city", args)  # 如果用户发送了参数则直接赋值
-
-
-@weather.got("city", prompt="你想查询哪个城市的天气呢？")
-async def handle_city(city: Message = Arg(), city_name: str = ArgPlainText("city")):
-    if city_name not in ["北京", "上海"]:  # 如果参数不符合要求，则提示用户重新输入
-        # 可以使用平台的 Message 类直接构造模板消息
-        await weather.reject(city.template("你想查询的城市 {city} 暂不支持，请重新输入！"))
-
-    city_weather = await get_weather(city_name)
-    await weather.finish(city_weather)
-
-
-# 在这里编写获取天气信息的函数
-async def get_weather(city: str) -> str:
-    return f"{city}的天气是..."

tests/fake_server.py

@@ -0,0 +1,69 @@
+import json
+import base64
+from typing import Dict, List, Union, TypeVar
+
+from werkzeug import Request, Response
+from werkzeug.datastructures import MultiDict
+
+K = TypeVar("K")
+V = TypeVar("V")
+
+
+def json_safe(string, content_type="application/octet-stream") -> str:
+    try:
+        string = string.decode("utf-8")
+        json.dumps(string)
+        return string
+    except (ValueError, TypeError):
+        return b"".join(
+            [
+                b"data:",
+                content_type.encode("utf-8"),
+                b";base64,",
+                base64.b64encode(string),
+            ]
+        ).decode("utf-8")
+
+
+def flattern(d: "MultiDict[K, V]") -> Dict[K, Union[V, List[V]]]:
+    return {k: v[0] if len(v) == 1 else v for k, v in d.to_dict(flat=False).items()}
+
+
+@Request.application
+def request_handler(request: Request) -> Response:
+    try:
+        _json = json.loads(request.data.decode("utf-8"))
+    except (ValueError, TypeError):
+        _json = None
+
+    return Response(
+        json.dumps(
+            {
+                "url": request.url,
+                "method": request.method,
+                "origin": request.headers.get("X-Forwarded-For", request.remote_addr),
+                "headers": flattern(
+                    MultiDict((k, v) for k, v in request.headers.items())
+                ),
+                "args": flattern(request.args),
+                "form": flattern(request.form),
+                "data": json_safe(request.data),
+                "json": _json,
+                "files": flattern(
+                    MultiDict(
+                        (
+                            k,
+                            json_safe(
+                                v.read(),
+                                request.files[k].content_type
+                                or "application/octet-stream",
+                            ),
+                        )
+                        for k, v in request.files.items()
+                    )
+                ),
+            }
+        ),
+        status=200,
+        content_type="application/json",
+    )

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": []
+}

tests/plugins.toml

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