🔖 Release 2.3.0

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

.eslintignore

@@ -0,0 +1,6 @@
+dist
+node_modules
+.yarn
+.history
+build
+lib

.eslintrc.js

@@ -0,0 +1,85 @@
+module.exports = {
+  root: true,
+  env: {
+    browser: true,
+    commonjs: true,
+    node: true,
+  },
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    tsconfigRootDir: __dirname,
+    project: ["./tsconfig.json", "./website/tsconfig.json"],
+  },
+  globals: {
+    JSX: true,
+  },
+  extends: [
+    "eslint:recommended",
+    "plugin:react/recommended",
+    "plugin:react-hooks/recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:import/recommended",
+    "plugin:regexp/recommended",
+    "plugin:prettier/recommended",
+  ],
+  settings: {
+    "import/resolver": {
+      node: {
+        extensions: [".js", ".jsx", ".ts", ".tsx"],
+      },
+      typescript: true,
+    },
+    react: {
+      version: "detect",
+    },
+  },
+  overrides: [
+    {
+      files: ["*.ts", "*.tsx"],
+      rules: {
+        "import/no-unresolved": "off",
+      },
+    },
+    {
+      files: ["*.js", "*.cjs"],
+      rules: {
+        "@typescript-eslint/no-var-requires": "off",
+      },
+    },
+  ],
+  plugins: ["@typescript-eslint"],
+  rules: {
+    "linebreak-style": ["error", "unix"],
+    quotes: ["error", "double", { avoidEscape: true }],
+    semi: ["error", "always"],
+    "@typescript-eslint/no-non-null-assertion": "off",
+    "import/order": [
+      "error",
+      {
+        groups: [
+          "builtin",
+          "external",
+          "internal",
+          "parent",
+          "sibling",
+          "index",
+        ],
+        pathGroups: [
+          { pattern: "react", group: "builtin", position: "before" },
+          { pattern: "fs-extra", group: "builtin" },
+          { pattern: "lodash", group: "external", position: "before" },
+          { pattern: "clsx", group: "external", position: "before" },
+          { pattern: "@theme/**", group: "internal" },
+          { pattern: "@site/**", group: "internal" },
+          { pattern: "@theme-init/**", group: "internal" },
+          { pattern: "@theme-original/**", group: "internal" },
+        ],
+        pathGroupsExcludedImportTypes: [],
+        "newlines-between": "always",
+        alphabetize: {
+          order: "asc",
+        },
+      },
+    ],
+  },
+};

.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
-  - 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
+    about: 前往 NoneBot 论坛提问

.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,18 +4,10 @@ description: Setup Node
 runs:
   using: "composite"
   steps:
-    - uses: actions/setup-node@v2
+    - uses: actions/setup-node@v4
       with:
-        node-version: "16"
+        node-version: "18"
+        cache: "yarn"
 
-    - id: yarn-cache-dir-path
-      run: echo "::set-output name=dir::$(yarn cache dir)"
-      shell: bash
-
-    - uses: actions/cache@v2
-      with:
-        path: ${{ steps.yarn-cache-dir-path.outputs.dir }}
-        key: ${{ runner.os }}-yarn-${{ hashFiles('**/yarn.lock') }}
-
-    - run: yarn install
+    - run: yarn install --frozen-lockfile
       shell: bash

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

@@ -5,27 +5,36 @@ inputs:
   python-version:
     description: Python version
     required: false
-    default: "3.9"
+    default: "3.10"
+  env-dir:
+    description: Environment directory
+    required: false
+    default: "."
+  no-root:
+    description: Do not install package in the environment
+    required: false
+    default: "false"
 
 runs:
   using: "composite"
   steps:
-    - id: python
-      uses: actions/setup-python@v2
+    - name: Install poetry
+      run: pipx install poetry
+      shell: bash
+
+    - uses: actions/setup-python@v5
       with:
         python-version: ${{ inputs.python-version }}
-        architecture: "x64"
+        cache: "poetry"
+        cache-dependency-path: |
+          ./poetry.lock
+          ${{ inputs.env-dir }}/poetry.lock
 
-    - 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
+    - run: |
+        cd ${{ inputs.env-dir }}
+        if [ "${{ inputs.no-root }}" = "true" ]; then
+          poetry install --all-extras --no-root
+        else
+          poetry install --all-extras
+        fi
       shell: bash

.github/dependabot.yml

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

.github/workflows/codecov.yml

@@ -5,39 +5,54 @@ on:
     branches:
       - master
   pull_request:
+    paths:
+      - "envs/**"
+      - "nonebot/**"
+      - "packages/**"
+      - "tests/**"
+      - ".github/actions/setup-python/**"
+      - ".github/workflows/codecov.yml"
+      - "pyproject.toml"
+      - "poetry.lock"
 
 jobs:
   test:
     name: Test Coverage
     runs-on: ${{ matrix.os }}
     concurrency:
-      group: test-coverage-${{ github.ref }}-${{ matrix.os }}-${{ matrix.python-version }}
+      group: test-coverage-${{ github.ref }}-${{ matrix.os }}-${{ matrix.python-version }}-${{ matrix.env }}
       cancel-in-progress: true
     strategy:
-      matrix:
-        python-version: ["3.7", "3.8", "3.9", "3.10"]
-        os: [ubuntu-latest, windows-latest, macos-latest]
       fail-fast: false
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        env: [pydantic-v1, pydantic-v2]
     env:
       OS: ${{ matrix.os }}
       PYTHON_VERSION: ${{ matrix.python-version }}
+      PYDANTIC_VERSION: ${{ matrix.env }}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Setup Python environment
         uses: ./.github/actions/setup-python
         with:
           python-version: ${{ matrix.python-version }}
+          env-dir: ./envs/${{ matrix.env }}
+          no-root: true
 
       - name: Run Pytest
         run: |
-          cd tests/
-          poetry run pytest -n auto --cov-report xml
+          cd ./envs/${{ matrix.env }}
+          poetry run bash "../../scripts/run-tests.sh"
 
       - name: Upload coverage report
-        uses: codecov/codecov-action@v3
+        uses: codecov/codecov-action@v4
         with:
-          env_vars: OS,PYTHON_VERSION
+          env_vars: OS,PYTHON_VERSION,PYDANTIC_VERSION
           files: ./tests/coverage.xml
           flags: unittests
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/noneflow.yml

@@ -0,0 +1,141 @@
+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:
+  check:
+    runs-on: ubuntu-latest
+    name: check
+    # do not run on forked PRs, do not run on not related issues, do not run on pr comments
+    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
+        )
+      )
+    steps:
+      - run: echo "Check passed"
+  reaction:
+    runs-on: ubuntu-latest
+    name: reaction
+    needs: check
+    if: |
+      (
+        github.event_name == 'issue_comment' &&
+        github.event.action == 'created'
+      ) ||
+      (
+        github.event_name == 'issues' &&
+        github.event.action == 'opened'
+      )
+    steps:
+      - name: Generate token
+        id: generate-token
+        uses: tibdex/github-app-token@v2
+        with:
+          app_id: ${{ secrets.APP_ID }}
+          private_key: ${{ secrets.APP_KEY }}
+
+      - name: Reaction on issue
+        if: github.event_name == 'issues'
+        run: |
+          gh api --method POST /repos/${{ github.repository }}/issues/${{ github.event.issue.number }}/reactions -f "content=rocket"
+        env:
+          GH_TOKEN: ${{ steps.generate-token.outputs.token }}
+
+      - name: Reaction on issue comment
+        if: github.event_name == 'issue_comment'
+        run: |
+          gh api --method POST /repos/${{ github.repository }}/issues/comments/${{ github.event.comment.id }}/reactions -f "content=rocket"
+        env:
+          GH_TOKEN: ${{ steps.generate-token.outputs.token }}
+  plugin_test:
+    runs-on: ubuntu-latest
+    name: nonebot2 plugin test
+    needs: check
+    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@v5
+        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@v2
+        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@v4
+        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": "assets/plugins.json",
+              "bot_path": "assets/bots.json",
+              "adapter_path": "assets/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,47 @@
+name: Pyright Lint
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    paths:
+      - "envs/**"
+      - "nonebot/**"
+      - "packages/**"
+      - "tests/**"
+      - ".github/actions/setup-python/**"
+      - ".github/workflows/pyright.yml"
+      - "pyproject.toml"
+      - "poetry.lock"
+
+jobs:
+  pyright:
+    name: Pyright Lint
+    runs-on: ubuntu-latest
+    concurrency:
+      group: pyright-${{ github.ref }}-${{ matrix.env }}
+      cancel-in-progress: true
+    strategy:
+      matrix:
+        env: [pydantic-v1, pydantic-v2]
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Python environment
+        uses: ./.github/actions/setup-python
+        with:
+          env-dir: ./envs/${{ matrix.env }}
+          no-root: true
+
+      - run: |
+          (cd ./envs/${{ matrix.env }} && echo "$(poetry env info --path)/bin" >> $GITHUB_PATH)
+          if [ "${{ matrix.env }}" = "pydantic-v1" ]; then
+            sed -i 's/PYDANTIC_V2 = true/PYDANTIC_V2 = false/g' ./pyproject.toml
+          fi
+        shell: bash
+
+      - name: Run Pyright
+        uses: jakebailey/pyright-action@v2

.github/workflows/release-drafter.yml

@@ -18,24 +18,31 @@ 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@v2
         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
 
-      - uses: release-drafter/release-drafter@v5
+      - uses: release-drafter/release-drafter@v6
         id: release-drafter
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ steps.generate-token.outputs.token }}
 
       - name: Update Changelog
         uses: docker://ghcr.io/nonebot/auto-changelog:master
         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,27 @@ jobs:
       - name: Commit and Push
         run: |
           yarn prettier
-          git config user.name github-actions[bot]
-          git config user.email github-actions[bot]@users.noreply.github.com
+          git config user.name noneflow[bot]
+          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
+    permissions:
+      id-token: write
+      contents: write
     steps:
-      - uses: actions/checkout@v3
+      - name: Generate token
+        id: generate-token
+        uses: tibdex/github-app-token@v2
+        with:
+          app_id: ${{ secrets.APP_ID }}
+          private_key: ${{ secrets.APP_KEY }}
+
+      - uses: actions/checkout@v4
 
       - name: Setup Python Environment
         uses: ./.github/actions/setup-python
@@ -65,33 +81,53 @@ jobs:
       - name: Build API Doc
         uses: ./.github/actions/build-api-doc
 
-      - run: |
-          echo "TAG_NAME=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
+      - name: Get Version
+        id: version
+        run: |
+          echo "VERSION=$(poetry version -s)" >> $GITHUB_OUTPUT
+          echo "TAG_VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_OUTPUT
+          echo "TAG_NAME=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
 
-      - uses: release-drafter/release-drafter@v5
+      - name: Check Version
+        if: steps.version.outputs.VERSION != steps.version.outputs.TAG_VERSION
+        run: exit 1
+
+      - uses: release-drafter/release-drafter@v6
         with:
-          name: Release ${{ env.TAG_NAME }} 🌈
-          tag: ${{ env.TAG_NAME }}
+          name: Release ${{ steps.version.outputs.TAG_NAME }} 🌈
+          tag: ${{ steps.version.outputs.TAG_NAME }}
           publish: true
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ steps.generate-token.outputs.token }}
 
-      - name: Build and Publish Package
+      - name: Build Package
         run: |
           poetry build
-          poetry publish -u ${{secrets.PYPI_USERNAME}} -p ${{secrets.PYPI_PASSWORD}}
-          gh release upload --clobber ${{ env.TAG_NAME }} dist/*.tar.gz dist/*.whl
+
+      - name: Publish package to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+      - name: Publish package to GitHub
+        run: |
+          gh release upload --clobber ${{ steps.version.outputs.TAG_NAME }} dist/*.tar.gz dist/*.whl
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ steps.generate-token.outputs.token }}
 
       - name: Build and Publish Doc Package
         run: |
           yarn build:plugin --out-dir ../packages/nonebot-plugin-docs/nonebot_plugin_docs/dist
-          export NONEBOT_VERSION=`poetry version -s`
           cd packages/nonebot-plugin-docs/
-          poetry version $NONEBOT_VERSION
+          poetry version ${{ steps.version.outputs.VERSION }}
           poetry build
-          poetry publish -u ${{secrets.PYPI_USERNAME}} -p ${{secrets.PYPI_PASSWORD}}
-          gh release upload --clobber ${{ env.TAG_NAME }} dist/*.tar.gz dist/*.whl
+
+      - name: Publish Doc Package to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: packages/nonebot-plugin-docs/dist/
+
+      - name: Publish Doc Package to GitHub
+        run: |
+          cd packages/nonebot-plugin-docs/
+          gh release upload --clobber ${{ steps.version.outputs.TAG_NAME }} dist/*.tar.gz dist/*.whl
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ steps.generate-token.outputs.token }}

.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@v2
         with:
-          ref: master
-          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 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.email github-actions[bot]@users.noreply.github.com
+          git config user.name noneflow[bot]
+          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,30 @@
+name: Ruff Lint
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    paths:
+      - "envs/**"
+      - "nonebot/**"
+      - "packages/**"
+      - "tests/**"
+      - ".github/actions/setup-python/**"
+      - ".github/workflows/ruff.yml"
+      - "pyproject.toml"
+      - "poetry.lock"
+
+jobs:
+  ruff:
+    name: Ruff Lint
+    runs-on: ubuntu-latest
+    concurrency:
+      group: pyright-${{ github.ref }}
+      cancel-in-progress: true
+
+    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@v3
         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@v3
         with:
           publish-dir: "./website/build"
           production-deploy: false

.gitignore

@@ -139,7 +139,7 @@ fabric.properties
 .LSOverride
 
 # Icon must end with two \r
-Icon
+# Icon
 
 # Thumbnails
 ._*

.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.4.2
+    hooks:
+      - id: ruff
+        args: [--fix, --exit-non-zero-on-fix]
+        stages: [commit]
+
   - repo: https://github.com/pycqa/isort
-    rev: 5.10.1
+    rev: 5.13.2
     hooks:
       - id: isort
+        stages: [commit]
 
   - repo: https://github.com/psf/black
-    rev: 22.3.0
+    rev: 24.4.2
     hooks:
       - id: black
+        stages: [commit]
 
   - repo: https://github.com/pre-commit/mirrors-prettier
-    rev: v2.6.2
+    rev: v4.0.0-alpha.8
     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]

.prettierrc

@@ -5,5 +5,17 @@
   "arrowParens": "always",
   "singleQuote": false,
   "trailingComma": "es5",
-  "semi": true
+  "semi": true,
+  "overrides": [
+    {
+      "files": [
+        "**/devcontainer.json",
+        "**/tsconfig.json",
+        "**/tsconfig.*.json"
+      ],
+      "options": {
+        "parser": "json"
+      }
+    }
+  ]
 }

.stylelintrc.js

@@ -0,0 +1,31 @@
+module.exports = {
+  extends: ["stylelint-config-standard", "stylelint-prettier/recommended"],
+  overrides: [
+    {
+      files: ["*.css"],
+      rules: {
+        "function-no-unknown": [true, { ignoreFunctions: ["theme"] }],
+        "selector-class-pattern": [
+          "^([a-z][a-z0-9]*)(-[a-z0-9]+)*$",
+          {
+            resolveNestedSelectors: true,
+            message: (selector) =>
+              `Expected class selector "${selector}" to be kebab-case`,
+          },
+        ],
+      },
+    },
+    {
+      files: ["*.module.css"],
+      rules: {
+        "selector-class-pattern": [
+          "^[a-z][a-zA-Z0-9]+$",
+          {
+            message: (selector) =>
+              `Expected class selector "${selector}" to be lowerCamelCase`,
+          },
+        ],
+      },
+    },
+  ],
+};

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>

CITATION.cff

@@ -0,0 +1,26 @@
+# This CITATION.cff file was generated with cffinit.
+# Visit https://bit.ly/cffinit to generate yours today!
+
+cff-version: 1.2.0
+title: NoneBot
+message: >-
+  If you use this software, please cite it using the
+  metadata from this file.
+type: software
+authors:
+  - given-names: Yongyu
+    family-names: Yan
+    email: yyy@nonebot.dev
+  - name: NoneBot Team
+    email: contact@nonebot.dev
+    website: 'https://github.com/nonebot'
+repository-code: 'https://github.com/nonebot/nonebot2'
+url: 'https://nonebot.dev/'
+abstract: >-
+  NoneBot, an asynchronous multi-platform chatbot framework
+  written in Python
+keywords:
+  - nonebot
+  - chatbot
+  - pydantic
+license: MIT

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.9+-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,23 +39,35 @@ _✨ 跨平台 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">
-    <img src="https://img.shields.io/badge/%E9%92%89%E9%92%89-Bot-lightgrey?style=social&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAMAAACdt4HsAAAAnFBMVEUAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD4jUzeAAAAM3RSTlMAQKSRaA+/f0YyFevh29R3cyklIfrlyrGsn41tVUs48c/HqJm9uZdhX1otGwkF9IN8V1CX0Q+IAAABY0lEQVRYw+3V2W7CMBAF0JuNQAhhX9OEfYdu9///rUVWpagE27Ef2gfO+0zGozsKnv6bMGzAhkNytIe5gDdzrwtTCwrbI8x4/NF668NAxgI3Q3UtFi3TyPwNQtPLUUmDd8YfqGLNe4v22XwEYb5zoOuF5baHq2UHtsKe5ivWfGAwrWu2mC34QM0PoCAuqZdOmiwV+5BLyMRtZ7dTSEcs48rzWfzwptMLyzpApka1SJ5FtR4kfCqNIBPEVDmqoqgwUYY5plQOlf6UEjNoOPnuKB6wzDyCrks///TDza8+PnR109WQdxLo8RKWq0PPnuXG0OXKQ6wWLFnCg75uYYbhmMIVVdQ709q33aHbGIj6Duz+2k1HQFX9VwqmY8xYsEJll2ahvhWgsjYLHFRXvIi2Qb0jzMQCzC3FAoydxCma88UCzE3JCWwkjCNYyMUCzHX4DiuTMawEwwhW6hnshPhjZzzJfAH0YacpbmRd7QAAAABJRU5ErkJggg==" alt="ding">
-  </a>
-  <a href="https://core.telegram.org/bots/api">
-    <img src="https://img.shields.io/badge/telegram-Bot-lightgrey?style=social&logo=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">
+  <a href="https://onebot.dev/">
+    <img src="https://img.shields.io/badge/OneBot-v12-black?style=social&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABABAMAAABYR2ztAAAAIVBMVEUAAAAAAAADAwMHBwceHh4UFBQNDQ0ZGRkoKCgvLy8iIiLWSdWYAAAAAXRSTlMAQObYZgAAAQVJREFUSMftlM0RgjAQhV+0ATYK6i1Xb+iMd0qgBEqgBEuwBOxU2QDKsjvojQPvkJ/ZL5sXkgWrFirK4MibYUdE3OR2nEpuKz1/q8CdNxNQgthZCXYVLjyoDQftaKuniHHWRnPh2GCUetR2/9HsMAXyUT4/3UHwtQT2AggSCGKeSAsFnxBIOuAggdh3AKTL7pDuCyABcMb0aQP7aM4AnAbc/wHwA5D2wDHTTe56gIIOUA/4YYV2e1sg713PXdZJAuncdZMAGkAukU9OAn40O849+0ornPwT93rphWF0mgAbauUrEOthlX8Zu7P5A6kZyKCJy75hhw1Mgr9RAUvX7A3csGqZegEdniCx30c3agAAAABJRU5ErkJggg==" alt="onebot">
   </a>
   <a href="https://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频道">
+    <img src="https://img.shields.io/badge/QQ-Bot-lightgrey?style=social&logo=data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMTIuODIgMTMwLjg5Ij48ZyBkYXRhLW5hbWU9IuWbvuWxgiAyIj48ZyBkYXRhLW5hbWU9IuWbvuWxgiAxIj48cGF0aCBkPSJNNTUuNjMgMTMwLjhjLTcgMC0xMy45LjA4LTIwLjg2IDAtMTkuMTUtLjI1LTMxLjcxLTExLjQtMzQuMjItMzAuMy00LjA3LTMwLjY2IDE0LjkzLTU5LjIgNDQuODMtNjYuNjQgMi0uNTEgNS4yMS0uMzEgNS4yMS0xLjYzIDAtMi4xMy4xNC0yLjEzLjE0LTUuNTcgMC0uODktMS4zLTEuNDYtMi4yMi0yLjMxLTYuNzMtNi4yMy03LjY3LTEzLjQxLTEtMjAuMTggNS40LTUuNTIgMTEuODctNS40IDE3LjgtLjU5IDYuNDkgNS4yNiA2LjMxIDEzLjA4LS44NiAyMS0uNjguNzQtMS43OCAxLjYtMS43OCAyLjY3djQuMjFjMCAxLjM1IDIuMiAxLjYyIDQuNzkgMi4zNSAzMS4wOSA4LjY1IDQ4LjE3IDM0LjEzIDQ1IDY2LjM3LTEuNzYgMTguMTUtMTQuNTYgMzAuMjMtMzIuNyAzMC42My04LjAyLjE5LTE2LjA3LS4wMS0yNC4xMy0uMDF6IiBmaWxsPSIjMDI5OWZlIi8+PHBhdGggZD0iTTMxLjQ2IDExOC4zOGMtMTAuNS0uNjktMTYuOC02Ljg2LTE4LjM4LTE3LjI3LTMtMTkuNDIgMi43OC0zNS44NiAxOC40Ni00Ny44MyAxNC4xNi0xMC44IDI5Ljg3LTEyIDQ1LjM4LTMuMTkgMTcuMjUgOS44NCAyNC41OSAyNS44MSAyNCA0NS4yOS0uNDkgMTUuOS04LjQyIDIzLjE0LTI0LjM4IDIzLjUtNi41OS4xNC0xMy4xOSAwLTE5Ljc5IDAiIGZpbGw9IiNmZWZlZmUiLz48cGF0aCBkPSJNNDYuMDUgNzkuNThjLjA5IDUgLjIzIDkuODItNyA5Ljc3LTcuODItLjA2LTYuMS01LjY5LTYuMjQtMTAuMTktLjE1LTQuODItLjczLTEwIDYuNzMtOS44NHM2LjM3IDUuNTUgNi41MSAxMC4yNnoiIGZpbGw9IiMxMDlmZmUiLz48cGF0aCBkPSJNODAuMjcgNzkuMjdjLS41MyAzLjkxIDEuNzUgOS42NC01Ljg4IDEwLTcuNDcuMzctNi44MS00LjgyLTYuNjEtOS41LjItNC4zMi0xLjgzLTEwIDUuNzgtMTAuNDJzNi41OSA0Ljg5IDYuNzEgOS45MnoiIGZpbGw9IiMwODljZmUiLz48L2c+PC9nPjwvc3ZnPg==" alt="QQ">
+  </a>
+  <a href="https://core.telegram.org/bots/api">
+    <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/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://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">
@@ -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://v2.nonebot.dev/docs/tutorial/create-project">开始使用</a>
+  <a href="https://nonebot.dev/docs/quick-start">快速上手</a>
   ·
   <a href="#插件">文档打不开？</a>
 </p>
 
 <p align="center">
-  <a href="https://asciinema.org/a/464654">
-    <img src="https://v2.nonebot.dev/img/setup.svg">
+  <a href="https://asciinema.org/a/569440">
+    <img src="https://nonebot.dev/img/setup.svg" alt="setup" >
   </a>
 </p>
 
@@ -86,22 +106,44 @@ 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-qq)，[协议](https://bot.q.qq.com/wiki/)）                |  ✅  |                            QQ 官方接口调整较多                            |
+  |                             Console（[仓库](https://github.com/nonebot/adapter-console)）                             |  ✅  |                                控制台交互                                 |
+  |     Red（[仓库](https://github.com/nonebot/adapter-red)，[协议](https://chrononeko.github.io/QQNTRedProtocol/)）      |  ✅  |                                  QQ 协议                                  |
+  |           Satori（[仓库](https://github.com/nonebot/adapter-satori)，[协议](https://satori.js.org/zh-CN)）            |  ✅  |               支持 Onebot、TG、飞书、微信公众号、Koishi 等                |
+  |   Discord（[仓库](https://github.com/nonebot/adapter-discord)，[协议](https://discord.com/developers/docs/intro)）    |  ✅  |                             Discord Bot 协议                              |
+  |               DoDo（[仓库](https://github.com/nonebot/adapter-dodo)，[协议](https://open.imdodo.com/)）               |  ✅  |                               DoDo Bot 协议                               |
+  |        Kritor（[仓库](https://github.com/nonebot/adapter-kritor)，[协议](https://github.com/KarinJS/kritor)）         |  ✅  |                 Kritor (OnebotX) 协议，QQ 机器人接口标准                  |
+  |         钉钉（[仓库](https://github.com/nonebot/adapter-ding)，[协议](https://open.dingtalk.com/document/)）          |  🤗  |                        寻找 Maintainer（暂不可用）                        |
+  |     开黑啦（[仓库](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)）                        |  ❌  |                     米游社大别野 Bot 协议，官方已下线                     |
+  | Rocket.Chat（[仓库](https://github.com/IUnlimit/nonebot-adapter-rocketchat)，[协议](https://developer.rocket.chat/)） |  ↗️  |                     Rocket.Chat 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 +155,21 @@ NoneBot2 不是 NoneBot1 的替代品。事实上，它们都在被积极的维
 
 ## 即刻开始
 
-~~完整~~文档可以在 [这里](https://v2.nonebot.dev/) 查看。
+~~完整~~文档可以在 [这里](https://nonebot.dev/) 查看。
 
 懒得看文档？下面是快速安装指南：
 
-1. (**强烈建议**)使用你喜欢的 Python 环境管理工具创建新的虚拟环境。
-
-2. 使用 `pip` (或其他) 安装 NoneBot 脚手架。
+1. 安装 [pipx](https://pypa.github.io/pipx/)
 
    ```bash
-   pip install nb-cli
+   python -m pip install --user pipx
+   python -m pipx ensurepath
+   ```
+
+2. 安装脚手架
+
+   ```bash
+   pipx install nb-cli
    ```
 
 3. 使用脚手架创建项目
@@ -131,6 +178,12 @@ NoneBot2 不是 NoneBot1 的替代品。事实上，它们都在被积极的维
    nb create
    ```
 
+4. 运行项目
+
+   ```bash
+   nb run
+   ```
+
 ## 社区资源
 
 ### 常见问题
@@ -157,9 +210,8 @@ NoneBot2 不是 NoneBot1 的替代品。事实上，它们都在被积极的维
   或者尝试以下镜像：
 
   - [文档镜像(中国境内)](https://nb2.baka.icu)
-  - [文档镜像(Vercel)](https://nonebot2-vercel-mirror.vercel.app)
 
-- 其他插件请查看 [商店](https://v2.nonebot.dev/store)
+- 其他插件请查看 [商店](https://nonebot.dev/store/plugins)
 
 ## 许可证
 
@@ -178,10 +230,62 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 请参考 [贡献指南](./CONTRIBUTING.md)
 
-### 鸣谢
+## 鸣谢
+
+### 赞助者
+
+感谢以下产品对 NoneBot 项目提供的赞助：
+
+<p align="center">
+  <a href="https://github.com/">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://assets.nonebot.dev/github-dark.png">
+      <img src="https://assets.nonebot.dev/github-light.png" height="50" alt="GitHub">
+    </picture>
+  </a>&nbsp;&nbsp;&nbsp;&nbsp;
+  <a href="https://www.netlify.com/">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://assets.nonebot.dev/netlify-dark.svg">
+      <img src="https://assets.nonebot.dev/netlify-light.svg" height="50" alt="netlify">
+    </picture>
+  </a>&nbsp;&nbsp;&nbsp;&nbsp;
+  <a href="https://sentry.io/">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://assets.nonebot.dev/sentry-dark.svg">
+      <img src="https://assets.nonebot.dev/sentry-light.svg" height="50" alt="sentry">
+    </picture>
+  </a>
+</p>
+<p align="center">
+  <a href="https://www.docker.com/">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://assets.nonebot.dev/docker-dark.svg">
+      <img src="https://assets.nonebot.dev/docker-light.svg" height="50" alt="docker">
+    </picture>
+  </a>&nbsp;&nbsp;&nbsp;&nbsp;
+  <a href="https://www.algolia.com/">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://assets.nonebot.dev/algolia-dark.svg">
+      <img src="https://assets.nonebot.dev/algolia-light.svg" height="50" alt="algolia">
+    </picture>
+  </a>
+</p>
+<p align="center">
+  <a href="https://www.jetbrains.com/">
+    <img src="https://resources.jetbrains.com/storage/products/company/brand/logos/jb_beam.svg" height="80" alt="JetBrains" >
+  </a>
+</p>
+
+感谢以下赞助者对 NoneBot 项目提供的资金支持：
+
+<a href="https://assets.nonebot.dev/sponsors.svg">
+  <img src="https://assets.nonebot.dev/sponsors.svg" alt="sponsors" />
+</a>
+
+### 开发者
 
 感谢以下开发者对 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" alt="contributors" />
 </a>

assets/adapters.json

@@ -0,0 +1,242 @@
+[
+  {
+    "module_name": "nonebot.adapters.onebot.v11",
+    "project_link": "nonebot-adapter-onebot",
+    "name": "OneBot V11",
+    "desc": "OneBot V11 协议",
+    "author": "yanyongyu",
+    "homepage": "https://onebot.adapters.nonebot.dev/",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "nonebot.adapters.ding",
+    "project_link": "nonebot-adapter-ding",
+    "name": "钉钉",
+    "desc": "钉钉协议",
+    "author": "Artin",
+    "homepage": "https://github.com/nonebot/adapter-ding",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "nonebot.adapters.feishu",
+    "project_link": "nonebot-adapter-feishu",
+    "name": "飞书",
+    "desc": "飞书协议",
+    "author": "StarHeartHunt",
+    "homepage": "https://github.com/nonebot/adapter-feishu",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "nonebot.adapters.telegram",
+    "project_link": "nonebot-adapter-telegram",
+    "name": "Telegram",
+    "desc": "Telegram 协议",
+    "author": "j1g5awi",
+    "homepage": "https://github.com/nonebot/adapter-telegram",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "nonebot.adapters.qq",
+    "project_link": "nonebot-adapter-qq",
+    "name": "QQ",
+    "desc": "QQ 官方机器人",
+    "author": "yanyongyu",
+    "homepage": "https://github.com/nonebot/adapter-qq",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "nonebot.adapters.kaiheila",
+    "project_link": "nonebot-adapter-kaiheila",
+    "name": "开黑啦",
+    "desc": "开黑啦协议适配",
+    "author": "Tian-que",
+    "homepage": "https://github.com/Tian-que/nonebot-adapter-kaiheila",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "module_name": "nonebot.adapters.mirai2",
+    "project_link": "nonebot_adapter_mirai2",
+    "name": "mirai2",
+    "desc": "为 nonebot2 添加 mirai_api_http2.x的兼容适配器",
+    "author": "ieew",
+    "homepage": "https://github.com/ieew/nonebot_adapter_mirai2",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "module_name": "nonebot.adapters.onebot.v12",
+    "project_link": "nonebot-adapter-onebot",
+    "name": "OneBot V12",
+    "desc": "OneBot V12 协议",
+    "author": "yanyongyu",
+    "homepage": "https://onebot.adapters.nonebot.dev/",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "nonebot.adapters.console",
+    "project_link": "nonebot-adapter-console",
+    "name": "Console",
+    "desc": "基于终端的交互式适配器",
+    "author": "Melodyknit",
+    "homepage": "https://github.com/nonebot/adapter-console",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "nonebot.adapters.github",
+    "project_link": "nonebot-adapter-github",
+    "name": "GitHub",
+    "desc": "GitHub APP & OAuth APP integration",
+    "author": "yanyongyu",
+    "homepage": "https://github.com/nonebot/adapter-github",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "nonebot.adapters.ntchat",
+    "project_link": "nonebot-adapter-ntchat",
+    "name": "Ntchat",
+    "desc": "pc hook的微信客户端适配",
+    "author": "JustUndertaker",
+    "homepage": "https://github.com/JustUndertaker/adapter-ntchat",
+    "tags": [
+      {
+        "label": "微信",
+        "color": "#ea5252"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "module_name": "nonebot.adapters.minecraft",
+    "project_link": "nonebot-adapter-minecraft",
+    "name": "Minecraft",
+    "desc": "MineCraft通信适配，支持Rcon",
+    "author": "17TheWord",
+    "homepage": "https://github.com/17TheWord/nonebot-adapter-minecraft",
+    "tags": [
+      {
+        "label": "Minecraft",
+        "color": "#4ef0ea"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "module_name": "nonebot.adapters.bilibili",
+    "project_link": "nonebot-adapter-bilibili",
+    "name": "BilibiliLive",
+    "desc": "b站直播间ws协议",
+    "author": "wwweww",
+    "homepage": "https://github.com/wwweww/adapter-bilibili",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "module_name": "nonebot_adapter_walleq",
+    "project_link": "nonebot-adapter-walleq",
+    "name": "Walle-Q",
+    "desc": "内置 QQ 协议实现",
+    "author": "abrahum",
+    "homepage": "https://github.com/onebot-walle/nonebot_adapter_walleq",
+    "tags": [
+      {
+        "label": "QQ",
+        "color": "#34a9cc"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "module_name": "nonebot.adapters.villa",
+    "project_link": "nonebot-adapter-villa",
+    "name": "大别野",
+    "desc": "米游社大别野官方Bot适配",
+    "author": "CMHopeSunshine",
+    "homepage": "https://github.com/CMHopeSunshine/nonebot-adapter-villa",
+    "tags": [
+      {
+        "label": "米哈游",
+        "color": "#e10909"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "module_name": "nonebot.adapters.red",
+    "project_link": "nonebot-adapter-red",
+    "name": "RedProtocol",
+    "desc": "QQNT RedProtocol 适配",
+    "author": "zhaomaoniu",
+    "homepage": "https://github.com/nonebot/adapter-red",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "nonebot.adapters.discord",
+    "project_link": "nonebot-adapter-discord",
+    "name": "Discord",
+    "desc": "Discord 官方 Bot 协议适配",
+    "author": "CMHopeSunshine",
+    "homepage": "https://github.com/nonebot/adapter-discord",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "nonebot.adapters.satori",
+    "project_link": "nonebot-adapter-satori",
+    "name": "Satori",
+    "desc": "Satori 协议适配器",
+    "author": "RF-Tar-Railt",
+    "homepage": "https://github.com/nonebot/adapter-satori",
+    "tags": [
+      {
+        "label": "跨平台",
+        "color": "#bf40bf"
+      }
+    ],
+    "is_official": true
+  },
+  {
+    "module_name": "nonebot.adapters.dodo",
+    "project_link": "nonebot-adapter-dodo",
+    "name": "DoDo",
+    "desc": "DoDo Bot 协议适配器",
+    "author": "CMHopeSunshine",
+    "homepage": "https://github.com/nonebot/adapter-dodo",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "nonebot.adapters.rocketchat",
+    "project_link": "nonebot-adapter-rocketchat",
+    "name": "RocketChat",
+    "desc": "RocketChat adapter for nonebot2",
+    "author": "IllTamer",
+    "homepage": "https://github.com/IUnlimit/nonebot-adapter-rocketchat",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "module_name": "nonebot.adapters.kritor",
+    "project_link": "nonebot-adapter-kritor",
+    "name": "Kritor",
+    "desc": "Kritor 协议适配",
+    "author": "RF-Tar-Railt",
+    "homepage": "https://github.com/nonebot/adapter-kritor",
+    "tags": [
+      {
+        "label": "QQNT",
+        "color": "#35a7c9"
+      }
+    ],
+    "is_official": true
+  }
+]

assets/bots.json

@@ -0,0 +1,611 @@
+[
+  {
+    "name": "HarukaBot",
+    "desc": "将B站UP主的动态和直播信息推送至QQ",
+    "author": "SK-415",
+    "homepage": "https://github.com/SK-415/HarukaBot",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "Omega Miya",
+    "desc": "B站推送Pixiv搜图识番求签抽卡表情包还有其他杂七杂八的功能",
+    "author": "Ailitonia",
+    "homepage": "https://github.com/Ailitonia/omega-miya",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "Github Bot",
+    "desc": "在QQ获取/处理Github repo/pr/issue",
+    "author": "yanyongyu",
+    "homepage": "https://github.com/cscs181/QQ-GitHub-Bot",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "YanXiBot",
+    "desc": "动漫资源查找与娱乐机器人",
+    "author": "Melodyknit",
+    "homepage": "https://github.com/Melodyknit/YanXiBot",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "绪山真寻bot",
+    "desc": "含有不少的娱乐功能同时稍稍有一些实用的功能 :P",
+    "author": "HibiKier",
+    "homepage": "https://github.com/HibiKier/zhenxun_bot",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "ATRI",
+    "desc": "高性能文爱萝卜子，糅杂了各类有趣小功能",
+    "author": "Kyomotoi",
+    "homepage": "https://github.com/Kyomotoi/ATRI",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "dumbot傻瓜机器人",
+    "desc": "猜一猜游戏、新闻一览、英文每日一词一短语等等，含一键启动及docker容器部署就绪",
+    "author": "ffreemt",
+    "homepage": "https://github.com/ffreemt/koyeb-nb2",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "DicePP",
+    "desc": "TRPG骰娘, 带先攻, 查询等功能, 主要面向DND5E. 面对骰主推出的船新版本, 内置Windows/Linux详细部署指南以及方便的自定义骰娘方法, 从回复文本到查询资料库都可轻松配置~",
+    "author": "pear-studio",
+    "homepage": "https://github.com/pear-studio/nonebot-dicepp",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "SetuBot",
+    "desc": "每个群配置文件独立,可以控制频率,socks http代理,R18开关,支持多tag,自建API lolicon Pixiv热度榜",
+    "author": "yuban10703",
+    "homepage": "https://github.com/yuban10703/setu-nonebot2",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "剑网三bot",
+    "desc": "网络游戏《剑侠情缘三》的群聊机器人，数据使用：www.jx3api.com",
+    "author": "JustUndertaker",
+    "homepage": "https://github.com/JustUndertaker/mini_jx3_bot",
+    "tags": [
+      {
+        "label": "剑网三",
+        "color": "#5393ec"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "PixivBot",
+    "desc": "顾名思义是Pixiv的bot（随机推荐插画、随机指定关键词插画、随机书签、查看排行榜、查看指定id插画）",
+    "author": "ssttkkl",
+    "homepage": "https://github.com/ssttkkl/PixivBot",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "SeaBot_QQ",
+    "desc": "一个能够获取新闻资讯并推送至QQ的群聊机器人。",
+    "author": "B1ue1nWh1te",
+    "homepage": "https://github.com/B1ue1nWh1te/SeaBot_QQ",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "琪露诺Bot",
+    "desc": "用QQ机器人控制Minecraft服务器！服务器状态查询/服务器白名单/插件列表/玩家查询/转发服务器消息/执行指令...   其他实用娱乐功能，三步即可成功部署的QQ bot",
+    "author": "summerkirakira",
+    "homepage": "https://github.com/summerkirakira/CirnoBot",
+    "tags": [
+      {
+        "label": "Minecraft",
+        "color": "#5393ec"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "Inkar Suki",
+    "desc": "一个十分方便的Bot，支持包括Webhook、群管、剑网3等一系列功能，持续更新中……",
+    "author": "HornCopper",
+    "homepage": "https://github.com/HornCopper/Inkar-Suki",
+    "tags": [
+      {
+        "label": "Minecraft",
+        "color": "#d03790"
+      },
+      {
+        "label": "GitHub",
+        "color": "#374fd0"
+      },
+      {
+        "label": "剑网3",
+        "color": "#ff0033"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "屑岛风Bot",
+    "desc": "自家用屑Bot",
+    "author": "kexue-z",
+    "homepage": "https://github.com/kexue-z/Dao-bot",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "LiteyukiBot-轻雪机器人",
+    "desc": "一个有各种琐事功能的bot，有AI接口，能陪聊",
+    "author": "snowyfirefly",
+    "homepage": "https://github.com/snowyfirefly/Liteyuki",
+    "tags": [
+      {
+        "label": "可爱",
+        "color": "#ffc0cb"
+      },
+      {
+        "label": "AI",
+        "color": "#ea5252"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "nya_bot",
+    "desc": "喵服——战魂铭人联机服务器兼机器人",
+    "author": "nikissXI",
+    "homepage": "https://github.com/nikissXI/nya_bot",
+    "tags": [
+      {
+        "label": "战魂铭人",
+        "color": "#25aaf4"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "真宵Bot",
+    "desc": "专注群聊的QQ机器人",
+    "author": "Shine-Light",
+    "homepage": "https://github.com/Shine-Light/Nonebot_Bot_MayaFey",
+    "tags": [
+      {
+        "label": "QQ",
+        "color": "#ea5252"
+      },
+      {
+        "label": "娱乐",
+        "color": "#a46e49"
+      },
+      {
+        "label": "群管",
+        "color": "#41aecb"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "SkadiBot",
+    "desc": "明日方舟主题机器人—斯卡蒂",
+    "author": "yuyuziYYZ",
+    "homepage": "https://github.com/yuyuziYYZ/skadi_bot",
+    "tags": [
+      {
+        "label": "明日方舟",
+        "color": "#a48888"
+      },
+      {
+        "label": "斯卡蒂",
+        "color": "#a48888"
+      },
+      {
+        "label": "arknights",
+        "color": "#a48888"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "小白机器人",
+    "desc": "一个高度依赖数据库的群管理机器人",
+    "author": "SDIJF1521",
+    "homepage": "https://github.com/SDIJF1521/qqai",
+    "tags": [
+      {
+        "label": "群管理",
+        "color": "#ea5252"
+      },
+      {
+        "label": "新人作品",
+        "color": "#ea5252"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "LittlePaimon",
+    "desc": "小派蒙，多功能原神机器人。",
+    "author": "CMHopeSunshine",
+    "homepage": "https://github.com/CMHopeSunshine/LittlePaimon",
+    "tags": [
+      {
+        "label": "原神",
+        "color": "#7a52ea"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "IdhagnBot",
+    "desc": "🐱🤖 一个以娱乐功能为主的缝合怪（划掉）QQ机器人，包含一定Furry要素但是不会卖萌（就是逊啦！）",
+    "author": "su226",
+    "homepage": "https://github.com/su226/IdhagnBot",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "hsbot",
+    "desc": "服务于《炉石传说》玩家的机器人，上线至今已有加入十余个个炉石相关群聊，上千名用户使用，响应请求数万次。 数据使用：HSreplay, Fbigame, Hearthstone API",
+    "author": "gzy02",
+    "homepage": "https://github.com/gzy02/hsbot",
+    "tags": [
+      {
+        "label": "炉石传说",
+        "color": "#526fea"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "Bread Dog Bot",
+    "desc": "Terraria TShock QQ 机器人",
+    "author": "Qianyiovo",
+    "homepage": "https://github.com/Qianyiovo/bread_dog_bot",
+    "tags": [
+      {
+        "label": "TShock",
+        "color": "#ea5252"
+      },
+      {
+        "label": "泰拉瑞亚",
+        "color": "#5dea52"
+      },
+      {
+        "label": "Terraria",
+        "color": "#5dea52"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "RanBot",
+    "desc": "不@会很安静的Bot",
+    "author": "IAXRetailer",
+    "homepage": "https://github.com/Hecatia-Hell-Workshop/RanBot",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "辞辞(cici)Bot",
+    "desc": "一个集成娱乐和群管为一体的机器人",
+    "author": "mengxinyuan638",
+    "homepage": "https://github.com/mengxinyuan638/cici-bot",
+    "tags": [
+      {
+        "label": "辞辞Bot",
+        "color": "#04de4d"
+      },
+      {
+        "label": "萌新源",
+        "color": "#fd1c06"
+      },
+      {
+        "label": "群管",
+        "color": "#06b8fd"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "SuzunoBot",
+    "desc": "多功能音游bot，主要服务maimaiDX、Arcaea",
+    "author": "Rinfair-CSP-A016",
+    "homepage": "https://github.com/Rinfair-CSP-A016/SuzunoBot-AGLAS",
+    "tags": [
+      {
+        "label": "maimaiDX",
+        "color": "#189ede"
+      },
+      {
+        "label": "Arcaea",
+        "color": "#d551ef"
+      },
+      {
+        "label": "coc",
+        "color": "#7fe4d0"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "青岚",
+    "desc": "基于NoneBot的与Minecraft Server互通消息的机器人",
+    "author": "17TheWord",
+    "homepage": "https://github.com/17TheWord/qinglan_bot",
+    "tags": [
+      {
+        "label": "MineCraft",
+        "color": "#4ef0ea"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "ChensQBOTv2",
+    "desc": "多功能QQ群机器人，权限管理/联ban/社工等等等等，以及拥有一个强大的开发者",
+    "author": "cnchens",
+    "homepage": "https://github.com/cnchens/ChensQBOTv2",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "koishi",
+    "desc": "支持爬取 codeforces, atcoder, 牛客上程序设计赛事的 bot。",
+    "author": "CupidsBow",
+    "homepage": "https://github.com/CupidsBow/koishi",
+    "tags": [
+      {
+        "label": "acm",
+        "color": "#f71d1d"
+      },
+      {
+        "label": "codeforces",
+        "color": "#1df721"
+      },
+      {
+        "label": "atcoder",
+        "color": "#aa1df7"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "脑积水",
+    "desc": "一个超级缝合怪...",
+    "author": "zhulinyv",
+    "homepage": "https://github.com/zhulinyv/NJS",
+    "tags": [
+      {
+        "label": "脑积水",
+        "color": "#ff00ac"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "LOVE酱",
+    "desc": "为铁锈战争游戏群服务的虚拟少女,内置了爬取铁锈房间列表功能,以及游戏内单位查询功能,并制作了教学系统以及铁锈相关游戏群的收集功能。",
+    "author": "allureluoli",
+    "homepage": "https://github.com/allureluoli/LOVE-",
+    "tags": [
+      {
+        "label": "铁锈战争",
+        "color": "#19e229"
+      },
+      {
+        "label": "RW",
+        "color": "#19e229"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "fubot",
+    "desc": "基于nonebot与go-cqhttp的QQ娱乐bot，提供群日常娱乐功能与舞萌DX游戏相关的信息查询功能。",
+    "author": "HCskia",
+    "homepage": "https://github.com/HCskia/fu-Bot",
+    "tags": [
+      {
+        "label": "maimai",
+        "color": "#52eaa5"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "桃桃酱",
+    "desc": "一个会拆家的高性能缝合萝卜子",
+    "author": "tkgs0",
+    "homepage": "https://github.com/tkgs0/Momoko",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "CoolQBot",
+    "desc": "基于 NoneBot2 的聊天机器人",
+    "author": "he0119",
+    "homepage": "https://github.com/he0119/CoolQBot",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "XDbot2",
+    "desc": "简单的QQ功能型机器人",
+    "author": "This-is-XiaoDeng",
+    "homepage": "https://github.com/ITCraftDevelopmentTeam/XDbot2",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "March7th",
+    "desc": "三月七 - 崩坏：星穹铁道机器人",
+    "author": "mobyw",
+    "homepage": "https://github.com/Mar-7th/March7th",
+    "tags": [
+      {
+        "label": "StarRail",
+        "color": "#5a8ccc"
+      },
+      {
+        "label": "星穹铁道",
+        "color": "#6faec6"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "ay机器人",
+    "desc": "codeforces和洛谷卷王监视、股票监控、ai聊天",
+    "author": "863109569",
+    "homepage": "https://github.com/863109569/qqbot",
+    "tags": [
+      {
+        "label": "acm",
+        "color": "#ea5252"
+      },
+      {
+        "label": "洛谷",
+        "color": "#81ea52"
+      },
+      {
+        "label": "codeforces",
+        "color": "#5261ea"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "狐尾",
+    "desc": "一个整合了兽云祭api的机器人，支持账号令牌操作，以及上传兽图",
+    "author": "bingqiu456",
+    "homepage": "https://github.com/bingqiu456/shouyun",
+    "tags": [
+      {
+        "label": "shouyun",
+        "color": "#52ea7a"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "ReimeiBot-黎明机器人",
+    "desc": "流星飞逝，黎明终将到来。",
+    "author": "ThirdBlood",
+    "homepage": "https://github.com/3rdBit/ReimeiBot",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "web_bot",
+    "desc": "把机器人搬到网络上",
+    "author": "wsdtl",
+    "homepage": "https://github.com/wsdtl/web_bot",
+    "tags": [
+      {
+        "label": "xiaonan",
+        "color": "#775151"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "林汐",
+    "desc": "多平台功能型Bot",
+    "author": "mute23-code",
+    "homepage": "https://github.com/netsora/SoraBot",
+    "tags": [
+      {
+        "label": "QQ频道",
+        "color": "#f47070"
+      },
+      {
+        "label": "OneBot v11",
+        "color": "#212121"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "米缸",
+    "desc": "基于nonebot2的米缸Bot",
+    "author": "LambdaYH",
+    "homepage": "https://github.com/LambdaYH/MigangBot",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "不正经的妹妹",
+    "desc": "一款功能丰富、简单易用、自定义性强、扩展性强的可爱的QQ娱乐机器人",
+    "author": "itsevin",
+    "homepage": "https://github.com/itsevin/sister_bot",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "星见Kirami",
+    "desc": "🌟 读作 Kirami，写作星见，简明轻快的聊天机器人应用。",
+    "author": "A-kirami",
+    "homepage": "https://kiramibot.dev/",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "OCNbot",
+    "desc": "OI Contest Notifier bot，一个可以推送洛谷、cf、atcoder、牛客比赛通知的bot",
+    "author": "ACnoway",
+    "homepage": "https://github.com/ACnoway/OCNbot",
+    "tags": [
+      {
+        "label": "OI",
+        "color": "#2fccff"
+      },
+      {
+        "label": "ACM",
+        "color": "#ff0004"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "妃爱",
+    "desc": "超可爱的妃爱QQ群聊机器人",
+    "author": "jiangyuxiaoxiao",
+    "homepage": "https://github.com/jiangyuxiaoxiao/Hiyori",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "芙芙",
+    "desc": "供 Mooncell Wiki 协作使用的跨平台机器人",
+    "author": "StarHeartHunt",
+    "homepage": "https://github.com/MooncellWiki/BotFooChan",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "Sakiko",
+    "desc": "基于 LiteLoaderBDS 的 Minecraft 基岩版 Bot",
+    "author": "zhaomaoniu",
+    "homepage": "https://github.com/zhaomaoniu/Sakiko",
+    "tags": [
+      {
+        "label": "Minecraft",
+        "color": "#6cc349"
+      },
+      {
+        "label": "BanGDream",
+        "color": "#e70050"
+      }
+    ],
+    "is_official": false
+  }
+]

assets/drivers.json

@@ -0,0 +1,62 @@
+[
+  {
+    "module_name": "~none",
+    "project_link": "",
+    "name": "None",
+    "desc": "None 驱动器",
+    "author": "yanyongyu",
+    "homepage": "/docs/advanced/driver",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "~fastapi",
+    "project_link": "nonebot2[fastapi]",
+    "name": "FastAPI",
+    "desc": "FastAPI 驱动器",
+    "author": "yanyongyu",
+    "homepage": "/docs/advanced/driver",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "~quart",
+    "project_link": "nonebot2[quart]",
+    "name": "Quart",
+    "desc": "Quart 驱动器",
+    "author": "yanyongyu",
+    "homepage": "/docs/advanced/driver",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "~httpx",
+    "project_link": "nonebot2[httpx]",
+    "name": "HTTPX",
+    "desc": "HTTPX 驱动器",
+    "author": "yanyongyu",
+    "homepage": "/docs/advanced/driver",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "~websockets",
+    "project_link": "nonebot2[websockets]",
+    "name": "websockets",
+    "desc": "websockets 驱动器",
+    "author": "yanyongyu",
+    "homepage": "/docs/advanced/driver",
+    "tags": [],
+    "is_official": true
+  },
+  {
+    "module_name": "~aiohttp",
+    "project_link": "nonebot2[aiohttp]",
+    "name": "AIOHTTP",
+    "desc": "AIOHTTP 驱动器",
+    "author": "yanyongyu",
+    "homepage": "/docs/advanced/driver",
+    "tags": [],
+    "is_official": true
+  }
+]

envs/pydantic-v1/pyproject.toml

@@ -0,0 +1,18 @@
+[tool.poetry]
+name = "nonebot-pydantic-v1"
+version = "0.1.0"
+description = "Private pydantic v1 test env for nonebot"
+authors = ["yanyongyu <yyy@nonebot.dev>"]
+license = "MIT"
+
+[tool.poetry.dependencies]
+python = "^3.9"
+
+[tool.poetry.group.dev.dependencies]
+pydantic = "^1.0.0"
+nonebot-test = { path = "../test/", develop = false }
+nonebot2 = { path = "../../", extras = ["all"], develop = true }
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

envs/pydantic-v2/pyproject.toml

@@ -0,0 +1,18 @@
+[tool.poetry]
+name = "nonebot-pydantic-v2"
+version = "0.1.0"
+description = "Private pydantic v2 test env for nonebot"
+authors = ["yanyongyu <yyy@nonebot.dev>"]
+license = "MIT"
+
+[tool.poetry.dependencies]
+python = "^3.9"
+
+[tool.poetry.group.dev.dependencies]
+pydantic = "^2.0.0"
+nonebot-test = { path = "../test/", develop = false }
+nonebot2 = { path = "../../", extras = ["all"], develop = true }
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

envs/test/nonebot-test.py

@@ -0,0 +1 @@
+# fake file to make project installable

envs/test/pyproject.toml

@@ -0,0 +1,21 @@
+[tool.poetry]
+name = "nonebot-test"
+version = "0.1.0"
+description = "Private test env for nonebot"
+authors = ["yanyongyu <yyy@nonebot.dev>"]
+license = "MIT"
+packages = [{ include = "nonebot-test.py" }]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+nonebug = "^0.3.7"
+wsproto = "^1.2.0"
+pytest-cov = "^5.0.0"
+pytest-xdist = "^3.0.2"
+pytest-asyncio = "^0.23.2"
+werkzeug = ">=2.3.6,<4.0.0"
+coverage-conditional-plugin = "^0.9.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

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,18 @@
 - `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_plugins` => {ref}``load_builtin_plugins` <nonebot.plugin.load.load_builtin_plugins>`
-- `get_plugin` => {ref}``get_plugin` <nonebot.plugin.plugin.get_plugin>`
-- `get_plugin_by_module_name` => {ref}``get_plugin_by_module_name` <nonebot.plugin.plugin.get_plugin_by_module_name>`
-- `get_loaded_plugins` => {ref}``get_loaded_plugins` <nonebot.plugin.plugin.get_loaded_plugins>`
-- `get_available_plugin_names` => {ref}``get_available_plugin_names` <nonebot.plugin.plugin.get_available_plugin_names>`
-- `export` => {ref}``export` <nonebot.plugin.export.export>`
+- `load_builtin_plugin` =>
+  {ref}``load_builtin_plugin` <nonebot.plugin.load.load_builtin_plugin>`
+- `load_builtin_plugins` =>
+  {ref}``load_builtin_plugins` <nonebot.plugin.load.load_builtin_plugins>`
+- `get_plugin` => {ref}``get_plugin` <nonebot.plugin.get_plugin>`
+- `get_plugin_by_module_name` =>
+  {ref}``get_plugin_by_module_name` <nonebot.plugin.get_plugin_by_module_name>`
+- `get_loaded_plugins` =>
+  {ref}``get_loaded_plugins` <nonebot.plugin.get_loaded_plugins>`
+- `get_available_plugin_names` =>
+  {ref}``get_available_plugin_names` <nonebot.plugin.get_available_plugin_names>`
+- `get_plugin_config` => {ref}``get_plugin_config` <nonebot.plugin.get_plugin_config>`
 - `require` => {ref}``require` <nonebot.plugin.load.require>`
 
 FrontMatter:
@@ -37,24 +43,25 @@ FrontMatter:
     description: nonebot 模块
 """
 
-import importlib
-from typing import Any, Dict, Type, Optional
+import os
+from importlib.metadata import version
+from typing import Any, Union, TypeVar, Optional, overload
 
-import pkg_resources
+import loguru
 
-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.drivers import Driver, ReverseDriver, combine_driver
+from nonebot.compat import model_dump
+from nonebot.log import logger as logger
+from nonebot.adapters import Bot, Adapter
+from nonebot.config import DOTENV_TYPE, Env, Config
+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__ = _dist.version
-    VERSION = _dist.parsed_version
-except pkg_resources.DistributionNotFound:  # pragma: no cover
+    __version__ = version("nonebot2")
+except Exception:  # pragma: no cover
     __version__ = None
-    VERSION = None
+
+A = TypeVar("A", bound=Adapter)
 
 _driver: Optional[Driver] = None
 
@@ -68,7 +75,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 +88,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` 类型
-        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化 ({ref}`nonebot.init <nonebot.init>` 尚未调用)
+        AssertionError: 全局 Driver 对象不是 {ref}`nonebot.drivers.ASGIMixin` 类型
+        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化
+            ({ref}`nonebot.init <nonebot.init>` 尚未调用)
 
     用法:
         ```python
@@ -96,21 +166,21 @@ def get_app() -> Any:
         ```
     """
     driver = get_driver()
-    assert isinstance(
-        driver, ReverseDriver
-    ), "app object is only available for reverse driver"
+    assert isinstance(driver, ASGIMixin), "app object is only available for asgi 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` 类型
-        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化 ({ref}`nonebot.init <nonebot.init>` 尚未调用)
+        AssertionError: 全局 Driver 对象不是 {ref}`nonebot.drivers.ASGIMixin` 类型
+        ValueError: 全局 {ref}`nonebot.drivers.Driver` 对象尚未初始化
+            ({ref}`nonebot.init <nonebot.init>` 尚未调用)
 
     用法:
         ```python
@@ -119,8 +189,8 @@ def get_asgi() -> Any:
     """
     driver = get_driver()
     assert isinstance(
-        driver, ReverseDriver
-    ), "asgi object is only available for reverse driver"
+        driver, ASGIMixin
+    ), "asgi object is only available for asgi driver"
     return driver.asgi
 
 
@@ -131,7 +201,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 +210,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
@@ -158,56 +230,52 @@ def get_bot(self_id: Optional[str] = None) -> Bot:
     raise ValueError("There are no bots to get.")
 
 
-def get_bots() -> Dict[str, Bot]:
+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 driver.bots
+    return get_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]:
+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.id_
+        if (module_name := record["name"])
+        and (plugin := get_plugin_by_module_name(module_name))
+        else (module_name and module_name.split(".", maxsplit=1)[0])
+    )
+
+
+def init(*, _env_file: Optional[DOTENV_TYPE] = None, **kwargs: Any) -> None:
     """初始化 NoneBot 以及 全局 {ref}`nonebot.drivers.Driver` 对象。
 
     NoneBot 将会从 .env 文件中读取环境信息，并使用相应的 env 文件配置。
@@ -227,21 +295,27 @@ def init(*, _env_file: Optional[str] = None, **kwargs: Any) -> None:
     if not _driver:
         logger.success("NoneBot is initializing...")
         env = Env()
+        _env_file = _env_file or f".env.{env.environment}"
         config = Config(
             **kwargs,
-            _common_config=env.dict(),
-            _env_file=_env_file or f".env.{env.environment}",
+            _env_file=(
+                (".env", _env_file)
+                if isinstance(_env_file, (str, os.PathLike))
+                else _env_file
+            ),
         )
 
-        default_filter.level = config.log_level
+        logger.configure(
+            extra={"nonebot_log_level": config.log_level}, patcher=_log_patcher
+        )
         logger.opt(colors=True).info(
             f"Current <y><b>Env: {escape_tag(env.environment)}</b></y>"
         )
         logger.opt(colors=True).debug(
-            f"Loaded <y><b>Config</b></y>: {escape_tag(str(config.dict()))}"
+            f"Loaded <y><b>Config</b></y>: {escape_tag(str(model_dump(config)))}"
         )
 
-        DriverClass: Type[Driver] = _resolve_combine_expr(config.driver)
+        DriverClass = _resolve_combine_expr(config.driver)
         _driver = DriverClass(env, config)
 
 
@@ -262,7 +336,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
@@ -283,10 +357,9 @@ from nonebot.plugin import load_from_json as load_from_json
 from nonebot.plugin import load_from_toml as load_from_toml
 from nonebot.plugin import load_all_plugins as load_all_plugins
 from nonebot.plugin import on_shell_command as on_shell_command
+from nonebot.plugin import get_plugin_config as get_plugin_config
 from nonebot.plugin import get_loaded_plugins as get_loaded_plugins
 from nonebot.plugin import load_builtin_plugin as load_builtin_plugin
 from nonebot.plugin import load_builtin_plugins as load_builtin_plugins
 from nonebot.plugin import get_plugin_by_module_name as get_plugin_by_module_name
 from nonebot.plugin import get_available_plugin_names as get_available_plugin_names
-
-__autodoc__ = {"internal": False}

nonebot/adapters/__init__.py

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

@@ -0,0 +1,380 @@
+"""本模块为 Pydantic 版本兼容层模块
+
+为兼容 Pydantic V1 与 V2 版本，定义了一系列兼容函数与类供使用。
+
+FrontMatter:
+    sidebar_position: 16
+    description: nonebot.compat 模块
+"""
+
+from collections.abc import Generator
+from dataclasses import dataclass, is_dataclass
+from typing_extensions import Self, get_args, get_origin, is_typeddict
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Union,
+    TypeVar,
+    Callable,
+    Optional,
+    Protocol,
+    Annotated,
+)
+
+from pydantic import VERSION, BaseModel
+
+from nonebot.typing import origin_is_annotated
+
+T = TypeVar("T")
+
+PYDANTIC_V2 = int(VERSION.split(".", 1)[0]) == 2
+
+if TYPE_CHECKING:
+
+    class _CustomValidationClass(Protocol):
+        @classmethod
+        def __get_validators__(cls) -> Generator[Callable[..., Any], None, None]: ...
+
+    CVC = TypeVar("CVC", bound=_CustomValidationClass)
+
+
+__all__ = (
+    "Required",
+    "PydanticUndefined",
+    "PydanticUndefinedType",
+    "ConfigDict",
+    "DEFAULT_CONFIG",
+    "FieldInfo",
+    "ModelField",
+    "extract_field_info",
+    "model_field_validate",
+    "model_fields",
+    "model_config",
+    "model_dump",
+    "type_validate_python",
+    "type_validate_json",
+    "custom_validation",
+)
+
+__autodoc__ = {
+    "PydanticUndefined": "Pydantic Undefined object",
+    "PydanticUndefinedType": "Pydantic Undefined type",
+}
+
+
+if PYDANTIC_V2:  # pragma: pydantic-v2
+    from pydantic_core import CoreSchema, core_schema
+    from pydantic._internal._repr import display_as_type
+    from pydantic import TypeAdapter, GetCoreSchemaHandler
+    from pydantic.fields import FieldInfo as BaseFieldInfo
+
+    Required = Ellipsis
+    """Alias of Ellipsis for compatibility with pydantic v1"""
+
+    # Export undefined type
+    from pydantic_core import PydanticUndefined as PydanticUndefined
+    from pydantic_core import PydanticUndefinedType as PydanticUndefinedType
+
+    # isort: split
+
+    # Export model config dict
+    from pydantic import ConfigDict as ConfigDict
+
+    DEFAULT_CONFIG = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+    """Default config for validations"""
+
+    class FieldInfo(BaseFieldInfo):
+        """FieldInfo class with extra property for compatibility with pydantic v1"""
+
+        # make default can be positional argument
+        def __init__(self, default: Any = PydanticUndefined, **kwargs: Any) -> None:
+            super().__init__(default=default, **kwargs)
+
+        @property
+        def extra(self) -> dict[str, Any]:
+            """Extra data that is not part of the standard pydantic fields.
+
+            For compatibility with pydantic v1.
+            """
+            # extract extra data from attributes set except used slots
+            # we need to call super in advance due to
+            # comprehension not inlined in cpython < 3.12
+            # https://peps.python.org/pep-0709/
+            slots = super().__slots__
+            return {k: v for k, v in self._attributes_set.items() if k not in slots}
+
+    @dataclass
+    class ModelField:
+        """ModelField class for compatibility with pydantic v1"""
+
+        name: str
+        """The name of the field."""
+        annotation: Any
+        """The annotation of the field."""
+        field_info: FieldInfo
+        """The FieldInfo of the field."""
+
+        @classmethod
+        def _construct(cls, name: str, annotation: Any, field_info: FieldInfo) -> Self:
+            return cls(name, annotation, field_info)
+
+        @classmethod
+        def construct(
+            cls, name: str, annotation: Any, field_info: Optional[FieldInfo] = None
+        ) -> Self:
+            """Construct a ModelField from given infos."""
+            return cls._construct(name, annotation, field_info or FieldInfo())
+
+        def _annotation_has_config(self) -> bool:
+            """Check if the annotation has config.
+
+            TypeAdapter raise error when annotation has config
+            and given config is not None.
+            """
+            type_is_annotated = origin_is_annotated(get_origin(self.annotation))
+            inner_type = (
+                get_args(self.annotation)[0] if type_is_annotated else self.annotation
+            )
+            try:
+                return (
+                    issubclass(inner_type, BaseModel)
+                    or is_dataclass(inner_type)
+                    or is_typeddict(inner_type)
+                )
+            except TypeError:
+                return False
+
+        def get_default(self) -> Any:
+            """Get the default value of the field."""
+            return self.field_info.get_default(call_default_factory=True)
+
+        def _type_display(self):
+            """Get the display of the type of the field."""
+            return display_as_type(self.annotation)
+
+        def __hash__(self) -> int:
+            # Each ModelField is unique for our purposes,
+            # to allow store them in a set.
+            return id(self)
+
+    def extract_field_info(field_info: BaseFieldInfo) -> dict[str, Any]:
+        """Get FieldInfo init kwargs from a FieldInfo instance."""
+
+        kwargs = field_info._attributes_set.copy()
+        kwargs["annotation"] = field_info.rebuild_annotation()
+        return kwargs
+
+    def model_field_validate(
+        model_field: ModelField, value: Any, config: Optional[ConfigDict] = None
+    ) -> Any:
+        """Validate the value pass to the field."""
+        type: Any = Annotated[model_field.annotation, model_field.field_info]
+        return TypeAdapter(
+            type, config=None if model_field._annotation_has_config() else config
+        ).validate_python(value)
+
+    def model_fields(model: type[BaseModel]) -> list[ModelField]:
+        """Get field list of a model."""
+
+        return [
+            ModelField._construct(
+                name=name,
+                annotation=field_info.rebuild_annotation(),
+                field_info=FieldInfo(**extract_field_info(field_info)),
+            )
+            for name, field_info in model.model_fields.items()
+        ]
+
+    def model_config(model: type[BaseModel]) -> Any:
+        """Get config of a model."""
+        return model.model_config
+
+    def model_dump(
+        model: BaseModel,
+        include: Optional[set[str]] = None,
+        exclude: Optional[set[str]] = None,
+        by_alias: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+    ) -> dict[str, Any]:
+        return model.model_dump(
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+        )
+
+    def type_validate_python(type_: type[T], data: Any) -> T:
+        """Validate data with given type."""
+        return TypeAdapter(type_).validate_python(data)
+
+    def type_validate_json(type_: type[T], data: Union[str, bytes]) -> T:
+        """Validate JSON with given type."""
+        return TypeAdapter(type_).validate_json(data)
+
+    def __get_pydantic_core_schema__(
+        cls: type["_CustomValidationClass"],
+        source_type: Any,
+        handler: GetCoreSchemaHandler,
+    ) -> CoreSchema:
+        validators = list(cls.__get_validators__())
+        if len(validators) == 1:
+            return core_schema.no_info_plain_validator_function(validators[0])
+        return core_schema.chain_schema(
+            [core_schema.no_info_plain_validator_function(func) for func in validators]
+        )
+
+    def custom_validation(class_: type["CVC"]) -> type["CVC"]:
+        """Use pydantic v1 like validator generator in pydantic v2"""
+
+        setattr(
+            class_,
+            "__get_pydantic_core_schema__",
+            classmethod(__get_pydantic_core_schema__),
+        )
+        return class_
+
+else:  # pragma: pydantic-v1
+    from pydantic import Extra
+    from pydantic import parse_obj_as, parse_raw_as
+    from pydantic import BaseConfig as PydanticConfig
+    from pydantic.fields import FieldInfo as BaseFieldInfo
+    from pydantic.fields import ModelField as BaseModelField
+    from pydantic.schema import get_annotation_from_field_info
+
+    # isort: split
+
+    from pydantic.fields import Required as Required
+
+    # isort: split
+
+    from pydantic.fields import Undefined as PydanticUndefined
+    from pydantic.fields import UndefinedType as PydanticUndefinedType
+
+    class ConfigDict(PydanticConfig):
+        """Config class that allow get value with default value."""
+
+        @classmethod
+        def get(cls, field: str, default: Any = None) -> Any:
+            """Get a config value."""
+            return getattr(cls, field, default)
+
+    class DEFAULT_CONFIG(ConfigDict):
+        extra = Extra.allow
+        arbitrary_types_allowed = True
+
+    class FieldInfo(BaseFieldInfo):
+        def __init__(self, default: Any = PydanticUndefined, **kwargs: Any):
+            # preprocess default value to make it compatible with pydantic v2
+            # when default is Required, set it to PydanticUndefined
+            if default is Required:
+                default = PydanticUndefined
+            super().__init__(default, **kwargs)
+
+    class ModelField(BaseModelField):
+        @classmethod
+        def _construct(cls, name: str, annotation: Any, field_info: FieldInfo) -> Self:
+            return cls(
+                name=name,
+                type_=annotation,
+                class_validators=None,
+                model_config=DEFAULT_CONFIG,
+                default=field_info.default,
+                default_factory=field_info.default_factory,
+                required=(
+                    field_info.default is PydanticUndefined
+                    and field_info.default_factory is None
+                ),
+                field_info=field_info,
+            )
+
+        @classmethod
+        def construct(
+            cls, name: str, annotation: Any, field_info: Optional[FieldInfo] = None
+        ) -> Self:
+            """Construct a ModelField from given infos.
+
+            Field annotation is preprocessed with field_info.
+            """
+            if field_info is not None:
+                annotation = get_annotation_from_field_info(
+                    annotation, field_info, name
+                )
+            return cls._construct(name, annotation, field_info or FieldInfo())
+
+    def extract_field_info(field_info: BaseFieldInfo) -> dict[str, Any]:
+        """Get FieldInfo init kwargs from a FieldInfo instance."""
+
+        kwargs = {
+            s: getattr(field_info, s) for s in field_info.__slots__ if s != "extra"
+        }
+        kwargs.update(field_info.extra)
+        return kwargs
+
+    def model_field_validate(
+        model_field: ModelField, value: Any, config: Optional[type[ConfigDict]] = None
+    ) -> Any:
+        """Validate the value pass to the field.
+
+        Set config before validate to ensure validate correctly.
+        """
+
+        if model_field.model_config is not config:
+            model_field.set_config(config or ConfigDict)
+
+        v, errs_ = model_field.validate(value, {}, loc=())
+        if errs_:
+            raise ValueError(value, model_field)
+        return v
+
+    def model_fields(model: type[BaseModel]) -> list[ModelField]:
+        """Get field list of a model."""
+
+        # construct the model field without preprocess to avoid error
+        return [
+            ModelField._construct(
+                name=model_field.name,
+                annotation=model_field.annotation,
+                field_info=FieldInfo(
+                    **extract_field_info(model_field.field_info),
+                ),
+            )
+            for model_field in model.__fields__.values()
+        ]
+
+    def model_config(model: type[BaseModel]) -> Any:
+        """Get config of a model."""
+        return model.__config__
+
+    def model_dump(
+        model: BaseModel,
+        include: Optional[set[str]] = None,
+        exclude: Optional[set[str]] = None,
+        by_alias: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+    ) -> dict[str, Any]:
+        return model.dict(
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+        )
+
+    def type_validate_python(type_: type[T], data: Any) -> T:
+        """Validate data with given type."""
+        return parse_obj_as(type_, data)
+
+    def type_validate_json(type_: type[T], data: Union[str, bytes]) -> T:
+        """Validate JSON with given type."""
+        return parse_raw_as(type_, data)
+
+    def custom_validation(class_: type["CVC"]) -> type["CVC"]:
+        """Do nothing in pydantic v1"""
+        return class_

nonebot/config.py

@@ -1,132 +1,365 @@
 """本模块定义了 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
+import abc
+import json
 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 collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Union, Optional
+from typing_extensions import TypeAlias, get_args, get_origin
 
-from pydantic import BaseSettings, IPvAnyAddress
-from pydantic.env_settings import (
-    SettingsError,
-    EnvSettingsSource,
-    InitSettingsSource,
-    SettingsSourceCallable,
-    read_env_file,
-    env_file_sentinel,
-)
+from dotenv import dotenv_values
+from pydantic import Field, BaseModel
+from pydantic.networks import IPvAnyAddress
 
 from nonebot.log import logger
-from nonebot.utils import escape_tag
+from nonebot.typing import origin_is_union
+from nonebot.utils import deep_update, type_is_complex, lenient_issubclass
+from nonebot.compat import (
+    PYDANTIC_V2,
+    ConfigDict,
+    ModelField,
+    PydanticUndefined,
+    PydanticUndefinedType,
+    model_config,
+    model_fields,
+)
+
+DOTENV_TYPE: TypeAlias = Union[
+    Path, str, list[Union[Path, str]], tuple[Union[Path, str], ...]
+]
+
+ENV_FILE_SENTINEL = Path("")
 
 
-class CustomEnvSettings(EnvSettingsSource):
-    def __call__(self, settings: BaseSettings) -> Dict[str, Any]:
-        """
-        Build environment variables suitable for passing to the Model.
-        """
-        d: Dict[str, Optional[str]] = {}
+class SettingsError(ValueError): ...
 
-        if settings.__config__.case_sensitive:
-            env_vars: Mapping[str, Optional[str]] = os.environ  # pragma: no cover
-        else:
-            env_vars = {k.lower(): v for k, v in os.environ.items()}
 
-        env_file_vars: Dict[str, Optional[str]] = {}
-        env_file = (
-            self.env_file
-            if self.env_file != env_file_sentinel
-            else settings.__config__.env_file
+class BaseSettingsSource(abc.ABC):
+    def __init__(self, settings_cls: type["BaseSettings"]) -> None:
+        self.settings_cls = settings_cls
+
+    @property
+    def config(self) -> "SettingsConfig":
+        return model_config(self.settings_cls)
+
+    @abc.abstractmethod
+    def __call__(self) -> dict[str, Any]:
+        raise NotImplementedError
+
+
+class InitSettingsSource(BaseSettingsSource):
+    __slots__ = ("init_kwargs",)
+
+    def __init__(
+        self, settings_cls: type["BaseSettings"], init_kwargs: dict[str, Any]
+    ) -> None:
+        self.init_kwargs = init_kwargs
+        super().__init__(settings_cls)
+
+    def __call__(self) -> dict[str, Any]:
+        return self.init_kwargs
+
+    def __repr__(self) -> str:
+        return f"InitSettingsSource(init_kwargs={self.init_kwargs!r})"
+
+
+class DotEnvSettingsSource(BaseSettingsSource):
+    def __init__(
+        self,
+        settings_cls: type["BaseSettings"],
+        env_file: Optional[DOTENV_TYPE] = ENV_FILE_SENTINEL,
+        env_file_encoding: Optional[str] = None,
+        case_sensitive: Optional[bool] = None,
+        env_nested_delimiter: Optional[str] = None,
+    ) -> None:
+        super().__init__(settings_cls)
+        self.env_file = (
+            env_file
+            if env_file is not ENV_FILE_SENTINEL
+            else self.config.get("env_file", (".env",))
         )
-        env_file_encoding = (
-            self.env_file_encoding
-            if self.env_file_encoding is not None
-            else settings.__config__.env_file_encoding
+        self.env_file_encoding = (
+            env_file_encoding
+            if env_file_encoding is not None
+            else self.config.get("env_file_encoding", "utf-8")
         )
-        if env_file is not None:
-            env_path = Path(env_file)
+        self.case_sensitive = (
+            case_sensitive
+            if case_sensitive is not None
+            else self.config.get("case_sensitive", False)
+        )
+        self.env_nested_delimiter = (
+            env_nested_delimiter
+            if env_nested_delimiter is not None
+            else self.config.get("env_nested_delimiter", None)
+        )
+
+    def _apply_case_sensitive(self, var_name: str) -> str:
+        return var_name if self.case_sensitive else var_name.lower()
+
+    def _field_is_complex(self, field: ModelField) -> tuple[bool, bool]:
+        if type_is_complex(field.annotation):
+            return True, False
+        elif origin_is_union(get_origin(field.annotation)) and any(
+            type_is_complex(arg) for arg in get_args(field.annotation)
+        ):
+            return True, True
+        return False, False
+
+    def _parse_env_vars(
+        self, env_vars: Mapping[str, Optional[str]]
+    ) -> dict[str, Optional[str]]:
+        return {
+            self._apply_case_sensitive(key): value for key, value in env_vars.items()
+        }
+
+    def _read_env_file(self, file_path: Path) -> dict[str, Optional[str]]:
+        file_vars = dotenv_values(file_path, encoding=self.env_file_encoding)
+        return self._parse_env_vars(file_vars)
+
+    def _read_env_files(self) -> dict[str, Optional[str]]:
+        env_files = self.env_file
+        if env_files is None:
+            return {}
+
+        if isinstance(env_files, (str, os.PathLike)):
+            env_files = [env_files]
+
+        dotenv_vars: dict[str, Optional[str]] = {}
+        for env_file in env_files:
+            env_path = Path(env_file).expanduser()
             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}
+                dotenv_vars.update(self._read_env_file(env_path))
+        return dotenv_vars
 
-        for field in settings.__fields__.values():
-            env_val: Optional[str] = None
-            for env_name in field.field_info.extra["env_names"]:
-                env_val = env_vars.get(env_name)
-                if env_name in env_file_vars:
-                    del env_file_vars[env_name]
-                if env_val is not None:
-                    break
+    def _next_field(
+        self, field: Optional[ModelField], key: str
+    ) -> Optional[ModelField]:
+        if not field or origin_is_union(get_origin(field.annotation)):
+            return None
+        elif field.annotation and lenient_issubclass(field.annotation, BaseModel):
+            for field in model_fields(field.annotation):
+                if field.name == key:
+                    return field
+        return None
 
-            if env_val is None:
+    def _explode_env_vars(
+        self,
+        field: ModelField,
+        env_vars: dict[str, Optional[str]],
+        env_file_vars: dict[str, Optional[str]],
+    ) -> dict[str, Any]:
+        if self.env_nested_delimiter is None:
+            return {}
+
+        prefix = f"{field.name}{self.env_nested_delimiter}"
+        result: dict[str, Any] = {}
+        for env_name, env_val in env_vars.items():
+            if not env_name.startswith(prefix):
                 continue
 
-            if field.is_complex():
-                try:
-                    env_val = settings.__config__.json_loads(env_val)
-                except ValueError as e:  # pragma: no cover
-                    raise SettingsError(
-                        f'error parsing JSON for "{env_name}"'  # type: ignore
-                    ) from e
-            d[field.alias] = env_val
+            # delete from file vars when used
+            if env_name in env_file_vars:
+                del env_file_vars[env_name]
 
-        if env_file_vars:
-            for env_name in env_file_vars.keys():
-                env_val = env_vars[env_name]
+            _, *keys, last_key = env_name.split(self.env_nested_delimiter)
+            env_var = result
+            target_field: Optional[ModelField] = field
+            for key in keys:
+                target_field = self._next_field(target_field, key)
+                env_var = env_var.setdefault(key, {})
+
+            target_field = self._next_field(target_field, last_key)
+            if target_field and env_val:
+                is_complex, allow_parse_failure = self._field_is_complex(target_field)
+                if is_complex:
+                    try:
+                        env_val = json.loads(env_val)
+                    except ValueError as e:
+                        if not allow_parse_failure:
+                            raise SettingsError(
+                                f'error parsing env var "{env_name}"'
+                            ) from e
+
+            env_var[last_key] = env_val
+
+        return result
+
+    def __call__(self) -> dict[str, Any]:
+        """从环境变量和 dotenv 配置文件中读取配置项。"""
+
+        d: dict[str, Any] = {}
+
+        env_vars = self._parse_env_vars(os.environ)
+        env_file_vars = self._read_env_files()
+        env_vars = {**env_file_vars, **env_vars}
+
+        for field in model_fields(self.settings_cls):
+            field_name = field.name
+            env_name = self._apply_case_sensitive(field_name)
+
+            # try get values from env vars
+            env_val = env_vars.get(env_name, PydanticUndefined)
+            # delete from file vars when used
+            if env_name in env_file_vars:
+                del env_file_vars[env_name]
+
+            is_complex, allow_parse_failure = self._field_is_complex(field)
+            if is_complex:
+                if isinstance(env_val, PydanticUndefinedType):
+                    # field is complex but no value found so far, try explode_env_vars
+                    if env_val_built := self._explode_env_vars(
+                        field, env_vars, env_file_vars
+                    ):
+                        d[field_name] = env_val_built
+                elif env_val is None:
+                    d[field_name] = env_val
+                else:
+                    # field is complex and there's a value
+                    # decode that as JSON, then add explode_env_vars
+                    try:
+                        env_val = json.loads(env_val)
+                    except ValueError as e:
+                        if not allow_parse_failure:
+                            raise SettingsError(
+                                f'error parsing env var "{env_name}"'
+                            ) from e
+
+                    if isinstance(env_val, dict):
+                        # field value is a dict
+                        # try explode_env_vars to find more sub-values
+                        d[field_name] = deep_update(
+                            env_val,
+                            self._explode_env_vars(field, env_vars, env_file_vars),
+                        )
+                    else:
+                        d[field_name] = env_val
+            elif env_val is not PydanticUndefined:
+                # simplest case, field is not complex
+                # we only need to add the value if it was found
+                d[field_name] = env_val
+
+        # remain user custom config
+        for env_name in env_file_vars:
+            env_val = env_vars[env_name]
+            if env_val and (val_striped := env_val.strip()):
+                # there's a value, decode that as JSON
                 try:
-                    if env_val:
-                        env_val = settings.__config__.json_loads(env_val.strip())
-                except ValueError as e:
-                    logger.opt(colors=True, exception=e).trace(
-                        f"Error while parsing JSON for {escape_tag(env_name)}. Assumed as string."
+                    env_val = json.loads(val_striped)
+                except ValueError:
+                    logger.trace(
+                        "Error while parsing JSON for "
+                        f"{env_name!r}={val_striped!r}. "
+                        "Assumed as string."
                     )
 
+            # explode value when it's a nested dict
+            env_name, *nested_keys = env_name.split(self.env_nested_delimiter)
+            if nested_keys and (env_name not in d or isinstance(d[env_name], dict)):
+                result = {}
+                *keys, last_key = nested_keys
+                _tmp = result
+                for key in keys:
+                    _tmp = _tmp.setdefault(key, {})
+                _tmp[last_key] = env_val
+                d[env_name] = deep_update(d.get(env_name, {}), result)
+            elif not nested_keys:
                 d[env_name] = env_val
 
         return d
 
 
-class BaseConfig(BaseSettings):
+if PYDANTIC_V2:  # pragma: pydantic-v2
+
+    class SettingsConfig(ConfigDict, total=False):
+        env_file: Optional[DOTENV_TYPE]
+        env_file_encoding: str
+        case_sensitive: bool
+        env_nested_delimiter: Optional[str]
+
+else:  # pragma: pydantic-v1
+
+    class SettingsConfig(ConfigDict):
+        env_file: Optional[DOTENV_TYPE]
+        env_file_encoding: str
+        case_sensitive: bool
+        env_nested_delimiter: Optional[str]
+
+
+class BaseSettings(BaseModel):
     if TYPE_CHECKING:
         # dummy getattr for pylance checking, actually not used
         def __getattr__(self, name: str) -> Any:  # pragma: no cover
             return self.__dict__.get(name)
 
-    class Config:
-        @classmethod
-        def customise_sources(
-            cls,
-            init_settings: InitSettingsSource,
-            env_settings: EnvSettingsSource,
-            file_secret_settings: SettingsSourceCallable,
-        ) -> Tuple[SettingsSourceCallable, ...]:
-            common_config = init_settings.init_kwargs.pop("_common_config", {})
-            return (
-                init_settings,
-                CustomEnvSettings(
-                    env_settings.env_file, env_settings.env_file_encoding
-                ),
-                InitSettingsSource(common_config),
-                file_secret_settings,
+    if PYDANTIC_V2:  # pragma: pydantic-v2
+        model_config = SettingsConfig(
+            extra="allow",
+            env_file=".env",
+            env_file_encoding="utf-8",
+            case_sensitive=False,
+            env_nested_delimiter="__",
+        )
+    else:  # pragma: pydantic-v1
+
+        class Config(SettingsConfig):
+            extra = "allow"  # type: ignore
+            env_file = ".env"
+            env_file_encoding = "utf-8"
+            case_sensitive = False
+            env_nested_delimiter = "__"
+
+    def __init__(
+        __settings_self__,  # pyright: ignore[reportSelfClsParameterName]
+        _env_file: Optional[DOTENV_TYPE] = ENV_FILE_SENTINEL,
+        _env_file_encoding: Optional[str] = None,
+        _env_nested_delimiter: Optional[str] = None,
+        **values: Any,
+    ) -> None:
+        super().__init__(
+            **__settings_self__._settings_build_values(
+                values,
+                env_file=_env_file,
+                env_file_encoding=_env_file_encoding,
+                env_nested_delimiter=_env_nested_delimiter,
             )
+        )
+
+    def _settings_build_values(
+        self,
+        init_kwargs: dict[str, Any],
+        env_file: Optional[DOTENV_TYPE] = None,
+        env_file_encoding: Optional[str] = None,
+        env_nested_delimiter: Optional[str] = None,
+    ) -> dict[str, Any]:
+        init_settings = InitSettingsSource(self.__class__, init_kwargs=init_kwargs)
+        env_settings = DotEnvSettingsSource(
+            self.__class__,
+            env_file=env_file,
+            env_file_encoding=env_file_encoding,
+            env_nested_delimiter=env_nested_delimiter,
+        )
+        return deep_update(env_settings(), init_settings())
 
 
-class Env(BaseConfig):
+class Env(BaseSettings):
     """运行环境配置。大小写不敏感。
 
-    将会从 `环境变量` > `.env 环境配置文件` 的优先级读取环境信息。
+    将会从 **环境变量** > **dotenv 配置文件** 的优先级读取环境信息。
     """
 
     environment: str = "prod"
@@ -135,22 +368,18 @@ class Env(BaseConfig):
     NoneBot 将从 `.env.{environment}` 文件中加载配置。
     """
 
-    class Config:
-        extra = "allow"
-        env_file = ".env"
 
-
-class Config(BaseConfig):
+class Config(BaseSettings):
     """NoneBot 主要配置。大小写不敏感。
 
     除了 NoneBot 的配置项外，还可以自行添加配置项到 `.env.{environment}` 文件中。
     这些配置将会在 json 反序列化后一起带入 `Config` 类中。
 
-    配置方法参考: [配置](https://v2.nonebot.dev/docs/tutorial/configuration)
+    配置方法参考: [配置](https://nonebot.dev/docs/appendices/config)
     """
 
-    _env_file: str = ".env"
-    _common_config: Dict[str, Any] = {}
+    if TYPE_CHECKING:
+        _env_file: Optional[DOTENV_TYPE] = ".env", ".env.prod"
 
     # nonebot configs
     driver: str = "~fastapi"
@@ -159,15 +388,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`。
@@ -185,7 +416,7 @@ class Config(BaseConfig):
     """API 请求超时时间，单位: 秒。"""
 
     # bot runtime configs
-    superusers: Set[str] = set()
+    superusers: set[str] = set()
     """机器人超级用户。
 
     用法:
@@ -193,19 +424,23 @@ class Config(BaseConfig):
         SUPERUSERS=["12345789"]
         ```
     """
-    nickname: Set[str] = set()
+    nickname: set[str] = set()
     """机器人昵称。"""
-    command_start: Set[str] = {"/"}
+    command_start: set[str] = {"/"}
     """命令的起始标记，用于判断一条消息是不是命令。
 
+    参考[命令响应规则](https://nonebot.dev/docs/advanced/matcher#command)。
+
     用法:
         ```conf
         COMMAND_START=["/", ""]
         ```
     """
-    command_sep: Set[str] = {"."}
+    command_sep: set[str] = {"."}
     """命令的分隔标记，用于将文本形式的命令切分为元组（实际的命令名）。
 
+    参考[命令响应规则](https://nonebot.dev/docs/advanced/matcher#command)。
+
     用法:
         ```conf
         COMMAND_SEP=["."]
@@ -216,9 +451,8 @@ class Config(BaseConfig):
 
     用法:
         ```conf
-        SESSION_EXPIRE_TIMEOUT=120  # 单位: 秒
-        SESSION_EXPIRE_TIMEOUT=[DD ][HH:MM]SS[.ffffff]
-        SESSION_EXPIRE_TIMEOUT=P[DD]DT[HH]H[MM]M[SS]S  # ISO 8601
+        SESSION_EXPIRE_TIMEOUT=[-][DD]D[,][HH:MM:]SS[.ffffff]
+        SESSION_EXPIRE_TIMEOUT=[±]P[DD]DT[HH]H[MM]M[SS]S  # ISO 8601
         ```
     """
 
@@ -229,12 +463,21 @@ class Config(BaseConfig):
     # custom configs can be assigned during nonebot.init
     # or from env file using json loads
 
-    class Config:
-        extra = "allow"
-        env_file = ".env.prod"
+    if PYDANTIC_V2:  # pragma: pydantic-v2
+        model_config = SettingsConfig(env_file=(".env", ".env.prod"))
+    else:  # pragma: pydantic-v1
+
+        class Config(  # pyright: ignore[reportIncompatibleVariableOverride]
+            SettingsConfig
+        ):
+            env_file = ".env", ".env.prod"
 
 
 __autodoc__ = {
-    "CustomEnvSettings": False,
-    "BaseConfig": False,
+    "SettingsError": False,
+    "BaseSettingsSource": False,
+    "InitSettingsSource": False,
+    "DotEnvSettingsSource": False,
+    "SettingsConfig": False,
+    "BaseSettings": False,
 }

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"
-"""正则匹配 group 元组存储 key"""
-REGEX_DICT: Literal["_matched_dict"] = "_matched_dict"
-"""正则匹配 group 字典存储 key"""
+STARTSWITH_KEY: Literal["_startswith"] = "_startswith"
+"""响应触发前缀 key"""
+ENDSWITH_KEY: Literal["_endswith"] = "_endswith"
+"""响应触发后缀 key"""
+FULLMATCH_KEY: Literal["_fullmatch"] = "_fullmatch"
+"""响应触发完整消息 key"""
+KEYWORD_KEY: Literal["_keyword"] = "_keyword"
+"""响应触发关键字 key"""
+
+WINDOWS = sys.platform.startswith("win") or (sys.platform == "cli" and os.name == "nt")

nonebot/dependencies/__init__.py

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

nonebot/dependencies/utils.py

@@ -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, Callable, ForwardRef
 
 from loguru import logger
-from pydantic.fields import ModelField
-from pydantic.typing import ForwardRef, evaluate_forwardref
 
 from nonebot.exception import TypeMisMatch
-
-V = TypeVar("V")
+from nonebot.typing import evaluate_forwardref
+from nonebot.compat import DEFAULT_CONFIG, ModelField, model_field_validate
 
 
 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 typed_signature
+    return inspect.Signature(typed_params)
 
 
-def get_typed_annotation(param: inspect.Parameter, globalns: Dict[str, Any]) -> Any:
+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:
-    _, errs_ = field.validate(value, {}, loc=())
-    if errs_:
+def check_field_type(field: ModelField, value: Any) -> Any:
+    """检查字段类型是否匹配"""
+
+    try:
+        return model_field_validate(field, value, DEFAULT_CONFIG)
+    except ValueError:
         raise TypeMisMatch(field, value)
-    return value

nonebot/drivers/__init__.py

@@ -8,30 +8,41 @@ 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 HTTPClientSession as HTTPClientSession
+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/aiohttp.py

@@ -15,66 +15,150 @@ FrontMatter:
     description: nonebot.drivers.aiohttp 模块
 """
 
-from typing import Type, AsyncGenerator
+from typing_extensions import override
+from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, Union, Optional
+
+from multidict import CIMultiDict
 
-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 import URL, Request, Response
+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.internal.driver import Cookies, QueryTypes, CookieTypes, HeaderTypes
+from nonebot.drivers import (
+    HTTPVersion,
+    HTTPClientMixin,
+    HTTPClientSession,
+    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]`"
-    ) from None
+        "Please install aiohttp first to use this driver. "
+        "Install with pip: `pip install nonebot2[aiohttp]`"
+    ) from e
 
 
-class Mixin(ForwardMixin):
+class Session(HTTPClientSession):
+    @override
+    def __init__(
+        self,
+        params: QueryTypes = None,
+        headers: HeaderTypes = None,
+        cookies: CookieTypes = None,
+        version: Union[str, HTTPVersion] = HTTPVersion.H11,
+        timeout: Optional[float] = None,
+        proxy: Optional[str] = None,
+    ):
+        self._client: Optional[aiohttp.ClientSession] = None
+
+        self._params = URL.build(query=params).query if params is not None else None
+
+        self._headers = CIMultiDict(headers) if headers is not None else None
+        self._cookies = tuple(
+            (cookie.name, cookie.value)
+            for cookie in Cookies(cookies)
+            if cookie.value is not None
+        )
+
+        version = HTTPVersion(version)
+        if version == HTTPVersion.H10:
+            self._version = aiohttp.HttpVersion10
+        elif version == HTTPVersion.H11:
+            self._version = aiohttp.HttpVersion11
+        else:
+            raise RuntimeError(f"Unsupported HTTP version: {version}")
+
+        self._timeout = timeout
+        self._proxy = proxy
+
+    @property
+    def client(self) -> aiohttp.ClientSession:
+        if self._client is None:
+            raise RuntimeError("Session is not initialized")
+        return self._client
+
+    @override
+    async def request(self, setup: Request) -> Response:
+        if self._params:
+            params = self._params.copy()
+            params.update(setup.url.query)
+            url = setup.url.with_query(params)
+        else:
+            url = setup.url
+
+        data = setup.data
+        if setup.files:
+            data = aiohttp.FormData(data or {}, quote_fields=False)
+            for name, file in setup.files:
+                data.add_field(name, file[1], content_type=file[2], filename=file[0])
+
+        cookies = (
+            (cookie.name, cookie.value)
+            for cookie in setup.cookies
+            if cookie.value is not None
+        )
+
+        timeout = aiohttp.ClientTimeout(setup.timeout)
+
+        async with await self.client.request(
+            setup.method,
+            url,
+            data=setup.content or data,
+            json=setup.json,
+            cookies=cookies,
+            headers=setup.headers,
+            proxy=setup.proxy or self._proxy,
+            timeout=timeout,
+        ) as response:
+            return Response(
+                response.status,
+                headers=response.headers.copy(),
+                content=await response.read(),
+                request=setup,
+            )
+
+    @override
+    async def setup(self) -> None:
+        if self._client is not None:
+            raise RuntimeError("Session has already been initialized")
+        self._client = aiohttp.ClientSession(
+            cookies=self._cookies,
+            headers=self._headers,
+            version=self._version,
+            timeout=self._timeout,
+            trust_env=True,
+        )
+        await self._client.__aenter__()
+
+    @override
+    async def close(self) -> None:
+        try:
+            if self._client is not None:
+                await self._client.close()
+        finally:
+            self._client = None
+
+
+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
-        elif setup.version == HTTPVersion.H11:
-            version = aiohttp.HttpVersion11
-        else:
-            raise RuntimeError(f"Unsupported HTTP version: {setup.version}")
+        async with self.get_session() as session:
+            return await session.request(setup)
 
-        timeout = aiohttp.ClientTimeout(setup.timeout)
-        files = None
-        if setup.files:
-            files = aiohttp.FormData()
-            for name, file in setup.files:
-                files.add_field(name, file[1], content_type=file[2], filename=file[0])
-        async with aiohttp.ClientSession(version=version, trust_env=True) as session:
-            async with session.request(
-                setup.method,
-                setup.url,
-                data=setup.content or setup.data or files,
-                json=setup.json,
-                headers=setup.headers,
-                timeout=timeout,
-                proxy=setup.proxy,
-            ) as response:
-                res = 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 +176,26 @@ class Mixin(ForwardMixin):
                 headers=setup.headers,
                 proxy=setup.proxy,
             ) as ws:
-                websocket = WebSocket(request=setup, session=session, websocket=ws)
-                yield websocket
+                yield WebSocket(request=setup, session=session, websocket=ws)
+
+    @override
+    def get_session(
+        self,
+        params: QueryTypes = None,
+        headers: HeaderTypes = None,
+        cookies: CookieTypes = None,
+        version: Union[str, HTTPVersion] = HTTPVersion.H11,
+        timeout: Optional[float] = None,
+        proxy: Optional[str] = None,
+    ) -> Session:
+        return Session(
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            version=version,
+            timeout=timeout,
+            proxy=proxy,
+        )
 
 
 class WebSocket(BaseWebSocket):
@@ -111,17 +213,17 @@ 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)
-    async def close(self, code: int = 1000):
-        await self.websocket.close(code=code)
+    @override
+    async def close(self, code: int = 1000, reason: str = ""):
+        await self.websocket.close(code=code, message=reason.encode("utf-8"))
         await self.session.close()
 
     async def _receive(self) -> aiohttp.WSMessage:
@@ -130,7 +232,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 +241,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 +250,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 +259,19 @@ 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
-"""AIOHTTP Driver"""
+if TYPE_CHECKING:
+
+    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 提示
 本驱动仅支持服务端连接
 :::
@@ -10,23 +16,34 @@ FrontMatter:
 """
 
 import logging
+import contextlib
 from functools import wraps
-from typing import Any, List, Tuple, Union, Callable, Optional
+from typing_extensions import override
+from typing import Any, Union, Optional
 
-import uvicorn
-from pydantic import BaseSettings
-from fastapi.responses import Response
-from fastapi import FastAPI, Request, UploadFile, status
-from starlette.websockets import WebSocket, WebSocketState, WebSocketDisconnect
+from pydantic import BaseModel
 
 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.compat import model_dump, type_validate_python
+from nonebot.drivers import HTTPServerSetup, WebSocketServerSetup
+
+try:
+    import uvicorn
+    from fastapi.responses import Response
+    from fastapi import FastAPI, Request, UploadFile, status
+    from starlette.websockets import WebSocket, WebSocketState, WebSocketDisconnect
+except 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):
@@ -42,7 +59,7 @@ def catch_closed(func):
     return decorator
 
 
-class Config(BaseSettings):
+class Config(BaseModel):
     """FastAPI 驱动框架设置，详情参考 FastAPI 文档"""
 
     fastapi_openapi_url: Optional[str] = None
@@ -55,58 +72,59 @@ class Config(BaseSettings):
     """是否包含适配器路由的 schema，默认为 `True`"""
     fastapi_reload: bool = False
     """开启/关闭冷重载"""
-    fastapi_reload_dirs: Optional[List[str]] = None
+    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
+    fastapi_reload_includes: Optional[list[str]] = None
     """要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值"""
-    fastapi_reload_excludes: Optional[List[str]] = None
+    fastapi_reload_excludes: Optional[list[str]] = None
     """不要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值"""
-
-    class Config:
-        extra = "ignore"
+    fastapi_extra: dict[str, Any] = {}
+    """传递给 `FastAPI` 的其他参数。"""
 
 
-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.fastapi_config: Config = type_validate_python(Config, model_dump(config))
 
         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 +137,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,27 +148,25 @@ class Driver(ReverseDriver):
             name=setup.name,
         )
 
-    @overrides(ReverseDriver)
-    def on_startup(self, func: Callable) -> Callable:
-        """参考文档: `Events <https://fastapi.tiangolo.com/advanced/events/#startup-event>`_"""
-        return self.server_app.on_event("startup")(func)
+    @contextlib.asynccontextmanager
+    async def _lifespan_manager(self, app: FastAPI):
+        await self._lifespan.startup()
+        try:
+            yield
+        finally:
+            await self._lifespan.shutdown()
 
-    @overrides(ReverseDriver)
-    def on_shutdown(self, func: Callable) -> Callable:
-        """参考文档: `Events <https://fastapi.tiangolo.com/advanced/events/#shutdown-event>`_"""
-        return self.server_app.on_event("shutdown")(func)
-
-    @overrides(ReverseDriver)
+    @override
     def run(
         self,
         host: Optional[str] = None,
         port: Optional[int] = None,
-        *,
+        *args,
         app: Optional[str] = None,
         **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 +202,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:
+        files: Optional[list[tuple[str, FileTypes]]] = None
+        with contextlib.suppress(Exception):
             form = await request.form()
             data = {}
             files = []
@@ -204,8 +218,7 @@ class Driver(ReverseDriver):
                     )
                 else:
                     data[key] = value
-        except Exception:
-            pass
+
         http_request = BaseRequest(
             request.method,
             str(request.url),
@@ -219,7 +232,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 +255,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 +286,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,67 +14,145 @@ FrontMatter:
     sidebar_position: 3
     description: nonebot.drivers.httpx 模块
 """
-from typing import Type, AsyncGenerator
-from contextlib import asynccontextmanager
 
-from nonebot.typing import overrides
-from nonebot.drivers._block_driver import BlockDriver
+from typing_extensions import override
+from typing import TYPE_CHECKING, Union, Optional
+
+from multidict import CIMultiDict
+
+from nonebot.drivers.none import Driver as NoneDriver
+from nonebot.internal.driver import Cookies, QueryTypes, CookieTypes, HeaderTypes
 from nonebot.drivers import (
+    URL,
     Request,
     Response,
-    WebSocket,
     HTTPVersion,
-    ForwardMixin,
-    ForwardDriver,
+    HTTPClientMixin,
+    HTTPClientSession,
     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]`"
-    ) from None
+        "Please install httpx first to use this driver. "
+        "Install with pip: `pip install nonebot2[httpx]`"
+    ) from e
 
 
-class Mixin(ForwardMixin):
+class Session(HTTPClientSession):
+    @override
+    def __init__(
+        self,
+        params: QueryTypes = None,
+        headers: HeaderTypes = None,
+        cookies: CookieTypes = None,
+        version: Union[str, HTTPVersion] = HTTPVersion.H11,
+        timeout: Optional[float] = None,
+        proxy: Optional[str] = None,
+    ):
+        self._client: Optional[httpx.AsyncClient] = None
+
+        self._params = (
+            tuple(URL.build(query=params).query.items()) if params is not None else None
+        )
+        self._headers = (
+            tuple(CIMultiDict(headers).items()) if headers is not None else None
+        )
+        self._cookies = Cookies(cookies)
+        self._version = HTTPVersion(version)
+        self._timeout = timeout
+        self._proxy = proxy
+
+    @property
+    def client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            raise RuntimeError("Session is not initialized")
+        return self._client
+
+    @override
+    async def request(self, setup: Request) -> Response:
+        response = await self.client.request(
+            setup.method,
+            str(setup.url),
+            content=setup.content,
+            data=setup.data,
+            files=setup.files,
+            json=setup.json,
+            headers=tuple(setup.headers.items()),
+            cookies=setup.cookies.jar,
+            timeout=setup.timeout,
+        )
+        return Response(
+            response.status_code,
+            headers=response.headers.multi_items(),
+            content=response.content,
+            request=setup,
+        )
+
+    @override
+    async def setup(self) -> None:
+        if self._client is not None:
+            raise RuntimeError("Session has already been initialized")
+        self._client = httpx.AsyncClient(
+            params=self._params,
+            headers=self._headers,
+            cookies=self._cookies.jar,
+            http2=self._version == HTTPVersion.H2,
+            proxies=self._proxy,
+            follow_redirects=True,
+        )
+        await self._client.__aenter__()
+
+    @override
+    async def close(self) -> None:
+        try:
+            if self._client is not None:
+                await self._client.aclose()
+        finally:
+            self._client = None
+
+
+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(
-            http2=setup.version == HTTPVersion.H2,
-            proxies=setup.proxy,  # type: ignore
-            follow_redirects=True,
-        ) as client:
-            response = await client.request(
-                setup.method,
-                str(setup.url),
-                content=setup.content,  # type: ignore
-                data=setup.data,  # type: ignore
-                json=setup.json,
-                files=setup.files,  # type: ignore
-                headers=tuple(setup.headers.items()),
-                timeout=setup.timeout,
-            )
-            return Response(
-                response.status_code,
-                headers=response.headers.multi_items(),
-                content=response.content,
-                request=setup,
-            )
+        async with self.get_session(
+            version=setup.version, proxy=setup.proxy
+        ) as session:
+            return await session.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
+    @override
+    def get_session(
+        self,
+        params: QueryTypes = None,
+        headers: HeaderTypes = None,
+        cookies: CookieTypes = None,
+        version: Union[str, HTTPVersion] = HTTPVersion.H11,
+        timeout: Optional[float] = None,
+        proxy: Optional[str] = None,
+    ) -> Session:
+        return Session(
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            version=version,
+            timeout=timeout,
+            proxy=proxy,
+        )
 
 
-Driver: Type[ForwardDriver] = combine_driver(BlockDriver, Mixin)  # type: ignore
-"""HTTPX Driver"""
+if TYPE_CHECKING:
+
+    class Driver(Mixin, NoneDriver): ...
+
+else:
+    Driver = combine_driver(NoneDriver, Mixin)
+    """HTTPX Driver"""

nonebot/drivers/none.py

@@ -0,0 +1,143 @@
+"""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
+
+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.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 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>Application startup failed. "
+                "Exiting.</bg #f8bbd0></r>"
+            )
+            self.should_exit.set()
+            return
+
+        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,32 +17,35 @@ 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, Union, Optional, cast
 
-import uvicorn
-from pydantic import BaseSettings
+from pydantic import BaseModel
 
 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.compat import model_dump, type_validate_python
+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]`"
-    ) from None
-
-_AsyncCallable = TypeVar("_AsyncCallable", bound=Callable[..., Coroutine])
+        "Please install Quart first to use this driver. "
+        "Install with pip: `pip install nonebot2[quart]`"
+    ) from e
 
 
 def catch_closed(func):
@@ -56,59 +59,62 @@ def catch_closed(func):
     return decorator
 
 
-class Config(BaseSettings):
+class Config(BaseModel):
     """Quart 驱动框架设置"""
 
     quart_reload: bool = False
     """开启/关闭冷重载"""
-    quart_reload_dirs: Optional[List[str]] = None
+    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
+    quart_reload_includes: Optional[list[str]] = None
     """要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值"""
-    quart_reload_excludes: Optional[List[str]] = None
+    quart_reload_excludes: Optional[list[str]] = None
     """不要监听的文件列表，支持 glob pattern，默认为 uvicorn 默认值"""
-
-    class Config:
-        extra = "ignore"
+    quart_extra: dict[str, Any] = {}
+    """传递给 `Quart` 的其他参数。"""
 
 
-class Driver(ReverseDriver):
+class Driver(BaseDriver, ASGIMixin):
     """Quart 驱动框架"""
 
     def __init__(self, env: Env, config: NoneBotConfig):
         super().__init__(env, config)
 
-        self.quart_config = Config(**config.dict())
+        self.quart_config = type_validate_python(Config, model_dump(config))
 
-        self._server_app = Quart(self.__class__.__qualname__)
+        self._server_app = Quart(
+            self.__class__.__qualname__, **self.quart_config.quart_extra
+        )
+        self._server_app.before_serving(self._lifespan.startup)
+        self._server_app.after_serving(self._lifespan.shutdown)
 
     @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 +126,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,22 +137,12 @@ class Driver(ReverseDriver):
             view_func=_handle,
         )
 
-    @overrides(ReverseDriver)
-    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)
-    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,
         port: Optional[int] = None,
-        *,
+        *args,
         app: Optional[str] = None,
         **kwargs,
     ):
@@ -184,13 +180,11 @@ class Driver(ReverseDriver):
     async def _handle_http(self, setup: HTTPServerSetup) -> Response:
         request: Request = _request
 
-        json = None
-        if request.is_json:
-            json = await request.get_json()
+        json = await request.get_json() if request.is_json else None
 
         data = await request.form
         files_dict = await request.files
-        files: List[Tuple[str, FileTypes]] = []
+        files: list[tuple[str, FileTypes]] = []
         key: str
         value: FileStorage
         for key, value in files_dict.items():
@@ -219,7 +213,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 +224,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 +232,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 +267,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 +275,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,63 +14,64 @@ 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 collections.abc import Coroutine, AsyncGenerator
+from typing import TYPE_CHECKING, Any, Union, TypeVar, Callable
 
-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, Coroutine[Any, Any, T]]
+) -> Callable[P, Coroutine[Any, Any, 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:
-            if e.rcvd_then_sent:
-                raise WebSocketClosed(e.rcvd.code, e.rcvd.reason)  # type: ignore
-            else:
-                raise WebSocketClosed(e.sent.code, e.sent.reason)  # type: ignore
+            raise WebSocketClosed(e.code, e.reason)
 
     return decorator
 
 
-class Mixin(ForwardMixin):
+class Mixin(WebSocketClientMixin):
     """Websockets Mixin"""
 
     @property
-    @overrides(ForwardMixin)
+    @override
     def type(self) -> str:
         return "websockets"
 
-    @overrides(ForwardMixin)
-    async def request(self, setup: Request) -> Response:
-        return await super(Mixin, self).request(setup)
-
-    @overrides(ForwardMixin)
+    @override
     @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 msg
+        return await self.websocket.recv()
 
-    @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,19 @@ 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
-"""Websockets Driver"""
+if TYPE_CHECKING:
+
+    class Driver(Mixin, NoneDriver): ...
+
+else:
+    Driver = combine_driver(NoneDriver, Mixin)
+    """Websockets Driver"""

nonebot/exception.py

@@ -31,26 +31,30 @@ FrontMatter:
 
 from typing import Any, Optional
 
-from pydantic.fields import ModelField
+from nonebot.compat 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):
-        return f"<ParserExit status={self.status} message={self.message}>"
-
-    def __str__(self):
-        return self.__repr__()
+    def __repr__(self) -> str:
+        return (
+            f"ParserExit(status={self.status}"
+            + (f", message={self.message!r}" if self.message else "")
+            + ")"
+        )
 
 
 # Processor Exception
@@ -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):
-        return f"<IgnoredException, reason={self.reason}>"
-
-    def __str__(self):
-        return self.__repr__()
+    def __repr__(self) -> str:
+        return f"IgnoredException(reason={self.reason!r})"
 
 
 class SkippedException(ProcessException):
@@ -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):
-        return f"<TypeMisMatch, param={self.param}, value={self.value}>"
-
-    def __str__(self):
-        self.__repr__()
+    def __repr__(self) -> str:
+        return (
+            f"TypeMisMatch(param={self.param.name}, "
+            f"type={self.param._type_display()}, value={self.value!r}>"
+        )
 
 
 class MockApiException(ProcessException):
-    """指示 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):
-        return f"<ApiCancelledException, result={self.result}>"
-
-    def __str__(self):
-        return self.__repr__()
+    def __repr__(self) -> str:
+        return f"MockApiException(result={self.result!r})"
 
 
 class StopPropagation(ProcessException):
@@ -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

@@ -1,16 +1,19 @@
 import abc
+from typing import Any
+from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
-from typing import Any, Dict, AsyncGenerator
 
 from nonebot.config import Config
+from nonebot.internal.driver._lifespan import LIFESPAN_FUNC
 from nonebot.internal.driver import (
     Driver,
     Request,
     Response,
+    ASGIMixin,
     WebSocket,
-    ForwardDriver,
-    ReverseDriver,
+    HTTPClientMixin,
     HTTPServerSetup,
+    WebSocketClientMixin,
     WebSocketServerSetup,
 )
 
@@ -30,9 +33,12 @@ class Adapter(abc.ABC):
     def __init__(self, driver: Driver, **kwargs: Any):
         self.driver: Driver = driver
         """{ref}`nonebot.drivers.Driver` 实例"""
-        self.bots: Dict[str, Bot] = {}
+        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,35 +69,39 @@ 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
 
+    def on_ready(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
+        return self.driver._lifespan.on_ready(func)
+
     @abc.abstractmethod
     async def _call_api(self, bot: Bot, api: str, **data: Any) -> Any:
         """`Adapter` 实际调用 api 的逻辑实现函数，实现该方法以调用 api。

nonebot/internal/adapter/bot.py

@@ -1,8 +1,7 @@
 import abc
 import asyncio
 from functools import partial
-from typing_extensions import Protocol
-from typing import TYPE_CHECKING, Any, Set, Union, Optional
+from typing import TYPE_CHECKING, Any, Union, ClassVar, Optional, Protocol
 
 from nonebot.log import logger
 from nonebot.config import Config
@@ -14,10 +13,8 @@ if TYPE_CHECKING:
     from .adapter import Adapter
     from .message import Message, MessageSegment
 
-
-class _ApiCall(Protocol):
-    async def __call__(self, **kwargs: Any) -> Any:
-        ...
+    class _ApiCall(Protocol):
+        async def __call__(self, **kwargs: Any) -> Any: ...
 
 
 class Bot(abc.ABC):
@@ -30,9 +27,9 @@ class Bot(abc.ABC):
         self_id: 机器人 ID
     """
 
-    _calling_api_hook: Set[T_CallingAPIHook] = set()
+    _calling_api_hook: ClassVar[set[T_CallingAPIHook]] = set()
     """call_api 时执行的函数"""
-    _called_api_hook: Set[T_CalledAPIHook] = set()
+    _called_api_hook: ClassVar[set[T_CalledAPIHook]] = set()
     """call_api 后执行的函数"""
 
     def __init__(self, adapter: "Adapter", self_id: str):
@@ -41,7 +38,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 +76,7 @@ class Bot(abc.ABC):
         skip_calling_api: bool = False
         exception: Optional[Exception] = None
 
-        coros = list(map(lambda x: x(self, api, data), self._calling_api_hook))
-        if coros:
+        if coros := [hook(self, api, data) for hook in self._calling_api_hook]:
             try:
                 logger.debug("Running CallingAPI hooks...")
                 await asyncio.gather(*coros)
@@ -95,15 +98,17 @@ class Bot(abc.ABC):
             except Exception as e:
                 exception = e
 
-        coros = list(
-            map(lambda x: x(self, exception, api, data, result), self._called_api_hook)
-        )
-        if coros:
+        if coros := [
+            hook(self, exception, api, data, result) for hook in self._called_api_hook
+        ]:
             try:
                 logger.debug("Running CalledAPI hooks...")
                 await asyncio.gather(*coros)
             except MockApiException as e:
+                # mock api result
                 result = e.result
+                # ignore exception
+                exception = None
                 logger.debug(
                     f"Calling API {api} result is mocked. Return {result} instead."
                 )

nonebot/internal/adapter/event.py

@@ -1,9 +1,10 @@
 import abc
-from typing import Any, Type, TypeVar
+from typing import Any, TypeVar
 
 from pydantic import BaseModel
 
 from nonebot.utils import DataclassEncoder
+from nonebot.compat import PYDANTIC_V2, ConfigDict
 
 from .message import Message
 
@@ -13,15 +14,21 @@ E = TypeVar("E", bound="Event")
 class Event(abc.ABC, BaseModel):
     """Event 基类。提供获取关键信息的方法，其余信息可直接获取。"""
 
-    class Config:
-        extra = "allow"
-        json_encoders = {Message: DataclassEncoder}
+    if PYDANTIC_V2:  # pragma: pydantic-v2
+        model_config = ConfigDict(extra="allow")
+    else:  # pragma: pydantic-v1
 
-    @classmethod
-    def validate(cls: Type["E"], value: Any) -> "E":
-        if isinstance(value, Event) and not isinstance(value, cls):
-            raise TypeError(f"{value} is incompatible with Event type {cls}")
-        return super().validate(value)
+        class Config(ConfigDict):
+            extra = "allow"  # type: ignore
+            json_encoders = {Message: DataclassEncoder}  # noqa: RUF012
+
+    if not PYDANTIC_V2:  # pragma: pydantic-v1
+
+        @classmethod
+        def validate(cls: type["E"], value: Any) -> "E":
+            if isinstance(value, Event) and not isinstance(value, cls):
+                raise TypeError(f"{value} is incompatible with Event type {cls}")
+            return super().validate(value)
 
     @abc.abstractmethod
     def get_type(self) -> str:
@@ -44,10 +51,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 +66,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,41 +1,40 @@
 import abc
 from copy import deepcopy
+from typing_extensions import Self
+from collections.abc import Iterable
 from dataclasses import field, asdict, dataclass
-from typing import (
+from typing import (  # noqa: UP035
     Any,
-    Dict,
-    List,
     Type,
-    Tuple,
     Union,
     Generic,
     TypeVar,
-    Iterable,
     Optional,
+    SupportsIndex,
     overload,
 )
 
-from pydantic import parse_obj_as
+from nonebot.compat import custom_validation, type_validate_python
 
 from .template import MessageTemplate
 
-T = TypeVar("T")
 TMS = TypeVar("TMS", bound="MessageSegment")
 TM = TypeVar("TM", bound="Message")
 
 
+@custom_validation
 @dataclass
 class MessageSegment(abc.ABC, Generic[TM]):
     """消息段基类"""
 
     type: str
     """消息段类型"""
-    data: Dict[str, Any] = field(default_factory=dict)
+    data: dict[str, Any] = field(default_factory=dict)
     """消息段数据"""
 
     @classmethod
     @abc.abstractmethod
-    def get_message_class(cls) -> Type[TM]:
+    def get_message_class(cls) -> Type[TM]:  # noqa: UP006
         """获取消息数组类型"""
         raise NotImplementedError
 
@@ -47,7 +46,9 @@ class MessageSegment(abc.ABC, Generic[TM]):
     def __len__(self) -> int:
         return len(str(self))
 
-    def __ne__(self: T, other: T) -> bool:
+    def __ne__(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, other: Self
+    ) -> bool:
         return not self == other
 
     def __add__(self: TMS, other: Union[str, TMS, Iterable[TMS]]) -> TM:
@@ -61,9 +62,11 @@ 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 isinstance(value, MessageSegment):
+            raise ValueError(f"Type {type(value)} can not be converted to {cls}")
         if not isinstance(value, dict):
             raise ValueError(f"Expected dict for MessageSegment, got {type(value)}")
         if "type" not in value:
@@ -84,7 +87,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
@@ -93,8 +99,9 @@ class MessageSegment(abc.ABC, Generic[TM]):
         raise NotImplementedError
 
 
-class Message(List[TMS], abc.ABC):
-    """消息数组
+@custom_validation
+class Message(list[TMS], abc.ABC):
+    """消息序列
 
     参数:
         message: 消息内容
@@ -117,12 +124,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` 对象作为消息模板
-
-        并且提供了拓展的格式化控制符, 可以用适用于该消息类型的 `MessageSegment` 的工厂方法创建消息
+        用法和 `str.format` 大致相同，支持以 `Message` 对象作为消息模板并输出消息对象。
+        并且提供了拓展的格式化控制符，
+        可以通过该消息类型的 `MessageSegment` 工厂方法创建消息。
 
         参数:
             format_string: 格式化模板
@@ -134,7 +141,7 @@ class Message(List[TMS], abc.ABC):
 
     @classmethod
     @abc.abstractmethod
-    def get_segment_class(cls) -> Type[TMS]:
+    def get_segment_class(cls) -> type[TMS]:
         """获取消息段类型"""
         raise NotImplementedError
 
@@ -146,7 +153,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):
@@ -154,9 +161,9 @@ class Message(List[TMS], abc.ABC):
         elif isinstance(value, str):
             pass
         elif isinstance(value, dict):
-            value = parse_obj_as(cls.get_segment_class(), value)
+            value = type_validate_python(cls.get_segment_class(), value)
         elif isinstance(value, Iterable):
-            value = [parse_obj_as(cls.get_segment_class(), v) for v in value]
+            value = [type_validate_python(cls.get_segment_class(), v) for v in value]
         else:
             raise ValueError(
                 f"Expected str, dict or iterable for Message, got {type(value)}"
@@ -169,16 +176,18 @@ class Message(List[TMS], abc.ABC):
         """构造消息数组"""
         raise NotImplementedError
 
-    def __add__(self: TM, other: Union[str, TMS, Iterable[TMS]]) -> TM:
+    def __add__(  # pyright: ignore[reportIncompatibleMethodOverride]
+        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,69 +195,74 @@ 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,
+    def __getitem__(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self,
         args: Union[
             str,
-            Tuple[str, int],
-            Tuple[str, slice],
+            tuple[str, int],
+            tuple[str, slice],
             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 +277,54 @@ 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__(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, value: Union[TMS, str]
+    ) -> bool:
+        """检查消息段是否存在
+
+        参数:
+            value: 消息段或消息段类型
+        返回:
+            消息内是否存在给定消息段或给定类型的消息段
+        """
+        if isinstance(value, str):
+            return next((seg for seg in self if seg.type == value), None) is not 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 +339,32 @@ 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(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, obj: Union[str, TMS]
+    ) -> Self:
         """添加一个消息段到消息数组末尾。
 
         参数:
@@ -302,7 +378,9 @@ 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(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, obj: Union[Self, Iterable[TMS]]
+    ) -> Self:
         """拼接一个消息数组或多个消息段到消息数组末尾。
 
         参数:
@@ -312,18 +390,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,31 +1,33 @@
 import functools
 from string import Formatter
+from typing_extensions import TypeAlias
+from collections.abc import Mapping, Sequence
 from typing import (
     TYPE_CHECKING,
     Any,
-    Set,
-    Dict,
-    List,
-    Type,
-    Tuple,
     Union,
     Generic,
-    Mapping,
     TypeVar,
     Callable,
     Optional,
-    Sequence,
     cast,
     overload,
 )
 
+from _string import formatter_field_name_split  # type: ignore
+
 if TYPE_CHECKING:
     from .message import Message, MessageSegment
 
+    def formatter_field_name_split(
+        field_name: str,
+    ) -> tuple[str, list[tuple[bool, str]]]: ...
+
+
 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)
 
 
@@ -35,26 +37,38 @@ class MessageTemplate(Formatter, Generic[TF]):
     参数:
         template: 模板
         factory: 消息类型工厂，默认为 `str`
+        private_getattr: 是否允许在模板中访问私有属性，默认为 `False`
     """
 
     @overload
     def __init__(
-        self: "MessageTemplate[str]", template: str, factory: Type[str] = str
-    ) -> None:
-        ...
+        self: "MessageTemplate[str]",
+        template: str,
+        factory: type[str] = str,
+        private_getattr: bool = False,
+    ) -> None: ...
 
     @overload
     def __init__(
-        self: "MessageTemplate[TM]", template: Union[str, TM], factory: Type[TM]
-    ) -> None:
-        ...
+        self: "MessageTemplate[TM]",
+        template: Union[str, TM],
+        factory: type[TM],
+        private_getattr: bool = False,
+    ) -> None: ...
 
-    def __init__(  # type:ignore
-        self, template, factory=str
-    ) -> None:  # TODO: fix type hint here
-        self.template: TF = template
-        self.factory: Type[TF] = factory
-        self.format_specs: Dict[str, FormatSpecFunc] = {}
+    def __init__(
+        self,
+        template: Union[str, TM],
+        factory: Union[type[str], type[TM]] = str,
+        private_getattr: bool = False,
+    ) -> None:
+        self.template: TF = template  # type: ignore
+        self.factory: type[TF] = factory  # type: ignore
+        self.format_specs: dict[str, FormatSpecFunc] = {}
+        self.private_getattr = private_getattr
+
+    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
@@ -65,7 +79,9 @@ class MessageTemplate(Formatter, Generic[TF]):
         self.format_specs[name] = spec
         return spec
 
-    def format(self, *args, **kwargs):
+    def format(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, *args, **kwargs
+    ) -> TF:
         """根据传入参数和模板生成消息对象"""
         return self._format(args, kwargs)
 
@@ -95,10 +111,10 @@ 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(
+    def vformat(  # pyright: ignore[reportIncompatibleMethodOverride]
         self,
         format_string: str,
         args: Sequence[Any],
@@ -106,20 +122,19 @@ class MessageTemplate(Formatter, Generic[TF]):
     ) -> TF:
         raise NotImplementedError("`vformat` has merged into `_format`")
 
-    def _vformat(
+    def _vformat(  # pyright: ignore[reportIncompatibleMethodOverride]
         self,
         format_string: str,
         args: Sequence[Any],
         kwargs: Mapping[str, Any],
-        used_args: Set[Union[int, str]],
+        used_args: set[Union[int, str]],
         auto_arg_index: int = 0,
-    ) -> Tuple[TF, int]:
-        results: List[Any] = [self.factory()]
+    ) -> 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)
@@ -164,10 +179,23 @@ class MessageTemplate(Formatter, Generic[TF]):
 
         return functools.reduce(self._add, results), auto_arg_index
 
+    def get_field(
+        self, field_name: str, args: Sequence[Any], kwargs: Mapping[str, Any]
+    ) -> tuple[Any, Union[int, str]]:
+        first, rest = formatter_field_name_split(field_name)
+        obj = self.get_value(first, args, kwargs)
+
+        for is_attr, value in rest:
+            if not self.private_getattr and value.startswith("_"):
+                raise ValueError("Cannot access private attribute")
+            obj = getattr(obj, value) if is_attr else obj[value]
+
+        return obj, first
+
     def format_field(self, value: Any, format_spec: str) -> Any:
         formatter: Optional[FormatSpecFunc] = self.format_specs.get(format_spec)
         if formatter is None and not issubclass(self.factory, str):
-            segment_class: Type["MessageSegment"] = self.factory.get_segment_class()
+            segment_class: type["MessageSegment"] = self.factory.get_segment_class()
             method = getattr(segment_class, format_spec, None)
             if callable(method) and not cast(str, method.__name__).startswith("_"):
                 formatter = getattr(segment_class, format_spec)

nonebot/internal/driver/__init__.py

@@ -1,8 +1,9 @@
 from .model import URL as URL
 from .model import RawURL as RawURL
-from .driver import Driver as Driver
+from .abstract import Mixin as Mixin
 from .model import Cookies as Cookies
 from .model import Request as Request
+from .abstract import Driver as Driver
 from .model import FileType as FileType
 from .model import Response as Response
 from .model import DataTypes as DataTypes
@@ -10,16 +11,21 @@ from .model import FileTypes as FileTypes
 from .model import WebSocket as WebSocket
 from .model import FilesTypes as FilesTypes
 from .model import QueryTypes as QueryTypes
+from .abstract import ASGIMixin as ASGIMixin
 from .model import CookieTypes as CookieTypes
 from .model import FileContent as FileContent
 from .model import HTTPVersion as HTTPVersion
 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 .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 .abstract import ForwardMixin as ForwardMixin
+from .abstract import ReverseMixin as ReverseMixin
+from .abstract import ForwardDriver as ForwardDriver
+from .abstract import ReverseDriver as ReverseDriver
+from .combine import combine_driver as combine_driver
 from .model import HTTPServerSetup as HTTPServerSetup
+from .abstract import HTTPClientMixin as HTTPClientMixin
+from .abstract import HTTPClientSession as HTTPClientSession
 from .model import WebSocketServerSetup as WebSocketServerSetup
+from .abstract import WebSocketClientMixin as WebSocketClientMixin

nonebot/internal/driver/_lifespan.py

@@ -0,0 +1,55 @@
+from collections.abc import Awaitable
+from typing_extensions import TypeAlias
+from typing import Any, Union, Callable, 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._ready_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
+
+    def on_ready(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
+        self._ready_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)
+
+        if self._ready_funcs:
+            await self._run_lifespan_func(self._ready_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/internal/driver/abstract.py

@@ -0,0 +1,352 @@
+import abc
+import asyncio
+from types import TracebackType
+from collections.abc import AsyncGenerator
+from typing_extensions import Self, TypeAlias
+from contextlib import AsyncExitStack, asynccontextmanager
+from typing import TYPE_CHECKING, Any, Union, ClassVar, Optional
+
+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.internal.params import BotParam, DependParam, DefaultParam
+from nonebot.typing import (
+    T_DependencyCache,
+    T_BotConnectionHook,
+    T_BotDisconnectionHook,
+)
+
+from ._lifespan import LIFESPAN_FUNC, Lifespan
+from .model import (
+    Request,
+    Response,
+    WebSocket,
+    QueryTypes,
+    CookieTypes,
+    HeaderTypes,
+    HTTPVersion,
+    HTTPServerSetup,
+    WebSocketServerSetup,
+)
+
+if TYPE_CHECKING:
+    from nonebot.internal.adapter import Bot, Adapter
+
+
+BOT_HOOK_PARAMS = [DependParam, BotParam, DefaultParam]
+
+
+class Driver(abc.ABC):
+    """驱动器基类。
+
+    驱动器控制框架的启动和停止，适配器的注册，以及机器人生命周期管理。
+
+    参数:
+        env: 包含环境信息的 Env 对象
+        config: 包含配置信息的 Config 对象
+    """
+
+    _adapters: ClassVar[dict[str, "Adapter"]] = {}
+    """已注册的适配器列表"""
+    _bot_connection_hook: ClassVar[set[Dependent[Any]]] = set()
+    """Bot 连接建立时执行的函数"""
+    _bot_disconnection_hook: ClassVar[set[Dependent[Any]]] = set()
+    """Bot 连接断开时执行的函数"""
+
+    def __init__(self, env: Env, config: Config):
+        self.env: str = env.environment
+        """环境名称"""
+        self.config: Config = config
+        """全局配置对象"""
+        self._bots: dict[str, "Bot"] = {}
+        self._bot_tasks: set[asyncio.Task] = set()
+        self._lifespan = Lifespan()
+
+    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._bots
+
+    def register_adapter(self, adapter: type["Adapter"], **kwargs) -> None:
+        """注册一个协议适配器
+
+        参数:
+            adapter: 适配器类
+            kwargs: 其他传递给适配器的参数
+        """
+        name = adapter.get_name()
+        if name in self._adapters:
+            logger.opt(colors=True).debug(
+                f'Adapter "<y>{escape_tag(name)}</y>" already exists'
+            )
+            return
+        self._adapters[name] = adapter(self, **kwargs)
+        logger.opt(colors=True).debug(
+            f'Succeeded to load adapter "<y>{escape_tag(name)}</y>"'
+        )
+
+    @property
+    @abc.abstractmethod
+    def type(self) -> str:
+        """驱动类型名称"""
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def logger(self):
+        """驱动专属 logger 日志记录器"""
+        raise NotImplementedError
+
+    @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)
+
+    def on_startup(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
+        """注册一个启动时执行的函数"""
+        return self._lifespan.on_startup(func)
+
+    def on_shutdown(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
+        """注册一个停止时执行的函数"""
+        return self._lifespan.on_shutdown(func)
+
+    @classmethod
+    def on_bot_connect(cls, func: T_BotConnectionHook) -> T_BotConnectionHook:
+        """装饰一个函数使他在 bot 连接成功时执行。
+
+        钩子函数参数:
+
+        - bot: 当前连接上的 Bot 对象
+        """
+        cls._bot_connection_hook.add(
+            Dependent[Any].parse(call=func, allow_types=BOT_HOOK_PARAMS)
+        )
+        return func
+
+    @classmethod
+    def on_bot_disconnect(cls, func: T_BotDisconnectionHook) -> T_BotDisconnectionHook:
+        """装饰一个函数使他在 bot 连接断开时执行。
+
+        钩子函数参数:
+
+        - bot: 当前连接上的 Bot 对象
+        """
+        cls._bot_disconnection_hook.add(
+            Dependent[Any].parse(call=func, allow_types=BOT_HOOK_PARAMS)
+        )
+        return func
+
+    def _bot_connect(self, bot: "Bot") -> None:
+        """在连接成功后，调用该函数来注册 bot 对象"""
+        if bot.self_id in self._bots:
+            raise RuntimeError(f"Duplicate bot connection with id {bot.self_id}")
+        self._bots[bot.self_id] = bot
+
+        async def _run_hook(bot: "Bot") -> None:
+            dependency_cache: T_DependencyCache = {}
+            async with AsyncExitStack() as stack:
+                if coros := [
+                    run_coro_with_catch(
+                        hook(bot=bot, stack=stack, dependency_cache=dependency_cache),
+                        (SkippedException,),
+                    )
+                    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>"
+                        )
+
+        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._bots:
+            del self._bots[bot.self_id]
+
+        async def _run_hook(bot: "Bot") -> None:
+            dependency_cache: T_DependencyCache = {}
+            async with AsyncExitStack() as stack:
+                if coros := [
+                    run_coro_with_catch(
+                        hook(bot=bot, stack=stack, dependency_cache=dependency_cache),
+                        (SkippedException,),
+                    )
+                    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>"
+                        )
+
+        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 Mixin(abc.ABC):
+    """可与其他驱动器共用的混入基类。"""
+
+    @property
+    @abc.abstractmethod
+    def type(self) -> str:
+        """混入驱动类型名称"""
+        raise NotImplementedError
+
+
+class ForwardMixin(Mixin):
+    """客户端混入基类。"""
+
+
+class ReverseMixin(Mixin):
+    """服务端混入基类。"""
+
+
+class HTTPClientSession(abc.ABC):
+    """HTTP 客户端会话基类。"""
+
+    @abc.abstractmethod
+    def __init__(
+        self,
+        params: QueryTypes = None,
+        headers: HeaderTypes = None,
+        cookies: CookieTypes = None,
+        version: Union[str, HTTPVersion] = HTTPVersion.H11,
+        timeout: Optional[float] = None,
+        proxy: Optional[str] = None,
+    ):
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def request(self, setup: Request) -> Response:
+        """发送一个 HTTP 请求"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def setup(self) -> None:
+        """初始化会话"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    async def close(self) -> None:
+        """关闭会话"""
+        raise NotImplementedError
+
+    async def __aenter__(self) -> Self:
+        await self.setup()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc: Optional[BaseException],
+        tb: Optional[TracebackType],
+    ) -> None:
+        await self.close()
+
+
+class HTTPClientMixin(ForwardMixin):
+    """HTTP 客户端混入基类。"""
+
+    @abc.abstractmethod
+    async def request(self, setup: Request) -> Response:
+        """发送一个 HTTP 请求"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_session(
+        self,
+        params: QueryTypes = None,
+        headers: HeaderTypes = None,
+        cookies: CookieTypes = None,
+        version: Union[str, HTTPVersion] = HTTPVersion.H11,
+        timeout: Optional[float] = None,
+        proxy: Optional[str] = None,
+    ) -> HTTPClientSession:
+        """获取一个 HTTP 会话"""
+        raise NotImplementedError
+
+
+class WebSocketClientMixin(ForwardMixin):
+    """WebSocket 客户端混入基类。"""
+
+    @abc.abstractmethod
+    @asynccontextmanager
+    async def websocket(self, setup: Request) -> AsyncGenerator[WebSocket, None]:
+        """发起一个 WebSocket 连接"""
+        raise NotImplementedError
+        yield  # used for static type checking's generator detection
+
+
+class ASGIMixin(ReverseMixin):
+    """ASGI 服务端基类。
+
+    将后端框架封装，以满足适配器使用。
+    """
+
+    @property
+    @abc.abstractmethod
+    def server_app(self) -> Any:
+        """驱动 APP 对象"""
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def asgi(self) -> Any:
+        """驱动 ASGI 对象"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def setup_http_server(self, setup: "HTTPServerSetup") -> None:
+        """设置一个 HTTP 服务器路由配置"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def setup_websocket_server(self, setup: "WebSocketServerSetup") -> None:
+        """设置一个 WebSocket 服务器路由配置"""
+        raise NotImplementedError
+
+
+ForwardDriver: TypeAlias = ForwardMixin
+"""支持客户端请求的驱动器。
+
+**Deprecated**，请使用 {ref}`nonebot.drivers.ForwardMixin` 或其子类代替。
+"""
+
+ReverseDriver: TypeAlias = ReverseMixin
+"""支持服务端请求的驱动器。
+
+**Deprecated**，请使用 {ref}`nonebot.drivers.ReverseMixin` 或其子类代替。
+"""

nonebot/internal/driver/combine.py

@@ -0,0 +1,44 @@
+from typing import TYPE_CHECKING, Union, TypeVar, overload
+
+from .abstract import Mixin, Driver
+
+D = TypeVar("D", bound="Driver")
+
+if TYPE_CHECKING:
+
+    class CombinedDriver(Driver, Mixin): ...
+
+
+@overload
+def combine_driver(driver: type[D]) -> type[D]: ...
+
+
+@overload
+def combine_driver(
+    driver: type[D], _m: type[Mixin], *mixins: type[Mixin]
+) -> type["CombinedDriver"]: ...
+
+
+def combine_driver(
+    driver: type[D], *mixins: type[Mixin]
+) -> Union[type[D], type["CombinedDriver"]]:
+    """将一个驱动器和多个混入类合并。"""
+    # check first
+    if not issubclass(driver, Driver):
+        raise TypeError("`driver` must be subclass of Driver")
+    if not all(issubclass(m, Mixin) for m in mixins):
+        raise TypeError("`mixins` must be subclass of Mixin")
+
+    if not mixins:
+        return driver
+
+    def type_(self: "CombinedDriver") -> str:
+        return (
+            driver.type.__get__(self)  # type: ignore
+            + "+"
+            + "+".join(x.type.__get__(self) for x in mixins)  # type: ignore
+        )
+
+    return type(
+        "CombinedDriver", (*mixins, driver), {"type": property(type_)}
+    )  # type: ignore

nonebot/internal/driver/driver.py

@@ -1,245 +0,0 @@
-import abc
-import asyncio
-from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, Any, Set, Dict, Type, Callable, AsyncGenerator
-
-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 .model import Request, Response, WebSocket, HTTPServerSetup, WebSocketServerSetup
-
-if TYPE_CHECKING:
-    from nonebot.internal.adapter import Bot, Adapter
-
-
-BOT_HOOK_PARAMS = [DependParam, BotParam, DefaultParam]
-
-
-class Driver(abc.ABC):
-    """Driver 基类。
-
-    参数:
-        env: 包含环境信息的 Env 对象
-        config: 包含配置信息的 Config 对象
-    """
-
-    _adapters: Dict[str, "Adapter"] = {}
-    """已注册的适配器列表"""
-    _bot_connection_hook: Set[Dependent[Any]] = set()
-    """Bot 连接建立时执行的函数"""
-    _bot_disconnection_hook: Set[Dependent[Any]] = set()
-    """Bot 连接断开时执行的函数"""
-
-    def __init__(self, env: Env, config: Config):
-        self.env: str = env.environment
-        """环境名称"""
-        self.config: Config = config
-        """全局配置对象"""
-        self._clients: Dict[str, "Bot"] = {}
-
-    @property
-    def bots(self) -> Dict[str, "Bot"]:
-        """获取当前所有已连接的 Bot"""
-        return self._clients
-
-    def register_adapter(self, adapter: Type["Adapter"], **kwargs) -> None:
-        """注册一个协议适配器
-
-        参数:
-            adapter: 适配器类
-            kwargs: 其他传递给适配器的参数
-        """
-        name = adapter.get_name()
-        if name in self._adapters:
-            logger.opt(colors=True).debug(
-                f'Adapter "<y>{escape_tag(name)}</y>" already exists'
-            )
-            return
-        self._adapters[name] = adapter(self, **kwargs)
-        logger.opt(colors=True).debug(
-            f'Succeeded to load adapter "<y>{escape_tag(name)}</y>"'
-        )
-
-    @property
-    @abc.abstractmethod
-    def type(self) -> str:
-        """驱动类型名称"""
-        raise NotImplementedError
-
-    @property
-    @abc.abstractmethod
-    def logger(self):
-        """驱动专属 logger 日志记录器"""
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def run(self, *args, **kwargs):
-        """
-        启动驱动框架
-        """
-        logger.opt(colors=True).debug(
-            f"<g>Loaded adapters: {escape_tag(', '.join(self._adapters))}</g>"
-        )
-
-    @abc.abstractmethod
-    def on_startup(self, func: Callable) -> Callable:
-        """注册一个在驱动器启动时执行的函数"""
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def on_shutdown(self, func: Callable) -> Callable:
-        """注册一个在驱动器停止时执行的函数"""
-        raise NotImplementedError
-
-    @classmethod
-    def on_bot_connect(cls, func: T_BotConnectionHook) -> T_BotConnectionHook:
-        """装饰一个函数使他在 bot 连接成功时执行。
-
-        钩子函数参数:
-
-        - bot: 当前连接上的 Bot 对象
-        """
-        cls._bot_connection_hook.add(
-            Dependent[Any].parse(call=func, allow_types=BOT_HOOK_PARAMS)
-        )
-        return func
-
-    @classmethod
-    def on_bot_disconnect(cls, func: T_BotDisconnectionHook) -> T_BotDisconnectionHook:
-        """装饰一个函数使他在 bot 连接断开时执行。
-
-        钩子函数参数:
-
-        - bot: 当前连接上的 Bot 对象
-        """
-        cls._bot_disconnection_hook.add(
-            Dependent[Any].parse(call=func, allow_types=BOT_HOOK_PARAMS)
-        )
-        return func
-
-    def _bot_connect(self, bot: "Bot") -> None:
-        """在连接成功后，调用该函数来注册 bot 对象"""
-        if bot.self_id in self._clients:
-            raise RuntimeError(f"Duplicate bot connection with id {bot.self_id}")
-        self._clients[bot.self_id] = bot
-
-        async def _run_hook(bot: "Bot") -> None:
-            coros = list(
-                map(
-                    lambda x: run_coro_with_catch(x(bot=bot), (SkippedException,)),
-                    self._bot_connection_hook,
-                )
-            )
-            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>"
-                    )
-
-        asyncio.create_task(_run_hook(bot))
-
-    def _bot_disconnect(self, bot: "Bot") -> None:
-        """在连接断开后，调用该函数来注销 bot 对象"""
-        if bot.self_id in self._clients:
-            del self._clients[bot.self_id]
-
-        async def _run_hook(bot: "Bot") -> None:
-            coros = list(
-                map(
-                    lambda x: run_coro_with_catch(x(bot=bot), (SkippedException,)),
-                    self._bot_disconnection_hook,
-                )
-            )
-            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>"
-                    )
-
-        asyncio.create_task(_run_hook(bot))
-
-
-class ForwardMixin(abc.ABC):
-    """客户端混入基类。"""
-
-    @property
-    @abc.abstractmethod
-    def type(self) -> str:
-        """客户端驱动类型名称"""
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    async def request(self, setup: Request) -> Response:
-        """发送一个 HTTP 请求"""
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    @asynccontextmanager
-    async def websocket(self, setup: Request) -> AsyncGenerator[WebSocket, None]:
-        """发起一个 WebSocket 连接"""
-        raise NotImplementedError
-        yield  # used for static type checking's generator detection
-
-
-class ForwardDriver(Driver, ForwardMixin):
-    """客户端基类。将客户端框架封装，以满足适配器使用。"""
-
-
-class ReverseDriver(Driver):
-    """服务端基类。将后端框架封装，以满足适配器使用。"""
-
-    @property
-    @abc.abstractmethod
-    def server_app(self) -> Any:
-        """驱动 APP 对象"""
-        raise NotImplementedError
-
-    @property
-    @abc.abstractmethod
-    def asgi(self) -> Any:
-        """驱动 ASGI 对象"""
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def setup_http_server(self, setup: "HTTPServerSetup") -> None:
-        """设置一个 HTTP 服务器路由配置"""
-        raise NotImplementedError
-
-    @abc.abstractmethod
-    def setup_websocket_server(self, setup: "WebSocketServerSetup") -> None:
-        """设置一个 WebSocket 服务器路由配置"""
-        raise NotImplementedError
-
-
-def combine_driver(driver: Type[Driver], *mixins: Type[ForwardMixin]) -> Type[Driver]:
-    """将一个驱动器和多个混入类合并。"""
-    # check first
-    assert issubclass(driver, Driver), "`driver` must be subclass of Driver"
-    assert all(
-        map(lambda m: issubclass(m, ForwardMixin), mixins)
-    ), "`mixins` must be subclass of ForwardMixin"
-
-    if not mixins:
-        return driver
-
-    class CombinedDriver(*mixins, driver, ForwardDriver):  # type: ignore
-        @property
-        def type(self) -> str:
-            return (
-                driver.type.__get__(self)
-                + "+"
-                + "+".join(map(lambda x: x.type.__get__(self), mixins))
-            )
-
-    return CombinedDriver

nonebot/internal/driver/model.py

@@ -1,55 +1,47 @@
 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,
-    Any,
-    Dict,
-    List,
-    Tuple,
-    Union,
-    Mapping,
-    Callable,
-    Iterator,
-    Optional,
-    Awaitable,
-    MutableMapping,
-)
+from typing import IO, Any, Union, Callable, Optional
+from collections.abc import Mapping, Iterator, Awaitable, MutableMapping
 
 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]
-QueryVariable = Union[SimpleQuery, List[SimpleQuery]]
-QueryTypes = Union[
-    None, str, Mapping[str, QueryVariable], List[Tuple[str, QueryVariable]]
+SimpleQuery: TypeAlias = Union[str, int, float]
+QueryVariable: TypeAlias = Union[SimpleQuery, list[SimpleQuery]]
+QueryTypes: TypeAlias = Union[
+    None, str, Mapping[str, QueryVariable], list[tuple[str, SimpleQuery]]
 ]
 
-HeaderTypes = Union[
+HeaderTypes: TypeAlias = Union[
     None,
     CIMultiDict[str],
-    Dict[str, str],
-    List[Tuple[str, 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]
-DataTypes = Union[dict, None]
-FileContent = Union[IO[bytes], bytes]
-FileType = Tuple[Optional[str], FileContent, Optional[str]]
-FileTypes = Union[
+ContentTypes: TypeAlias = Union[str, bytes, None]
+DataTypes: TypeAlias = Union[dict, None]
+FileContent: TypeAlias = Union[IO[bytes], bytes]
+FileType: TypeAlias = tuple[Optional[str], FileContent, Optional[str]]
+FileTypes: TypeAlias = Union[
     # file (or bytes)
     FileContent,
     # (filename, file (or bytes))
-    Tuple[Optional[str], FileContent],
+    tuple[Optional[str], FileContent],
     # (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 +97,9 @@ class Request:
         self.url: URL = url
 
         # headers
-        self.headers: CIMultiDict[str]
-        if headers is not None:
-            self.headers = CIMultiDict(headers)
-        else:
-            self.headers = CIMultiDict()
-
+        self.headers: CIMultiDict[str] = (
+            CIMultiDict(headers) if headers is not None else CIMultiDict()
+        )
         # cookies
         self.cookies = Cookies(cookies)
 
@@ -118,22 +107,20 @@ class Request:
         self.content: ContentTypes = content
         self.data: DataTypes = data
         self.json: Any = json
-        self.files: Optional[List[Tuple[str, FileType]]] = None
+        self.files: Optional[list[tuple[str, FileType]]] = None
         if files:
             self.files = []
             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__
-        url = str(self.url)
-        return f"<{class_name}({self.method!r}, {url!r})>"
+        return f"{self.__class__.__name__}(method={self.method!r}, url='{self.url!s}')"
 
 
 class Response:
@@ -149,30 +136,30 @@ class Response:
         self.status_code: int = status_code
 
         # headers
-        self.headers: CIMultiDict[str]
-        if headers is not None:
-            self.headers = CIMultiDict(headers)
-        else:
-            self.headers = CIMultiDict()
-
+        self.headers: CIMultiDict[str] = (
+            CIMultiDict(headers) if headers is not None else CIMultiDict()
+        )
         # body
         self.content: ContentTypes = content
 
         # request
         self.request: Optional[Request] = request
 
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(status_code={self.status_code!r})"
+
 
 class WebSocket(abc.ABC):
     def __init__(self, *, request: Request):
-        # request
         self.request: Request = request
 
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}('{self.request.url!s}')"
+
     @property
     @abc.abstractmethod
     def closed(self) -> bool:
-        """
-        连接是否已经关闭
-        """
+        """连接是否已经关闭"""
         raise NotImplementedError
 
     @abc.abstractmethod
@@ -258,7 +245,7 @@ class Cookies(MutableMapping):
         )
         self.jar.set_cookie(cookie)
 
-    def get(
+    def get(  # pyright: ignore[reportIncompatibleMethodOverride]
         self,
         name: str,
         default: Optional[str] = None,
@@ -299,11 +286,18 @@ class Cookies(MutableMapping):
     def clear(self, domain: Optional[str] = None, path: Optional[str] = None) -> None:
         self.jar.clear(domain, path)
 
-    def update(self, cookies: CookieTypes = None) -> None:
+    def update(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, cookies: CookieTypes = None
+    ) -> None:
         cookies = Cookies(cookies)
         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 +314,30 @@ class Cookies(MutableMapping):
         return len(self.jar)
 
     def __iter__(self) -> Iterator[Cookie]:
-        return (cookie for cookie in self.jar)
+        return iter(self.jar)
 
     def __repr__(self) -> str:
         cookies_repr = ", ".join(
-            [
-                f"<Cookie {cookie.name}={cookie.value} for {cookie.domain} />"
-                for cookie in self.jar
-            ]
+            f"Cookie({cookie.name}={cookie.value} for {cookie.domain})"
+            for cookie in self.jar
         )
+        return f"{self.__class__.__name__}({cookies_repr})"
 
-        return f"<Cookies [{cookies_repr}]>"
+    class _CookieCompatRequest(urllib.request.Request):
+        def __init__(self, request: Request) -> None:
+            super().__init__(
+                url=str(request.url),
+                headers=dict(request.headers),
+                method=request.method,
+            )
+            self.request = request
+            self.added_headers: dict[str, str] = {}
+
+        def add_unredirected_header(  # pyright: ignore[reportIncompatibleMethodOverride]
+            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,92 @@
+from typing import TYPE_CHECKING, Union, TypeVar, Optional, overload
+from collections.abc import Iterator, KeysView, ItemsView, ValuesView, MutableMapping
+
+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(  # pyright: ignore[reportIncompatibleMethodOverride]
+        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(  # pyright: ignore[reportIncompatibleMethodOverride]
+        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,46 @@
+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 contextlib import AsyncExitStack
-from typing import (
+from typing_extensions import Self
+from collections.abc import Iterable
+from datetime import datetime, timedelta
+from contextlib import AsyncExitStack, contextmanager
+from typing import (  # noqa: UP035
     TYPE_CHECKING,
     Any,
-    Dict,
-    List,
     Type,
     Union,
     TypeVar,
     Callable,
+    ClassVar,
     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 +48,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 .rule import Rule
-from .permission import USER, Permission
-from .adapter import Bot, Event, Message, MessageSegment, MessageTemplate
-from .params import (
+from nonebot.internal.params import (
     Depends,
     ArgParam,
     BotParam,
@@ -56,83 +66,104 @@ 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_id: 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_id is not None:
+            return get_plugin(self.plugin_id)
+
+    @property
+    def plugin_name(self) -> Optional[str]:
+        """事件响应器所在插件名"""
+        return self.plugin and 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
-        permission: Permission
-        handlers: List[T_Handler]
-        priority: int
-        block: bool
-        temp: bool
-        expire_time: Optional[datetime]
+        _source: Optional[MatcherSource]
+        module_name: Optional[str]
 
     def __repr__(self) -> str:
         return (
-            f"<Matcher from {self.module_name or 'unknown'}, "
-            f"type={self.type}, priority={self.priority}, "
-            f"temp={self.temp}>"
+            f"{self.__name__}(type={self.type!r}"
+            + (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)
-
 
 class Matcher(metaclass=MatcherMeta):
     """事件响应器类"""
 
-    plugin: Optional["Plugin"] = None
-    """事件响应器所在插件"""
-    module: Optional[ModuleType] = None
-    """事件响应器所在插件模块"""
-    plugin_name: Optional[str] = None
-    """事件响应器所在插件名"""
-    module_name: Optional[str] = None
-    """事件响应器所在点分割插件模块路径"""
+    _source: ClassVar[Optional[MatcherSource]] = None
 
-    type: str = ""
+    type: ClassVar[str] = ""
     """事件响应器类型"""
-    rule: Rule = Rule()
+    rule: ClassVar[Rule] = Rule()
     """事件响应器匹配规则"""
-    permission: Permission = Permission()
+    permission: ClassVar[Permission] = Permission()
     """事件响应器触发权限"""
-    handlers: List[Dependent[Any]] = []
+    handlers: ClassVar[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], ...]] = (  # noqa: UP006
         DependParam,
         BotParam,
         EventParam,
@@ -140,41 +171,45 @@ class Matcher(metaclass=MatcherMeta):
         ArgParam,
         MatcherParam,
         DefaultParam,
-    ]
+    )
 
     def __init__(self):
-        self.handlers = self.handlers.copy()
+        self.remain_handlers: list[Dependent[Any]] = self.handlers.copy()
         self.state = self._default_state.copy()
 
     def __repr__(self) -> str:
         return (
-            f"<Matcher from {self.module_name or 'unknown'}, type={self.type}, "
-            f"priority={self.priority}, temp={self.temp}>"
+            f"{self.__class__.__name__}(type={self.type!r}"
+            + (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,
         type_: str = "",
         rule: Optional[Rule] = None,
         permission: Optional[Permission] = None,
-        handlers: Optional[List[Union[T_Handler, Dependent[Any]]]] = None,
+        handlers: Optional[list[Union[T_Handler, Dependent[Any]]]] = None,
         temp: bool = False,
         priority: int = 1,
         block: bool = False,
         *,
         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]:  # noqa: UP006
         """
         创建一个新的事件响应器，并存储至 `matchers <#matchers>`_
 
@@ -186,55 +221,96 @@ class Matcher(metaclass=MatcherMeta):
             temp: 是否为临时事件响应器，即触发一次后删除
             priority: 响应优先级
             block: 是否阻止事件向更低优先级的响应器传播
-            plugin: 事件响应器所在插件
-            module: 事件响应器所在模块
-            default_state: 默认状态 `state`
+            plugin: **Deprecated.** 事件响应器所在插件
+            module: **Deprecated.** 事件响应器所在模块
+            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_id=plugin and plugin.id_,
+                module_name=module and module.__name__,
+            )
+            if plugin is not None or module is not None
+            else None
+        )
+
         NewMatcher = type(
-            "Matcher",
-            (Matcher,),
+            cls.__name__,
+            (cls,),
             {
-                "plugin": plugin,
-                "module": module,
-                "plugin_name": plugin and plugin.name,
-                "module_name": module and module.__name__,
+                "_source": source,
                 "type": type_,
                 "rule": rule or Rule(),
                 "permission": permission or Permission(),
-                "handlers": [
-                    handler
-                    if isinstance(handler, Dependent)
-                    else Dependent[Any].parse(
-                        call=handler, allow_types=cls.HANDLER_PARAM_TYPES
-                    )
-                    for handler in handlers
-                ]
-                if handlers
-                else [],
+                "handlers": (
+                    [
+                        (
+                            handler
+                            if isinstance(handler, Dependent)
+                            else Dependent[Any].parse(
+                                call=handler, allow_types=cls.HANDLER_PARAM_TYPES
+                            )
+                        )
+                        for handler in handlers
+                    ]
+                    if handlers
+                    else []
+                ),
                 "temp": temp,
-                "expire_time": expire_time,
+                "expire_time": (
+                    expire_time
+                    and (
+                        expire_time
+                        if isinstance(expire_time, datetime)
+                        else datetime.now() + expire_time
+                    )
+                ),
                 "priority": priority,
                 "block": block,
                 "_default_state": default_state or {},
                 "_default_type_updater": (
                     default_type_updater
-                    if isinstance(default_type_updater, Dependent)
-                    else default_type_updater
-                    and Dependent[str].parse(
-                        call=default_type_updater, allow_types=cls.HANDLER_PARAM_TYPES
+                    and (
+                        default_type_updater
+                        if isinstance(default_type_updater, Dependent)
+                        else Dependent[str].parse(
+                            call=default_type_updater,
+                            allow_types=cls.HANDLER_PARAM_TYPES,
+                        )
                     )
                 ),
                 "_default_permission_updater": (
                     default_permission_updater
-                    if isinstance(default_permission_updater, Dependent)
-                    else default_permission_updater
-                    and Dependent[Permission].parse(
-                        call=default_permission_updater,
-                        allow_types=cls.HANDLER_PARAM_TYPES,
+                    and (
+                        default_permission_updater
+                        if isinstance(default_permission_updater, Dependent)
+                        else Dependent[Permission].parse(
+                            call=default_permission_updater,
+                            allow_types=cls.HANDLER_PARAM_TYPES,
+                        )
                     )
                 ),
             },
@@ -244,7 +320,37 @@ class Matcher(metaclass=MatcherMeta):
 
         matchers[priority].append(NewMatcher)
 
-        return NewMatcher
+        return NewMatcher  # type: ignore
+
+    @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 plugin_id(cls) -> Optional[str]:
+        """事件响应器所在插件标识符"""
+        return cls._source and cls._source.plugin_id
+
+    @classproperty
+    def plugin_name(cls) -> Optional[str]:
+        """事件响应器所在插件名"""
+        return cls._source and cls._source.plugin_name
+
+    @classproperty
+    def module(cls) -> Optional[ModuleType]:
+        """事件响应器所在插件模块"""
+        return cls._source and cls._source.module
+
+    @classproperty
+    def module_name(cls) -> Optional[str]:
+        """事件响应器所在插件模块路径"""
+        return cls._source and cls._source.module_name
 
     @classmethod
     async def check_perm(
@@ -322,7 +428,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 +440,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 +456,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 在接收用户新的一条消息后继续运行该函数
 
@@ -359,7 +465,7 @@ class Matcher(metaclass=MatcherMeta):
             parameterless: 非参数类型依赖列表
         """
 
-        async def _receive(event: Event, matcher: "Matcher") -> Union[None, NoReturn]:
+        async def _receive(event: Event, matcher: "Matcher") -> None:
             matcher.set_target(RECEIVE_KEY.format(id=id))
             if matcher.get_target() == RECEIVE_KEY.format(id=id):
                 matcher.set_receive(id, event)
@@ -368,14 +474,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):
-                    func_handler.prepend_parameterless(depend)
+                new_handler = Dependent(
+                    call=func_handler.call,
+                    params=func_handler.params,
+                    parameterless=Dependent.parse_parameterless(
+                        tuple(_parameterless), cls.HANDLER_PARAM_TYPES
+                    )
+                    + func_handler.parameterless,
+                )
+                cls.handlers[-1] = new_handler
             else:
                 cls.append_handler(func, parameterless=_parameterless)
 
@@ -388,11 +500,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 +522,20 @@ class Matcher(metaclass=MatcherMeta):
                 return
             await matcher.reject(prompt)
 
-        _parameterless = [
-            Depends(_key_getter),
-            *(parameterless or []),
-        ]
+        _parameterless = (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):
-                    func_handler.prepend_parameterless(depend)
+                new_handler = Dependent(
+                    call=func_handler.call,
+                    params=func_handler.params,
+                    parameterless=Dependent.parse_parameterless(
+                        tuple(_parameterless), cls.HANDLER_PARAM_TYPES
+                    )
+                    + func_handler.parameterless,
+                )
+                cls.handlers[-1] = new_handler
             else:
                 cls.append_handler(func, parameterless=_parameterless)
 
@@ -437,7 +553,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 +575,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 +592,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 +610,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 +630,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 +652,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 +669,15 @@ 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 +689,30 @@ 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,31 +729,76 @@ 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 "message"
-        return await updater(bot=bot, event=event, state=self.state, matcher=self)
+        return (
+            await updater(
+                bot=bot,
+                event=event,
+                state=self.state,
+                matcher=self,
+                stack=stack,
+                dependency_cache=dependency_cache,
+            )
+            if updater
+            else "message"
+        )
 
-    async def update_permission(self, bot: Bot, event: Event) -> Permission:
-        updater = self.__class__._default_permission_updater
-        if not updater:
-            return USER(event.get_session_id(), perm=self.permission)
-        return await updater(bot=bot, event=event, state=self.state, matcher=self)
+    async def update_permission(
+        self,
+        bot: Bot,
+        event: Event,
+        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()
-        self.handlers.insert(0, handler)
+        self.remain_handlers.insert(0, handler)
         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 +808,34 @@ class Matcher(metaclass=MatcherMeta):
         dependency_cache: Optional[T_DependencyCache] = None,
     ):
         logger.trace(
-            f"Matcher {self} run with incoming args: "
-            f"bot={bot}, event={event}, state={state}"
+            f"{self} run with incoming args: "
+            f"bot={bot}, event={event!r}, state={state!r}"
         )
-        b_t = current_bot.set(bot)
-        e_t = current_event.set(event)
-        m_t = current_matcher.set(self)
-        try:
-            # Refresh preprocess state
-            self.state.update(state)
 
-            while self.handlers:
-                handler = self.handlers.pop(0)
-                current_handler.set(handler)
-                logger.debug(f"Running handler {handler}")
-                try:
-                    await handler(
-                        matcher=self,
-                        bot=bot,
-                        event=event,
-                        state=self.state,
-                        stack=stack,
-                        dependency_cache=dependency_cache,
-                    )
-                except TypeMisMatch as e:
-                    logger.debug(
-                        f"Handler {handler} param {e.param.name} value {e.value} "
-                        f"mismatch type {e.param._type_display()}, skipped"
-                    )
-                except SkippedException as e:
-                    logger.debug(f"Handler {handler} skipped")
-        except StopPropagation:
-            self.block = True
-        finally:
-            logger.info(f"Matcher {self} running complete")
-            current_bot.reset(b_t)
-            current_event.reset(e_t)
-            current_matcher.reset(m_t)
+        with self.ensure_context(bot, event):
+            try:
+                # Refresh preprocess state
+                self.state.update(state)
+
+                while self.remain_handlers:
+                    handler = self.remain_handlers.pop(0)
+                    current_handler.set(handler)
+                    logger.debug(f"Running handler {handler}")
+                    try:
+                        await handler(
+                            matcher=self,
+                            bot=bot,
+                            event=event,
+                            state=self.state,
+                            stack=stack,
+                            dependency_cache=dependency_cache,
+                        )
+                    except SkippedException:
+                        logger.debug(f"Handler {handler} skipped")
+            except StopPropagation:
+                self.block = True
+            finally:
+                logger.info(f"{self} running complete")
 
     # 运行handlers
     async def run(
@@ -669,53 +851,44 @@ class Matcher(metaclass=MatcherMeta):
 
         except RejectedException:
             await self.resolve_reject()
-            type_ = await self.update_type(bot, event)
-            permission = await self.update_permission(bot, event)
+            type_ = await self.update_type(bot, event, stack, dependency_cache)
+            permission = await self.update_permission(
+                bot, event, stack, dependency_cache
+            )
 
-            Matcher.new(
+            self.new(
                 type_,
                 Rule(),
                 permission,
-                self.handlers,
+                self.remain_handlers,
                 temp=True,
                 priority=0,
                 block=True,
-                plugin=self.plugin,
-                module=self.module,
-                expire_time=datetime.now() + bot.config.session_expire_timeout,
+                source=self.__class__._source,
+                expire_time=bot.config.session_expire_timeout,
                 default_state=self.state,
                 default_type_updater=self.__class__._default_type_updater,
                 default_permission_updater=self.__class__._default_permission_updater,
             )
         except PausedException:
-            type_ = await self.update_type(bot, event)
-            permission = await self.update_permission(bot, event)
+            type_ = await self.update_type(bot, event, stack, dependency_cache)
+            permission = await self.update_permission(
+                bot, event, stack, dependency_cache
+            )
 
-            Matcher.new(
+            self.new(
                 type_,
                 Rule(),
                 permission,
-                self.handlers,
+                self.remain_handlers,
                 temp=True,
                 priority=0,
                 block=True,
-                plugin=self.plugin,
-                module=self.module,
-                expire_time=datetime.now() + bot.config.session_expire_timeout,
+                source=self.__class__._source,
+                expire_time=bot.config.session_expire_timeout,
                 default_state=self.state,
                 default_type_updater=self.__class__._default_type_updater,
                 default_permission_updater=self.__class__._default_permission_updater,
             )
         except FinishedException:
             pass
-
-
-__autodoc__ = {
-    "MatcherMeta": False,
-    "Matcher.get_target": False,
-    "Matcher.set_target": False,
-    "Matcher.update_type": False,
-    "Matcher.update_permission": False,
-    "Matcher.resolve_reject": False,
-    "Matcher.simple_run": False,
-}

nonebot/internal/matcher/provider.py

@@ -0,0 +1,28 @@
+import abc
+from typing import TYPE_CHECKING
+from collections import defaultdict
+from collections.abc import 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,17 +1,24 @@
 import asyncio
 import inspect
-import warnings
-from typing_extensions import Literal
-from typing import TYPE_CHECKING, Any, Callable, Optional, cast
+from typing_extensions import Self, get_args, override, get_origin
 from contextlib import AsyncExitStack, contextmanager, asynccontextmanager
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Union,
+    Literal,
+    Callable,
+    Optional,
+    Annotated,
+    cast,
+)
 
-from pydantic.fields import Required, Undefined, ModelField
+from pydantic.fields import FieldInfo as PydanticFieldInfo
 
-from nonebot.log import logger
-from nonebot.exception import TypeMisMatch
+from nonebot.dependencies import Param, Dependent
 from nonebot.dependencies.utils import check_field_type
-from nonebot.dependencies import Param, Dependent, CustomConfig
 from nonebot.typing import T_State, T_Handler, T_DependencyCache
+from nonebot.compat import FieldInfo, ModelField, PydanticUndefined, extract_field_info
 from nonebot.utils import (
     get_name,
     run_sync,
@@ -33,26 +40,31 @@ class DependsInner:
         dependency: Optional[T_Handler] = None,
         *,
         use_cache: bool = True,
+        validate: Union[bool, PydanticFieldInfo] = 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, PydanticFieldInfo] = False,
 ) -> Any:
     """子依赖装饰器
 
     参数:
         dependency: 依赖函数。默认为参数的类型注释。
         use_cache: 是否使用缓存。默认为 `True`。
+        validate: 是否使用 Pydantic 类型校验。默认为 `False`。
 
     用法:
         ```python
@@ -65,63 +77,115 @@ 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 __init__(
+        self, *args, dependent: Dependent, use_cache: bool, **kwargs: Any
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.dependent = dependent
+        self.use_cache = use_cache
+
+    def __repr__(self) -> str:
+        return f"Depends({self.dependent}, use_cache={self.use_cache})"
 
     @classmethod
-    def _check_param(
+    def _from_field(
         cls,
-        dependent: Dependent,
-        name: str,
-        param: inspect.Parameter,
-    ) -> Optional["DependParam"]:
-        if isinstance(param.default, DependsInner):
-            dependency: T_Handler
-            if param.default.dependency is 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
-            )
+        sub_dependent: Dependent,
+        use_cache: bool,
+        validate: Union[bool, PydanticFieldInfo],
+    ) -> Self:
+        kwargs = {}
+        if isinstance(validate, PydanticFieldInfo):
+            kwargs.update(extract_field_info(validate))
+
+        kwargs["validate"] = bool(validate)
+        kwargs["dependent"] = sub_dependent
+        kwargs["use_cache"] = use_cache
+
+        return cls(**kwargs)
 
     @classmethod
+    @override
+    def _check_param(
+        cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]
+    ) -> Optional[Self]:
+        type_annotation, depends_inner = param.annotation, None
+        # extract type annotation and dependency from Annotated
+        if get_origin(param.annotation) is Annotated:
+            type_annotation, *extra_args = get_args(param.annotation)
+            depends_inner = next(
+                (x for x in reversed(extra_args) if isinstance(x, DependsInner)), None
+            )
+
+        # 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,
         dependency_cache: Optional[T_DependencyCache] = None,
         **kwargs: Any,
     ) -> Any:
-        use_cache: bool = self.extra["use_cache"]
+        use_cache: bool = self.use_cache
         dependency_cache = {} if dependency_cache is None else dependency_cache
 
-        sub_dependent: Dependent = self.extra["dependent"]
-        sub_dependent.call = cast(Callable[..., Any], sub_dependent.call)
-        call = sub_dependent.call
+        sub_dependent: Dependent = self.dependent
+        call = cast(Callable[..., Any], sub_dependent.call)
 
         # solve sub dependency with current cache
         sub_values = await sub_dependent.solve(
@@ -133,7 +197,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,231 +208,339 @@ class DependParam(Param):
                 cm = asynccontextmanager(call)(**sub_values)
             task = asyncio.create_task(stack.enter_async_context(cm))
             dependency_cache[call] = task
-            solved = await task
+            return await task
         elif is_coroutine_callable(call):
             task = asyncio.create_task(call(**sub_values))
             dependency_cache[call] = task
-            solved = await task
+            return await task
         else:
             task = asyncio.create_task(run_sync(call)(**sub_values))
             dependency_cache[call] = task
-            solved = await task
+            return await task
 
-        return solved
-
-
-class _BotChecker(Param):
-    async def _solve(self, bot: "Bot", **kwargs: Any) -> Any:
-        field: ModelField = self.extra["field"]
-        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
+    @override
+    async def _check(self, **kwargs: Any) -> None:
+        # run sub dependent pre-checkers
+        await self.dependent.check(**kwargs)
 
 
 class BotParam(Param):
-    """{ref}`nonebot.adapters.Bot` 参数"""
+    """{ref}`nonebot.adapters.Bot` 注入参数。
+
+    本注入解析所有类型为且仅为 {ref}`nonebot.adapters.Bot` 及其子类或 `None` 的参数。
+
+    为保证兼容性，本注入还会解析名为 `bot` 且没有类型注解的参数。
+    """
+
+    def __init__(
+        self, *args, checker: Optional[ModelField] = None, **kwargs: Any
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.checker = checker
+
+    def __repr__(self) -> str:
+        return (
+            "BotParam("
+            + (repr(self.checker.annotation) if self.checker is not None else "")
+            + ")"
+        )
 
     @classmethod
+    @override
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
-    ) -> Optional["BotParam"]:
+        cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]
+    ) -> Optional[Self]:
         from nonebot.adapters import Bot
 
-        if param.default == param.empty:
-            if generic_check_issubclass(param.annotation, Bot):
-                if param.annotation is not Bot:
-                    dependent.pre_checkers.append(
-                        _BotChecker(
-                            Required,
-                            field=ModelField(
-                                name=name,
-                                type_=param.annotation,
-                                class_validators=None,
-                                model_config=CustomConfig,
-                                default=None,
-                                required=True,
-                            ),
-                        )
-                    )
-                return cls(Required)
-            elif param.annotation == param.empty and name == "bot":
-                return cls(Required)
+        # param type is Bot(s) or subclass(es) of Bot or None
+        if generic_check_issubclass(param.annotation, Bot):
+            checker: Optional[ModelField] = None
+            if param.annotation is not Bot:
+                checker = ModelField.construct(
+                    name=param.name, annotation=param.annotation, field_info=FieldInfo()
+                )
+            return cls(checker=checker)
+        # legacy: param is named "bot" and has no type annotation
+        elif param.annotation == param.empty and param.name == "bot":
+            return cls()
 
-    async def _solve(self, bot: "Bot", **kwargs: Any) -> Any:
+    @override
+    async def _solve(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, bot: "Bot", **kwargs: Any
+    ) -> Any:
         return bot
 
-
-class _EventChecker(Param):
-    async def _solve(self, event: "Event", **kwargs: Any) -> Any:
-        field: ModelField = self.extra["field"]
-        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
+    @override
+    async def _check(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, bot: "Bot", **kwargs: Any
+    ) -> None:
+        if self.checker is not None:
+            check_field_type(self.checker, bot)
 
 
 class EventParam(Param):
-    """{ref}`nonebot.adapters.Event` 参数"""
+    """{ref}`nonebot.adapters.Event` 注入参数
+
+    本注入解析所有类型为且仅为 {ref}`nonebot.adapters.Event` 及其子类或 `None` 的参数。
+
+    为保证兼容性，本注入还会解析名为 `event` 且没有类型注解的参数。
+    """
+
+    def __init__(
+        self, *args, checker: Optional[ModelField] = None, **kwargs: Any
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.checker = checker
+
+    def __repr__(self) -> str:
+        return (
+            "EventParam("
+            + (repr(self.checker.annotation) if self.checker is not None else "")
+            + ")"
+        )
 
     @classmethod
+    @override
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
-    ) -> Optional["EventParam"]:
+        cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]
+    ) -> Optional[Self]:
         from nonebot.adapters import Event
 
-        if param.default == param.empty:
-            if generic_check_issubclass(param.annotation, Event):
-                if param.annotation is not Event:
-                    dependent.pre_checkers.append(
-                        _EventChecker(
-                            Required,
-                            field=ModelField(
-                                name=name,
-                                type_=param.annotation,
-                                class_validators=None,
-                                model_config=CustomConfig,
-                                default=None,
-                                required=True,
-                            ),
-                        )
-                    )
-                return cls(Required)
-            elif param.annotation == param.empty and name == "event":
-                return cls(Required)
+        # param type is Event(s) or subclass(es) of Event or None
+        if generic_check_issubclass(param.annotation, Event):
+            checker: Optional[ModelField] = None
+            if param.annotation is not Event:
+                checker = ModelField.construct(
+                    name=param.name, annotation=param.annotation, field_info=FieldInfo()
+                )
+            return cls(checker=checker)
+        # legacy: param is named "event" and has no type annotation
+        elif param.annotation == param.empty and param.name == "event":
+            return cls()
 
-    async def _solve(self, event: "Event", **kwargs: Any) -> Any:
+    @override
+    async def _solve(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, event: "Event", **kwargs: Any
+    ) -> Any:
         return event
 
-
-class StateInner(T_State):
-    ...
-
-
-def State() -> T_State:
-    """**Deprecated**: 事件处理状态参数，请直接使用 {ref}`nonebot.typing.T_State`"""
-    warnings.warn("State() is deprecated, use `T_State` instead", DeprecationWarning)
-    return StateInner()
+    @override
+    async def _check(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, event: "Event", **kwargs: Any
+    ) -> Any:
+        if self.checker is not None:
+            check_field_type(self.checker, event)
 
 
 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
-    ) -> Optional["StateParam"]:
-        if isinstance(param.default, StateInner):
-            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)
+        cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]
+    ) -> Optional[Self]:
+        # param type is T_State
+        if param.annotation is T_State:
+            return cls()
+        # legacy: param is named "state" and has no type annotation
+        elif param.annotation == param.empty and param.name == "state":
+            return cls()
 
-    async def _solve(self, state: T_State, **kwargs: Any) -> Any:
+    @override
+    async def _solve(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, state: T_State, **kwargs: Any
+    ) -> Any:
         return state
 
 
 class MatcherParam(Param):
-    """事件响应器实例参数"""
+    """事件响应器实例注入参数
+
+    本注入解析所有类型为且仅为 {ref}`nonebot.matcher.Matcher` 及其子类或 `None` 的参数。
+
+    为保证兼容性，本注入还会解析名为 `matcher` 且没有类型注解的参数。
+    """
+
+    def __init__(
+        self, *args, checker: Optional[ModelField] = None, **kwargs: Any
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.checker = checker
+
+    def __repr__(self) -> str:
+        return (
+            "MatcherParam("
+            + (repr(self.checker.annotation) if self.checker is not None else "")
+            + ")"
+        )
 
     @classmethod
+    @override
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
-    ) -> Optional["MatcherParam"]:
+        cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]
+    ) -> Optional[Self]:
         from nonebot.matcher import Matcher
 
-        if generic_check_issubclass(param.annotation, Matcher) or (
-            param.annotation == param.empty and name == "matcher"
-        ):
-            return cls(Required)
+        # param type is Matcher(s) or subclass(es) of Matcher or None
+        if generic_check_issubclass(param.annotation, Matcher):
+            checker: Optional[ModelField] = None
+            if param.annotation is not Matcher:
+                checker = ModelField.construct(
+                    name=param.name, annotation=param.annotation, field_info=FieldInfo()
+                )
+            return cls(checker=checker)
+        # legacy: param is named "matcher" and has no type annotation
+        elif param.annotation == param.empty and param.name == "matcher":
+            return cls()
 
-    async def _solve(self, matcher: "Matcher", **kwargs: Any) -> Any:
+    @override
+    async def _solve(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, matcher: "Matcher", **kwargs: Any
+    ) -> Any:
         return matcher
 
+    @override
+    async def _check(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, matcher: "Matcher", **kwargs: Any
+    ) -> Any:
+        if self.checker is not None:
+            check_field_type(self.checker, matcher)
+
 
 class ArgInner:
     def __init__(
         self, key: Optional[str], type: Literal["message", "str", "plaintext"]
     ) -> None:
-        self.key = key
-        self.type = type
+        self.key: Optional[str] = key
+        self.type: Literal["message", "str", "plaintext"] = 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 __init__(
+        self,
+        *args,
+        key: str,
+        type: Literal["message", "str", "plaintext"],
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self.key = key
+        self.type = type
+
+    def __repr__(self) -> str:
+        return f"ArgParam(key={self.key!r}, type={self.type!r})"
 
     @classmethod
+    @override
     def _check_param(
-        cls, dependent: Dependent, name: str, param: inspect.Parameter
-    ) -> Optional["ArgParam"]:
+        cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]
+    ) -> Optional[Self]:
         if isinstance(param.default, ArgInner):
-            return cls(Required, key=param.default.key or name, type=param.default.type)
+            return cls(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)[:0:-1]:
+                if isinstance(arg, ArgInner):
+                    return cls(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"])
+    async def _solve(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, matcher: "Matcher", **kwargs: Any
+    ) -> Any:
+        message = matcher.get_arg(self.key)
         if message is None:
             return message
-        if self.extra["type"] == "message":
+        if self.type == "message":
             return message
-        elif self.extra["type"] == "str":
+        elif self.type == "str":
             return str(message)
         else:
             return message.extract_plain_text()
 
 
 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
-    ) -> Optional["ExceptionParam"]:
-        if generic_check_issubclass(param.annotation, Exception) or (
-            param.annotation == param.empty and name == "exception"
-        ):
-            return cls(Required)
+        cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]
+    ) -> Optional[Self]:
+        # param type is Exception(s) or subclass(es) of Exception or None
+        if generic_check_issubclass(param.annotation, Exception):
+            return cls()
+        # legacy: param is named "exception" and has no type annotation
+        elif param.annotation == param.empty and param.name == "exception":
+            return cls()
 
+    @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
-    ) -> Optional["DefaultParam"]:
+        cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]
+    ) -> Optional[Self]:
         if param.default != param.empty:
-            return cls(param.default)
+            return cls(default=param.default)
 
+    @override
     async def _solve(self, **kwargs: Any) -> Any:
-        return Undefined
+        return PydanticUndefined
 
 
 __autodoc__ = {

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 Union, ClassVar, NoReturn, Optional
 
 from nonebot.dependencies import Dependent
 from nonebot.utils import run_coro_with_catch
@@ -8,7 +9,7 @@ from nonebot.exception import SkippedException
 from nonebot.typing import T_DependencyCache, T_PermissionChecker
 
 from .adapter import Bot, Event
-from .params import BotParam, EventParam, DependParam, DefaultParam
+from .params import Param, BotParam, EventParam, DependParam, DefaultParam
 
 
 class Permission:
@@ -29,7 +30,7 @@ class Permission:
 
     __slots__ = ("checkers",)
 
-    HANDLER_PARAM_TYPES = [
+    HANDLER_PARAM_TYPES: ClassVar[list[type[Param]]] = [
         DependParam,
         BotParam,
         EventParam,
@@ -37,16 +38,21 @@ class Permission:
     ]
 
     def __init__(self, *checkers: Union[T_PermissionChecker, Dependent[bool]]) -> None:
-        self.checkers: Set[Dependent[bool]] = set(
-            checker
-            if isinstance(checker, Dependent)
-            else Dependent[bool].parse(
-                call=checker, allow_types=self.HANDLER_PARAM_TYPES
+        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 +60,7 @@ class Permission:
         stack: Optional[AsyncExitStack] = None,
         dependency_cache: Optional[T_DependencyCache] = None,
     ) -> bool:
-        """检查是否满足某个权限
+        """检查是否满足某个权限。
 
         参数:
             bot: Bot 对象
@@ -106,7 +112,7 @@ class Permission:
 
 
 class User:
-    """检查当前事件是否属于指定会话
+    """检查当前事件是否属于指定会话。
 
     参数:
         users: 会话 ID 元组
@@ -116,24 +122,68 @@ class User:
     __slots__ = ("users", "perm")
 
     def __init__(
-        self, users: Tuple[str, ...], perm: Optional[Permission] = None
+        self, users: tuple[str, ...], perm: Optional[Permission] = None
     ) -> None:
         self.users = users
         self.perm = perm
 
-    async def __call__(self, bot: Bot, event: Event) -> bool:
-        return bool(
-            event.get_session_id() in self.users
-            and (self.perm is None or await self.perm(bot, event))
+    def __repr__(self) -> str:
+        return (
+            f"User(users={self.users}"
+            + (f", permission={self.perm})" if self.perm else "")
+            + ")"
         )
 
+    async def __call__(self, bot: Bot, event: Event) -> bool:
+        try:
+            session = event.get_session_id()
+        except Exception:
+            return False
+        return bool(
+            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 := next(iter(perm.checkers)).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

@@ -1,13 +1,13 @@
 import asyncio
 from contextlib import AsyncExitStack
-from typing import Set, Union, NoReturn, Optional
+from typing import Union, ClassVar, NoReturn, Optional
 
 from nonebot.dependencies import Dependent
 from nonebot.exception import SkippedException
 from nonebot.typing import T_State, T_RuleChecker, T_DependencyCache
 
 from .adapter import Bot, Event
-from .params import BotParam, EventParam, StateParam, DependParam, DefaultParam
+from .params import Param, BotParam, EventParam, StateParam, DependParam, DefaultParam
 
 
 class Rule:
@@ -28,7 +28,7 @@ class Rule:
 
     __slots__ = ("checkers",)
 
-    HANDLER_PARAM_TYPES = [
+    HANDLER_PARAM_TYPES: ClassVar[list[type[Param]]] = [
         DependParam,
         BotParam,
         EventParam,
@@ -37,16 +37,21 @@ class Rule:
     ]
 
     def __init__(self, *checkers: Union[T_RuleChecker, Dependent[bool]]) -> None:
-        self.checkers: Set[Dependent[bool]] = set(
-            checker
-            if isinstance(checker, Dependent)
-            else Dependent[bool].parse(
-                call=checker, allow_types=self.HANDLER_PARAM_TYPES
+        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
@@ -13,17 +13,16 @@ FrontMatter:
 """
 
 import sys
+import inspect
 import logging
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 import loguru
 
 if TYPE_CHECKING:
     # avoid sphinx autodoc resolve annotation failed
     # because loguru module do not have `Logger` class actually
-    from loguru import Logger
-
-    from nonebot.plugin import Plugin
+    from loguru import Logger, Record
 
 # logger = logging.getLogger("nonebot")
 logger: "Logger" = loguru.logger
@@ -47,33 +46,18 @@ 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
-
-
+# https://loguru.readthedocs.io/en/stable/overview.html#entirely-compatible-with-standard-logging
 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
-        while frame and frame.f_code.co_filename == logging.__file__:
+        frame, depth = inspect.currentframe(), 0
+        while frame and (depth == 0 or frame.f_code.co_filename == logging.__file__):
             frame = frame.f_back
             depth += 1
 
@@ -82,9 +66,13 @@ class LoguruHandler(logging.Handler):  # pragma: no cover
         )
 
 
-logger.remove()
-default_filter: Filter = Filter()
-"""默认日志等级过滤器"""
+def default_filter(record: "Record"):
+    """默认的日志过滤器，根据 `config.log_level` 配置改变日志等级。"""
+    log_level = record["extra"].get("nonebot_log_level", "INFO")
+    levelno = logger.level(log_level).no if isinstance(log_level, str) else log_level
+    return record["level"].no >= levelno
+
+
 default_format: str = (
     "<g>{time:MM-DD HH:mm:ss}</g> "
     "[<lvl>{level}</lvl>] "
@@ -93,6 +81,8 @@ default_format: str = (
     "{message}"
 )
 """默认日志格式"""
+
+logger.remove()
 logger_id = logger.add(
     sys.stdout,
     level=0,
@@ -100,5 +90,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, Optional
 
 from nonebot.log import logger
 from nonebot.rule import TrieRule
@@ -45,19 +46,19 @@ from nonebot.internal.params import (
 if TYPE_CHECKING:
     from nonebot.adapters import Bot, Event
 
-_event_preprocessors: Set[Dependent[Any]] = set()
-_event_postprocessors: Set[Dependent[Any]] = set()
-_run_preprocessors: Set[Dependent[Any]] = set()
-_run_postprocessors: Set[Dependent[Any]] = set()
+_event_preprocessors: set[Dependent[Any]] = set()
+_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,131 +113,374 @@ 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 _check_matcher(
-    priority: int,
-    Matcher: Type[Matcher],
+async def _apply_event_preprocessors(
     bot: "Bot",
     event: "Event",
     state: T_State,
     stack: Optional[AsyncExitStack] = None,
     dependency_cache: Optional[T_DependencyCache] = None,
-) -> None:
-    if Matcher.expire_time and datetime.now() > Matcher.expire_time:
-        try:
-            matchers[priority].remove(Matcher)
-        except Exception:
-            pass
-        return
+    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:
-        if not await Matcher.check_perm(
-            bot, event, stack, dependency_cache
-        ) or not await Matcher.check_rule(bot, event, state, stack, dependency_cache):
-            return
+        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(
-            f"<r><bg #f8bbd0>Rule check failed for {Matcher}.</bg #f8bbd0></r>"
+            "<r><bg #f8bbd0>Error when running EventPreProcessors. "
+            "Event ignored!</bg #f8bbd0></r>"
         )
-        return
+        return False
 
-    if Matcher.temp:
-        try:
-            matchers[priority].remove(Matcher)
-        except Exception:
-            pass
-
-    await _run_matcher(Matcher, bot, event, state, stack, dependency_cache)
+    return True
 
 
-async def _run_matcher(
-    Matcher: Type[Matcher],
+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:
-    logger.info(f"Event will be handled by {Matcher}")
+    """运行事件后处理。
 
-    matcher = Matcher()
+    参数:
+        bot: Bot 对象
+        event: Event 对象
+        state: 会话状态
+        stack: 异步上下文栈
+        dependency_cache: 依赖缓存
+        show_log: 是否显示日志
+    """
+    if not _event_postprocessors:
+        return
 
-    coros = list(
-        map(
-            lambda x: run_coro_with_catch(
-                x(
-                    matcher=matcher,
-                    bot=bot,
-                    event=event,
-                    state=state,
-                    stack=stack,
-                    dependency_cache=dependency_cache,
-                ),
-                (SkippedException,),
-            ),
-            _run_preprocessors,
-        )
-    )
-    if coros:
-        try:
-            await asyncio.gather(*coros)
-        except IgnoredException:
-            logger.opt(colors=True).info(
-                f"Matcher {matcher} running is <b>cancelled</b>"
+    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
             )
-            return
+        )
+    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
+            return False
 
-    exception = None
+    return True
 
-    try:
-        logger.debug(f"Running matcher {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>"
-        )
-        exception = e
 
-    coros = list(
-        map(
-            lambda x: run_coro_with_catch(
-                x(
-                    matcher=matcher,
-                    exception=exception,
-                    bot=bot,
-                    event=event,
-                    state=state,
-                    stack=stack,
-                    dependency_cache=dependency_cache,
-                ),
-                (SkippedException,),
-            ),
-            _run_postprocessors,
-        )
-    )
-    if coros:
+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(*coros)
+            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(
+    Matcher: type[Matcher],
+    bot: "Bot",
+    event: "Event",
+    state: T_State,
+    stack: Optional[AsyncExitStack] = None,
+    dependency_cache: Optional[T_DependencyCache] = None,
+) -> bool:
+    """检查事件响应器是否符合运行条件。
+
+    请注意，过时的事件响应器将被**销毁**。对于未过时的事件响应器，将会一次检查其响应类型、权限和规则。
+
+    参数:
+        Matcher: 要检查的事件响应器
+        bot: Bot 对象
+        event: Event 对象
+        state: 会话状态
+        stack: 异步上下文栈
+        dependency_cache: 依赖缓存
+
+    返回:
+        bool: 是否符合运行条件
+    """
+    if Matcher.expire_time and datetime.now() > Matcher.expire_time:
+        with contextlib.suppress(Exception):
+            Matcher.destroy()
+        return False
+
+    try:
+        if not await Matcher.check_perm(bot, event, stack, dependency_cache):
+            logger.trace(f"Permission conditions not met for {Matcher}")
+            return False
+    except Exception as e:
+        logger.opt(colors=True, exception=e).error(
+            f"<r><bg #f8bbd0>Permission check failed for {Matcher}.</bg #f8bbd0></r>"
+        )
+        return False
+
+    try:
+        if not await Matcher.check_rule(bot, event, state, stack, dependency_cache):
+            logger.trace(f"Rule conditions not met for {Matcher}")
+            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 False
+
+    return True
+
+
+async def _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: 依赖缓存
+
+    异常:
+        StopPropagation: 阻止事件继续传播
+    """
+    logger.info(f"Event will be handled by {Matcher}")
+
+    if Matcher.temp:
+        with contextlib.suppress(Exception):
+            Matcher.destroy()
+
+    matcher = Matcher()
+
+    if not await _apply_run_preprocessors(
+        bot=bot,
+        event=event,
+        state=state,
+        matcher=matcher,
+        stack=stack,
+        dependency_cache=dependency_cache,
+    ):
+        return
+
+    exception = None
+
+    try:
+        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} failed.</bg #f8bbd0></r>"
+        )
+        exception = e
+
+    await _apply_run_postprocessors(
+        bot=bot,
+        event=event,
+        matcher=matcher,
+        exception=exception,
+        stack=stack,
+        dependency_cache=dependency_cache,
+    )
+
     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 +497,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:
@@ -252,41 +505,19 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
     if show_log:
         logger.opt(colors=True).success(log_msg)
 
-    state: Dict[Any, Any] = {}
+    state: dict[Any, Any] = {}
     dependency_cache: T_DependencyCache = {}
 
+    # create event scope context
     async with AsyncExitStack() as stack:
-        coros = list(
-            map(
-                lambda x: run_coro_with_catch(
-                    x(
-                        bot=bot,
-                        event=event,
-                        state=state,
-                        stack=stack,
-                        dependency_cache=dependency_cache,
-                    ),
-                    (SkippedException,),
-                ),
-                _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
+        if not await _apply_event_preprocessors(
+            bot=bot,
+            event=event,
+            state=state,
+            stack=stack,
+            dependency_cache=dependency_cache,
+        ):
+            return
 
         # Trie Match
         try:
@@ -297,6 +528,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 +537,12 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
                 logger.debug(f"Checking for matchers in priority {priority}...")
 
             pending_tasks = [
-                _check_matcher(
-                    priority, matcher, bot, event, state.copy(), stack, dependency_cache
+                check_and_run_matcher(
+                    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 +554,7 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
                         "<r><bg #f8bbd0>Error when checking Matcher.</bg #f8bbd0></r>"
                     )
 
-        coros = list(
-            map(
-                lambda x: run_coro_with_catch(
-                    x(
-                        bot=bot,
-                        event=event,
-                        state=state,
-                        stack=stack,
-                        dependency_cache=dependency_cache,
-                    ),
-                    (SkippedException,),
-                ),
-                _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>"
-                )
+        if show_log:
+            logger.debug("Checking for matchers completed")
+
+        await _apply_event_postprocessors(bot, event, state, stack, dependency_cache)

nonebot/params.py

@@ -5,17 +5,17 @@ FrontMatter:
     description: nonebot.params 模块
 """
 
-from typing import Any, Dict, List, Tuple, Optional
+from re import Match
+from typing import Any, Union, Literal, Callable, Optional, overload
 
 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 +26,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,
 )
 
 
@@ -77,7 +80,7 @@ def _command(state: T_State) -> Message:
     return state[PREFIX_KEY][CMD_KEY]
 
 
-def Command() -> Tuple[str, ...]:
+def Command() -> tuple[str, ...]:
     """消息命令元组"""
     return Depends(_command)
 
@@ -109,16 +112,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,37 +139,103 @@ 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):
-    return state[REGEX_GROUP]
+def _regex_str(
+    groups: tuple[Union[str, int], ...]
+) -> Callable[[T_State], Union[str, tuple[Union[str, Any], ...], Any]]:
+    def _regex_str_dependency(
+        state: T_State,
+    ) -> Union[str, tuple[Union[str, Any], ...], Any]:
+        return _regex_matched(state).group(*groups)
+
+    return _regex_str_dependency
 
 
-def RegexGroup() -> Tuple[Any, ...]:
+@overload
+def RegexStr(__group: Literal[0] = 0) -> str: ...
+
+
+@overload
+def RegexStr(__group: Union[str, int]) -> Union[str, Any]: ...
+
+
+@overload
+def RegexStr(
+    __group1: Union[str, int], __group2: Union[str, int], *groups: Union[str, int]
+) -> tuple[Union[str, Any], ...]: ...
+
+
+def RegexStr(*groups: Union[str, int]) -> Union[str, tuple[Union[str, Any], ...], Any]:
+    """正则匹配结果文本"""
+    return Depends(_regex_str(groups), use_cache=False)
+
+
+def _regex_group(state: T_State) -> tuple[Any, ...]:
+    return _regex_matched(state).groups()
+
+
+def RegexGroup() -> tuple[Any, ...]:
     """正则匹配结果 group 元组"""
     return Depends(_regex_group, use_cache=False)
 
 
-def _regex_dict(state: T_State):
-    return state[REGEX_DICT]
+def _regex_dict(state: T_State) -> dict[str, Any]:
+    return _regex_matched(state).groupdict()
 
 
-def RegexDict() -> Dict[str, Any]:
+def RegexDict() -> dict[str, Any]:
     """正则匹配结果 group 字典"""
     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 +252,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` ，
-其中是 `PermissionChecker` 的集合，只要有一个 `PermissionChecker` 检查结果为 `True` 时就会继续运行。
+每个{ref}`事件响应器 <nonebot.matcher.Matcher>`
+拥有一个 {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 (
-            f"{bot.adapter.get_name().split(maxsplit=1)[0].lower()}:{event.get_user_id()}"
+        try:
+            user_id = event.get_user_id()
+        except Exception:
+            return False
+        return (
+            f"{bot.adapter.get_name().split(maxsplit=1)[0].lower()}:{user_id}"
             in bot.config.superusers
-            or event.get_user_id() in bot.config.superusers  # 兼容旧配置
+            or user_id in bot.config.superusers  # 兼容旧配置
         )
 
 
 SUPERUSER: Permission = Permission(SuperUser())
-"""匹配任意超级用户消息类型事件"""
+"""匹配任意超级用户事件"""
 
 __autodoc__ = {
     "Permission": True,

nonebot/plugin/__init__.py

@@ -16,6 +16,7 @@
 - `on_command` => {ref}``on_command` <nonebot.plugin.on.on_command>`
 - `on_shell_command` => {ref}``on_shell_command` <nonebot.plugin.on.on_shell_command>`
 - `on_regex` => {ref}``on_regex` <nonebot.plugin.on.on_regex>`
+- `on_type` => {ref}``on_type` <nonebot.plugin.on.on_type>`
 - `CommandGroup` => {ref}``CommandGroup` <nonebot.plugin.on.CommandGroup>`
 - `Matchergroup` => {ref}``MatcherGroup` <nonebot.plugin.on.MatcherGroup>`
 - `load_plugin` => {ref}``load_plugin` <nonebot.plugin.load.load_plugin>`
@@ -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_plugins` => {ref}``load_builtin_plugins` <nonebot.plugin.load.load_builtin_plugins>`
-- `get_plugin` => {ref}``get_plugin` <nonebot.plugin.plugin.get_plugin>`
-- `get_loaded_plugins` => {ref}``get_loaded_plugins` <nonebot.plugin.plugin.get_loaded_plugins>`
-- `export` => {ref}``export` <nonebot.plugin.export.export>`
+- `load_builtin_plugin` =>
+  {ref}``load_builtin_plugin` <nonebot.plugin.load.load_builtin_plugin>`
+- `load_builtin_plugins` =>
+  {ref}``load_builtin_plugins` <nonebot.plugin.load.load_builtin_plugins>`
 - `require` => {ref}``require` <nonebot.plugin.load.require>`
+- `PluginMetadata` => {ref}``PluginMetadata` <nonebot.plugin.model.PluginMetadata>`
 
 FrontMatter:
     sidebar_position: 0
@@ -38,10 +39,17 @@ FrontMatter:
 from itertools import chain
 from types import ModuleType
 from contextvars import ContextVar
-from typing import Set, Dict, List, Optional
+from typing import TypeVar, Optional
 
-_plugins: Dict[str, "Plugin"] = {}
-_managers: List["PluginManager"] = []
+from pydantic import BaseModel
+
+from nonebot import get_driver
+from nonebot.compat import model_dump, type_validate_python
+
+C = TypeVar("C", bound=BaseModel)
+
+_plugins: dict[str, "Plugin"] = {}
+_managers: list["PluginManager"] = []
 _current_plugin: ContextVar[Optional["Plugin"]] = ContextVar(
     "_current_plugin", default=None
 )
@@ -51,32 +59,87 @@ def _module_name_to_plugin_name(module_name: str) -> str:
     return module_name.rsplit(".", 1)[-1]
 
 
+def _controlled_modules() -> dict[str, str]:
+    return {
+        plugin_id: module_name
+        for manager in _managers
+        for plugin_id, module_name in manager.controlled_modules.items()
+    }
+
+
+def _find_parent_plugin_id(
+    module_name: str, controlled_modules: Optional[dict[str, str]] = None
+) -> Optional[str]:
+    if controlled_modules is None:
+        controlled_modules = _controlled_modules()
+    available = {
+        module_name: plugin_id for plugin_id, module_name in controlled_modules.items()
+    }
+    while "." in module_name:
+        module_name, _ = module_name.rsplit(".", 1)
+        if module_name in available:
+            return available[module_name]
+
+
+def _module_name_to_plugin_id(
+    module_name: str, controlled_modules: Optional[dict[str, str]] = None
+) -> str:
+    plugin_name = _module_name_to_plugin_name(module_name)
+    if parent_plugin_id := _find_parent_plugin_id(module_name, controlled_modules):
+        return f"{parent_plugin_id}:{plugin_name}"
+    return plugin_name
+
+
 def _new_plugin(
     module_name: str, module: ModuleType, manager: "PluginManager"
 ) -> "Plugin":
-    plugin_name = _module_name_to_plugin_name(module_name)
-    if plugin_name in _plugins:
-        raise RuntimeError("Plugin already exists! Check your plugin name.")
-    plugin = Plugin(plugin_name, module, module_name, manager)
-    _plugins[plugin_name] = plugin
+    plugin_id = _module_name_to_plugin_id(module_name)
+    if plugin_id in _plugins:
+        raise RuntimeError(
+            f"Plugin {plugin_id} already exists! Check your plugin name."
+        )
+
+    parent_plugin_id = _find_parent_plugin_id(module_name)
+    if parent_plugin_id is not None and parent_plugin_id not in _plugins:
+        raise RuntimeError(
+            f"Parent plugin {parent_plugin_id} must "
+            f"be loaded before loading {plugin_id}."
+        )
+    parent_plugin = _plugins[parent_plugin_id] if parent_plugin_id is not None else None
+
+    plugin = Plugin(
+        name=_module_name_to_plugin_name(module_name),
+        module=module,
+        module_name=module_name,
+        manager=manager,
+        parent_plugin=parent_plugin,
+    )
+    if parent_plugin:
+        parent_plugin.sub_plugins.add(plugin)
+
+    _plugins[plugin_id] = plugin
     return plugin
 
 
 def _revert_plugin(plugin: "Plugin") -> None:
-    if plugin.name not in _plugins:
+    if plugin.id_ not in _plugins:
         raise RuntimeError("Plugin not found!")
-    del _plugins[plugin.name]
+    del _plugins[plugin.id_]
+    if parent_plugin := plugin.parent_plugin:
+        parent_plugin.sub_plugins.discard(plugin)
 
 
-def get_plugin(name: str) -> Optional["Plugin"]:
+def get_plugin(plugin_id: str) -> Optional["Plugin"]:
     """获取已经导入的某个插件。
 
     如果为 `load_plugins` 文件夹导入的插件，则为文件(夹)名。
 
+    如果为嵌套的子插件，标识符为 `父插件标识符:子插件文件(夹)名`。
+
     参数:
-        name: 插件名，即 {ref}`nonebot.plugin.plugin.Plugin.name`。
+        plugin_id: 插件标识符，即 {ref}`nonebot.plugin.model.Plugin.id_`。
     """
-    return _plugins.get(name)
+    return _plugins.get(plugin_id)
 
 
 def get_plugin_by_module_name(module_name: str) -> Optional["Plugin"]:
@@ -85,34 +148,37 @@ def get_plugin_by_module_name(module_name: str) -> Optional["Plugin"]:
     如果提供的模块名为某个插件的子模块，同样会返回该插件。
 
     参数:
-        module_name: 模块名，即 {ref}`nonebot.plugin.plugin.Plugin.module_name`。
+        module_name: 模块名，即 {ref}`nonebot.plugin.model.Plugin.module_name`。
     """
-    splits = module_name.split(".")
     loaded = {plugin.module_name: plugin for plugin in _plugins.values()}
-    while splits:
-        name = ".".join(splits)
-        if name in loaded:
-            return loaded[name]
-        splits.pop()
+    has_parent = True
+    while has_parent:
+        if module_name in loaded:
+            return loaded[module_name]
+        module_name, *has_parent = module_name.rsplit(".", 1)
 
 
-def get_loaded_plugins() -> Set["Plugin"]:
+def get_loaded_plugins() -> set["Plugin"]:
     """获取当前已导入的所有插件。"""
     return set(_plugins.values())
 
 
-def get_available_plugin_names() -> Set[str]:
-    """获取当前所有可用的插件名（包含尚未加载的插件）。"""
+def get_available_plugin_names() -> set[str]:
+    """获取当前所有可用的插件标识符（包含尚未加载的插件）。"""
     return {*chain.from_iterable(manager.available_plugins for manager in _managers)}
 
 
+def get_plugin_config(config: type[C]) -> C:
+    """从全局配置获取当前插件需要的配置项。"""
+    return type_validate_python(config, model_dump(get_driver().config))
+
+
 from .on import on as on
 from .manager import PluginManager
-from .export import Export as Export
-from .export import export as export
+from .on import on_type as on_type
+from .model import Plugin as Plugin
 from .load import require as require
 from .on import on_regex as on_regex
-from .plugin import Plugin as Plugin
 from .on import on_notice as on_notice
 from .on import on_command as on_command
 from .on import on_keyword as on_keyword
@@ -128,8 +194,9 @@ from .load import load_plugins as load_plugins
 from .on import on_startswith as on_startswith
 from .load import load_from_json as load_from_json
 from .load import load_from_toml as load_from_toml
+from .model import PluginMetadata as PluginMetadata
 from .on import on_shell_command as on_shell_command
-from .plugin import PluginMetadata as PluginMetadata
 from .load import load_all_plugins as load_all_plugins
 from .load import load_builtin_plugin as load_builtin_plugin
 from .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,31 +4,43 @@ FrontMatter:
     sidebar_position: 1
     description: nonebot.plugin.load 模块
 """
+
 import json
-import warnings
-from typing import Set, Iterable, Optional
+from pathlib import Path
+from types import ModuleType
+from typing import Union, Optional
+from collections.abc import Iterable
 
-import tomlkit
+from nonebot.utils import path_to_module_name
 
-from .export import Export
-from .plugin import Plugin
+from .model import Plugin
 from .manager import PluginManager
-from . import _managers, get_plugin, _module_name_to_plugin_name
+from . import _managers, get_plugin, _module_name_to_plugin_id
+
+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)
 
 
-def load_plugins(*plugin_dir: str) -> Set[Plugin]:
+def load_plugins(*plugin_dir: str) -> set[Plugin]:
     """导入文件夹下多个插件，以 `_` 开头的插件不会被导入!
 
     参数:
@@ -41,7 +53,7 @@ def load_plugins(*plugin_dir: str) -> Set[Plugin]:
 
 def load_all_plugins(
     module_path: Iterable[str], plugin_dir: Iterable[str]
-) -> Set[Plugin]:
+) -> set[Plugin]:
     """导入指定列表中的插件以及指定目录下多个插件，以 `_` 开头的插件不会被导入!
 
     参数:
@@ -53,8 +65,9 @@ def load_all_plugins(
     return manager.load_all_plugins()
 
 
-def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]:
-    """导入指定 json 文件中的 `plugins` 以及 `plugin_dirs` 下多个插件，以 `_` 开头的插件不会被导入!
+def load_from_json(file_path: str, encoding: str = "utf-8") -> set[Plugin]:
+    """导入指定 json 文件中的 `plugins` 以及 `plugin_dirs` 下多个插件。
+    以 `_` 开头的插件不会被导入!
 
     参数:
         file_path: 指定 json 文件路径
@@ -72,8 +85,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"
@@ -81,8 +96,10 @@ def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]:
     return load_all_plugins(set(plugins), set(plugin_dirs))
 
 
-def load_from_toml(file_path: str, encoding: str = "utf-8") -> Set[Plugin]:
-    """导入指定 toml 文件 `[tool.nonebot]` 中的 `plugins` 以及 `plugin_dirs` 下多个插件，以 `_` 开头的插件不会被导入!
+def load_from_toml(file_path: str, encoding: str = "utf-8") -> set[Plugin]:
+    """导入指定 toml 文件 `[tool.nonebot]` 中的
+    `plugins` 以及 `plugin_dirs` 下多个插件。
+    以 `_` 开头的插件不会被导入!
 
     参数:
         file_path: 指定 toml 文件路径
@@ -99,19 +116,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:
-        data = tomlkit.parse(f.read())  # type: ignore
+    with open(file_path, encoding=encoding) as f:
+        data = tomllib.loads(f.read())
 
     nonebot_data = data.get("tool", {}).get("nonebot")
-    if not nonebot_data:
-        nonebot_data = data.get("nonebot", {}).get("plugins")
-        if nonebot_data:
-            warnings.warn(
-                "[nonebot.plugins] table is deprecated. Use [tool.nonebot] instead.",
-                DeprecationWarning,
-            )
-        else:
-            raise ValueError("Cannot find '[tool.nonebot]' in given toml file!")
+    if nonebot_data is None:
+        raise ValueError("Cannot find '[tool.nonebot]' in given toml file!")
+    if not isinstance(nonebot_data, dict):
+        raise TypeError("'[tool.nonebot]' must be a Table!")
     plugins = nonebot_data.get("plugins", [])
     plugin_dirs = nonebot_data.get("plugin_dirs", [])
     assert isinstance(plugins, list), "plugins must be a list of plugin name"
@@ -128,7 +140,7 @@ def load_builtin_plugin(name: str) -> Optional[Plugin]:
     return load_plugin(f"nonebot.plugins.{name}")
 
 
-def load_builtin_plugins(*plugins: str) -> Set[Plugin]:
+def load_builtin_plugins(*plugins: str) -> set[Plugin]:
     """导入多个 NoneBot 内置插件。
 
     参数:
@@ -139,28 +151,78 @@ def load_builtin_plugins(*plugins: str) -> Set[Plugin]:
 
 def _find_manager_by_name(name: str) -> Optional[PluginManager]:
     for manager in reversed(_managers):
-        if name in manager.plugins or name in manager.searched_plugins:
+        if (
+            name in manager.controlled_modules
+            or name in manager.controlled_modules.values()
+        ):
             return manager
 
 
-def require(name: str) -> Export:
-    """获取一个插件的导出内容。
-
-    如果为 `load_plugins` 文件夹导入的插件，则为文件(夹)名。
+def require(name: str) -> ModuleType:
+    """声明依赖插件。
 
     参数:
-        name: 插件名，即 {ref}`nonebot.plugin.plugin.Plugin.name`。
+        name: 插件模块名或插件标识符，仅在已声明插件的情况下可使用标识符。
 
     异常:
         RuntimeError: 插件无法加载
     """
-    plugin = get_plugin(_module_name_to_plugin_name(name))
-    if not plugin:
-        manager = _find_manager_by_name(name)
-        if manager:
+    if "." in name:
+        # name is a module name
+        plugin = get_plugin(_module_name_to_plugin_id(name))
+    else:
+        # name is a plugin id or simple module name (equals to plugin id)
+        plugin = get_plugin(name)
+
+    # if plugin not loaded
+    if plugin is None:
+        # plugin already declared, module name / plugin id
+        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)
-        if not plugin:
-            raise RuntimeError(f'Cannot load plugin "{name}"!')
-    return plugin.export
+
+    if plugin is None:
+        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_id(name))
+        if plugin is None:
+            raise RuntimeError(
+                f'Plugin "{name}" is not loaded! You should require it first.'
+            )
+        meta = plugin.metadata
+        if meta is None:
+            raise ValueError(f'Plugin "{name}" has no metadata!')
+
+        if (raw := meta.supported_adapters) is None:
+            continue
+
+        support = {
+            f"nonebot.adapters.{adapter[1:]}" if adapter.startswith("~") else adapter
+            for adapter in raw
+        }
+
+        final_supported = (
+            support if final_supported is None else (final_supported & support)
+        )
+
+    return final_supported

nonebot/plugin/manager.py

@@ -6,26 +6,28 @@ FrontMatter:
     sidebar_position: 5
     description: nonebot.plugin.manager 模块
 """
+
 import sys
 import pkgutil
 import importlib
 from pathlib import Path
 from itertools import chain
+from typing import Optional
 from types import ModuleType
 from importlib.abc import MetaPathFinder
+from collections.abc import Iterable, Sequence
 from importlib.machinery import PathFinder, SourceFileLoader
-from typing import Set, Dict, List, Union, 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 .model import Plugin, PluginMetadata
 from . import (
     _managers,
     _new_plugin,
     _revert_plugin,
     _current_plugin,
-    _module_name_to_plugin_name,
+    _module_name_to_plugin_id,
 )
 
 
@@ -34,7 +36,7 @@ class PluginManager:
 
     参数:
         plugins: 独立插件模块名集合。
-        search_path: 插件搜索路径（文件夹）。
+        search_path: 插件搜索路径（文件夹），相对于当前工作目录。
     """
 
     def __init__(
@@ -43,65 +45,78 @@ class PluginManager:
         search_path: Optional[Iterable[str]] = None,
     ):
         # simple plugin not in search path
-        self.plugins: Set[str] = set(plugins or [])
-        self.search_path: Set[str] = set(search_path or [])
+        self.plugins: set[str] = set(plugins or [])
+        self.search_path: set[str] = set(search_path or [])
 
         # cache plugins
-        self._third_party_plugin_names: Dict[str, str] = {}
-        self._searched_plugin_names: Dict[str, Path] = {}
-        self.prepare_plugins()
+        self._third_party_plugin_ids: dict[str, str] = {}
+        self._searched_plugin_ids: dict[str, str] = {}
+        self._prepare_plugins()
+
+    def __repr__(self) -> str:
+        return f"PluginManager(available_plugins={self.controlled_modules})"
 
     @property
-    def third_party_plugins(self) -> Set[str]:
-        """返回所有独立插件名称。"""
-        return set(self._third_party_plugin_names.keys())
+    def third_party_plugins(self) -> set[str]:
+        """返回所有独立插件标识符。"""
+        return set(self._third_party_plugin_ids.keys())
 
     @property
-    def searched_plugins(self) -> Set[str]:
-        """返回已搜索到的插件名称。"""
-        return set(self._searched_plugin_names.keys())
+    def searched_plugins(self) -> set[str]:
+        """返回已搜索到的插件标识符。"""
+        return set(self._searched_plugin_ids.keys())
 
     @property
-    def available_plugins(self) -> Set[str]:
-        """返回当前插件管理器中可用的插件名称。"""
+    def available_plugins(self) -> set[str]:
+        """返回当前插件管理器中可用的插件标识符。"""
         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,))
+    @property
+    def controlled_modules(self) -> dict[str, str]:
+        """返回当前插件管理器中控制的插件标识符与模块路径映射字典。"""
+        return dict(
+            chain(
+                self._third_party_plugin_ids.items(), self._searched_plugin_ids.items()
+            )
+        )
 
-    def _previous_plugins(self) -> Set[str]:
-        _pre_managers: List[PluginManager]
+    def _previous_controlled_modules(self) -> dict[str, str]:
+        _pre_managers: list[PluginManager]
         if self in _managers:
             _pre_managers = _managers[: _managers.index(self)]
         else:
             _pre_managers = _managers[:]
 
         return {
-            *chain.from_iterable(manager.available_plugins for manager in _pre_managers)
+            plugin_id: module_name
+            for manager in _pre_managers
+            for plugin_id, module_name in manager.controlled_modules.items()
         }
 
-    def prepare_plugins(self) -> Set[str]:
+    def _prepare_plugins(self) -> set[str]:
         """搜索插件并缓存插件名称。"""
-
         # get all previous ready to load plugins
-        previous_plugins = self._previous_plugins()
-        searched_plugins: Dict[str, Path] = {}
-        third_party_plugins: Dict[str, str] = {}
+        previous_plugin_ids = self._previous_controlled_modules()
+
+        # if self not in global managers, merge self's controlled modules
+        def get_controlled_modules():
+            return (
+                previous_plugin_ids
+                if self in _managers
+                else {**previous_plugin_ids, **self.controlled_modules}
+            )
 
         # check third party plugins
         for plugin in self.plugins:
-            name = _module_name_to_plugin_name(plugin)
-            if name in third_party_plugins or name in previous_plugins:
+            plugin_id = _module_name_to_plugin_id(plugin, get_controlled_modules())
+            if (
+                plugin_id in self._third_party_plugin_ids
+                or plugin_id in previous_plugin_ids
+            ):
                 raise RuntimeError(
-                    f"Plugin already exists: {name}! Check your plugin name"
+                    f"Plugin already exists: {plugin_id}! Check your plugin name"
                 )
-            third_party_plugins[name] = plugin
-
-        self._third_party_plugin_names = third_party_plugins
+            self._third_party_plugin_ids[plugin_id] = plugin
 
         # check plugins in search path
         for module_info in pkgutil.iter_modules(self.search_path):
@@ -109,64 +124,80 @@ class PluginManager:
             if module_info.name.startswith("_"):
                 continue
 
+            if not (
+                module_spec := module_info.module_finder.find_spec(
+                    module_info.name, None
+                )
+            ):
+                continue
+
+            if not module_spec.origin:
+                continue
+
+            # get module name from path, pkgutil does not return the actual module name
+            module_path = Path(module_spec.origin).resolve()
+            module_name = path_to_module_name(module_path)
+            plugin_id = _module_name_to_plugin_id(module_name, get_controlled_modules())
+
             if (
-                module_info.name in searched_plugins
-                or module_info.name in previous_plugins
-                or module_info.name in third_party_plugins
+                plugin_id in previous_plugin_ids
+                or plugin_id in self._third_party_plugin_ids
+                or plugin_id in self._searched_plugin_ids
             ):
                 raise RuntimeError(
-                    f"Plugin already exists: {module_info.name}! Check your plugin name"
+                    f"Plugin already exists: {plugin_id}! Check your plugin name"
                 )
 
-            module_spec = module_info.module_finder.find_spec(module_info.name, None)
-            if not module_spec:
-                continue
-            module_path = module_spec.origin
-            if not module_path:
-                continue
-            searched_plugins[module_info.name] = Path(module_path).resolve()
-
-        self._searched_plugin_names = searched_plugins
+            self._searched_plugin_ids[plugin_id] = module_name
 
         return self.available_plugins
 
     def load_plugin(self, name: str) -> Optional[Plugin]:
         """加载指定插件。
 
-        对于独立插件，可以使用完整插件模块名或者插件名称。
+        可以使用完整插件模块名或者插件标识符加载。
 
         参数:
-            name: 插件名称。
+            name: 插件名称或插件标识符。
         """
 
         try:
-            if name in self.plugins:
+            # load using plugin id
+            if name in self._third_party_plugin_ids:
+                module = importlib.import_module(self._third_party_plugin_ids[name])
+            elif name in self._searched_plugin_ids:
+                module = importlib.import_module(self._searched_plugin_ids[name])
+            # load using module name
+            elif (
+                name in self._third_party_plugin_ids.values()
+                or name in self._searched_plugin_ids.values()
+            ):
                 module = importlib.import_module(name)
-            elif name in self._third_party_plugin_names:
-                module = importlib.import_module(self._third_party_plugin_names[name])
-            elif name in self._searched_plugin_names:
-                module = importlib.import_module(
-                    self._path_to_module_name(self._searched_plugin_names[name])
-                )
             else:
                 raise RuntimeError(f"Plugin not found: {name}! Check your plugin name")
 
-            logger.opt(colors=True).success(
-                f'Succeeded to import "<y>{escape_tag(name)}</y>"'
-            )
-            plugin = getattr(module, "__plugin__", None)
-            if plugin is None:
+            if (
+                plugin := getattr(module, "__plugin__", None)
+            ) is None or not isinstance(plugin, Plugin):
                 raise RuntimeError(
                     f"Module {module.__name__} is not loaded as a plugin! "
-                    "Make sure not to import it before loading."
+                    f"Make sure not to import it before loading."
                 )
+            logger.opt(colors=True).success(
+                f'Succeeded to load plugin "<y>{escape_tag(plugin.id_)}</y>"'
+                + (
+                    f' from "<m>{escape_tag(plugin.module_name)}</m>"'
+                    if plugin.module_name != plugin.id_
+                    else ""
+                )
+            )
             return plugin
         except Exception as e:
             logger.opt(colors=True, exception=e).error(
                 f'<r><bg #f8bbd0>Failed to import "{escape_tag(name)}"</bg #f8bbd0></r>'
             )
 
-    def load_all_plugins(self) -> Set[Plugin]:
+    def load_all_plugins(self) -> set[Plugin]:
         """加载所有可用插件。"""
 
         return set(
@@ -178,7 +209,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:
@@ -188,21 +219,16 @@ class PluginFinder(MetaPathFinder):
             module_origin = module_spec.origin
             if not module_origin:
                 return
-            module_path = Path(module_origin).resolve()
 
             for manager in reversed(_managers):
-                # use path instead of name in case of submodule name conflict
-                if (
-                    fullname in manager.plugins
-                    or module_path in manager._searched_plugin_names.values()
-                ):
+                if fullname in manager.controlled_modules.values():
                     module_spec.loader = PluginLoader(manager, fullname, module_origin)
                     return module_spec
         return
 
 
 class PluginLoader(SourceFileLoader):
-    def __init__(self, manager: PluginManager, fullname: str, path) -> None:
+    def __init__(self, manager: PluginManager, fullname: str, path: str) -> None:
         self.manager = manager
         self.loaded = False
         super().__init__(fullname, path)
@@ -222,14 +248,6 @@ class PluginLoader(SourceFileLoader):
         plugin = _new_plugin(self.name, module, self.manager)
         setattr(module, "__plugin__", plugin)
 
-        # detect parent plugin before entering current plugin context
-        parent_plugin = _current_plugin.get()
-        if parent_plugin and _managers.index(parent_plugin.manager) < _managers.index(
-            self.manager
-        ):
-            plugin.parent_plugin = parent_plugin
-            parent_plugin.sub_plugins.add(plugin)
-
         # enter plugin context
         _plugin_token = _current_plugin.set(plugin)
 

nonebot/plugin/model.py

@@ -0,0 +1,89 @@
+"""本模块定义插件相关信息。
+
+FrontMatter:
+    sidebar_position: 3
+    description: nonebot.plugin.model 模块
+"""
+
+import contextlib
+from types import ModuleType
+from dataclasses import field, dataclass
+from typing import TYPE_CHECKING, Any, Type, Optional  # noqa: UP035
+
+from pydantic import BaseModel
+
+from nonebot.matcher import Matcher
+from nonebot.utils import resolve_dot_notation
+
+if TYPE_CHECKING:
+    from nonebot.adapters import Adapter
+
+    from .manager import PluginManager
+
+
+@dataclass(eq=False)
+class PluginMetadata:
+    """插件元信息，由插件编写者提供"""
+
+    name: str
+    """插件名称"""
+    description: str
+    """插件功能介绍"""
+    usage: str
+    """插件使用方法"""
+    type: Optional[str] = None
+    """插件类型，用于商店分类"""
+    homepage: Optional[str] = None
+    """插件主页"""
+    config: Optional[Type[BaseModel]] = None  # noqa: UP006
+    """插件配置项"""
+    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"]]]:  # noqa: UP006
+        """获取当前已安装的插件支持适配器类列表"""
+        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)
+class Plugin:
+    """存储插件信息"""
+
+    name: str
+    """插件名称，NoneBot 使用 文件/文件夹 名称作为插件名称"""
+    module: ModuleType
+    """插件模块对象"""
+    module_name: str
+    """点分割模块路径"""
+    manager: "PluginManager"
+    """导入该插件的插件管理器"""
+    matcher: set[type[Matcher]] = field(default_factory=set)
+    """插件加载时定义的 `Matcher`"""
+    parent_plugin: Optional["Plugin"] = None
+    """父插件"""
+    sub_plugins: set["Plugin"] = field(default_factory=set)
+    """子插件集合"""
+    metadata: Optional[PluginMetadata] = None
+
+    @property
+    def id_(self) -> str:
+        """插件索引标识"""
+        return (
+            f"{self.parent_plugin.id_}:{self.name}" if self.parent_plugin else self.name
+        )

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 .model 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]] = ...,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+    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] = ...,
-) -> Type[Matcher]: ...
+    state: T_State | None = ...,
+) -> 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] = ...,
-) -> Type[Matcher]: ...
+    state: T_State | None = ...,
+) -> type[Matcher]: ...
 def on_message(
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
+    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] = ...,
-) -> Type[Matcher]: ...
+    state: T_State | None = ...,
+) -> 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] = ...,
-) -> Type[Matcher]: ...
+    state: T_State | None = ...,
+) -> 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] = ...,
-) -> Type[Matcher]: ...
+    state: T_State | None = ...,
+) -> type[Matcher]: ...
 def on_startswith(
-    msg: Union[str, Tuple[str, ...]],
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    msg: str | tuple[str, ...],
+    rule: Rule | T_RuleChecker | None = ...,
     ignorecase: bool = ...,
     *,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-    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] = ...,
-) -> Type[Matcher]: ...
+    state: T_State | None = ...,
+) -> type[Matcher]: ...
 def on_endswith(
-    msg: Union[str, Tuple[str, ...]],
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    msg: str | tuple[str, ...],
+    rule: Rule | T_RuleChecker | None = ...,
     ignorecase: bool = ...,
     *,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-    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] = ...,
-) -> Type[Matcher]: ...
+    state: T_State | None = ...,
+) -> type[Matcher]: ...
 def on_fullmatch(
-    msg: Union[str, Tuple[str, ...]],
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    msg: str | tuple[str, ...],
+    rule: Rule | T_RuleChecker | None = ...,
     ignorecase: bool = ...,
     *,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-    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] = ...,
-) -> Type[Matcher]: ...
+    state: T_State | None = ...,
+) -> type[Matcher]: ...
 def on_keyword(
-    keywords: Set[str],
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    keywords: set[str],
+    rule: Rule | T_RuleChecker | None = ...,
     *,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-    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] = ...,
-) -> Type[Matcher]: ...
+    state: T_State | None = ...,
+) -> type[Matcher]: ...
 def on_command(
-    cmd: Union[str, Tuple[str, ...]],
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-    aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
+    cmd: str | tuple[str, ...],
+    rule: Rule | T_RuleChecker | None = ...,
+    aliases: set[str | tuple[str, ...]] | None = ...,
+    force_whitespace: str | bool | None = ...,
     *,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-    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] = ...,
-) -> Type[Matcher]: ...
+    state: T_State | None = ...,
+) -> type[Matcher]: ...
 def on_shell_command(
-    cmd: Union[str, Tuple[str, ...]],
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-    aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
-    parser: Optional[ArgumentParser] = ...,
+    cmd: str | tuple[str, ...],
+    rule: Rule | T_RuleChecker | None = ...,
+    aliases: set[str | tuple[str, ...]] | None = ...,
+    parser: ArgumentParser | None = ...,
     *,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-    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] = ...,
-) -> Type[Matcher]: ...
+    state: T_State | None = ...,
+) -> type[Matcher]: ...
 def on_regex(
     pattern: str,
-    flags: Union[int, re.RegexFlag] = ...,
-    rule: Optional[Union[Rule, T_RuleChecker]] = ...,
+    flags: int | re.RegexFlag = ...,
+    rule: Rule | T_RuleChecker | None = ...,
     *,
-    permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-    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] = ...,
-) -> Type[Matcher]: ...
+    state: T_State | None = ...,
+) -> 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]] = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        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: 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: Optional[Union[Rule, T_RuleChecker]] = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
+        aliases: set[str | tuple[str, ...]] | None = ...,
+        force_whitespace: str | bool | None = ...,
+        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] = ...,
-    ) -> Type[Matcher]: ...
+        state: T_State | None = ...,
+    ) -> type[Matcher]: ...
     def shell_command(
         self,
-        cmd: Union[str, Tuple[str, ...]],
+        cmd: str | tuple[str, ...],
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        aliases: Optional[Set[Union[str, Tuple[str, ...]]]],
-        parser: Optional[ArgumentParser] = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        rule: Rule | T_RuleChecker | None = ...,
+        aliases: set[str | tuple[str, ...]] | None = ...,
+        parser: ArgumentParser | None = ...,
+        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] = ...,
-    ) -> Type[Matcher]: ...
+        state: T_State | None = ...,
+    ) -> type[Matcher]: ...
 
-class MatcherGroup:
+class MatcherGroup(_Group):
     def __init__(
         self,
         *,
         type: str = ...,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        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: Optional[T_State] = ...,
+        state: T_State | None = ...,
     ): ...
     def on(
         self,
         *,
         type: str = ...,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        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: Optional[T_State] = ...,
-    ) -> Type[Matcher]: ...
+        state: T_State | None = ...,
+    ) -> type[Matcher]: ...
     def on_metaevent(
         self,
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        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: Optional[T_State] = ...,
-    ) -> Type[Matcher]: ...
+        state: T_State | None = ...,
+    ) -> type[Matcher]: ...
     def on_message(
         self,
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        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: Optional[T_State] = ...,
-    ) -> Type[Matcher]: ...
+        state: T_State | None = ...,
+    ) -> type[Matcher]: ...
     def on_notice(
         self,
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        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: Optional[T_State] = ...,
-    ) -> Type[Matcher]: ...
+        state: T_State | None = ...,
+    ) -> type[Matcher]: ...
     def on_request(
         self,
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        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: Optional[T_State] = ...,
-    ) -> Type[Matcher]: ...
+        state: T_State | None = ...,
+    ) -> type[Matcher]: ...
     def on_startswith(
         self,
-        msg: Union[str, Tuple[str, ...]],
+        msg: str | tuple[str, ...],
         *,
         ignorecase: bool = ...,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        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: Optional[T_State] = ...,
-    ) -> Type[Matcher]: ...
+        state: T_State | None = ...,
+    ) -> type[Matcher]: ...
     def on_endswith(
         self,
-        msg: Union[str, Tuple[str, ...]],
+        msg: str | tuple[str, ...],
         *,
         ignorecase: bool = ...,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        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: Optional[T_State] = ...,
-    ) -> Type[Matcher]: ...
+        state: T_State | None = ...,
+    ) -> type[Matcher]: ...
     def on_fullmatch(
         self,
-        msg: Union[str, Tuple[str, ...]],
+        msg: str | tuple[str, ...],
         *,
         ignorecase: bool = ...,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        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: Optional[T_State] = ...,
-    ) -> Type[Matcher]: ...
+        state: T_State | None = ...,
+    ) -> type[Matcher]: ...
     def on_keyword(
         self,
-        keywords: Set[str],
+        keywords: set[str],
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        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: Optional[T_State] = ...,
-    ) -> Type[Matcher]: ...
+        state: T_State | None = ...,
+    ) -> type[Matcher]: ...
     def on_command(
         self,
-        cmd: Union[str, Tuple[str, ...]],
-        aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
+        cmd: str | tuple[str, ...],
+        aliases: set[str | tuple[str, ...]] | None = ...,
+        force_whitespace: str | bool | None = ...,
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        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: Optional[T_State] = ...,
-    ) -> Type[Matcher]: ...
+        state: T_State | None = ...,
+    ) -> type[Matcher]: ...
     def on_shell_command(
         self,
-        cmd: Union[str, Tuple[str, ...]],
-        aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = ...,
-        parser: Optional[ArgumentParser] = ...,
+        cmd: str | tuple[str, ...],
+        aliases: set[str | tuple[str, ...]] | None = ...,
+        parser: ArgumentParser | None = ...,
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        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: Optional[T_State] = ...,
-    ) -> Type[Matcher]: ...
+        state: T_State | None = ...,
+    ) -> type[Matcher]: ...
     def on_regex(
         self,
         pattern: str,
-        flags: Union[int, re.RegexFlag] = ...,
+        flags: int | re.RegexFlag = ...,
         *,
-        rule: Optional[Union[Rule, T_RuleChecker]] = ...,
-        permission: Optional[Union[Permission, T_PermissionChecker]] = ...,
-        handlers: Optional[List[Union[T_Handler, Dependent]]] = ...,
+        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: Optional[T_State] = ...,
-    ) -> Type[Matcher]: ...
+        state: T_State | None = ...,
+    ) -> 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,57 +0,0 @@
-"""本模块定义插件对象。
-
-FrontMatter:
-    sidebar_position: 3
-    description: nonebot.plugin.plugin 模块
-"""
-from types import ModuleType
-from dataclasses import field, dataclass
-from typing import TYPE_CHECKING, Any, Set, Dict, Type, Optional
-
-from pydantic import BaseModel
-
-from nonebot.matcher import Matcher
-
-from .export import Export
-from . import _plugins as plugins  # FIXME: backport for nonebug
-
-if TYPE_CHECKING:
-    from .manager import PluginManager
-
-
-@dataclass(eq=False)
-class PluginMetadata:
-    """插件元信息，由插件编写者提供"""
-
-    name: str
-    """插件可阅读名称"""
-    description: str
-    """插件功能介绍"""
-    usage: str
-    """插件使用方法"""
-    config: Optional[Type[BaseModel]] = None
-    """插件配置项"""
-    extra: Dict[Any, Any] = field(default_factory=dict)
-
-
-@dataclass(eq=False)
-class Plugin:
-    """存储插件信息"""
-
-    name: str
-    """插件索引标识，NoneBot 使用 文件/文件夹 名称作为标识符"""
-    module: ModuleType
-    """插件模块对象"""
-    module_name: str
-    """点分割模块路径"""
-    manager: "PluginManager"
-    """导入该插件的插件管理器"""
-    export: Export = field(default_factory=Export)
-    """**Deprecated:** 插件内定义的导出内容"""
-    matcher: Set[Type[Matcher]] = field(default_factory=set)
-    """插件内定义的 `Matcher`"""
-    parent_plugin: Optional["Plugin"] = None
-    """父插件"""
-    sub_plugins: Set["Plugin"] = field(default_factory=set)
-    """子插件集合"""
-    metadata: Optional[PluginMetadata] = None

nonebot/plugins/echo.py

@@ -1,11 +1,23 @@
+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()):
-    await echo.send(message=message)
+async def handle_echo(message: Message = CommandArg()):
+    if any((not seg.is_text()) or str(seg) for seg in message):
+        await echo.send(message=message)

nonebot/plugins/single_session.py

@@ -1,10 +1,21 @@
-from typing import Dict, AsyncGenerator
+from collections.abc import AsyncGenerator
 
 from nonebot.adapters import Event
 from nonebot.params import Depends
+from nonebot.plugin import PluginMetadata
 from nonebot.message import IgnoredException, event_preprocessor
 
-_running_matcher: Dict[str, int] = {}
+__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] = {}
 
 
 async def matcher_mutex(event: Event) -> AsyncGenerator[bool, None]:
@@ -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:
+        if event_id := _running_matcher.get(session_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`
-其中是 `RuleChecker` 的集合，只有当所有 `RuleChecker` 检查结果为 `True` 时继续运行。
+每个{ref}`事件响应器 <nonebot.matcher.Matcher>`拥有一个
+{ref}`nonebot.rule.Rule`，其中是 `RuleChecker` 的集合。
+只有当所有 `RuleChecker` 检查结果为 `True` 时继续运行。
 
 FrontMatter:
     sidebar_position: 5
@@ -10,11 +11,25 @@ FrontMatter:
 
 import re
 import shlex
-from itertools import product
-from argparse import Namespace
-from typing_extensions import TypedDict
+from argparse import Action
+from gettext import gettext
+from argparse import ArgumentError
+from contextvars import ContextVar
+from collections.abc import Sequence
+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,
+    Union,
+    TypeVar,
+    Optional,
+    TypedDict,
+    NamedTuple,
+    cast,
+    overload,
+)
 
 from pygtrie import CharTrie
 
@@ -24,40 +39,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 (
-    Command,
-    EventToMe,
-    EventType,
-    CommandArg,
-    EventMessage,
-    EventPlainText,
-)
+from nonebot.params import Command, EventToMe, CommandArg, CommandWhitespace
 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(
-    "CMD_RESULT",
-    {
-        "command": Optional[Tuple[str, ...]],
-        "raw_command": Optional[str],
-        "command_arg": Optional[Message[MessageSegment]],
-        "command_start": Optional[str],
-    },
-)
+T = TypeVar("T")
 
-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 +88,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 +102,35 @@ class TrieRule:
         message_seg: MessageSegment = message[0]
         if message_seg.is_text():
             segment_text = str(message_seg).lstrip()
-            pf = cls.prefix.longest_prefix(segment_text)
-            if pf:
+            if pf := cls.prefix.longest_prefix(segment_text):
                 value: TRIE_VALUE = pf.value
                 prefix[RAW_CMD_KEY] = pf.key
                 prefix[CMD_START_KEY] = value.command_start
                 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):
-                    msg.insert(0, new_segment)
+
+                # check whitespace
+                arg_str = segment_text[len(pf.key) :]
+                arg_str_stripped = arg_str.lstrip()
+                # check next segment until arg detected or no text remain
+                while not arg_str_stripped and msg and msg[0].is_text():
+                    arg_str += str(msg.pop(0))
+                    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
@@ -109,25 +146,39 @@ class StartswithRule:
 
     __slots__ = ("msg", "ignorecase")
 
-    def __init__(self, msg: Tuple[str, ...], ignorecase: bool = False):
+    def __init__(self, msg: tuple[str, ...], ignorecase: bool = False):
         self.msg = msg
         self.ignorecase = ignorecase
 
-    async def __call__(
-        self, type: str = EventType(), text: str = EventPlainText()
-    ) -> Any:
-        if type != "message":
-            return False
-        return bool(
-            re.match(
-                f"^(?:{'|'.join(re.escape(prefix) for prefix in self.msg)})",
-                text,
-                re.IGNORECASE if self.ignorecase else 0,
-            )
+    def __repr__(self) -> str:
+        return f"Startswith(msg={self.msg}, ignorecase={self.ignorecase})"
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, StartswithRule)
+            and frozenset(self.msg) == frozenset(other.msg)
+            and self.ignorecase == other.ignorecase
         )
 
+    def __hash__(self) -> int:
+        return hash((frozenset(self.msg), self.ignorecase))
 
-def startswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule:
+    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:
     """匹配消息纯文本开头。
 
     参数:
@@ -150,25 +201,39 @@ class EndswithRule:
 
     __slots__ = ("msg", "ignorecase")
 
-    def __init__(self, msg: Tuple[str, ...], ignorecase: bool = False):
+    def __init__(self, msg: tuple[str, ...], ignorecase: bool = False):
         self.msg = msg
         self.ignorecase = ignorecase
 
-    async def __call__(
-        self, type: str = EventType(), text: str = EventPlainText()
-    ) -> Any:
-        if type != "message":
-            return False
-        return bool(
-            re.search(
-                f"(?:{'|'.join(re.escape(prefix) for prefix in self.msg)})$",
-                text,
-                re.IGNORECASE if self.ignorecase else 0,
-            )
+    def __repr__(self) -> str:
+        return f"Endswith(msg={self.msg}, ignorecase={self.ignorecase})"
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, EndswithRule)
+            and frozenset(self.msg) == frozenset(other.msg)
+            and self.ignorecase == other.ignorecase
         )
 
+    def __hash__(self) -> int:
+        return hash((frozenset(self.msg), self.ignorecase))
 
-def endswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule:
+    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:
     """匹配消息纯文本结尾。
 
     参数:
@@ -191,20 +256,38 @@ 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)
+    def __init__(self, msg: tuple[str, ...], ignorecase: bool = False):
+        self.msg = tuple(map(str.casefold, msg) if ignorecase else msg)
         self.ignorecase = ignorecase
 
-    async def __call__(
-        self, type_: str = EventType(), text: str = EventPlainText()
-    ) -> bool:
+    def __repr__(self) -> str:
+        return f"Fullmatch(msg={self.msg}, ignorecase={self.ignorecase})"
+
+    def __eq__(self, other: object) -> bool:
         return (
-            type_ == "message"
-            and (text.casefold() if self.ignorecase else text) in self.msg
+            isinstance(other, FullmatchRule)
+            and frozenset(self.msg) == frozenset(other.msg)
+            and self.ignorecase == other.ignorecase
         )
 
+    def __hash__(self) -> int:
+        return hash((frozenset(self.msg), self.ignorecase))
 
-def fullmatch(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule:
+    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 +312,28 @@ class KeywordsRule:
     def __init__(self, *keywords: str):
         self.keywords = keywords
 
-    async def __call__(
-        self, type: str = EventType(), text: str = EventPlainText()
-    ) -> bool:
-        if type != "message":
+    def __repr__(self) -> str:
+        return f"Keywords(keywords={self.keywords})"
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, KeywordsRule) and frozenset(
+            self.keywords
+        ) == frozenset(other.keywords)
+
+    def __hash__(self) -> int:
+        return hash(frozenset(self.keywords))
+
+    async def __call__(self, event: Event, state: T_State) -> bool:
+        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 +351,49 @@ class CommandRule:
 
     参数:
         cmds: 指定命令元组列表
+        force_whitespace: 是否强制命令后必须有指定空白符
     """
 
-    __slots__ = ("cmds",)
+    __slots__ = ("cmds", "force_whitespace")
 
-    def __init__(self, cmds: List[Tuple[str, ...]]):
-        self.cmds = cmds
+    def __init__(
+        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:
-        return cmd in self.cmds
+    def __repr__(self) -> str:
+        return f"Command(cmds={self.cmds})"
 
-    def __repr__(self):
-        return f"<Command {self.cmds}>"
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, CommandRule) and frozenset(self.cmds) == frozenset(
+            other.cmds
+        )
+
+    def __hash__(self) -> int:
+        return hash((frozenset(self.cmds),))
+
+    async def __call__(
+        self,
+        cmd: Optional[tuple[str, ...]] = Command(),
+        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 +405,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` 开头的消息
@@ -293,7 +421,7 @@ def command(*cmds: Union[str, Tuple[str, ...]]) -> Rule:
     config = get_driver().config
     command_start = config.command_start
     command_sep = config.command_sep
-    commands: List[Tuple[str, ...]] = []
+    commands: list[tuple[str, ...]] = []
     for command in cmds:
         if isinstance(command, str):
             command = (command,)
@@ -309,36 +437,87 @@ 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):
-        old_message: str = getattr(self, "message", "")
-        if old_message:
-            old_message += "\n"
-        old_message += message
-        setattr(self, "message", old_message)
+    if TYPE_CHECKING:
 
-    def exit(self, status: int = 0, message: Optional[str] = None):
-        raise ParserExit(
-            status=status, message=message or getattr(self, "message", None)
-        )
+        @overload
+        def parse_known_args(
+            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(  # pyright: ignore[reportIncompatibleMethodOverride]
+            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,
-        namespace: Optional[Namespace] = None,
-    ) -> Namespace:
-        setattr(self, "message", "")
-        return super().parse_args(args=args, namespace=namespace)  # type: ignore
+        args: Optional[Sequence[Union[str, MessageSegment]]] = None,
+        namespace: Optional[T] = None,
+    ) -> Union[Namespace, T]:
+        result, argv = self.parse_known_args(args, namespace)
+        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:
@@ -351,44 +530,71 @@ class ShellCommandRule:
 
     __slots__ = ("cmds", "parser")
 
-    def __init__(self, cmds: List[Tuple[str, ...]], parser: Optional[ArgumentParser]):
-        self.cmds = cmds
+    def __init__(self, cmds: list[tuple[str, ...]], parser: Optional[ArgumentParser]):
+        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(),
+        cmd: Optional[tuple[str, ...]] = Command(),
         msg: Optional[Message] = CommandArg(),
     ) -> bool:
-        if cmd in self.cmds and msg is not None:
-            message = str(msg)
-            state[SHELL_ARGV] = shlex.split(message)
-            if self.parser:
-                try:
-                    args = self.parser.parse_args(state[SHELL_ARGV])
-                    state[SHELL_ARGS] = args
-                except ParserExit as e:
-                    state[SHELL_ARGS] = e
-            return True
-        else:
+        if cmd not in self.cmds or msg is None:
             return False
 
+        state[SHELL_ARGV] = list(
+            chain.from_iterable(
+                shlex.split(str(seg)) if cast(MessageSegment, seg).is_text() else (seg,)
+                for seg in msg
+            )
+        )
+
+        if self.parser:
+            t = parser_message.set("")
+            try:
+                args = self.parser.parse_args(state[SHELL_ARGV])
+                state[SHELL_ARGS] = args
+            except ArgumentError as e:
+                state[SHELL_ARGS] = ParserExit(status=2, message=str(e))
+            except ParserExit as e:
+                state[SHELL_ARGS] = e
+            finally:
+                parser_message.reset(t)
+        return True
+
 
 def shell_command(
-    *cmds: Union[str, Tuple[str, ...]], parser: Optional[ArgumentParser] = None
+    *cmds: Union[str, tuple[str, ...]], parser: Optional[ArgumentParser] = None
 ) -> Rule:
     """匹配 `shell_like` 形式的消息命令。
 
     根据配置里提供的 {ref}``command_start` <nonebot.config.Config.command_start>`,
     {ref}``command_sep` <nonebot.config.Config.command_sep>` 判断消息是否为命令。
 
-    可以通过 {ref}`nonebot.params.Command` 获取匹配成功的命令（例: `("test",)`），
-    通过 {ref}`nonebot.params.RawCommand` 获取匹配成功的原始命令文本（例: `"/test"`），
-    通过 {ref}`nonebot.params.ShellCommandArgv` 获取解析前的参数列表（例: `["arg", "-h"]`），
-    通过 {ref}`nonebot.params.ShellCommandArgs` 获取解析后的参数字典（例: `{"arg": "arg", "h": True}`）。
+    可以通过 {ref}`nonebot.params.Command` 获取匹配成功的命令
+    （例: `("test",)`），
+    通过 {ref}`nonebot.params.RawCommand` 获取匹配成功的原始命令文本
+    （例: `"/test"`），
+    通过 {ref}`nonebot.params.ShellCommandArgv` 获取解析前的参数列表
+    （例: `["arg", "-h"]`），
+    通过 {ref}`nonebot.params.ShellCommandArgs` 获取解析后的参数字典
+    （例: `{"arg": "arg", "h": True}`）。
 
-    :::warning 警告
+    :::caution 警告
     如果参数解析失败，则通过 {ref}`nonebot.params.ShellCommandArgs`
     获取的将是 {ref}`nonebot.exception.ParserExit` 异常。
     :::
@@ -398,7 +604,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
@@ -419,7 +626,7 @@ def shell_command(
     config = get_driver().config
     command_start = config.command_start
     command_sep = config.command_sep
-    commands: List[Tuple[str, ...]] = []
+    commands: list[tuple[str, ...]] = []
     for command in cmds:
         if isinstance(command, str):
             command = (command,)
@@ -452,19 +659,26 @@ class RegexRule:
         self.regex = regex
         self.flags = flags
 
-    async def __call__(
-        self,
-        state: T_State,
-        type: str = EventType(),
-        msg: Message = EventMessage(),
-    ) -> bool:
-        if type != "message":
+    def __repr__(self) -> str:
+        return f"Regex(regex={self.regex!r}, flags={self.flags})"
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, RegexRule)
+            and self.regex == other.regex
+            and self.flags == other.flags
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.regex, self.flags))
+
+    async def __call__(self, event: Event, state: T_State) -> bool:
+        try:
+            msg = event.get_message()
+        except Exception:
             return False
-        matched = re.search(self.regex, str(msg), self.flags)
-        if matched:
-            state[REGEX_MATCHED] = matched.group()
-            state[REGEX_GROUP] = matched.groups()
-            state[REGEX_DICT] = matched.groupdict()
+        if matched := re.search(self.regex, str(msg), self.flags):
+            state[REGEX_MATCHED] = matched
             return True
         else:
             return False
@@ -473,7 +687,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 +700,8 @@ def regex(regex: str, flags: Union[int, re.RegexFlag] = 0) -> Rule:
     :::
 
     :::tip 提示
-    正则表达式匹配使用 `EventMessage` 的 `str` 字符串，而非 `EventMessage` 的 `PlainText` 纯文本字符串
+    正则表达式匹配使用 `EventMessage` 的 `str` 字符串，
+    而非 `EventMessage` 的 `PlainText` 纯文本字符串
     :::
     """
 
@@ -498,6 +713,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 +732,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,26 +1,23 @@
 """本模块定义了 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 模块
 """
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    Union,
-    TypeVar,
-    Callable,
-    Optional,
-    Awaitable,
-)
+
+import sys
+import types
+import warnings
+import contextlib
+import typing as t
+import typing_extensions as t_ext
+from typing import TYPE_CHECKING, TypeVar
+from typing_extensions import ParamSpec, TypeAlias, get_args, override, get_origin
 
 if TYPE_CHECKING:
     from asyncio import Task
@@ -28,23 +25,98 @@ 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 = t.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:
-        assert func.__name__ in dir(InterfaceClass), f"Error method: {func.__name__}"
-        return func
-
-    return overrider
+    warnings.warn(
+        "overrides is deprecated and will be removed in a future version, "
+        "use @typing_extensions.override instead. "
+        "See [PEP 698](https://peps.python.org/pep-0698/) for more details.",
+        DeprecationWarning,
+    )
+    return override
 
 
-T_State = Dict[Any, Any]
+if sys.version_info < (3, 10):
+
+    def type_has_args(type_: type[t.Any]) -> bool:
+        """判断类型是否有参数"""
+        return isinstance(type_, (t._GenericAlias, types.GenericAlias))  # type: ignore
+
+else:
+
+    def type_has_args(type_: type[t.Any]) -> bool:
+        return isinstance(type_, (t._GenericAlias, types.GenericAlias, types.UnionType))  # type: ignore
+
+
+if sys.version_info < (3, 10):
+
+    def origin_is_union(origin: t.Optional[type[t.Any]]) -> bool:
+        """判断是否是 Union 类型"""
+        return origin is t.Union
+
+else:
+
+    def origin_is_union(origin: t.Optional[type[t.Any]]) -> bool:
+        return origin is t.Union or origin is types.UnionType
+
+
+def origin_is_literal(origin: t.Optional[type[t.Any]]) -> bool:
+    """判断是否是 Literal 类型"""
+    return origin is t.Literal or origin is t_ext.Literal
+
+
+def _literal_values(type_: type[t.Any]) -> tuple[t.Any, ...]:
+    return get_args(type_)
+
+
+def all_literal_values(type_: type[t.Any]) -> list[t.Any]:
+    """获取 Literal 类型包含的所有值"""
+    if not origin_is_literal(get_origin(type_)):
+        return [type_]
+
+    return [x for value in _literal_values(type_) for x in all_literal_values(value)]
+
+
+def origin_is_annotated(origin: t.Optional[type[t.Any]]) -> bool:
+    """判断是否是 Annotated 类型"""
+    with contextlib.suppress(TypeError):
+        return origin is not None and issubclass(origin, t_ext.Annotated)
+    return False
+
+
+NONE_TYPES = {None, type(None), t.Literal[None], t_ext.Literal[None]}
+if sys.version_info >= (3, 10):
+    NONE_TYPES.add(types.NoneType)
+
+
+def is_none_type(type_: type[t.Any]) -> bool:
+    """判断是否是 None 类型"""
+    return type_ in NONE_TYPES
+
+
+def evaluate_forwardref(
+    ref: t.ForwardRef, globalns: dict[str, t.Any], localns: dict[str, t.Any]
+) -> t.Any:
+    return ref._evaluate(globalns, localns, frozenset())
+
+
+# state
+T_State: TypeAlias = dict[t.Any, t.Any]
 """事件处理状态 State 类型"""
 
-T_BotConnectionHook = Callable[..., Awaitable[Any]]
+_DependentCallable: TypeAlias = t.Union[
+    t.Callable[..., T], t.Callable[..., t.Awaitable[T]]
+]
+
+# driver hooks
+T_BotConnectionHook: TypeAlias = _DependentCallable[t.Any]
 """Bot 连接建立时钩子函数
 
 依赖参数:
@@ -53,7 +125,7 @@ T_BotConnectionHook = Callable[..., Awaitable[Any]]
 - BotParam: Bot 对象
 - DefaultParam: 带有默认值的参数
 """
-T_BotDisconnectionHook = Callable[..., Awaitable[Any]]
+T_BotDisconnectionHook: TypeAlias = _DependentCallable[t.Any]
 """Bot 连接断开时钩子函数
 
 依赖参数:
@@ -62,14 +134,19 @@ T_BotDisconnectionHook = Callable[..., Awaitable[Any]]
 - BotParam: Bot 对象
 - DefaultParam: 带有默认值的参数
 """
-T_CallingAPIHook = Callable[["Bot", str, Dict[str, Any]], Awaitable[Any]]
+
+# api hooks
+T_CallingAPIHook: TypeAlias = t.Callable[
+    ["Bot", str, dict[str, t.Any]], t.Awaitable[t.Any]
+]
 """`bot.call_api` 钩子函数"""
-T_CalledAPIHook = Callable[
-    ["Bot", Optional[Exception], str, Dict[str, Any], Any], Awaitable[Any]
+T_CalledAPIHook: TypeAlias = t.Callable[
+    ["Bot", t.Optional[Exception], str, dict[str, t.Any], t.Any], t.Awaitable[t.Any]
 ]
 """`bot.call_api` 后执行的函数，参数分别为 bot, exception, api, data, result"""
 
-T_EventPreProcessor = Callable[..., Union[Any, Awaitable[Any]]]
+# event hooks
+T_EventPreProcessor: TypeAlias = _DependentCallable[t.Any]
 """事件预处理函数 EventPreProcessor 类型
 
 依赖参数:
@@ -80,8 +157,8 @@ T_EventPreProcessor = Callable[..., Union[Any, Awaitable[Any]]]
 - StateParam: State 对象
 - DefaultParam: 带有默认值的参数
 """
-T_EventPostProcessor = Callable[..., Union[Any, Awaitable[Any]]]
-"""事件预处理函数 EventPostProcessor 类型
+T_EventPostProcessor: TypeAlias = _DependentCallable[t.Any]
+"""事件后处理函数 EventPostProcessor 类型
 
 依赖参数:
 
@@ -91,7 +168,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[t.Any]
 """事件响应器运行前预处理函数 RunPreProcessor 类型
 
 依赖参数:
@@ -103,8 +182,8 @@ T_RunPreProcessor = Callable[..., Union[Any, Awaitable[Any]]]
 - MatcherParam: Matcher 对象
 - DefaultParam: 带有默认值的参数
 """
-T_RunPostProcessor = Callable[..., Union[Any, Awaitable[Any]]]
-"""事件响应器运行前预处理函数 RunPostProcessor 类型
+T_RunPostProcessor: TypeAlias = _DependentCallable[t.Any]
+"""事件响应器运行后后处理函数 RunPostProcessor 类型
 
 依赖参数:
 
@@ -117,7 +196,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 +208,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 +219,11 @@ T_PermissionChecker = Callable[..., Union[bool, Awaitable[bool]]]
 - DefaultParam: 带有默认值的参数
 """
 
-T_Handler = Callable[..., Any]
+T_Handler: TypeAlias = _DependentCallable[t.Any]
 """Handler 处理函数。"""
-T_TypeUpdater = Callable[..., Union[str, Awaitable[str]]]
-"""TypeUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新响应的事件类型。默认会更新为 `message`。
+T_TypeUpdater: TypeAlias = _DependentCallable[str]
+"""TypeUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新响应的事件类型。
+默认会更新为 `message`。
 
 依赖参数:
 
@@ -153,8 +234,9 @@ T_TypeUpdater = Callable[..., Union[str, Awaitable[str]]]
 - MatcherParam: Matcher 对象
 - DefaultParam: 带有默认值的参数
 """
-T_PermissionUpdater = Callable[..., Union["Permission", Awaitable["Permission"]]]
-"""PermissionUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新会话对象权限。默认会更新为当前事件的触发对象。
+T_PermissionUpdater: TypeAlias = _DependentCallable["Permission"]
+"""PermissionUpdater 在 Matcher.pause, Matcher.reject 时被运行，用于更新会话对象权限。
+默认会更新为当前事件的触发对象。
 
 依赖参数:
 
@@ -165,5 +247,5 @@ T_PermissionUpdater = Callable[..., Union["Permission", Awaitable["Permission"]]
 - MatcherParam: Matcher 对象
 - DefaultParam: 带有默认值的参数
 """
-T_DependencyCache = Dict[Callable[..., Any], "Task[Any]"]
+T_DependencyCache: TypeAlias = dict[_DependentCallable[t.Any], "Task[t.Any]"]
 """依赖缓存, 用于存储依赖函数的返回值"""

nonebot/utils.py

@@ -9,27 +9,28 @@ import re
 import json
 import asyncio
 import inspect
+import importlib
+import contextlib
 import dataclasses
+from pathlib import Path
+from collections import deque
+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 import (
-    Any,
-    Type,
-    Tuple,
-    Union,
-    TypeVar,
-    Callable,
-    Optional,
-    Coroutine,
-    AsyncGenerator,
-    ContextManager,
-)
+from contextlib import AbstractContextManager, asynccontextmanager
+from typing_extensions import ParamSpec, get_args, override, get_origin
+from collections.abc import Mapping, Sequence, Coroutine, AsyncGenerator
+from typing import Any, Union, Generic, TypeVar, Callable, Optional, overload
 
-from pydantic.typing import is_union, is_none_type
+from pydantic import BaseModel
 
 from nonebot.log import logger
-from nonebot.typing import overrides
+from nonebot.typing import (
+    is_none_type,
+    type_has_args,
+    origin_is_union,
+    origin_is_literal,
+    all_literal_values,
+)
 
 P = ParamSpec("P")
 R = TypeVar("R")
@@ -49,27 +50,96 @@ def escape_tag(s: str) -> str:
     return re.sub(r"</?((?:[fb]g\s)?[^<>\s]*)>", r"\\\g<0>", s)
 
 
+def deep_update(
+    mapping: dict[K, Any], *updating_mappings: dict[K, Any]
+) -> dict[K, Any]:
+    """深度更新合并字典"""
+    updated_mapping = mapping.copy()
+    for updating_mapping in updating_mappings:
+        for k, v in updating_mapping.items():
+            if (
+                k in updated_mapping
+                and isinstance(updated_mapping[k], dict)
+                and isinstance(v, dict)
+            ):
+                updated_mapping[k] = deep_update(updated_mapping[k], v)
+            else:
+                updated_mapping[k] = v
+    return updated_mapping
+
+
+def lenient_issubclass(
+    cls: Any, class_or_tuple: Union[type[Any], tuple[type[Any], ...]]
+) -> bool:
+    """检查 cls 是否是 class_or_tuple 中的一个类型子类并忽略类型错误。"""
+    try:
+        return isinstance(cls, type) and issubclass(cls, class_or_tuple)
+    except TypeError:
+        return False
+
+
 def generic_check_issubclass(
-    cls: Any, class_or_tuple: Union[Type[Any], Tuple[Type[Any], ...]]
+    cls: Any, class_or_tuple: Union[type[Any], tuple[type[Any], ...]]
 ) -> 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.Literal` 类型，
+      则会检查其中的所有值是否是 class_or_tuple 中一个类型的实例。
+    - 如果 cls 是 `typing.TypeVar` 类型，
+      则会检查其 `__bound__` 或 `__constraints__`
+      是否是 class_or_tuple 中一个类型的子类或 None。
     """
-    try:
-        return issubclass(cls, class_or_tuple)
-    except TypeError:
-        origin = get_origin(cls)
-        if is_union(origin):
+    if not type_has_args(cls):
+        with contextlib.suppress(TypeError):
+            return issubclass(cls, class_or_tuple)
+
+    origin = get_origin(cls)
+    if origin_is_union(origin):
+        return all(
+            is_none_type(type_) or generic_check_issubclass(type_, class_or_tuple)
+            for type_ in get_args(cls)
+        )
+    elif origin_is_literal(origin):
+        return all(
+            is_none_type(value) or isinstance(value, class_or_tuple)
+            for value in all_literal_values(cls)
+        )
+    # ensure generic List, Dict can be checked
+    elif origin:
+        # avoid class check error (typing.Final, typing.ClassVar, etc...)
+        try:
+            return issubclass(origin, class_or_tuple)
+        except TypeError:
+            return False
+    elif isinstance(cls, TypeVar):
+        if cls.__constraints__:
             return all(
                 is_none_type(type_) or generic_check_issubclass(type_, class_or_tuple)
-                for type_ in get_args(cls)
+                for type_ in cls.__constraints__
             )
-        elif origin:
-            return issubclass(origin, class_or_tuple)
+        elif cls.__bound__:
+            return generic_check_issubclass(cls.__bound__, class_or_tuple)
+    return False
+
+
+def type_is_complex(type_: type[Any]) -> bool:
+    """检查 type_ 是否是复杂类型"""
+    origin = get_origin(type_)
+    return _type_is_complex_inner(type_) or _type_is_complex_inner(origin)
+
+
+def _type_is_complex_inner(type_: Optional[type[Any]]) -> bool:
+    if lenient_issubclass(type_, (str, bytes)):
         return False
 
+    return lenient_issubclass(
+        type_, (BaseModel, Mapping, Sequence, tuple, set, frozenset, deque)
+    ) or dataclasses.is_dataclass(type_)
+
 
 def is_coroutine_callable(call: Callable[..., Any]) -> bool:
     """检查 call 是否是一个 callable 协程函数"""
@@ -108,7 +178,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
@@ -116,7 +187,7 @@ def run_sync(call: Callable[P, R]) -> Callable[P, Coroutine[None, None, R]]:
 
 @asynccontextmanager
 async def run_sync_ctx_manager(
-    cm: ContextManager[T],
+    cm: AbstractContextManager[T],
 ) -> AsyncGenerator[T, None]:
     """一个用于包装 sync context manager 为 async context manager 的执行函数"""
     try:
@@ -129,11 +200,38 @@ async def run_sync_ctx_manager(
         await run_sync(cm.__exit__)(None, None, None)
 
 
+@overload
 async def run_coro_with_catch(
     coro: Coroutine[Any, Any, T],
-    exc: Tuple[Type[Exception], ...],
-    return_on_err: R = None,
-) -> Union[T, R]:
+    exc: tuple[type[Exception], ...],
+    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 +245,45 @@ def get_name(obj: Any) -> str:
     return obj.__class__.__name__
 
 
-class DataclassEncoder(json.JSONEncoder):
-    """在JSON序列化 {re}`nonebot.adapters._message.Message` (List[Dataclass]) 时使用的 `JSONEncoder`"""
+def path_to_module_name(path: Path) -> str:
+    """转换路径为模块名"""
+    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 +299,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,31 @@
     "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/\"",
+    "lint": "yarn lint:js && yarn lint:style",
+    "lint:js": "eslint --cache --report-unused-disable-directives \"**/*.{js,jsx,ts,tsx,mjs}\"",
+    "lint:js:fix": "eslint --cache --report-unused-disable-directives --fix \"**/*.{js,jsx,ts,tsx,mjs}\"",
+    "lint:style": "stylelint \"**/*.css\"",
+    "lint:style:fix": "stylelint --fix \"**/*.css\"",
+    "pyright": "pyright"
   },
   "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^6.6.0",
+    "@typescript-eslint/parser": "^6.6.0",
     "cross-env": "^7.0.3",
-    "prettier": "^2.5.0"
+    "eslint": "^8.48.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-import-resolver-typescript": "^3.6.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-jsx-a11y": "^6.7.1",
+    "eslint-plugin-prettier": "^5.0.0",
+    "eslint-plugin-react": "^7.33.2",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-regexp": "^1.15.0",
+    "prettier": "^3.0.3",
+    "pyright": "^1.1.317",
+    "stylelint": "^15.10.3",
+    "stylelint-config-standard": "^34.0.0",
+    "stylelint-prettier": "^4.0.2"
   }
 }