更改令人费解的 requirements.txt 方案

Reviewed-on: #22

.vscode/launch.json

@@ -1,24 +0,0 @@
-{
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "name": "运行 Bot 并调试（自动重载）",
-            "type": "debugpy",
-            "request": "launch",
-            "module": "watchfiles",
-            "args": [
-                "bot.main"
-            ],
-            "console": "integratedTerminal",
-            "justMyCode": true,
-            "env": {
-                "PYTHONPATH": "${workspaceFolder}"
-            },
-            "cwd": "${workspaceFolder}",
-            "presentation": {
-                "hidden": false,
-                "group": "bot"
-            }
-        }
-    ]
-}

.vscode/tasks.json

@@ -1,30 +0,0 @@
-{
-    "version": "2.0.0",
-    "tasks": [
-        {
-            "label": "Poetry: Export requirements.txt (Production)",
-            "type": "shell",
-            "command": "poetry export -f requirements.txt --output requirements.txt --without-hashes",
-            "group": "build",
-            "presentation": {
-                "reveal": "always",
-                "panel": "new"
-            },
-            "problemMatcher": [],
-            "detail": "导出生产环境依赖到 requirements.txt"
-        },
-        {
-            "label": "Bot: Run with Auto-reload",
-            "type": "shell",
-            "command": "poetry run watchfiles bot.main",
-            "group": "build",
-            "isBackground": true,
-            "presentation": {
-                "reveal": "always",
-                "panel": "new"
-            },
-            "problemMatcher": [],
-            "detail": "运行 bot 并启用自动重载功能"
-        }
-    ]
-}

Dockerfile

@@ -1,8 +1,32 @@
-FROM python:3.13-slim
+# copied from https://www.martinrichards.me/post/python_poetry_docker/
+FROM python:3.13-slim AS base
+
+ENV VIRTUAL_ENV=/app/.venv \
+    PATH="/app/.venv/bin:$PATH"
+
+
+
+FROM base AS builder
+
+ENV POETRY_NO_INTERACTION=1 \
+    POETRY_VIRTUALENVS_IN_PROJECT=1 \
+    POETRY_VIRTUALENVS_CREATE=1 \
+    POETRY_CACHE_DIR=/tmp/poetry_cache
+
+WORKDIR /app
+
+RUN pip install poetry
+
+COPY pyproject.toml poetry.lock ./
+RUN python -m poetry install --no-root && rm -rf $POETRY_CACHE_DIR
+
+
+
+FROM base AS runtime
+
+COPY --from=builder ${VIRTUAL_ENV} ${VIRTUAL_ENV}
 
 WORKDIR /app
-COPY requirements.txt ./
-RUN pip install -r requirements.txt --no-deps
 
 COPY bot.py pyproject.toml .env.prod .env.test ./
 COPY assets ./assets

README.md

@@ -65,10 +65,10 @@ code .
 
 ### 运行
 
-你可以在 VSCode 的「运行与调试」窗口，启动 `运行 Bot 并调试（自动重载）` 任务来启动 Bot，也可以使用命令行手动启动 Bot：
+使用命令行手动启动 Bot：
 
 ```bash
-poetry run watchfiles bot.main
+poetry run watchfiles bot.main konabot
 ```
 
 如果你不希望自动重载，只是想运行 Bot，可以直接运行：

konabot/common/nb/is_admin.py

@@ -0,0 +1,34 @@
+from nonebot import get_plugin_config
+import nonebot
+import nonebot.adapters
+import nonebot.adapters.console
+import nonebot.adapters.discord
+import nonebot.adapters.onebot
+from pydantic import BaseModel
+
+
+class IsAdminConfig(BaseModel):
+    admin_qq_group: list[int] = []
+    admin_qq_account: list[int] = []
+    admin_discord_channel: list[int] = []
+    admin_discord_account: list[int] = []
+
+cfg = get_plugin_config(IsAdminConfig)
+
+
+def is_admin(event: nonebot.adapters.Event):
+    if isinstance(event, nonebot.adapters.onebot.v11.MessageEvent):
+        if event.user_id in cfg.admin_qq_account:
+            return True
+        if isinstance(event, nonebot.adapters.onebot.v11.GroupMessageEvent):
+            if event.group_id in cfg.admin_qq_group:
+                return True
+    if isinstance(event, nonebot.adapters.discord.event.MessageEvent):
+        if event.channel_id in cfg.admin_discord_channel:
+            return True
+        if event.user_id in cfg.admin_discord_account:
+            return True
+    if isinstance(event, nonebot.adapters.console.event.Event):
+        return True
+
+    return False

konabot/common/path.py

@@ -2,3 +2,11 @@ from pathlib import Path
 
 ASSETS_PATH = Path(__file__).resolve().parent.parent.parent / "assets"
 FONTS_PATH = ASSETS_PATH / "fonts"
+
+SRC_PATH = Path(__file__).resolve().parent.parent
+
+DOCS_PATH = SRC_PATH / "docs"
+DOCS_PATH_MAN1 = DOCS_PATH / "user"
+DOCS_PATH_MAN3 = DOCS_PATH / "lib"
+DOCS_PATH_MAN7 = DOCS_PATH / "concepts"
+DOCS_PATH_MAN8 = DOCS_PATH / "sys"

konabot/docs/README.md

@@ -0,0 +1,40 @@
+# 此方 Bot 的文档系统
+
+此方 Bot 使用类 Linux 的 `man` 指令来管理文档。文档一般建议使用纯文本书写，带有相对良好的格式。
+
+## 文件夹摆放规则
+
+`docs` 目录下，有若干文档可以拿来阅读和输出。每个子文件夹里，文档文件使用名字不含空格的 txt 文件书写，其他后缀名的文件将会被忽略。所以，如果你希望有些文件只在代码库中可阅读，你可以使用 `.md` 格式。
+
+### 1 - user
+
+`docs/user` 目录下的文档是直接会给用户进行检索的文档，在直接使用 `man` 指令时，会搜索该文件夹的全部文件，以知晓所有有文档的指令。
+
+### 3 - lib
+
+`docs/lib` 目录下的文档主要给该项目的维护者进行阅读和使用，讲述的是本项目内置的一些函数的功能讲解（一般以便利为主要目的）以及一些项目安排上的要求。一般不会列举，除非用户指定要求列举该范围。
+
+### 7 - concepts
+
+`docs/concepts` 用来摆放任何的概念。任何的。一般不会列举，除非用户指定要求列举该范围。
+
+### 8 - sys
+
+`docs/sys` 用于摆放仅 MTTU 群可以使用的文档集合。在 MTTU 群内，该目录下的文档也会被索引，否则文档将不可阅读。
+
+## 书写规范
+
+无特殊要求，因为当用户进行 `man` 的时候，会将文档内的内容原封不动地展示出来。但是，你仍然可以模仿 Linux 下的 `man` 指令的格式进行书写。
+
+```
+指令介绍
+    man - 用于展示此方 BOT 使用手册的指令
+
+格式
+    man [文档类型] <指令>
+
+示例
+    `man` 查看所有有文档的指令清单
+    `man 喵` 查看指令「喵」的使用说明
+……
+```

konabot/docs/lib/is_admin.txt

@@ -0,0 +1,45 @@
+指令介绍
+    is_admin - 用于判断当前事件是否来自管理员的内部权限校验函数
+
+格式
+    from konabot.common.nb.is_admin import is_admin
+    from nonebot import on
+    from nonebot.adapters import Event
+    from loguru import logger
+
+    @on().handle()
+    async def _(event: Event):
+        if is_admin(event):
+            logger.info("管理员发送了消息")
+
+说明
+    is_admin 是 Bot 内部用于权限控制的核心函数，根据事件来源（QQ、Discord、控制台）及插件配置，判断触发事件的用户或群组是否具有管理员权限。
+
+支持的适配器与判定逻辑：
+    • OneBot V11（QQ）
+        - 若用户 ID 在配置项 admin_qq_account 中，则视为管理员
+        - 若为群聊消息，且群 ID 在配置项 admin_qq_group 中，则视为管理员
+
+    • Discord
+        - 若频道 ID 在配置项 admin_discord_channel 中，则视为管理员
+        - 若用户 ID 在配置项 admin_discord_account 中，则视为管理员
+
+    • Console（控制台）
+        - 所有控制台输入均默认视为管理员操作，自动返回 True
+
+配置项（位于插件配置中）
+    ADMIN_QQ_GROUP: list[int]
+        允许的管理员 QQ 群 ID 列表
+
+    ADMIN_QQ_ACCOUNT: list[int]
+        允许的管理员 QQ 账号 ID 列表
+
+    ADMIN_DISCORD_CHANNEL: list[int]
+        允许的管理员 Discord 频道 ID 列表
+
+    ADMIN_DISCORD_ACCOUNT: list[int]
+        允许的管理员 Discord 用户 ID 列表
+
+注意事项
+    - 若未在配置文件中设置任何管理员 ID，该函数对所有非控制台事件返回 False
+    - 控制台事件始终拥有管理员权限，便于本地调试与运维

konabot/docs/sys/out.txt

@@ -0,0 +1 @@
+MAN what can I say!

konabot/docs/user/man.txt

@@ -0,0 +1,20 @@
+指令介绍
+    man - 用于展示此方 BOT 使用手册的指令
+
+格式
+    man 文档类型
+    man [文档类型] <指令>
+
+示例
+    `man` 查看所有有文档的指令清单
+    `man 3` 列举所有可读文档的库函数清单
+    `man 喵` 查看指令「喵」的使用说明
+    `man 8 out` 查看管理员指令「out」的使用说明
+
+文档类型
+    文档类型用来区分同一指令在不同场景下的情景。你可以使用数字编号进行筛选。分为这些种类：
+
+    - 1 用户态指令，用于日常使用的指令
+    - 3 库函数指令，用于 Bot 开发用的函数查询
+    - 7 概念指令，用于概念解释
+    - 8 系统指令，仅管理员可用

konabot/docs/user/openssl.txt

@@ -0,0 +1,21 @@
+指令介绍
+    openssl - 用于生成指定长度的加密安全随机数据
+
+格式
+    openssl rand <模式> <字节数>
+
+示例
+    `openssl rand -hex 16` 生成 16 字节的十六进制随机数
+    `openssl rand -base64 32` 生成 32 字节并以 Base64 编码输出的随机数据
+
+说明
+    该指令使用 Python 的 secrets 模块生成加密安全的随机字节，并支持以十六进制（-hex）或 Base64（-base64）格式输出。
+
+参数说明
+    模式（mode）
+        - -hex     ：以十六进制字符串形式输出随机数据
+        - -base64  ：以 Base64 编码字符串形式输出随机数据
+
+    字节数（num）
+        - 必须为正整数
+        - 最大支持 256 字节

konabot/docs/user/ytpgif.txt

@@ -0,0 +1,41 @@
+指令介绍
+    ytpgif - 生成来回镜像翻转的仿 YTPMV 动图
+
+格式
+    ytpgif [倍速]
+
+示例
+    `ytpgif`  
+        使用默认倍速（1.0）处理你发送或回复的图片，生成镜像动图。
+
+    `ytpgif 2.5`  
+        以 2.5 倍速处理图片，生成更快节奏的镜像动图。
+
+    回复一张图片并发送 `ytpgif 0.5`  
+        以慢速（0.5 倍）生成镜像动图。
+
+参数说明
+    倍速（可选）
+        - 类型：浮点数
+        - 默认值：1.0
+        - 有效范围：0.1 ～ 20.0
+        - 作用：
+            • 对于静态图：控制镜像切换的快慢（值越大，切换越快）。
+            • 对于动图：控制截取原始动图正向和反向片段的时长（值越大，截取的片段越长）。
+
+使用方式
+    发送指令前，请确保：
+      - 直接在消息中附带一张图片，或
+      - 回复一条包含图片的消息后再发送指令。
+
+    插件会自动：
+      - 下载并识别图片（支持静态图和 GIF 动图）
+      - 自动缩放至最大边长不超过 256 像素（保持宽高比）
+      - 静态图 → 生成“原图↔镜像”循环动图
+      - 动图 → 截取开头一段正向播放 + 同一段镜像翻转播放，拼接成新动图
+      - 保留透明通道（如原图含透明），否则转为 RGB 避免颜色异常
+
+注意事项
+    - 图片过大、格式损坏或网络问题可能导致处理失败。
+    - 动图帧数过多或单帧过短可能无法生成有效输出。
+    - 输出 GIF 最大单段帧数限制为 500 帧，以防资源耗尽。

konabot/docs/user/喵.txt

@@ -0,0 +1,2 @@
+指令介绍
+    喵 - 你发喵，此方就会回复喵

konabot/docs/user/摇数字.txt

@@ -0,0 +1,7 @@
+指令介绍
+    摇数字 - 生成一个随机数字并发送
+
+示例
+    `摇数字` 随机生成一个 1-6 的数字
+
+该指令不接受任何参数，直接调用即可。

konabot/docs/user/摇骰子.txt

@@ -0,0 +1,22 @@
+指令介绍
+    摇骰子 - 用于生成随机数并以骰子图像形式展示的指令
+
+格式
+    摇骰子 [最小值] [最大值]
+
+示例
+    `摇骰子` 随机生成一个 1-6 的数字，并显示对应的骰子图像
+    `摇骰子 10` 生成 1 到 10 之间的随机整数
+    `摇骰子 0.5` 生成 0 到 0.5 之间的随机小数
+    `摇骰子 -5 5` 生成 -5 到 5 之间的随机数
+
+说明
+    该指令支持以下几种调用方式：
+      - 不带参数：使用默认范围生成随机数
+      - 仅指定一个参数 f1：
+          - 若 f1 > 1，则生成 [1, f1] 范围内的随机数
+          - 若 0 < f1 ≤ 1，则生成 [0, f1] 范围内的随机数
+          - 若 f1 ≤ 0，则生成 [f1, 0] 范围内的随机数
+      - 指定两个参数 f1 和 f2：生成 [f1, f2] 范围内的随机数（顺序无关，内部会自动处理大小）
+
+返回结果将以骰子样式的图像形式展示生成的随机数值。

konabot/docs/user/雷达回波.txt

@@ -0,0 +1,13 @@
+指令介绍
+    雷达回波 - 用于获取指定地区的天气雷达回波图像
+
+格式
+    雷达回波 <地区>
+
+示例
+    `雷达回波 华南` 获取华南地区的天气雷达回波图
+    `雷达回波 全国` 获取全国的天气雷达回波图
+
+说明
+    该指令通过查询中国气象局 https://www.nmc.cn/publish/radar/chinaall.html ，获取指定地区的实时天气雷达回波图像。
+    支持的地区有：全国 华北 东北 华东 华中 华南 西南 西北。

konabot/plugins/man/__init__.py

@@ -0,0 +1,104 @@
+from curses.ascii import isdigit
+from pathlib import Path
+
+import nonebot
+import nonebot.adapters
+import nonebot.adapters.discord
+import nonebot.rule
+from nonebot import on_command
+from nonebot_plugin_alconna import Alconna, Args, UniMessage, on_alconna
+
+from konabot.common.nb.is_admin import is_admin
+from konabot.common.path import DOCS_PATH_MAN1, DOCS_PATH_MAN3, DOCS_PATH_MAN7, DOCS_PATH_MAN8
+
+def search_man(section: int) -> dict[tuple[int, str], Path]:
+    base_path = {
+        1: DOCS_PATH_MAN1,
+        3: DOCS_PATH_MAN3,
+        7: DOCS_PATH_MAN7,
+        8: DOCS_PATH_MAN8,
+    }.get(section, DOCS_PATH_MAN1)
+
+    res: dict[tuple[int, str], Path] = {}
+    for fp in base_path.iterdir():
+        if fp.suffix != '.txt':
+            continue
+        name = fp.name.lower().removesuffix('.txt')
+        res[(section, name)] = fp
+    return res
+
+
+man = on_alconna(Alconna(
+    'man',
+    Args['section', int | None],
+    Args['doc', str | None],
+))
+
+@man.handle()
+async def _(
+    section: int | None,
+    doc: str | None,
+    event: nonebot.adapters.Event,
+):
+    if doc is not None and section is None and all(isdigit(c) for c in doc):
+        section = int(doc)
+        doc = None
+
+    if section is not None and section not in {1, 3, 7, 8}:
+        await man.send(
+            UniMessage().text(f"你所指定的文档类型 {section} 不在可用范围内")
+        )
+        return
+
+    if doc is None:
+        # 检索模式
+        if section is None:
+            section_set = {1}
+        else:
+            section_set = {section}
+        if 1 in section_set and is_admin(event):
+            section_set.add(8)
+        mans: list[str] = []
+        for section in section_set:
+            mans += [f"{n}({s})" for s, n in search_man(section).keys()]
+        mans.sort()
+        
+        await man.send(UniMessage().text(
+            (
+                "★此方 BOT 使用帮助★\n"
+                "使用 man <指令名> 查询某个指令的名字\n\n"
+                "可供查询的指令清单："
+            )
+            + ", ".join(mans)
+            + "\n\n例如，使用 man man 来查询 man 指令的使用方法"
+        ))
+    else:
+        # 查阅模式
+        if section is None:
+            section_set = {1}
+        else:
+            section_set = {section}
+        if 1 in section_set and is_admin(event):
+            section_set.add(8)
+        if 8 in section_set and not is_admin(event):
+            await man.send(UniMessage().text("你没有查看该指令类型的权限"))
+            return
+        mans_dict: dict[tuple[int, str], Path] = {}
+        for section in section_set:
+            mans_dict: dict[tuple[int, str], Path] = {**mans_dict, **search_man(section)}
+        mans_dict_2 = {key[1]: val for key, val in mans_dict.items()}
+        mans_fp = mans_dict_2.get(doc.lower())
+        if mans_fp is None:
+            await man.send(UniMessage().text("你所检索的指令不存在"))
+            return
+        mans_msg = mans_fp.read_text('utf-8', 'replace')
+        if isinstance(event, nonebot.adapters.discord.event.MessageEvent):
+            mans_msg = f'```\n{mans_msg}\n```'
+        await man.send(UniMessage().text(mans_msg))
+
+
+help_deprecated = on_command('help', rule=nonebot.rule.to_me())
+
+@help_deprecated.handle()
+async def _():
+    await help_deprecated.send('你可以使用 man 指令来查询此方 BOT 的帮助')

konabot/plugins/simple_notify/__init__.py

@@ -4,6 +4,7 @@ from pathlib import Path
 from typing import Any, Literal, cast
 
 import nonebot
+import ptimeparse
 from loguru import logger
 from nonebot import on_message
 from nonebot.adapters import Event
@@ -19,8 +20,6 @@ from nonebot.adapters.onebot.v11.event import \
 from nonebot_plugin_alconna import UniMessage, UniMsg
 from pydantic import BaseModel
 
-from konabot.plugins.simple_notify.parse_time import get_target_time
-
 evt = on_message()
 
 (Path(__file__).parent.parent.parent.parent / "data").mkdir(exist_ok=True)
@@ -141,10 +140,15 @@ async def _(msg: UniMsg, mEvt: Event):
         return
 
     notify_time, notify_text = segments
-    target_time = get_target_time(notify_time)
-    if target_time is None:
+    # target_time = get_target_time(notify_time)
+    try:
+        target_time = ptimeparse.parse(notify_time)
+    except Exception:
         logger.info(f"无法从 {notify_time} 中解析出时间")
         return
+    # if target_time is None:
+    #     logger.info(f"无法从 {notify_time} 中解析出时间")
+    #     return
     if not notify_text:
         return
 

konabot/plugins/simple_notify/parse_time.py

@@ -1,358 +0,0 @@
-import datetime
-import re
-from typing import Optional, Dict, List, Callable, Tuple
-
-from loguru import logger
-
-# --- 常量与正则表达式定义 (Constants and Regex Definitions) ---
-
-# 数字模式，兼容中文和阿拉伯数字
-P_NUM = r"(\d+|[零一两二三四五六七八九十]+)"
-
-# 预编译的正则表达式
-PATTERNS = {
-    # 相对时间, e.g., "5分钟后"
-    "DELTA": re.compile(
-        r"^"
-        r"((?P<days>" + P_NUM + r") ?天)?"
-        r"((?P<hours>" + P_NUM + r") ?个?小?时)?"
-        r"((?P<minutes>" + P_NUM + r") ?分钟?)?"
-        r"((?P<seconds>" + P_NUM + r") ?秒钟?)?"
-        r" ?后 ?$"
-    ),
-    # 绝对时间
-    "YEAR": re.compile(r"(" + P_NUM + r") ?年"),
-    "MONTH": re.compile(r"(" + P_NUM + r") ?月"),
-    "DAY": re.compile(r"(" + P_NUM + r") ?[日号]"),
-    "HOUR": re.compile(r"(" + P_NUM + r") ?[点时](半)?钟?"),
-    "MINUTE": re.compile(r"(" + P_NUM + r") ?分(钟)?"),
-    "SECOND": re.compile(r"(" + P_NUM + r") ?秒(钟)?"),
-    "HMS_COLON": re.compile(r"(\d{1,2})[:：](\d{1,2})([:：](\d{1,2}))?"),
-    "PM": re.compile(r"(下午|PM|晚上)"),
-    # 相对日期
-    "TOMORROW": re.compile(r"明天"),
-    "DAY_AFTER_TOMORROW": re.compile(r"后天"),
-    "TODAY": re.compile(r"今天"),
-}
-
-# 中文数字到阿拉伯数字的映射
-CHINESE_TO_ARABIC_MAP: Dict[str, int] = {
-    '零': 0, '一': 1, '二': 2, '三': 3, '四': 4,
-    '五': 5, '六': 6, '七': 7, '八': 8, '九': 9, '十': 10
-}
-
-# --- 核心工具函数 (Core Utility Functions) ---
-
-def parse_number(s: str) -> int:
-    """
-    将包含中文或阿拉伯数字的字符串解析为整数。
-    例如: "五" -> 5, "十五" -> 15, "二十三" -> 23, "12" -> 12。
-    返回 -1 表示解析失败。
-    """
-    if not s:
-        return -1
-        
-    s = s.strip().replace("两", "二")
-
-    if s.isdigit():
-        return int(s)
-
-    if s in CHINESE_TO_ARABIC_MAP:
-        return CHINESE_TO_ARABIC_MAP[s]
-
-    # 处理 "十" 在不同位置的情况
-    if s.startswith('十'):
-        if len(s) == 1:
-            return 10
-        num = CHINESE_TO_ARABIC_MAP.get(s[1])
-        return 10 + num if num is not None else -1
-    
-    if s.endswith('十'):
-        if len(s) == 2:
-            num = CHINESE_TO_ARABIC_MAP.get(s[0])
-            return 10 * num if num is not None else -1
-
-    if '十' in s:
-        parts = s.split('十')
-        if len(parts) == 2:
-            left = CHINESE_TO_ARABIC_MAP.get(parts[0])
-            right = CHINESE_TO_ARABIC_MAP.get(parts[1])
-            if left is not None and right is not None:
-                return left * 10 + right
-    
-    return -1
-
-
-# --- 时间解析器类 (Time Parser Class) ---
-
-class TimeParser:
-    """
-    一个用于解析自然语言时间描述的类。
-    """
-    def __init__(self, content: str):
-        self.original_content: str = content
-        self.content_to_parse: str = self._preprocess(content)
-        self.now: datetime.datetime = datetime.datetime.now()
-        # 将 t 作为结果构建器，初始化为今天的午夜
-        self.t: datetime.datetime = self.now.replace(hour=0, minute=0, second=0, microsecond=0)
-        self.is_pm_specified: bool = False
-        self.is_date_specified: bool = False
-        self.is_time_specified: bool = False
-
-    def _preprocess(self, content: str) -> str:
-        """预处理字符串，移除不相关字符。"""
-        content = re.sub(r"\s+", "", content)
-        content = re.sub(r"[,，\.。:：、]", "", content)
-        return content
-
-    def _consume_match(self, match: re.Match) -> str:
-        """从待解析字符串中移除已匹配的部分。"""
-        self.content_to_parse = self.content_to_parse.replace(match.group(0), "", 1)
-        return match.group(0)
-
-    def parse(self) -> Optional[datetime.datetime]:
-        """
-        主解析方法。
-        首先尝试解析相对时间（如“5分钟后”），失败则尝试解析绝对时间。
-        """
-        logger.debug(f"🎉 开始解析: '{self.original_content}' -> 清洗后: '{self.content_to_parse}'")
-        if not self.content_to_parse:
-            logger.debug("❌ 内容为空，无法解析。")
-            return None
-
-        # 1. 尝试相对时间解析
-        if (target_time := self._parse_relative_time()) is not None:
-            return target_time
-
-        # 2. 尝试绝对时间解析
-        if (target_time := self._parse_absolute_time()) is not None:
-            return target_time
-
-        logger.debug(f"❌ 所有解析模式均未匹配成功。")
-        return None
-
-    def _parse_relative_time(self) -> Optional[datetime.datetime]:
-        """解析 'X天X小时X分钟后' 这种格式。"""
-        if match := PATTERNS["DELTA"].match(self.content_to_parse):
-            logger.debug("⏳ 匹配到相对时间模式 (DELTA)。")
-            try:
-                delta_parts = {
-                    "days": parse_number(match.group("days") or "0"),
-                    "hours": parse_number(match.group("hours") or "0"),
-                    "minutes": parse_number(match.group("minutes") or "0"),
-                    "seconds": parse_number(match.group("seconds") or "0"),
-                }
-                
-                # 检查是否有无效的数字解析
-                if any(v < 0 for v in delta_parts.values()):
-                    logger.debug(f"❌ 解析时间片段为数字时失败: {delta_parts}")
-                    return None
-                
-                delta = datetime.timedelta(**delta_parts)
-                if delta.total_seconds() == 0:
-                    logger.debug("❌ 解析出的时间增量为0。")
-                    return None
-
-                target_time = self.now + delta
-                logger.debug(f"✅ 相对时间解析成功 -> {target_time}")
-                return target_time
-            except (ValueError, TypeError) as e:
-                logger.debug(f"❌ 解析相对时间时出错: {e}", exc_info=True)
-                return None
-        return None
-
-    def _parse_absolute_time(self) -> Optional[datetime.datetime]:
-        """解析一个指定的日期和时间。"""
-        logger.debug(f"🎯 启动绝对时间解析，基准时间: {self.t}")
-        
-        # 定义解析步骤和顺序
-        # (pattern_key, handler_method)
-        parsing_steps: List[Tuple[str, Callable[[re.Match], bool]]] = [
-            ("TOMORROW", self._handle_tomorrow),
-            ("DAY_AFTER_TOMORROW", self._handle_day_after_tomorrow),
-            ("TODAY", self._handle_today),
-            ("YEAR", self._handle_year),
-            ("MONTH", self._handle_month),
-            ("DAY", self._handle_day),
-            ("HMS_COLON", self._handle_hms_colon),
-            ("PM", self._handle_pm),
-            ("HOUR", self._handle_hour),
-            ("MINUTE", self._handle_minute),
-            ("SECOND", self._handle_second),
-        ]
-
-        for key, handler in parsing_steps:
-            if match := PATTERNS[key].search(self.content_to_parse):
-                if not handler(match):
-                    # 如果任何一个处理器返回False，说明解析失败
-                    return None
-        
-        # 移除无意义的上午关键词
-        self.content_to_parse = self.content_to_parse.replace("上午", "").replace("AM", "").replace("凌晨", "")
-
-        # 如果解析后还有剩余字符，说明有无法识别的部分
-        if self.content_to_parse.strip():
-            logger.debug(f"❌ 匹配失败，存在未解析的残留内容: '{self.content_to_parse.strip()}'")
-            return None
-            
-        # 最终调整和检查
-        return self._finalize_datetime()
-
-    # --- Handler Methods for Absolute Time Parsing ---
-
-    def _handle_tomorrow(self, match: re.Match) -> bool:
-        self.t += datetime.timedelta(days=1)
-        self.is_date_specified = True
-        logger.debug(f"📅 匹配到 '明天' -> {self.t.date()}, 消耗: '{self._consume_match(match)}'")
-        return True
-
-    def _handle_day_after_tomorrow(self, match: re.Match) -> bool:
-        self.t += datetime.timedelta(days=2)
-        self.is_date_specified = True
-        logger.debug(f"📅 匹配到 '后天' -> {self.t.date()}, 消耗: '{self._consume_match(match)}'")
-        return True
-
-    def _handle_today(self, match: re.Match) -> bool:
-        self.is_date_specified = True
-        logger.debug(f"📅 匹配到 '今天', 日期基准不变, 消耗: '{self._consume_match(match)}'")
-        return True
-
-    def _handle_year(self, match: re.Match) -> bool:
-        year = parse_number(match.group(1))
-        if year < 0: return False
-        if year < 100: year += 2000 # 处理 "25年" -> 2025
-        if year < self.now.year:
-            logger.debug(f"❌ 指定的年份 {year} 已过去。")
-            return False
-        self.t = self.t.replace(year=year)
-        self.is_date_specified = True
-        logger.debug(f"Y| 年份更新 -> {self.t.year}, 消耗: '{self._consume_match(match)}'")
-        return True
-
-    def _handle_month(self, match: re.Match) -> bool:
-        month = parse_number(match.group(1))
-        if not (1 <= month <= 12):
-            logger.debug(f"❌ 无效的月份: {month}")
-            return False
-        
-        # 如果设置的月份在当前月份之前，且没有指定年份，则年份加一
-        if month < self.t.month and not self.is_date_specified:
-            self.t = self.t.replace(year=self.t.year + 1)
-            logger.debug(f"💡 月份小于当前月份，年份自动进位 -> {self.t.year}")
-
-        self.t = self.t.replace(month=month)
-        self.is_date_specified = True
-        logger.debug(f"M| 月份更新 -> {self.t.month}, 消耗: '{self._consume_match(match)}'")
-        return True
-
-    def _handle_day(self, match: re.Match) -> bool:
-        day = parse_number(match.group(1))
-        if not (1 <= day <= 31):
-            logger.debug(f"❌ 无效的日期: {day}")
-            return False
-        
-        try:
-            # 如果日期小于当前日期，且只指定了日，则月份加一
-            if day < self.t.day and not self.is_date_specified:
-                if self.t.month == 12:
-                    self.t = self.t.replace(year=self.t.year + 1, month=1)
-                else:
-                    self.t = self.t.replace(month=self.t.month + 1)
-                logger.debug(f"💡 日期小于当前日期，月份自动进位 -> {self.t.year}-{self.t.month}")
-            
-            self.t = self.t.replace(day=day)
-            self.is_date_specified = True
-            logger.debug(f"D| 日期更新 -> {self.t.day}, 消耗: '{self._consume_match(match)}'")
-            return True
-        except ValueError:
-            logger.debug(f"❌ 日期 {day} 对于月份 {self.t.month} 无效 (例如2月30号)。")
-            return False
-
-    def _handle_hms_colon(self, match: re.Match) -> bool:
-        h = int(match.group(1))
-        m = int(match.group(2))
-        s_str = match.group(4) # group(3) is with colon, group(4) is the number
-        s = int(s_str) if s_str else 0
-        if not (0 <= h <= 23 and 0 <= m <= 59 and 0 <= s <= 59):
-            logger.debug(f"❌ 无效的时间格式: H={h}, M={m}, S={s}")
-            return False
-        self.t = self.t.replace(hour=h, minute=m, second=s)
-        self.is_time_specified = True
-        logger.debug(f"T| 时分秒(冒号格式)更新 -> {self.t.time()}, 消耗: '{self._consume_match(match)}'")
-        return True
-
-    def _handle_pm(self, match: re.Match) -> bool:
-        self.is_pm_specified = True
-        logger.debug(f"PM| 匹配到下午/晚上, 消耗: '{self._consume_match(match)}'")
-        return True
-
-    def _handle_hour(self, match: re.Match) -> bool:
-        hour = parse_number(match.group(1))
-        has_half = match.group(2) == '半'
-        if not (0 <= hour <= 23):
-            logger.debug(f"❌ 无效的小时: {hour}")
-            return False
-        minute = 30 if has_half else self.t.minute
-        self.t = self.t.replace(hour=hour, minute=minute)
-        self.is_time_specified = True
-        logger.debug(f"H| 小时更新 -> {self.t.hour}{':30' if has_half else ''}, 消耗: '{self._consume_match(match)}'")
-        return True
-
-    def _handle_minute(self, match: re.Match) -> bool:
-        minute = parse_number(match.group(1))
-        if not (0 <= minute <= 59):
-            logger.debug(f"❌ 无效的分钟: {minute}")
-            return False
-        self.t = self.t.replace(minute=minute)
-        self.is_time_specified = True
-        logger.debug(f"M| 分钟更新 -> {self.t.minute}, 消耗: '{self._consume_match(match)}'")
-        return True
-
-    def _handle_second(self, match: re.Match) -> bool:
-        second = parse_number(match.group(1))
-        if not (0 <= second <= 59):
-            logger.debug(f"❌ 无效的秒: {second}")
-            return False
-        self.t = self.t.replace(second=second)
-        self.is_time_specified = True
-        logger.debug(f"S| 秒更新 -> {self.t.second}, 消耗: '{self._consume_match(match)}'")
-        return True
-
-    def _finalize_datetime(self) -> Optional[datetime.datetime]:
-        """对解析出的时间进行最后的调整和检查。"""
-        # 处理下午/晚上
-        if self.is_pm_specified and self.t.hour < 12:
-            self.t = self.t.replace(hour=self.t.hour + 12)
-            logger.debug(f"💡 根据 PM 标识，小时调整为 -> {self.t.hour}")
-
-        # 如果没有指定任何时间或日期部分，则认为解析无效
-        if not self.is_date_specified and not self.is_time_specified:
-            logger.debug("❌ 未能从输入中解析出任何有效的日期或时间部分。")
-            return None
-
-        # 如果最终计算出的时间点在当前时间之前，自动往后推
-        # 例如：现在是 15:00，说 "14点"，应该是指明天的14点
-        if self.t < self.now:
-            # 只有在明确指定了时间的情况下，才自动加一天
-            # 如果只指定了一个过去的日期（如“去年5月1号”），则不应该调整
-            if self.is_time_specified:
-                self.t += datetime.timedelta(days=1)
-                logger.debug(f"🔁 目标时间已过，自动调整为明天 -> {self.t}")
-        
-        logger.debug(f"✅ 解析成功，最终时间: {self.t}")
-        return self.t
-
-# --- 公共接口 (Public Interface) ---
-
-def get_target_time(content: str) -> Optional[datetime.datetime]:
-    """
-    高级接口，用于将自然语言时间描述转换为 datetime 对象。
-
-    Args:
-        content: 包含时间信息的字符串。
-
-    Returns:
-        一个 datetime 对象，如果解析失败则返回 None。
-    """
-    parser = TimeParser(content)
-    return parser.parse()

konabot/plugins/ytpgif/__init__.py

@@ -1,9 +1,9 @@
-import os
-import tempfile
+from io import BytesIO
 from typing import Optional
 
-from PIL import Image, ImageSequence
+from PIL import Image
 from nonebot.adapters import Event as BaseEvent
+from nonebot.adapters import Bot as BaseBot
 from nonebot.plugin import PluginMetadata
 from nonebot_plugin_alconna import (
     Alconna,
@@ -12,6 +12,9 @@ from nonebot_plugin_alconna import (
     UniMessage,
     on_alconna,
 )
+from returns.result import Failure, Success
+
+from konabot.common.nb.extract_image import extract_image_from_message
 
 __plugin_meta__ = PluginMetadata(
     name="ytpgif",
@@ -60,7 +63,7 @@ async def get_image_url(event: BaseEvent) -> Optional[str]:
         if seg.type == "image" and seg.data.get("url"):
             return str(seg.data["url"])
 
-    if hasattr(event, "reply") and (reply := event.reply):
+    if hasattr(event, "reply") and (reply := getattr(event, "reply")):
         reply_msg = reply.message
         for seg in reply_msg:
             if seg.type == "image" and seg.data.get("url"):
@@ -89,7 +92,7 @@ def resize_frame(frame: Image.Image) -> Image.Image:
 
 
 @ytpgif_cmd.handle()
-async def handle_ytpgif(event: BaseEvent, speed: float = 1.0):
+async def handle_ytpgif(event: BaseEvent, bot: BaseBot, speed: float = 1.0):
     # === 校验 speed 范围 ===
     if not (MIN_SPEED <= speed <= MAX_SPEED):
         await ytpgif_cmd.send(
@@ -97,172 +100,148 @@ async def handle_ytpgif(event: BaseEvent, speed: float = 1.0):
         )
         return
 
-    img_url = await get_image_url(event)
-    if not img_url:
-        await ytpgif_cmd.send(
-            await UniMessage.text(
-                "请发送一张图片或回复一张图片来生成镜像动图。"
-            ).export()
-        )
-        return
+    match await extract_image_from_message(event.get_message(), event, bot):
+        case Success(img):
+            src_img = img
+
+        case Failure(msg):
+            await ytpgif_cmd.send(
+                await UniMessage.text(msg).export()
+            )
+            return
+
+        case _:
+            return
 
     try:
-        image_data = await download_image(img_url)
-    except Exception as e:
-        print(f"[YTPGIF] 下载失败: {e}")
-        await ytpgif_cmd.send(
-            await UniMessage.text("❌ 图片下载失败，请重试。").export()
-        )
-        return
+        try:
+            n_frames = getattr(src_img, "n_frames", 1)
+            is_animated = n_frames > 1
+        except Exception:
+            is_animated = False
+        n_frames = 1
 
-    input_path = output_path = None
-    try:
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".gif") as tmp_in:
-            tmp_in.write(image_data)
-            input_path = tmp_in.name
+        output_frames = []
+        output_durations_ms = []
 
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".gif") as tmp_out:
-            output_path = tmp_out.name
+        if is_animated:
+            # === 动图模式：截取正向 + 镜像两段 ===
+            frames_with_duration = []
+            palette = src_img.getpalette()
 
-        with Image.open(input_path) as src_img:
-            # === 判断是否为动图 ===
-            try:
-                n_frames = getattr(src_img, "n_frames", 1)
-                is_animated = n_frames > 1
-            except Exception:
-                is_animated = False
+            for idx in range(n_frames):
+                src_img.seek(idx)
+                frame = src_img.copy()
+                # 检查是否需要透明通道
+                has_alpha = (
+                    frame.mode in ("RGBA", "LA")
+                    or (frame.mode == "P" and "transparency" in frame.info)
+                )
+                if has_alpha:
+                    frame = frame.convert("RGBA")
+                else:
+                    frame = frame.convert("RGB")
+                resized_frame = resize_frame(frame)
 
-            output_frames = []
-            output_durations_ms = []
+                # 若原图有调色板，尝试保留（可选）
+                if palette and resized_frame.mode == "P":
+                    try:
+                        resized_frame.putpalette(palette)
+                    except Exception:  # noqa
+                        pass
 
-            if is_animated:
-                # === 动图模式：截取正向 + 镜像两段 ===
-                frames_with_duration = []
-                palette = src_img.getpalette()
+                ms = frame.info.get("duration", int(BASE_SEGMENT_DURATION * 1000))
+                dur_sec = max(0.01, ms / 1000.0)
+                frames_with_duration.append((resized_frame, dur_sec))
 
-                for idx in range(n_frames):
-                    src_img.seek(idx)
-                    frame = src_img.copy()
-                    # 检查是否需要透明通道
-                    has_alpha = (
-                        frame.mode in ("RGBA", "LA")
-                        or (frame.mode == "P" and "transparency" in frame.info)
-                    )
-                    if has_alpha:
-                        frame = frame.convert("RGBA")
-                    else:
-                        frame = frame.convert("RGB")
-                    resized_frame = resize_frame(frame)
+            max_dur = BASE_SEGMENT_DURATION * speed
+            accumulated = 0.0
+            frame_count = 0
 
-                    # 若原图有调色板，尝试保留（可选）
-                    if palette and resized_frame.mode == "P":
-                        try:
-                            resized_frame.putpalette(palette)
-                        except Exception:  # noqa
-                            pass
+            # 正向段
+            for img, dur in frames_with_duration:
+                if accumulated + dur > max_dur or frame_count >= MAX_FRAMES_PER_SEGMENT:
+                    break
+                output_frames.append(img)
+                output_durations_ms.append(int(dur * 1000))
+                accumulated += dur
+                frame_count += 1
 
-                    ms = frame.info.get("duration", int(BASE_SEGMENT_DURATION * 1000))
-                    dur_sec = max(0.01, ms / 1000.0)
-                    frames_with_duration.append((resized_frame, dur_sec))
-
-                max_dur = BASE_SEGMENT_DURATION * speed
-                accumulated = 0.0
-                frame_count = 0
-
-                # 正向段
-                for img, dur in frames_with_duration:
-                    if accumulated + dur > max_dur or frame_count >= MAX_FRAMES_PER_SEGMENT:
-                        break
-                    output_frames.append(img)
-                    output_durations_ms.append(int(dur * 1000))
-                    accumulated += dur
-                    frame_count += 1
-
-                if frame_count == 0:
-                    await ytpgif_cmd.send(
-                        await UniMessage.text("动图帧太短，无法生成有效片段。").export()
-                    )
-                    return
-
-                # 镜像段（从头开始）
-                accumulated = 0.0
-                frame_count = 0
-                for img, dur in frames_with_duration:
-                    if accumulated + dur > max_dur or frame_count >= MAX_FRAMES_PER_SEGMENT:
-                        break
-                    flipped = img.transpose(Image.FLIP_LEFT_RIGHT)
-                    output_frames.append(flipped)
-                    output_durations_ms.append(int(dur * 1000))
-                    accumulated += dur
-                    frame_count += 1
-
-            else:
-                # === 静态图模式：制作翻转动画 ===
-                raw_frame = src_img.convert("RGBA")
-                resized_frame = resize_frame(raw_frame)
-
-                interval_sec = max(0.025, min(2.5, BASE_INTERVAL / speed))
-                duration_ms = int(interval_sec * 1000)
-
-                frame1 = resized_frame
-                frame2 = resized_frame.transpose(Image.FLIP_LEFT_RIGHT)
-
-                output_frames = [frame1, frame2]
-                output_durations_ms = [duration_ms, duration_ms]
-
-            if len(output_frames) < 1:
+            if frame_count == 0:
                 await ytpgif_cmd.send(
-                    await UniMessage.text("未能生成任何帧。").export()
+                    await UniMessage.text("动图帧太短，无法生成有效片段。").export()
                 )
                 return
 
-            # === 🔐 关键修复：防止无透明图的颜色被当成透明 ===
-            need_transparency = False
-            for frame in output_frames:
-                if frame.mode == "RGBA":
-                    alpha_channel = frame.getchannel("A")
-                    if any(pix < 255 for pix in alpha_channel.getdata()):
-                        need_transparency = True
-                        break
-                elif frame.mode == "P" and "transparency" in frame.info:
+            # 镜像段（从头开始）
+            accumulated = 0.0
+            frame_count = 0
+            for img, dur in frames_with_duration:
+                if accumulated + dur > max_dur or frame_count >= MAX_FRAMES_PER_SEGMENT:
+                    break
+                flipped = img.transpose(Image.Transpose.FLIP_LEFT_RIGHT)
+                output_frames.append(flipped)
+                output_durations_ms.append(int(dur * 1000))
+                accumulated += dur
+                frame_count += 1
+
+        else:
+            # === 静态图模式：制作翻转动画 ===
+            raw_frame = src_img.convert("RGBA")
+            resized_frame = resize_frame(raw_frame)
+
+            interval_sec = max(0.025, min(2.5, BASE_INTERVAL / speed))
+            duration_ms = int(interval_sec * 1000)
+
+            frame1 = resized_frame
+            frame2 = resized_frame.transpose(Image.Transpose.FLIP_LEFT_RIGHT)
+
+            output_frames = [frame1, frame2]
+            output_durations_ms = [duration_ms, duration_ms]
+
+        if len(output_frames) < 1:
+            await ytpgif_cmd.send(
+                await UniMessage.text("未能生成任何帧。").export()
+            )
+            return
+
+        # === 🔐 关键修复：防止无透明图的颜色被当成透明 ===
+        need_transparency = False
+        for frame in output_frames:
+            if frame.mode == "RGBA":
+                alpha_channel = frame.getchannel("A")
+                if any(pix < 255 for pix in alpha_channel.getdata()):
                     need_transparency = True
                     break
+            elif frame.mode == "P" and "transparency" in frame.info:
+                need_transparency = True
+                break
 
-            # 如果不需要透明，则统一转为 RGB 避免调色板污染
-            if not need_transparency:
-                output_frames = [f.convert("RGB") for f in output_frames]
+        # 如果不需要透明，则统一转为 RGB 避免调色板污染
+        if not need_transparency:
+            output_frames = [f.convert("RGB") for f in output_frames]
 
-            # 构建保存参数
-            save_kwargs = {
-                "save_all": True,
-                "append_images": output_frames[1:],
-                "format": "GIF",
-                "loop": 0,           # 无限循环
-                "duration": output_durations_ms,
-                "disposal": 2,       # 清除到背景色，避免残留
-                "optimize": False,   # 关闭抖动（等效 -dither none）
-            }
+        # 构建保存参数
+        save_kwargs = {
+            "save_all": True,
+            "append_images": output_frames[1:],
+            "format": "GIF",
+            "loop": 0,           # 无限循环
+            "duration": output_durations_ms,
+            "disposal": 2,       # 清除到背景色，避免残留
+            "optimize": False,   # 关闭抖动（等效 -dither none）
+        }
 
-            # 只有真正需要透明时才启用 transparency
-            if need_transparency:
-                save_kwargs["transparency"] = 0
+        # 只有真正需要透明时才启用 transparency
+        if need_transparency:
+            save_kwargs["transparency"] = 0
 
-            output_frames[0].save(output_path, **save_kwargs)
-
-        # 发送结果
-        with open(output_path, "rb") as f:
-            result_image = UniMessage.image(raw=f.read())
+        bio = BytesIO()
+        output_frames[0].save(bio, **save_kwargs)
+        result_image = UniMessage.image(raw=bio)
         await ytpgif_cmd.send(await result_image.export())
-
     except Exception as e:
         print(f"[YTPGIF] 处理失败: {e}")
         await ytpgif_cmd.send(
             await UniMessage.text("❌ 处理失败，可能是图片格式不支持、文件损坏或过大。").export()
-        )
-    finally:
-        for path in filter(None, [input_path, output_path]):
-            if os.path.exists(path):
-                try:
-                    os.unlink(path)
-                except:  # noqa
-                    pass
+        )

poetry.lock

@@ -2062,6 +2062,23 @@ files = [
     {file = "propcache-0.3.2.tar.gz", hash = "sha256:20d7d62e4e7ef05f221e0db2856b979540686342e7dd9973b815599c7057e168"},
 ]
 
+[[package]]
+name = "ptimeparse"
+version = "0.1.2"
+description = "一个用于解析中文的时间表达的库"
+optional = false
+python-versions = ">=3.9"
+groups = ["main"]
+files = [
+    {file = "ptimeparse-0.1.2-py3-none-any.whl", hash = "sha256:0eea791396e53b63330fadb40d9f0a2e6272bd5467246f10d1d6971bc606edff"},
+    {file = "ptimeparse-0.1.2.tar.gz", hash = "sha256:658be90a3cc2994c09c4ea2f276d257e7eb84bc330be79950baefe32b19779a2"},
+]
+
+[package.source]
+type = "legacy"
+url = "https://gitea.service.jazzwhom.top/api/packages/Passthem/pypi/simple"
+reference = "pt-gitea-pypi"
+
 [[package]]
 name = "pycares"
 version = "4.11.0"
@@ -3181,4 +3198,4 @@ type = ["pytest-mypy"]
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.12,<4.0"
-content-hash = "927913b9030d1f6c126bb2d12eab7307dc6297f259c7c62e3033706457d27ce0"
+content-hash = "b4c3d28f7572c57e867d126ce0c64787ae608b114e66b8de06147caf13e049dd"

pyproject.toml

@@ -22,9 +22,17 @@ dependencies = [
     "imagetext-py (>=2.2.0,<3.0.0)",
     "opencv-python-headless (>=4.12.0.88,<5.0.0.0)",
     "returns (>=0.26.0,<0.27.0)",
+    "ptimeparse (>=0.1.1,<0.2.0)",
 ]
 
-
 [build-system]
 requires = ["poetry-core>=2.0.0,<3.0.0"]
 build-backend = "poetry.core.masonry.api"
+
+[[tool.poetry.source]]
+name = "pt-gitea-pypi"
+url = "https://gitea.service.jazzwhom.top/api/packages/Passthem/pypi/simple/"
+priority = "supplemental"
+
+[tool.poetry.dependencies]
+ptimeparse = {source = "pt-gitea-pypi"}

requirements.txt

@@ -1,84 +0,0 @@
-aio-mc-rcon==3.4.1 ; python_version >= "3.12" and python_version < "4.0"
-aiodns==3.5.0 ; python_version >= "3.12" and python_version < "4.0"
-aiohappyeyeballs==2.6.1 ; python_version >= "3.12" and python_version < "4.0"
-aiohttp==3.12.15 ; python_version >= "3.12" and python_version < "4.0"
-aiosignal==1.4.0 ; python_version >= "3.12" and python_version < "4.0"
-annotated-types==0.7.0 ; python_version >= "3.12" and python_version < "4.0"
-anyio==4.11.0 ; python_version >= "3.12" and python_version < "4.0"
-apscheduler==3.11.0 ; python_version >= "3.12" and python_version < "4.0"
-arclet-alconna-tools==0.7.11 ; python_version >= "3.12" and python_version < "4.0"
-arclet-alconna==1.8.40 ; python_version >= "3.12" and python_version < "4.0"
-attrs==25.3.0 ; python_version >= "3.12" and python_version < "4.0"
-beautifulsoup4==4.13.5 ; python_version >= "3.12" and python_version < "4.0"
-brotli==1.1.0 ; python_version >= "3.12" and python_version < "4.0" and platform_python_implementation == "CPython"
-brotlicffi==1.1.0.0 ; python_version >= "3.12" and python_version < "4.0" and platform_python_implementation != "CPython"
-certifi==2025.8.3 ; python_version >= "3.12" and python_version < "4.0"
-cffi==2.0.0 ; python_version >= "3.12" and python_version < "4.0"
-charset-normalizer==3.4.3 ; python_version >= "3.12" and python_version < "4.0"
-click==8.3.0 ; python_version >= "3.12" and python_version < "4.0"
-colorama==0.4.6 ; python_version >= "3.12" and python_version < "4.0" and (sys_platform == "win32" or platform_system == "Windows")
-exceptiongroup==1.3.0 ; python_version >= "3.12" and python_version < "4.0"
-fastapi==0.117.1 ; python_version >= "3.12" and python_version < "4.0"
-frozenlist==1.7.0 ; python_version >= "3.12" and python_version < "4.0"
-h11==0.16.0 ; python_version >= "3.12" and python_version < "4.0"
-h2==4.3.0 ; python_version >= "3.12" and python_version < "4.0"
-hpack==4.1.0 ; python_version >= "3.12" and python_version < "4.0"
-httpcore==1.0.9 ; python_version >= "3.12" and python_version < "4.0"
-httptools==0.6.4 ; python_version >= "3.12" and python_version < "4.0"
-httpx==0.28.1 ; python_version >= "3.12" and python_version < "4.0"
-hyperframe==6.1.0 ; python_version >= "3.12" and python_version < "4.0"
-idna==3.10 ; python_version >= "3.12" and python_version < "4.0"
-imagetext-py==2.2.0 ; python_version >= "3.12" and python_version < "4.0"
-importlib-metadata==8.7.0 ; python_version >= "3.12" and python_version < "4.0"
-linkify-it-py==2.0.3 ; python_version >= "3.12" and python_version < "4.0"
-loguru==0.7.3 ; python_version >= "3.12" and python_version < "4.0"
-lxml==6.0.2 ; python_version >= "3.12" and python_version < "4.0"
-markdown-it-py==4.0.0 ; python_version >= "3.12" and python_version < "4.0"
-mdit-py-plugins==0.5.0 ; python_version >= "3.12" and python_version < "4.0"
-mdurl==0.1.2 ; python_version >= "3.12" and python_version < "4.0"
-msgpack==1.1.1 ; python_version >= "3.12" and python_version < "4.0"
-multidict==6.6.4 ; python_version >= "3.12" and python_version < "4.0"
-nepattern==0.7.7 ; python_version >= "3.12" and python_version < "4.0"
-nonebot-adapter-console==0.9.0 ; python_version >= "3.12" and python_version < "4.0"
-nonebot-adapter-discord==0.1.8 ; python_version >= "3.12" and python_version < "4.0"
-nonebot-adapter-minecraft==1.5.2 ; python_version >= "3.12" and python_version < "4.0"
-nonebot-adapter-onebot==2.4.6 ; python_version >= "3.12" and python_version < "4.0"
-nonebot-plugin-alconna==0.59.4 ; python_version >= "3.12" and python_version < "4.0"
-nonebot-plugin-apscheduler==0.5.0 ; python_version >= "3.12" and python_version < "4.0"
-nonebot-plugin-waiter==0.8.1 ; python_version >= "3.12" and python_version < "4.0"
-nonebot2==2.4.3 ; python_version >= "3.12" and python_version < "4.0"
-nonechat==0.6.1 ; python_version >= "3.12" and python_version < "4.0"
-numpy==2.2.6 ; python_version >= "3.12" and python_version < "4.0"
-opencv-python-headless==4.12.0.88 ; python_version >= "3.12" and python_version < "4.0"
-pillow==11.3.0 ; python_version >= "3.12" and python_version < "4.0"
-platformdirs==4.4.0 ; python_version >= "3.12" and python_version < "4.0"
-propcache==0.3.2 ; python_version >= "3.12" and python_version < "4.0"
-pycares==4.11.0 ; python_version >= "3.12" and python_version < "4.0"
-pycparser==2.23 ; python_version >= "3.12" and python_version < "4.0" and implementation_name != "PyPy"
-pydantic-core==2.33.2 ; python_version >= "3.12" and python_version < "4.0"
-pydantic==2.11.9 ; python_version >= "3.12" and python_version < "4.0"
-pygments==2.19.2 ; python_version >= "3.12" and python_version < "4.0"
-pygtrie==2.5.0 ; python_version >= "3.12" and python_version < "4.0"
-python-dotenv==1.1.1 ; python_version >= "3.12" and python_version < "4.0"
-pyyaml==6.0.3 ; python_version >= "3.12" and python_version < "4.0"
-requests==2.32.5 ; python_version >= "3.12" and python_version < "4.0"
-returns==0.26.0 ; python_version >= "3.12" and python_version < "4.0"
-rich==14.1.0 ; python_version >= "3.12" and python_version < "4.0"
-sniffio==1.3.1 ; python_version >= "3.12" and python_version < "4.0"
-soupsieve==2.8 ; python_version >= "3.12" and python_version < "4.0"
-starlette==0.48.0 ; python_version >= "3.12" and python_version < "4.0"
-tarina==0.6.8 ; python_version >= "3.12" and python_version < "4.0"
-textual==3.7.1 ; python_version >= "3.12" and python_version < "4.0"
-typing-extensions==4.15.0 ; python_version >= "3.12" and python_version < "4.0"
-typing-inspection==0.4.1 ; python_version >= "3.12" and python_version < "4.0"
-tzdata==2025.2 ; python_version >= "3.12" and python_version < "4.0" and platform_system == "Windows"
-tzlocal==5.3.1 ; python_version >= "3.12" and python_version < "4.0"
-uc-micro-py==1.0.3 ; python_version >= "3.12" and python_version < "4.0"
-urllib3==2.5.0 ; python_version >= "3.12" and python_version < "4.0"
-uvicorn==0.37.0 ; python_version >= "3.12" and python_version < "4.0"
-uvloop==0.21.0 ; python_version >= "3.12" and python_version < "4.0" and sys_platform != "win32" and sys_platform != "cygwin" and platform_python_implementation != "PyPy"
-watchfiles==1.1.0 ; python_version >= "3.12" and python_version < "4.0"
-websockets==15.0.1 ; python_version >= "3.12" and python_version < "4.0"
-win32-setctime==1.2.0 ; python_version >= "3.12" and python_version < "4.0" and sys_platform == "win32"
-yarl==1.20.1 ; python_version >= "3.12" and python_version < "4.0"
-zipp==3.23.0 ; python_version >= "3.12" and python_version < "4.0"