Skip to content

Tasdax123/claude-fidelity-translator / plugins/fidelity-translator/skills/fidelity-translator

fidelity-translator

Verified

scripts/verify_chunk.py

View on GitHub
#!/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()
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 194kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 194kUpdated Claude CodeCodexVerifiedInstall