#!/usr/bin/env python3 """ 种子下载目录清理脚本:只保留「大体积视频 + 字幕 + 与视频同名的海报」,其余全部删除。 背景: 主程序 (LookingWebMain.py) 只能把 magnet 交给 Transmission,无法挑选文件, 种子里的广告(twojav.com@*.url、宣传页、样片等)会被一起下载下来。本脚本在 下载完成后单独运行,按「文件类型 + 体积」做一次清理,与主程序互不依赖。 保留规则(命中任意一条即保留): 1. 视频: 扩展名属于 VIDEO_EXTS 且体积 >= --min-size-mb(默认 100MB)。 扩展名未知/没有扩展名时,读取文件头 (magic bytes) 嗅探,识别为视频容器也保留。 2. 字幕: 文件名中出现字幕扩展名(.srt/.ass/.ssa/.vtt/.sub/.idx/.sup/.smi 等), 含 `xxx.CN.srt.old-20260918` 这类字幕备份。 3. 海报: 图片扩展名,且文件名包含「同目录下某个已保留视频」的文件名主干 (如 `ATID-643 ... 松井日奈子-poster.jpg` 命中同名视频,`OTHER-999-poster.jpg` 不命中)。 4. 通用封面图: `folder.jpg` / `poster.jpg` / `cover.jpg` / `backdrop.jpg` / `fanart.jpg` 等媒体库约定的封面名,且**同目录下确实还有保留的视频**(避免留下只有封面的空壳目录)。 不想要这一类加 `--no-covers`。 删除规则: 以上四条都不命中的文件一律删除;另外**同一目录内内容相同的大视频只保留一份** (同一部作品被多个发布站各下一份时,文件名只差站点前缀,见 `--no-dedupe`)。 删除完成后再自底向上清理空目录:子目录先删,父目录随即变空则继续向上删 (例如 `影片目录/xxx.trickplay/320 - 10x10/` 会整条链删掉), 包括整个影片级目录;但**不会删除 --root 本身**。 安全性: - 默认是**预演模式**,只统计和打印,不删除任何文件;确认无误后加 --apply 才真正删除。 - 不跟随符号链接目录;删除符号链接时只删链接本身,不会删到链接指向的目标。 - 只处理 --root 目录内部;空目录清理不会删除 root 本身。 用法: python clean_seed_extras.py # 预演(默认,安全) python clean_seed_extras.py --manifest clean_manifest.txt # 导出完整待删清单 python clean_seed_extras.py --apply # 真正删除 python clean_seed_extras.py --apply --no-dedupe # 不做重复视频去重 python clean_seed_extras.py --apply --list-all # 删除并列出每个被删文件 python clean_seed_extras.py --apply --no-subtitles # 连字幕一起删,只留视频+海报 python clean_seed_extras.py --apply --no-posters # 不保留海报 python clean_seed_extras.py --min-size-mb 50 # 视频体积阈值改成 50MB """ import argparse import hashlib import os import re import sys import time from collections import Counter from dataclasses import dataclass from loguru import logger # 默认清理目标:本机下载目录 DEFAULT_ROOT = "/mnt/fnOS/123/" # “大视频”阈值(MB)。>= 该体积的视频才保留 DEFAULT_MIN_SIZE_MB = 100 # 重复视频指纹读取字节数:只哈希「头部 N + 尾部 N + 体积」 # (大文件全量哈希要读 TB 级数据,不值得;同源发布的同名文件头尾一致即判定重复) DEFAULT_DUP_CHECK_BYTES = 4 * 1024 * 1024 # 站点发布前缀,如 masex.tv@xxx.mp4、hkbisi.com@xxx.mp4 SITE_PREFIX_RE = re.compile(r"^([^@/\\]{1,40})@") # 视频扩展名(尽量覆盖常见容器/编码格式;扩展名未知时另有文件头嗅探兜底) VIDEO_EXTS = { # 常见容器 ".mp4", ".m4v", ".mkv", ".webm", ".avi", ".wmv", ".asf", ".mov", ".qt", ".flv", ".f4v", ".rm", ".rmvb", ".divx", ".xvid", ".ogv", ".ogm", ".dv", ".3gp", ".3g2", ".mxf", ".vob", ".dat", # 传输流 / 高清录制 ".ts", ".m2ts", ".mts", ".tp", ".trp", # MPEG 系 ".mpg", ".mpeg", ".mpe", ".m1v", ".m2v", ".mpv", # 裸流 / 编码名 ".h264", ".h265", ".hevc", ".av1", ".vc1", ".avs", # 光盘镜像(多为原盘/BDMV 打包,常含正片) ".iso", ".img", ".ifo", } # 字幕:用「文件名中出现字幕扩展名」判断,这样 xxx.srt.old-20260918 这类备份也会保留 SUBTITLE_IN_NAME_RE = re.compile( r"\.(srt|ass|ssa|vtt|sub|idx|sup|smi|sami|ttml|dfxp|sbv|usf)(\.|$)", re.IGNORECASE, ) # 图片(海报候选) IMAGE_EXTS = {".jpg", ".jpeg", ".jfif", ".png", ".webp", ".bmp", ".gif", ".tbn"} # 媒体库通用封面图名(Jellyfin/Emby/Kodi 约定)。这些图不包含视频文件名, # 但会被当作影片封面使用,因此默认保留(仅当同目录还有保留的视频时)。 COVER_IMAGE_NAMES = { "folder.jpg", "folder.png", "folder.jpeg", "poster.jpg", "poster.png", "poster.jpeg", "cover.jpg", "cover.png", "cover.jpeg", "default.jpg", "default.png", "movie.jpg", "movie.png", "show.jpg", "show.png", "backdrop.jpg", "backdrop.png", "fanart.jpg", "fanart.png", "banner.jpg", "banner.png", "thumb.jpg", "thumb.png", "landscape.jpg", "landscape.png", "disc.jpg", "disc.png", "logo.png", "clearlogo.png", "clearart.png", } # 视频文件头嗅探只读取的字节数 SNIFF_BYTES = 512 @dataclass class Entry: """扫描到的单个文件""" path: str dir: str name: str size: int ext: str is_link: bool keep: bool = False reason: str = "" dup_of: str = "" # 被判定为重复时,记录保留的那一份的路径 def site_prefix(name): """取文件名开头的站点前缀(无前缀返回空字符串)""" match = SITE_PREFIX_RE.match(name) return match.group(1).lower() if match else "" def file_fingerprint(path, check_bytes): """文件指纹 = sha256(体积 + 头部 check_bytes + 尾部 check_bytes) 不读中间部分,避免为了校验重复去读 TB 级数据;对“同一源发布两次”的文件足够可靠。 """ size = os.path.getsize(path) digest = hashlib.sha256() digest.update(str(size).encode()) with open(path, "rb") as fp: digest.update(fp.read(check_bytes)) if size > check_bytes * 2: fp.seek(-check_bytes, os.SEEK_END) digest.update(fp.read(check_bytes)) return digest.hexdigest() def plan_duplicate_videos(entries, min_size, check_bytes, prefer_source=()): """找出同目录内内容相同的大视频,返回 [(保留项, [重复项, ...]), ...] 先按「同目录 + 同体积」分组(几乎不耗 IO),再对每组算指纹确认内容一致, 指纹不同(体积相同但内容不同)的一律不动。 保留哪一份(依次比较): 1. 无站点前缀(文件名最干净); 2. --prefer-source 里列出的站点; 3. 同目录内该前缀出现次数多的(与目录内命名保持一致); 4. 文件名短、字典序。 """ prefer_source = tuple(p.lower() for p in prefer_source) # 同目录内各站点前缀的出现次数(仅统计保留的视频) prefix_count = {} for entry in entries: if entry.keep and entry.reason.startswith("视频"): key = (entry.dir, site_prefix(entry.name)) prefix_count[key] = prefix_count.get(key, 0) + 1 def rank(entry): prefix = site_prefix(entry.name) if not prefix: order = 0 elif prefix in prefer_source: order = 1 + prefer_source.index(prefix) else: order = 1 + len(prefer_source) popularity = -prefix_count.get((entry.dir, prefix), 0) return (order, popularity, len(entry.name), entry.name.casefold()) # 候选:会被保留的视频(跳过符号链接,不拿链接做删除依据) groups = {} for entry in entries: if entry.keep and entry.reason.startswith("视频") \ and entry.size >= min_size and not entry.is_link: groups.setdefault((entry.dir, entry.size), []).append(entry) plans = [] for items in groups.values(): if len(items) < 2: continue by_fingerprint = {} for entry in items: try: fingerprint = file_fingerprint(entry.path, check_bytes) except OSError as err: logger.warning("无法读取文件内容,跳过去重: {} ({})", entry.path, err) continue by_fingerprint.setdefault(fingerprint, []).append(entry) for same in by_fingerprint.values(): if len(same) < 2: continue same.sort(key=rank) plans.append((same[0], same[1:])) return plans def looks_like_video(path): """按文件头判断是否为视频容器(用于扩展名未知/无扩展名的大文件) 只做「像视频」的保守判断:无法确定时返回 False(宁可留下垃圾,也不误删视频)。 """ try: with open(path, "rb") as fp: head = fp.read(SNIFF_BYTES) except OSError: return False if len(head) >= 12 and head[4:8] == b"ftyp": # mp4 / mov / m4v / 3gp return True if head.startswith(b"\x1a\x45\xdf\xa3"): # mkv / webm (EBML) return True if head.startswith(b"RIFF") and head[8:12] == b"AVI ": # avi return True if head.startswith(b"FLV\x01"): # flv return True if head.startswith(b"\x30\x26\xb2\x75\x8e\x66\xcf\x11"): # asf / wmv return True if head.startswith(b"\x00\x00\x01\xba"): # mpeg program stream return True if head.startswith(b"\x00\x00\x01\xb3"): # mpeg video es return True if head.startswith(b".RMF"): # rm / rmvb return True # mpeg-ts:同步字节 0x47,间隔 188 再校验一次,避免误判 if len(head) > 188 and head[0:1] == b"\x47" and head[188:189] == b"\x47": return True return False def collect(root, skip_recent_min=0): """遍历 root,收集文件与目录清单(不跟随符号链接目录)""" entries = [] dirs = [] now = time.time() for dirpath, dirnames, filenames in os.walk(root, followlinks=False): dirs.append(dirpath) # 符号链接目录不进入,避免跨出目标目录删除外部数据 dirnames[:] = [d for d in dirnames if not os.path.islink(os.path.join(dirpath, d))] for name in filenames: path = os.path.join(dirpath, name) is_link = os.path.islink(path) try: st = os.stat(path) # 跟随链接取体积 size, mtime = st.st_size, st.st_mtime except OSError as err: logger.warning("无法读取文件信息,跳过: {} ({})", path, err) continue if skip_recent_min and now - mtime < skip_recent_min * 60: logger.warning("文件最近被修改过,跳过(可能仍在下载): {}", path) continue entries.append(Entry(path, dirpath, name, size, os.path.splitext(name)[1].lower(), is_link)) return entries, dirs def decide(entries, min_size, keep_subtitles, keep_posters, keep_covers=True, dedupe=True, check_bytes=DEFAULT_DUP_CHECK_BYTES, prefer_source=()): """标记每个文件保留/删除(就地修改 entries) 处理顺序:先定下要保留的视频 → 再去重 → 最后才匹配字幕/海报/封面。 去重必须在海报匹配之前,否则「被删副本的同名海报」会留到下一轮才被清掉, 脚本就不是一次收敛。 Args: keep_covers: 是否保留 folder.jpg / poster.jpg 等通用封面图 dedupe: 是否对同目录内内容相同的大视频去重(只留一份) """ # 第一轮:找出所有达到阈值的视频 for entry in entries: if entry.size < min_size: continue if entry.ext in VIDEO_EXTS: entry.keep, entry.reason = True, "视频" elif looks_like_video(entry.path): entry.keep, entry.reason = True, "视频(按文件头识别)" # 第二轮:同目录内内容相同的大视频只保留一份 if dedupe: for kept, duplicates in plan_duplicate_videos(entries, min_size, check_bytes, prefer_source): for entry in duplicates: entry.keep = False entry.reason = "重复视频" entry.dup_of = kept.path logger.info("重复视频: 保留 {},删除 {} 个内容相同的副本({})", kept.name, len(duplicates), human_size(sum(e.size for e in duplicates))) # 去重完成后,按「真正留下来的视频」建索引,供海报/封面匹配 video_stems = {} for entry in entries: if entry.keep and entry.reason.startswith("视频"): video_stems.setdefault(entry.dir, []).append(os.path.splitext(entry.name)[0].casefold()) # 长主干优先,避免短名字误命中别的海报 for stems in video_stems.values(): stems.sort(key=len, reverse=True) # 第三轮:字幕、同名海报、通用封面 for entry in entries: if entry.keep or entry.reason: # 已定案(保留或已判为重复视频)的不再覆盖 continue if keep_subtitles and SUBTITLE_IN_NAME_RE.search(entry.name): entry.keep, entry.reason = True, "字幕" continue if keep_posters and entry.ext in IMAGE_EXTS: # 同目录必须还有保留的视频,否则封面图本身也成了无主垃圾 if video_stems.get(entry.dir): if keep_covers and entry.name.casefold() in COVER_IMAGE_NAMES: entry.keep, entry.reason = True, "通用封面" continue stem = os.path.splitext(entry.name)[0].casefold() if any(v in stem for v in video_stems[entry.dir]): entry.keep, entry.reason = True, "海报" continue entry.reason = "待删除" def delete_files(entries): """删除标记为待删的文件,返回 (删除数, 释放字节, 失败数)""" deleted = freed = failed = 0 for entry in entries: if entry.keep: continue try: os.remove(entry.path) # 符号链接只删链接本身 except OSError as err: failed += 1 logger.warning("删除失败: {} ({})", entry.path, err) continue deleted += 1 freed += entry.size logger.debug("已删除: {}", entry.path) return deleted, freed, failed def plan_empty_dirs(entries, dirs, root): """计算删除后会被清空的目录(自底向上级联,不含 root 本身) 逻辑上与真实删除一致:子目录先判定,父目录在子目录全被清空后也随之清空, 因此能一路级联到影片级目录。预演(--manifest)和执行使用同一份结果。 """ real_root = os.path.realpath(root) has_kept = {e.dir for e in entries if e.keep} children = {} for d in dirs: if os.path.realpath(d) != real_root and not os.path.islink(d): children.setdefault(os.path.dirname(d), []).append(d) alive = set() for d in sorted(dirs, key=lambda p: p.count(os.sep), reverse=True): if d in has_kept or any(ch in alive for ch in children.get(d, ())): alive.add(d) return [d for d in dirs if d not in alive and os.path.realpath(d) != real_root and not os.path.islink(d)] def remove_empty_dirs(paths): """删除 plan_empty_dirs 规划出的空目录(保留 root 本身)""" removed = 0 for path in sorted(paths, key=lambda p: p.count(os.sep), reverse=True): try: if not os.listdir(path): # 文件删除失败时目录不为空,这里会自然跳过 os.rmdir(path) removed += 1 logger.debug("已删除空目录: {}", path) except OSError as err: logger.debug("空目录清理跳过: {} ({})", path, err) return removed def write_manifest(path, entries, empty_dirs, root, min_size_mb): """把待删清单写入文件,便于逐段复核(不执行任何删除)""" to_delete = [e for e in entries if not e.keep] duplicates = [e for e in to_delete if e.dup_of] others = [e for e in to_delete if not e.dup_of] buckets = [ ("A. 小体积视频(未达阈值)", [e for e in others if e.ext in VIDEO_EXTS]), ("B. 无扩展名非视频(BT 填充 .pad 等)", [e for e in others if not e.ext]), ("C. 图片(非同名海报/封面)", [e for e in others if e.ext in IMAGE_EXTS]), ("D. 广告/文本/其他", [e for e in others if e.ext and e.ext not in VIDEO_EXTS and e.ext not in IMAGE_EXTS]), ] total_files = len(to_delete) total_bytes = sum(e.size for e in to_delete) lines = [ "# clean_seed_extras 待删除清单(本文件只是清单,不代表已删除)", f"# 生成时间: {time.strftime('%Y-%m-%d %H:%M:%S')}", f"# 根目录 : {root}", f"# 视频阈值: >= {min_size_mb:g} MB", f"# 合计 : {total_files} 个文件({human_size(total_bytes)}) + {len(empty_dirs)} 个空目录", "", ] for title, items in buckets: items.sort(key=lambda e: -e.size) lines.append(f"===== {title} — {len(items)} 个," f"{human_size(sum(e.size for e in items))} =====") lines.extend(f"{e.size:>13} {e.path}" for e in items) lines.append("") # 重复视频:按“保留哪一份”分组展示,方便核对 groups = {} for entry in duplicates: groups.setdefault(entry.dup_of, []).append(entry) lines.append(f"===== E. 重复大视频(同目录内容相同,每组只保留一份) — " f"{len(duplicates)} 个,{human_size(sum(e.size for e in duplicates))} =====") for kept_path, dups in sorted(groups.items()): dups.sort(key=lambda e: -e.size) lines.append(f"--- 保留: {kept_path} (删除 {len(dups)} 份副本," f"释放 {human_size(sum(e.size for e in dups))})") lines.extend(f"{e.size:>13} {e.path}" for e in dups) lines.append("") lines.append(f"===== F. 待删除的空目录 — {len(empty_dirs)} 个 =====") lines.extend(f"DIR {d}" for d in sorted(empty_dirs)) with open(path, "w", encoding="utf-8") as fp: fp.write("\n".join(lines) + "\n") logger.info("待删清单已写入: {}({} 个文件 + {} 个空目录,{})", os.path.abspath(path), total_files, len(empty_dirs), human_size(total_bytes)) return path def human_size(num_bytes): """字节数转可读体积""" value = float(num_bytes) for unit in ("B", "KB", "MB", "GB", "TB"): if value < 1024 or unit == "TB": return f"{value:.1f} {unit}" value /= 1024 return f"{value:.1f} TB" def print_summary(entries, root, min_size_mb, dry_run, deleted, freed, failed, removed_dirs, list_all, list_limit): """打印统计结果""" keep_counter = Counter(e.reason for e in entries if e.keep) del_counter = Counter(e.ext or "(无扩展名)" for e in entries if not e.keep) duplicates = [e for e in entries if not e.keep and e.dup_of] print("\n" + "=" * 68) print(f"目录: {root}") print(f"视频阈值: >= {min_size_mb:g} MB") print("-" * 68) print(f"扫描文件总数: {len(entries)} 保留: {len(entries) - deleted} 删除: {deleted}") if keep_counter: print("保留明细: " + ",".join(f"{k} {v} 个" for k, v in keep_counter.most_common())) if del_counter: print("删除明细(按扩展名): " + ",".join(f"{k} {v} 个" for k, v in del_counter.most_common(10))) if duplicates: kept_groups = {e.dup_of for e in duplicates} print(f"其中重复大视频: {len(duplicates)} 个({human_size(sum(e.size for e in duplicates))})," f"共 {len(kept_groups)} 组,每组保留一份") if not dry_run: print(f"释放空间: {human_size(freed)}" + (f" 删除失败: {failed}" if failed else "")) print(f"清理空目录: {removed_dirs} 个") print("=" * 68) to_delete = [e for e in entries if not e.keep] if dry_run and to_delete: limit = len(to_delete) if list_all else list_limit print(f"待删除文件(最多显示 {limit} 个,实际 {len(to_delete)} 个):") for entry in to_delete[:limit]: print(f" [删] {human_size(entry.size):>10} {entry.path}") if len(to_delete) > limit: print(f" ... 其余 {len(to_delete) - limit} 个已省略(--list-all 可全部显示)") elif list_all: for entry in to_delete: print(f" [已删] {human_size(entry.size):>10} {entry.path}") if dry_run: print("\n>>> 预演模式,未删除任何文件。确认无误后加 --apply 执行:") print(f">>> python {os.path.basename(__file__)} --apply") else: print(f"\n>>> 清理完成,共删除 {deleted} 个文件,释放 {human_size(freed)}。") def build_parser(): parser = argparse.ArgumentParser( description="清理种子下载目录:只保留大体积视频 + 字幕 + 与视频同名的海报", formatter_class=argparse.RawDescriptionHelpFormatter, ) parser.add_argument("--root", default=DEFAULT_ROOT, help=f"清理目标目录(默认 {DEFAULT_ROOT})") parser.add_argument("--min-size-mb", type=float, default=DEFAULT_MIN_SIZE_MB, help=f"视频体积阈值,>= 该值才保留(默认 {DEFAULT_MIN_SIZE_MB})") parser.add_argument("--apply", action="store_true", help="真正执行删除;不加则只预演(默认)") parser.add_argument("--no-subtitles", action="store_true", help="不保留字幕") parser.add_argument("--no-posters", action="store_true", help="不保留任何图片(含同名海报与通用封面)") parser.add_argument("--no-covers", action="store_true", help="只保留与视频同名的海报,删除 folder.jpg/poster.jpg 等通用封面图") parser.add_argument("--no-dedupe", action="store_true", help="不对「同目录内容相同的大视频」去重(默认去重,每组只留一份)") parser.add_argument("--dup-check-bytes", type=int, default=DEFAULT_DUP_CHECK_BYTES, help=f"重复校验读取的字节数(头/尾各读这么多,默认 {DEFAULT_DUP_CHECK_BYTES})") parser.add_argument("--prefer-source", default="", help="优先保留的站点前缀,逗号分隔(如 masex.tv,hkbisi.com)") parser.add_argument("--manifest", metavar="PATH", default=None, help="把待删清单(文件 + 空目录)写入指定文件,便于逐段复核") parser.add_argument("--keep-empty-dirs", action="store_true", help="保留删除后变空的目录(默认会级联删除空目录,但不删 root 本身)") parser.add_argument("--skip-recent-min", type=int, default=0, help="跳过最近 N 分钟内修改过的文件(默认 0,不跳过)") parser.add_argument("--list-all", action="store_true", help="列出全部待删/已删文件") parser.add_argument("--list-limit", type=int, default=200, help="预演时最多显示多少条待删文件(默认 200)") parser.add_argument("--quiet", action="store_true", help="只输出统计,不输出逐条明细") return parser def main(argv=None): args = build_parser().parse_args(argv) logger.remove() logger.add(sys.stderr, format="{level: <7} {message}", level="INFO") root = os.path.abspath(os.path.expanduser(args.root)) if not os.path.isdir(root): logger.error("目标目录不存在或不是目录: {}", root) return 2 min_size = int(args.min_size_mb * 1024 * 1024) dry_run = not args.apply print("=" * 68) print("种子目录清理" + ("(预演模式,不会删除任何文件)" if dry_run else "(删除模式)")) print("=" * 68) print(f"目标目录 : {root}") print(f"视频阈值 : >= {args.min_size_mb:g} MB") print(f"保留字幕 : {'否' if args.no_subtitles else '是'}") print(f"保留同名海报: {'否' if args.no_posters else '是'}") print(f"保留通用封面: {'否' if (args.no_posters or args.no_covers) else '是'}") print(f"重复视频去重: {'否' if args.no_dedupe else '是'}") print(f"清理空目录 : {'否' if args.keep_empty_dirs else '是'}") entries, dirs = collect(root, skip_recent_min=args.skip_recent_min) logger.info("扫描完成:{} 个文件,{} 个目录", len(entries), len(dirs)) prefer_source = tuple(p.strip() for p in args.prefer_source.split(",") if p.strip()) decide(entries, min_size, keep_subtitles=not args.no_subtitles, keep_posters=not args.no_posters, keep_covers=not args.no_covers, dedupe=not args.no_dedupe, check_bytes=args.dup_check_bytes, prefer_source=prefer_source) # 空目录先规划后执行:预演/清单/真实删除使用同一份结果 planned_dirs = [] if args.keep_empty_dirs else plan_empty_dirs(entries, dirs, root) if args.manifest: write_manifest(args.manifest, entries, planned_dirs, root, args.min_size_mb) if dry_run: deleted = sum(1 for e in entries if not e.keep) freed = sum(e.size for e in entries if not e.keep) failed = removed_dirs = 0 if args.quiet: args.list_all = False else: deleted, freed, failed = delete_files(entries) removed_dirs = remove_empty_dirs(planned_dirs) if args.quiet: args.list_all = False args.list_limit = 0 print_summary(entries, root, args.min_size_mb, dry_run, deleted, freed, failed, removed_dirs, args.list_all, args.list_limit) return 1 if failed else 0 if __name__ == "__main__": sys.exit(main())