bdpan-cli 0.1.0__py3-none-any.whl

bdpan_cli/media_info.py

@@ -0,0 +1,251 @@
+"""MediaInfo: 百度网盘视频/媒体深度元数据探测与目录聚合统计。"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+from typing import Any
+
+from bdpan_cli._vendor import openapi_client
+from bdpan_cli._vendor.openapi_client.api.multimediafile_api import MultimediafileApi
+from bdpan_cli._vendor.openapi_client.rest import ApiException
+from bdpan_cli.file_manager import FileManager
+
+logger = logging.getLogger(__name__)
+
+# 常见媒体格式分类表
+EXTENSION_CATEGORY_MAP = {
+    # 视频
+    ".mkv": "video",
+    ".mp4": "video",
+    ".avi": "video",
+    ".mov": "video",
+    ".wmv": "video",
+    ".flv": "video",
+    ".rmvb": "video",
+    ".ts": "video",
+    ".m2ts": "video",
+    ".iso": "video",
+    # 字幕
+    ".srt": "subtitle",
+    ".ass": "subtitle",
+    ".sub": "subtitle",
+    ".vtt": "subtitle",
+    ".idx": "subtitle",
+    ".sup": "subtitle",
+    # 图片/海报
+    ".jpg": "image",
+    ".jpeg": "image",
+    ".png": "image",
+    ".webp": "image",
+    ".bmp": "image",
+    ".gif": "image",
+    # 音频
+    ".mp3": "audio",
+    ".flac": "audio",
+    ".wav": "audio",
+    ".aac": "audio",
+    ".m4a": "audio",
+    ".ogg": "audio",
+    ".ape": "audio",
+    # 压缩包
+    ".zip": "archive",
+    ".rar": "archive",
+    ".7z": "archive",
+    ".tar": "archive",
+    ".gz": "archive",
+    # 文档/NFO
+    ".nfo": "doc",
+    ".txt": "doc",
+    ".pdf": "doc",
+}
+
+
+class MediaInfoError(RuntimeError):
+    """媒体元数据解析或统计异常基类。"""
+
+
+def format_duration(seconds: int | float | None) -> str:
+    """将秒数格式化为 HH:MM:SS。"""
+    if not seconds or seconds < 0:
+        return "00:00:00"
+    total_sec = int(seconds)
+    hours = total_sec // 3600
+    minutes = (total_sec % 3600) // 60
+    secs = total_sec % 60
+    return f"{hours:02d}:{minutes:02d}:{secs:02d}"
+
+
+def normalize_resolution(width: int | None, height: int | None) -> str:
+    """归一化视频分辨率描述。"""
+    if not width or not height:
+        return "未知分辨率"
+    w, h = int(width), int(height)
+    if w >= 3840 or h >= 2160:
+        return f"{w}x{h} (4K UHD)"
+    if w >= 2560 or h >= 1440:
+        return f"{w}x{h} (2K QHD)"
+    if w >= 1920 or h >= 1080:
+        return f"{w}x{h} (1080P FHD)"
+    if w >= 1280 or h >= 720:
+        return f"{w}x{h} (720P HD)"
+    return f"{w}x{h}"
+
+
+def normalize_codec(codec: str | None) -> str:
+    """归一化编码名称。"""
+    if not codec:
+        return "未知编码"
+    c = str(codec).strip().lower()
+    if c in ("hevc", "h265", "h.265"):
+        return "HEVC"
+    if c in ("h264", "h.264", "avc"):
+        return "H.264"
+    if c in ("av01", "av1"):
+        return "AV1"
+    if c in ("vc1", "vc-1"):
+        return "VC-1"
+    return codec.upper()
+
+
+class MediaInfoClient:
+    """网盘媒体元数据探测与聚合统计客户端。"""
+
+    def __init__(self, access_token: str, api_client: openapi_client.ApiClient | None = None) -> None:
+        self.access_token = access_token
+        self.api_client = api_client or openapi_client.ApiClient()
+        self._multimedia_api = MultimediafileApi(self.api_client)
+        self._file_manager = FileManager(access_token, self.api_client)
+
+    def get_media_info(self, remote_path: str) -> dict[str, Any]:
+        """获取单个视频/多媒体文件的深度媒体元数据。
+
+        Args:
+            remote_path: 网盘文件路径。
+
+        Returns:
+            包含分辨率、时长、编码、音轨、文件大小等元数据的结构化字典。
+
+        Raises:
+            MediaInfoError: 当文件不存在、为目录或接口异常时抛出。
+        """
+        info = self._file_manager.get_file_info(remote_path)
+        if not info:
+            raise MediaInfoError(f"网盘文件不存在: {remote_path}")
+        if info.get("isdir") == 1:
+            raise MediaInfoError(f"目标为目录，无法解析媒体深度元数据: {remote_path}")
+
+        fs_id = info["fs_id"]
+        try:
+            res = self._multimedia_api.xpanmultimediafilemetas(
+                access_token=self.access_token,
+                fsids=json.dumps([fs_id]),
+                extra="1",
+                needmedia=1,
+            )
+        except ApiException as e:
+            raise MediaInfoError(f"获取媒体元数据 API 异常 [{remote_path}]: {e.status} {e.body}") from e
+
+        if not isinstance(res, dict) or res.get("errno") != 0:
+            raise MediaInfoError(f"获取媒体元数据失败 [{remote_path}]: errno={res.get('errno', '?')}")
+
+        entries = res.get("list") or []
+        entry = entries[0] if entries else {}
+
+        # 提取字段
+        size = int(entry.get("size") or info.get("size") or 0)
+        filename = entry.get("server_filename") or info.get("server_filename") or os.path.basename(remote_path)
+        ext = os.path.splitext(filename)[1].lower()
+        is_video = EXTENSION_CATEGORY_MAP.get(ext) == "video"
+
+        # 尝试从 media_info 或直接字段提取宽/高/时长/编码
+        media_info_block = entry.get("media_info") or {}
+        video_track = (media_info_block.get("video") or [{}])[0] if isinstance(media_info_block.get("video"), list) and media_info_block.get("video") else {}
+
+        duration = entry.get("duration") or video_track.get("duration") or 0
+        width = entry.get("width") or video_track.get("width")
+        height = entry.get("height") or video_track.get("height")
+        raw_codec = entry.get("video_codec") or video_track.get("codec")
+
+        audio_tracks = media_info_block.get("audio") or []
+
+        return {
+            "path": remote_path,
+            "filename": filename,
+            "fs_id": fs_id,
+            "size": size,
+            "md5": entry.get("md5") or info.get("md5"),
+            "category": EXTENSION_CATEGORY_MAP.get(ext, "other"),
+            "is_video": is_video,
+            "duration_seconds": int(duration),
+            "duration_formatted": format_duration(duration),
+            "width": width,
+            "height": height,
+            "resolution": normalize_resolution(width, height),
+            "video_codec": normalize_codec(raw_codec),
+            "audio_tracks_count": len(audio_tracks),
+            "audio_tracks": audio_tracks,
+            "raw_media_info": media_info_block,
+        }
+
+    def get_dir_stats(self, remote_path: str, max_depth: int | None = None) -> dict[str, Any]:
+        """递归统计指定目录下的容量、文件数及扩展名与类别分布。
+
+        Args:
+            remote_path: 网盘目录绝对路径。
+            max_depth: 最大扫描深度。
+
+        Returns:
+            统计结果字典。
+        """
+        raw_path = remote_path or "/"
+        target_dir = "/" + raw_path.strip("/") if raw_path != "/" else "/"
+        entries, errors = self._file_manager.walk(target_dir, max_depth=max_depth)
+
+        total_files = 0
+        total_dirs = 0
+        total_size = 0
+        by_extension: dict[str, dict[str, int]] = {}
+        by_category: dict[str, dict[str, int]] = {
+            "video": {"count": 0, "size": 0},
+            "subtitle": {"count": 0, "size": 0},
+            "image": {"count": 0, "size": 0},
+            "audio": {"count": 0, "size": 0},
+            "archive": {"count": 0, "size": 0},
+            "doc": {"count": 0, "size": 0},
+            "other": {"count": 0, "size": 0},
+        }
+
+        for _, e in entries:
+            if e.get("isdir") == 1:
+                total_dirs += 1
+            else:
+                total_files += 1
+                size = int(e.get("size") or 0)
+                total_size += size
+                fname = e.get("server_filename") or ""
+                ext = os.path.splitext(fname)[1].lower() or "(no-ext)"
+
+                if ext not in by_extension:
+                    by_extension[ext] = {"count": 0, "size": 0}
+                by_extension[ext]["count"] += 1
+                by_extension[ext]["size"] += size
+
+                cat = EXTENSION_CATEGORY_MAP.get(ext, "other")
+                by_category[cat]["count"] += 1
+                by_category[cat]["size"] += size
+
+        # 按大小降序排序扩展名
+        sorted_ext = dict(sorted(by_extension.items(), key=lambda item: item[1]["size"], reverse=True))
+
+        return {
+            "root": target_dir,
+            "max_depth": max_depth,
+            "total_files": total_files,
+            "total_dirs": total_dirs,
+            "total_size": total_size,
+            "by_extension": sorted_ext,
+            "by_category": by_category,
+            "errors": [{"path": p, "error": msg} for p, msg in errors],
+        }

bdpan_cli/ops.py

@@ -0,0 +1,173 @@
+"""操作流水审计与逆向撤销体系 (Operation Audit Logging & Undo Engine - BK-0034)."""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import time
+import uuid
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from bdpan_cli.file_manager import FileManager, FileManagerError
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_OPS_DIR = Path(__file__).resolve().parents[2] / ".bdpan_ops"
+
+
+class UndoError(RuntimeError):
+    """撤销操作异常基类。"""
+
+
+class OperationLogger:
+    """操作审计流水记录器，将每一次破坏性/批量操作落盘为结构化 JSON 日志。"""
+
+    def __init__(self, ops_dir: str | Path | None = None) -> None:
+        self.ops_dir = Path(ops_dir).resolve() if ops_dir else DEFAULT_OPS_DIR
+        self.ops_dir.mkdir(parents=True, exist_ok=True)
+
+    def record_operation(
+        self,
+        command: str,
+        items: list[dict[str, Any]],
+        account: str = "default",
+    ) -> str:
+        """记录一次批量操作流水。
+
+        Args:
+            command: 命令类型，如 mv, rename, foldering, dedup 等。
+            items: 操作的映射项列表，每项形如 {"src": "/old/path", "dest": "/new/path"}。
+            account: 操作所使用的网盘账号标识。
+
+        Returns:
+            分配的唯一操作批次 ID (op_id)。
+        """
+        now = datetime.now()
+        op_id = f"{now.strftime('%Y%m%d_%H%M%S')}_{command}_{uuid.uuid4().hex[:6]}"
+        record = {
+            "op_id": op_id,
+            "command": command,
+            "timestamp": int(time.time()),
+            "created_at": now.isoformat(),
+            "account": account,
+            "undone": False,
+            "undone_at": None,
+            "items": items,
+        }
+        file_path = self.ops_dir / f"{op_id}.json"
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(record, f, ensure_ascii=False, indent=2)
+
+        logger.debug("已记录操作流水 [%s]: %d 项映射", op_id, len(items))
+        return op_id
+
+    def list_operations(self, limit: int = 20) -> list[dict[str, Any]]:
+        """按时间倒序列出最近的操作审计流水。"""
+        if not self.ops_dir.exists():
+            return []
+
+        ops: list[dict[str, Any]] = []
+        # 按文件名排序，文件名以时间戳开头，因此逆序即为最新在前
+        for f in sorted(self.ops_dir.glob("*.json"), reverse=True):
+            try:
+                with open(f, "r", encoding="utf-8") as fp:
+                    data = json.load(fp)
+                if isinstance(data, dict) and "op_id" in data:
+                    ops.append(data)
+                    if len(ops) >= limit:
+                        break
+            except (OSError, json.JSONDecodeError) as e:
+                logger.warning("跳过不可读流水文件 [%s]: %s", f, e)
+
+        return ops
+
+    def get_operation(self, op_id: str) -> dict[str, Any] | None:
+        """读取指定 op_id 的完整流水记录。"""
+        file_path = self.ops_dir / f"{op_id}.json"
+        if not file_path.exists():
+            return None
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except (OSError, json.JSONDecodeError) as e:
+            logger.error("读取流水失败 [%s]: %s", op_id, e)
+            return None
+
+    def mark_undone(self, op_id: str) -> None:
+        """标记指定操作为已撤销。"""
+        file_path = self.ops_dir / f"{op_id}.json"
+        if not file_path.exists():
+            raise UndoError(f"流水文件不存在: {op_id}")
+
+        with open(file_path, "r", encoding="utf-8") as f:
+            record = json.load(f)
+
+        record["undone"] = True
+        record["undone_at"] = datetime.now().isoformat()
+
+        with open(file_path, "w", encoding="utf-8") as f:
+            json.dump(record, f, ensure_ascii=False, indent=2)
+
+
+class UndoEngine:
+    """逆向撤销执行引擎，将历史操作中的 dest 反向移回原 src。"""
+
+    def __init__(self, file_manager: FileManager, ops_logger: OperationLogger | None = None) -> None:
+        self.file_manager = file_manager
+        self.ops_logger = ops_logger or OperationLogger()
+
+    def plan_undo(self, op_id: str) -> dict[str, Any]:
+        """为指定操作生成逆向回滚计划。"""
+        op = self.ops_logger.get_operation(op_id)
+        if not op:
+            raise UndoError(f"未找到对应的操作流水: {op_id}")
+        if op.get("undone"):
+            raise UndoError(f"操作 [{op_id}] 此前已被撤销过 (撤销时间: {op.get('undone_at')})，禁止重复撤销")
+
+        items = op.get("items") or []
+        reversals: list[dict[str, str]] = []
+        for item in items:
+            src = item.get("src")
+            dest = item.get("dest")
+            if not src or not dest:
+                continue
+            # 逆向：现在的源是以前的 dest，现在的目标目录是以前 src 的父目录，文件名是以前 src 的文件名
+            dest_dir = os.path.dirname(src) or "/"
+            newname = os.path.basename(src)
+            reversals.append({
+                "src": dest,
+                "dest_dir": dest_dir,
+                "newname": newname,
+            })
+
+        return {
+            "op_id": op_id,
+            "command": op.get("command"),
+            "account": op.get("account"),
+            "created_at": op.get("created_at"),
+            "reversals": reversals,
+        }
+
+    def execute_undo(self, op_id: str, dry_run: bool = False) -> dict[str, Any]:
+        """执行逆向回滚。"""
+        plan = self.plan_undo(op_id)
+        reversals = plan["reversals"]
+        if not reversals:
+            return {"op_id": op_id, "undone_count": 0, "dry_run": dry_run}
+
+        if dry_run:
+            return {"op_id": op_id, "undone_count": len(reversals), "dry_run": True, "plan": reversals}
+
+        # 转换为 batch_move 所需的三元组列表：(src, dest_dir, newname)
+        move_tuples = [(r["src"], r["dest_dir"], r["newname"]) for r in reversals]
+        try:
+            self.file_manager.batch_move(move_tuples, batch_size=50)
+        except FileManagerError as e:
+            raise UndoError(f"执行回滚移动失败: {e}") from e
+
+        # 标记已撤销
+        self.ops_logger.mark_undone(op_id)
+        return {"op_id": op_id, "undone_count": len(reversals), "dry_run": False}

bdpan_cli/organize.py

@@ -0,0 +1,108 @@
+"""电影目录规整与迁移任务脚本。"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from typing import Any
+
+from bdpan_cli.auth import TokenManager
+from bdpan_cli.config import load_config
+from bdpan_cli.file_manager import FileManager
+
+logger = logging.getLogger(__name__)
+
+ROOT_DIR = "/影视/电影"
+UNWATCHED_OLD = f"{ROOT_DIR}/0_notWatch"
+UNWATCHED_NEW_NAME = "unwatched"
+UNWATCHED_NEW_PATH = f"{ROOT_DIR}/{UNWATCHED_NEW_NAME}"
+WATCHED_DIR = f"{ROOT_DIR}/watched"
+TRIAGE_DIR = f"{ROOT_DIR}/pending_triage"
+
+
+def run_organization() -> None:
+    config = load_config()
+    token = TokenManager(config).get_access_token()
+    mgr = FileManager(token)
+
+    logger.info("=== 阶段 0: 检查当前目录状态 ===")
+    entries = mgr.list_dir(ROOT_DIR, limit=1000)
+    name_map = {e.get("server_filename"): e for e in entries}
+    logger.info("当前 %s 下共有 %d 个条目", ROOT_DIR, len(entries))
+
+    # 1. 待看目录重命名
+    logger.info("=== 阶段 1: 重命名待看目录 ===")
+    if "0_notWatch" in name_map:
+        logger.info("发现 0_notWatch，开始重命名为 %s ...", UNWATCHED_NEW_NAME)
+        res_rename = mgr.rename(UNWATCHED_OLD, UNWATCHED_NEW_NAME)
+        logger.info("重命名成功: %s", res_rename)
+    elif UNWATCHED_NEW_NAME in name_map:
+        logger.info("目录 %s 已存在，跳过重命名", UNWATCHED_NEW_NAME)
+    else:
+        logger.warning("未找到 0_notWatch 或 %s，请确认目录状态", UNWATCHED_NEW_NAME)
+
+    # 2. 创建目标目录
+    logger.info("=== 阶段 2: 确保目标目录存在 ===")
+    logger.info("创建/确保已看目录: %s", WATCHED_DIR)
+    mgr.mkdir(WATCHED_DIR)
+    logger.info("创建/确保待整理目录: %s", TRIAGE_DIR)
+    mgr.mkdir(TRIAGE_DIR)
+
+    # 3. 重新扫描根目录以获取最新条目清单
+    logger.info("=== 阶段 3: 扫描待归类文件与目录 ===")
+    current_entries = mgr.list_dir(ROOT_DIR, limit=1000)
+
+    # 保留在根目录的三个核心文件夹
+    preserved_names = {UNWATCHED_NEW_NAME, "0_notWatch", "watched", "pending_triage"}
+
+    items_to_triage: list[tuple[str, str, str]] = []  # (src_path, dest_dir, new_name)
+    items_to_watched: list[tuple[str, str, str]] = []
+
+    for item in current_entries:
+        fname = item.get("server_filename")
+        if fname in preserved_names:
+            continue
+        fpath = item.get("path")
+        isdir = item.get("isdir") == 1
+
+        if isdir:
+            items_to_watched.append((fpath, WATCHED_DIR, fname))
+        else:
+            # 种子、压缩包、单视频、字幕等全部非目录文件移至 pending_triage
+            items_to_triage.append((fpath, TRIAGE_DIR, fname))
+
+    logger.info("待迁移到 watched (电影目录): %d 项", len(items_to_watched))
+    logger.info("待迁移到 pending_triage (杂项文件): %d 项", len(items_to_triage))
+
+    # 4. 执行迁移到 pending_triage
+    if items_to_triage:
+        logger.info("开始分批迁移杂项文件到 %s (批次大小 50)...", TRIAGE_DIR)
+        res_triage = mgr.batch_move(items_to_triage, batch_size=50)
+        logger.info("杂项文件迁移完成，共调用 %d 个批次", len(res_triage))
+
+    # 5. 执行迁移到 watched
+    if items_to_watched:
+        logger.info("开始分批迁移电影目录到 %s (批次大小 50)...", WATCHED_DIR)
+        res_watched = mgr.batch_move(items_to_watched, batch_size=50)
+        logger.info("电影目录迁移完成，共调用 %d 个批次", len(res_watched))
+
+    # 6. 对账与最终验证
+    logger.info("=== 阶段 4: 迁移后对账审计 ===")
+    final_root_entries = mgr.list_dir(ROOT_DIR, limit=1000)
+    root_names = [e.get("server_filename") for e in final_root_entries]
+    logger.info("%s 根目录最终条目数: %d -> %s", ROOT_DIR, len(root_names), root_names)
+
+    watched_entries = mgr.list_dir(WATCHED_DIR, limit=1000)
+    logger.info("%s 下最终条目数: %d", WATCHED_DIR, len(watched_entries))
+
+    triage_entries = mgr.list_dir(TRIAGE_DIR, limit=1000)
+    logger.info("%s 下最终条目数: %d", TRIAGE_DIR, len(triage_entries))
+
+    unwatched_entries = mgr.list_dir(UNWATCHED_NEW_PATH, limit=1000)
+    logger.info("%s 下最终条目数: %d", UNWATCHED_NEW_PATH, len(unwatched_entries))
+
+    logger.info("=== 迁移完成！ ===")
+
+
+if __name__ == "__main__":
+    run_organization()