nonebot-plugin-randpic 2.0.0__tar.gz → 2.0.2__tar.gz

{nonebot_plugin_randpic-2.0.0 → nonebot_plugin_randpic-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nonebot-plugin-randpic
-Version: 2.0.0
+Version: 2.0.2
 Summary: 一个通过指令随机发送你存储的图片的nonebot2插件
 License: MIT
 License-File: LICENSE
@@ -24,6 +24,7 @@ Requires-Dist: nonebot-adapter-onebot (>=2.1.5,<3.0.0)
 Requires-Dist: nonebot-plugin-localstore (>=0.6.0,<0.7.0)
 Requires-Dist: nonebot2[fastapi] (>=2.0.0,<3.0.0)
 Requires-Dist: pillow (>=11.0.0)
+Requires-Dist: rich (>=13.0,<15.0)
 Project-URL: Homepage, https://github.com/HuParry/nonebot-plugin-randpic
 Project-URL: Repository, https://github.com/HuParry/nonebot-plugin-randpic
 Description-Content-Type: text/markdown
@@ -61,13 +62,11 @@ _✨ 一个发送指令就能让你的 bot 发出对应指令的图片的插件
 - 自动压缩超过 1MiB 的图片，群内添加时使用感知哈希检查相似图片。
 - 本地静态图库无需 OSS；可选同步到阿里云 OSS。增删后自动更新网页，网页分页并使用浏览器原生懒加载。
 
-### 2.0.0 升级说明
+### 初始化与数据持久化
 
-2.0.0 重构了图片存储、数据库、指令和网页同步。原有 `.env` 配置项、指令配置 JSON、图片目录和命名规则继续使用。
+首次启动会创建数据库，并扫描配置的图片文件夹，根据实际图片建立索引，发送次数从 0 开始。数据库不存在时也可由图片文件重新建立索引。
 
-首次启动会将旧版 `Pic_of_<指令>` 表和历史引用关系迁移到统一的图片表，保留能对应到现有图片的发送次数和引用关系。旧表保留，迁移前自动备份数据库到 `database/data.pre-v2.db`。之后启动只核对文件变化，不再清空并重建图片记录。
-
-升级前建议完整备份存储目录。若需要回退 1.x，请恢复完整备份；2.0 不会持续更新旧表，不能直接让旧版读取新运行状态。
+之后每次启动都会核对文件变化，并保留已有图片的发送次数、消息引用关系和同步状态。这些运行数据无法仅凭图片内容恢复，因此不要在正常使用期间删除数据库。
 
 实现说明见 [架构与数据一致性](./docs/architecture.md)。
 
@@ -86,7 +85,6 @@ data/randpic/
 │   └── 马哥/
 ├── database/
 │   ├── data.db            # 图片、发送次数、历史消息、待同步任务
-│   ├── data.pre-v2.db     # 从旧版迁移时生成的原始数据库备份
 │   └── ...                # 文件恢复日志、网页上传缓存等内部文件
 └── public/                # 自动生成的本地静态网页与图片副本，请勿手动维护
 ```
@@ -107,7 +105,7 @@ Bot 运行期间请通过指令增删图片，直接修改文件需重启才能
 
 使用 FastAPI 驱动时，Bot 启动后即可通过 `http://<host>:<port>/randpic/` 查看图库，无需配置 OSS。默认每页 100 张图片，可通过 `randpic_web_page_size` 调整。图片使用 `loading="lazy"`，按需加载。
 
-增删图片后本地页面立即重新发布；已打开的网页在可见时每 15 秒检查一次目录版本，发现变化会自动刷新。没有 FastAPI 服务的驱动仍可使用聊天指令和 OSS 同步。
+增删图片后本地页面立即重新发布，浏览器手动刷新即可查看最新内容。没有 FastAPI 服务的驱动仍可使用聊天指令和 OSS 同步。
 
 #### 阿里云 OSS
 
@@ -122,9 +120,9 @@ Bot 运行期间请通过指令增删图片，直接修改文件需重启才能
 
 ![](./docs/static-page.png)
 
-启动、添加和删除后会自动同步；`上传oss` 可手动全量重新发布、重试未完成任务。默认最多 16 个并发请求，终端按节流频率输出独立进度日志，不使用持续占用终端的进度条。
+启动、添加和删除后会自动同步；`上传oss` 可手动全量重新发布、重试未完成任务。默认最多 16 个并发请求，普通终端中以单行动态进度显示完成数、百分比和成功／失败数，最多每秒刷新 5 次；其他插件的默认 NoneBot 日志显示在进度行上方。同步结束后清除动态行，只保留一条结果汇总，错误详情仍单独记录。输出重定向、非交互控制台或已移除 NoneBot 默认日志处理器时仅输出汇总。
 
-失败任务存入数据库，后台约每 30 秒重试，重启后继续处理。OSS 的图片、页面和目录版本依次同步，网络故障期间云端可能暂时落后于本地图。`randpic_oss_no_upload_list` 只影响 OSS，本地网页仍显示所有配置的分类；此前已同步的分类被排除后，其受本插件跟踪的云端对象会清理。未被数据库跟踪的历史对象不保证自动清理。
+失败任务存入数据库，后台约每 30 秒重试，重启后继续处理。OSS 的图片和页面依次同步，网络故障期间云端可能暂时落后于本地图。`randpic_oss_no_upload_list` 只影响 OSS，本地网页仍显示所有配置的分类；此前已同步的分类被排除后，其受本插件跟踪的云端对象会清理。未被数据库跟踪的历史对象不保证自动清理。
 
 ## 💿 安装
 
@@ -194,8 +192,6 @@ Bot 运行期间请通过指令增删图片，直接修改文件需重启才能
 
 上面表示 `capoo` 指令对所有群启用，`马哥` 指令仅在群号 `123456789` 中被禁用。
 
-> 旧版（v1.4.0 及更早）的纯数组格式 `["capoo", "马哥"]` 仍可识别：插件启动时会自动迁移为上述字典格式并回写文件。
-
 在 `.env` 中，例如这样配置（这是例子，不代表你也需要这样配置）：
 ```
 randpic_store_dir_path="data/randpic"
@@ -256,7 +252,7 @@ randpic_oss_no_upload_list=["capoo"]
 #### `启用马哥` 指令
 <img src="./docs/enable.jpg" width="375"  alt="启用马哥"/>
 
-#### 静态页面网页效果（旧版示意图，2.0 支持本地及 OSS）
+#### 静态页面网页示意（支持本地及 OSS）
 <img src="./docs/web_page.png" width="375"  alt="静态页面网页效果"/>
 
 ## 本地开发检查

{nonebot_plugin_randpic-2.0.0 → nonebot_plugin_randpic-2.0.2}/README.md

@@ -31,13 +31,11 @@ _✨ 一个发送指令就能让你的 bot 发出对应指令的图片的插件
 - 自动压缩超过 1MiB 的图片，群内添加时使用感知哈希检查相似图片。
 - 本地静态图库无需 OSS；可选同步到阿里云 OSS。增删后自动更新网页，网页分页并使用浏览器原生懒加载。
 
-### 2.0.0 升级说明
+### 初始化与数据持久化
 
-2.0.0 重构了图片存储、数据库、指令和网页同步。原有 `.env` 配置项、指令配置 JSON、图片目录和命名规则继续使用。
+首次启动会创建数据库，并扫描配置的图片文件夹，根据实际图片建立索引，发送次数从 0 开始。数据库不存在时也可由图片文件重新建立索引。
 
-首次启动会将旧版 `Pic_of_<指令>` 表和历史引用关系迁移到统一的图片表，保留能对应到现有图片的发送次数和引用关系。旧表保留，迁移前自动备份数据库到 `database/data.pre-v2.db`。之后启动只核对文件变化，不再清空并重建图片记录。
-
-升级前建议完整备份存储目录。若需要回退 1.x，请恢复完整备份；2.0 不会持续更新旧表，不能直接让旧版读取新运行状态。
+之后每次启动都会核对文件变化，并保留已有图片的发送次数、消息引用关系和同步状态。这些运行数据无法仅凭图片内容恢复，因此不要在正常使用期间删除数据库。
 
 实现说明见 [架构与数据一致性](./docs/architecture.md)。
 
@@ -56,7 +54,6 @@ data/randpic/
 │   └── 马哥/
 ├── database/
 │   ├── data.db            # 图片、发送次数、历史消息、待同步任务
-│   ├── data.pre-v2.db     # 从旧版迁移时生成的原始数据库备份
 │   └── ...                # 文件恢复日志、网页上传缓存等内部文件
 └── public/                # 自动生成的本地静态网页与图片副本，请勿手动维护
 ```
@@ -77,7 +74,7 @@ Bot 运行期间请通过指令增删图片，直接修改文件需重启才能
 
 使用 FastAPI 驱动时，Bot 启动后即可通过 `http://<host>:<port>/randpic/` 查看图库，无需配置 OSS。默认每页 100 张图片，可通过 `randpic_web_page_size` 调整。图片使用 `loading="lazy"`，按需加载。
 
-增删图片后本地页面立即重新发布；已打开的网页在可见时每 15 秒检查一次目录版本，发现变化会自动刷新。没有 FastAPI 服务的驱动仍可使用聊天指令和 OSS 同步。
+增删图片后本地页面立即重新发布，浏览器手动刷新即可查看最新内容。没有 FastAPI 服务的驱动仍可使用聊天指令和 OSS 同步。
 
 #### 阿里云 OSS
 
@@ -92,9 +89,9 @@ Bot 运行期间请通过指令增删图片，直接修改文件需重启才能
 
 ![](./docs/static-page.png)
 
-启动、添加和删除后会自动同步；`上传oss` 可手动全量重新发布、重试未完成任务。默认最多 16 个并发请求，终端按节流频率输出独立进度日志，不使用持续占用终端的进度条。
+启动、添加和删除后会自动同步；`上传oss` 可手动全量重新发布、重试未完成任务。默认最多 16 个并发请求，普通终端中以单行动态进度显示完成数、百分比和成功／失败数，最多每秒刷新 5 次；其他插件的默认 NoneBot 日志显示在进度行上方。同步结束后清除动态行，只保留一条结果汇总，错误详情仍单独记录。输出重定向、非交互控制台或已移除 NoneBot 默认日志处理器时仅输出汇总。
 
-失败任务存入数据库，后台约每 30 秒重试，重启后继续处理。OSS 的图片、页面和目录版本依次同步，网络故障期间云端可能暂时落后于本地图。`randpic_oss_no_upload_list` 只影响 OSS，本地网页仍显示所有配置的分类；此前已同步的分类被排除后，其受本插件跟踪的云端对象会清理。未被数据库跟踪的历史对象不保证自动清理。
+失败任务存入数据库，后台约每 30 秒重试，重启后继续处理。OSS 的图片和页面依次同步，网络故障期间云端可能暂时落后于本地图。`randpic_oss_no_upload_list` 只影响 OSS，本地网页仍显示所有配置的分类；此前已同步的分类被排除后，其受本插件跟踪的云端对象会清理。未被数据库跟踪的历史对象不保证自动清理。
 
 ## 💿 安装
 
@@ -164,8 +161,6 @@ Bot 运行期间请通过指令增删图片，直接修改文件需重启才能
 
 上面表示 `capoo` 指令对所有群启用，`马哥` 指令仅在群号 `123456789` 中被禁用。
 
-> 旧版（v1.4.0 及更早）的纯数组格式 `["capoo", "马哥"]` 仍可识别：插件启动时会自动迁移为上述字典格式并回写文件。
-
 在 `.env` 中，例如这样配置（这是例子，不代表你也需要这样配置）：
 ```
 randpic_store_dir_path="data/randpic"
@@ -226,7 +221,7 @@ randpic_oss_no_upload_list=["capoo"]
 #### `启用马哥` 指令
 <img src="./docs/enable.jpg" width="375"  alt="启用马哥"/>
 
-#### 静态页面网页效果（旧版示意图，2.0 支持本地及 OSS）
+#### 静态页面网页示意（支持本地及 OSS）
 <img src="./docs/web_page.png" width="375"  alt="静态页面网页效果"/>
 
 ## 本地开发检查

{nonebot_plugin_randpic-2.0.0 → nonebot_plugin_randpic-2.0.2}/nonebot_plugin_randpic/ali_oss.py

@@ -44,7 +44,7 @@ class OSSUploaderV2:
             result = await asyncio.wait_for(self.client.put_object(oss.PutObjectRequest(
                 bucket=self.bucket, key=oss_key, body=data,
                 content_type=mimetypes.guess_type(oss_key)[0] or 'application/octet-stream',
-                cache_control='no-cache' if oss_key.endswith(('.html', '.json')) else 'public, max-age=31536000, immutable',
+                cache_control='no-cache' if oss_key.endswith('.html') else 'public, max-age=31536000, immutable',
             )), timeout=60)
             if 200 <= result.status_code < 300:
                 return True

{nonebot_plugin_randpic-2.0.0 → nonebot_plugin_randpic-2.0.2}/nonebot_plugin_randpic/compress.py

@@ -136,26 +136,3 @@ def process_image(data: bytes, max_bytes: int = MAX_BYTES, target_quality: int =
     except Exception as exc:
         raise InvalidImage('图片损坏、像素过大或格式无法处理。') from exc
     return ProcessedImage(data, extension, hashlib.sha256(data).hexdigest(), phash, original_hash)
-
-
-# 保留常用图片工具入口，便于既有调用迁移。
-def compress_image_from_bytes(image_bytes: bytes, log_progress: bool = True) -> bytes:
-    return process_image(image_bytes).data
-
-
-def adaptive_compress_bytes(image_bytes: bytes, max_size_mb: float = 1, target_quality: int = 85) -> bytes:
-    if max_size_mb <= 0:
-        raise ValueError('目标大小必须大于 0。')
-    return process_image(image_bytes, int(max_size_mb * MAX_BYTES), target_quality).data
-
-
-def get_image_extension(image_bytes: bytes) -> str:
-    try:
-        with _open(image_bytes) as image:
-            return FORMATS[image.format]
-    except Exception as exc:
-        raise InvalidImage('无法识别图片格式。') from exc
-
-
-def compute_phash(image_bytes: bytes) -> str:
-    return process_image(image_bytes).phash

{nonebot_plugin_randpic-2.0.0 → nonebot_plugin_randpic-2.0.2}/nonebot_plugin_randpic/config.py

@@ -1,4 +1,4 @@
-"""插件设置与向后兼容的指令配置文件。"""
+"""插件设置与指令配置文件。"""
 
 import json
 from pathlib import Path
@@ -34,7 +34,7 @@ class Config(BaseModel):
 
 
 class CommandSettings:
-    """保留旧版 list[str] 和 dict[str, list[int]] 格式；损坏的文件绝不覆盖。"""
+    """读取 dict[str, list[int]] 格式的指令设置；损坏的文件绝不覆盖。"""
 
     def __init__(self, root: Path):
         self.path = root / 'randpic_commands.json'
@@ -48,12 +48,9 @@ class CommandSettings:
             return
         try:
             data = json.loads(self.path.read_text(encoding='utf-8'))
-            if isinstance(data, list):
-                entries = [(name, []) for name in data]
-            elif isinstance(data, dict):
-                entries = list(data.items())
-            else:
-                raise ValueError('顶层必须是对象或旧版指令数组')
+            if not isinstance(data, dict):
+                raise ValueError('顶层必须是对象：指令名对应禁用群号列表')
+            entries = list(data.items())
         except (OSError, ValueError) as exc:
             self.writable = False
             self.commands = {}
@@ -71,8 +68,6 @@ class CommandSettings:
             valid_groups = frozenset(g for g in groups if type(g) is int and g > 0)
             commands[name] = commands.get(name, frozenset()) | valid_groups
         self.commands = commands
-        if isinstance(data, list):
-            self.save()
 
     def save(self) -> bool:
         if not self.writable:

{nonebot_plugin_randpic-2.0.0 → nonebot_plugin_randpic-2.0.2}/nonebot_plugin_randpic/library.py

@@ -1,11 +1,9 @@
 """图库业务：启动整理、添加、引用删除、发送快照，均在工作线程中执行。"""
 
 import hashlib
-import re
 import sqlite3
 import uuid
 from collections import defaultdict
-from contextlib import closing
 from dataclasses import dataclass, replace
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
@@ -36,7 +34,7 @@ class ImageLibrary:
     def __init__(self, root: Path):
         self.root = root.resolve()
         self.image_root = self.root / 'img'
-        self.repository = Repository(self.root / 'database' / 'data.db', self.image_root)
+        self.repository = Repository(self.root / 'database' / 'data.db')
         self.settings = CommandSettings(self.root)
         self.journal = FileJournal(self.root, self.repository)
         self.store_lock = StoreLock(self.root / 'database' / 'randpic.lock')
@@ -48,7 +46,6 @@ class ImageLibrary:
             directory.mkdir(parents=True, exist_ok=True)
         self.store_lock.acquire()
         try:
-            self._recover_v1_staging()
             self.repository.initialize()
             self.journal.initialize()
             self.journal.recover()
@@ -61,30 +58,6 @@ class ImageLibrary:
     def close(self) -> None:
         self.store_lock.release()
 
-    def _recover_v1_staging(self) -> None:
-        if not self.repository.path.exists():
-            return
-        with closing(sqlite3.connect(self.repository.path)) as db:
-            if not db.execute("SELECT 1 FROM sqlite_master WHERE name = 'randpic_sent_images'").fetchone():
-                return
-            for staged in self.image_root.glob('*/.randpic-delete-*.tmp'):
-                match = re.fullmatch(r'\.randpic-delete-(.+)\.[0-9a-f]{32}\.tmp', staged.name)
-                if match is None:
-                    continue
-                try:
-                    key = f'{staged.parent.name}/{match[1]}'
-                    original = safe_path(self.image_root, key)
-                    row = db.execute('SELECT MIN(deleted) FROM randpic_sent_images WHERE img_url = ? AND content_hash = ?',
-                                     (key, digest_file(staged))).fetchone()
-                    if row[0] == 1:
-                        staged.unlink()
-                    elif not original.exists():
-                        staged.rename(original)
-                    else:
-                        raise RandpicError('恢复位置已存在')
-                except Exception as exc:
-                    logger.error(f'恢复旧版图片备份失败，已保留文件：{staged} ({exc})')
-
     def _candidates(self, command: str, existing: List[ImageRecord]) -> List[_Candidate]:
         directory = safe_path(self.image_root, f'{command}/placeholder').parent
         directory.mkdir(parents=True, exist_ok=True)

nonebot_plugin_randpic-2.0.2/nonebot_plugin_randpic/progress.py

@@ -0,0 +1,118 @@
+"""终端单行进度，与 NoneBot 默认控制台日志共用 Rich Console。"""
+
+import sys
+import threading
+import time
+from typing import Optional
+
+from nonebot import log as nonebot_log
+from rich.console import Console
+from rich.live import Live
+from rich.text import Text
+
+
+class SyncProgress:
+    # 同时维护多个图库时也只显示一个动态行，不等待其他同步结束。
+    _display_lock = threading.Lock()
+
+    def __init__(self, total: int):
+        self.total = total
+        self.stream = sys.stdout
+        self.console: Optional[Console] = None
+        self.live: Optional[Live] = None
+        self._handler_id: Optional[int] = None
+        self._owns_display = False
+        self._last_refresh = 0.0
+
+    def _text(self, completed: int, succeeded: int, failed: int) -> Text:
+        percent = completed * 100 / self.total if self.total else 100
+        return Text(
+            f'OSS 同步 {completed}/{self.total} ({percent:.1f}%) '
+            f'成功 {succeeded}，失败 {failed}',
+            no_wrap=True, overflow='ellipsis',
+        )
+
+    def _write_log(self, message) -> None:
+        # 保留 NoneBot 格式和 ANSI 颜色；日志由 Live 自动排到进度行上方。
+        self.console.print(Text.from_ansi(str(message).rstrip('\n')), soft_wrap=True)
+
+    def __enter__(self):
+        self.console = Console(file=self.stream)
+        if not self.console.is_terminal or self.console.is_dumb_terminal or self.console.is_jupyter:
+            return self
+        if not self._display_lock.acquire(blocking=False):
+            return self
+        self._owns_display = True
+        try:
+            # 只临时接管 NoneBot 自带的控制台输出，文件和其他自定义 sink 保持原样。
+            # 若默认 sink 已被用户移除，则尊重其日志配置，只输出最终汇总。
+            try:
+                nonebot_log.logger.remove(nonebot_log.logger_id)
+            except ValueError:
+                self._release_display()
+                return self
+            try:
+                self._handler_id = nonebot_log.logger.add(
+                    self._write_log, level=0, diagnose=False,
+                    filter=nonebot_log.default_filter, format=nonebot_log.default_format,
+                    colorize=True,
+                )
+            except Exception:
+                nonebot_log.logger_id = self._add_default_handler()
+                raise
+            nonebot_log.logger_id = self._handler_id
+            self.live = Live(
+                self._text(0, 0, 0), console=self.console, transient=True,
+                auto_refresh=False, redirect_stdout=True, redirect_stderr=True,
+            )
+            self.live.start(refresh=True)
+            self._last_refresh = time.monotonic()
+        except Exception:
+            # 显示不可用不能中断上传；退出时同时恢复日志和标准输出。
+            self.__exit__(None, None, None)
+        return self
+
+    def update(self, completed: int, succeeded: int, failed: int) -> None:
+        if self.live is None:
+            return
+        now = time.monotonic()
+        if completed != self.total and now - self._last_refresh < 0.2:
+            return
+        try:
+            self.live.update(self._text(completed, succeeded, failed), refresh=True)
+            self._last_refresh = now
+        except Exception:
+            self.__exit__(None, None, None)
+
+    def _add_default_handler(self) -> int:
+        return nonebot_log.logger.add(
+            self.stream, level=0, diagnose=False,
+            filter=nonebot_log.default_filter, format=nonebot_log.default_format,
+        )
+
+    def _release_display(self) -> None:
+        if self._owns_display:
+            self._owns_display = False
+            self._display_lock.release()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        try:
+            if self.live is not None:
+                try:
+                    self.live.stop()
+                except Exception:
+                    pass  # 终端关闭等显示错误不应把成功的上传变成失败。
+                finally:
+                    self.live = None
+        finally:
+            try:
+                if self._handler_id is not None:
+                    handler_id, self._handler_id = self._handler_id, None
+                    try:
+                        nonebot_log.logger.remove(handler_id)
+                    except ValueError:
+                        pass  # 同步期间用户重新配置了日志，不重新添加默认控制台。
+                    else:
+                        nonebot_log.logger_id = self._add_default_handler()
+            finally:
+                self._release_display()

{nonebot_plugin_randpic-2.0.0 → nonebot_plugin_randpic-2.0.2}/nonebot_plugin_randpic/repository.py

@@ -1,17 +1,12 @@
 """SQLite 存储。连接只在线程内使用，事务不跨聊天请求或网络请求。"""
 
 import sqlite3
-import time
-import uuid
-from contextlib import closing, contextmanager
+from contextlib import contextmanager
 from dataclasses import fields
 from pathlib import Path
-from typing import Dict, Iterator, List, Mapping, Optional, Tuple
-
-from nonebot.log import logger
+from typing import Iterator, List, Mapping, Optional, Tuple
 
 from .models import ImageRecord, RandpicError, SyncJob
-from .utils import digest_file, parse_index, safe_path, valid_command
 
 
 IMAGE_COLUMNS = ', '.join(field.name for field in fields(ImageRecord))
@@ -57,8 +52,8 @@ def _hamming(left: str, right: str) -> int:
 
 
 class Repository:
-    def __init__(self, path: Path, image_root: Path):
-        self.path, self.image_root = path, image_root
+    def __init__(self, path: Path):
+        self.path = path
 
     @contextmanager
     def connection(self, *, write: bool = False) -> Iterator[sqlite3.Connection]:
@@ -98,93 +93,15 @@ class Repository:
             version = int(self.meta(db, 'schema_version')) if 'randpic_meta' in names else 0
             if version > 2:
                 raise RandpicError('数据库来自更新版本的 Randpic，不能用 2.0.0 覆盖。')
-            legacy = any(name.startswith('Pic_of_') for name in names) or 'randpic_sent_images' in names
-            backup = self.path.with_name(self.path.stem + '.pre-v2.db')
-            if not version and legacy and not backup.exists():
-                temporary = backup.with_name(backup.name + '.' + uuid.uuid4().hex + '.tmp')
-                try:
-                    with closing(sqlite3.connect(temporary)) as destination:
-                        db.backup(destination)
-                    temporary.replace(backup)
-                finally:
-                    if temporary.exists():
-                        temporary.unlink()
             db.execute('PRAGMA journal_mode = WAL')
             db.execute('PRAGMA synchronous = FULL')
             db.executescript(SCHEMA)
         with self.connection(write=True) as db:
             if int(self.meta(db, 'schema_version')) == 0:
-                self._migrate_legacy(db, names)
                 self.set_meta(db, 'schema_version', '2')
                 self.set_meta(db, 'published_revision', '-1')
                 self.mark_dirty(db)
 
-    def _migrate_legacy(self, db: sqlite3.Connection, names: set) -> None:
-        current: Dict[Tuple[str, str], ImageRecord] = {}
-        for name in sorted(names):
-            if not name.startswith('Pic_of_') or not valid_command(name[7:]):
-                continue
-            command = name[7:]
-            self.set_sequence(db, command, 0)
-            columns = {row[1] for row in db.execute(f'PRAGMA table_info("{name}")')}
-            if 'img_url' not in columns:
-                continue
-            for row in db.execute(f'SELECT * FROM "{name}"'):
-                key = str(row['img_url']).replace('\\', '/')
-                try:
-                    path = safe_path(self.image_root, key)
-                    if key.split('/')[0] != command:
-                        raise RandpicError('分类与图片路径不一致')
-                    self.set_sequence(db, command, parse_index(path.stem, command) or 0)
-                    exists = path.is_file()
-                    content_hash = digest_file(path) if exists else ''
-                    stat = path.stat() if exists else None
-                    count = max(0, int(row['send_count'] or 0)) if 'send_count' in columns else 0
-                except (OSError, ValueError, RandpicError) as exc:
-                    logger.warning(f'迁移旧图片记录失败，保留原表：{key} ({exc})')
-                    continue
-                previous = current.get((command, path.name))
-                if previous is not None:
-                    db.execute('UPDATE randpic_images SET send_count = send_count + ? WHERE id = ?', (count, previous.id))
-                    continue
-                image = ImageRecord(
-                    uuid.uuid4().hex, command, path.name, content_hash,
-                    str(row['phash'] or '') if 'phash' in columns else '', count,
-                    stat.st_size if stat else 0, stat.st_mtime_ns if stat else 0, not exists, False,
-                )
-                self.upsert_image(db, image)
-                current[(command, path.name)] = image
-                db.execute('INSERT OR IGNORE INTO randpic_remote VALUES (?, ?)', (key, ''))
-            db.execute('INSERT OR IGNORE INTO randpic_remote VALUES (?, ?)', (f'{command}/index.html', ''))
-        if current:
-            db.execute('INSERT OR IGNORE INTO randpic_remote VALUES (?, ?)', ('index.html', ''))
-        if 'randpic_sent_images' not in names:
-            return
-        historical: Dict[Tuple[str, str, str], str] = {}
-        for row in db.execute('SELECT * FROM randpic_sent_images'):
-            try:
-                command, key, content_hash = str(row['command']), str(row['img_url']).replace('\\', '/'), str(row['content_hash'])
-                path = safe_path(self.image_root, key)
-                if path.parent.name != command:
-                    raise RandpicError('分类与图片路径不一致')
-                self.set_sequence(db, command, parse_index(path.stem, command) or 0)
-                image = current.get((command, path.name))
-                if row['deleted'] or image is None or image.deleted or image.content_hash != content_hash:
-                    identity = (command, path.name, content_hash)
-                    image_id = historical.get(identity)
-                    if image_id is None:
-                        image_id = uuid.uuid4().hex
-                        historical[identity] = image_id
-                        self.upsert_image(db, ImageRecord(image_id, command, path.name, content_hash, '', deleted=True, validated=False))
-                    if row['sync_pending']:
-                        db.execute('INSERT OR IGNORE INTO randpic_remote VALUES (?, ?)', (key, ''))
-                else:
-                    image_id = image.id
-                db.execute('INSERT OR REPLACE INTO randpic_messages VALUES (?, ?, ?, ?)',
-                           (str(row['bot_id']), int(row['group_id']), int(row['message_id']), image_id))
-            except (KeyError, IndexError, ValueError, RandpicError) as exc:
-                logger.warning(f'迁移历史发图消息失败，保留原记录：{exc}')
-
     @staticmethod
     def upsert_image(db: sqlite3.Connection, image: ImageRecord) -> None:
         names = [field.name for field in fields(ImageRecord)]

{nonebot_plugin_randpic-2.0.0 → nonebot_plugin_randpic-2.0.2}/nonebot_plugin_randpic/service.py

@@ -13,6 +13,7 @@ from .ali_oss import OSSUploaderV2
 from .config import Config
 from .library import ImageLibrary
 from .models import ImageRecord, ImageSnapshot, MutationResult, RandpicError, SyncResult
+from .progress import SyncProgress
 from .utils import run_blocking
 from .web import GalleryPublisher
 
@@ -192,46 +193,50 @@ class RandpicService:
             if not jobs:
                 return SyncResult()
             succeeded = failed = completed = 0
-            last_report = 0.0
-
-            async def phase(items):
-                queue = asyncio.Queue()
-                for job in items:
-                    queue.put_nowait(job)
-
-                async def worker():
-                    nonlocal succeeded, failed, completed, last_report
-                    while not queue.empty():
-                        job = queue.get_nowait()
-                        try:
-                            if job.action == 'delete':
-                                ok = await self.uploader.delete_file(job.key)
-                            else:
-                                ok = await self.uploader.upload_file(job.local_path, job.key, job.content_hash)
-                            if ok:
-                                await run_blocking(self.repository.complete_job, job)
-                                succeeded += 1
-                            else:
-                                await run_blocking(self.repository.fail_job, job, '远端请求失败或任务已过期')
+            started = asyncio.get_running_loop().time()
+
+            with SyncProgress(len(jobs)) as progress:
+                async def phase(items):
+                    queue = asyncio.Queue()
+                    for job in items:
+                        queue.put_nowait(job)
+
+                    async def worker():
+                        nonlocal succeeded, failed, completed
+                        while not queue.empty():
+                            job = queue.get_nowait()
+                            try:
+                                if job.action == 'delete':
+                                    ok = await self.uploader.delete_file(job.key)
+                                else:
+                                    ok = await self.uploader.upload_file(job.local_path, job.key, job.content_hash)
+                                if ok:
+                                    await run_blocking(self.repository.complete_job, job)
+                                    succeeded += 1
+                                else:
+                                    await run_blocking(self.repository.fail_job, job, '远端请求失败或任务已过期')
+                                    failed += 1
+                            except Exception as exc:
+                                logger.error(f'同步 OSS 任务失败，已保留以便重试：{job.key} ({exc})')
                                 failed += 1
-                        except Exception as exc:
-                            logger.error(f'同步 OSS 任务失败，已保留以便重试：{job.key} ({exc})')
-                            failed += 1
-                        finally:
-                            queue.task_done()
-                            completed += 1
-                            now = asyncio.get_running_loop().time()
-                            if now - last_report >= 1 or completed == len(jobs):
-                                logger.info(f'OSS同步进度: {completed}/{len(jobs)} ({completed * 100 / len(jobs):.1f}%)，成功 {succeeded}，失败 {failed}')
-                                last_report = now
-
-                await asyncio.gather(*(worker() for _ in range(min(self.config.randpic_upload_concurrency, len(items)))))
-
-            # 先同步图片，再同步页面，最后更新用于浏览器自动刷新的目录版本。
-            await phase([job for job in jobs if not job.key.endswith(('.html', '.json'))])
-            await phase([job for job in jobs if job.key.endswith('.html')])
-            await phase([job for job in jobs if job.key.endswith('.json')])
+                            finally:
+                                queue.task_done()
+                                completed += 1
+                                progress.update(completed, succeeded, failed)
+
+                    await asyncio.gather(*(worker() for _ in range(min(self.config.randpic_upload_concurrency, len(items)))))
+
+                # 先同步图片，再同步页面。
+                await phase([job for job in jobs if not job.key.endswith('.html')])
+                await phase([job for job in jobs if job.key.endswith('.html')])
             pending = len(await run_blocking(self.repository.sync_jobs))
+            elapsed = asyncio.get_running_loop().time() - started
+            summary = (f'OSS 同步完成：成功 {succeeded}，失败 {failed}，待处理 {pending}，'
+                       f'用时 {elapsed:.1f} 秒')
+            if failed:
+                logger.warning(summary + '；失败任务将自动重试')
+            else:
+                logger.info(summary)
             return SyncResult(succeeded=succeeded, failed=failed, pending=pending)
 
     async def _retry_worker(self) -> None:

{nonebot_plugin_randpic-2.0.0 → nonebot_plugin_randpic-2.0.2}/nonebot_plugin_randpic/web.py

@@ -1,7 +1,6 @@
-"""静态网页发布：原子替换文件、分页、懒加载，以及增删后的自动刷新。"""
+"""静态网页发布：原子替换文件、分页与图片懒加载。"""
 
 import hashlib
-import json
 import math
 from html import escape
 from pathlib import Path
@@ -67,8 +66,7 @@ def _url(image: ImageRecord) -> str:
     return quote(image.filename, safe='') + '?v=' + image.content_hash[:16]
 
 
-def _shell(title: str, home: str, version: str, command: str, page: int, content: str) -> str:
-    state = json.dumps({'version': version, 'command': command, 'page': page}, ensure_ascii=False).replace('<', '\\u003c')
+def _shell(title: str, home: str, content: str) -> str:
     return f'''<!doctype html><html lang="zh-CN"><head><meta charset="utf-8">
 <meta name="viewport" content="width=device-width,initial-scale=1"><meta name="theme-color" content="#f5f6f2">
 <title>{escape(title)} · Randpic</title><style>{GALLERY_STYLE}
@@ -77,22 +75,13 @@ def _shell(title: str, home: str, version: str, command: str, page: int, content
 </style></head><body><div class="shell">
 <nav class="topbar"><a class="brand" href="{home}"><span class="brand-mark">✳</span><span>RANDPIC / 图片收藏馆</span></a><span class="top-note">捕捉喜欢的瞬间</span></nav>
 {content}<footer>Randpic · 收藏每一个喜欢的瞬间</footer></div>
-<script>(()=>{{const state={state}; const home={json.dumps(home)};
-setInterval(async()=>{{if(document.hidden)return;try{{
-const response=await fetch(home+'catalog.json',{{cache:'no-store'}});if(!response.ok)return;
-const next=await response.json();if(next.version===state.version)return;
-if(state.command && (!(state.command in next.pages)||state.page>next.pages[state.command])){{location.href=state.command in next.pages?'./':home;return;}}
-location.reload();}}catch(error){{}}}},15000);}})();</script></body></html>'''
+</body></html>'''
 
 
 def render_catalog(groups: Mapping[str, Sequence[ImageRecord]], page_size: int) -> Dict[str, bytes]:
-    """相同图库总是产生相同 HTML；发送次数变化不会导致网页重复刷新。"""
-    identity = [(command, [(image.id, image.filename, image.content_hash) for image in images])
-                for command, images in sorted(groups.items())]
-    version = hashlib.sha256(json.dumps(identity, ensure_ascii=False).encode()).hexdigest()
+    """生成纯静态 HTML，只让内容实际变化的页面产生同步任务。"""
     pages = {command: max(1, math.ceil(len(images) / page_size)) for command, images in groups.items()}
-    catalog = json.dumps({'version': version, 'pages': pages}, ensure_ascii=False, sort_keys=True).encode()
-    files = {'catalog.json': catalog}
+    files: Dict[str, bytes] = {}
     total = sum(len(images) for images in groups.values())
     cards = []
     for command, images in sorted(groups.items()):
@@ -106,7 +95,7 @@ def render_catalog(groups: Mapping[str, Sequence[ImageRecord]], page_size: int)
     home = f'''<header class="hero"><p class="eyebrow">YOUR IMAGE LIBRARY</p><h1>每一张，都值得<br>被好好收藏。</h1>
 <p class="hero-copy">在这里慢慢翻看收藏的每一份灵感。</p></header><div class="section-head"><h2>全部分类</h2>
 <span class="count">{len(groups)} 个分类　·　{total} 张图片</span></div><main class="folder-grid">{''.join(cards)}</main>'''
-    files['index.html'] = _shell('图片收藏馆', './', version, '', 1, home).encode()
+    files['index.html'] = _shell('图片收藏馆', './', home).encode()
     for command, images in groups.items():
         for page in range(1, pages[command] + 1):
             cards = []
@@ -128,7 +117,7 @@ def render_catalog(groups: Mapping[str, Sequence[ImageRecord]], page_size: int)
 <header class="gallery-title"><p class="eyebrow">COLLECTION</p><h1>{escape(command)}</h1><p class="hero-copy">本分类共收藏 {len(images)} 张图片。</p></header>
 <main class="image-grid">{''.join(cards)}</main><nav class="pagination">{''.join(navigation)}</nav>'''
             filename = 'index.html' if page == 1 else f'page-{page}.html'
-            files[f'{command}/{filename}'] = _shell(command, '../', version, command, page, content).encode()
+            files[f'{command}/{filename}'] = _shell(command, '../', content).encode()
     return files
 
 

{nonebot_plugin_randpic-2.0.0 → nonebot_plugin_randpic-2.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "nonebot-plugin-randpic"
-version = "2.0.0"
+version = "2.0.2"
 description = "一个通过指令随机发送你存储的图片的nonebot2插件"
 authors = ["HuParry <hu_parry@qq.com>"]
 license = "MIT"
@@ -20,6 +20,7 @@ alibabacloud_oss_v2 = ">=1.2.0"
 aiohttp = ">=3.8.0,<4.0.0"
 pillow = ">=11.0.0"
 imagehash = ">=4.3.0"
+rich = ">=13.0,<15.0"
 
 [build-system]
 requires = ["poetry-core"]