#!/usr/bin/env python3
"""Deterministic post-translation verification — pure regex, no LLM calls.
Checks (all driven by patterns; multilingual where it matters):
- section_ids — every NN.M.M in source appears in target
- numbers — every numeric value preserved (locale-aware date / decimal handling)
- fig_table_refs — figure / table cross-references preserved across language
- citations — regulatory citation forms preserved (§, Art., No., №, FAR/EASA-style IDs)
- hazard_categories — count AND ordered sequence of WARNING/CAUTION/NOTE matches
Direction-aware via --direction <SRC_CODE>_<TGT_CODE> (e.g. uk_en, en_de, ja_en).
A hazard-mapping YAML can be passed via --hazard-mapping for non-default language pairs.
"""
import argparse, json, re, sys
from pathlib import Path
# ---- Generic patterns (work across languages) -------------------------------
SECTION_ID_RE = re.compile(r"\b(\d{2}(?:\.\d+){1,5})\b")
NUMBER_RE = re.compile(r"\b(\d+(?:[.,]\d+)?)\b")
DATE_DDMMYYYY_RE = re.compile(r"\b(\d{2}\.\d{2}\.\d{4})\b")
DATE_YYYYMMDD_RE = re.compile(r"\b(\d{4}-\d{2}-\d{2})\b")
PAGE_FOOTER_DATE_RE = re.compile(r"\b(0[1-9]|1[0-2])\.20\d{2}\b")
# Citation patterns — multiple regulatory traditions
CITATIONS = [
re.compile(r"№\s*(\d+(?:/\d+)?)"), # Cyrillic № prefix
re.compile(r"\bNo\.\s*(\d+(?:[/-]\d+)?)\b"), # English "No. 123"
re.compile(r"\bNr\.\s*(\d+(?:[/-]\d+)?)\b"), # German "Nr. 123"
re.compile(r"§\s*(\d+(?:\.\d+)*[a-z]?)"), # § paragraph mark
re.compile(r"\bArt\.\s*(\d+(?:[.\-]\d+)*)\b"), # Article Art. 5
re.compile(r"\bAnnex\s+([IVXLCDM]+|\d+)\b"), # Annex I / Annex 3
re.compile(r"\bFAR\s+(\d+\.\d+)\b"), # FAR 23.1309
re.compile(r"\bCS-(\w+)\b"), # EASA CS-25 etc.
re.compile(r"\bSTANAG\s+(\d+)\b"), # NATO STANAG 4671
re.compile(r"\bISO\s+(\d{3,5}(?:[-:]\d+)*)\b"), # ISO 13485, ISO 26262-3
re.compile(r"\bIEC\s+(\d{3,5}(?:[-:]\d+)*)\b"),
re.compile(r"\bICH\s+([A-Z]\d+[A-Z]?)\b"), # ICH E6, ICH Q9
]
# Figure / table reference patterns — by language
FIG_TABLE_PATTERNS = {
"en": {
"fig": re.compile(r"\b(?:Fig\.?|Figure)\s*(\d+(?:\.\d+)*)", re.IGNORECASE),
"tab": re.compile(r"\bTable\s*(\d+(?:\.\d+)*)", re.IGNORECASE),
},
"uk": {
"fig": re.compile(r"\bРис\.\s*(\d+(?:\.\d+)*)"),
"tab": re.compile(r"\bТаблиц[яі]\s*(\d+(?:\.\d+)*)"),
},
"ru": {
"fig": re.compile(r"\bРис\.\s*(\d+(?:\.\d+)*)"),
"tab": re.compile(r"\bТаблиц[аы]\s*(\d+(?:\.\d+)*)"),
},
"de": {
"fig": re.compile(r"\b(?:Abb\.?|Abbildung)\s*(\d+(?:\.\d+)*)"),
"tab": re.compile(r"\bTabelle\s*(\d+(?:\.\d+)*)"),
},
"fr": {
"fig": re.compile(r"\b(?:Fig\.?|Figure)\s*(\d+(?:\.\d+)*)"),
"tab": re.compile(r"\bTableau\s*(\d+(?:\.\d+)*)"),
},
"es": {
"fig": re.compile(r"\b(?:Fig\.?|Figura)\s*(\d+(?:\.\d+)*)"),
"tab": re.compile(r"\bTabla\s*(\d+(?:\.\d+)*)"),
},
"pt": {
"fig": re.compile(r"\b(?:Fig\.?|Figura)\s*(\d+(?:\.\d+)*)"),
"tab": re.compile(r"\bTabela\s*(\d+(?:\.\d+)*)"),
},
"it": {
"fig": re.compile(r"\b(?:Fig\.?|Figura)\s*(\d+(?:\.\d+)*)"),
"tab": re.compile(r"\bTabella\s*(\d+(?:\.\d+)*)"),
},
"ja": {
"fig": re.compile(r"図\s*(\d+(?:[.\-]\d+)*)"),
"tab": re.compile(r"表\s*(\d+(?:[.\-]\d+)*)"),
},
"zh": {
"fig": re.compile(r"图\s*(\d+(?:[.\-]\d+)*)"),
"tab": re.compile(r"表\s*(\d+(?:[.\-]\d+)*)"),
},
"ko": {
"fig": re.compile(r"그림\s*(\d+(?:[.\-]\d+)*)"),
"tab": re.compile(r"표\s*(\d+(?:[.\-]\d+)*)"),
},
}
# Hazard label sets per language. Keys are canonical English; values are the
# strings to look for in source / target. Each entry is a *set* because some
# languages use multiple forms (e.g. CAUTION can be "AVERTISSEMENT" or "ATTENTION").
HAZARD_MAPS = {
"en": {"DANGER": {"DANGER"}, "WARNING": {"WARNING"}, "CAUTION": {"CAUTION"}, "NOTE": {"NOTE", "NOTICE"}},
"uk": {"DANGER": {"НЕБЕЗПЕКА"}, "WARNING": {"УВАГА"}, "CAUTION": {"ПОПЕРЕДЖЕННЯ"}, "NOTE": {"ПРИМІТКА"}},
"ru": {"DANGER": {"ОПАСНОСТЬ"}, "WARNING": {"ВНИМАНИЕ"}, "CAUTION": {"ОСТОРОЖНО"}, "NOTE": {"ПРИМЕЧАНИЕ"}},
"de": {"DANGER": {"GEFAHR"}, "WARNING": {"WARNUNG", "ACHTUNG"}, "CAUTION": {"VORSICHT"}, "NOTE": {"HINWEIS"}},
"fr": {"DANGER": {"DANGER"}, "WARNING": {"AVERTISSEMENT"}, "CAUTION": {"ATTENTION", "MISE EN GARDE"}, "NOTE": {"NOTE", "REMARQUE"}},
"es": {"DANGER": {"PELIGRO"}, "WARNING": {"ADVERTENCIA"}, "CAUTION": {"PRECAUCIÓN", "PRECAUCION", "CUIDADO"}, "NOTE": {"NOTA"}},
"pt": {"DANGER": {"PERIGO"}, "WARNING": {"AVISO", "ADVERTÊNCIA"}, "CAUTION": {"CUIDADO", "ATENÇÃO"}, "NOTE": {"NOTA"}},
"it": {"DANGER": {"PERICOLO"}, "WARNING": {"AVVERTENZA", "AVVERTIMENTO"}, "CAUTION": {"ATTENZIONE"}, "NOTE": {"NOTA"}},
"ja": {"DANGER": {"危険"}, "WARNING": {"警告"}, "CAUTION": {"注意"}, "NOTE": {"備考", "備註"}},
"zh": {"DANGER": {"危险", "危險"}, "WARNING": {"警告"}, "CAUTION": {"注意"}, "NOTE": {"备注", "備註"}},
"ko": {"DANGER": {"위험"}, "WARNING": {"경고"}, "CAUTION": {"주의"}, "NOTE": {"비고"}},
}
MONTH_NAMES = {"01": "Jan", "02": "Feb", "03": "Mar", "04": "Apr",
"05": "May", "06": "Jun", "07": "Jul", "08": "Aug",
"09": "Sep", "10": "Oct", "11": "Nov", "12": "Dec"}
def normalize_number(s): return s.replace(",", ".")
def load_source(path):
p = Path(path)
if p.suffix == ".json":
data = json.loads(p.read_text(encoding="utf-8"))
if isinstance(data, dict) and "pages" in data:
return "\n".join(pg.get("text", "") for pg in data["pages"])
return json.dumps(data, ensure_ascii=False)
return p.read_text(encoding="utf-8")
def find_unique(pattern, text, group=1):
seen, seen_set = [], set()
for m in pattern.finditer(text):
v = m.group(group)
if v not in seen_set:
seen.append(v); seen_set.add(v)
return seen
def check_section_ids(source, translation):
src_ids = find_unique(SECTION_ID_RE, source)
trn_ids = set(find_unique(SECTION_ID_RE, translation))
src_ids = [s for s in src_ids
if not DATE_DDMMYYYY_RE.fullmatch(s)
and not PAGE_FOOTER_DATE_RE.fullmatch(s)]
missing = [s for s in src_ids if s not in trn_ids]
return {"check": "section_ids", "source_count": len(src_ids),
"missing": missing, "ok": len(missing) == 0}
def check_numbers(source, translation):
src_stripped = PAGE_FOOTER_DATE_RE.sub("", source)
trn_stripped = PAGE_FOOTER_DATE_RE.sub("", translation)
src_nums = {normalize_number(n) for n in find_unique(NUMBER_RE, src_stripped)}
trn_nums = {normalize_number(n) for n in find_unique(NUMBER_RE, trn_stripped)}
# DD.MM.YYYY -> 'DD MMM YYYY' equivalences
for m in DATE_DDMMYYYY_RE.finditer(source):
dd, mm, yyyy = m.group(1).split(".")
mw = MONTH_NAMES.get(mm)
if mw and (f"{int(dd)} {mw} {yyyy}" in translation or f"{dd} {mw} {yyyy}" in translation):
trn_nums.update({normalize_number(dd), normalize_number(mm), normalize_number(yyyy)})
# Reverse direction
en_date_re = re.compile(r"\b(\d{1,2})\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+(\d{4})\b",
re.IGNORECASE)
inverse = {v.lower(): k for k, v in MONTH_NAMES.items()}
for m in en_date_re.finditer(source):
dd = m.group(1).zfill(2); mm = inverse[m.group(2).lower()]; yyyy = m.group(3)
if f"{dd}.{mm}.{yyyy}" in translation:
trn_nums.update({normalize_number(dd), normalize_number(mm), normalize_number(yyyy)})
# ISO 8601 dates
for m in DATE_YYYYMMDD_RE.finditer(source):
yyyy, mm, dd = m.group(1).split("-")
trn_nums.update({normalize_number(dd), normalize_number(mm), normalize_number(yyyy)})
missing = sorted(src_nums - trn_nums,
key=lambda x: float(x) if x.replace(".", "").isdigit() else 0)
# Drop very small numbers — they generate too many false positives (page nums etc.)
missing = [m for m in missing if not (m.replace(".", "").isdigit() and float(m) < 3)]
return {"check": "numbers", "source_count": len(src_nums),
"missing": missing[:30], "missing_total": len(missing),
"ok": len(missing) == 0}
def check_fig_table_refs(source, translation, src_lang, tgt_lang):
src_pat = FIG_TABLE_PATTERNS.get(src_lang)
tgt_pat = FIG_TABLE_PATTERNS.get(tgt_lang)
if not src_pat or not tgt_pat:
return {"check": "fig_table_refs", "skipped": True,
"reason": f"no pattern for {src_lang} or {tgt_lang}",
"ok": True}
src_figs = set(find_unique(src_pat["fig"], source))
src_tabs = set(find_unique(src_pat["tab"], source))
trn_figs = set(find_unique(tgt_pat["fig"], translation))
trn_tabs = set(find_unique(tgt_pat["tab"], translation))
mf = sorted(src_figs - trn_figs); mt = sorted(src_tabs - trn_tabs)
return {"check": "fig_table_refs", "src_lang": src_lang, "tgt_lang": tgt_lang,
"source_figs": sorted(src_figs), "missing_figs": mf,
"source_tables": sorted(src_tabs), "missing_tables": mt,
"ok": not (mf or mt)}
def check_citations(source, translation):
found_in_source = set()
for pat in CITATIONS:
for m in pat.finditer(source):
found_in_source.add(m.group(0))
missing = [c for c in found_in_source if c not in translation]
return {"check": "regulatory_citations",
"source_citations": sorted(found_in_source),
"missing": sorted(missing), "ok": len(missing) == 0}
def _ordered_hazards(text, words):
"""Return the hazard-label sequence in document order, mapped to canonical English."""
spans = []
for canonical, variants in words.items():
for v in variants:
for m in re.finditer(rf"\b{re.escape(v)}\b", text, flags=re.IGNORECASE):
spans.append((m.start(), canonical))
spans.sort()
return [c for _, c in spans]
def check_hazard_categories(source, translation, src_lang, tgt_lang):
src_map = HAZARD_MAPS.get(src_lang) or HAZARD_MAPS["en"]
tgt_map = HAZARD_MAPS.get(tgt_lang) or HAZARD_MAPS["en"]
counts = {}; swaps = []
for canonical in ("DANGER", "WARNING", "CAUTION", "NOTE"):
src_variants = src_map.get(canonical, set())
tgt_variants = tgt_map.get(canonical, set())
c_src = sum(len(re.findall(rf"\b{re.escape(v)}\b", source, re.IGNORECASE)) for v in src_variants)
c_tgt = sum(len(re.findall(rf"\b{re.escape(v)}\b", translation, re.IGNORECASE)) for v in tgt_variants)
counts[canonical] = {"source": c_src, "translation": c_tgt,
"src_variants": sorted(src_variants),
"tgt_variants": sorted(tgt_variants)}
if c_src > 0 and c_tgt == 0:
swaps.append(f"{canonical} present in source ({c_src}) but no target equivalent in translation")
# Ordered-sequence check — catches per-callout category swaps
src_seq = _ordered_hazards(source, src_map)
tgt_seq = _ordered_hazards(translation, tgt_map)
sequence_mismatches = []
if len(src_seq) == len(tgt_seq):
for i, (s, t) in enumerate(zip(src_seq, tgt_seq)):
if s != t:
sequence_mismatches.append({"index": i, "expected": s, "got": t})
elif src_seq:
sequence_mismatches.append({"length_mismatch": True,
"source_count": len(src_seq),
"translation_count": len(tgt_seq)})
if sequence_mismatches:
swaps.append(f"hazard sequence mismatch: {sequence_mismatches[:5]}")
return {"check": "hazard_categories", "src_lang": src_lang, "tgt_lang": tgt_lang,
"counts": counts,
"source_sequence": src_seq, "translation_sequence": tgt_seq,
"sequence_mismatches": sequence_mismatches,
"swap_suspects": swaps, "ok": not swaps}
def main():
ap = argparse.ArgumentParser()
ap.add_argument("source")
ap.add_argument("translation")
ap.add_argument("--direction", required=True,
help="<src>_<tgt>, e.g. uk_en, en_de, ja_en")
ap.add_argument("--out", default=None)
args = ap.parse_args()
parts = args.direction.split("_")
if len(parts) != 2:
sys.stderr.write("ERROR: --direction must be <src>_<tgt>, e.g. uk_en\n"); sys.exit(2)
src_lang, tgt_lang = parts
source = load_source(args.source)
translation = Path(args.translation).read_text(encoding="utf-8")
checks = [
check_section_ids(source, translation),
check_numbers(source, translation),
check_fig_table_refs(source, translation, src_lang, tgt_lang),
check_citations(source, translation),
check_hazard_categories(source, translation, src_lang, tgt_lang),
]
all_ok = all(c.get("ok", True) for c in checks)
report = {"source": args.source, "translation": args.translation,
"direction": args.direction, "all_ok": all_ok, "checks": checks}
out_path = args.out or Path(args.translation).with_suffix(".verify.json")
Path(out_path).write_text(json.dumps(report, ensure_ascii=False, indent=2))
label = f"{src_lang.upper()} -> {tgt_lang.upper()}"
print(f"{'PASS' if all_ok else 'FAIL'} ({label}) - {out_path}")
for c in checks:
marker = "ok" if c.get("ok", True) else "FAIL"
name = c.get("check", "?")
if name == "section_ids":
extra = f" missing IDs: {c['missing'][:10]}" if c.get("missing") else ""
print(f" [{marker}] section_ids ({c.get('source_count', 0)} expected){extra}")
elif name == "numbers":
extra = f" missing values: {c['missing'][:10]}" if c.get("missing") else ""
print(f" [{marker}] numbers ({c.get('source_count', 0)} expected, "
f"{c.get('missing_total', 0)} missing){extra}")
elif name == "fig_table_refs":
if c.get("skipped"):
print(f" [skip] fig_table_refs — {c.get('reason')}"); continue
extra = ""
if c.get("missing_figs"): extra += f" missing figs: {c['missing_figs']}"
if c.get("missing_tables"): extra += f" missing tables: {c['missing_tables']}"
print(f" [{marker}] fig_table_refs{extra}")
elif name == "regulatory_citations":
extra = f" missing citations: {c['missing']}" if c.get("missing") else ""
print(f" [{marker}] regulatory_citations{extra}")
elif name == "hazard_categories":
extra = f" swap suspects: {c['swap_suspects']}" if c.get("swap_suspects") else ""
print(f" [{marker}] hazard_categories{extra}")
sys.exit(0 if all_ok else 1)
if __name__ == "__main__":
main()