Files
lookingWeb/clean_seed_extras.py
cat-shark 827bbb6b6a feat: 新增种子目录清理脚本与配套 skill
主程序只能把 magnet 交给 Transmission,无法挑选文件,种子内的广告
(*.url、宣传页、样片/预告)会一并下载,同一部作品还会被多个发布站各下一份。
新增离线清理脚本处理下载完成后的目录。

clean_seed_extras.py:
- 保留:>=100MB 的视频(40+ 扩展名;无扩展名时读文件头嗅探)、字幕
  (含 .srt.old-<日期> 备份)、与同目录视频同名的海报、folder.jpg 等通用封面
- 删除:其余文件;同目录内内容相同的大视频只保留一份,校验方式为
  sha256(体积 + 头 4MB + 尾 4MB),体积相同但内容不同的不会误删
- 删除后自底向上级联清理空目录(可删到影片级目录,但不删 --root 本身)
- 默认预演,需 --apply 才真正删除;--manifest 导出待删清单供逐段复核
- 其他开关:--no-subtitles/--no-posters/--no-covers/--no-dedupe/--min-size-mb/
  --prefer-source/--keep-empty-dirs/--skip-recent-min

.agents/skills/torrent-download-cleanup:
- 记录完整流程(预演 -> 出清单 -> 用户确认 -> 执行 -> 复核)、保留/删除规则、
  去重策略、代码维护注意(decide() 必须是 视频 -> 去重 -> 海报匹配 的顺序)
- 附只读盘点脚本 find_missing_torrents.py:找出 Transmission 中数据已不在磁盘
  的任务(自包含,只用 requests)

tests/test_clean_seed_extras.py: 30 个离线用例(tmp_path 临时目录)
tests/README.md: 补充脚本用法与测试说明
2026-10-18 00:54:08 +08:00

590 lines
26 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/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>{level: <7}</level> {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())