Skip to content

armgit / peach

Public Imported from GitHub
0

Peach: Local-first video metadata scraper and media manager.

15.0 KB
Raw Blame
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
文件名净化:清除推广域名、装饰符号、乱码字形与残留噪声。

只做可逆、无歧义的改写。番号使用 Peach 的统一规范:大写、标准连字符、片商番号
至少三位数字;FC2 统一为 ``FC2-PPV-<数字>``。
  * 不动 "xxx.mp4.jpg":那是该 mp4 的缩略图,不是双后缀(真的双后缀只有 2 条)。
  * 不重排标题/不套命名模板:只替换 ledger 已确认的番号片段。

先出 CSV 供人工核对,加 --apply 才落盘;改名同时同步 ledger 的 path/name。

用法:
    python scripts/clean_names.py [--location 来源ID] [--apply]
"""
from __future__ import annotations

import argparse
import sys
import ntpath
import os
import posixpath
import re
import sqlite3
import time
import uuid
from pathlib import Path

PROJECT_ROOT = Path(__file__).resolve().parent.parent
SRC_DIR = PROJECT_ROOT / "src"
if str(SRC_DIR) not in sys.path:
    sys.path.insert(0, str(SRC_DIR))

from peach.review_csv import write_rows
from peach.catalog_rules import is_jav_code, normalise_code_key
from peach.config import DATABASE_PATH, GENERATED_DIR, LOG_DIR
from peach.media_sources import SCANNABLE_LOCATIONS
from peach.organize_templates import clean_filename
from peach.scripting import (
    add_ledger_write_args, open_for_write, open_readonly, verify_after_write,
)

DEFAULT_DB = DATABASE_PATH
DEFAULT_OUT = GENERATED_DIR / "name-clean.csv"
DEFAULT_LOG_DIR = LOG_DIR
_logf = None


def configure_log(log_dir: str | Path) -> None:
    global _logf
    root = Path(log_dir)
    root.mkdir(parents=True, exist_ok=True)
    path = root / time.strftime("clean-names-%Y%m%d-%H%M%S.log")
    _logf = path.open("w", encoding="utf-8", buffering=1)


def log(msg: str) -> None:
    line = f"[{time.strftime('%H:%M:%S')}] {msg}"
    print(line, flush=True)
    if _logf is not None:
        _logf.write(line + "\n")


def close_log() -> None:
    global _logf
    if _logf is not None:
        _logf.close()
        _logf = None


TLD = r"(?:com|net|la|xyz|cc|me|top|vip|club|info|org|tv|app|co|pw|gg|cn)"

# 站点前缀:域名后面常跟 @ - _ 空格,或直接连着广告语
RE_PREFIX = re.compile(
    rf"^\s*[\[\【@]?\s*(?:www\.)?[0-9A-Za-z][-0-9A-Za-z]{{1,30}}\.{TLD}"
    rf"(?:\d{{6,}})?\s*[@\-_\]\】、,,]?\s*", re.I)
# 尾部域名:紧贴扩展名之前
RE_SUFFIX = re.compile(
    rf"[-_@\s]+(?:www\.)?[0-9A-Za-z][-0-9A-Za-z]{{2,25}}\.{TLD}\s*(?=\.[A-Za-z0-9]{{2,4}}$)", re.I)
# 番号后直接黏着的方括号域名:`CJOD-158[fuckbe.com].mp4` 没有分隔符,
# 旧 `RE_SUFFIX` 刻意要求空格/横线,因而漏掉。只删完整括号域名,不碰普通标题括号。
RE_BRACKET_DOMAIN = re.compile(
    rf"[\[【((]\s*(?:www\.)?[0-9A-Za-z][-0-9A-Za-z]{{1,30}}\.{TLD}\s*[\]】))]", re.I)
# 中文推广尾巴(域名已被上面吃掉后剩下的宣传语)
RE_ADCOPY = re.compile(
    r"[-_\s]*(?:全网最火爆成人游戏|成人手游|最新地址|开车地址|每日更新|无码破解|"
    r"免费看片|请记住本站|更多资源|中文成人网站?)[^.]*(?=\.[A-Za-z0-9]{2,4}$)")


def _normalise_code_in_name(name: str, code: str | None,
                            allow_compact_code: bool = False) -> str:
    """只替换 ledger 已确认的番号片段,不从文件名重新猜番号。"""
    canonical = normalise_code_key(code)
    if not is_jav_code(code) and not (
        allow_compact_code and is_jav_code(canonical)
    ):
        return name
    if canonical.startswith("FC2-PPV-"):
        digits = canonical.rsplit("-", 1)[-1]
        pattern = re.compile(
            rf"(?<![A-Z0-9])FC2(?:[-_ ]?PPV)?[-_ ]*0*{re.escape(digits)}(?!\d)", re.I,
        )
    else:
        amateur = re.fullmatch(r"(\d{3})?([A-Z]+)-(\d+)", canonical)
        dated = re.fullmatch(r"(\d{6})([-_])(\d{2,4})", canonical)
        if amateur:
            prefix, letters, digits = amateur.groups()
            number = str(int(digits))
            pattern = re.compile(
                rf"(?<![A-Z0-9]){re.escape(prefix or '')}{re.escape(letters)}"
                rf"[-_ ]?0*{re.escape(number)}(?!\d)", re.I,
            )
        elif dated:
            left, separator, right = dated.groups()
            # 只补齐缺分隔符或用空格分隔的写法。日期式番号的 `-` 与 `_` 是两个片商
            # (`catalog_rules._CODE_DATE`),把文件名里的另一种改写成 ledger 这一种,
            # 就是拿一部片的名字盖掉另一部的证据。
            pattern = re.compile(
                rf"(?<!\d){re.escape(left)}(?:{re.escape(separator)}| )?"
                rf"{re.escape(right)}(?!\d)",
            )
        else:
            return name
    return pattern.sub(canonical, name, count=1)


def propose(name: str, code: str | None = None,
            allow_compact_code: bool = False) -> str:
    """返回净化后的文件名;无需改动则原样返回。"""
    stem, dot, ext = name.rpartition(".")
    if not dot or not stem:           # 没有扩展名、或形如 ".mp4" 的空主干,都不碰
        return name

    new = RE_PREFIX.sub("", clean_filename(name), count=1)
    new, bracket_domains = RE_BRACKET_DOMAIN.subn("", new)
    new = RE_SUFFIX.sub("", new)
    new = RE_ADCOPY.sub("", new)
    new = _normalise_code_in_name(new, code, allow_compact_code)

    # 同类双后缀 .mp4.mp4(.mp4.jpg 这种缩略图命名不算)
    dbl = re.search(r"\.([A-Za-z0-9]{2,4})\.([A-Za-z0-9]{2,4})$", new)
    if dbl and dbl.group(1).lower() == dbl.group(2).lower():
        new = new[: dbl.start()] + "." + dbl.group(2)

    # 删除方括号域名后会留下双分隔符或尾分隔符:
    # `标题 - [site.com] - 年份` 应变成 `标题 - 年份`,而不是 `标题 -  - 年份`。
    if bracket_domains:
        new = re.sub(r"[ \t]{2,}", " ", new)
        new = re.sub(r"(?:\s*-\s*){2,}", " - ", new)

    # 首尾空白 / 扩展名前的空格、点和分隔符
    new = new.strip()
    if new != name:
        new = re.sub(r"[\s._\-—]+(?=\.[A-Za-z0-9]{2,4}$)", "", new)
    new = re.sub(r"^[\s._\-—]+", "", new)

    # 净化到只剩扩展名、或只剩 "(1)" 这种序号,说明规则吃过头了,放弃这条
    if not new or new.startswith(".") or new == name:
        return name
    body = os.path.splitext(new)[0]
    if not re.sub(r"[\s()\[\]【】.\-_—]", "", body):
        return name
    # 只剩 "(2)" 这种括号序号,等于把名字删没了
    if re.fullmatch(r"[\s\-_.]*\(\d+\)[\s\-_.]*", body):
        return name
    if os.path.splitext(new)[1].lower() != os.path.splitext(name)[1].lower():
        return name
    return new


FIELDS = ["id", "location", "dir", "old", "new", "old_code", "new_code", "status"]


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="preview or apply conservative filename cleanup")
    add_ledger_write_args(parser, db_default=DEFAULT_DB)
    parser.add_argument("--out", type=Path, default=DEFAULT_OUT)
    parser.add_argument("--log-dir", type=Path, default=DEFAULT_LOG_DIR)
    parser.add_argument("--location", choices=SCANNABLE_LOCATIONS)
    return parser


def write_plan(path: str | Path, plan: list[dict]) -> None:
    target = Path(path)
    write_rows(target, FIELDS, plan)


def verify_backup(backup: Path) -> None:
    """备份是唯一的回退路径,所以要当场校验一遍。

    坏掉的备份比没有备份更糟:它看起来是有的,等到需要它的那天才发现打不开。
    备份本身由 `open_for_write` 用 SQLite 备份 API 落盘(WAL 安全),这里只做验收。
    """
    connection = open_readonly(backup)
    try:
        integrity, foreign_keys = verify_after_write(connection)
    finally:
        connection.close()
    if integrity != "ok" or foreign_keys:
        raise RuntimeError(
            f"备份校验失败:integrity={integrity} foreign_keys={foreign_keys}"
        )


def _numbered_name(name: str, occupied: set[str]) -> tuple[str, bool]:
    """目标撞名时保留两份媒体,用稳定的 ``(n)`` 后缀消歧。"""
    if name.lower() not in occupied:
        return name, False
    stem, ext = os.path.splitext(name)
    index = 2
    while True:
        candidate = f"{stem} ({index}){ext}"
        if candidate.lower() not in occupied:
            return candidate, True
        index += 1


def _path_ops(path: str):
    """按 ledger 路径本身选择 Windows/POSIX 语义,而不是按运行主机选择。"""
    return ntpath if ntpath.splitdrive(path)[0] or "\\" in path else posixpath


def _dirname(path: str) -> str:
    return _path_ops(path).dirname(path)


def _join(directory: str, name: str) -> str:
    return _path_ops(directory).join(directory, name)


def build_plan(rows: list[tuple]) -> list[dict]:
    taken: dict[str, set[str]] = {}
    for _aid, _location, path, name, _code, *_evidence in rows:
        taken.setdefault(_dirname(path).lower(), set()).add(str(name).lower())

    plan: list[dict] = []
    for aid, location, path, name, code, *evidence in rows:
        allow_compact = bool(evidence and evidence[0])
        normalized = normalise_code_key(code)
        canonical = (
            normalized if is_jav_code(code)
            or (allow_compact and is_jav_code(normalized)) else str(code or "")
        )
        proposed = propose(str(name), str(code or ""), allow_compact)
        if proposed == name and canonical == str(code or ""):
            continue
        directory = _dirname(path)
        occupied = taken[directory.lower()]
        occupied.discard(str(name).lower())
        target, suffixed = _numbered_name(proposed, occupied)
        occupied.add(target.lower())
        plan.append({
            "id": aid, "location": location, "dir": directory,
            "old": name, "new": target, "old_code": code or "",
            "new_code": canonical, "status": "ready-suffixed" if suffixed else "ready",
        })
    return plan


def _rename_path(source: str, destination: str) -> None:
    """Windows 只改大小写时通过同目录临时名,避免把源误判成目标撞名。"""
    if source != destination and source.lower() == destination.lower():
        staging = source + f".peach-rename-{uuid.uuid4().hex}.tmp"
        os.rename(source, staging)
        try:
            os.rename(staging, destination)
        except Exception:
            os.rename(staging, source)
            raise
    else:
        os.rename(source, destination)


def _database_health(connection: sqlite3.Connection) -> tuple[str, int, int]:
    integrity = str(connection.execute("PRAGMA integrity_check").fetchone()[0])
    foreign_keys = len(connection.execute("PRAGMA foreign_key_check").fetchall())
    assets = int(connection.execute("SELECT count(*) FROM asset").fetchone()[0])
    return integrity, foreign_keys, assets


def run(args_ns: argparse.Namespace) -> int:
    conn = open_for_write(args_ns)
    where = "WHERE name IS NOT NULL"
    sql_args: list = []
    if args_ns.location:
        where += " AND location = ?"
        sql_args.append(args_ns.location)
    asset_columns = {row[1] for row in conn.execute("PRAGMA table_info(asset)")}
    evidence_terms = []
    if "studio" in asset_columns:
        evidence_terms.append("COALESCE(trim(studio),'')<>''")
    if "release_date" in asset_columns:
        evidence_terms.append("COALESCE(trim(release_date),'')<>''")
    tables = {row[0] for row in conn.execute(
        "SELECT name FROM sqlite_master WHERE type='table'"
    )}
    if {"asset_entity", "entity"}.issubset(tables):
        evidence_terms.append(
            "EXISTS(SELECT 1 FROM asset_entity ae JOIN entity e ON e.id=ae.entity_id "
            "WHERE ae.asset_id=asset.id AND e.kind IN ('performer','studio','series'))"
        )
    release_evidence = " OR ".join(evidence_terms) or "0"
    rows = conn.execute(
        f"SELECT id,location,path,name,code,CASE WHEN {release_evidence} "
        f"THEN 1 ELSE 0 END FROM asset {where}", sql_args,
    ).fetchall()
    log(f"扫描 {len(rows)} 条" + (f"(location={args_ns.location})" if args_ns.location else ""))

    plan = build_plan(rows)
    ready = [p for p in plan if p["status"].startswith("ready")]
    suffixed = sum(p["status"] == "ready-suffixed" for p in plan)
    log(f"待规范 {len(plan)} 条,其中可执行 {len(ready)},撞名保留双份 {suffixed}")
    write_plan(args_ns.out, plan)

    if args_ns.apply:
        before = _database_health(conn)
        if before[0] != "ok" or before[1]:
            raise RuntimeError(f"写入前 ledger 校验失败:integrity={before[0]} foreign_keys={before[1]}")
        verify_backup(args_ns.backup)
        log(f"数据库备份 → {args_ns.backup}")
        ok = fail = gone = 0
        for item in ready:
            src = _join(item["dir"], item["old"])
            dst = _join(item["dir"], item["new"])
            rename_needed = src != dst
            if rename_needed and not os.path.exists(src):
                item["status"] = "missing"
                gone += 1
                continue
            case_only = src.lower() == dst.lower()
            if rename_needed and os.path.exists(dst) and not case_only:
                item["status"] = "collide"
                fail += 1
                continue
            try:
                if rename_needed:
                    _rename_path(src, dst)
            except Exception as exc:
                item["status"] = f"error:{type(exc).__name__}"
                log(f"  失败 {src} -> {item['new']} : {exc}")
                fail += 1
                continue
            try:
                conn.execute(
                    "UPDATE asset SET path=?, name=?, code=? WHERE id=?",
                    (dst, item["new"], item["new_code"], item["id"]),
                )
                conn.commit()
            except Exception as exc:
                conn.rollback()
                try:
                    if rename_needed:
                        _rename_path(dst, src)
                    item["status"] = f"db-error-rolled-back:{type(exc).__name__}"
                except Exception:
                    item["status"] = f"db-error-manual-repair:{type(exc).__name__}"
                log(f"  数据库失败 {src} -> {item['new']} : {exc}")
                fail += 1
                continue
            item["status"] = "done"
            ok += 1
        after = _database_health(conn)
        if after[0] != "ok" or after[1] or after[2] != before[2]:
            raise RuntimeError(
                f"写入后 ledger 校验失败:integrity={after[0]} foreign_keys={after[1]} "
                f"assets={before[2]}->{after[2]}"
            )
        log(f"改名完成 {ok},失败 {fail},源已不存在 {gone}")
    conn.close()

    write_plan(args_ns.out, plan)
    log(f"→ {args_ns.out}")
    if not args_ns.apply:
        log("未加 --apply,只出清单未改名。")
    return 2 if args_ns.apply and any(
        not str(item["status"]).startswith("done") for item in plan
    ) else 0


def main(argv: list[str] | None = None) -> int:
    args_ns = build_parser().parse_args(argv)
    configure_log(args_ns.log_dir)
    try:
        return run(args_ns)
    finally:
        close_log()


if __name__ == "__main__":
    raise SystemExit(main())