bdpan-cli 0.1.0__py3-none-any.whl

bdpan_cli/config.py

@@ -0,0 +1,26 @@
+"""应用配置：从 .env 读取百度网盘开放平台凭证。"""
+
+import os
+from dataclasses import dataclass
+
+from dotenv import load_dotenv
+
+
+@dataclass(frozen=True)
+class AppConfig:
+    app_key: str
+    secret_key: str
+
+
+def load_config() -> AppConfig:
+    load_dotenv()
+    values = {
+        "BAIDU_APP_KEY": os.getenv("BAIDU_APP_KEY", "").strip(),
+        "BAIDU_SECRET_KEY": os.getenv("BAIDU_SECRET_KEY", "").strip(),
+    }
+    missing = [name for name, value in values.items() if not value]
+    if missing:
+        raise RuntimeError(
+            f"缺少配置项：{'、'.join(missing)}，请在 .env 中填写（参考 .env.example）"
+        )
+    return AppConfig(values["BAIDU_APP_KEY"], values["BAIDU_SECRET_KEY"])

bdpan_cli/dedup.py

@@ -0,0 +1,310 @@
+"""网盘冲突副本与重复文件扫描与治理模块 (BK-0027)。
+
+支持检测并治理百度网盘因重复上传或同步产生的形如 `(1)`、`(2)` 的冲突副本、
+无主编号副本以及空目录，提供安全隔离（--staging-dir）与回收站清理（--delete）。
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Any
+
+from bdpan_cli.file_manager import FileManager, FileManagerError
+
+logger = logging.getLogger(__name__)
+
+# 匹配冲突副本后缀，如 "name (1)", "name(2)", "name (01).mp4", "name (1).mkv"
+# index 限制为 1-3 位数字，自动排除 4 位年份数字如 (1995), (2021)
+CONFLICT_SUFFIX_PATTERN = re.compile(
+    r"^(?P<base>.+?)(?:[\s._-]*)?\((?P<index>\d{1,3})\)(?P<ext>\.[^.]+)?$"
+)
+
+
+@dataclass
+class DedupCandidate:
+    """待治理的冲突副本或重复项。"""
+
+    path: str
+    name: str
+    isdir: bool
+    size: int
+    reason: str
+    clean_name: str
+    primary_path: str | None = None
+
+
+@dataclass
+class DedupPlan:
+    """重复项治理扫描计划与统计。"""
+
+    target_dir: str
+    candidates: list[DedupCandidate]
+    total_size: int
+    scanned_count: int
+    orphan_groups_count: int = 0
+
+
+def scan_directory_duplicates(
+    dir_path: str,
+    entries: list[dict[str, Any]],
+    include_orphans: bool = False,
+    include_empty: bool = False,
+    mgr: FileManager | None = None,
+) -> tuple[list[DedupCandidate], int]:
+    """在单层目录条目中检测冲突副本与重复项。
+
+    Args:
+        dir_path: 当前扫描的父目录绝对路径。
+        entries: 当前目录下的条目列表（来自 list_dir 或 walk 分组）。
+        include_orphans: 是否将无主冲突副本组（如缺少未带编号原版但有 (1)/(2)）中更高编号项视为冗余。
+        include_empty: 是否检测并标记空子目录。
+        mgr: 可选的 FileManager 实例，用于单层模式下探查子目录是否为空。
+
+    Returns:
+        (candidates, orphan_groups_count) 二元组。
+    """
+    entry_map: dict[str, dict[str, Any]] = {
+        e.get("server_filename", ""): e for e in entries if e.get("server_filename")
+    }
+    candidates: list[DedupCandidate] = []
+    orphan_groups: dict[tuple[str, str, bool], list[tuple[int, dict[str, Any]]]] = defaultdict(list)
+
+    for e in entries:
+        fname = e.get("server_filename", "")
+        if not fname:
+            continue
+        isdir = e.get("isdir") == 1
+        path = e.get("path") or f"{dir_path.rstrip('/')}/{fname}"
+        size = int(e.get("size") or 0)
+
+        # 1. 检测空目录（若启用）
+        if include_empty and isdir:
+            is_empty = False
+            if mgr is not None:
+                try:
+                    sub_entries = mgr.list_dir(path, limit=1)
+                    if len(sub_entries) == 0:
+                        is_empty = True
+                except Exception as ex:
+                    logger.debug("探查目录是否为空失败 [%s]: %s", path, ex)
+            if is_empty:
+                candidates.append(
+                    DedupCandidate(
+                        path=path,
+                        name=fname,
+                        isdir=True,
+                        size=0,
+                        reason="空目录 (0 项)",
+                        clean_name=fname,
+                    )
+                )
+                continue
+
+        # 2. 匹配冲突副本正则 (1), (2) ...
+        m = CONFLICT_SUFFIX_PATTERN.match(fname)
+        if not m:
+            continue
+
+        base = m.group("base").rstrip(" ._-")
+        idx = int(m.group("index"))
+        ext = m.group("ext") or ""
+        clean_name = f"{base}{ext}" if not isdir else base
+
+        # 检查同目录下是否存在未带序号的主条目
+        if clean_name in entry_map and entry_map[clean_name].get("isdir") == e.get("isdir"):
+            primary = entry_map[clean_name]
+            if not isdir:
+                if size == int(primary.get("size") or 0):
+                    reason = f"存在同名主文件 '{clean_name}' 且大小一致 ({idx})"
+                else:
+                    reason = f"存在同名主文件 '{clean_name}' (序号冲突副本 ({idx}))"
+            else:
+                reason = f"存在同名主目录 '{clean_name}' (冲突副本 ({idx}))"
+
+            candidates.append(
+                DedupCandidate(
+                    path=path,
+                    name=fname,
+                    isdir=isdir,
+                    size=size,
+                    reason=reason,
+                    clean_name=clean_name,
+                    primary_path=primary.get("path"),
+                )
+            )
+        else:
+            orphan_groups[(base, ext, isdir)].append((idx, e))
+
+    # 3. 处理无主冲突副本组
+    orphan_groups_count = 0
+    for (base, ext, isdir), group in orphan_groups.items():
+        if len(group) > 1:
+            orphan_groups_count += 1
+            if include_orphans:
+                # 排序保留序号最小者，更高序号作为冗余候选
+                sorted_group = sorted(group, key=lambda x: x[0])
+                kept_idx, kept_entry = sorted_group[0]
+                kept_name = kept_entry.get("server_filename", "")
+                clean_name = f"{base}{ext}" if not isdir else base
+                for idx, item in sorted_group[1:]:
+                    item_path = item.get("path") or f"{dir_path.rstrip('/')}/{item.get('server_filename')}"
+                    item_name = item.get("server_filename", "")
+                    candidates.append(
+                        DedupCandidate(
+                            path=item_path,
+                            name=item_name,
+                            isdir=isdir,
+                            size=int(item.get("size") or 0),
+                            reason=f"无主条目，同组保留最低序号 '{kept_name}' (冗余副本 ({idx}))",
+                            clean_name=clean_name,
+                            primary_path=kept_entry.get("path"),
+                        )
+                    )
+
+    return candidates, orphan_groups_count
+
+
+def plan_dedup(
+    dir_path: str,
+    mgr: FileManager,
+    recursive: bool = False,
+    include_orphans: bool = False,
+    include_empty: bool = False,
+) -> DedupPlan:
+    """扫描指定网盘目录并规划冲突副本治理方案。
+
+    Args:
+        dir_path: 网盘目标目录。
+        mgr: FileManager 实例。
+        recursive: 是否递归扫描所有子目录。
+        include_orphans: 是否处理无主冲突副本组（保留 (1)，清理 (2)+）。
+        include_empty: 是否清理空目录。
+
+    Returns:
+        DedupPlan 规划结果对象。
+    """
+    clean_dir = "/" + dir_path.strip("/") if dir_path != "/" else "/"
+    logger.info("开始扫描冲突副本: target=%s, recursive=%s", clean_dir, recursive)
+
+    if not recursive:
+        entries = mgr.list_dir(clean_dir)
+        candidates, orphan_count = scan_directory_duplicates(
+            clean_dir,
+            entries,
+            include_orphans=include_orphans,
+            include_empty=include_empty,
+            mgr=mgr,
+        )
+        total_size = sum(c.size for c in candidates)
+        return DedupPlan(
+            target_dir=clean_dir,
+            candidates=candidates,
+            total_size=total_size,
+            scanned_count=len(entries),
+            orphan_groups_count=orphan_count,
+        )
+
+    # 递归模式：通过 DFS walk 遍历全子树并按父目录分组治理
+    entries, errors = mgr.walk(clean_dir)
+    by_parent: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    all_dir_paths: set[str] = set()
+
+    for _, entry in entries:
+        p = entry.get("path", "")
+        if entry.get("isdir") == 1:
+            all_dir_paths.add(p)
+        parent = os.path.dirname(p) or "/"
+        by_parent[parent].append(entry)
+
+    all_candidates: list[DedupCandidate] = []
+    total_orphan_count = 0
+
+    # 逐目录检测冲突副本
+    for parent_dir, dir_entries in by_parent.items():
+        cand, orph = scan_directory_duplicates(
+            parent_dir,
+            dir_entries,
+            include_orphans=include_orphans,
+            include_empty=False,  # 递归模式下空目录统一在下方处理
+            mgr=None,
+        )
+        all_candidates.extend(cand)
+        total_orphan_count += orph
+
+    # 递归模式检测空目录（若开启）
+    if include_empty:
+        non_empty_parents = set(by_parent.keys())
+        for dpath in all_dir_paths:
+            # 若一个目录不在任何条目的父目录集合中，且自身不是由已标记候选构成的
+            if dpath not in non_empty_parents:
+                dname = os.path.basename(dpath)
+                all_candidates.append(
+                    DedupCandidate(
+                        path=dpath,
+                        name=dname,
+                        isdir=True,
+                        size=0,
+                        reason="空目录 (0 项)",
+                        clean_name=dname,
+                    )
+                )
+
+    total_size = sum(c.size for c in all_candidates)
+    return DedupPlan(
+        target_dir=clean_dir,
+        candidates=all_candidates,
+        total_size=total_size,
+        scanned_count=len(entries),
+        orphan_groups_count=total_orphan_count,
+    )
+
+
+def execute_dedup(
+    plan: DedupPlan,
+    mgr: FileManager,
+    staging_dir: str | None = None,
+    delete: bool = False,
+    batch_size: int = 50,
+) -> dict[str, int]:
+    """执行重复项治理计划（移动到暂存目录或直接删除）。
+
+    Args:
+        plan: 治理计划。
+        mgr: FileManager 实例。
+        staging_dir: 隔离暂存目录路径（若指定则批量移动至该目录）。
+        delete: 若为 True 则直接移入网盘回收站。
+        batch_size: 每批次提交上限（默认 50）。
+
+    Returns:
+        包含 'moved' 和 'deleted' 数量的字典。
+    """
+    if not plan.candidates:
+        return {"moved": 0, "deleted": 0}
+
+    if staging_dir:
+        clean_staging = "/" + staging_dir.strip("/")
+        # 确保隔离目录存在
+        try:
+            mgr.mkdir(clean_staging)
+        except FileManagerError:
+            pass
+
+        items_to_move = [
+            (c.path, clean_staging, c.name)
+            for c in plan.candidates
+        ]
+        logger.info("正在批量移动 %d 个冲突副本至 %s", len(items_to_move), clean_staging)
+        mgr.batch_move(items_to_move, batch_size=batch_size)
+        return {"moved": len(items_to_move), "deleted": 0}
+
+    if delete:
+        paths_to_delete = [c.path for c in plan.candidates]
+        logger.info("正在批量删除 %d 个冲突副本入回收站", len(paths_to_delete))
+        mgr.batch_delete(paths_to_delete, batch_size=batch_size)
+        return {"moved": 0, "deleted": len(paths_to_delete)}
+
+    return {"moved": 0, "deleted": 0}

bdpan_cli/downloader.py

@@ -0,0 +1,178 @@
+"""Downloader: 百度网盘文件直链提取与多协议/分块断点续传下载引擎。"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import time
+import urllib.request
+from pathlib import Path
+from typing import Any, Callable
+
+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__)
+
+# 官方防盗链/限速必需请求头
+BAIDU_PAN_UA = "pan.baidu.com"
+CHUNK_READ_SIZE = 256 * 1024  # 256KB 缓冲区
+
+
+class DownloadError(RuntimeError):
+    """文件下载或直链获取异常基类。"""
+
+
+class Downloader:
+    """网盘文件直链提取与断点续传下载器。"""
+
+    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_dlink(self, remote_path: str) -> dict[str, Any]:
+        """获取单个网盘文件的真实下载直链 (dlink) 与元数据。
+
+        Args:
+            remote_path: 网盘文件绝对路径。
+
+        Returns:
+            条目元数据字典，包含 dlink、fs_id、size、md5、server_filename 等。
+
+        Raises:
+            DownloadError: 当文件不存在、为目录或接口返回异常时抛出。
+        """
+        info = self._file_manager.get_file_info(remote_path)
+        if not info:
+            raise DownloadError(f"网盘文件不存在: {remote_path}")
+        if info.get("isdir") == 1:
+            raise DownloadError(f"目标为目录，不支持直接获取直链下载: {remote_path}")
+
+        fs_id = info["fs_id"]
+        try:
+            res = self._multimedia_api.xpanmultimediafilemetas(
+                access_token=self.access_token,
+                fsids=json.dumps([fs_id]),
+                dlink="1",
+            )
+        except ApiException as e:
+            raise DownloadError(f"获取直链 API 异常 [{remote_path}]: {e.status} {e.body}") from e
+
+        if not isinstance(res, dict) or res.get("errno") != 0:
+            raise DownloadError(f"获取直链失败 [{remote_path}]: errno={res.get('errno', '?')}")
+
+        entries = res.get("list") or []
+        if not entries:
+            raise DownloadError(f"获取直链返回空列表 [{remote_path}]")
+
+        meta = entries[0]
+        if not meta.get("dlink"):
+            raise DownloadError(f"未能解析到有效直链 [{remote_path}]")
+
+        # 合并 path 与 server_filename
+        meta["path"] = remote_path
+        meta["server_filename"] = info.get("server_filename", os.path.basename(remote_path))
+        return meta
+
+    def download_file(
+        self,
+        remote_path: str,
+        local_dest: str | Path,
+        overwrite: bool = False,
+        progress: Callable[[dict[str, Any]], None] | None = None,
+    ) -> str:
+        """下载网盘文件至本地，支持断点续传与 User-Agent 防盗链穿透。
+
+        Args:
+            remote_path: 网盘文件路径。
+            local_dest: 本地目标文件路径或目标目录。
+            overwrite: 若本地目标已存在是否覆盖。
+            progress: 进度回调函数，接收 phase, downloaded, total, speed 等事件。
+
+        Returns:
+            本地最终完整文件路径。
+        """
+        meta = self.get_dlink(remote_path)
+        dlink = meta["dlink"]
+        total_size = meta.get("size", 0)
+        filename = meta.get("server_filename") or os.path.basename(remote_path)
+
+        local_dest_path = Path(local_dest).resolve()
+        if local_dest_path.is_dir():
+            target_file = local_dest_path / filename
+        else:
+            target_file = local_dest_path
+
+        if target_file.exists() and not overwrite:
+            if target_file.stat().st_size == total_size:
+                logger.info("本地已存在同名且大小一致的文件，跳过下载: %s", target_file)
+                return str(target_file)
+            raise DownloadError(f"本地文件已存在且未开启 overwrite: {target_file}")
+
+        target_file.parent.mkdir(parents=True, exist_ok=True)
+        tmp_file = target_file.with_name(target_file.name + ".tmp")
+
+        # 断点续传检查
+        current_size = tmp_file.stat().st_size if tmp_file.exists() else 0
+        if current_size > total_size:
+            # 临时文件损坏，重新开始
+            current_size = 0
+            tmp_file.unlink(missing_ok=True)
+
+        req = urllib.request.Request(dlink)
+        req.add_header("User-Agent", BAIDU_PAN_UA)
+        if current_size > 0:
+            req.add_header("Range", f"bytes={current_size}-")
+
+        mode = "ab" if current_size > 0 else "wb"
+        downloaded = current_size
+        start_time = time.time()
+        last_report_time = start_time
+
+        try:
+            with urllib.request.urlopen(req, timeout=60) as resp, open(tmp_file, mode) as f:
+                while True:
+                    buf = resp.read(CHUNK_READ_SIZE)
+                    if not buf:
+                        break
+                    f.write(buf)
+                    downloaded += len(buf)
+
+                    now = time.time()
+                    if progress and (now - last_report_time >= 0.5 or downloaded == total_size):
+                        elapsed = now - start_time
+                        speed = (downloaded - current_size) / elapsed if elapsed > 0 else 0
+                        progress({
+                            "phase": "download",
+                            "downloaded": downloaded,
+                            "total": total_size,
+                            "speed": speed,
+                            "filename": filename,
+                        })
+                        last_report_time = now
+        except Exception as e:
+            raise DownloadError(f"下载传输异常 [{remote_path}]: {e}") from e
+
+        # 校验下载完整性
+        if total_size > 0 and downloaded < total_size:
+            raise DownloadError(f"下载不完整 [{downloaded}/{total_size} 字节]，已保留临时文件供续传: {tmp_file}")
+
+        # 原子重命名为正式文件
+        tmp_file.replace(target_file)
+        return str(target_file)
+
+    @staticmethod
+    def generate_export_command(dlink: str, filename: str, style: str = "aria2") -> str:
+        """生成便于外部工具（aria2c 或 curl）高速下载的命令。"""
+        if style.lower() == "curl":
+            return f'curl -C - -H "User-Agent: {BAIDU_PAN_UA}" -o "{filename}" "{dlink}"'
+        # 默认 aria2
+        return (
+            f'aria2c -c -s16 -x16 --header="User-Agent: {BAIDU_PAN_UA}" '
+            f'"{dlink}" -o "{filename}"'
+        )