| |
| """一次性迁移：四个 XToY 目录 → 统一 data/ 平铺布局（2026-10-19）。 |
| |
| 旧布局：WordTranslation/{EnToX,XToEn,ZhToX,XToZh}/data/<src>_<dst>.jsonl.gz |
| 新布局：WordTranslation/data/<src>_<dst>.jsonl.gz（每个方向唯一一份，方向在文件名里） |
| |
| 顺手修掉旧 pack 产物的三个 gzip/换行问题： |
| * FNAME 被写成 "<name>.jsonl.gz.tmp"（用 7-Zip / gunzip -N 解压后后缀错乱） |
| * MTIME 每次不同（rebuild 非确定） |
| * 正文全是 CRLF（Windows 文本模式写出的），与 Linux 重建产物不一致 → 统一 LF |
| 做法是逐文件「解压→按正确头重压」：**除 CRLF→LF 外，JSONL 内容逐字节不变**。 |
| （wt.py 的 pack 已同步修好，今后新产物不会再犯。） |
| |
| en⇄zh 只在两套管线各产一份、字节不同；沿用网站消费端（init_web.js）的口径保留 |
| en_zh ← XToZh 管线，zh_en ← XToEn 管线，另一份进 build/dupes/ 留档。 |
| 构建输入（cache/llm/manual）归入 build/<pair>/，与正向目录完全相同的副本去重丢弃。 |
| |
| 可重复执行：若 data/ 已是新布局，自动只做「换行归一 + 重建 sidecar」。 |
| |
| 用法：python tools/migrate_flat_layout.py [--dry-run] |
| """ |
| import gzip |
| import hashlib |
| import json |
| import os |
| import shutil |
| import sys |
| from datetime import datetime |
| from pathlib import Path |
|
|
| HERE = Path(__file__).resolve().parent |
| sys.path.insert(0, str(HERE)) |
| import wt |
|
|
| WT = wt.WT |
| DATA = wt.DATA_DIR |
| OLD_DIRS = ("EnToX", "XToEn", "ZhToX", "XToZh") |
| LEGACY = WT / "build" / f"legacy-{datetime.now():%Y%m%d}" |
| DUPES = WT / "build" / "dupes" |
|
|
| |
| KEEP_FROM = {"en_zh.jsonl.gz": "XToZh", "zh_en.jsonl.gz": "XToEn"} |
|
|
| |
| BUILD_MAP = [ |
| ("EnToX", "cache", "en/cache"), |
| ("EnToX", "llm", "en/llm"), |
| ("EnToX", "manual", "en/manual"), |
| ("EnToX", "raw", None), |
| ("XToEn", "cache", None), |
| ("XToEn", "llm", None), |
| ("XToEn", "manual", "en/manual-rev"), |
| ("ZhToX", "cache", "zh/cache"), |
| ("ZhToX", "llm", "zh/llm"), |
| ("ZhToX", "manual", "zh/manual"), |
| ("XToZh", "cache", None), |
| ("XToZh", "llm", None), |
| ("XToZh", "manual", "zh/manual-rev"), |
| ] |
|
|
| DIRECTIONS = [ |
| ("en", "p1", "EnToX", "en"), |
| ("en", "p2", "XToEn", None), |
| ("zh", "p1", "ZhToX", "zh"), |
| ("zh", "p2", "XToZh", None), |
| ] |
|
|
| |
| DEDUP_CHECK = { |
| ("XToEn", "cache"): "en/cache", |
| ("XToEn", "llm"): "en/llm", |
| ("XToZh", "cache"): "zh/cache", |
| ("XToZh", "llm"): "zh/llm", |
| } |
|
|
| DRY = "--dry-run" in sys.argv |
|
|
| |
| BACKUP = os.environ.get("WT_MIGRATE_BACKUP") |
|
|
|
|
| def sha256(b): |
| return hashlib.sha256(b).hexdigest() |
|
|
|
|
| def gunzip_bytes(p): |
| with gzip.open(p, "rb") as fh: |
| return fh.read() |
|
|
|
|
| def normalize(data): |
| """统一 LF 换行：旧产物在 Windows 文本模式下被写成了 CRLF（gzip.open(...,'wt') 的 |
| 平台默认换行翻译），JSONL 语义不变，但平台间产物不一致。新 pack 一律 LF。""" |
| if b"\r\n" in data: |
| data = data.replace(b"\r\n", b"\n") |
| return data |
|
|
|
|
| def write_gz(path, data): |
| """写 gzip：不写 FNAME、mtime=0（确定性），与 wt.pack_one 同款。""" |
| with open(path, "wb") as raw: |
| with gzip.GzipFile(filename="", mode="wb", fileobj=raw, |
| compresslevel=9, mtime=0) as gz: |
| gz.write(data) |
|
|
|
|
| def content_hashes(d): |
| """dir -> {文件名: 归一化后 JSONL 内容的 sha256}（只看顶层，即 data 文件）""" |
| out = {} |
| d = Path(d) |
| if not d.exists(): |
| return out |
| for f in sorted(d.glob("*.jsonl.gz")): |
| out[f.name] = sha256(normalize(gunzip_bytes(f))) |
| return out |
|
|
|
|
| def normalize_data_files(): |
| """把 data/ 里仍是 CRLF 的文件就地重写为 LF（内容其余部分逐字节不变）。""" |
| n = 0 |
| for f in sorted(DATA.glob("*.jsonl.gz")): |
| raw = gunzip_bytes(f) |
| norm = normalize(raw) |
| if norm == raw: |
| continue |
| lines_before = raw.count(b"\n") |
| if norm.count(b"\n") != lines_before: |
| sys.exit(f"[迁移] {f.name} 换行归一后行数变了") |
| write_gz(f, norm) |
| n += 1 |
| print(f"[迁移] 换行归一：{n} 个文件 CRLF→LF（其余已是 LF）") |
|
|
|
|
| def dir_bytes_hashes(d): |
| """dir -> {相对路径: 原始字节 sha256}（用于断言两份构建输入逐字节相同）""" |
| out = {} |
| d = Path(d) |
| if not d.exists(): |
| return out |
| for f in sorted(d.rglob("*")): |
| if f.is_file(): |
| out[str(f.relative_to(d)).replace("\\", "/")] = sha256(f.read_bytes()) |
| return out |
|
|
|
|
| def read_old(dirpath): |
| j = dirpath / "meta.json" |
| meta = json.loads(j.read_text(encoding="utf-8")) if j.exists() else {} |
| cards = {} |
| for name in ("meta.json", "files.json", "README.md"): |
| p = dirpath / name |
| cards[name] = p.read_text(encoding="utf-8") if p.exists() else None |
| return meta, cards |
|
|
|
|
| def main(): |
| |
| resumed = DATA.exists() and any(DATA.glob("*.jsonl.gz")) |
|
|
| old_metas, old_cards, root_readme = {}, {}, None |
| pre = None |
| if resumed: |
| print(f"[迁移] 检测到 {DATA} 已是新布局 —— 跳过搬迁，只做换行归一 + 重建 sidecar/README") |
| for d in OLD_DIRS: |
| old_metas[d], _ = read_old(LEGACY / d) |
| if not any(old_metas.values()): |
| sys.exit(f"[迁移] 续跑需要旧 meta.json，但 {LEGACY} 里没有，无法重建 sidecar") |
| if BACKUP: |
| bp = Path(BACKUP) |
| pre = {d: content_hashes(bp / d / "data") for d in OLD_DIRS} |
| print(f"[迁移] 续跑比对基准：{bp}") |
| else: |
| print("[迁移] 读取旧 sidecar ...") |
| for d in OLD_DIRS: |
| old_metas[d], old_cards[d] = read_old(WT / d) |
| root_readme = (WT / "README.md").read_text(encoding="utf-8") |
| pre = {d: content_hashes(WT / d / "data") for d in OLD_DIRS} |
| n_pre = sum(len(v) for v in pre.values()) |
| print(f"[迁移] 迁移前 data 文件共 {n_pre} 个（4×41 里有 2 个 en⇄zh 重复）") |
|
|
| if DRY: |
| print("[迁移] --dry-run：只做检查，不落盘。完成。") |
| return |
|
|
| if not resumed: |
| print("[迁移] 归档旧 sidecar / 旧工作区 README ...") |
| LEGACY.mkdir(parents=True, exist_ok=True) |
| for d in OLD_DIRS: |
| tgt = LEGACY / d |
| tgt.mkdir(parents=True, exist_ok=True) |
| for name, text in old_cards[d].items(): |
| if text is not None: |
| (tgt / name).write_text(text, encoding="utf-8") |
| (LEGACY / "WORKSPACE_README.md").write_text(root_readme, encoding="utf-8") |
|
|
| |
| DATA.mkdir(parents=True, exist_ok=True) |
| DUPES.mkdir(parents=True, exist_ok=True) |
| moved = duped = 0 |
| for d in OLD_DIRS: |
| for f in sorted((WT / d / "data").glob("*.jsonl.gz")): |
| keep_from = KEEP_FROM.get(f.name) |
| if keep_from and keep_from != d: |
| shutil.move(str(f), str(DUPES / f"{d}_{f.name}")) |
| duped += 1 |
| continue |
| raw = gunzip_bytes(f) |
| want = sha256(normalize(raw)) |
| write_gz(DATA / f.name, normalize(raw)) |
| got = sha256(normalize(gunzip_bytes(DATA / f.name))) |
| if got != want: |
| sys.exit(f"[迁移] 校验失败：{f.name} 重压后内容变了") |
| f.unlink() |
| moved += 1 |
| print(f"[迁移] data/ 落盘 {moved} 个文件，另有 {duped} 个 en⇄zh 重复件归档到 build/dupes/") |
|
|
| |
| for old_dir, sub, rel in BUILD_MAP: |
| src = WT / old_dir / sub |
| if not src.exists(): |
| continue |
| if rel is None: |
| if (old_dir, sub) in DEDUP_CHECK: |
| ref = WT / "build" / DEDUP_CHECK[(old_dir, sub)] |
| a, b = dir_bytes_hashes(src), dir_bytes_hashes(ref) |
| if a != b: |
| sys.exit(f"[迁移] {old_dir}/{sub} 与 build/{DEDUP_CHECK[(old_dir, sub)]} " |
| f"并不相同，不能去重") |
| print(f"[迁移] 去重丢弃 {old_dir}/{sub}" |
| f"（与 build/{DEDUP_CHECK[(old_dir, sub)]} 逐字节相同）") |
| else: |
| print(f"[迁移] 丢弃空的 {old_dir}/{sub}") |
| if any(src.rglob("*")): |
| sys.exit(f"[迁移] {old_dir}/{sub} 非空，不能按空目录处理") |
| shutil.rmtree(src) |
| continue |
| dst = WT / "build" / rel |
| dst.parent.mkdir(parents=True, exist_ok=True) |
| if dst.exists(): |
| sys.exit(f"[迁移] 目标已存在：{dst}") |
| shutil.move(str(src), str(dst)) |
| print(f"[迁移] {old_dir}/{sub} → build/{rel}") |
|
|
| |
| for d in OLD_DIRS: |
| for name in ("meta.json", "files.json", "README.md"): |
| p = WT / d / name |
| if p.exists(): |
| p.unlink() |
| left = [p for p in (WT / d).rglob("*") if p.is_file()] |
| if left: |
| sys.exit(f"[迁移] {d} 仍有未处理文件：{left[:5]}") |
| shutil.rmtree(WT / d) |
| print("[迁移] 旧 XToY 目录已移除") |
|
|
| |
| normalize_data_files() |
|
|
| |
| meta = { |
| "version": 2, |
| "generatedAt": wt.local_iso(), |
| "dataset": "vocabradar/WordTranslation", |
| "layout": "data/<src>_<dst>.jsonl.gz", |
| "capPerWord": wt.CAP_PER_WORD, |
| "directions": {}, |
| } |
| for pair, pass_name, dir_name, _ in DIRECTIONS: |
| old = old_metas[dir_name] |
| langs = wt.recount(pass_name, pair) |
| if pass_name == "p2": |
| |
| for code, st in langs.items(): |
| st["vocabSize"] = (old.get("languages", {}).get(code, {}) |
| .get("vocabSize") or 0) |
| meta["directions"][dir_name] = { |
| "source": old.get("source", {}), |
| "vocabulary": old.get("vocabulary", {}), |
| "languages": langs, |
| } |
| print(f"[迁移] {dir_name}: {len(langs)} 语") |
| (WT / "meta.json").write_text(json.dumps(meta, ensure_ascii=False, indent=2) + "\n", |
| encoding="utf-8") |
| wt.write_files_json() |
| wt.write_readme(meta) |
|
|
| |
| final = content_hashes(DATA) |
| if len(final) != 162: |
| sys.exit(f"[迁移] data/ 实际 {len(final)} 个文件，期望 162") |
| if pre is None: |
| print(f"[迁移] 校验：data/ = {len(final)} 个唯一方向" |
| f"（未提供 WT_MIGRATE_BACKUP，未做逐字节比对）") |
| else: |
| kept = {} |
| for d in OLD_DIRS: |
| for name, h in pre[d].items(): |
| keep_from = KEEP_FROM.get(name) |
| if keep_from is not None and keep_from != d: |
| continue |
| kept[name] = h |
| if len(kept) != 162: |
| sys.exit(f"[迁移] 期望 162 个唯一方向，实得 {len(kept)}") |
| bad = sorted(n for n, h in kept.items() if final.get(n) != h) |
| if bad: |
| sys.exit(f"[迁移] 内容校验失败（{len(bad)} 个）：{bad[:5]}") |
| print(f"[迁移] 校验通过：data/ = {len(final)} 个唯一方向" |
| f"（换行符归一外，内容与迁移前逐字节一致）") |
| print(f"[迁移] 完成。旧 sidecar / 旧 README 存于 {LEGACY}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
