🔖 Release 2.4.0

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Komorebi <110453675+KomoriDev@users.noreply.github.com>
Co-authored-by: Ju4tCode <42488585+yanyongyu@users.noreply.github.com>

.devcontainer/devcontainer.json

@@ -9,13 +9,12 @@
     "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.fixAll.ruff": "explicit",
-            "source.organizeImports": true
+            "source.organizeImports": "explicit"
           }
         },
         "[javascript]": {

.github/FUNDING.yml

@@ -1,2 +1,2 @@
 open_collective: nonebot
-custom: ["https://afdian.net/@nonebot"]
+custom: ["https://afdian.com/@nonebot"]

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

@@ -25,7 +25,6 @@ runs:
     - uses: actions/setup-python@v5
       with:
         python-version: ${{ inputs.python-version }}
-        architecture: "x64"
         cache: "poetry"
         cache-dependency-path: |
           ./poetry.lock

.github/dependabot.yml

@@ -35,3 +35,12 @@ updates:
       actions:
         patterns:
           - "*"
+
+  - package-ecosystem: devcontainers
+    directory: "/"
+    schedule:
+      interval: daily
+    groups:
+      devcontainers:
+        patterns:
+          - "*"

.github/workflows/codecov.yml

@@ -23,11 +23,11 @@ jobs:
       group: test-coverage-${{ github.ref }}-${{ matrix.os }}-${{ matrix.python-version }}-${{ matrix.env }}
       cancel-in-progress: true
     strategy:
+      fail-fast: false
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
         os: [ubuntu-latest, windows-latest, macos-latest]
         env: [pydantic-v1, pydantic-v2]
-      fail-fast: false
     env:
       OS: ${{ matrix.os }}
       PYTHON_VERSION: ${{ matrix.python-version }}

.github/workflows/noneflow.yml

@@ -15,9 +15,10 @@ concurrency:
   cancel-in-progress: false
 
 jobs:
-  plugin_test:
+  check:
     runs-on: ubuntu-latest
-    name: nonebot2 plugin test
+    name: check
+    # do not run on forked PRs, do not run on not related issues, do not run on pr comments
     if: |
       !(
         (
@@ -35,6 +36,46 @@ jobs:
           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:

.github/workflows/release-drafter.yml

@@ -40,7 +40,7 @@ jobs:
       - name: Update Changelog
         uses: docker://ghcr.io/nonebot/auto-changelog:master
         with:
-          changelog_file: website/src/pages/changelog.md
+          changelog_file: website/src/changelog/changelog.md
           latest_changes_position: '# 更新日志\n\n'
           latest_changes_title: "## 最近更新"
           replace_regex: '(?<=## 最近更新\n)[\s\S]*?(?=\n## )'

.github/workflows/release.yml

@@ -32,7 +32,7 @@ jobs:
       - name: Archive Changelog
         uses: docker://ghcr.io/nonebot/auto-changelog:master
         with:
-          changelog_file: website/src/pages/changelog.md
+          changelog_file: website/src/changelog/changelog.md
           archive_regex: '(?<=## )最近更新(?=\n)'
           archive_title: ${{ env.TAG_NAME }}
           commit_and_push: false

.github/workflows/website-deploy.yml

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

.github/workflows/website-preview-cd.yml

@@ -0,0 +1,99 @@
+name: Site Deploy (Preview CD)
+
+on:
+  workflow_run:
+    workflows: ["Site Deploy (Preview CI)"]
+    types:
+      - completed
+
+jobs:
+  preview-cd:
+    runs-on: ubuntu-latest
+    concurrency:
+      group: pull-request-preview-${{ github.event.workflow_run.head_repository.full_name }}-${{ github.event.workflow_run.head_branch }}
+      cancel-in-progress: true
+
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
+
+    environment: pull request
+
+    permissions:
+      actions: read
+      statuses: write
+      pull-requests: write
+
+    steps:
+      - name: Set Commit Status
+        uses: actions/github-script@v7
+        with:
+          script: |
+            github.rest.repos.createCommitStatus({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              sha: context.payload.workflow_run.head_sha,
+              context: 'Website Preview',
+              description: 'Deploying...',
+              state: 'pending',
+            })
+
+      - name: Download Artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: website-preview
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+          run-id: ${{ github.event.workflow_run.id }}
+
+      - name: Restore Context
+        run: |
+          cat action.env >> $GITHUB_ENV
+
+      - name: Set Deploy Name
+        run: |
+          echo "DEPLOY_NAME=deploy-preview-${{ env.PR_NUMBER }}" >> $GITHUB_ENV
+
+      - name: Deploy to Netlify
+        id: deploy
+        uses: nwtgck/actions-netlify@v3
+        with:
+          publish-dir: ./website/build
+          production-deploy: false
+          deploy-message: "Deploy ${{ env.DEPLOY_NAME }}@${{ github.event.workflow_run.head_sha }}"
+          alias: ${{ env.DEPLOY_NAME }}
+        env:
+          NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }}
+          NETLIFY_SITE_ID: ${{ secrets.SITE_ID }}
+
+      # action netlify has no pull request context, so we need to comment by ourselves
+      - name: Comment on Pull Request
+        uses: marocchino/sticky-pull-request-comment@v2
+        with:
+          header: website
+          number: ${{ env.PR_NUMBER }}
+          message: |
+            :rocket: Deployed to ${{ steps.deploy.outputs.deploy-url }}
+
+      - name: Set Commit Status
+        uses: actions/github-script@v7
+        if: always()
+        with:
+          script: |
+            if (`${{ job.status }}` === 'success') {
+              github.rest.repos.createCommitStatus({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                sha: context.payload.workflow_run.head_sha,
+                context: 'Website Preview',
+                description: `Deployed to ${{ steps.deploy.outputs.deploy-url }}`,
+                state: 'success',
+                target_url: `${{ steps.deploy.outputs.deploy-url }}`,
+              })
+            } else {
+              github.rest.repos.createCommitStatus({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                sha: context.payload.workflow_run.head_sha,
+                context: 'Website Preview',
+                description: `Deploy ${{ job.status }}`,
+                state: 'failure',
+              })
+            }

.github/workflows/website-preview-ci.yml

@@ -0,0 +1,42 @@
+name: Site Deploy (Preview CI)
+
+on:
+  pull_request:
+
+jobs:
+  preview-ci:
+    runs-on: ubuntu-latest
+    concurrency:
+      group: pull-request-preview-${{ github.event.number }}
+      cancel-in-progress: true
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+          fetch-depth: 0
+
+      - name: Setup Python Environment
+        uses: ./.github/actions/setup-python
+
+      - name: Setup Node Environment
+        uses: ./.github/actions/setup-node
+
+      - name: Build API Doc
+        uses: ./.github/actions/build-api-doc
+
+      - name: Build Doc
+        run: yarn build
+
+      - name: Export Context
+        run: |
+          echo "PR_NUMBER=${{ github.event.number }}" >> ./action.env
+
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: website-preview
+          path: |
+            ./website/build
+            ./action.env
+          retention-days: 1

.github/workflows/website-preview.yml

@@ -1,46 +0,0 @@
-name: Site Deploy(Preview)
-
-on:
-  pull_request_target:
-
-jobs:
-  preview:
-    runs-on: ubuntu-latest
-    concurrency:
-      group: pull-request-preview-${{ github.event.number }}
-      cancel-in-progress: true
-
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-          fetch-depth: 0
-
-      - name: Setup Python Environment
-        uses: ./.github/actions/setup-python
-
-      - name: Setup Node Environment
-        uses: ./.github/actions/setup-node
-
-      - name: Build API Doc
-        uses: ./.github/actions/build-api-doc
-
-      - name: Build Doc
-        run: yarn build
-
-      - name: Get Deploy Name
-        run: |
-          echo "DEPLOY_NAME=deploy-preview-${{ github.event.number }}" >> $GITHUB_ENV
-
-      - name: Deploy to Netlify
-        uses: nwtgck/actions-netlify@v2
-        with:
-          publish-dir: "./website/build"
-          production-deploy: false
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          deploy-message: "Deploy ${{ env.DEPLOY_NAME }}@${{ github.sha }}"
-          enable-commit-comment: false
-          alias: ${{ env.DEPLOY_NAME }}
-        env:
-          NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }}
-          NETLIFY_SITE_ID: ${{ secrets.SITE_ID }}

.gitignore

@@ -7,6 +7,7 @@ docs_build/_build
 !tests/.env
 .docusaurus
 website/docs/api/**/*.md
+website/src/pages/changelog/**/*
 
 # Created by https://www.toptal.com/developers/gitignore/api/python,node,visualstudiocode,jetbrains,macos,windows,linux
 # Edit at https://www.toptal.com/developers/gitignore?templates=python,node,visualstudiocode,jetbrains,macos,windows,linux

.pre-commit-config.yaml

@@ -7,30 +7,23 @@ ci:
   autoupdate_commit_msg: ":arrow_up: auto update by pre-commit hooks"
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.2.0
+    rev: v0.7.1
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]
-        stages: [commit]
+        stages: [pre-commit]
 
   - repo: https://github.com/pycqa/isort
     rev: 5.13.2
     hooks:
       - id: isort
-        stages: [commit]
+        stages: [pre-commit]
 
   - repo: https://github.com/psf/black
-    rev: 24.1.1
+    rev: 24.10.0
     hooks:
       - id: black
-        stages: [commit]
+        stages: [pre-commit]
-
-  - repo: https://github.com/pre-commit/mirrors-prettier
-    rev: v4.0.0-alpha.8
-    hooks:
-      - id: prettier
-        types_or: [javascript, jsx, ts, tsx, markdown, yaml, json]
-        stages: [commit]
 
   - repo: https://github.com/nonebot/nonemoji
     rev: v0.1.4

CHANGELOG.md

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

README.md

@@ -21,7 +21,7 @@ _✨ 跨平台 Python 异步机器人框架 ✨_
   <a href="https://pypi.python.org/pypi/nonebot2">
     <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.8+-blue?logo=python&logoColor=edb641" 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>
@@ -110,26 +110,29 @@ NoneBot2 是一个现代、跨平台、可扩展的 Python 聊天机器人框架
 - 社区丰富：社区用户众多，直接和间接用户超过十万人，每天都有大量的活跃用户 ([社区资源](#社区资源))
 - 海纳百川：一个框架，支持多个聊天软件平台，可自定义通信协议
 
-  |                                                           协议名称                                                           | 状态 |                                   注释                                    |
+  |                                                       协议名称                                                        | 状态 |                                   注释                                    |
-  | :--------------------------------------------------------------------------------------------------------------------------: | :--: | :-----------------------------------------------------------------------: |
+  | :-------------------------------------------------------------------------------------------------------------------: | :--: | :-----------------------------------------------------------------------: |
-  |                   OneBot（[仓库](https://github.com/nonebot/adapter-onebot)，[协议](https://onebot.dev/)）                   |  ✅  | 支持 QQ、TG、微信公众号、KOOK 等[平台](https://onebot.dev/ecosystem.html) |
+  |               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)）          |  ✅  |                                                                           |
+  |      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)）         |  ✅  |                                                                           |
+  |     飞书（[仓库](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                           |
+  |         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 官方接口调整较多                            |
+  |                QQ（[仓库](https://github.com/nonebot/adapter-qq)，[协议](https://bot.q.qq.com/wiki/)）                |  ✅  |                            QQ 官方接口调整较多                            |
-  |             钉钉（[仓库](https://github.com/nonebot/adapter-ding)，[协议](https://open.dingtalk.com/document/)）             |  🤗  |                        寻找 Maintainer（暂不可用）                        |
+  |                             Console（[仓库](https://github.com/nonebot/adapter-console)）                             |  ✅  |                                控制台交互                                 |
-  |                                Console（[仓库](https://github.com/nonebot/adapter-console)）                                 |  ✅  |                                控制台交互                                 |
+  |     Red（[仓库](https://github.com/nonebot/adapter-red)，[协议](https://chrononeko.github.io/QQNTRedProtocol/)）      |  ✅  |                                  QQ 协议                                  |
-  |        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 等                |
-  |               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 协议                              |
-  |      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 协议                               |
-  |                  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/Tian-que/nonebot-adapter-kaiheila)，[协议](https://developer.kookapp.cn/)）         |  ↗️  |                                由社区贡献                                 |
+  |    Mirai（[仓库](https://github.com/nonebot/adapter-mirai)，[协议](https://docs.mirai.mamoe.net/mirai-api-http/)）    |  ✅  |                                  QQ 协议                                  |
-  |    Mirai（[仓库](https://github.com/ieew/nonebot_adapter_mirai2)，[协议](https://docs.mirai.mamoe.net/mirai-api-http/)）     |  ↗️  |                            QQ 协议，由社区贡献                            |
+  |         钉钉（[仓库](https://github.com/nonebot/adapter-ding)，[协议](https://open.dingtalk.com/document/)）          |  🤗  |                        寻找 Maintainer（暂不可用）                        |
-  |                              Ntchat（[仓库](https://github.com/JustUndertaker/adapter-ntchat)）                              |  ↗️  |                           微信协议，由社区贡献                            |
+  |     开黑啦（[仓库](https://github.com/Tian-que/nonebot-adapter-kaiheila)，[协议](https://developer.kookapp.cn/)）     |  ↗️  |                                由社区贡献                                 |
-  |                         MineCraft（[仓库](https://github.com/17TheWord/nonebot-adapter-minecraft)）                          |  ↗️  |                                由社区贡献                                 |
+  |                          Ntchat（[仓库](https://github.com/JustUndertaker/adapter-ntchat)）                           |  ↗️  |                           微信协议，由社区贡献                            |
-  |                             BiliBili Live（[仓库](https://github.com/wwweww/adapter-bilibili)）                              |  ↗️  |                                由社区贡献                                 |
+  |                      MineCraft（[仓库](https://github.com/17TheWord/nonebot-adapter-minecraft)）                      |  ↗️  |                                由社区贡献                                 |
-  |                          Walle-Q（[仓库](https://github.com/onebot-walle/nonebot_adapter_walleq)）                           |  ↗️  |                            QQ 协议，由社区贡献                            |
+  |                          BiliBili Live（[仓库](https://github.com/wwweww/adapter-bilibili)）                          |  ↗️  |                                由社区贡献                                 |
-  | Villa（[仓库](https://github.com/CMHopeSunshine/nonebot-adapter-villa)，[协议](https://webstatic.mihoyo.com/vila/bot/doc/)） |  ↗️  |                     米游社大别野 Bot 协议，由社区贡献                     |
+  |                       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 协议，由社区贡献                      |
+  |     Tailchat（[仓库](https://github.com/eya46/nonebot-adapter-tailchat)，[协议](https://tailchat.msgbyte.com/)）      |  ↗️  |                  Tailchat 开放平台 Bot 协议，由社区贡献                   |
 
 - 坚实后盾：支持多种 web 框架，可自定义替换、组合
 

assets/adapters.json

@@ -60,14 +60,14 @@
     "is_official": false
   },
   {
-    "module_name": "nonebot.adapters.mirai2",
+    "module_name": "nonebot.adapters.mirai",
-    "project_link": "nonebot_adapter_mirai2",
+    "project_link": "nonebot-adapter-mirai",
-    "name": "mirai2",
+    "name": "Mirai",
-    "desc": "为 nonebot2 添加 mirai_api_http2.x的兼容适配器",
+    "desc": "mirai-api-http v2 协议适配",
-    "author": "ieew",
+    "author": "RF-Tar-Railt",
-    "homepage": "https://github.com/ieew/nonebot_adapter_mirai2",
+    "homepage": "https://github.com/nonebot/adapter-mirai",
     "tags": [],
-    "is_official": false
+    "is_official": true
   },
   {
     "module_name": "nonebot.adapters.onebot.v12",
@@ -213,5 +213,40 @@
     "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
+  },
+  {
+    "module_name": "nonebot_adapter_tailchat",
+    "project_link": "nonebot-adapter-tailchat",
+    "name": "Tailchat",
+    "desc": "Tailchat 适配器",
+    "author": "eya46",
+    "homepage": "https://github.com/eya46/nonebot-adapter-tailchat",
+    "tags": [],
+    "is_official": false
   }
 ]

assets/bots.json

@@ -607,5 +607,55 @@
       }
     ],
     "is_official": false
+  },
+  {
+    "name": "星辰 Bot",
+    "desc": "欢迎使用 星辰 Bot 项目！这是一款基于 NoneBot2 打造的智能 QQ 机器人，旨在为用户提供丰富的功能体验。无论是获取一言的灵感，探索历史上的今天，还是穿梭60s世界，星辰 Bot 为您打开了全新的交流之门。快来尝试吧！",
+    "author": "StarXinXin",
+    "homepage": "https://github.com/StarXinXin/StarsBot",
+    "tags": [],
+    "is_official": false
+  },
+  {
+    "name": "Minecraft_QQBot",
+    "desc": "基于 NoneBot2 的 Minecraft 群服互联 QQ 机器人，支持多服务器多种方式连接。",
+    "author": "Lonely-Sails",
+    "homepage": "https://github.com/Minecraft-QQBot/BotServer",
+    "tags": [
+      {
+        "label": "Minecraft",
+        "color": "#ea5252"
+      },
+      {
+        "label": "娱乐",
+        "color": "#37a7e7"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "小安提Bot",
+    "desc": "服务于音游 舞萌DX 的多功能Bot",
+    "author": "Ant1816",
+    "homepage": "https://github.com/Ant1816/Ant1Bot",
+    "tags": [
+      {
+        "label": "maimaiDX",
+        "color": "#52ea9a"
+      },
+      {
+        "label": "音游",
+        "color": "#f74b18"
+      }
+    ],
+    "is_official": false
+  },
+  {
+    "name": "CanrotBot",
+    "desc": "有很多实用功能的bot，也有很多没什么用的娱乐功能；接入了大模型，并且有一部分功能可以被大模型调用。主打一个全都有（",
+    "author": "wangyw15",
+    "homepage": "https://github.com/wangyw15/CanrotBot",
+    "tags": [],
+    "is_official": false
   }
 ]

envs/pydantic-v1/pyproject.toml

@@ -6,7 +6,7 @@ authors = ["yanyongyu <yyy@nonebot.dev>"]
 license = "MIT"
 
 [tool.poetry.dependencies]
-python = "^3.8"
+python = "^3.9"
 
 [tool.poetry.group.dev.dependencies]
 pydantic = "^1.0.0"

envs/pydantic-v2/pyproject.toml

@@ -6,7 +6,7 @@ authors = ["yanyongyu <yyy@nonebot.dev>"]
 license = "MIT"
 
 [tool.poetry.dependencies]
-python = "^3.8"
+python = "^3.9"
 
 [tool.poetry.group.dev.dependencies]
 pydantic = "^2.0.0"

envs/test/pyproject.toml

@@ -7,12 +7,12 @@ license = "MIT"
 packages = [{ include = "nonebot-test.py" }]
 
 [tool.poetry.dependencies]
-python = "^3.8"
+python = "^3.9"
-nonebug = "^0.3.0"
+trio = "^0.27.0"
+nonebug = "^0.4.1"
 wsproto = "^1.2.0"
-pytest-cov = "^4.0.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"
 

nonebot/__init__.py

@@ -39,16 +39,19 @@
 - `require` => {ref}``require` <nonebot.plugin.load.require>`
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 0
     description: nonebot 模块
 """
 
 import os
 from importlib.metadata import version
-from typing import Any, Dict, Type, Union, TypeVar, Optional, overload
+from typing import Any, Union, TypeVar, Optional, overload
 
 import loguru
 
+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
@@ -99,7 +102,7 @@ def get_adapter(name: str) -> Adapter:
 
 
 @overload
-def get_adapter(name: Type[A]) -> A:
+def get_adapter(name: type[A]) -> A:
     """
     参数:
         name: 适配器类型
@@ -109,7 +112,7 @@ def get_adapter(name: Type[A]) -> A:
     """
 
 
-def get_adapter(name: Union[str, Type[Adapter]]) -> Adapter:
+def get_adapter(name: Union[str, type[Adapter]]) -> Adapter:
     """获取已注册的 {ref}`nonebot.adapters.Adapter` 实例。
 
     异常:
@@ -130,7 +133,7 @@ def get_adapter(name: Union[str, Type[Adapter]]) -> Adapter:
     return adapters[target]
 
 
-def get_adapters() -> Dict[str, Adapter]:
+def get_adapters() -> dict[str, Adapter]:
     """获取所有已注册的 {ref}`nonebot.adapters.Adapter` 实例。
 
     返回:
@@ -229,7 +232,7 @@ 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` 对象。
 
     返回:
@@ -248,7 +251,7 @@ def get_bots() -> Dict[str, Bot]:
     return get_driver().bots
 
 
-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(
         drivers[0], "Driver", default_prefix="nonebot.drivers."
@@ -265,11 +268,12 @@ def _resolve_combine_expr(obj_str: str) -> Type[Driver]:
 
 
 def _log_patcher(record: "loguru.Record"):
+    """使用插件标识优化日志展示"""
     record["name"] = (
-        plugin.name
+        plugin.id_
         if (module_name := record["name"])
         and (plugin := get_plugin_by_module_name(module_name))
-        else (module_name and module_name.split(".")[0])
+        else (module_name and module_name.split(".", maxsplit=1)[0])
     )
 
 
@@ -310,7 +314,7 @@ def init(*, _env_file: Optional[DOTENV_TYPE] = None, **kwargs: Any) -> None:
             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 = _resolve_combine_expr(config.driver)

nonebot/adapters/__init__.py

@@ -3,6 +3,8 @@
 使用 {ref}`nonebot.drivers.Driver.register_adapter` 注册适配器。
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 0
     description: nonebot.adapters 模块
 """

nonebot/compat.py

@@ -3,24 +3,27 @@
 为兼容 Pydantic V1 与 V2 版本，定义了一系列兼容函数与类供使用。
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 16
     description: nonebot.compat 模块
 """
 
+from collections.abc import Generator
+from functools import cached_property
 from dataclasses import dataclass, is_dataclass
-from typing_extensions import Self, Annotated, get_args, get_origin, is_typeddict
+from typing_extensions import Self, get_args, get_origin, is_typeddict
 from typing import (
     TYPE_CHECKING,
     Any,
-    Set,
+    Union,
-    Dict,
+    Generic,
-    List,
-    Type,
     TypeVar,
     Callable,
     Optional,
     Protocol,
-    Generator,
+    Annotated,
+    overload,
 )
 
 from pydantic import VERSION, BaseModel
@@ -48,12 +51,13 @@ __all__ = (
     "DEFAULT_CONFIG",
     "FieldInfo",
     "ModelField",
+    "TypeAdapter",
     "extract_field_info",
-    "model_field_validate",
     "model_fields",
     "model_config",
     "model_dump",
     "type_validate_python",
+    "type_validate_json",
     "custom_validation",
 )
 
@@ -64,9 +68,10 @@ __autodoc__ = {
 
 
 if PYDANTIC_V2:  # pragma: pydantic-v2
+    from pydantic import GetCoreSchemaHandler
+    from pydantic import TypeAdapter as TypeAdapter
     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
@@ -92,7 +97,7 @@ if PYDANTIC_V2:  # pragma: pydantic-v2
             super().__init__(default=default, **kwargs)
 
         @property
-        def extra(self) -> Dict[str, Any]:
+        def extra(self) -> dict[str, Any]:
             """Extra data that is not part of the standard pydantic fields.
 
             For compatibility with pydantic v1.
@@ -126,6 +131,25 @@ if PYDANTIC_V2:  # pragma: pydantic-v2
             """Construct a ModelField from given infos."""
             return cls._construct(name, annotation, field_info or FieldInfo())
 
+        def __hash__(self) -> int:
+            # Each ModelField is unique for our purposes,
+            # to allow store them in a set.
+            return id(self)
+
+        @cached_property
+        def type_adapter(self) -> TypeAdapter:
+            """TypeAdapter of the field.
+
+            Cache the TypeAdapter to avoid creating it multiple times.
+            Pydantic v2 uses too much cpu time to create TypeAdapter.
+
+            See: https://github.com/pydantic/pydantic/issues/9834
+            """
+            return TypeAdapter(
+                Annotated[self.annotation, self.field_info],
+                config=None if self._annotation_has_config() else DEFAULT_CONFIG,
+            )
+
         def _annotation_has_config(self) -> bool:
             """Check if the annotation has config.
 
@@ -153,28 +177,18 @@ if PYDANTIC_V2:  # pragma: pydantic-v2
             """Get the display of the type of the field."""
             return display_as_type(self.annotation)
 
-        def __hash__(self) -> int:
+        def validate_value(self, value: Any) -> Any:
-            # Each ModelField is unique for our purposes,
+            """Validate the value pass to the field."""
-            # to allow store them in a set.
+            return self.type_adapter.validate_python(value)
-            return id(self)
 
-    def extract_field_info(field_info: BaseFieldInfo) -> Dict[str, Any]:
+    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(
+    def model_fields(model: type[BaseModel]) -> list[ModelField]:
-        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 [
@@ -186,23 +200,38 @@ if PYDANTIC_V2:  # pragma: pydantic-v2
             for name, field_info in model.model_fields.items()
         ]
 
-    def model_config(model: Type[BaseModel]) -> Any:
+    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,
+        include: Optional[set[str]] = None,
-        exclude: Optional[Set[str]] = None,
+        exclude: Optional[set[str]] = None,
-    ) -> Dict[str, Any]:
+        by_alias: bool = False,
-        return model.model_dump(include=include, exclude=exclude)
+        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:
+    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"],
+        cls: type["_CustomValidationClass"],
         source_type: Any,
         handler: GetCoreSchemaHandler,
     ) -> CoreSchema:
@@ -213,7 +242,7 @@ if PYDANTIC_V2:  # pragma: pydantic-v2
             [core_schema.no_info_plain_validator_function(func) for func in validators]
         )
 
-    def custom_validation(class_: Type["CVC"]) -> Type["CVC"]:
+    def custom_validation(class_: type["CVC"]) -> type["CVC"]:
         """Use pydantic v1 like validator generator in pydantic v2"""
 
         setattr(
@@ -225,7 +254,7 @@ if PYDANTIC_V2:  # pragma: pydantic-v2
 
 else:  # pragma: pydantic-v1
     from pydantic import Extra
-    from pydantic import parse_obj_as
+    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
@@ -291,7 +320,46 @@ else:  # pragma: pydantic-v1
                 )
             return cls._construct(name, annotation, field_info or FieldInfo())
 
-    def extract_field_info(field_info: BaseFieldInfo) -> Dict[str, Any]:
+        def validate_value(self, value: Any) -> Any:
+            """Validate the value pass to the field."""
+            v, errs_ = self.validate(value, {}, loc=())
+            if errs_:
+                raise ValueError(value, self)
+            return v
+
+    class TypeAdapter(Generic[T]):
+        @overload
+        def __init__(
+            self,
+            type: type[T],
+            *,
+            config: Optional[ConfigDict] = ...,
+        ) -> None: ...
+
+        @overload
+        def __init__(
+            self,
+            type: Any,
+            *,
+            config: Optional[ConfigDict] = ...,
+        ) -> None: ...
+
+        def __init__(
+            self,
+            type: Any,
+            *,
+            config: Optional[ConfigDict] = None,
+        ) -> None:
+            self.type = type
+            self.config = config
+
+        def validate_python(self, value: Any) -> T:
+            return type_validate_python(self.type, value)
+
+        def validate_json(self, value: Union[str, bytes]) -> T:
+            return type_validate_json(self.type, value)
+
+    def extract_field_info(field_info: BaseFieldInfo) -> dict[str, Any]:
         """Get FieldInfo init kwargs from a FieldInfo instance."""
 
         kwargs = {
@@ -300,23 +368,7 @@ else:  # pragma: pydantic-v1
         kwargs.update(field_info.extra)
         return kwargs
 
-    def model_field_validate(
+    def model_fields(model: type[BaseModel]) -> list[ModelField]:
-        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
@@ -331,21 +383,36 @@ else:  # pragma: pydantic-v1
             for model_field in model.__fields__.values()
         ]
 
-    def model_config(model: Type[BaseModel]) -> Any:
+    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,
+        include: Optional[set[str]] = None,
-        exclude: Optional[Set[str]] = None,
+        exclude: Optional[set[str]] = None,
-    ) -> Dict[str, Any]:
+        by_alias: bool = False,
-        return model.dict(include=include, exclude=exclude)
+        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:
+    def type_validate_python(type_: type[T], data: Any) -> T:
         """Validate data with given type."""
         return parse_obj_as(type_, data)
 
-    def custom_validation(class_: Type["CVC"]) -> Type["CVC"]:
+    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

@@ -7,6 +7,8 @@ NoneBot 使用 [`pydantic`](https://pydantic-docs.helpmanual.io/) 以及
 详情见 [`pydantic Field Type`](https://pydantic-docs.helpmanual.io/usage/types/) 文档。
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 1
     description: nonebot.config 模块
 """
@@ -17,19 +19,9 @@ import json
 from pathlib import Path
 from datetime import timedelta
 from ipaddress import IPv4Address
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Union, Optional
 from typing_extensions import TypeAlias, get_args, get_origin
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Set,
-    Dict,
-    List,
-    Type,
-    Tuple,
-    Union,
-    Mapping,
-    Optional,
-)
 
 from dotenv import dotenv_values
 from pydantic import Field, BaseModel
@@ -49,7 +41,7 @@ from nonebot.compat import (
 )
 
 DOTENV_TYPE: TypeAlias = Union[
-    Path, str, List[Union[Path, str]], Tuple[Union[Path, str], ...]
+    Path, str, list[Union[Path, str]], tuple[Union[Path, str], ...]
 ]
 
 ENV_FILE_SENTINEL = Path("")
@@ -59,7 +51,7 @@ class SettingsError(ValueError): ...
 
 
 class BaseSettingsSource(abc.ABC):
-    def __init__(self, settings_cls: Type["BaseSettings"]) -> None:
+    def __init__(self, settings_cls: type["BaseSettings"]) -> None:
         self.settings_cls = settings_cls
 
     @property
@@ -67,7 +59,7 @@ class BaseSettingsSource(abc.ABC):
         return model_config(self.settings_cls)
 
     @abc.abstractmethod
-    def __call__(self) -> Dict[str, Any]:
+    def __call__(self) -> dict[str, Any]:
         raise NotImplementedError
 
 
@@ -75,12 +67,12 @@ class InitSettingsSource(BaseSettingsSource):
     __slots__ = ("init_kwargs",)
 
     def __init__(
-        self, settings_cls: Type["BaseSettings"], init_kwargs: Dict[str, Any]
+        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]:
+    def __call__(self) -> dict[str, Any]:
         return self.init_kwargs
 
     def __repr__(self) -> str:
@@ -90,7 +82,7 @@ class InitSettingsSource(BaseSettingsSource):
 class DotEnvSettingsSource(BaseSettingsSource):
     def __init__(
         self,
-        settings_cls: Type["BaseSettings"],
+        settings_cls: type["BaseSettings"],
         env_file: Optional[DOTENV_TYPE] = ENV_FILE_SENTINEL,
         env_file_encoding: Optional[str] = None,
         case_sensitive: Optional[bool] = None,
@@ -121,7 +113,7 @@ class DotEnvSettingsSource(BaseSettingsSource):
     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]:
+    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(
@@ -132,16 +124,16 @@ class DotEnvSettingsSource(BaseSettingsSource):
 
     def _parse_env_vars(
         self, env_vars: Mapping[str, Optional[str]]
-    ) -> Dict[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]]:
+    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]]:
+    def _read_env_files(self) -> dict[str, Optional[str]]:
         env_files = self.env_file
         if env_files is None:
             return {}
@@ -149,7 +141,7 @@ class DotEnvSettingsSource(BaseSettingsSource):
         if isinstance(env_files, (str, os.PathLike)):
             env_files = [env_files]
 
-        dotenv_vars: Dict[str, Optional[str]] = {}
+        dotenv_vars: dict[str, Optional[str]] = {}
         for env_file in env_files:
             env_path = Path(env_file).expanduser()
             if env_path.is_file():
@@ -170,14 +162,14 @@ class DotEnvSettingsSource(BaseSettingsSource):
     def _explode_env_vars(
         self,
         field: ModelField,
-        env_vars: Dict[str, Optional[str]],
+        env_vars: dict[str, Optional[str]],
-        env_file_vars: Dict[str, Optional[str]],
+        env_file_vars: dict[str, Optional[str]],
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         if self.env_nested_delimiter is None:
             return {}
 
         prefix = f"{field.name}{self.env_nested_delimiter}"
-        result: Dict[str, Any] = {}
+        result: dict[str, Any] = {}
         for env_name, env_val in env_vars.items():
             if not env_name.startswith(prefix):
                 continue
@@ -209,10 +201,10 @@ class DotEnvSettingsSource(BaseSettingsSource):
 
         return result
 
-    def __call__(self) -> Dict[str, Any]:
+    def __call__(self) -> dict[str, Any]:
         """从环境变量和 dotenv 配置文件中读取配置项。"""
 
-        d: Dict[str, Any] = {}
+        d: dict[str, Any] = {}
 
         env_vars = self._parse_env_vars(os.environ)
         env_file_vars = self._read_env_files()
@@ -317,7 +309,7 @@ class BaseSettings(BaseModel):
             return self.__dict__.get(name)
 
     if PYDANTIC_V2:  # pragma: pydantic-v2
-        model_config: SettingsConfig = SettingsConfig(
+        model_config = SettingsConfig(
             extra="allow",
             env_file=".env",
             env_file_encoding="utf-8",
@@ -351,11 +343,11 @@ class BaseSettings(BaseModel):
 
     def _settings_build_values(
         self,
-        init_kwargs: Dict[str, Any],
+        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]:
+    ) -> dict[str, Any]:
         init_settings = InitSettingsSource(self.__class__, init_kwargs=init_kwargs)
         env_settings = DotEnvSettingsSource(
             self.__class__,
@@ -426,7 +418,7 @@ class Config(BaseSettings):
     """API 请求超时时间，单位: 秒。"""
 
     # bot runtime configs
-    superusers: Set[str] = set()
+    superusers: set[str] = set()
     """机器人超级用户。
 
     用法:
@@ -434,9 +426,9 @@ class Config(BaseSettings):
         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)。
@@ -446,7 +438,7 @@ class Config(BaseSettings):
         COMMAND_START=["/", ""]
         ```
     """
-    command_sep: Set[str] = {"."}
+    command_sep: set[str] = {"."}
     """命令的分隔标记，用于将文本形式的命令切分为元组（实际的命令名）。
 
     参考[命令响应规则](https://nonebot.dev/docs/advanced/matcher#command)。
@@ -461,9 +453,8 @@ class Config(BaseSettings):
 
     用法:
         ```conf
-        SESSION_EXPIRE_TIMEOUT=120  # 单位: 秒
+        SESSION_EXPIRE_TIMEOUT=[-][DD]D[,][HH:MM:]SS[.ffffff]
-        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=P[DD]DT[HH]H[MM]M[SS]S  # ISO 8601
         ```
     """
 
@@ -478,7 +469,9 @@ class Config(BaseSettings):
         model_config = SettingsConfig(env_file=(".env", ".env.prod"))
     else:  # pragma: pydantic-v1
 
-        class Config(SettingsConfig):
+        class Config(  # pyright: ignore[reportIncompatibleVariableOverride]
+            SettingsConfig
+        ):
             env_file = ".env", ".env.prod"
 
 

nonebot/consts.py

@@ -1,6 +1,8 @@
 """本模块包含了 NoneBot 事件处理过程中使用到的常量。
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 9
     description: nonebot.consts 模块
 """

nonebot/dependencies/__init__.py

@@ -1,34 +1,32 @@
 """本模块模块实现了依赖注入的定义与处理。
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 0
     description: nonebot.dependencies 模块
 """
 
 import abc
-import asyncio
 import inspect
+from functools import partial
 from dataclasses import field, dataclass
-from typing import (
+from collections.abc import Iterable, Awaitable
-    Any,
+from typing import Any, Generic, TypeVar, Callable, Optional, cast
-    Dict,
+
-    List,
+import anyio
-    Type,
+from exceptiongroup import BaseExceptionGroup, catch
-    Tuple,
-    Generic,
-    TypeVar,
-    Callable,
-    Iterable,
-    Optional,
-    Awaitable,
-    cast,
-)
 
 from nonebot.log import logger
 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 nonebot.utils import (
+    run_sync,
+    run_coro_with_shield,
+    is_coroutine_callable,
+    flatten_exception_group,
+)
 
 from .utils import check_field_type, get_typed_signature
 
@@ -48,13 +46,13 @@ class Param(abc.ABC, FieldInfo):
 
     @classmethod
     def _check_param(
-        cls, param: inspect.Parameter, allow_types: Tuple[Type["Param"], ...]
+        cls, param: inspect.Parameter, allow_types: tuple[type["Param"], ...]
     ) -> Optional["Param"]:
         return
 
     @classmethod
     def _check_parameterless(
-        cls, value: Any, allow_types: Tuple[Type["Param"], ...]
+        cls, value: Any, allow_types: tuple[type["Param"], ...]
     ) -> Optional["Param"]:
         return
 
@@ -79,8 +77,8 @@ class Dependent(Generic[R]):
     """
 
     call: _DependentCallable[R]
-    params: Tuple[ModelField, ...] = field(default_factory=tuple)
+    params: tuple[ModelField, ...] = field(default_factory=tuple)
-    parameterless: Tuple[Param, ...] = 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):
@@ -94,7 +92,16 @@ class Dependent(Generic[R]):
         )
 
     async def __call__(self, **kwargs: Any) -> R:
-        try:
+        exception: Optional[BaseExceptionGroup[SkippedException]] = None
+
+        def _handle_skipped(exc_group: BaseExceptionGroup[SkippedException]):
+            nonlocal exception
+            exception = exc_group
+            # raise one of the exceptions instead
+            excs = list(flatten_exception_group(exc_group))
+            logger.trace(f"{self} skipped due to {excs}")
+
+        with catch({SkippedException: _handle_skipped}):
             # do pre-check
             await self.check(**kwargs)
 
@@ -106,15 +113,14 @@ class Dependent(Generic[R]):
                 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 exception
-            raise
 
     @staticmethod
     def parse_params(
-        call: _DependentCallable[R], allow_types: Tuple[Type[Param], ...]
+        call: _DependentCallable[R], allow_types: tuple[type[Param], ...]
-    ) -> Tuple[ModelField, ...]:
+    ) -> tuple[ModelField, ...]:
-        fields: List[ModelField] = []
+        fields: list[ModelField] = []
         params = get_typed_signature(call).parameters.values()
 
         for param in params:
@@ -144,9 +150,9 @@ class Dependent(Generic[R]):
 
     @staticmethod
     def parse_parameterless(
-        parameterless: Tuple[Any, ...], allow_types: Tuple[Type[Param], ...]
+        parameterless: tuple[Any, ...], allow_types: tuple[type[Param], ...]
-    ) -> Tuple[Param, ...]:
+    ) -> tuple[Param, ...]:
-        parameterless_params: List[Param] = []
+        parameterless_params: list[Param] = []
         for value in parameterless:
             for allow_type in allow_types:
                 if param := allow_type._check_parameterless(value, allow_types):
@@ -162,7 +168,7 @@ class Dependent(Generic[R]):
         *,
         call: _DependentCallable[R],
         parameterless: Optional[Iterable[Any]] = None,
-        allow_types: Iterable[Type[Param]],
+        allow_types: Iterable[type[Param]],
     ) -> "Dependent[R]":
         allow_types = tuple(allow_types)
 
@@ -176,12 +182,19 @@ class Dependent(Generic[R]):
         return cls(call, params, parameterless_params)
 
     async def check(self, **params: Any) -> None:
-        await asyncio.gather(*(param._check(**params) for param in self.parameterless))
+        if self.parameterless:
-        await asyncio.gather(
+            async with anyio.create_task_group() as tg:
-            *(cast(Param, param.field_info)._check(**params) for param in self.params)
+                for param in self.parameterless:
-        )
+                    tg.start_soon(partial(param._check, **params))
 
-    async def _solve_field(self, field: ModelField, params: Dict[str, Any]) -> Any:
+        if self.params:
+            async with anyio.create_task_group() as tg:
+                for param in self.params:
+                    tg.start_soon(
+                        partial(cast(Param, param.field_info)._check, **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:
@@ -189,16 +202,28 @@ class Dependent(Generic[R]):
         v = check_field_type(field, value)
         return v if param.validate else value
 
-    async def solve(self, **params: Any) -> Dict[str, Any]:
+    async def solve(self, **params: Any) -> dict[str, Any]:
         # solve parameterless
         for param in self.parameterless:
             await param._solve(**params)
 
         # solve param values
-        values = await asyncio.gather(
+        result: dict[str, Any] = {}
-            *(self._solve_field(field, params) for field in self.params)
+        if not self.params:
-        )
+            return result
-        return {field.name: value for field, value in zip(self.params, values)}
+
+        async def _solve_field(field: ModelField, params: dict[str, Any]) -> None:
+            value = await self._solve_field(field, params)
+            result[field.name] = value
+
+        async with anyio.create_task_group() as tg:
+            for field in self.params:
+                # shield the task to prevent cancellation
+                # when one of the tasks raises an exception
+                # this will improve the dependency cache reusability
+                tg.start_soon(run_coro_with_shield, _solve_field(field, params))
+
+        return result
 
 
 __autodoc__ = {"CustomConfig": False}

nonebot/dependencies/utils.py

@@ -1,17 +1,19 @@
 """
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 1
     description: nonebot.dependencies.utils 模块
 """
 
 import inspect
-from typing import Any, Dict, Callable, ForwardRef
+from typing import Any, Callable, ForwardRef
 
 from loguru import logger
 
+from nonebot.compat import ModelField
 from nonebot.exception import TypeMisMatch
 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:
@@ -31,7 +33,7 @@ def get_typed_signature(call: Callable[..., Any]) -> inspect.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
@@ -51,6 +53,6 @@ def check_field_type(field: ModelField, value: Any) -> Any:
     """检查字段类型是否匹配"""
 
     try:
-        return model_field_validate(field, value, DEFAULT_CONFIG)
+        return field.validate_value(value)
     except ValueError:
         raise TypeMisMatch(field, value)

nonebot/drivers/__init__.py

@@ -3,6 +3,8 @@
 各驱动请继承以下基类。
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 0
     description: nonebot.drivers 模块
 """
@@ -23,6 +25,7 @@ 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
 

nonebot/drivers/aiohttp.py

@@ -11,21 +11,28 @@ pip install nonebot2[aiohttp]
 :::
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 2
     description: nonebot.drivers.aiohttp 模块
 """
 
 from typing_extensions import override
+from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, AsyncGenerator
+from typing import TYPE_CHECKING, Union, Optional
+
+from multidict import CIMultiDict
 
-from nonebot.drivers import Request, Response
 from nonebot.exception import WebSocketClosed
+from nonebot.drivers import URL, Request, Response
 from nonebot.drivers.none import Driver as NoneDriver
 from nonebot.drivers import WebSocket as BaseWebSocket
+from nonebot.internal.driver import Cookies, QueryTypes, CookieTypes, HeaderTypes
 from nonebot.drivers import (
     HTTPVersion,
     HTTPClientMixin,
+    HTTPClientSession,
     WebSocketClientMixin,
     combine_driver,
 )
@@ -39,6 +46,107 @@ except ModuleNotFoundError as e:  # pragma: no cover
     ) from e
 
 
+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"""
 
@@ -49,42 +157,8 @@ class Mixin(HTTPClientMixin, WebSocketClientMixin):
 
     @override
     async def request(self, setup: Request) -> Response:
-        if setup.version == HTTPVersion.H10:
+        async with self.get_session() as session:
-            version = aiohttp.HttpVersion10
+            return await session.request(setup)
-        elif setup.version == HTTPVersion.H11:
-            version = aiohttp.HttpVersion11
-        else:
-            raise RuntimeError(f"Unsupported HTTP version: {setup.version}")
-
-        timeout = aiohttp.ClientTimeout(setup.timeout)
-
-        data = setup.data
-        if setup.files:
-            data = aiohttp.FormData(data or {})
-            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
-        }
-        async with aiohttp.ClientSession(
-            cookies=cookies, version=version, trust_env=True
-        ) as session:
-            async with session.request(
-                setup.method,
-                setup.url,
-                data=setup.content or data,
-                json=setup.json,
-                headers=setup.headers,
-                timeout=timeout,
-                proxy=setup.proxy,
-            ) as response:
-                return Response(
-                    response.status,
-                    headers=response.headers.copy(),
-                    content=await response.read(),
-                    request=setup,
-                )
 
     @override
     @asynccontextmanager
@@ -106,6 +180,25 @@ class Mixin(HTTPClientMixin, WebSocketClientMixin):
             ) as ws:
                 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):
     """AIOHTTP Websocket Wrapper"""
@@ -131,8 +224,8 @@ class WebSocket(BaseWebSocket):
         raise NotImplementedError
 
     @override
-    async def close(self, code: int = 1000):
+    async def close(self, code: int = 1000, reason: str = ""):
-        await self.websocket.close(code=code)
+        await self.websocket.close(code=code, message=reason.encode("utf-8"))
         await self.session.close()
 
     async def _receive(self) -> aiohttp.WSMessage:

nonebot/drivers/fastapi.py

@@ -11,6 +11,8 @@ pip install nonebot2[fastapi]
 :::
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 1
     description: nonebot.drivers.fastapi 模块
 """
@@ -19,7 +21,7 @@ import logging
 import contextlib
 from functools import wraps
 from typing_extensions import override
-from typing import Any, Dict, List, Tuple, Union, Optional
+from typing import Any, Union, Optional
 
 from pydantic import BaseModel
 
@@ -31,6 +33,7 @@ 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.compat import model_dump, type_validate_python
 from nonebot.drivers import HTTPServerSetup, WebSocketServerSetup
 
 try:
@@ -71,15 +74,15 @@ class Config(BaseModel):
     """是否包含适配器路由的 schema，默认为 `True`"""
     fastapi_reload: bool = False
     """开启/关闭冷重载"""
-    fastapi_reload_dirs: Optional[List[str]] = None
+    fastapi_reload_dirs: Optional[list[str]] = None
     """重载监控文件夹列表，默认为 uvicorn 默认值"""
     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 默认值"""
-    fastapi_extra: Dict[str, Any] = {}
+    fastapi_extra: dict[str, Any] = {}
     """传递给 `FastAPI` 的其他参数。"""
 
 
@@ -89,7 +92,7 @@ class Driver(BaseDriver, ASGIMixin):
     def __init__(self, env: Env, config: NoneBotConfig):
         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,
@@ -160,7 +163,7 @@ class Driver(BaseDriver, ASGIMixin):
         self,
         host: Optional[str] = None,
         port: Optional[int] = None,
-        *,
+        *args,
         app: Optional[str] = None,
         **kwargs,
     ):
@@ -205,7 +208,7 @@ class Driver(BaseDriver, ASGIMixin):
             json = await request.json()
 
         data: Optional[dict] = None
-        files: Optional[List[Tuple[str, FileTypes]]] = None
+        files: Optional[list[tuple[str, FileTypes]]] = None
         with contextlib.suppress(Exception):
             form = await request.form()
             data = {}

nonebot/drivers/httpx.py

@@ -11,19 +11,26 @@ pip install nonebot2[httpx]
 :::
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 3
     description: nonebot.drivers.httpx 模块
 """
 
-from typing import TYPE_CHECKING
 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,
     HTTPVersion,
     HTTPClientMixin,
+    HTTPClientSession,
     combine_driver,
 )
 
@@ -36,6 +43,79 @@ except ModuleNotFoundError as e:  # pragma: no cover
     ) from e
 
 
+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"""
 
@@ -46,28 +126,29 @@ class Mixin(HTTPClientMixin):
 
     @override
     async def request(self, setup: Request) -> Response:
-        async with httpx.AsyncClient(
+        async with self.get_session(
-            cookies=setup.cookies.jar,
+            version=setup.version, proxy=setup.proxy
-            http2=setup.version == HTTPVersion.H2,
+        ) as session:
-            proxies=setup.proxy,
+            return await session.request(setup)
-            follow_redirects=True,
+
-        ) as client:
+    @override
-            response = await client.request(
+    def get_session(
-                setup.method,
+        self,
-                str(setup.url),
+        params: QueryTypes = None,
-                content=setup.content,
+        headers: HeaderTypes = None,
-                data=setup.data,
+        cookies: CookieTypes = None,
-                json=setup.json,
+        version: Union[str, HTTPVersion] = HTTPVersion.H11,
-                files=setup.files,
+        timeout: Optional[float] = None,
-                headers=tuple(setup.headers.items()),
+        proxy: Optional[str] = None,
-                timeout=setup.timeout,
+    ) -> Session:
-            )
+        return Session(
-            return Response(
+            params=params,
-                response.status_code,
+            headers=headers,
-                headers=response.headers.multi_items(),
+            cookies=cookies,
-                content=response.content,
+            version=version,
-                request=setup,
+            timeout=timeout,
-            )
+            proxy=proxy,
+        )
 
 
 if TYPE_CHECKING:

nonebot/drivers/none.py

@@ -5,19 +5,25 @@
 :::
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 6
     description: nonebot.drivers.none 模块
 """
 
 import signal
-import asyncio
+from typing import Optional
-import threading
 from typing_extensions import override
 
+import anyio
+from anyio.abc import TaskGroup
+from exceptiongroup import BaseExceptionGroup, catch
+
 from nonebot.log import logger
 from nonebot.consts import WINDOWS
 from nonebot.config import Env, Config
 from nonebot.drivers import Driver as BaseDriver
+from nonebot.utils import flatten_exception_group
 
 HANDLED_SIGNALS = (
     signal.SIGINT,  # Unix signal 2. Sent by Ctrl+C.
@@ -33,8 +39,8 @@ class Driver(BaseDriver):
     def __init__(self, env: Env, config: Config):
         super().__init__(env, config)
 
-        self.should_exit: asyncio.Event = asyncio.Event()
+        self.should_exit: anyio.Event = anyio.Event()
-        self.force_exit: bool = False
+        self.force_exit: anyio.Event = anyio.Event()
 
     @property
     @override
@@ -52,83 +58,98 @@ class Driver(BaseDriver):
     def run(self, *args, **kwargs):
         """启动 none driver"""
         super().run(*args, **kwargs)
-        loop = asyncio.get_event_loop()
+        anyio.run(self._serve)
-        loop.run_until_complete(self._serve())
 
     async def _serve(self):
-        self._install_signal_handlers()
+        async with anyio.create_task_group() as driver_tg:
-        await self._startup()
+            driver_tg.start_soon(self._handle_signals)
-        if self.should_exit.is_set():
+            driver_tg.start_soon(self._listen_force_exit, driver_tg)
-            return
+            driver_tg.start_soon(self._handle_lifespan, driver_tg)
-        await self._main_loop()
-        await self._shutdown()
 
-    async def _startup(self):
+    async def _handle_signals(self):
         try:
-            await self._lifespan.startup()
+            with anyio.open_signal_receiver(*HANDLED_SIGNALS) as signal_receiver:
-        except Exception as e:
+                async for sig in signal_receiver:
-            logger.opt(colors=True, exception=e).error(
+                    self.exit(force=self.should_exit.is_set())
-                "<r><bg #f8bbd0>Error when running startup function. "
-                "Ignored!</bg #f8bbd0></r>"
-            )
-
-        logger.info("Application startup completed.")
-
-    async def _main_loop(self):
-        await self.should_exit.wait()
-
-    async def _shutdown(self):
-        logger.info("Shutting down")
-
-        logger.info("Waiting for application shutdown.")
-
-        try:
-            await self._lifespan.shutdown()
-        except Exception as e:
-            logger.opt(colors=True, exception=e).error(
-                "<r><bg #f8bbd0>Error when running shutdown function. "
-                "Ignored!</bg #f8bbd0></r>"
-            )
-
-        for task in asyncio.all_tasks():
-            if task is not asyncio.current_task() and not task.done():
-                task.cancel()
-        await asyncio.sleep(0.1)
-
-        tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
-        if tasks and not self.force_exit:
-            logger.info("Waiting for tasks to finish. (CTRL+C to force quit)")
-        while tasks and not self.force_exit:
-            await asyncio.sleep(0.1)
-            tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
-
-        for task in tasks:
-            task.cancel()
-
-        await asyncio.gather(*tasks, return_exceptions=True)
-
-        logger.info("Application shutdown complete.")
-        loop = asyncio.get_event_loop()
-        loop.stop()
-
-    def _install_signal_handlers(self) -> None:
-        if threading.current_thread() is not threading.main_thread():
-            # Signals can only be listened to from the main thread.
-            return
-
-        loop = asyncio.get_event_loop()
-
-        try:
-            for sig in HANDLED_SIGNALS:
-                loop.add_signal_handler(sig, self._handle_exit, sig, None)
         except NotImplementedError:
             # Windows
             for sig in HANDLED_SIGNALS:
-                signal.signal(sig, self._handle_exit)
+                signal.signal(sig, self._handle_legacy_signal)
 
-    def _handle_exit(self, sig, frame):
+    # backport for Windows signal handling
+    def _handle_legacy_signal(self, sig, frame):
         self.exit(force=self.should_exit.is_set())
 
+    async def _handle_lifespan(self, tg: TaskGroup):
+        try:
+            await self._startup()
+
+            if self.should_exit.is_set():
+                return
+
+            await self._listen_exit()
+
+            await self._shutdown()
+        finally:
+            tg.cancel_scope.cancel()
+
+    async def _startup(self):
+        def handle_exception(exc_group: BaseExceptionGroup[Exception]) -> None:
+            self.should_exit.set()
+
+            for exc in flatten_exception_group(exc_group):
+                logger.opt(colors=True, exception=exc).error(
+                    "<r><bg #f8bbd0>Error occurred while running startup hook."
+                    "</bg #f8bbd0></r>"
+                )
+            logger.error(
+                "<r><bg #f8bbd0>Application startup failed. "
+                "Exiting.</bg #f8bbd0></r>"
+            )
+
+        with catch({Exception: handle_exception}):
+            await self._lifespan.startup()
+
+        if not self.should_exit.is_set():
+            logger.info("Application startup completed.")
+
+    async def _listen_exit(self, tg: Optional[TaskGroup] = None):
+        await self.should_exit.wait()
+
+        if tg is not None:
+            tg.cancel_scope.cancel()
+
+    async def _shutdown(self):
+        logger.info("Shutting down")
+        logger.info("Waiting for application shutdown. (CTRL+C to force quit)")
+
+        error_occurred: bool = False
+
+        def handle_exception(exc_group: BaseExceptionGroup[Exception]) -> None:
+            nonlocal error_occurred
+
+            error_occurred = True
+
+            for exc in flatten_exception_group(exc_group):
+                logger.opt(colors=True, exception=exc).error(
+                    "<r><bg #f8bbd0>Error occurred while running shutdown hook."
+                    "</bg #f8bbd0></r>"
+                )
+            logger.error(
+                "<r><bg #f8bbd0>Application shutdown failed. "
+                "Exiting.</bg #f8bbd0></r>"
+            )
+
+        with catch({Exception: handle_exception}):
+            await self._lifespan.shutdown()
+
+        if not error_occurred:
+            logger.info("Application shutdown complete.")
+
+    async def _listen_force_exit(self, tg: TaskGroup):
+        await self.force_exit.wait()
+        tg.cancel_scope.cancel()
+
     def exit(self, force: bool = False):
         """退出 none driver
 
@@ -138,4 +159,4 @@ class Driver(BaseDriver):
         if not self.should_exit.is_set():
             self.should_exit.set()
         if force:
-            self.force_exit = True
+            self.force_exit.set()

nonebot/drivers/quart.py

@@ -11,6 +11,8 @@ pip install nonebot2[quart]
 :::
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 5
     description: nonebot.drivers.quart 模块
 """
@@ -18,7 +20,7 @@ FrontMatter:
 import asyncio
 from functools import wraps
 from typing_extensions import override
-from typing import Any, Dict, List, Tuple, Union, Optional, cast
+from typing import Any, Union, Optional, cast
 
 from pydantic import BaseModel
 
@@ -30,6 +32,7 @@ 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.compat import model_dump, type_validate_python
 from nonebot.drivers import HTTPServerSetup, WebSocketServerSetup
 
 try:
@@ -63,15 +66,15 @@ class Config(BaseModel):
 
     quart_reload: bool = False
     """开启/关闭冷重载"""
-    quart_reload_dirs: Optional[List[str]] = None
+    quart_reload_dirs: Optional[list[str]] = None
     """重载监控文件夹列表，默认为 uvicorn 默认值"""
     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 默认值"""
-    quart_extra: Dict[str, Any] = {}
+    quart_extra: dict[str, Any] = {}
     """传递给 `Quart` 的其他参数。"""
 
 
@@ -81,7 +84,7 @@ class Driver(BaseDriver, ASGIMixin):
     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.quart_config.quart_extra
@@ -141,7 +144,7 @@ class Driver(BaseDriver, ASGIMixin):
         self,
         host: Optional[str] = None,
         port: Optional[int] = None,
-        *,
+        *args,
         app: Optional[str] = None,
         **kwargs,
     ):
@@ -183,7 +186,7 @@ class Driver(BaseDriver, ASGIMixin):
 
         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():

nonebot/drivers/websockets.py

@@ -11,6 +11,8 @@ pip install nonebot2[websockets]
 :::
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 4
     description: nonebot.drivers.websockets 模块
 """
@@ -19,7 +21,8 @@ import logging
 from functools import wraps
 from contextlib import asynccontextmanager
 from typing_extensions import ParamSpec, override
-from typing import TYPE_CHECKING, Union, TypeVar, Callable, Awaitable, AsyncGenerator
+from collections.abc import Coroutine, AsyncGenerator
+from typing import TYPE_CHECKING, Any, Union, TypeVar, Callable
 
 from nonebot.drivers import Request
 from nonebot.log import LoguruHandler
@@ -44,7 +47,9 @@ logger = logging.Logger("websockets.client", "INFO")
 logger.addHandler(LoguruHandler())
 
 
-def catch_closed(func: Callable[P, Awaitable[T]]) -> Callable[P, Awaitable[T]]:
+def catch_closed(
+    func: Callable[P, Coroutine[Any, Any, T]]
+) -> Callable[P, Coroutine[Any, Any, T]]:
     @wraps(func)
     async def decorator(*args: P.args, **kwargs: P.kwargs) -> T:
         try:
@@ -66,6 +71,8 @@ class Mixin(WebSocketClientMixin):
     @override
     @asynccontextmanager
     async def websocket(self, setup: Request) -> AsyncGenerator["WebSocket", None]:
+        if setup.proxy is not None:
+            logger.warning("proxy is not supported by websockets driver")
         connection = Connect(
             str(setup.url),
             extra_headers={**setup.headers, **setup.cookies.as_header(setup)},

nonebot/exception.py

@@ -25,6 +25,8 @@ NoneBotException
 ```
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 10
     description: nonebot.exception 模块
 """

nonebot/internal/adapter/adapter.py

@@ -1,6 +1,7 @@
 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
@@ -32,7 +33,7 @@ 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:

nonebot/internal/adapter/bot.py

@@ -1,11 +1,14 @@
 import abc
-import asyncio
 from functools import partial
-from typing import TYPE_CHECKING, Any, Set, Union, Optional, Protocol
+from typing import TYPE_CHECKING, Any, Union, ClassVar, Optional, Protocol
+
+import anyio
+from exceptiongroup import BaseExceptionGroup, catch
 
 from nonebot.log import logger
 from nonebot.config import Config
 from nonebot.exception import MockApiException
+from nonebot.utils import flatten_exception_group
 from nonebot.typing import T_CalledAPIHook, T_CallingAPIHook
 
 if TYPE_CHECKING:
@@ -27,9 +30,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):
@@ -76,47 +79,98 @@ class Bot(abc.ABC):
         skip_calling_api: bool = False
         exception: Optional[Exception] = None
 
-        if coros := [hook(self, api, data) for hook in self._calling_api_hook]:
+        if self._calling_api_hook:
-            try:
+            logger.debug("Running CallingAPI hooks...")
-                logger.debug("Running CallingAPI hooks...")
+
-                await asyncio.gather(*coros)
+            def _handle_mock_api_exception(
-            except MockApiException as e:
+                exc_group: BaseExceptionGroup[MockApiException],
+            ) -> None:
+                nonlocal skip_calling_api, result
+
+                excs = [
+                    exc
+                    for exc in flatten_exception_group(exc_group)
+                    if isinstance(exc, MockApiException)
+                ]
+                if not excs:
+                    return
+                elif len(excs) > 1:
+                    logger.warning(
+                        "Multiple hooks want to mock API result. Use the first one."
+                    )
+
                 skip_calling_api = True
-                result = e.result
+                result = excs[0].result
+
                 logger.debug(
-                    f"Calling API {api} is cancelled. Return {result} instead."
+                    f"Calling API {api} is cancelled. Return {result!r} instead."
-                )
-            except Exception as e:
-                logger.opt(colors=True, exception=e).error(
-                    "<r><bg #f8bbd0>Error when running CallingAPI hook. "
-                    "Running cancelled!</bg #f8bbd0></r>"
                 )
 
+            def _handle_exception(exc_group: BaseExceptionGroup[Exception]) -> None:
+                for exc in flatten_exception_group(exc_group):
+                    logger.opt(colors=True, exception=exc).error(
+                        "<r><bg #f8bbd0>Error when running CallingAPI hook. "
+                        "Running cancelled!</bg #f8bbd0></r>"
+                    )
+
+            with catch(
+                {
+                    MockApiException: _handle_mock_api_exception,
+                    Exception: _handle_exception,
+                }
+            ):
+                async with anyio.create_task_group() as tg:
+                    for hook in self._calling_api_hook:
+                        tg.start_soon(hook, self, api, data)
+
         if not skip_calling_api:
             try:
                 result = await self.adapter._call_api(self, api, **data)
             except Exception as e:
                 exception = e
 
-        if coros := [
+        if self._called_api_hook:
-            hook(self, exception, api, data, result) for hook in self._called_api_hook
+            logger.debug("Running CalledAPI hooks...")
-        ]:
+
-            try:
+            def _handle_mock_api_exception(
-                logger.debug("Running CalledAPI hooks...")
+                exc_group: BaseExceptionGroup[MockApiException],
-                await asyncio.gather(*coros)
+            ) -> None:
-            except MockApiException as e:
+                nonlocal result, exception
-                # mock api result
+
-                result = e.result
+                excs = [
-                # ignore exception
+                    exc
+                    for exc in flatten_exception_group(exc_group)
+                    if isinstance(exc, MockApiException)
+                ]
+                if not excs:
+                    return
+                elif len(excs) > 1:
+                    logger.warning(
+                        "Multiple hooks want to mock API result. Use the first one."
+                    )
+
+                result = excs[0].result
                 exception = None
                 logger.debug(
                     f"Calling API {api} result is mocked. Return {result} instead."
                 )
-            except Exception as e:
+
-                logger.opt(colors=True, exception=e).error(
+            def _handle_exception(exc_group: BaseExceptionGroup[Exception]) -> None:
-                    "<r><bg #f8bbd0>Error when running CalledAPI hook. "
+                for exc in flatten_exception_group(exc_group):
-                    "Running cancelled!</bg #f8bbd0></r>"
+                    logger.opt(colors=True, exception=exc).error(
-                )
+                        "<r><bg #f8bbd0>Error when running CalledAPI hook. "
+                        "Running cancelled!</bg #f8bbd0></r>"
+                    )
+
+            with catch(
+                {
+                    MockApiException: _handle_mock_api_exception,
+                    Exception: _handle_exception,
+                }
+            ):
+                async with anyio.create_task_group() as tg:
+                    for hook in self._called_api_hook:
+                        tg.start_soon(hook, self, exception, api, data, result)
 
         if exception:
             raise exception

nonebot/internal/adapter/event.py

@@ -1,5 +1,5 @@
 import abc
-from typing import Any, Type, TypeVar
+from typing import Any, TypeVar
 
 from pydantic import BaseModel
 
@@ -20,12 +20,12 @@ class Event(abc.ABC, BaseModel):
 
         class Config(ConfigDict):
             extra = "allow"  # type: ignore
-            json_encoders = {Message: DataclassEncoder}
+            json_encoders = {Message: DataclassEncoder}  # noqa: RUF012
 
     if not PYDANTIC_V2:  # pragma: pydantic-v1
 
         @classmethod
-        def validate(cls: Type["E"], value: Any) -> "E":
+        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)

nonebot/internal/adapter/message.py

@@ -1,17 +1,14 @@
 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,
@@ -32,12 +29,12 @@ 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
 
@@ -49,7 +46,9 @@ class MessageSegment(abc.ABC, Generic[TM]):
     def __len__(self) -> int:
         return len(str(self))
 
-    def __ne__(self, other: Self) -> 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:
@@ -101,7 +100,7 @@ class MessageSegment(abc.ABC, Generic[TM]):
 
 
 @custom_validation
-class Message(List[TMS], abc.ABC):
+class Message(list[TMS], abc.ABC):
     """消息序列
 
     参数:
@@ -142,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
 
@@ -177,7 +176,9 @@ class Message(List[TMS], abc.ABC):
         """构造消息数组"""
         raise NotImplementedError
 
-    def __add__(self, other: Union[str, TMS, Iterable[TMS]]) -> Self:
+    def __add__(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, other: Union[str, TMS, Iterable[TMS]]
+    ) -> Self:
         result = self.copy()
         result += other
         return result
@@ -209,7 +210,7 @@ class Message(List[TMS], abc.ABC):
         """
 
     @overload
-    def __getitem__(self, args: Tuple[str, int]) -> TMS:
+    def __getitem__(self, args: tuple[str, int]) -> TMS:
         """索引指定类型的消息段
 
         参数:
@@ -220,7 +221,7 @@ class Message(List[TMS], abc.ABC):
         """
 
     @overload
-    def __getitem__(self, args: Tuple[str, slice]) -> Self:
+    def __getitem__(self, args: tuple[str, slice]) -> Self:
         """切片指定类型的消息段
 
         参数:
@@ -252,12 +253,12 @@ class Message(List[TMS], abc.ABC):
             消息切片 `args`
         """
 
-    def __getitem__(
+    def __getitem__(  # pyright: ignore[reportIncompatibleMethodOverride]
         self,
         args: Union[
             str,
-            Tuple[str, int],
+            tuple[str, int],
-            Tuple[str, slice],
+            tuple[str, slice],
             int,
             slice,
         ],
@@ -276,7 +277,9 @@ class Message(List[TMS], abc.ABC):
         else:
             raise ValueError("Incorrect arguments to slice")  # pragma: no cover
 
-    def __contains__(self, value: Union[TMS, str]) -> bool:
+    def __contains__(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, value: Union[TMS, str]
+    ) -> bool:
         """检查消息段是否存在
 
         参数:
@@ -285,7 +288,7 @@ class Message(List[TMS], abc.ABC):
             消息内是否存在给定消息段或给定类型的消息段
         """
         if isinstance(value, str):
-            return bool(next((seg for seg in self if seg.type == value), None))
+            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:
@@ -359,7 +362,9 @@ class Message(List[TMS], abc.ABC):
             return all(seg.type == value for seg in self)
         return all(seg == value for seg in self)
 
-    def append(self, obj: Union[str, TMS]) -> Self:
+    def append(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, obj: Union[str, TMS]
+    ) -> Self:
         """添加一个消息段到消息数组末尾。
 
         参数:
@@ -373,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, obj: Union[Self, Iterable[TMS]]) -> Self:
+    def extend(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, obj: Union[Self, Iterable[TMS]]
+    ) -> Self:
         """拼接一个消息数组或多个消息段到消息数组末尾。
 
         参数:

nonebot/internal/adapter/template.py

@@ -1,21 +1,15 @@
 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,
 )
@@ -25,9 +19,9 @@ from _string import formatter_field_name_split  # type: ignore
 if TYPE_CHECKING:
     from .message import Message, MessageSegment
 
-    def formatter_field_name_split(  # noqa: F811
+    def formatter_field_name_split(
         field_name: str,
-    ) -> Tuple[str, List[Tuple[bool, str]]]: ...
+    ) -> tuple[str, list[tuple[bool, str]]]: ...
 
 
 TM = TypeVar("TM", bound="Message")
@@ -50,7 +44,7 @@ class MessageTemplate(Formatter, Generic[TF]):
     def __init__(
         self: "MessageTemplate[str]",
         template: str,
-        factory: Type[str] = str,
+        factory: type[str] = str,
         private_getattr: bool = False,
     ) -> None: ...
 
@@ -58,19 +52,19 @@ class MessageTemplate(Formatter, Generic[TF]):
     def __init__(
         self: "MessageTemplate[TM]",
         template: Union[str, TM],
-        factory: Type[TM],
+        factory: type[TM],
         private_getattr: bool = False,
     ) -> None: ...
 
     def __init__(
         self,
         template: Union[str, TM],
-        factory: Union[Type[str], Type[TM]] = str,
+        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.factory: type[TF] = factory  # type: ignore
-        self.format_specs: Dict[str, FormatSpecFunc] = {}
+        self.format_specs: dict[str, FormatSpecFunc] = {}
         self.private_getattr = private_getattr
 
     def __repr__(self) -> str:
@@ -85,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)
 
@@ -118,7 +114,7 @@ class MessageTemplate(Formatter, Generic[TF]):
         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],
@@ -126,15 +122,15 @@ 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]:
+    ) -> tuple[TF, int]:
-        results: List[Any] = [self.factory()]
+        results: list[Any] = [self.factory()]
 
         for literal_text, field_name, format_spec, conversion in self.parse(
             format_string
@@ -185,7 +181,7 @@ class MessageTemplate(Formatter, Generic[TF]):
 
     def get_field(
         self, field_name: str, args: Sequence[Any], kwargs: Mapping[str, Any]
-    ) -> Tuple[Any, Union[int, str]]:
+    ) -> tuple[Any, Union[int, str]]:
         first, rest = formatter_field_name_split(field_name)
         obj = self.get_value(first, args, kwargs)
 
@@ -199,7 +195,7 @@ class MessageTemplate(Formatter, Generic[TF]):
     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

@@ -26,5 +26,6 @@ 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

@@ -1,5 +1,11 @@
+from types import TracebackType
 from typing_extensions import TypeAlias
-from typing import Any, List, Union, Callable, Awaitable, cast
+from collections.abc import Iterable, Awaitable
+from typing import Any, Union, Callable, Optional, cast
+
+import anyio
+from anyio.abc import TaskGroup
+from exceptiongroup import suppress
 
 from nonebot.utils import run_sync, is_coroutine_callable
 
@@ -10,9 +16,23 @@ LIFESPAN_FUNC: TypeAlias = Union[SYNC_LIFESPAN_FUNC, ASYNC_LIFESPAN_FUNC]
 
 class Lifespan:
     def __init__(self) -> None:
-        self._startup_funcs: List[LIFESPAN_FUNC] = []
+        self._task_group: Optional[TaskGroup] = None
-        self._ready_funcs: List[LIFESPAN_FUNC] = []
+
-        self._shutdown_funcs: List[LIFESPAN_FUNC] = []
+        self._startup_funcs: list[LIFESPAN_FUNC] = []
+        self._ready_funcs: list[LIFESPAN_FUNC] = []
+        self._shutdown_funcs: list[LIFESPAN_FUNC] = []
+
+    @property
+    def task_group(self) -> TaskGroup:
+        if self._task_group is None:
+            raise RuntimeError("Lifespan not started")
+        return self._task_group
+
+    @task_group.setter
+    def task_group(self, task_group: TaskGroup) -> None:
+        if self._task_group is not None:
+            raise RuntimeError("Lifespan already started")
+        self._task_group = task_group
 
     def on_startup(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
         self._startup_funcs.append(func)
@@ -28,7 +48,7 @@ class Lifespan:
 
     @staticmethod
     async def _run_lifespan_func(
-        funcs: List[LIFESPAN_FUNC],
+        funcs: Iterable[LIFESPAN_FUNC],
     ) -> None:
         for func in funcs:
             if is_coroutine_callable(func):
@@ -37,18 +57,44 @@ class Lifespan:
                 await run_sync(cast(SYNC_LIFESPAN_FUNC, func))()
 
     async def startup(self) -> None:
+        # create background task group
+        self.task_group = anyio.create_task_group()
+        await self.task_group.__aenter__()
+
+        # run startup funcs
         if self._startup_funcs:
             await self._run_lifespan_func(self._startup_funcs)
 
+        # run ready funcs
         if self._ready_funcs:
             await self._run_lifespan_func(self._ready_funcs)
 
-    async def shutdown(self) -> None:
+    async def shutdown(
+        self,
+        *,
+        exc_type: Optional[type[BaseException]] = None,
+        exc_val: Optional[BaseException] = None,
+        exc_tb: Optional[TracebackType] = None,
+    ) -> None:
         if self._shutdown_funcs:
-            await self._run_lifespan_func(self._shutdown_funcs)
+            # reverse shutdown funcs to ensure stack order
+            await self._run_lifespan_func(reversed(self._shutdown_funcs))
+
+        # shutdown background task group
+        self.task_group.cancel_scope.cancel()
+
+        with suppress(Exception):
+            await self.task_group.__aexit__(exc_type, exc_val, exc_tb)
+
+        self._task_group = None
 
     async def __aenter__(self) -> None:
         await self.startup()
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+    async def __aexit__(
-        await self.shutdown()
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        await self.shutdown(exc_type=exc_type, exc_val=exc_val, exc_tb=exc_tb)

nonebot/internal/driver/abstract.py

@@ -1,15 +1,20 @@
 import abc
-import asyncio
+from types import TracebackType
-from typing_extensions import TypeAlias
+from collections.abc import AsyncGenerator
+from typing_extensions import Self, TypeAlias
 from contextlib import AsyncExitStack, asynccontextmanager
-from typing import TYPE_CHECKING, Any, Set, Dict, Type, AsyncGenerator
+from typing import TYPE_CHECKING, Any, Union, ClassVar, Optional
+
+from anyio.abc import TaskGroup
+from anyio import CancelScope, create_task_group
+from exceptiongroup import BaseExceptionGroup, catch
 
 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.utils import escape_tag, run_coro_with_catch, flatten_exception_group
 from nonebot.typing import (
     T_DependencyCache,
     T_BotConnectionHook,
@@ -17,7 +22,17 @@ from nonebot.typing import (
 )
 
 from ._lifespan import LIFESPAN_FUNC, Lifespan
-from .model import Request, Response, WebSocket, HTTPServerSetup, WebSocketServerSetup
+from .model import (
+    Request,
+    Response,
+    WebSocket,
+    QueryTypes,
+    CookieTypes,
+    HeaderTypes,
+    HTTPVersion,
+    HTTPServerSetup,
+    WebSocketServerSetup,
+)
 
 if TYPE_CHECKING:
     from nonebot.internal.adapter import Bot, Adapter
@@ -36,11 +51,11 @@ class Driver(abc.ABC):
         config: 包含配置信息的 Config 对象
     """
 
-    _adapters: Dict[str, "Adapter"] = {}
+    _adapters: ClassVar[dict[str, "Adapter"]] = {}
     """已注册的适配器列表"""
-    _bot_connection_hook: Set[Dependent[Any]] = set()
+    _bot_connection_hook: ClassVar[set[Dependent[Any]]] = set()
     """Bot 连接建立时执行的函数"""
-    _bot_disconnection_hook: Set[Dependent[Any]] = set()
+    _bot_disconnection_hook: ClassVar[set[Dependent[Any]]] = set()
     """Bot 连接断开时执行的函数"""
 
     def __init__(self, env: Env, config: Config):
@@ -48,8 +63,7 @@ class Driver(abc.ABC):
         """环境名称"""
         self.config: Config = config
         """全局配置对象"""
-        self._bots: Dict[str, "Bot"] = {}
+        self._bots: dict[str, "Bot"] = {}
-        self._bot_tasks: Set[asyncio.Task] = set()
         self._lifespan = Lifespan()
 
     def __repr__(self) -> str:
@@ -59,11 +73,15 @@ class Driver(abc.ABC):
         )
 
     @property
-    def bots(self) -> Dict[str, "Bot"]:
+    def bots(self) -> dict[str, "Bot"]:
         """获取当前所有已连接的 Bot"""
         return self._bots
 
-    def register_adapter(self, adapter: Type["Adapter"], **kwargs) -> None:
+    @property
+    def task_group(self) -> TaskGroup:
+        return self._lifespan.task_group
+
+    def register_adapter(self, adapter: type["Adapter"], **kwargs) -> None:
         """注册一个协议适配器
 
         参数:
@@ -100,8 +118,6 @@ class Driver(abc.ABC):
             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)
@@ -142,66 +158,63 @@ class Driver(abc.ABC):
             raise RuntimeError(f"Duplicate bot connection with id {bot.self_id}")
         self._bots[bot.self_id] = bot
 
+        if not self._bot_connection_hook:
+            return
+
+        def handle_exception(exc_group: BaseExceptionGroup) -> None:
+            for exc in flatten_exception_group(exc_group):
+                logger.opt(colors=True, exception=exc).error(
+                    "<r><bg #f8bbd0>"
+                    "Error when running WebSocketConnection hook:"
+                    "</bg #f8bbd0></r>"
+                )
+
         async def _run_hook(bot: "Bot") -> None:
             dependency_cache: T_DependencyCache = {}
-            async with AsyncExitStack() as stack:
+            with CancelScope(shield=True), catch({Exception: handle_exception}):
-                if coros := [
+                async with AsyncExitStack() as stack, create_task_group() as tg:
-                    run_coro_with_catch(
+                    for hook in self._bot_connection_hook:
-                        hook(bot=bot, stack=stack, dependency_cache=dependency_cache),
+                        tg.start_soon(
-                        (SkippedException,),
+                            run_coro_with_catch,
-                    )
+                            hook(
-                    for hook in self._bot_connection_hook
+                                bot=bot, stack=stack, dependency_cache=dependency_cache
-                ]:
+                            ),
-                    try:
+                            (SkippedException,),
-                        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))
+        self.task_group.start_soon(_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]
 
+        if not self._bot_disconnection_hook:
+            return
+
+        def handle_exception(exc_group: BaseExceptionGroup) -> None:
+            for exc in flatten_exception_group(exc_group):
+                logger.opt(colors=True, exception=exc).error(
+                    "<r><bg #f8bbd0>"
+                    "Error when running WebSocketDisConnection hook:"
+                    "</bg #f8bbd0></r>"
+                )
+
         async def _run_hook(bot: "Bot") -> None:
             dependency_cache: T_DependencyCache = {}
-            async with AsyncExitStack() as stack:
+            # shield cancellation to ensure bot disconnect hooks are always run
-                if coros := [
+            with CancelScope(shield=True), catch({Exception: handle_exception}):
-                    run_coro_with_catch(
+                async with create_task_group() as tg, AsyncExitStack() as stack:
-                        hook(bot=bot, stack=stack, dependency_cache=dependency_cache),
+                    for hook in self._bot_disconnection_hook:
-                        (SkippedException,),
+                        tg.start_soon(
-                    )
+                            run_coro_with_catch,
-                    for hook in self._bot_disconnection_hook
+                            hook(
-                ]:
+                                bot=bot, stack=stack, dependency_cache=dependency_cache
-                    try:
+                            ),
-                        await asyncio.gather(*coros)
+                            (SkippedException,),
-                    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))
+        self.task_group.start_soon(_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):
@@ -222,6 +235,49 @@ 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 客户端混入基类。"""
 
@@ -230,6 +286,19 @@ class HTTPClientMixin(ForwardMixin):
         """发送一个 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 客户端混入基类。"""

nonebot/internal/driver/combine.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Type, Union, TypeVar, overload
+from typing import TYPE_CHECKING, Union, TypeVar, overload
 
 from .abstract import Mixin, Driver
 
@@ -10,16 +10,18 @@ if TYPE_CHECKING:
 
 
 @overload
-def combine_driver(driver: Type[D]) -> Type[D]: ...
+def combine_driver(driver: type[D]) -> type[D]: ...
 
 
 @overload
-def combine_driver(driver: Type[D], *mixins: Type[Mixin]) -> Type["CombinedDriver"]: ...
+def combine_driver(
+    driver: type[D], __m: type[Mixin], /, *mixins: type[Mixin]
+) -> type["CombinedDriver"]: ...
 
 
 def combine_driver(
-    driver: Type[D], *mixins: Type[Mixin]
+    driver: type[D], *mixins: type[Mixin]
-) -> Union[Type[D], Type["CombinedDriver"]]:
+) -> Union[type[D], type["CombinedDriver"]]:
     """将一个驱动器和多个混入类合并。"""
     # check first
     if not issubclass(driver, Driver):

nonebot/internal/driver/model.py

@@ -4,56 +4,44 @@ from enum import Enum
 from dataclasses import dataclass
 from typing_extensions import TypeAlias
 from http.cookiejar import Cookie, CookieJar
-from typing import (
+from typing import IO, Any, Union, Callable, Optional
-    IO,
+from collections.abc import Mapping, Iterator, Awaitable, MutableMapping
-    Any,
-    Dict,
-    List,
-    Tuple,
-    Union,
-    Mapping,
-    Callable,
-    Iterator,
-    Optional,
-    Awaitable,
-    MutableMapping,
-)
 
 from yarl import URL as URL
 from multidict import CIMultiDict
 
-RawURL: TypeAlias = Tuple[bytes, bytes, Optional[int], bytes]
+RawURL: TypeAlias = tuple[bytes, bytes, Optional[int], bytes]
 
 SimpleQuery: TypeAlias = Union[str, int, float]
-QueryVariable: TypeAlias = Union[SimpleQuery, List[SimpleQuery]]
+QueryVariable: TypeAlias = Union[SimpleQuery, list[SimpleQuery]]
 QueryTypes: TypeAlias = Union[
-    None, str, Mapping[str, QueryVariable], List[Tuple[str, QueryVariable]]
+    None, str, Mapping[str, QueryVariable], list[tuple[str, SimpleQuery]]
 ]
 
 HeaderTypes: TypeAlias = Union[
     None,
     CIMultiDict[str],
-    Dict[str, str],
+    dict[str, str],
-    List[Tuple[str, str]],
+    list[tuple[str, str]],
 ]
 
 CookieTypes: TypeAlias = Union[
-    None, "Cookies", CookieJar, Dict[str, str], List[Tuple[str, str]]
+    None, "Cookies", CookieJar, dict[str, str], list[tuple[str, str]]
 ]
 
 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]]
+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: TypeAlias = Union[Dict[str, FileTypes], List[Tuple[str, FileTypes]], None]
+FilesTypes: TypeAlias = Union[dict[str, FileTypes], list[tuple[str, FileTypes]], None]
 
 
 class HTTPVersion(Enum):
@@ -119,7 +107,7 @@ 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
@@ -257,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,
@@ -298,12 +286,14 @@ 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]:
+    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
@@ -341,9 +331,11 @@ class Cookies(MutableMapping):
                 method=request.method,
             )
             self.request = request
-            self.added_headers: Dict[str, str] = {}
+            self.added_headers: dict[str, str] = {}
 
-        def add_unredirected_header(self, key: str, value: str) -> None:
+        def add_unredirected_header(  # pyright: ignore[reportIncompatibleMethodOverride]
+            self, key: str, value: str
+        ) -> None:
             super().add_unredirected_header(key, value)
             self.added_headers[key] = value
 

nonebot/internal/matcher/manager.py

@@ -1,18 +1,5 @@
-from typing import (
+from typing import TYPE_CHECKING, Union, TypeVar, Optional, overload
-    TYPE_CHECKING,
+from collections.abc import Iterator, KeysView, ItemsView, ValuesView, MutableMapping
-    List,
-    Type,
-    Tuple,
-    Union,
-    TypeVar,
-    Iterator,
-    KeysView,
-    Optional,
-    ItemsView,
-    ValuesView,
-    MutableMapping,
-    overload,
-)
 
 from .provider import DEFAULT_PROVIDER_CLASS, MatcherProvider
 
@@ -22,7 +9,7 @@ if TYPE_CHECKING:
 T = TypeVar("T")
 
 
-class MatcherManager(MutableMapping[int, List[Type["Matcher"]]]):
+class MatcherManager(MutableMapping[int, list[type["Matcher"]]]):
     """事件响应器管理器
 
     实现了常用字典操作，用于管理事件响应器。
@@ -43,10 +30,10 @@ class MatcherManager(MutableMapping[int, List[Type["Matcher"]]]):
     def __len__(self) -> int:
         return len(self.provider)
 
-    def __getitem__(self, key: int) -> List[Type["Matcher"]]:
+    def __getitem__(self, key: int) -> list[type["Matcher"]]:
         return self.provider[key]
 
-    def __setitem__(self, key: int, value: List[Type["Matcher"]]) -> None:
+    def __setitem__(self, key: int, value: list[type["Matcher"]]) -> None:
         self.provider[key] = value
 
     def __delitem__(self, key: int) -> None:
@@ -58,41 +45,45 @@ class MatcherManager(MutableMapping[int, List[Type["Matcher"]]]):
     def keys(self) -> KeysView[int]:
         return self.provider.keys()
 
-    def values(self) -> ValuesView[List[Type["Matcher"]]]:
+    def values(self) -> ValuesView[list[type["Matcher"]]]:
         return self.provider.values()
 
-    def items(self) -> ItemsView[int, List[Type["Matcher"]]]:
+    def items(self) -> ItemsView[int, list[type["Matcher"]]]:
         return self.provider.items()
 
     @overload
-    def get(self, key: int) -> Optional[List[Type["Matcher"]]]: ...
+    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: T) -> Union[list[type["Matcher"]], T]: ...
 
     def get(
         self, key: int, default: Optional[T] = None
-    ) -> Optional[Union[List[Type["Matcher"]], T]]:
+    ) -> Optional[Union[list[type["Matcher"]], T]]:
         return self.provider.get(key, default)
 
-    def pop(self, key: int) -> List[Type["Matcher"]]:
+    def pop(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, key: int
+    ) -> list[type["Matcher"]]:
         return self.provider.pop(key)
 
-    def popitem(self) -> Tuple[int, List[Type["Matcher"]]]:
+    def popitem(self) -> tuple[int, list[type["Matcher"]]]:
         return self.provider.popitem()
 
     def clear(self) -> None:
         self.provider.clear()
 
-    def update(self, __m: MutableMapping[int, List[Type["Matcher"]]]) -> None:
+    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"]]
+        self, key: int, default: list[type["Matcher"]]
-    ) -> List[Type["Matcher"]]:
+    ) -> list[type["Matcher"]]:
         return self.provider.setdefault(key, default)
 
-    def set_provider(self, provider_class: Type[MatcherProvider]) -> None:
+    def set_provider(self, provider_class: type[MatcherProvider]) -> None:
         """设置事件响应器存储器
 
         参数:

nonebot/internal/matcher/matcher.py

@@ -6,29 +6,29 @@ from types import ModuleType
 from dataclasses import dataclass
 from contextvars import ContextVar
 from typing_extensions import Self
+from collections.abc import Iterable
 from datetime import datetime, timedelta
 from contextlib import AsyncExitStack, contextmanager
-from typing import (
+from typing import (  # noqa: UP035
     TYPE_CHECKING,
     Any,
-    List,
     Type,
-    Tuple,
     Union,
     TypeVar,
     Callable,
     ClassVar,
-    Iterable,
     NoReturn,
     Optional,
     overload,
 )
 
+from exceptiongroup import BaseExceptionGroup, catch
+
 from nonebot.log import logger
 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.utils import classproperty, flatten_exception_group
 from nonebot.internal.adapter import (
     Bot,
     Event,
@@ -78,15 +78,15 @@ T = TypeVar("T")
 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")
+current_handler: ContextVar[Dependent[Any]] = ContextVar("current_handler")
 
 
 @dataclass
 class MatcherSource:
     """Matcher 源代码上下文信息"""
 
-    plugin_name: Optional[str] = None
+    plugin_id: Optional[str] = None
-    """事件响应器所在插件名称"""
+    """事件响应器所在插件标识符"""
     module_name: Optional[str] = None
     """事件响应器所在插件模块的路径名"""
     lineno: Optional[int] = None
@@ -97,8 +97,13 @@ class MatcherSource:
         """事件响应器所在插件"""
         from nonebot.plugin import get_plugin
 
-        if self.plugin_name is not None:
+        if self.plugin_id is not None:
-            return get_plugin(self.plugin_name)
+            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]:
@@ -141,7 +146,7 @@ class Matcher(metaclass=MatcherMeta):
     """事件响应器匹配规则"""
     permission: ClassVar[Permission] = Permission()
     """事件响应器触发权限"""
-    handlers: List[Dependent[Any]] = []
+    handlers: ClassVar[list[Dependent[Any]]] = []
     """事件响应器拥有的事件处理函数列表"""
     priority: ClassVar[int] = 1
     """事件响应器优先级"""
@@ -160,7 +165,7 @@ class Matcher(metaclass=MatcherMeta):
     _default_permission_updater: ClassVar[Optional[Dependent[Permission]]] = None
     """事件响应器权限更新函数"""
 
-    HANDLER_PARAM_TYPES: ClassVar[Tuple[Type[Param], ...]] = (
+    HANDLER_PARAM_TYPES: ClassVar[tuple[Type[Param], ...]] = (  # noqa: UP006
         DependParam,
         BotParam,
         EventParam,
@@ -171,7 +176,7 @@ class Matcher(metaclass=MatcherMeta):
     )
 
     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:
@@ -192,7 +197,7 @@ class Matcher(metaclass=MatcherMeta):
         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,
@@ -206,7 +211,7 @@ class Matcher(metaclass=MatcherMeta):
         default_permission_updater: Optional[
             Union[T_PermissionUpdater, Dependent[Permission]]
         ] = None,
-    ) -> Type[Self]:
+    ) -> Type[Self]:  # noqa: UP006
         """
         创建一个新的事件响应器，并存储至 `matchers <#matchers>`_
 
@@ -247,7 +252,7 @@ class Matcher(metaclass=MatcherMeta):
             )
         source = source or (
             MatcherSource(
-                plugin_name=plugin and plugin.name,
+                plugin_id=plugin and plugin.id_,
                 module_name=module and module.__name__,
             )
             if plugin is not None or module is not None
@@ -330,15 +335,20 @@ class Matcher(metaclass=MatcherMeta):
         return cls._source and cls._source.plugin
 
     @classproperty
-    def module(cls) -> Optional[ModuleType]:
+    def plugin_id(cls) -> Optional[str]:
-        """事件响应器所在插件模块"""
+        """事件响应器所在插件标识符"""
-        return cls._source and cls._source.module
+        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]:
         """事件响应器所在插件模块路径"""
@@ -457,7 +467,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)
@@ -775,7 +785,7 @@ class Matcher(metaclass=MatcherMeta):
 
     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]
 
@@ -804,28 +814,34 @@ class Matcher(metaclass=MatcherMeta):
             f"bot={bot}, event={event!r}, state={state!r}"
         )
 
+        def _handle_stop_propagation(exc_group: BaseExceptionGroup[StopPropagation]):
+            self.block = True
+
         with self.ensure_context(bot, event):
             try:
-                # Refresh preprocess state
+                with catch({StopPropagation: _handle_stop_propagation}):
-                self.state.update(state)
+                    # Refresh preprocess state
+                    self.state.update(state)
 
-                while self.handlers:
+                    while self.remain_handlers:
-                    handler = self.handlers.pop(0)
+                        handler = self.remain_handlers.pop(0)
-                    current_handler.set(handler)
+                        current_handler.set(handler)
-                    logger.debug(f"Running handler {handler}")
+                        logger.debug(f"Running handler {handler}")
-                    try:
+
-                        await handler(
+                        def _handle_skipped(
-                            matcher=self,
+                            exc_group: BaseExceptionGroup[SkippedException],
-                            bot=bot,
+                        ):
-                            event=event,
+                            logger.debug(f"Handler {handler} skipped")
-                            state=self.state,
+
-                            stack=stack,
+                        with catch({SkippedException: _handle_skipped}):
-                            dependency_cache=dependency_cache,
+                            await handler(
-                        )
+                                matcher=self,
-                    except SkippedException:
+                                bot=bot,
-                        logger.debug(f"Handler {handler} skipped")
+                                event=event,
-            except StopPropagation:
+                                state=self.state,
-                self.block = True
+                                stack=stack,
+                                dependency_cache=dependency_cache,
+                            )
             finally:
                 logger.info(f"{self} running complete")
 
@@ -838,10 +854,54 @@ class Matcher(metaclass=MatcherMeta):
         stack: Optional[AsyncExitStack] = None,
         dependency_cache: Optional[T_DependencyCache] = None,
     ):
-        try:
+        exc: Optional[Union[FinishedException, RejectedException, PausedException]] = (
+            None
+        )
+
+        def _handle_special_exception(
+            exc_group: BaseExceptionGroup[
+                Union[FinishedException, RejectedException, PausedException]
+            ]
+        ):
+            nonlocal exc
+            excs = list(flatten_exception_group(exc_group))
+            if len(excs) > 1:
+                logger.warning(
+                    "Multiple session control exceptions occurred. "
+                    "NoneBot will choose the proper one."
+                )
+                finished_exc = next(
+                    (e for e in excs if isinstance(e, FinishedException)),
+                    None,
+                )
+                rejected_exc = next(
+                    (e for e in excs if isinstance(e, RejectedException)),
+                    None,
+                )
+                paused_exc = next(
+                    (e for e in excs if isinstance(e, PausedException)),
+                    None,
+                )
+                exc = finished_exc or rejected_exc or paused_exc
+            elif isinstance(
+                excs[0], (FinishedException, RejectedException, PausedException)
+            ):
+                exc = excs[0]
+
+        with catch(
+            {
+                (
+                    FinishedException,
+                    RejectedException,
+                    PausedException,
+                ): _handle_special_exception
+            }
+        ):
             await self.simple_run(bot, event, state, stack, dependency_cache)
 
-        except RejectedException:
+        if isinstance(exc, FinishedException):
+            pass
+        elif isinstance(exc, RejectedException):
             await self.resolve_reject()
             type_ = await self.update_type(bot, event, stack, dependency_cache)
             permission = await self.update_permission(
@@ -852,7 +912,7 @@ class Matcher(metaclass=MatcherMeta):
                 type_,
                 Rule(),
                 permission,
-                self.handlers,
+                self.remain_handlers,
                 temp=True,
                 priority=0,
                 block=True,
@@ -862,7 +922,7 @@ class Matcher(metaclass=MatcherMeta):
                 default_type_updater=self.__class__._default_type_updater,
                 default_permission_updater=self.__class__._default_permission_updater,
             )
-        except PausedException:
+        elif isinstance(exc, PausedException):
             type_ = await self.update_type(bot, event, stack, dependency_cache)
             permission = await self.update_permission(
                 bot, event, stack, dependency_cache
@@ -872,7 +932,7 @@ class Matcher(metaclass=MatcherMeta):
                 type_,
                 Rule(),
                 permission,
-                self.handlers,
+                self.remain_handlers,
                 temp=True,
                 priority=0,
                 block=True,
@@ -882,5 +942,3 @@ class Matcher(metaclass=MatcherMeta):
                 default_type_updater=self.__class__._default_type_updater,
                 default_permission_updater=self.__class__._default_permission_updater,
             )
-        except FinishedException:
-            pass

nonebot/internal/matcher/provider.py

@@ -1,12 +1,13 @@
 import abc
+from typing import TYPE_CHECKING
 from collections import defaultdict
-from typing import TYPE_CHECKING, List, Type, Mapping, MutableMapping
+from collections.abc import Mapping, MutableMapping
 
 if TYPE_CHECKING:
     from .matcher import Matcher
 
 
-class MatcherProvider(abc.ABC, MutableMapping[int, List[Type["Matcher"]]]):
+class MatcherProvider(abc.ABC, MutableMapping[int, list[type["Matcher"]]]):
     """事件响应器存储器基类
 
     参数:
@@ -14,12 +15,12 @@ class MatcherProvider(abc.ABC, MutableMapping[int, List[Type["Matcher"]]]):
     """
 
     @abc.abstractmethod
-    def __init__(self, matchers: Mapping[int, List[Type["Matcher"]]]):
+    def __init__(self, matchers: Mapping[int, list[type["Matcher"]]]):
         raise NotImplementedError
 
 
 class _DictProvider(defaultdict, MatcherProvider):
-    def __init__(self, matchers: Mapping[int, List[Type["Matcher"]]]):
+    def __init__(self, matchers: Mapping[int, list[type["Matcher"]]]):
         super().__init__(list, matchers)
 
 

nonebot/internal/params.py

@@ -1,25 +1,33 @@
-import asyncio
 import inspect
+from enum import Enum
+from typing_extensions import Self, get_args, override, get_origin
 from contextlib import AsyncExitStack, contextmanager, asynccontextmanager
-from typing_extensions import Self, Annotated, get_args, override, get_origin
 from typing import (
     TYPE_CHECKING,
     Any,
-    Type,
-    Tuple,
     Union,
     Literal,
     Callable,
     Optional,
+    Annotated,
     cast,
 )
 
+import anyio
+from exceptiongroup import BaseExceptionGroup, catch
 from pydantic.fields import FieldInfo as PydanticFieldInfo
 
+from nonebot.exception import SkippedException
 from nonebot.dependencies import Param, Dependent
 from nonebot.dependencies.utils import check_field_type
-from nonebot.typing import T_State, T_Handler, T_DependencyCache
 from nonebot.compat import FieldInfo, ModelField, PydanticUndefined, extract_field_info
+from nonebot.typing import (
+    _STATE_FLAG,
+    T_State,
+    T_Handler,
+    T_DependencyCache,
+    origin_is_annotated,
+)
 from nonebot.utils import (
     get_name,
     run_sync,
@@ -88,6 +96,78 @@ def Depends(
     return DependsInner(dependency, use_cache=use_cache, validate=validate)
 
 
+class CacheState(str, Enum):
+    """子依赖缓存状态"""
+
+    PENDING = "PENDING"
+    FINISHED = "FINISHED"
+
+
+class DependencyCache:
+    """子依赖结果缓存。
+
+    用于缓存子依赖的结果，以避免重复计算。
+    """
+
+    def __init__(self):
+        self._state = CacheState.PENDING
+        self._result: Any = None
+        self._exception: Optional[BaseException] = None
+        self._waiter = anyio.Event()
+
+    def done(self) -> bool:
+        return self._state == CacheState.FINISHED
+
+    def result(self) -> Any:
+        """获取子依赖结果"""
+
+        if self._state != CacheState.FINISHED:
+            raise RuntimeError("Result is not ready")
+
+        if self._exception is not None:
+            raise self._exception
+        return self._result
+
+    def exception(self) -> Optional[BaseException]:
+        """获取子依赖异常"""
+
+        if self._state != CacheState.FINISHED:
+            raise RuntimeError("Result is not ready")
+
+        return self._exception
+
+    def set_result(self, result: Any) -> None:
+        """设置子依赖结果"""
+
+        if self._state != CacheState.PENDING:
+            raise RuntimeError(f"Cache state invalid: {self._state}")
+
+        self._result = result
+        self._state = CacheState.FINISHED
+        self._waiter.set()
+
+    def set_exception(self, exception: BaseException) -> None:
+        """设置子依赖异常"""
+
+        if self._state != CacheState.PENDING:
+            raise RuntimeError(f"Cache state invalid: {self._state}")
+
+        self._exception = exception
+        self._state = CacheState.FINISHED
+        self._waiter.set()
+
+    async def wait(self):
+        """等待子依赖结果"""
+        await self._waiter.wait()
+        if self._state != CacheState.FINISHED:
+            raise RuntimeError("Invalid cache state")
+
+        if self._exception is not None:
+            raise self._exception
+
+        return self._result
+
+
 class DependParam(Param):
     """子依赖注入参数。
 
@@ -97,7 +177,7 @@ class DependParam(Param):
     """
 
     def __init__(
-        self, *args, dependent: Dependent, use_cache: bool, **kwargs: Any
+        self, *args, dependent: Dependent[Any], use_cache: bool, **kwargs: Any
     ) -> None:
         super().__init__(*args, **kwargs)
         self.dependent = dependent
@@ -109,7 +189,7 @@ class DependParam(Param):
     @classmethod
     def _from_field(
         cls,
-        sub_dependent: Dependent,
+        sub_dependent: Dependent[Any],
         use_cache: bool,
         validate: Union[bool, PydanticFieldInfo],
     ) -> Self:
@@ -126,7 +206,7 @@ class DependParam(Param):
     @classmethod
     @override
     def _check_param(
-        cls, param: inspect.Parameter, allow_types: Tuple[Type[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
@@ -166,7 +246,7 @@ class DependParam(Param):
     @classmethod
     @override
     def _check_parameterless(
-        cls, value: Any, allow_types: Tuple[Type[Param], ...]
+        cls, value: Any, allow_types: tuple[type[Param], ...]
     ) -> Optional["Param"]:
         if isinstance(value, DependsInner):
             assert value.dependency, "Dependency cannot be empty"
@@ -185,21 +265,31 @@ class DependParam(Param):
         use_cache: bool = self.use_cache
         dependency_cache = {} if dependency_cache is None else dependency_cache
 
-        sub_dependent: Dependent = self.dependent
+        sub_dependent = self.dependent
         call = cast(Callable[..., Any], sub_dependent.call)
 
         # solve sub dependency with current cache
-        sub_values = await sub_dependent.solve(
+        exc: Optional[BaseExceptionGroup[SkippedException]] = None
-            stack=stack,
+
-            dependency_cache=dependency_cache,
+        def _handle_skipped(exc_group: BaseExceptionGroup[SkippedException]):
-            **kwargs,
+            nonlocal exc
-        )
+            exc = exc_group
+
+        with catch({SkippedException: _handle_skipped}):
+            sub_values = await sub_dependent.solve(
+                stack=stack,
+                dependency_cache=dependency_cache,
+                **kwargs,
+            )
+
+        if exc is not None:
+            raise exc
 
         # run dependency function
-        task: asyncio.Task[Any]
         if use_cache and call in dependency_cache:
-            return await dependency_cache[call]
+            return await dependency_cache[call].wait()
-        elif is_gen_callable(call) or is_async_gen_callable(call):
+
+        if is_gen_callable(call) or is_async_gen_callable(call):
             assert isinstance(
                 stack, AsyncExitStack
             ), "Generator dependency should be called in context"
@@ -207,17 +297,28 @@ class DependParam(Param):
                 cm = run_sync_ctx_manager(contextmanager(call)(**sub_values))
             else:
                 cm = asynccontextmanager(call)(**sub_values)
-            task = asyncio.create_task(stack.enter_async_context(cm))
+
-            dependency_cache[call] = task
+            target = stack.enter_async_context(cm)
-            return await task
         elif is_coroutine_callable(call):
-            task = asyncio.create_task(call(**sub_values))
+            target = call(**sub_values)
-            dependency_cache[call] = task
-            return await task
         else:
-            task = asyncio.create_task(run_sync(call)(**sub_values))
+            target = run_sync(call)(**sub_values)
-            dependency_cache[call] = task
+
-            return await task
+        dependency_cache[call] = cache = DependencyCache()
+        try:
+            result = await target
+        except Exception as e:
+            cache.set_exception(e)
+            raise
+        except BaseException as e:
+            cache.set_exception(e)
+            # remove cache when base exception occurs
+            # e.g. CancelledError
+            dependency_cache.pop(call, None)
+            raise
+        else:
+            cache.set_result(result)
+            return result
 
     @override
     async def _check(self, **kwargs: Any) -> None:
@@ -249,7 +350,7 @@ class BotParam(Param):
     @classmethod
     @override
     def _check_param(
-        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
+        cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]
     ) -> Optional[Self]:
         from nonebot.adapters import Bot
 
@@ -266,11 +367,15 @@ class BotParam(Param):
             return cls()
 
     @override
-    async def _solve(self, bot: "Bot", **kwargs: Any) -> Any:
+    async def _solve(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, bot: "Bot", **kwargs: Any
+    ) -> Any:
         return bot
 
     @override
-    async def _check(self, bot: "Bot", **kwargs: Any) -> None:
+    async def _check(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, bot: "Bot", **kwargs: Any
+    ) -> None:
         if self.checker is not None:
             check_field_type(self.checker, bot)
 
@@ -299,7 +404,7 @@ class EventParam(Param):
     @classmethod
     @override
     def _check_param(
-        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
+        cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]
     ) -> Optional[Self]:
         from nonebot.adapters import Event
 
@@ -316,11 +421,15 @@ class EventParam(Param):
             return cls()
 
     @override
-    async def _solve(self, event: "Event", **kwargs: Any) -> Any:
+    async def _solve(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, event: "Event", **kwargs: Any
+    ) -> Any:
         return event
 
     @override
-    async def _check(self, event: "Event", **kwargs: Any) -> Any:
+    async def _check(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, event: "Event", **kwargs: Any
+    ) -> Any:
         if self.checker is not None:
             check_field_type(self.checker, event)
 
@@ -339,17 +448,21 @@ class StateParam(Param):
     @classmethod
     @override
     def _check_param(
-        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
+        cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]
     ) -> Optional[Self]:
         # param type is T_State
-        if param.annotation is T_State:
+        if origin_is_annotated(
+            get_origin(param.annotation)
+        ) and _STATE_FLAG in get_args(param.annotation):
             return cls()
         # legacy: param is named "state" and has no type annotation
         elif param.annotation == param.empty and param.name == "state":
             return cls()
 
     @override
-    async def _solve(self, state: T_State, **kwargs: Any) -> Any:
+    async def _solve(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, state: T_State, **kwargs: Any
+    ) -> Any:
         return state
 
 
@@ -377,7 +490,7 @@ class MatcherParam(Param):
     @classmethod
     @override
     def _check_param(
-        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
+        cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]
     ) -> Optional[Self]:
         from nonebot.matcher import Matcher
 
@@ -394,11 +507,15 @@ class MatcherParam(Param):
             return cls()
 
     @override
-    async def _solve(self, matcher: "Matcher", **kwargs: Any) -> Any:
+    async def _solve(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, matcher: "Matcher", **kwargs: Any
+    ) -> Any:
         return matcher
 
     @override
-    async def _check(self, matcher: "Matcher", **kwargs: Any) -> Any:
+    async def _check(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, matcher: "Matcher", **kwargs: Any
+    ) -> Any:
         if self.checker is not None:
             check_field_type(self.checker, matcher)
 
@@ -455,7 +572,7 @@ class ArgParam(Param):
     @classmethod
     @override
     def _check_param(
-        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
+        cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]
     ) -> Optional[Self]:
         if isinstance(param.default, ArgInner):
             return cls(key=param.default.key or param.name, type=param.default.type)
@@ -464,7 +581,9 @@ class ArgParam(Param):
                 if isinstance(arg, ArgInner):
                     return cls(key=arg.key or param.name, type=arg.type)
 
-    async def _solve(self, matcher: "Matcher", **kwargs: Any) -> Any:
+    async def _solve(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self, matcher: "Matcher", **kwargs: Any
+    ) -> Any:
         message = matcher.get_arg(self.key)
         if message is None:
             return message
@@ -490,7 +609,7 @@ class ExceptionParam(Param):
     @classmethod
     @override
     def _check_param(
-        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
+        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):
@@ -518,7 +637,7 @@ class DefaultParam(Param):
     @classmethod
     @override
     def _check_param(
-        cls, param: inspect.Parameter, allow_types: Tuple[Type[Param], ...]
+        cls, param: inspect.Parameter, allow_types: tuple[type[Param], ...]
     ) -> Optional[Self]:
         if param.default != param.empty:
             return cls(default=param.default)

nonebot/internal/permission.py

@@ -1,7 +1,8 @@
-import asyncio
 from typing_extensions import Self
 from contextlib import AsyncExitStack
-from typing import Set, Tuple, Union, NoReturn, Optional
+from typing import Union, ClassVar, NoReturn, Optional
+
+import anyio
 
 from nonebot.dependencies import Dependent
 from nonebot.utils import run_coro_with_catch
@@ -9,7 +10,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:
@@ -30,7 +31,7 @@ class Permission:
 
     __slots__ = ("checkers",)
 
-    HANDLER_PARAM_TYPES = [
+    HANDLER_PARAM_TYPES: ClassVar[list[type[Param]]] = [
         DependParam,
         BotParam,
         EventParam,
@@ -38,7 +39,7 @@ class Permission:
     ]
 
     def __init__(self, *checkers: Union[T_PermissionChecker, Dependent[bool]]) -> None:
-        self.checkers: Set[Dependent[bool]] = {
+        self.checkers: set[Dependent[bool]] = {
             (
                 checker
                 if isinstance(checker, Dependent)
@@ -70,22 +71,26 @@ class Permission:
         """
         if not self.checkers:
             return True
-        results = await asyncio.gather(
+
-            *(
+        result = False
-                run_coro_with_catch(
+
-                    checker(
+        async def _run_checker(checker: Dependent[bool]) -> None:
-                        bot=bot,
+            nonlocal result
-                        event=event,
+            # calculate the result first to avoid data racing
-                        stack=stack,
+            is_passed = await run_coro_with_catch(
-                        dependency_cache=dependency_cache,
+                checker(
-                    ),
+                    bot=bot, event=event, stack=stack, dependency_cache=dependency_cache
-                    (SkippedException,),
+                ),
-                    False,
+                (SkippedException,),
-                )
+                False,
-                for checker in self.checkers
+            )
-            ),
+            result |= is_passed
-        )
+
-        return any(results)
+        async with anyio.create_task_group() as tg:
+            for checker in self.checkers:
+                tg.start_soon(_run_checker, checker)
+
+        return result
 
     def __and__(self, other: object) -> NoReturn:
         raise RuntimeError("And operation between Permissions is not allowed.")
@@ -122,7 +127,7 @@ 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
@@ -146,7 +151,7 @@ class User:
     @classmethod
     def _clean_permission(cls, perm: Permission) -> Optional[Permission]:
         if len(perm.checkers) == 1 and isinstance(
-            user_perm := tuple(perm.checkers)[0].call, cls
+            user_perm := next(iter(perm.checkers)).call, cls
         ):
             return user_perm.perm
         return perm

nonebot/internal/rule.py

@@ -1,13 +1,15 @@
-import asyncio
 from contextlib import AsyncExitStack
-from typing import Set, Union, NoReturn, Optional
+from typing import Union, ClassVar, NoReturn, Optional
+
+import anyio
+from exceptiongroup import BaseExceptionGroup, catch
 
 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 +30,7 @@ class Rule:
 
     __slots__ = ("checkers",)
 
-    HANDLER_PARAM_TYPES = [
+    HANDLER_PARAM_TYPES: ClassVar[list[type[Param]]] = [
         DependParam,
         BotParam,
         EventParam,
@@ -37,7 +39,7 @@ class Rule:
     ]
 
     def __init__(self, *checkers: Union[T_RuleChecker, Dependent[bool]]) -> None:
-        self.checkers: Set[Dependent[bool]] = {
+        self.checkers: set[Dependent[bool]] = {
             (
                 checker
                 if isinstance(checker, Dependent)
@@ -71,22 +73,33 @@ class Rule:
         """
         if not self.checkers:
             return True
-        try:
+
-            results = await asyncio.gather(
+        result = True
-                *(
+
-                    checker(
+        def _handle_skipped_exception(
-                        bot=bot,
+            exc_group: BaseExceptionGroup[SkippedException],
-                        event=event,
+        ) -> None:
-                        state=state,
+            nonlocal result
-                        stack=stack,
+            result = False
-                        dependency_cache=dependency_cache,
+
-                    )
+        async def _run_checker(checker: Dependent[bool]) -> None:
-                    for checker in self.checkers
+            nonlocal result
-                )
+            # calculate the result first to avoid data racing
+            is_passed = await checker(
+                bot=bot,
+                event=event,
+                state=state,
+                stack=stack,
+                dependency_cache=dependency_cache,
             )
-        except SkippedException:
+            result &= is_passed
-            return False
+
-        return all(results)
+        with catch({SkippedException: _handle_skipped_exception}):
+            async with anyio.create_task_group() as tg:
+                for checker in self.checkers:
+                    tg.start_soon(_run_checker, checker)
+
+        return result
 
     def __and__(self, other: Optional[Union["Rule", T_RuleChecker]]) -> "Rule":
         if other is None:

nonebot/log.py

@@ -8,11 +8,14 @@ NoneBot 使用 [`loguru`][loguru] 来记录日志信息。
 [loguru]: https://github.com/Delgan/loguru
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 7
     description: nonebot.log 模块
 """
 
 import sys
+import inspect
 import logging
 from typing import TYPE_CHECKING
 
@@ -45,6 +48,7 @@ logger: "Logger" = loguru.logger
 # logger.addHandler(default_handler)
 
 
+# https://loguru.readthedocs.io/en/stable/overview.html#entirely-compatible-with-standard-logging
 class LoguruHandler(logging.Handler):  # pragma: no cover
     """logging 与 loguru 之间的桥梁，将 logging 的日志转发到 loguru。"""
 
@@ -54,8 +58,8 @@ class LoguruHandler(logging.Handler):  # pragma: no cover
         except ValueError:
             level = record.levelno
 
-        frame, depth = sys._getframe(6), 6
+        frame, depth = inspect.currentframe(), 0
-        while frame and frame.f_code.co_filename == logging.__file__:
+        while frame and (depth == 0 or frame.f_code.co_filename == logging.__file__):
             frame = frame.f_back
             depth += 1
 

nonebot/matcher.py

@@ -1,6 +1,8 @@
 """本模块实现事件响应器的创建与运行，并提供一些快捷方法来帮助用户更好的与机器人进行对话。
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 3
     description: nonebot.matcher 模块
 """

nonebot/message.py

@@ -3,27 +3,36 @@
 NoneBot 内部处理并按优先级分发事件给所有事件响应器，提供了多个插槽以进行事件的预处理等。
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 2
     description: nonebot.message 模块
 """
 
-import asyncio
 import contextlib
 from datetime import datetime
 from contextlib import AsyncExitStack
-from typing import TYPE_CHECKING, Any, Set, Dict, Type, Optional
+from typing import TYPE_CHECKING, Any, Callable, Optional
+
+import anyio
+from exceptiongroup import BaseExceptionGroup, catch
 
 from nonebot.log import logger
 from nonebot.rule import TrieRule
 from nonebot.dependencies import Dependent
 from nonebot.matcher import Matcher, matchers
-from nonebot.utils import escape_tag, run_coro_with_catch
 from nonebot.exception import (
     NoLogException,
     StopPropagation,
     IgnoredException,
     SkippedException,
 )
+from nonebot.utils import (
+    escape_tag,
+    run_coro_with_catch,
+    run_coro_with_shield,
+    flatten_exception_group,
+)
 from nonebot.typing import (
     T_State,
     T_DependencyCache,
@@ -46,10 +55,10 @@ from nonebot.internal.params import (
 if TYPE_CHECKING:
     from nonebot.adapters import Bot, Event
 
-_event_preprocessors: Set[Dependent[Any]] = set()
+_event_preprocessors: set[Dependent[Any]] = set()
-_event_postprocessors: Set[Dependent[Any]] = set()
+_event_postprocessors: set[Dependent[Any]] = set()
-_run_preprocessors: Set[Dependent[Any]] = set()
+_run_preprocessors: set[Dependent[Any]] = set()
-_run_postprocessors: Set[Dependent[Any]] = set()
+_run_postprocessors: set[Dependent[Any]] = set()
 
 EVENT_PCS_PARAMS = (
     DependParam,
@@ -123,6 +132,21 @@ def run_postprocessor(func: T_RunPostProcessor) -> T_RunPostProcessor:
     return func
 
 
+def _handle_ignored_exception(msg: str) -> Callable[[BaseExceptionGroup], None]:
+    def _handle(exc_group: BaseExceptionGroup[IgnoredException]) -> None:
+        logger.opt(colors=True).info(msg)
+
+    return _handle
+
+
+def _handle_exception(msg: str) -> Callable[[BaseExceptionGroup], None]:
+    def _handle(exc_group: BaseExceptionGroup[Exception]) -> None:
+        for exc in flatten_exception_group(exc_group):
+            logger.opt(colors=True, exception=exc).error(msg)
+
+    return _handle
+
+
 async def _apply_event_preprocessors(
     bot: "Bot",
     event: "Event",
@@ -150,10 +174,21 @@ async def _apply_event_preprocessors(
     if show_log:
         logger.debug("Running PreProcessors...")
 
-    try:
+    with catch(
-        await asyncio.gather(
+        {
-            *(
+            IgnoredException: _handle_ignored_exception(
-                run_coro_with_catch(
+                f"Event {escape_tag(event.get_event_name())} is <b>ignored</b>"
+            ),
+            Exception: _handle_exception(
+                "<r><bg #f8bbd0>Error when running EventPreProcessors. "
+                "Event ignored!</bg #f8bbd0></r>"
+            ),
+        }
+    ):
+        async with anyio.create_task_group() as tg:
+            for proc in _event_preprocessors:
+                tg.start_soon(
+                    run_coro_with_catch,
                     proc(
                         bot=bot,
                         event=event,
@@ -163,22 +198,10 @@ async def _apply_event_preprocessors(
                     ),
                     (SkippedException,),
                 )
-                for proc in _event_preprocessors
-            )
-        )
-    except IgnoredException:
-        logger.opt(colors=True).info(
-            f"Event {escape_tag(event.get_event_name())} is <b>ignored</b>"
-        )
-        return False
-    except Exception as e:
-        logger.opt(colors=True, exception=e).error(
-            "<r><bg #f8bbd0>Error when running EventPreProcessors. "
-            "Event ignored!</bg #f8bbd0></r>"
-        )
-        return False
 
-    return True
+        return True
+
+    return False
 
 
 async def _apply_event_postprocessors(
@@ -205,10 +228,17 @@ async def _apply_event_postprocessors(
     if show_log:
         logger.debug("Running PostProcessors...")
 
-    try:
+    with catch(
-        await asyncio.gather(
+        {
-            *(
+            Exception: _handle_exception(
-                run_coro_with_catch(
+                "<r><bg #f8bbd0>Error when running EventPostProcessors</bg #f8bbd0></r>"
+            )
+        }
+    ):
+        async with anyio.create_task_group() as tg:
+            for proc in _event_postprocessors:
+                tg.start_soon(
+                    run_coro_with_catch,
                     proc(
                         bot=bot,
                         event=event,
@@ -218,13 +248,6 @@ async def _apply_event_postprocessors(
                     ),
                     (SkippedException,),
                 )
-                for proc in _event_postprocessors
-            )
-        )
-    except Exception as e:
-        logger.opt(colors=True, exception=e).error(
-            "<r><bg #f8bbd0>Error when running EventPostProcessors</bg #f8bbd0></r>"
-        )
 
 
 async def _apply_run_preprocessors(
@@ -252,35 +275,38 @@ async def _apply_run_preprocessors(
         return True
 
     # ensure matcher function can be correctly called
-    with matcher.ensure_context(bot, event):
+    with (
-        try:
+        matcher.ensure_context(bot, event),
-            await asyncio.gather(
+        catch(
-                *(
+            {
-                    run_coro_with_catch(
+                IgnoredException: _handle_ignored_exception(
-                        proc(
+                    f"{matcher} running is <b>cancelled</b>"
-                            matcher=matcher,
+                ),
-                            bot=bot,
+                Exception: _handle_exception(
-                            event=event,
+                    "<r><bg #f8bbd0>Error when running RunPreProcessors. "
-                            state=state,
+                    "Running cancelled!</bg #f8bbd0></r>"
-                            stack=stack,
+                ),
-                            dependency_cache=dependency_cache,
+            }
-                        ),
+        ),
-                        (SkippedException,),
+    ):
-                    )
+        async with anyio.create_task_group() as tg:
-                    for proc in _run_preprocessors
+            for proc in _run_preprocessors:
+                tg.start_soon(
+                    run_coro_with_catch,
+                    proc(
+                        matcher=matcher,
+                        bot=bot,
+                        event=event,
+                        state=state,
+                        stack=stack,
+                        dependency_cache=dependency_cache,
+                    ),
+                    (SkippedException,),
                 )
-            )
-        except IgnoredException:
-            logger.opt(colors=True).info(f"{matcher} running is <b>cancelled</b>")
-            return False
-        except Exception as e:
-            logger.opt(colors=True, exception=e).error(
-                "<r><bg #f8bbd0>Error when running RunPreProcessors. "
-                "Running cancelled!</bg #f8bbd0></r>"
-            )
-            return False
 
-    return True
+        return True
+
+    return False
 
 
 async def _apply_run_postprocessors(
@@ -304,33 +330,36 @@ async def _apply_run_postprocessors(
     if not _run_postprocessors:
         return
 
-    with matcher.ensure_context(bot, event):
+    with (
-        try:
+        matcher.ensure_context(bot, event),
-            await asyncio.gather(
+        catch(
-                *(
+            {
-                    run_coro_with_catch(
+                Exception: _handle_exception(
-                        proc(
+                    "<r><bg #f8bbd0>Error when running RunPostProcessors"
-                            matcher=matcher,
+                    "</bg #f8bbd0></r>"
-                            exception=exception,
+                )
-                            bot=bot,
+            }
-                            event=event,
+        ),
-                            state=matcher.state,
+    ):
-                            stack=stack,
+        async with anyio.create_task_group() as tg:
-                            dependency_cache=dependency_cache,
+            for proc in _run_postprocessors:
-                        ),
+                tg.start_soon(
-                        (SkippedException,),
+                    run_coro_with_catch,
-                    )
+                    proc(
-                    for proc in _run_postprocessors
+                        matcher=matcher,
+                        exception=exception,
+                        bot=bot,
+                        event=event,
+                        state=matcher.state,
+                        stack=stack,
+                        dependency_cache=dependency_cache,
+                    ),
+                    (SkippedException,),
                 )
-            )
-        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],
+    Matcher: type[Matcher],
     bot: "Bot",
     event: "Event",
     state: T_State,
@@ -381,7 +410,7 @@ async def _check_matcher(
 
 
 async def _run_matcher(
-    Matcher: Type[Matcher],
+    Matcher: type[Matcher],
     bot: "Bot",
     event: "Event",
     state: T_State,
@@ -423,8 +452,9 @@ async def _run_matcher(
 
     exception = None
 
+    logger.debug(f"Running {matcher}")
+
     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(
@@ -446,7 +476,7 @@ async def _run_matcher(
 
 
 async def check_and_run_matcher(
-    Matcher: Type[Matcher],
+    Matcher: type[Matcher],
     bot: "Bot",
     event: "Event",
     state: T_State,
@@ -492,8 +522,7 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
 
     用法:
         ```python
-        import asyncio
+        driver.task_group.start_soon(handle_event, bot, event)
-        asyncio.create_task(handle_event(bot, event))
         ```
     """
     show_log = True
@@ -505,7 +534,7 @@ 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
@@ -528,6 +557,13 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
             )
 
         break_flag = False
+
+        def _handle_stop_propagation(exc_group: BaseExceptionGroup) -> None:
+            nonlocal break_flag
+
+            break_flag = True
+            logger.debug("Stop event propagation")
+
         # iterate through all priority until stop propagation
         for priority in sorted(matchers.keys()):
             if break_flag:
@@ -536,23 +572,30 @@ async def handle_event(bot: "Bot", event: "Event") -> None:
             if show_log:
                 logger.debug(f"Checking for matchers in priority {priority}...")
 
-            pending_tasks = [
+            if not (priority_matchers := matchers[priority]):
-                check_and_run_matcher(
+                continue
-                    matcher, bot, event, state.copy(), stack, dependency_cache
+
-                )
+            with catch(
-                for matcher in matchers[priority]
+                {
-            ]
+                    StopPropagation: _handle_stop_propagation,
-            results = await asyncio.gather(*pending_tasks, return_exceptions=True)
+                    Exception: _handle_exception(
-            for result in results:
-                if not isinstance(result, Exception):
-                    continue
-                if isinstance(result, StopPropagation):
-                    break_flag = True
-                    logger.debug("Stop event propagation")
-                else:
-                    logger.opt(colors=True, exception=result).error(
                         "<r><bg #f8bbd0>Error when checking Matcher.</bg #f8bbd0></r>"
-                    )
+                    ),
+                }
+            ):
+                async with anyio.create_task_group() as tg:
+                    for matcher in priority_matchers:
+                        tg.start_soon(
+                            run_coro_with_shield,
+                            check_and_run_matcher(
+                                matcher,
+                                bot,
+                                event,
+                                state.copy(),
+                                stack,
+                                dependency_cache,
+                            ),
+                        )
 
         if show_log:
             logger.debug("Checking for matchers completed")

nonebot/params.py

@@ -1,22 +1,14 @@
 """本模块定义了依赖注入的各类参数。
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 4
     description: nonebot.params 模块
 """
 
-from typing import (
+from re import Match
-    Any,
+from typing import Any, Union, Literal, Callable, Optional, overload
-    Dict,
-    List,
-    Match,
-    Tuple,
-    Union,
-    Literal,
-    Callable,
-    Optional,
-    overload,
-)
 
 from nonebot.typing import T_State
 from nonebot.matcher import Matcher
@@ -90,7 +82,7 @@ def _command(state: T_State) -> Message:
     return state[PREFIX_KEY][CMD_KEY]
 
 
-def Command() -> Tuple[str, ...]:
+def Command() -> tuple[str, ...]:
     """消息命令元组"""
     return Depends(_command)
 
@@ -140,7 +132,7 @@ def ShellCommandArgs() -> Any:
     return Depends(_shell_command_args, use_cache=False)
 
 
-def _shell_command_argv(state: T_State) -> List[Union[str, MessageSegment]]:
+def _shell_command_argv(state: T_State) -> list[Union[str, MessageSegment]]:
     return state[SHELL_ARGV]
 
 
@@ -159,11 +151,11 @@ def RegexMatched() -> Match[str]:
 
 
 def _regex_str(
-    groups: Tuple[Union[str, int], ...]
+    groups: tuple[Union[str, int], ...]
-) -> Callable[[T_State], Union[str, Tuple[Union[str, Any], ...], Any]]:
+) -> Callable[[T_State], Union[str, tuple[Union[str, Any], ...], Any]]:
     def _regex_str_dependency(
         state: T_State,
-    ) -> Union[str, Tuple[Union[str, Any], ...], Any]:
+    ) -> Union[str, tuple[Union[str, Any], ...], Any]:
         return _regex_matched(state).group(*groups)
 
     return _regex_str_dependency
@@ -180,28 +172,28 @@ 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], ...]: ...
+) -> tuple[Union[str, Any], ...]: ...
 
 
-def RegexStr(*groups: Union[str, int]) -> Union[str, Tuple[Union[str, Any], ...], 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, ...]:
+def _regex_group(state: T_State) -> tuple[Any, ...]:
     return _regex_matched(state).groups()
 
 
-def RegexGroup() -> Tuple[Any, ...]:
+def RegexGroup() -> tuple[Any, ...]:
     """正则匹配结果 group 元组"""
     return Depends(_regex_group, use_cache=False)
 
 
-def _regex_dict(state: T_State) -> Dict[str, Any]:
+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)
 

nonebot/permission.py

@@ -5,6 +5,8 @@
 只要有一个 `PermissionChecker` 检查结果为 `True` 时就会继续运行。
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 6
     description: nonebot.permission 模块
 """

nonebot/plugin/__init__.py

@@ -32,6 +32,8 @@
 - `PluginMetadata` => {ref}``PluginMetadata` <nonebot.plugin.model.PluginMetadata>`
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 0
     description: nonebot.plugin 模块
 """
@@ -39,7 +41,7 @@ FrontMatter:
 from itertools import chain
 from types import ModuleType
 from contextvars import ContextVar
-from typing import Set, Dict, List, Type, Tuple, TypeVar, Optional
+from typing import TypeVar, Optional
 
 from pydantic import BaseModel
 
@@ -48,10 +50,10 @@ from nonebot.compat import model_dump, type_validate_python
 
 C = TypeVar("C", bound=BaseModel)
 
-_plugins: Dict[str, "Plugin"] = {}
+_plugins: dict[str, "Plugin"] = {}
-_managers: List["PluginManager"] = []
+_managers: list["PluginManager"] = []
-_current_plugin_chain: ContextVar[Tuple["Plugin", ...]] = ContextVar(
+_current_plugin: ContextVar[Optional["Plugin"]] = ContextVar(
-    "_current_plugin_chain", default=()
+    "_current_plugin", default=None
 )
 
 
@@ -59,34 +61,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)
+    plugin_id = _module_name_to_plugin_id(module_name)
-    if plugin_name in _plugins:
+    if plugin_id in _plugins:
-        raise RuntimeError("Plugin already exists! Check your plugin name.")
+        raise RuntimeError(
-    plugin = Plugin(plugin_name, module, module_name, manager)
+            f"Plugin {plugin_id} already exists! Check your plugin name."
-    _plugins[plugin_name] = plugin
+        )
+
+    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.remove(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.model.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"]:
@@ -105,17 +160,17 @@ def get_plugin_by_module_name(module_name: str) -> Optional["Plugin"]:
         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:
+def get_plugin_config(config: type[C]) -> C:
     """从全局配置获取当前插件需要的配置项。"""
     return type_validate_python(config, model_dump(get_driver().config))
 

nonebot/plugin/load.py

@@ -1,6 +1,8 @@
 """本模块定义插件加载接口。
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 1
     description: nonebot.plugin.load 模块
 """
@@ -8,18 +10,19 @@ FrontMatter:
 import json
 from pathlib import Path
 from types import ModuleType
-from typing import Set, Union, Iterable, Optional
+from typing import Union, Optional
+from collections.abc import Iterable
 
 from nonebot.utils import path_to_module_name
 
 from .model import Plugin
 from .manager import PluginManager
-from . import _managers, get_plugin, _current_plugin_chain, _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
+    import tomli as tomllib  # pyright: ignore[reportMissingImports]
 
 
 def load_plugin(module_path: Union[str, Path]) -> Optional[Plugin]:
@@ -39,7 +42,7 @@ def load_plugin(module_path: Union[str, Path]) -> Optional[Plugin]:
     return manager.load_plugin(module_path)
 
 
-def load_plugins(*plugin_dir: str) -> Set[Plugin]:
+def load_plugins(*plugin_dir: str) -> set[Plugin]:
     """导入文件夹下多个插件，以 `_` 开头的插件不会被导入!
 
     参数:
@@ -52,7 +55,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]:
     """导入指定列表中的插件以及指定目录下多个插件，以 `_` 开头的插件不会被导入!
 
     参数:
@@ -64,7 +67,7 @@ def load_all_plugins(
     return manager.load_all_plugins()
 
 
-def load_from_json(file_path: str, encoding: str = "utf-8") -> Set[Plugin]:
+def load_from_json(file_path: str, encoding: str = "utf-8") -> set[Plugin]:
     """导入指定 json 文件中的 `plugins` 以及 `plugin_dirs` 下多个插件。
     以 `_` 开头的插件不会被导入!
 
@@ -95,7 +98,7 @@ 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]:
+def load_from_toml(file_path: str, encoding: str = "utf-8") -> set[Plugin]:
     """导入指定 toml 文件 `[tool.nonebot]` 中的
     `plugins` 以及 `plugin_dirs` 下多个插件。
     以 `_` 开头的插件不会被导入!
@@ -139,7 +142,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 内置插件。
 
     参数:
@@ -150,41 +153,45 @@ 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) -> ModuleType:
-    """获取一个插件的导出内容。
+    """声明依赖插件。
-
-    如果为 `load_plugins` 文件夹导入的插件，则为文件(夹)名。
 
     参数:
-        name: 插件名，即 {ref}`nonebot.plugin.model.Plugin.name`。
+        name: 插件模块名或插件标识符，仅在已声明插件的情况下可使用标识符。
 
     异常:
         RuntimeError: 插件无法加载
     """
-    plugin = get_plugin(_module_name_to_plugin_name(name))
+    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 not plugin:
+    if plugin is None:
-        # plugin already declared
+        # 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:
-            # clear current plugin chain, ensure plugin loaded in a new context
+            plugin = load_plugin(name)
-            _t = _current_plugin_chain.set(())
+
-            try:
+    if plugin is None:
-                plugin = load_plugin(name)
-            finally:
-                _current_plugin_chain.reset(_t)
-    if not plugin:
         raise RuntimeError(f'Cannot load plugin "{name}"!')
     return plugin.module
 
 
-def inherit_supported_adapters(*names: str) -> Optional[Set[str]]:
+def inherit_supported_adapters(*names: str) -> Optional[set[str]]:
     """获取已加载插件的适配器支持状态集合。
 
     如果传入了多个插件名称，返回值会自动取交集。
@@ -196,27 +203,28 @@ def inherit_supported_adapters(*names: str) -> Optional[Set[str]]:
         RuntimeError: 插件未加载
         ValueError: 插件缺少元数据
     """
-    final_supported: Optional[Set[str]] = None
+    final_supported: Optional[set[str]] = None
 
     for name in names:
-        plugin = get_plugin(_module_name_to_plugin_name(name))
+        plugin = get_plugin(_module_name_to_plugin_id(name))
         if plugin is None:
-            raise RuntimeError(f'Plugin "{name}" is not loaded!')
+            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!')
-        support = meta.supported_adapters
+
-        if support is None:
+        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 and {
+    return final_supported
-        (
-            f"nonebot.adapters.{adapter_name[1:]}"
-            if adapter_name.startswith("~")
-            else adapter_name
-        )
-        for adapter_name in final_supported
-    }

nonebot/plugin/manager.py

@@ -3,6 +3,8 @@
 参考: [import hooks](https://docs.python.org/3/reference/import.html#import-hooks), [PEP302](https://www.python.org/dev/peps/pep-0302/)
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 5
     description: nonebot.plugin.manager 模块
 """
@@ -12,10 +14,11 @@ 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, Iterable, Optional, Sequence
 
 from nonebot.log import logger
 from nonebot.utils import escape_tag, path_to_module_name
@@ -25,8 +28,8 @@ from . import (
     _managers,
     _new_plugin,
     _revert_plugin,
-    _current_plugin_chain,
+    _current_plugin,
-    _module_name_to_plugin_name,
+    _module_name_to_plugin_id,
 )
 
 
@@ -35,7 +38,7 @@ class PluginManager:
 
     参数:
         plugins: 独立插件模块名集合。
-        search_path: 插件搜索路径（文件夹）。
+        search_path: 插件搜索路径（文件夹），相对于当前工作目录。
     """
 
     def __init__(
@@ -44,60 +47,78 @@ class PluginManager:
         search_path: Optional[Iterable[str]] = None,
     ):
         # simple plugin not in search path
-        self.plugins: Set[str] = set(plugins or [])
+        self.plugins: set[str] = set(plugins or [])
-        self.search_path: Set[str] = set(search_path or [])
+        self.search_path: set[str] = set(search_path or [])
 
         # cache plugins
-        self._third_party_plugin_names: Dict[str, str] = {}
+        self._third_party_plugin_ids: dict[str, str] = {}
-        self._searched_plugin_names: Dict[str, Path] = {}
+        self._searched_plugin_ids: dict[str, str] = {}
-        self.prepare_plugins()
+        self._prepare_plugins()
 
     def __repr__(self) -> str:
-        return f"PluginManager(plugins={self.plugins}, search_path={self.search_path})"
+        return f"PluginManager(available_plugins={self.controlled_modules})"
 
     @property
-    def third_party_plugins(self) -> Set[str]:
+    def third_party_plugins(self) -> set[str]:
-        """返回所有独立插件名称。"""
+        """返回所有独立插件标识符。"""
-        return set(self._third_party_plugin_names.keys())
+        return set(self._third_party_plugin_ids.keys())
 
     @property
-    def searched_plugins(self) -> Set[str]:
+    def searched_plugins(self) -> set[str]:
-        """返回已搜索到的插件名称。"""
+        """返回已搜索到的插件标识符。"""
-        return set(self._searched_plugin_names.keys())
+        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 _previous_plugins(self) -> Set[str]:
+    @property
-        _pre_managers: List[PluginManager]
+    def controlled_modules(self) -> dict[str, str]:
+        """返回当前插件管理器中控制的插件标识符与模块路径映射字典。"""
+        return dict(
+            chain(
+                self._third_party_plugin_ids.items(), self._searched_plugin_ids.items()
+            )
+        )
+
+    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()
+        previous_plugin_ids = self._previous_controlled_modules()
-        searched_plugins: Dict[str, Path] = {}
+
-        third_party_plugins: Dict[str, str] = {}
+        # 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)
+            plugin_id = _module_name_to_plugin_id(plugin, get_controlled_modules())
-            if name in third_party_plugins or name in previous_plugins:
+            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_ids[plugin_id] = plugin
-
-        self._third_party_plugin_names = third_party_plugins
 
         # check plugins in search path
         for module_info in pkgutil.iter_modules(self.search_path):
@@ -105,47 +126,55 @@ class PluginManager:
             if module_info.name.startswith("_"):
                 continue
 
-            if (
-                module_info.name in searched_plugins
-                or module_info.name in previous_plugins
-                or module_info.name in third_party_plugins
-            ):
-                raise RuntimeError(
-                    f"Plugin already exists: {module_info.name}! Check your plugin name"
-                )
-
             if not (
                 module_spec := module_info.module_finder.find_spec(
                     module_info.name, None
                 )
             ):
                 continue
-            if not (module_path := module_spec.origin):
-                continue
-            searched_plugins[module_info.name] = Path(module_path).resolve()
 
-        self._searched_plugin_names = searched_plugins
+            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 (
+                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: {plugin_id}! Check your plugin name"
+                )
+
+            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(
-                    path_to_module_name(self._searched_plugin_names[name])
-                )
             else:
                 raise RuntimeError(f"Plugin not found: {name}! Check your plugin name")
 
@@ -154,13 +183,13 @@ class PluginManager:
             ) 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.name)}</y>"'
+                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.name
+                    if plugin.module_name != plugin.id_
                     else ""
                 )
             )
@@ -170,7 +199,7 @@ class PluginManager:
                 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(
@@ -192,21 +221,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.controlled_modules.values():
-                if (
-                    fullname in manager.plugins
-                    or module_path in manager._searched_plugin_names.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)
@@ -226,17 +250,8 @@ class PluginLoader(SourceFileLoader):
         plugin = _new_plugin(self.name, module, self.manager)
         setattr(module, "__plugin__", plugin)
 
-        # detect parent plugin before entering current plugin context
-        parent_plugins = _current_plugin_chain.get()
-        for pre_plugin in reversed(parent_plugins):
-            # ensure parent plugin is declared before current plugin
-            if _managers.index(pre_plugin.manager) < _managers.index(self.manager):
-                plugin.parent_plugin = pre_plugin
-                pre_plugin.sub_plugins.add(plugin)
-                break
-
         # enter plugin context
-        _plugin_token = _current_plugin_chain.set(parent_plugins + (plugin,))
+        _plugin_token = _current_plugin.set(plugin)
 
         try:
             super().exec_module(module)
@@ -245,7 +260,7 @@ class PluginLoader(SourceFileLoader):
             raise
         finally:
             # leave plugin context
-            _current_plugin_chain.reset(_plugin_token)
+            _current_plugin.reset(_plugin_token)
 
         # get plugin metadata
         metadata: Optional[PluginMetadata] = getattr(module, "__plugin_meta__", None)

nonebot/plugin/model.py

@@ -1,6 +1,8 @@
 """本模块定义插件相关信息。
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 3
     description: nonebot.plugin.model 模块
 """
@@ -8,7 +10,7 @@ FrontMatter:
 import contextlib
 from types import ModuleType
 from dataclasses import field, dataclass
-from typing import TYPE_CHECKING, Any, Set, Dict, Type, Optional
+from typing import TYPE_CHECKING, Any, Type, Optional  # noqa: UP035
 
 from pydantic import BaseModel
 
@@ -35,19 +37,19 @@ class PluginMetadata:
     """插件类型，用于商店分类"""
     homepage: Optional[str] = None
     """插件主页"""
-    config: Optional[Type[BaseModel]] = None
+    config: Optional[Type[BaseModel]] = None  # noqa: UP006
     """插件配置项"""
-    supported_adapters: Optional[Set[str]] = None
+    supported_adapters: Optional[set[str]] = None
     """插件支持的适配器模块路径
 
     格式为 `<module>[:<Adapter>]`，`~` 为 `nonebot.adapters.` 的缩写。
 
     `None` 表示支持**所有适配器**。
     """
-    extra: Dict[Any, Any] = field(default_factory=dict)
+    extra: dict[Any, Any] = field(default_factory=dict)
     """插件额外信息，可由插件编写者自由扩展定义"""
 
-    def get_supported_adapters(self) -> Optional[Set[Type["Adapter"]]]:
+    def get_supported_adapters(self) -> Optional[set[Type["Adapter"]]]:  # noqa: UP006
         """获取当前已安装的插件支持适配器类列表"""
         if self.supported_adapters is None:
             return None
@@ -66,17 +68,24 @@ class Plugin:
     """存储插件信息"""
 
     name: str
-    """插件索引标识，NoneBot 使用 文件/文件夹 名称作为标识符"""
+    """插件名称，NoneBot 使用 文件/文件夹 名称作为插件名称"""
     module: ModuleType
     """插件模块对象"""
     module_name: str
     """点分割模块路径"""
     manager: "PluginManager"
     """导入该插件的插件管理器"""
-    matcher: Set[Type[Matcher]] = field(default_factory=set)
+    matcher: set[type[Matcher]] = field(default_factory=set)
     """插件加载时定义的 `Matcher`"""
     parent_plugin: Optional["Plugin"] = None
     """父插件"""
-    sub_plugins: Set["Plugin"] = field(default_factory=set)
+    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.py

@@ -1,6 +1,8 @@
 """本模块定义事件响应器便携定义函数。
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 2
     description: nonebot.plugin.on 模块
 """
@@ -9,8 +11,8 @@ import re
 import inspect
 import warnings
 from types import ModuleType
+from typing import Any, Union, Optional
 from datetime import datetime, timedelta
-from typing import Any, Set, Dict, List, Type, Tuple, Union, Optional
 
 from nonebot.adapters import Event
 from nonebot.permission import Permission
@@ -31,19 +33,19 @@ from nonebot.rule import (
 )
 
 from .model import Plugin
+from .manager import _current_plugin
 from . import get_plugin_by_module_name
-from .manager import _current_plugin_chain
 
 
-def store_matcher(matcher: Type[Matcher]) -> None:
+def store_matcher(matcher: type[Matcher]) -> None:
     """存储一个事件响应器到插件。
 
     参数:
         matcher: 事件响应器
     """
     # only store the matcher defined when plugin loading
-    if plugin_chain := _current_plugin_chain.get():
+    if plugin := _current_plugin.get():
-        plugin_chain[-1].matcher.add(matcher)
+        plugin.matcher.add(matcher)
 
 
 def get_matcher_plugin(depth: int = 1) -> Optional[Plugin]:  # pragma: no cover
@@ -76,7 +78,7 @@ def get_matcher_module(depth: int = 1) -> Optional[ModuleType]:  # pragma: no co
     return (source := get_matcher_source(depth + 1)) and source.module
 
 
-def get_matcher_source(depth: int = 1) -> Optional[MatcherSource]:
+def get_matcher_source(depth: int = 0) -> Optional[MatcherSource]:
     """获取事件响应器定义所在源码信息。
 
     参数:
@@ -85,20 +87,25 @@ def get_matcher_source(depth: int = 1) -> Optional[MatcherSource]:
     current_frame = inspect.currentframe()
     if current_frame is None:
         return None
-    frame = inspect.getouterframes(current_frame)[depth + 1].frame
+
+    frame = current_frame
+    d = depth + 1
+    while d > 0:
+        frame = frame.f_back
+        if frame is None:
+            raise ValueError("Depth out of range")
+        d -= 1
 
     module_name = (module := inspect.getmodule(frame)) and module.__name__
 
-    plugin: Optional["Plugin"] = None
     # matcher defined when plugin loading
-    if plugin_chain := _current_plugin_chain.get():
+    plugin: Optional["Plugin"] = _current_plugin.get()
-        plugin = plugin_chain[-1]
     # matcher defined when plugin running
-    elif module_name:
+    if plugin is None and module_name:
         plugin = get_plugin_by_module_name(module_name)
 
     return MatcherSource(
-        plugin_name=plugin and plugin.name,
+        plugin_id=plugin and plugin.id_,
         module_name=module_name,
         lineno=frame.f_lineno,
     )
@@ -109,14 +116,14 @@ def on(
     rule: Optional[Union[Rule, T_RuleChecker]] = None,
     permission: Optional[Union[Permission, T_PermissionChecker]] = None,
     *,
-    handlers: Optional[List[Union[T_Handler, Dependent]]] = None,
+    handlers: Optional[list[Union[T_Handler, Dependent[Any]]]] = None,
     temp: bool = False,
     expire_time: Optional[Union[datetime, timedelta]] = None,
     priority: int = 1,
     block: bool = False,
     state: Optional[T_State] = None,
     _depth: int = 0,
-) -> Type[Matcher]:
+) -> type[Matcher]:
     """注册一个基础事件响应器，可自定义类型。
 
     参数:
@@ -146,7 +153,7 @@ def on(
     return matcher
 
 
-def on_metaevent(*args, _depth: int = 0, **kwargs) -> Type[Matcher]:
+def on_metaevent(*args, _depth: int = 0, **kwargs) -> type[Matcher]:
     """注册一个元事件响应器。
 
     参数:
@@ -162,7 +169,7 @@ def on_metaevent(*args, _depth: int = 0, **kwargs) -> Type[Matcher]:
     return on("meta_event", *args, **kwargs, _depth=_depth + 1)
 
 
-def on_message(*args, _depth: int = 0, **kwargs) -> Type[Matcher]:
+def on_message(*args, _depth: int = 0, **kwargs) -> type[Matcher]:
     """注册一个消息事件响应器。
 
     参数:
@@ -179,7 +186,7 @@ def on_message(*args, _depth: int = 0, **kwargs) -> Type[Matcher]:
     return on("message", *args, **kwargs, _depth=_depth + 1)
 
 
-def on_notice(*args, _depth: int = 0, **kwargs) -> Type[Matcher]:
+def on_notice(*args, _depth: int = 0, **kwargs) -> type[Matcher]:
     """注册一个通知事件响应器。
 
     参数:
@@ -195,7 +202,7 @@ def on_notice(*args, _depth: int = 0, **kwargs) -> Type[Matcher]:
     return on("notice", *args, **kwargs, _depth=_depth + 1)
 
 
-def on_request(*args, _depth: int = 0, **kwargs) -> Type[Matcher]:
+def on_request(*args, _depth: int = 0, **kwargs) -> type[Matcher]:
     """注册一个请求事件响应器。
 
     参数:
@@ -212,12 +219,12 @@ def on_request(*args, _depth: int = 0, **kwargs) -> Type[Matcher]:
 
 
 def on_startswith(
-    msg: Union[str, Tuple[str, ...]],
+    msg: Union[str, tuple[str, ...]],
     rule: Optional[Union[Rule, T_RuleChecker]] = None,
     ignorecase: bool = False,
     _depth: int = 0,
     **kwargs,
-) -> Type[Matcher]:
+) -> type[Matcher]:
     """注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。
 
     参数:
@@ -236,12 +243,12 @@ def on_startswith(
 
 
 def on_endswith(
-    msg: Union[str, Tuple[str, ...]],
+    msg: Union[str, tuple[str, ...]],
     rule: Optional[Union[Rule, T_RuleChecker]] = None,
     ignorecase: bool = False,
     _depth: int = 0,
     **kwargs,
-) -> Type[Matcher]:
+) -> type[Matcher]:
     """注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。
 
     参数:
@@ -260,12 +267,12 @@ def on_endswith(
 
 
 def on_fullmatch(
-    msg: Union[str, Tuple[str, ...]],
+    msg: Union[str, tuple[str, ...]],
     rule: Optional[Union[Rule, T_RuleChecker]] = None,
     ignorecase: bool = False,
     _depth: int = 0,
     **kwargs,
-) -> Type[Matcher]:
+) -> type[Matcher]:
     """注册一个消息事件响应器，并且当消息的**文本部分**与指定内容完全一致时响应。
 
     参数:
@@ -284,11 +291,11 @@ def on_fullmatch(
 
 
 def on_keyword(
-    keywords: Set[str],
+    keywords: set[str],
     rule: Optional[Union[Rule, T_RuleChecker]] = None,
     _depth: int = 0,
     **kwargs,
-) -> Type[Matcher]:
+) -> type[Matcher]:
     """注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。
 
     参数:
@@ -306,13 +313,13 @@ def on_keyword(
 
 
 def on_command(
-    cmd: Union[str, Tuple[str, ...]],
+    cmd: Union[str, tuple[str, ...]],
     rule: Optional[Union[Rule, T_RuleChecker]] = None,
-    aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = None,
+    aliases: Optional[set[Union[str, tuple[str, ...]]]] = None,
     force_whitespace: Optional[Union[str, bool]] = None,
     _depth: int = 0,
     **kwargs,
-) -> Type[Matcher]:
+) -> type[Matcher]:
     """注册一个消息事件响应器，并且当消息以指定命令开头时响应。
 
     命令匹配规则参考: `命令形式匹配 <rule.md#command-command>`_
@@ -341,13 +348,13 @@ def on_command(
 
 
 def on_shell_command(
-    cmd: Union[str, Tuple[str, ...]],
+    cmd: Union[str, tuple[str, ...]],
     rule: Optional[Union[Rule, T_RuleChecker]] = None,
-    aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = None,
+    aliases: Optional[set[Union[str, tuple[str, ...]]]] = None,
     parser: Optional[ArgumentParser] = None,
     _depth: int = 0,
     **kwargs,
-) -> Type[Matcher]:
+) -> type[Matcher]:
     """注册一个支持 `shell_like` 解析参数的命令消息事件响应器。
 
     与普通的 `on_command` 不同的是，在添加 `parser` 参数时, 响应器会自动处理消息。
@@ -383,7 +390,7 @@ def on_regex(
     rule: Optional[Union[Rule, T_RuleChecker]] = None,
     _depth: int = 0,
     **kwargs,
-) -> Type[Matcher]:
+) -> type[Matcher]:
     """注册一个消息事件响应器，并且当消息匹配正则表达式时响应。
 
     命令匹配规则参考: `正则匹配 <rule.md#regex-regex-flags-0>`_
@@ -404,12 +411,12 @@ def on_regex(
 
 
 def on_type(
-    types: Union[Type[Event], Tuple[Type[Event], ...]],
+    types: Union[type[Event], tuple[type[Event], ...]],
     rule: Optional[Union[Rule, T_RuleChecker]] = None,
     *,
     _depth: int = 0,
     **kwargs,
-) -> Type[Matcher]:
+) -> type[Matcher]:
     """注册一个事件响应器，并且当事件为指定类型时响应。
 
     参数:
@@ -430,14 +437,14 @@ def on_type(
 class _Group:
     def __init__(self, **kwargs):
         """创建一个事件响应器组合，参数为默认值，与 `on` 一致"""
-        self.matchers: List[Type[Matcher]] = []
+        self.matchers: list[type[Matcher]] = []
         """组内事件响应器列表"""
-        self.base_kwargs: Dict[str, Any] = kwargs
+        self.base_kwargs: dict[str, Any] = kwargs
         """其他传递给 `on` 的参数默认值"""
 
     def _get_final_kwargs(
-        self, update: Dict[str, Any], *, exclude: Optional[Set[str]] = None
+        self, update: dict[str, Any], *, exclude: Optional[set[str]] = None
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """获取最终传递给 `on` 的参数
 
         参数:
@@ -470,18 +477,18 @@ class CommandGroup(_Group):
     """
 
     def __init__(
-        self, cmd: Union[str, Tuple[str, ...]], prefix_aliases: bool = False, **kwargs
+        self, cmd: Union[str, tuple[str, ...]], prefix_aliases: bool = False, **kwargs
     ):
         """命令前缀"""
         super().__init__(**kwargs)
-        self.basecmd: Tuple[str, ...] = (cmd,) if isinstance(cmd, str) else cmd
+        self.basecmd: tuple[str, ...] = (cmd,) if isinstance(cmd, str) else cmd
         self.base_kwargs.pop("aliases", None)
         self.prefix_aliases = prefix_aliases
 
     def __repr__(self) -> str:
         return f"CommandGroup(cmd={self.basecmd}, matchers={len(self.matchers)})"
 
-    def command(self, cmd: Union[str, Tuple[str, ...]], **kwargs) -> Type[Matcher]:
+    def command(self, cmd: Union[str, tuple[str, ...]], **kwargs) -> type[Matcher]:
         """注册一个新的命令。新参数将会覆盖命令组默认值
 
         参数:
@@ -509,8 +516,8 @@ class CommandGroup(_Group):
         return matcher
 
     def shell_command(
-        self, cmd: Union[str, Tuple[str, ...]], **kwargs
+        self, cmd: Union[str, tuple[str, ...]], **kwargs
-    ) -> Type[Matcher]:
+    ) -> type[Matcher]:
         """注册一个新的 `shell_like` 命令。新参数将会覆盖命令组默认值
 
         参数:
@@ -544,7 +551,7 @@ class MatcherGroup(_Group):
     def __repr__(self) -> str:
         return f"MatcherGroup(matchers={len(self.matchers)})"
 
-    def on(self, **kwargs) -> Type[Matcher]:
+    def on(self, **kwargs) -> type[Matcher]:
         """注册一个基础事件响应器，可自定义类型。
 
         参数:
@@ -562,7 +569,7 @@ class MatcherGroup(_Group):
         self.matchers.append(matcher)
         return matcher
 
-    def on_metaevent(self, **kwargs) -> Type[Matcher]:
+    def on_metaevent(self, **kwargs) -> type[Matcher]:
         """注册一个元事件响应器。
 
         参数:
@@ -580,7 +587,7 @@ class MatcherGroup(_Group):
         self.matchers.append(matcher)
         return matcher
 
-    def on_message(self, **kwargs) -> Type[Matcher]:
+    def on_message(self, **kwargs) -> type[Matcher]:
         """注册一个消息事件响应器。
 
         参数:
@@ -598,7 +605,7 @@ class MatcherGroup(_Group):
         self.matchers.append(matcher)
         return matcher
 
-    def on_notice(self, **kwargs) -> Type[Matcher]:
+    def on_notice(self, **kwargs) -> type[Matcher]:
         """注册一个通知事件响应器。
 
         参数:
@@ -616,7 +623,7 @@ class MatcherGroup(_Group):
         self.matchers.append(matcher)
         return matcher
 
-    def on_request(self, **kwargs) -> Type[Matcher]:
+    def on_request(self, **kwargs) -> type[Matcher]:
         """注册一个请求事件响应器。
 
         参数:
@@ -635,8 +642,8 @@ class MatcherGroup(_Group):
         return matcher
 
     def on_startswith(
-        self, msg: Union[str, Tuple[str, ...]], **kwargs
+        self, msg: Union[str, tuple[str, ...]], **kwargs
-    ) -> Type[Matcher]:
+    ) -> type[Matcher]:
         """注册一个消息事件响应器，并且当消息的**文本部分**以指定内容开头时响应。
 
         参数:
@@ -656,7 +663,7 @@ class MatcherGroup(_Group):
         self.matchers.append(matcher)
         return matcher
 
-    def on_endswith(self, msg: Union[str, Tuple[str, ...]], **kwargs) -> Type[Matcher]:
+    def on_endswith(self, msg: Union[str, tuple[str, ...]], **kwargs) -> type[Matcher]:
         """注册一个消息事件响应器，并且当消息的**文本部分**以指定内容结尾时响应。
 
         参数:
@@ -676,7 +683,7 @@ class MatcherGroup(_Group):
         self.matchers.append(matcher)
         return matcher
 
-    def on_fullmatch(self, msg: Union[str, Tuple[str, ...]], **kwargs) -> Type[Matcher]:
+    def on_fullmatch(self, msg: Union[str, tuple[str, ...]], **kwargs) -> type[Matcher]:
         """注册一个消息事件响应器，并且当消息的**文本部分**与指定内容完全一致时响应。
 
         参数:
@@ -696,7 +703,7 @@ class MatcherGroup(_Group):
         self.matchers.append(matcher)
         return matcher
 
-    def on_keyword(self, keywords: Set[str], **kwargs) -> Type[Matcher]:
+    def on_keyword(self, keywords: set[str], **kwargs) -> type[Matcher]:
         """注册一个消息事件响应器，并且当消息纯文本部分包含关键词时响应。
 
         参数:
@@ -717,11 +724,11 @@ class MatcherGroup(_Group):
 
     def on_command(
         self,
-        cmd: Union[str, Tuple[str, ...]],
+        cmd: Union[str, tuple[str, ...]],
-        aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = None,
+        aliases: Optional[set[Union[str, tuple[str, ...]]]] = None,
         force_whitespace: Optional[Union[str, bool]] = None,
         **kwargs,
-    ) -> Type[Matcher]:
+    ) -> type[Matcher]:
         """注册一个消息事件响应器，并且当消息以指定命令开头时响应。
 
         命令匹配规则参考: `命令形式匹配 <rule.md#command-command>`_
@@ -748,11 +755,11 @@ class MatcherGroup(_Group):
 
     def on_shell_command(
         self,
-        cmd: Union[str, Tuple[str, ...]],
+        cmd: Union[str, tuple[str, ...]],
-        aliases: Optional[Set[Union[str, Tuple[str, ...]]]] = None,
+        aliases: Optional[set[Union[str, tuple[str, ...]]]] = None,
         parser: Optional[ArgumentParser] = None,
         **kwargs,
-    ) -> Type[Matcher]:
+    ) -> type[Matcher]:
         """注册一个支持 `shell_like` 解析参数的命令消息事件响应器。
 
         与普通的 `on_command` 不同的是，在添加 `parser` 参数时, 响应器会自动处理消息。
@@ -780,7 +787,7 @@ class MatcherGroup(_Group):
 
     def on_regex(
         self, pattern: str, flags: Union[int, re.RegexFlag] = 0, **kwargs
-    ) -> Type[Matcher]:
+    ) -> type[Matcher]:
         """注册一个消息事件响应器，并且当消息匹配正则表达式时响应。
 
         命令匹配规则参考: `正则匹配 <rule.md#regex-regex-flags-0>`_
@@ -803,8 +810,8 @@ class MatcherGroup(_Group):
         return matcher
 
     def on_type(
-        self, types: Union[Type[Event], Tuple[Type[Event]]], **kwargs
+        self, types: Union[type[Event], tuple[type[Event]]], **kwargs
-    ) -> Type[Matcher]:
+    ) -> type[Matcher]:
         """注册一个事件响应器，并且当事件为指定类型时响应。
 
         参数:

nonebot/plugin/on.pyi

@@ -21,7 +21,7 @@ def on(
     rule: Rule | T_RuleChecker | None = ...,
     permission: Permission | T_PermissionChecker | None = ...,
     *,
-    handlers: list[T_Handler | Dependent] | None = ...,
+    handlers: list[T_Handler | Dependent[Any]] | None = ...,
     temp: bool = ...,
     expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
@@ -32,7 +32,7 @@ def on_metaevent(
     rule: Rule | T_RuleChecker | None = ...,
     permission: Permission | T_PermissionChecker | None = ...,
     *,
-    handlers: list[T_Handler | Dependent] | None = ...,
+    handlers: list[T_Handler | Dependent[Any]] | None = ...,
     temp: bool = ...,
     expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
@@ -43,7 +43,7 @@ def on_message(
     rule: Rule | T_RuleChecker | None = ...,
     permission: Permission | T_PermissionChecker | None = ...,
     *,
-    handlers: list[T_Handler | Dependent] | None = ...,
+    handlers: list[T_Handler | Dependent[Any]] | None = ...,
     temp: bool = ...,
     expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
@@ -54,7 +54,7 @@ def on_notice(
     rule: Rule | T_RuleChecker | None = ...,
     permission: Permission | T_PermissionChecker | None = ...,
     *,
-    handlers: list[T_Handler | Dependent] | None = ...,
+    handlers: list[T_Handler | Dependent[Any]] | None = ...,
     temp: bool = ...,
     expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
@@ -65,7 +65,7 @@ def on_request(
     rule: Rule | T_RuleChecker | None = ...,
     permission: Permission | T_PermissionChecker | None = ...,
     *,
-    handlers: list[T_Handler | Dependent] | None = ...,
+    handlers: list[T_Handler | Dependent[Any]] | None = ...,
     temp: bool = ...,
     expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
@@ -78,7 +78,7 @@ def on_startswith(
     ignorecase: bool = ...,
     *,
     permission: Permission | T_PermissionChecker | None = ...,
-    handlers: list[T_Handler | Dependent] | None = ...,
+    handlers: list[T_Handler | Dependent[Any]] | None = ...,
     temp: bool = ...,
     expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
@@ -91,7 +91,7 @@ def on_endswith(
     ignorecase: bool = ...,
     *,
     permission: Permission | T_PermissionChecker | None = ...,
-    handlers: list[T_Handler | Dependent] | None = ...,
+    handlers: list[T_Handler | Dependent[Any]] | None = ...,
     temp: bool = ...,
     expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
@@ -104,7 +104,7 @@ def on_fullmatch(
     ignorecase: bool = ...,
     *,
     permission: Permission | T_PermissionChecker | None = ...,
-    handlers: list[T_Handler | Dependent] | None = ...,
+    handlers: list[T_Handler | Dependent[Any]] | None = ...,
     temp: bool = ...,
     expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
@@ -116,7 +116,7 @@ def on_keyword(
     rule: Rule | T_RuleChecker | None = ...,
     *,
     permission: Permission | T_PermissionChecker | None = ...,
-    handlers: list[T_Handler | Dependent] | None = ...,
+    handlers: list[T_Handler | Dependent[Any]] | None = ...,
     temp: bool = ...,
     expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
@@ -130,7 +130,7 @@ def on_command(
     force_whitespace: str | bool | None = ...,
     *,
     permission: Permission | T_PermissionChecker | None = ...,
-    handlers: list[T_Handler | Dependent] | None = ...,
+    handlers: list[T_Handler | Dependent[Any]] | None = ...,
     temp: bool = ...,
     expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
@@ -144,7 +144,7 @@ def on_shell_command(
     parser: ArgumentParser | None = ...,
     *,
     permission: Permission | T_PermissionChecker | None = ...,
-    handlers: list[T_Handler | Dependent] | None = ...,
+    handlers: list[T_Handler | Dependent[Any]] | None = ...,
     temp: bool = ...,
     expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
@@ -157,7 +157,7 @@ def on_regex(
     rule: Rule | T_RuleChecker | None = ...,
     *,
     permission: Permission | T_PermissionChecker | None = ...,
-    handlers: list[T_Handler | Dependent] | None = ...,
+    handlers: list[T_Handler | Dependent[Any]] | None = ...,
     temp: bool = ...,
     expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
@@ -169,7 +169,7 @@ def on_type(
     rule: Rule | T_RuleChecker | None = ...,
     *,
     permission: Permission | T_PermissionChecker | None = ...,
-    handlers: list[T_Handler | Dependent] | None = ...,
+    handlers: list[T_Handler | Dependent[Any]] | None = ...,
     temp: bool = ...,
     expire_time: datetime | timedelta | None = ...,
     priority: int = ...,
@@ -194,7 +194,7 @@ class CommandGroup(_Group):
         *,
         rule: Rule | T_RuleChecker | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -209,7 +209,7 @@ class CommandGroup(_Group):
         aliases: set[str | tuple[str, ...]] | None = ...,
         force_whitespace: str | bool | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -224,7 +224,7 @@ class CommandGroup(_Group):
         aliases: set[str | tuple[str, ...]] | None = ...,
         parser: ArgumentParser | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -239,7 +239,7 @@ class MatcherGroup(_Group):
         type: str = ...,
         rule: Rule | T_RuleChecker | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -252,7 +252,7 @@ class MatcherGroup(_Group):
         type: str = ...,
         rule: Rule | T_RuleChecker | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -264,7 +264,7 @@ class MatcherGroup(_Group):
         *,
         rule: Rule | T_RuleChecker | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -276,7 +276,7 @@ class MatcherGroup(_Group):
         *,
         rule: Rule | T_RuleChecker | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -288,7 +288,7 @@ class MatcherGroup(_Group):
         *,
         rule: Rule | T_RuleChecker | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -300,7 +300,7 @@ class MatcherGroup(_Group):
         *,
         rule: Rule | T_RuleChecker | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -314,7 +314,7 @@ class MatcherGroup(_Group):
         ignorecase: bool = ...,
         rule: Rule | T_RuleChecker | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -328,7 +328,7 @@ class MatcherGroup(_Group):
         ignorecase: bool = ...,
         rule: Rule | T_RuleChecker | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -342,7 +342,7 @@ class MatcherGroup(_Group):
         ignorecase: bool = ...,
         rule: Rule | T_RuleChecker | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -355,7 +355,7 @@ class MatcherGroup(_Group):
         *,
         rule: Rule | T_RuleChecker | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -370,7 +370,7 @@ class MatcherGroup(_Group):
         *,
         rule: Rule | T_RuleChecker | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -385,7 +385,7 @@ class MatcherGroup(_Group):
         *,
         rule: Rule | T_RuleChecker | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -399,7 +399,7 @@ class MatcherGroup(_Group):
         *,
         rule: Rule | T_RuleChecker | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,
@@ -412,7 +412,7 @@ class MatcherGroup(_Group):
         *,
         rule: Rule | T_RuleChecker | None = ...,
         permission: Permission | T_PermissionChecker | None = ...,
-        handlers: list[T_Handler | Dependent] | None = ...,
+        handlers: list[T_Handler | Dependent[Any]] | None = ...,
         temp: bool = ...,
         expire_time: datetime | timedelta | None = ...,
         priority: int = ...,

nonebot/plugins/single_session.py

@@ -1,4 +1,4 @@
-from typing import Dict, AsyncGenerator
+from collections.abc import AsyncGenerator
 
 from nonebot.adapters import Event
 from nonebot.params import Depends
@@ -15,7 +15,7 @@ __plugin_meta__ = PluginMetadata(
     supported_adapters=None,
 )
 
-_running_matcher: Dict[str, int] = {}
+_running_matcher: dict[str, int] = {}
 
 
 async def matcher_mutex(event: Event) -> AsyncGenerator[bool, None]:

nonebot/rule.py

@@ -5,6 +5,8 @@
 只有当所有 `RuleChecker` 检查结果为 `True` 时继续运行。
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 5
     description: nonebot.rule 模块
 """
@@ -15,19 +17,16 @@ 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 (
     IO,
     TYPE_CHECKING,
-    List,
-    Type,
-    Tuple,
     Union,
     TypeVar,
     Optional,
-    Sequence,
     TypedDict,
     NamedTuple,
     cast,
@@ -63,7 +62,7 @@ T = TypeVar("T")
 
 
 class CMD_RESULT(TypedDict):
-    command: Optional[Tuple[str, ...]]
+    command: Optional[tuple[str, ...]]
     raw_command: Optional[str]
     command_arg: Optional[Message]
     command_start: Optional[str]
@@ -72,7 +71,7 @@ class CMD_RESULT(TypedDict):
 
 class TRIE_VALUE(NamedTuple):
     command_start: str
-    command: Tuple[str, ...]
+    command: tuple[str, ...]
 
 
 parser_message: ContextVar[str] = ContextVar("parser_message")
@@ -149,7 +148,7 @@ 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
 
@@ -181,7 +180,7 @@ class StartswithRule:
         return False
 
 
-def startswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule:
+def startswith(msg: Union[str, tuple[str, ...]], ignorecase: bool = False) -> Rule:
     """匹配消息纯文本开头。
 
     参数:
@@ -204,7 +203,7 @@ 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
 
@@ -236,7 +235,7 @@ class EndswithRule:
         return False
 
 
-def endswith(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule:
+def endswith(msg: Union[str, tuple[str, ...]], ignorecase: bool = False) -> Rule:
     """匹配消息纯文本结尾。
 
     参数:
@@ -259,7 +258,7 @@ class FullmatchRule:
 
     __slots__ = ("msg", "ignorecase")
 
-    def __init__(self, msg: Tuple[str, ...], ignorecase: bool = False):
+    def __init__(self, msg: tuple[str, ...], ignorecase: bool = False):
         self.msg = tuple(map(str.casefold, msg) if ignorecase else msg)
         self.ignorecase = ignorecase
 
@@ -290,7 +289,7 @@ class FullmatchRule:
         return False
 
 
-def fullmatch(msg: Union[str, Tuple[str, ...]], ignorecase: bool = False) -> Rule:
+def fullmatch(msg: Union[str, tuple[str, ...]], ignorecase: bool = False) -> Rule:
     """完全匹配消息。
 
     参数:
@@ -361,7 +360,7 @@ class CommandRule:
 
     def __init__(
         self,
-        cmds: List[Tuple[str, ...]],
+        cmds: list[tuple[str, ...]],
         force_whitespace: Optional[Union[str, bool]] = None,
     ):
         self.cmds = tuple(cmds)
@@ -380,7 +379,7 @@ class CommandRule:
 
     async def __call__(
         self,
-        cmd: Optional[Tuple[str, ...]] = Command(),
+        cmd: Optional[tuple[str, ...]] = Command(),
         cmd_arg: Optional[Message] = CommandArg(),
         cmd_whitespace: Optional[str] = CommandWhitespace(),
     ) -> bool:
@@ -394,7 +393,7 @@ class CommandRule:
 
 
 def command(
-    *cmds: Union[str, Tuple[str, ...]],
+    *cmds: Union[str, tuple[str, ...]],
     force_whitespace: Optional[Union[str, bool]] = None,
 ) -> Rule:
     """匹配消息命令。
@@ -424,7 +423,7 @@ def 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,)
@@ -460,23 +459,23 @@ class ArgumentParser(ArgParser):
             self,
             args: Optional[Sequence[Union[str, MessageSegment]]] = None,
             namespace: None = None,
-        ) -> Tuple[Namespace, List[Union[str, MessageSegment]]]: ...
+        ) -> 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]]]: ...
+        ) -> tuple[T, list[Union[str, MessageSegment]]]: ...
 
         @overload
         def parse_known_args(
             self, *, namespace: T
-        ) -> Tuple[T, List[Union[str, MessageSegment]]]: ...
+        ) -> tuple[T, list[Union[str, MessageSegment]]]: ...
 
-        def parse_known_args(
+        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]]]: ...
+        ) -> tuple[Union[Namespace, T], list[Union[str, MessageSegment]]]: ...
 
     @overload
     def parse_args(
@@ -506,7 +505,7 @@ class ArgumentParser(ArgParser):
 
     def _parse_optional(
         self, arg_string: Union[str, MessageSegment]
-    ) -> Optional[Tuple[Optional[Action], str, Optional[str]]]:
+    ) -> Optional[tuple[Optional[Action], str, Optional[str]]]:
         return (
             super()._parse_optional(arg_string) if isinstance(arg_string, str) else None
         )
@@ -533,7 +532,7 @@ class ShellCommandRule:
 
     __slots__ = ("cmds", "parser")
 
-    def __init__(self, cmds: List[Tuple[str, ...]], parser: Optional[ArgumentParser]):
+    def __init__(self, cmds: list[tuple[str, ...]], parser: Optional[ArgumentParser]):
         self.cmds = tuple(cmds)
         self.parser = parser
 
@@ -553,7 +552,7 @@ class ShellCommandRule:
     async def __call__(
         self,
         state: T_State,
-        cmd: Optional[Tuple[str, ...]] = Command(),
+        cmd: Optional[tuple[str, ...]] = Command(),
         msg: Optional[Message] = CommandArg(),
     ) -> bool:
         if cmd not in self.cmds or msg is None:
@@ -571,7 +570,7 @@ class ShellCommandRule:
             try:
                 args = self.parser.parse_args(state[SHELL_ARGV])
                 state[SHELL_ARGS] = args
-            except ArgumentError as e:  # pragma: py-gte-39
+            except ArgumentError as e:
                 state[SHELL_ARGS] = ParserExit(status=2, message=str(e))
             except ParserExit as e:
                 state[SHELL_ARGS] = e
@@ -581,7 +580,7 @@ class ShellCommandRule:
 
 
 def shell_command(
-    *cmds: Union[str, Tuple[str, ...]], parser: Optional[ArgumentParser] = None
+    *cmds: Union[str, tuple[str, ...]], parser: Optional[ArgumentParser] = None
 ) -> Rule:
     """匹配 `shell_like` 形式的消息命令。
 
@@ -629,7 +628,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,)
@@ -740,7 +739,7 @@ class IsTypeRule:
 
     __slots__ = ("types",)
 
-    def __init__(self, *types: Type[Event]):
+    def __init__(self, *types: type[Event]):
         self.types = types
 
     def __repr__(self) -> str:
@@ -756,7 +755,7 @@ class IsTypeRule:
         return isinstance(event, self.types)
 
 
-def is_type(*types: Type[Event]) -> Rule:
+def is_type(*types: type[Event]) -> Rule:
     """匹配事件类型。
 
     参数:

nonebot/typing.py

@@ -6,6 +6,8 @@
 [`typing`](https://docs.python.org/3/library/typing.html)。
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 11
     description: nonebot.typing 模块
 """
@@ -13,17 +15,15 @@ FrontMatter:
 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
-
     from nonebot.adapters import Bot
     from nonebot.permission import Permission
+    from nonebot.internal.params import DependencyCache
 
 T = TypeVar("T")
 P = ParamSpec("P")
@@ -45,26 +45,38 @@ def overrides(InterfaceClass: object):
 
 if sys.version_info < (3, 10):
 
-    def origin_is_union(origin: t.Optional[t.Type[t.Any]]) -> bool:
+    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[t.Type[t.Any]]) -> bool:
+    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[t.Type[t.Any]]) -> bool:
+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_: t.Type[t.Any]) -> t.Tuple[t.Any, ...]:
+def _literal_values(type_: type[t.Any]) -> tuple[t.Any, ...]:
     return get_args(type_)
 
 
-def all_literal_values(type_: t.Type[t.Any]) -> t.List[t.Any]:
+def all_literal_values(type_: type[t.Any]) -> list[t.Any]:
     """获取 Literal 类型包含的所有值"""
     if not origin_is_literal(get_origin(type_)):
         return [type_]
@@ -72,11 +84,9 @@ def all_literal_values(type_: t.Type[t.Any]) -> t.List[t.Any]:
     return [x for value in _literal_values(type_) for x in all_literal_values(value)]
 
 
-def origin_is_annotated(origin: t.Optional[t.Type[t.Any]]) -> bool:
+def origin_is_annotated(origin: t.Optional[type[t.Any]]) -> bool:
     """判断是否是 Annotated 类型"""
-    with contextlib.suppress(TypeError):
+    return origin is t_ext.Annotated
-        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]}
@@ -84,28 +94,31 @@ if sys.version_info >= (3, 10):
     NONE_TYPES.add(types.NoneType)
 
 
-def is_none_type(type_: t.Type[t.Any]) -> bool:
+def is_none_type(type_: type[t.Any]) -> bool:
     """判断是否是 None 类型"""
     return type_ in NONE_TYPES
 
 
-if sys.version_info < (3, 9):  # pragma: py-lt-39
+def evaluate_forwardref(
-
+    ref: t.ForwardRef, globalns: dict[str, t.Any], localns: dict[str, t.Any]
-    def evaluate_forwardref(
+) -> t.Any:
-        ref: t.ForwardRef, globalns: t.Dict[str, t.Any], localns: t.Dict[str, t.Any]
+    # Python 3.13/3.12.4+ made `recursive_guard` a kwarg,
-    ) -> t.Any:
+    # so name it explicitly to avoid:
-        return ref._evaluate(globalns, localns)
+    # TypeError: ForwardRef._evaluate()
-
+    # missing 1 required keyword-only argument: 'recursive_guard'
-else:  # pragma: py-gte-39
+    return ref._evaluate(globalns, localns, recursive_guard=frozenset())
-
-    def evaluate_forwardref(
-        ref: t.ForwardRef, globalns: t.Dict[str, t.Any], localns: t.Dict[str, t.Any]
-    ) -> t.Any:
-        return ref._evaluate(globalns, localns, frozenset())
 
 
 # state
-T_State: TypeAlias = t.Dict[t.Any, t.Any]
+# use annotated flag to avoid ForwardRef recreate generic type (py >= 3.11)
+class StateFlag:
+    def __repr__(self) -> str:
+        return "StateFlag()"
+
+
+_STATE_FLAG = StateFlag()
+
+T_State: TypeAlias = t.Annotated[dict[t.Any, t.Any], _STATE_FLAG]
 """事件处理状态 State 类型"""
 
 _DependentCallable: TypeAlias = t.Union[
@@ -134,11 +147,11 @@ T_BotDisconnectionHook: TypeAlias = _DependentCallable[t.Any]
 
 # api hooks
 T_CallingAPIHook: TypeAlias = t.Callable[
-    ["Bot", str, t.Dict[str, t.Any]], t.Awaitable[t.Any]
+    ["Bot", str, dict[str, t.Any]], t.Awaitable[t.Any]
 ]
 """`bot.call_api` 钩子函数"""
 T_CalledAPIHook: TypeAlias = t.Callable[
-    ["Bot", t.Optional[Exception], str, t.Dict[str, t.Any], t.Any], t.Awaitable[t.Any]
+    ["Bot", t.Optional[Exception], str, dict[str, t.Any], t.Any], t.Awaitable[t.Any]
 ]
 """`bot.call_api` 后执行的函数，参数分别为 bot, exception, api, data, result"""
 
@@ -244,5 +257,5 @@ T_PermissionUpdater: TypeAlias = _DependentCallable["Permission"]
 - MatcherParam: Matcher 对象
 - DefaultParam: 带有默认值的参数
 """
-T_DependencyCache: TypeAlias = t.Dict[_DependentCallable[t.Any], "Task[t.Any]"]
+T_DependencyCache: TypeAlias = dict[_DependentCallable[t.Any], "DependencyCache"]
 """依赖缓存, 用于存储依赖函数的返回值"""

nonebot/utils.py

@@ -1,45 +1,35 @@
 """本模块包含了 NoneBot 的一些工具函数
 
 FrontMatter:
+    mdx:
+        format: md
     sidebar_position: 8
     description: nonebot.utils 模块
 """
 
 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 contextlib import AbstractContextManager, asynccontextmanager
 from typing_extensions import ParamSpec, get_args, override, get_origin
-from typing import (
+from typing import Any, Union, Generic, TypeVar, Callable, Optional, overload
-    Any,
+from collections.abc import Mapping, Sequence, Coroutine, Generator, AsyncGenerator
-    Dict,
-    Type,
-    Tuple,
-    Union,
-    Generic,
-    Mapping,
-    TypeVar,
-    Callable,
-    Optional,
-    Sequence,
-    Coroutine,
-    AsyncGenerator,
-    ContextManager,
-    overload,
-)
 
+import anyio
+import anyio.to_thread
 from pydantic import BaseModel
+from exceptiongroup import BaseExceptionGroup, catch
 
 from nonebot.log import logger
 from nonebot.typing import (
     is_none_type,
+    type_has_args,
     origin_is_union,
     origin_is_literal,
     all_literal_values,
@@ -50,6 +40,7 @@ R = TypeVar("R")
 T = TypeVar("T")
 K = TypeVar("K")
 V = TypeVar("V")
+E = TypeVar("E", bound=BaseException)
 
 
 def escape_tag(s: str) -> str:
@@ -64,8 +55,8 @@ def escape_tag(s: str) -> str:
 
 
 def deep_update(
-    mapping: Dict[K, Any], *updating_mappings: Dict[K, Any]
+    mapping: dict[K, Any], *updating_mappings: dict[K, Any]
-) -> Dict[K, Any]:
+) -> dict[K, Any]:
     """深度更新合并字典"""
     updated_mapping = mapping.copy()
     for updating_mapping in updating_mappings:
@@ -82,7 +73,7 @@ def deep_update(
 
 
 def lenient_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 中的一个类型子类并忽略类型错误。"""
     try:
@@ -92,7 +83,7 @@ def lenient_issubclass(
 
 
 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 中的一个类型子类。
 
@@ -106,46 +97,46 @@ def generic_check_issubclass(
       则会检查其 `__bound__` 或 `__constraints__`
       是否是 class_or_tuple 中一个类型的子类或 None。
     """
-    try:
+    if not type_has_args(cls):
-        return issubclass(cls, class_or_tuple)
+        with contextlib.suppress(TypeError):
-    except TypeError:
+            return issubclass(cls, class_or_tuple)
-        origin = get_origin(cls)
+
-        if origin_is_union(origin):
+    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_is_literal(origin):
+        elif cls.__bound__:
-            return all(
+            return generic_check_issubclass(cls.__bound__, class_or_tuple)
-                is_none_type(value) or isinstance(value, class_or_tuple)
+    return False
-                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 cls.__constraints__
-                )
-            elif cls.__bound__:
-                return generic_check_issubclass(cls.__bound__, class_or_tuple)
-        return False
 
 
-def type_is_complex(type_: Type[Any]) -> bool:
+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:
+def _type_is_complex_inner(type_: Optional[type[Any]]) -> bool:
     if lenient_issubclass(type_, (str, bytes)):
         return False
 
@@ -189,18 +180,16 @@ def run_sync(call: Callable[P, R]) -> Callable[P, Coroutine[None, None, R]]:
 
     @wraps(call)
     async def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-        loop = asyncio.get_running_loop()
+        return await anyio.to_thread.run_sync(
-        pfunc = partial(call, *args, **kwargs)
+            partial(call, *args, **kwargs), abandon_on_cancel=True
-        context = copy_context()
+        )
-        result = await loop.run_in_executor(None, partial(context.run, pfunc))
-        return result
 
     return _wrapper
 
 
 @asynccontextmanager
 async def run_sync_ctx_manager(
-    cm: ContextManager[T],
+    cm: AbstractContextManager[T],
 ) -> AsyncGenerator[T, None]:
     """一个用于包装 sync context manager 为 async context manager 的执行函数"""
     try:
@@ -216,7 +205,7 @@ async def run_sync_ctx_manager(
 @overload
 async def run_coro_with_catch(
     coro: Coroutine[Any, Any, T],
-    exc: Tuple[Type[Exception], ...],
+    exc: tuple[type[Exception], ...],
     return_on_err: None = None,
 ) -> Union[T, None]: ...
 
@@ -224,14 +213,14 @@ async def run_coro_with_catch(
 @overload
 async def run_coro_with_catch(
     coro: Coroutine[Any, Any, T],
-    exc: Tuple[Type[Exception], ...],
+    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], ...],
+    exc: tuple[type[Exception], ...],
     return_on_err: Optional[R] = None,
 ) -> Optional[Union[T, R]]:
     """运行协程并当遇到指定异常时返回指定值。
@@ -245,10 +234,34 @@ async def run_coro_with_catch(
         协程的返回值或发生异常时的指定值
     """
 
-    try:
+    with catch({exc: lambda exc_group: None}):
         return await coro
-    except exc:
+
-        return return_on_err
+    return return_on_err
+
+
+async def run_coro_with_shield(coro: Coroutine[Any, Any, T]) -> T:
+    """运行协程并在取消时屏蔽取消异常。
+
+    参数:
+        coro: 要运行的协程
+
+    返回:
+        协程的返回值
+    """
+
+    with anyio.CancelScope(shield=True):
+        return await coro
+
+
+def flatten_exception_group(
+    exc_group: BaseExceptionGroup[E],
+) -> Generator[E, None, None]:
+    for exc in exc_group.exceptions:
+        if isinstance(exc, BaseExceptionGroup):
+            yield from flatten_exception_group(exc)
+        else:
+            yield exc
 
 
 def get_name(obj: Any) -> str:
@@ -289,7 +302,7 @@ 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:
+    def __get__(self, instance: Any, owner: Optional[type[Any]] = None) -> T:
         return self.func(type(instance) if owner is None else owner)
 
 

packages/nonebot-plugin-docs/README.md

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

packages/nonebot-plugin-docs/pyproject.toml

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

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "nonebot2"
-version = "2.2.0"
+version = "2.4.0"
 description = "An asynchronous python bot framework."
 authors = ["yanyongyu <yyy@nonebot.dev>"]
 license = "MIT"
@@ -22,12 +22,14 @@ include = ["nonebot/py.typed"]
 [tool.poetry.urls]
 "Bug Tracker" = "https://github.com/nonebot/nonebot2/issues"
 "Changelog" = "https://nonebot.dev/changelog"
-"Funding" = "https://afdian.net/@nonebot"
+"Funding" = "https://afdian.com/@nonebot"
 
 [tool.poetry.dependencies]
-python = "^3.8"
+python = "^3.9"
 yarl = "^1.7.2"
+anyio = "^4.4.0"
 pygtrie = "^2.4.1"
+exceptiongroup = "^1.2.2"
 loguru = ">=0.6.0,<1.0.0"
 python-dotenv = ">=0.21.0,<2.0.0"
 typing-extensions = ">=4.4.0,<5.0.0"
@@ -44,7 +46,7 @@ uvicorn = { version = ">=0.20.0,<1.0.0", extras = [
 ], optional = true }
 
 [tool.poetry.group.dev.dependencies]
-ruff = "^0.2.0"
+ruff = "^0.7.0"
 isort = "^5.10.1"
 black = "^24.0.0"
 nonemoji = "^0.1.2"
@@ -65,13 +67,12 @@ fastapi = ["fastapi", "uvicorn"]
 all = ["fastapi", "quart", "aiohttp", "httpx", "websockets", "uvicorn"]
 
 [tool.pytest.ini_options]
-asyncio_mode = "strict"
+addopts = "--cov=nonebot --cov-report=term-missing"
-addopts = "--cov=nonebot --cov-append --cov-report=term-missing"
 filterwarnings = ["error", "ignore::DeprecationWarning"]
 
 [tool.black]
 line-length = 88
-target-version = ["py38", "py39", "py310", "py311"]
+target-version = ["py39", "py310", "py311", "py312"]
 include = '\.pyi?$'
 extend-exclude = '''
 '''
@@ -87,18 +88,37 @@ extra_standard_library = ["typing_extensions"]
 
 [tool.ruff]
 line-length = 88
-target-version = "py38"
+target-version = "py39"
 
 [tool.ruff.lint]
-select = ["E", "W", "F", "UP", "C", "T", "PYI", "PT", "Q"]
+select = [
-ignore = ["E402", "C901", "UP037"]
+  "F",     # Pyflakes
+  "W",     # pycodestyle warnings
+  "E",     # pycodestyle errors
+  "UP",    # pyupgrade
+  "ASYNC", # flake8-async
+  "C4",    # flake8-comprehensions
+  "T10",   # flake8-debugger
+  "T20",   # flake8-print
+  "PYI",   # flake8-pyi
+  "PT",    # flake8-pytest-style
+  "Q",     # flake8-quotes
+  "RUF",   # Ruff-specific rules
+]
+ignore = [
+  "E402",   # module-import-not-at-top-of-file
+  "UP037",  # quoted-annotation
+  "RUF001", # ambiguous-unicode-character-string
+  "RUF002", # ambiguous-unicode-character-docstring
+  "RUF003", # ambiguous-unicode-character-comment
+]
 
 [tool.ruff.lint.flake8-pytest-style]
 fixture-parentheses = false
 mark-parentheses = false
 
 [tool.pyright]
-pythonVersion = "3.8"
+pythonVersion = "3.9"
 pythonPlatform = "All"
 defineConstant = { PYDANTIC_V2 = true }
 executionEnvironments = [
@@ -108,7 +128,7 @@ executionEnvironments = [
   { root = "./" },
 ]
 
-typeCheckingMode = "basic"
+typeCheckingMode = "standard"
 reportShadowedImports = false
 disableBytesTypePromotions = true
 

scripts/run-tests.sh

@@ -4,4 +4,4 @@
 cd "$(dirname "$0")/../tests"
 
 # Run the tests
-pytest -n auto --cov-report xml $@
+pytest -n auto --cov-append --cov-report xml $@

tests/.coveragerc

@@ -21,8 +21,6 @@ rules =
   "sys_platform != 'win32'": py-win32
   "sys_platform != 'linux'": py-linux
   "sys_platform != 'darwin'": py-darwin
-  "sys_version_info < (3, 9)": py-gte-39
-  "sys_version_info >= (3, 9)": py-lt-39
   "sys_version_info < (3, 11)": py-gte-311
   "sys_version_info >= (3, 11)": py-lt-311
   "package_version('pydantic') < (2,)": pydantic-v2

tests/conftest.py

@@ -1,7 +1,10 @@
 import os
 import threading
 from pathlib import Path
-from typing import TYPE_CHECKING, Set, Generator
+from functools import wraps
+from collections.abc import Generator
+from typing_extensions import ParamSpec
+from typing import TYPE_CHECKING, TypeVar, Callable
 
 import pytest
 from nonebug import NONEBOT_INIT_KWARGS
@@ -19,6 +22,9 @@ os.environ["CONFIG_OVERRIDE"] = "new"
 if TYPE_CHECKING:
     from nonebot.plugin import Plugin
 
+P = ParamSpec("P")
+R = TypeVar("R")
+
 collect_ignore = ["plugins/", "dynamic/", "bad_plugins/"]
 
 
@@ -37,14 +43,36 @@ def load_driver(request: pytest.FixtureRequest) -> Driver:
     return DriverClass(Env(environment=global_driver.env), global_driver.config)
 
 
+@pytest.fixture(scope="session", params=[pytest.param("asyncio"), pytest.param("trio")])
+def anyio_backend(request: pytest.FixtureRequest):
+    return request.param
+
+
+def run_once(func: Callable[P, R]) -> Callable[P, R]:
+    result = ...
+
+    @wraps(func)
+    def _wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        nonlocal result
+        if result is not Ellipsis:
+            return result
+
+        result = func(*args, **kwargs)
+        return result
+
+    return _wrapper
+
+
 @pytest.fixture(scope="session", autouse=True)
-def load_plugin(nonebug_init: None) -> Set["Plugin"]:
+@run_once
+def load_plugin(anyio_backend, nonebug_init: None) -> set["Plugin"]:
     # preload global plugins
     return nonebot.load_plugins(str(Path(__file__).parent / "plugins"))
 
 
 @pytest.fixture(scope="session", autouse=True)
-def load_builtin_plugin(nonebug_init: None) -> Set["Plugin"]:
+@run_once
+def load_builtin_plugin(anyio_backend, nonebug_init: None) -> set["Plugin"]:
     # preload builtin plugins
     return nonebot.load_builtin_plugins("echo", "single_session")
 

tests/fake_server.py

@@ -1,7 +1,7 @@
 import json
 import base64
 import socket
-from typing import Dict, List, Union, TypeVar
+from typing import Union, TypeVar
 
 from wsproto.events import Ping
 from werkzeug import Request, Response
@@ -31,7 +31,7 @@ def json_safe(string, content_type="application/octet-stream") -> str:
         ).decode("utf-8")
 
 
-def flattern(d: "MultiDict[K, V]") -> Dict[K, Union[V, List[V]]]:
+def flattern(d: "MultiDict[K, V]") -> dict[K, Union[V, list[V]]]:
     return {k: v[0] if len(v) == 1 else v for k, v in d.to_dict(flat=False).items()}
 
 

tests/plugins/metadata_3.py

@@ -0,0 +1,15 @@
+from nonebot.plugin import PluginMetadata
+
+__plugin_meta__ = PluginMetadata(
+    name="测试插件3",
+    description="测试继承适配器, 使用内置适配器全名",
+    usage="无法使用",
+    type="application",
+    homepage="https://nonebot.dev",
+    supported_adapters={
+        "nonebot.adapters.onebot.v11",
+        "nonebot.adapters.onebot.v12",
+        "~qq",
+    },
+    extra={"author": "NoneBot"},
+)

tests/plugins/nested/__init__.py

@@ -8,5 +8,5 @@ manager = PluginManager(
 _managers.append(manager)
 
 # test load nested plugin with require
-manager.load_plugin("nested_subplugin")
+manager.load_plugin("plugins.nested.plugins.nested_subplugin")
-manager.load_plugin("nested_subplugin2")
+manager.load_plugin("nested:nested_subplugin2")

tests/plugins/param/param_arg.py

@@ -1,4 +1,4 @@
-from typing_extensions import Annotated
+from typing import Annotated
 
 from nonebot.adapters import Message
 from nonebot.params import Arg, ArgStr, ArgPlainText

tests/plugins/param/param_bot.py

@@ -7,6 +7,10 @@ async def get_bot(b: Bot) -> Bot:
     return b
 
 
+async def postpone_bot(b: "Bot") -> Bot:
+    return b
+
+
 async def legacy_bot(bot):
     return bot
 

tests/plugins/param/param_depend.py

@@ -1,6 +1,7 @@
+from typing import Annotated
 from dataclasses import dataclass
-from typing_extensions import Annotated
 
+import anyio
 from pydantic import Field
 
 from nonebot import on_message
@@ -32,8 +33,8 @@ async def gen_async():
 
 @dataclass
 class ClassDependency:
-    x: int = Depends(gen_sync)
+    x: int = Depends(gen_sync)  # noqa: RUF009
-    y: int = Depends(gen_async)
+    y: int = Depends(gen_async)  # noqa: RUF009
 
 
 class FooBot(Bot): ...
@@ -105,3 +106,26 @@ async def validate_field(x: int = Depends(lambda: "1", validate=Field(gt=0))):
 
 async def validate_field_fail(x: int = Depends(lambda: "0", validate=Field(gt=0))):
     return x
+
+
+async def _dep():
+    await anyio.sleep(1)
+    return 1
+
+
+def _dep_mismatch():
+    return 1
+
+
+async def cache_exception_func1(
+    dep: int = Depends(_dep),
+    mismatch: dict = Depends(_dep_mismatch),
+):
+    raise RuntimeError("Never reach here")
+
+
+async def cache_exception_func2(
+    dep: int = Depends(_dep),
+    match: int = Depends(_dep_mismatch),
+):
+    return dep

tests/plugins/param/param_event.py

@@ -8,6 +8,10 @@ async def event(e: Event) -> Event:
     return e
 
 
+async def postpone_event(e: "Event") -> Event:
+    return e
+
+
 async def legacy_event(event):
     return event
 

tests/plugins/param/param_matcher.py

@@ -9,6 +9,10 @@ async def matcher(m: Matcher) -> Matcher:
     return m
 
 
+async def postpone_matcher(m: "Matcher") -> Matcher:
+    return m
+
+
 async def legacy_matcher(matcher):
     return matcher
 
@@ -27,7 +31,7 @@ class BarMatcher(Matcher): ...
 
 
 async def union_matcher(
-    m: Union[FooMatcher, BarMatcher]
+    m: Union[FooMatcher, BarMatcher],
 ) -> Union[FooMatcher, BarMatcher]:
     return m
 

tests/plugins/param/param_state.py

@@ -1,4 +1,4 @@
-from typing import List, Match, Tuple
+from re import Match
 
 from nonebot.typing import T_State
 from nonebot.adapters import Message
@@ -25,6 +25,10 @@ async def state(x: T_State) -> T_State:
     return x
 
 
+async def postpone_state(x: "T_State") -> T_State:
+    return x
+
+
 async def legacy_state(state):
     return state
 
@@ -32,7 +36,7 @@ async def legacy_state(state):
 async def not_legacy_state(state: int): ...
 
 
-async def command(cmd: Tuple[str, ...] = Command()) -> Tuple[str, ...]:
+async def command(cmd: tuple[str, ...] = Command()) -> tuple[str, ...]:
     return cmd
 
 
@@ -59,8 +63,8 @@ async def shell_command_args(
 
 
 async def shell_command_argv(
-    shell_command_argv: List[str] = ShellCommandArgv(),
+    shell_command_argv: list[str] = ShellCommandArgv(),
-) -> List[str]:
+) -> list[str]:
     return shell_command_argv
 
 
@@ -68,7 +72,7 @@ async def regex_dict(regex_dict: dict = RegexDict()) -> dict:
     return regex_dict
 
 
-async def regex_group(regex_group: Tuple = RegexGroup()) -> Tuple:
+async def regex_group(regex_group: tuple = RegexGroup()) -> tuple:
     return regex_group
 
 
@@ -80,8 +84,8 @@ async def regex_str(
     entire: str = RegexStr(),
     type_: str = RegexStr("type"),
     second: str = RegexStr(2),
-    groups: Tuple[str, ...] = RegexStr(1, "arg"),
+    groups: tuple[str, ...] = RegexStr(1, "arg"),
-) -> Tuple[str, str, str, Tuple[str, ...]]:
+) -> tuple[str, str, str, tuple[str, ...]]:
     return entire, type_, second, groups
 
 

tests/plugins/plugin/matchers.py

@@ -1,4 +1,3 @@
-from typing import Type
 from datetime import datetime, timezone
 
 from nonebot.adapters import Event
@@ -52,7 +51,7 @@ matcher_on = on(
 )
 
 
-def matcher_on_factory() -> Type[Matcher]:
+def matcher_on_factory() -> type[Matcher]:
     return on(
         "test",
         rule=rule,

tests/test_adapters/test_adapter.py

@@ -17,7 +17,7 @@ from nonebot.drivers import (
 )
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_adapter_connect(app: App, driver: Driver):
     last_connect_bot: Optional[Bot] = None
     last_disconnect_bot: Optional[Bot] = None
@@ -45,7 +45,6 @@ async def test_adapter_connect(app: App, driver: Driver):
         assert bot.self_id not in adapter.bots
 
 
-@pytest.mark.asyncio
 @pytest.mark.parametrize(
     "driver",
     [
@@ -75,7 +74,7 @@ async def test_adapter_connect(app: App, driver: Driver):
     ],
     indirect=True,
 )
-async def test_adapter_server(driver: Driver):
+def test_adapter_server(driver: Driver):
     last_http_setup: Optional[HTTPServerSetup] = None
     last_ws_setup: Optional[WebSocketServerSetup] = None
 
@@ -112,7 +111,7 @@ async def test_adapter_server(driver: Driver):
         assert last_ws_setup is setup
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 @pytest.mark.parametrize(
     "driver",
     [
@@ -159,7 +158,7 @@ async def test_adapter_http_client(driver: Driver):
         assert last_request is request
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 @pytest.mark.parametrize(
     "driver",
     [

tests/test_adapters/test_bot.py

@@ -1,5 +1,6 @@
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
+import anyio
 import pytest
 from nonebug import App
 
@@ -7,7 +8,7 @@ from nonebot.adapters import Bot
 from nonebot.exception import MockApiException
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_bot_call_api(app: App):
     async with app.test_api() as ctx:
         bot = ctx.create_bot()
@@ -23,11 +24,11 @@ async def test_bot_call_api(app: App):
             await bot.call_api("test")
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_bot_calling_api_hook_simple(app: App):
     runned: bool = False
 
-    async def calling_api_hook(bot: Bot, api: str, data: Dict[str, Any]):
+    async def calling_api_hook(bot: Bot, api: str, data: dict[str, Any]):
         nonlocal runned
         runned = True
 
@@ -49,11 +50,11 @@ async def test_bot_calling_api_hook_simple(app: App):
         assert result is True
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_bot_calling_api_hook_mock(app: App):
     runned: bool = False
 
-    async def calling_api_hook(bot: Bot, api: str, data: Dict[str, Any]):
+    async def calling_api_hook(bot: Bot, api: str, data: dict[str, Any]):
         nonlocal runned
         runned = True
 
@@ -76,7 +77,47 @@ async def test_bot_calling_api_hook_mock(app: App):
         assert result is False
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
+async def test_bot_calling_api_hook_multi_mock(app: App):
+    runned1: bool = False
+    runned2: bool = False
+    event = anyio.Event()
+
+    async def calling_api_hook1(bot: Bot, api: str, data: dict[str, Any]):
+        nonlocal runned1
+        runned1 = True
+        event.set()
+
+        raise MockApiException(1)
+
+    async def calling_api_hook2(bot: Bot, api: str, data: dict[str, Any]):
+        nonlocal runned2
+        runned2 = True
+        with anyio.fail_after(1):
+            await event.wait()
+
+        raise MockApiException(2)
+
+    hooks = set()
+
+    with pytest.MonkeyPatch.context() as m:
+        m.setattr(Bot, "_calling_api_hook", hooks)
+
+        Bot.on_calling_api(calling_api_hook1)
+        Bot.on_calling_api(calling_api_hook2)
+
+        assert hooks == {calling_api_hook1, calling_api_hook2}
+
+        async with app.test_api() as ctx:
+            bot = ctx.create_bot()
+            result = await bot.call_api("test")
+
+        assert runned1 is True
+        assert runned2 is True
+        assert result == 1
+
+
+@pytest.mark.anyio
 async def test_bot_called_api_hook_simple(app: App):
     runned: bool = False
 
@@ -84,7 +125,7 @@ async def test_bot_called_api_hook_simple(app: App):
         bot: Bot,
         exception: Optional[Exception],
         api: str,
-        data: Dict[str, Any],
+        data: dict[str, Any],
         result: Any,
     ):
         nonlocal runned
@@ -108,7 +149,7 @@ async def test_bot_called_api_hook_simple(app: App):
         assert result is True
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_bot_called_api_hook_mock(app: App):
     runned: bool = False
 
@@ -116,7 +157,7 @@ async def test_bot_called_api_hook_mock(app: App):
         bot: Bot,
         exception: Optional[Exception],
         api: str,
-        data: Dict[str, Any],
+        data: dict[str, Any],
         result: Any,
     ):
         nonlocal runned
@@ -150,3 +191,56 @@ async def test_bot_called_api_hook_mock(app: App):
 
         assert runned is True
         assert result is False
+
+
+@pytest.mark.anyio
+async def test_bot_called_api_hook_multi_mock(app: App):
+    runned1: bool = False
+    runned2: bool = False
+    event = anyio.Event()
+
+    async def called_api_hook1(
+        bot: Bot,
+        exception: Optional[Exception],
+        api: str,
+        data: dict[str, Any],
+        result: Any,
+    ):
+        nonlocal runned1
+        runned1 = True
+        event.set()
+
+        raise MockApiException(1)
+
+    async def called_api_hook2(
+        bot: Bot,
+        exception: Optional[Exception],
+        api: str,
+        data: dict[str, Any],
+        result: Any,
+    ):
+        nonlocal runned2
+        runned2 = True
+        with anyio.fail_after(1):
+            await event.wait()
+
+        raise MockApiException(2)
+
+    hooks = set()
+
+    with pytest.MonkeyPatch.context() as m:
+        m.setattr(Bot, "_called_api_hook", hooks)
+
+        Bot.on_called_api(called_api_hook1)
+        Bot.on_called_api(called_api_hook2)
+
+        assert hooks == {called_api_hook1, called_api_hook2}
+
+        async with app.test_api() as ctx:
+            bot = ctx.create_bot()
+            ctx.should_call_api("test", {}, True)
+            result = await bot.call_api("test")
+
+        assert runned1 is True
+        assert runned2 is True
+        assert result == 1

tests/test_adapters/test_message.py

@@ -192,6 +192,11 @@ def test_message_contains():
     assert message.has("foo") is False
     assert "foo" not in message
 
+    assert not bool(FakeMessageSegment.text(""))
+    msg_with_empty_seg = FakeMessage([FakeMessageSegment.text("")])
+    assert msg_with_empty_seg.has("text") is True
+    assert "text" in msg_with_empty_seg
+
 
 def test_message_only():
     message = FakeMessage(

tests/test_broadcast.py

@@ -25,7 +25,7 @@ async def _dependency() -> int:
     return 1
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_event_preprocessor(app: App, monkeypatch: pytest.MonkeyPatch):
     with monkeypatch.context() as m:
         m.setattr(message, "_event_preprocessors", set())
@@ -58,7 +58,7 @@ async def test_event_preprocessor(app: App, monkeypatch: pytest.MonkeyPatch):
         assert runned, "event_preprocessor should runned"
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_event_preprocessor_ignore(app: App, monkeypatch: pytest.MonkeyPatch):
     with monkeypatch.context() as m:
         m.setattr(message, "_event_preprocessors", set())
@@ -88,7 +88,7 @@ async def test_event_preprocessor_ignore(app: App, monkeypatch: pytest.MonkeyPat
         assert not runned, "matcher should not runned"
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_event_preprocessor_exception(
     app: App, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ):
@@ -132,7 +132,7 @@ async def test_event_preprocessor_exception(
         assert "RuntimeError: test" in capsys.readouterr().out
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_event_postprocessor(app: App, monkeypatch: pytest.MonkeyPatch):
     with monkeypatch.context() as m:
         m.setattr(message, "_event_postprocessors", set())
@@ -165,7 +165,7 @@ async def test_event_postprocessor(app: App, monkeypatch: pytest.MonkeyPatch):
         assert runned, "event_postprocessor should runned"
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_event_postprocessor_exception(
     app: App, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ):
@@ -202,7 +202,7 @@ async def test_event_postprocessor_exception(
         assert "RuntimeError: test" in capsys.readouterr().out
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_run_preprocessor(app: App, monkeypatch: pytest.MonkeyPatch):
     with monkeypatch.context() as m:
         m.setattr(message, "_run_preprocessors", set())
@@ -239,7 +239,7 @@ async def test_run_preprocessor(app: App, monkeypatch: pytest.MonkeyPatch):
         assert runned, "run_preprocessor should runned"
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_run_preprocessor_ignore(app: App, monkeypatch: pytest.MonkeyPatch):
     with monkeypatch.context() as m:
         m.setattr(message, "_run_preprocessors", set())
@@ -269,7 +269,7 @@ async def test_run_preprocessor_ignore(app: App, monkeypatch: pytest.MonkeyPatch
         assert not runned, "matcher should not runned"
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_run_preprocessor_exception(
     app: App, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ):
@@ -313,7 +313,7 @@ async def test_run_preprocessor_exception(
         assert "RuntimeError: test" in capsys.readouterr().out
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_run_postprocessor(app: App, monkeypatch: pytest.MonkeyPatch):
     with monkeypatch.context() as m:
         m.setattr(message, "_run_postprocessors", set())
@@ -351,7 +351,7 @@ async def test_run_postprocessor(app: App, monkeypatch: pytest.MonkeyPatch):
         assert runned, "run_postprocessor should runned"
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_run_postprocessor_exception(
     app: App, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
 ):

tests/test_compat.py

@@ -1,28 +1,28 @@
-from typing import Any
 from dataclasses import dataclass
+from typing import Any, Optional, Annotated
 
 import pytest
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
 
 from nonebot.compat import (
     DEFAULT_CONFIG,
     Required,
     FieldInfo,
+    TypeAdapter,
     PydanticUndefined,
     model_dump,
     custom_validation,
+    type_validate_json,
     type_validate_python,
 )
 
 
-@pytest.mark.asyncio
+def test_default_config():
-async def test_default_config():
     assert DEFAULT_CONFIG.get("extra") == "allow"
     assert DEFAULT_CONFIG.get("arbitrary_types_allowed") is True
 
 
-@pytest.mark.asyncio
+def test_field_info():
-async def test_field_info():
     # required should be convert to PydanticUndefined
     assert FieldInfo(Required).default is PydanticUndefined
 
@@ -30,8 +30,21 @@ async def test_field_info():
     assert FieldInfo(test="test").extra["test"] == "test"
 
 
-@pytest.mark.asyncio
+def test_type_adapter():
-async def test_model_dump():
+    t = TypeAdapter(Annotated[int, FieldInfo(ge=1)])
+
+    assert t.validate_python(2) == 2
+
+    with pytest.raises(ValidationError):
+        t.validate_python(0)
+
+    assert t.validate_json("2") == 2
+
+    with pytest.raises(ValidationError):
+        t.validate_json("0")
+
+
+def test_model_dump():
     class TestModel(BaseModel):
         test1: int
         test2: int
@@ -40,8 +53,7 @@ async def test_model_dump():
     assert model_dump(TestModel(test1=1, test2=2), exclude={"test1"}) == {"test2": 2}
 
 
-@pytest.mark.asyncio
+def test_custom_validation():
-async def test_custom_validation():
     called = []
 
     @custom_validation
@@ -66,3 +78,25 @@ async def test_custom_validation():
 
     assert type_validate_python(TestModel, {"test": 1}) == TestModel(test=1)
     assert called == [1, 2]
+
+
+def test_validate_json():
+    class TestModel(BaseModel):
+        test1: int
+        test2: str
+        test3: bool
+        test4: dict
+        test5: list
+        test6: Optional[int]
+
+    assert type_validate_json(
+        TestModel,
+        "{"
+        '  "test1": 1,'
+        '  "test2": "2",'
+        '  "test3": true,'
+        '  "test4": {},'
+        '  "test5": [],'
+        '  "test6": null'
+        "}",
+    ) == TestModel(test1=1, test2="2", test3=True, test4={}, test5=[], test6=None)

tests/test_config.py

@@ -1,9 +1,10 @@
-from typing import List, Union, Optional
+from typing import TYPE_CHECKING, Union, Optional
 
 import pytest
-from pydantic import BaseModel
+from pydantic import Field, BaseModel
 
-from nonebot.config import DOTENV_TYPE, BaseSettings, SettingsError
+from nonebot.compat import PYDANTIC_V2
+from nonebot.config import DOTENV_TYPE, BaseSettings, SettingsError, SettingsConfig
 
 
 class Simple(BaseModel):
@@ -14,36 +15,49 @@ class Simple(BaseModel):
 
 
 class Example(BaseSettings):
-    _env_file: Optional[DOTENV_TYPE] = ".env", ".env.example"
+    if TYPE_CHECKING:
-    _env_nested_delimiter: Optional[str] = "__"
+        _env_file: Optional[DOTENV_TYPE] = ".env", ".env.example"
+        _env_nested_delimiter: Optional[str] = "__"
+
+    if PYDANTIC_V2:
+        model_config = SettingsConfig(
+            env_file=(".env", ".env.example"), env_nested_delimiter="__"
+        )
+    else:
+
+        class Config(  # pyright: ignore[reportIncompatibleVariableOverride]
+            SettingsConfig
+        ):
+            env_file = ".env", ".env.example"
+            env_nested_delimiter = "__"
 
     simple: str = ""
-    complex: List[int] = [1]
+    complex: list[int] = Field(default=[1])
-    complex_none: Optional[List[int]] = None
+    complex_none: Optional[list[int]] = None
-    complex_union: Union[int, List[int]] = 1
+    complex_union: Union[int, list[int]] = 1
     nested: Simple = Simple()
     nested_inner: Simple = Simple()
 
-    class Config:
-        env_file = ".env", ".env.example"
-        env_nested_delimiter = "__"
-
 
 class ExampleWithoutDelimiter(Example):
-    class Config:
+    if PYDANTIC_V2:
-        env_nested_delimiter = None
+        model_config = SettingsConfig(env_nested_delimiter=None)
+    else:
+
+        class Config(  # pyright: ignore[reportIncompatibleVariableOverride]
+            SettingsConfig
+        ):
+            env_nested_delimiter = None
 
 
-@pytest.mark.asyncio
+def test_config_no_env():
-async def test_config_no_env():
     config = Example(_env_file=None)
     assert config.simple == ""
     with pytest.raises(AttributeError):
         config.common_config
 
 
-@pytest.mark.asyncio
+def test_config_with_env():
-async def test_config_with_env():
     config = Example(_env_file=(".env", ".env.example"))
     assert config.simple == "simple"
 
@@ -86,8 +100,7 @@ async def test_config_with_env():
         config.other_nested_inner__b
 
 
-@pytest.mark.asyncio
+def test_config_error_env():
-async def test_config_error_env():
     with pytest.MonkeyPatch().context() as m:
         m.setenv("COMPLEX", "not json")
 
@@ -95,8 +108,7 @@ async def test_config_error_env():
             Example(_env_file=(".env", ".env.example"))
 
 
-@pytest.mark.asyncio
+def test_config_without_delimiter():
-async def test_config_without_delimiter():
     config = ExampleWithoutDelimiter()
     assert config.nested.a == 1
     assert config.nested.b == 0

tests/test_driver.py

@@ -1,7 +1,8 @@
 import json
-import asyncio
+from typing import Any, Optional
-from typing import Any, Set, Optional
+from http.cookies import SimpleCookie
 
+import anyio
 import pytest
 from nonebug import App
 
@@ -24,7 +25,7 @@ from nonebot.drivers import (
 )
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 @pytest.mark.parametrize(
     "driver", [pytest.param("nonebot.drivers.none:Driver", id="none")], indirect=True
 )
@@ -58,22 +59,22 @@ async def test_lifespan(driver: Driver):
 
     @driver.on_shutdown
     async def _shutdown1():
-        assert shutdown_log == []
+        assert shutdown_log == [2]
         shutdown_log.append(1)
 
     @driver.on_shutdown
     async def _shutdown2():
-        assert shutdown_log == [1]
+        assert shutdown_log == []
         shutdown_log.append(2)
 
     async with driver._lifespan:
         assert start_log == [1, 2]
         assert ready_log == [1, 2]
 
-    assert shutdown_log == [1, 2]
+    assert shutdown_log == [2, 1]
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 @pytest.mark.parametrize(
     "driver",
     [
@@ -98,10 +99,10 @@ async def test_http_server(app: App, driver: Driver):
         assert response.status_code == 200
         assert response.text == "test"
 
-    await asyncio.sleep(1)
+    await anyio.sleep(1)
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 @pytest.mark.parametrize(
     "driver",
     [
@@ -154,10 +155,10 @@ async def test_websocket_server(app: App, driver: Driver):
 
             await ws.close(code=1000)
 
-    await asyncio.sleep(1)
+    await anyio.sleep(1)
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 @pytest.mark.parametrize(
     "driver",
     [
@@ -170,9 +171,10 @@ async def test_cross_context(app: App, driver: Driver):
     assert isinstance(driver, ASGIMixin)
 
     ws: Optional[WebSocket] = None
-    ws_ready = asyncio.Event()
+    ws_ready = anyio.Event()
-    ws_should_close = asyncio.Event()
+    ws_should_close = anyio.Event()
 
+    # create a background task before the ws connection established
     async def background_task():
         try:
             await ws_ready.wait()
@@ -184,8 +186,6 @@ async def test_cross_context(app: App, driver: Driver):
         finally:
             ws_should_close.set()
 
-    task = asyncio.create_task(background_task())
-
     async def _handle_ws(websocket: WebSocket) -> None:
         nonlocal ws
         await websocket.accept()
@@ -198,7 +198,9 @@ async def test_cross_context(app: App, driver: Driver):
     ws_setup = WebSocketServerSetup(URL("/ws_test"), "ws_test", _handle_ws)
     driver.setup_websocket_server(ws_setup)
 
-    async with app.test_server(driver.asgi) as ctx:
+    async with anyio.create_task_group() as tg, app.test_server(driver.asgi) as ctx:
+        tg.start_soon(background_task)
+
         client = ctx.get_client()
 
         async with client.websocket_connect("/ws_test") as websocket:
@@ -210,11 +212,10 @@ async def test_cross_context(app: App, driver: Driver):
                 if not e.args or "websocket.close" not in str(e.args[0]):
                     raise
 
-    await task
+    await anyio.sleep(1)
-    await asyncio.sleep(1)
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 @pytest.mark.parametrize(
     "driver",
     [
@@ -303,10 +304,125 @@ async def test_http_client(driver: Driver, server_url: URL):
         "test3": "test",
     }, "file parsing error"
 
-    await asyncio.sleep(1)
+    await anyio.sleep(1)
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
+@pytest.mark.parametrize(
+    "driver",
+    [
+        pytest.param("nonebot.drivers.httpx:Driver", id="httpx"),
+        pytest.param("nonebot.drivers.aiohttp:Driver", id="aiohttp"),
+    ],
+    indirect=True,
+)
+async def test_http_client_session(driver: Driver, server_url: URL):
+    assert isinstance(driver, HTTPClientMixin)
+
+    session = driver.get_session(
+        params={"session": "test"},
+        headers={"X-Session": "test"},
+        cookies={"session": "test"},
+    )
+    request = Request("GET", server_url)
+    with pytest.raises(RuntimeError):
+        await session.request(request)
+
+    with pytest.raises(RuntimeError):  # noqa: PT012
+        async with session:
+            async with session:
+                ...
+
+    async with session as session:
+        # simple post with query, headers, cookies and content
+        request = Request(
+            "POST",
+            server_url,
+            params={"param": "test"},
+            headers={"X-Test": "test"},
+            cookies={"cookie": "test"},
+            content="test",
+        )
+        response = await session.request(request)
+        assert response.status_code == 200
+        assert response.content
+        data = json.loads(response.content)
+        assert data["method"] == "POST"
+        assert data["args"] == {"session": "test", "param": "test"}
+        assert data["headers"].get("X-Session") == "test"
+        assert data["headers"].get("X-Test") == "test"
+        assert {
+            key: cookie.value
+            for key, cookie in SimpleCookie(data["headers"].get("Cookie")).items()
+        } == {
+            "session": "test",
+            "cookie": "test",
+        }
+        assert data["data"] == "test"
+
+        # post with data body
+        request = Request("POST", server_url, data={"form": "test"})
+        response = await session.request(request)
+        assert response.status_code == 200
+        assert response.content
+        data = json.loads(response.content)
+        assert data["method"] == "POST"
+        assert data["args"] == {"session": "test"}
+        assert data["headers"].get("X-Session") == "test"
+        assert {
+            key: cookie.value
+            for key, cookie in SimpleCookie(data["headers"].get("Cookie")).items()
+        } == {"session": "test"}
+        assert data["form"] == {"form": "test"}
+
+        # post with json body
+        request = Request("POST", server_url, json={"json": "test"})
+        response = await session.request(request)
+        assert response.status_code == 200
+        assert response.content
+        data = json.loads(response.content)
+        assert data["method"] == "POST"
+        assert data["args"] == {"session": "test"}
+        assert data["headers"].get("X-Session") == "test"
+        assert {
+            key: cookie.value
+            for key, cookie in SimpleCookie(data["headers"].get("Cookie")).items()
+        } == {"session": "test"}
+        assert data["json"] == {"json": "test"}
+
+        # post with files and form data
+        request = Request(
+            "POST",
+            server_url,
+            data={"form": "test"},
+            files=[
+                ("test1", b"test"),
+                ("test2", ("test.txt", b"test")),
+                ("test3", ("test.txt", b"test", "text/plain")),
+            ],
+        )
+        response = await session.request(request)
+        assert response.status_code == 200
+        assert response.content
+        data = json.loads(response.content)
+        assert data["method"] == "POST"
+        assert data["args"] == {"session": "test"}
+        assert data["headers"].get("X-Session") == "test"
+        assert {
+            key: cookie.value
+            for key, cookie in SimpleCookie(data["headers"].get("Cookie")).items()
+        } == {"session": "test"}
+        assert data["form"] == {"form": "test"}
+        assert data["files"] == {
+            "test1": "test",
+            "test2": "test",
+            "test3": "test",
+        }, "file parsing error"
+
+    await anyio.sleep(1)
+
+
+@pytest.mark.anyio
 @pytest.mark.parametrize(
     "driver",
     [
@@ -336,10 +452,9 @@ async def test_websocket_client(driver: Driver, server_url: URL):
         with pytest.raises(WebSocketClosed, match=r"code=1000"):
             await ws.receive()
 
-    await asyncio.sleep(1)
+    await anyio.sleep(1)
 
 
-@pytest.mark.asyncio
 @pytest.mark.parametrize(
     ("driver", "driver_type"),
     [
@@ -356,15 +471,15 @@ async def test_websocket_client(driver: Driver, server_url: URL):
     ],
     indirect=["driver"],
 )
-async def test_combine_driver(driver: Driver, driver_type: str):
+def test_combine_driver(driver: Driver, driver_type: str):
     assert driver.type == driver_type
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_bot_connect_hook(app: App, driver: Driver):
     with pytest.MonkeyPatch.context() as m:
-        conn_hooks: Set[Dependent[Any]] = set()
+        conn_hooks: set[Dependent[Any]] = set()
-        disconn_hooks: Set[Dependent[Any]] = set()
+        disconn_hooks: set[Dependent[Any]] = set()
         m.setattr(Driver, "_bot_connection_hook", conn_hooks)
         m.setattr(Driver, "_bot_disconnection_hook", disconn_hooks)
 
@@ -409,15 +524,15 @@ async def test_bot_connect_hook(app: App, driver: Driver):
 
             disconn_should_be_called = True
 
-        if conn_hook not in {hook.call for hook in conn_hooks}:
+        if conn_hook not in {hook.call for hook in conn_hooks}:  # type: ignore
             pytest.fail("on_bot_connect hook not registered")
-        if disconn_hook not in {hook.call for hook in disconn_hooks}:
+        if disconn_hook not in {hook.call for hook in disconn_hooks}:  # type: ignore
             pytest.fail("on_bot_disconnect hook not registered")
 
         async with app.test_api() as ctx:
             bot = ctx.create_bot()
 
-        await asyncio.sleep(1)
+        await anyio.sleep(1)
 
         if not conn_should_be_called:
             pytest.fail("on_bot_connect hook not called")

tests/test_echo.py

@@ -4,7 +4,7 @@ from nonebug import App
 from utils import FakeMessage, FakeMessageSegment, make_fake_event
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_echo(app: App):
     from nonebot.plugins.echo import echo
 

tests/test_init.py

@@ -14,8 +14,7 @@ from nonebot import (
 )
 
 
-@pytest.mark.asyncio
+def test_init():
-async def test_init():
     env = nonebot.get_driver().env
     assert env == "test"
 
@@ -35,31 +34,28 @@ async def test_init():
     assert config.not_nested == "some string"
 
 
-@pytest.mark.asyncio
+def test_get_driver(monkeypatch: pytest.MonkeyPatch):
-async def test_get_driver(app: App, monkeypatch: pytest.MonkeyPatch):
     with monkeypatch.context() as m:
         m.setattr(nonebot, "_driver", None)
         with pytest.raises(ValueError, match="initialized"):
             get_driver()
 
 
-@pytest.mark.asyncio
+def test_get_asgi():
-async def test_get_asgi(app: App, monkeypatch: pytest.MonkeyPatch):
     driver = get_driver()
     assert isinstance(driver, ReverseDriver)
     assert isinstance(driver, ASGIMixin)
     assert get_asgi() == driver.asgi
 
 
-@pytest.mark.asyncio
+def test_get_app():
-async def test_get_app(app: App, monkeypatch: pytest.MonkeyPatch):
     driver = get_driver()
     assert isinstance(driver, ReverseDriver)
     assert isinstance(driver, ASGIMixin)
     assert get_app() == driver.server_app
 
 
-@pytest.mark.asyncio
+@pytest.mark.anyio
 async def test_get_adapter(app: App, monkeypatch: pytest.MonkeyPatch):
     async with app.test_api() as ctx:
         adapter = ctx.create_adapter()
@@ -74,8 +70,7 @@ async def test_get_adapter(app: App, monkeypatch: pytest.MonkeyPatch):
                 get_adapter("not exist")
 
 
-@pytest.mark.asyncio
+def test_run(monkeypatch: pytest.MonkeyPatch):
-async def test_run(app: App, monkeypatch: pytest.MonkeyPatch):
     runned = False
 
     def mock_run(*args, **kwargs):
@@ -93,8 +88,7 @@ async def test_run(app: App, monkeypatch: pytest.MonkeyPatch):
     assert runned
 
 
-@pytest.mark.asyncio
+def test_get_bot(app: App, monkeypatch: pytest.MonkeyPatch):
-async def test_get_bot(app: App, monkeypatch: pytest.MonkeyPatch):
     driver = get_driver()
 
     with pytest.raises(ValueError, match="no bots"):