| |
| """Supervisor gate for the English Track B gt_source translation. |
| |
| Compares en/gt_source/<story>.json against zh/gt_source/<story>.json and refuses |
| anything that would break the deterministic build (complete_gt -> get_sut_prompts) |
| or drift from the frozen Chinese structure. |
| |
| Checks (all must pass): |
| 1. JSON parses. |
| 2. Structural skeleton identical to zh: same eids, same kinds, same scene ids |
| and order, same action-item shape, same numeric params, same enum/identifier |
| leaves (kind / eid / count / confusable_with / type / reason / shown / |
| resolves_to / pair / anchor.type). |
| 3. State-name referential integrity WITHIN en (state names may be remapped to |
| English, but must be remapped CONSISTENTLY): |
| set(entities[e].states.keys()) == set(state_machines[e]) (order too) |
| every events[].to in that entity's states |
| every present[].state in that entity's states |
| 4. Full English: ZERO CJK characters anywhere in the file. |
| 5. Every translatable field is non-empty. |
| 6. Deterministic build succeeds: complete_gt + get_sut_prompts run without |
| exception; no "name not found in action" warning (else the SUT prompt would |
| silently lose an appearance reveal -> the English name must appear verbatim |
| in its introduce/transform action). |
| |
| Exit code 0 = PASS, 1 = FAIL (errors printed). |
| |
| Usage: |
| python validate_en_source.py --story 0003_desert_archaeologist |
| python validate_en_source.py --all |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import re |
| import subprocess |
| import sys |
| import tempfile |
| from pathlib import Path |
|
|
| SELF = Path(__file__).resolve().parent |
| HERE = SELF.parent |
| ZH_DIR = HERE / "zh" / "gt_source" |
| EN_DIR = HERE / "en" / "gt_source" |
| |
| CJK = re.compile(r"[\u3000-\u303f\u3400-\u4dbf\u4e00-\u9fff\uff00-\uffef]") |
| |
| |
| HAN = re.compile(r"[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]") |
|
|
| |
| PROTECTED = { |
| "story_id", "kind", "eid", "count", "confusable_with", "type", "reason", |
| "shown", "resolves_to", "segment_sec", "gap_long_threshold", |
| "avoidance_probe_window", "probe_target_default", "id", |
| } |
|
|
|
|
| def has_cjk(s) -> bool: |
| return bool(CJK.search(str(s))) |
|
|
|
|
| class V: |
| def __init__(self): |
| self.errs: list[str] = [] |
| self.warns: list[str] = [] |
|
|
| def err(self, msg: str): |
| self.errs.append(msg) |
|
|
| def eq(self, a, b, where: str): |
| if a != b: |
| self.err(f"{where}: identifier changed {b!r} -> {a!r} (must stay equal to zh)") |
|
|
| def translatable(self, val, where: str): |
| if not isinstance(val, str) or not val.strip(): |
| self.err(f"{where}: empty/invalid translatable text") |
| elif has_cjk(val): |
| self.err(f"{where}: still contains CJK -> not translated") |
|
|
|
|
| def check_entities(zh, en, v: V): |
| ze, ee = zh.get("entities", {}), en.get("entities", {}) |
| if set(ze) != set(ee): |
| v.err(f"entities: eid set changed {sorted(set(ze)^set(ee))}") |
| return |
| for eid in ze: |
| z, e = ze[eid], ee[eid] |
| v.eq(e.get("kind"), z.get("kind"), f"entities.{eid}.kind") |
| v.translatable(e.get("name", ""), f"entities.{eid}.name") |
| if "states" in z: |
| if "states" not in e or not isinstance(e["states"], dict): |
| v.err(f"entities.{eid}.states: missing/invalid") |
| continue |
| if len(e["states"]) != len(z["states"]): |
| v.err(f"entities.{eid}.states: key count {len(e['states'])} != zh {len(z['states'])}") |
| for k, val in e["states"].items(): |
| if has_cjk(k): |
| v.err(f"entities.{eid}.states key {k!r} still CJK") |
| v.translatable(val, f"entities.{eid}.states[{k}]") |
| if "appearance" in z: |
| v.translatable(e.get("appearance", ""), f"entities.{eid}.appearance") |
|
|
|
|
| def check_state_machines(zh, en, v: V): |
| zsm, esm = zh.get("state_machines", {}), en.get("state_machines", {}) |
| if set(zsm) != set(esm): |
| v.err(f"state_machines: eid set changed {sorted(set(zsm)^set(esm))}") |
| return |
| ee = en.get("entities", {}) |
| for eid, zlist in zsm.items(): |
| elist = esm[eid] |
| if len(elist) != len(zlist): |
| v.err(f"state_machines.{eid}: len {len(elist)} != zh {len(zlist)}") |
| skeys = list(ee.get(eid, {}).get("states", {}).keys()) |
| if elist != skeys: |
| v.err(f"state_machines.{eid}: {elist} != entity states order {skeys} " |
| f"(state names must be remapped consistently)") |
|
|
|
|
| def _entity_states(en, eid) -> set: |
| return set(en.get("entities", {}).get(eid, {}).get("states", {}).keys()) |
|
|
|
|
| def check_lookalikes(zh, en, v: V): |
| zl, el = zh.get("lookalike_pairs", []), en.get("lookalike_pairs", []) |
| if len(zl) != len(el): |
| v.err(f"lookalike_pairs: count {len(el)} != zh {len(zl)}") |
| return |
| for i, (z, e) in enumerate(zip(zl, el)): |
| v.eq(e.get("pair"), z.get("pair"), f"lookalike_pairs[{i}].pair") |
| zf, ef = z.get("features", {}), e.get("features", {}) |
| if set(ef) != set(zf): |
| v.err(f"lookalike_pairs[{i}].features: eid keys changed") |
| for k, val in ef.items(): |
| v.translatable(val, f"lookalike_pairs[{i}].features[{k}]") |
| if "note" in z: |
| v.translatable(e.get("note", ""), f"lookalike_pairs[{i}].note") |
|
|
|
|
| def check_present(zpres, epres, eid_states, where, v: V): |
| if not isinstance(zpres, list) or not isinstance(epres, list) or len(zpres) != len(epres): |
| v.err(f"{where}: present shape mismatch") |
| return |
| for i, (z, e) in enumerate(zip(zpres, epres)): |
| w = f"{where}[{i}]" |
| if isinstance(z, str): |
| v.eq(e, z, f"{w} eid") |
| elif isinstance(z, dict): |
| if not isinstance(e, dict): |
| v.err(f"{w}: expected dict") |
| continue |
| eid = z.get("eid") |
| v.eq(e.get("eid"), eid, f"{w}.eid") |
| for pk in ("count", "confusable_with"): |
| if pk in z: |
| v.eq(e.get(pk), z.get(pk), f"{w}.{pk}") |
| if "state" in z: |
| st = e.get("state") |
| if st not in eid_states.get(eid, set()): |
| v.err(f"{w}.state {st!r} not in entity {eid} states") |
| if "anchor" in z: |
| za, ea = z["anchor"], e.get("anchor", {}) |
| v.eq(ea.get("type"), za.get("type"), f"{w}.anchor.type") |
| v.eq(ea.get("resolves_to"), za.get("resolves_to"), f"{w}.anchor.resolves_to") |
| v.translatable(ea.get("phrase", ""), f"{w}.anchor.phrase") |
|
|
|
|
| def check_scenes(zh, en, v: V): |
| zs, es = zh.get("scenes", []), en.get("scenes", []) |
| if len(zs) != len(es): |
| v.err(f"scenes: count {len(es)} != zh {len(zs)}") |
| return |
| eid_states = {eid: _entity_states(en, eid) for eid in en.get("entities", {})} |
| for si, (z, e) in enumerate(zip(zs, es)): |
| w = f"scenes[{si}]" |
| v.eq(e.get("id"), z.get("id"), f"{w}.id") |
| v.translatable(e.get("setting", ""), f"{w}.setting") |
| if "present" in z: |
| check_present(z["present"], e.get("present", []), eid_states, f"{w}.present", v) |
| za, ea = z.get("actions", []), e.get("actions", []) |
| if len(za) != len(ea): |
| v.err(f"{w}.actions: count {len(ea)} != zh {len(za)}") |
| continue |
| for ai, (zi, ei) in enumerate(zip(za, ea)): |
| aw = f"{w}.actions[{ai}]" |
| if isinstance(zi, str): |
| v.translatable(ei if isinstance(ei, str) else "", f"{aw}") |
| elif isinstance(zi, dict): |
| if not isinstance(ei, dict): |
| v.err(f"{aw}: expected dict") |
| continue |
| v.translatable(ei.get("action", ""), f"{aw}.action") |
| if "present" in zi: |
| check_present(zi["present"], ei.get("present", []), eid_states, f"{aw}.present", v) |
| for evi, ev in enumerate(zi.get("events", [])): |
| eev = ei.get("events", [])[evi] if evi < len(ei.get("events", [])) else {} |
| v.eq(eev.get("type"), ev.get("type"), f"{aw}.events[{evi}].type") |
| v.eq(eev.get("eid"), ev.get("eid"), f"{aw}.events[{evi}].eid") |
| if "to" in ev: |
| to = eev.get("to") |
| if to not in eid_states.get(ev.get("eid"), set()): |
| v.err(f"{aw}.events[{evi}].to {to!r} not in entity {ev.get('eid')} states") |
| for pk in ("reason", "shown"): |
| if pk in ev: |
| v.eq(eev.get(pk), ev.get(pk), f"{aw}.events[{evi}].{pk}") |
|
|
|
|
| def check_build(story: str, v: V): |
| |
| with tempfile.TemporaryDirectory(dir=HERE, prefix="_valtmp_") as td: |
| td = Path(td) |
| gt_out, sut_out = td / "gt", td / "sut" |
| r1 = subprocess.run( |
| [sys.executable, str(SELF / "complete_gt.py"), "--story", story, |
| "--src-dir", str(EN_DIR), "--out-dir", str(gt_out)], |
| capture_output=True, text=True) |
| if r1.returncode != 0: |
| v.err(f"complete_gt failed: {r1.stderr.strip()[:400]}") |
| return |
| r2 = subprocess.run( |
| [sys.executable, str(SELF / "get_sut_prompts.py"), "--story", story, |
| "--gt-dir", str(gt_out), "--out-dir", str(sut_out)], |
| capture_output=True, text=True) |
| if r2.returncode != 0: |
| v.err(f"get_sut_prompts failed: {r2.stderr.strip()[:400]}") |
| return |
| for line in (r1.stdout + r2.stdout).splitlines(): |
| if "not found in action" in line: |
| v.err(f"BUILD WARN (name not in action): {line.strip()}") |
| |
| sf = sut_out / f"{story}_name_anchored.json" |
| if sf.exists(): |
| d = json.loads(sf.read_text(encoding="utf-8")) |
| for seg in d.get("segments", []): |
| if HAN.search(str(seg.get("prompt", ""))): |
| v.err(f"built SUT prompt {seg['segment_id']} still has Han CJK") |
| break |
|
|
|
|
| def validate(story: str) -> V: |
| v = V() |
| zp, ep = ZH_DIR / f"{story}.json", EN_DIR / f"{story}.json" |
| if not ep.exists(): |
| v.err(f"missing {ep}") |
| return v |
| try: |
| zh = json.loads(zp.read_text(encoding="utf-8")) |
| en = json.loads(ep.read_text(encoding="utf-8")) |
| except Exception as exc: |
| v.err(f"JSON parse error: {exc}") |
| return v |
| v.eq(en.get("story_id"), zh.get("story_id"), "story_id") |
| for p in ("segment_sec", "gap_long_threshold", "avoidance_probe_window", "probe_target_default"): |
| v.eq(en.get(p), zh.get(p), p) |
| v.translatable(en.get("title", ""), "title") |
| if "premise" in zh: |
| v.translatable(en.get("premise", ""), "premise") |
| check_entities(zh, en, v) |
| check_state_machines(zh, en, v) |
| check_lookalikes(zh, en, v) |
| check_scenes(zh, en, v) |
| |
| |
| leftover = sorted({m.group(0) for m in CJK.finditer(json.dumps(en, ensure_ascii=False))}) |
| if leftover: |
| v.err(f"file still contains CJK chars: {''.join(leftover)[:60]}") |
| if not v.errs: |
| check_build(story, v) |
| return v |
|
|
|
|
| def main() -> int: |
| ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| ap.add_argument("--story") |
| ap.add_argument("--all", action="store_true") |
| a = ap.parse_args() |
| if a.all: |
| stories = [p.stem for p in sorted(ZH_DIR.glob("*.json"))] |
| elif a.story: |
| stories = [a.story] |
| else: |
| raise SystemExit("need --story or --all") |
| n_fail = 0 |
| for s in stories: |
| v = validate(s) |
| if v.errs: |
| n_fail += 1 |
| print(f"FAIL {s} ({len(v.errs)} error(s))") |
| for e in v.errs[:25]: |
| print(f" - {e}") |
| else: |
| print(f"PASS {s}") |
| print(f"\n{len(stories)-n_fail}/{len(stories)} passed") |
| return 1 if n_fail else 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
