Datasets:
File size: 8,682 Bytes
1b62586 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 | #!/usr/bin/env python3
"""Adapt frozen document cases and raw generations to the SEGALE interface."""
from __future__ import annotations
import argparse
import hashlib
import json
import re
from pathlib import Path
SAFE_ID = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,95}$")
CASE_METADATA_FIELDS = (
"schema_version",
"benchmark_version",
"track_id",
"split",
"corpus_id",
"work_id",
"official_directory_group",
"length_band",
"target_source_tokens",
"window_family_id",
)
def read_jsonl(path: Path) -> list[dict]:
with path.open(encoding="utf-8") as stream:
return [json.loads(line) for line in stream if line.strip()]
def write_jsonl(path: Path, rows: list[dict]) -> None:
with path.open("w", encoding="utf-8") as stream:
for row in rows:
stream.write(json.dumps(row, ensure_ascii=False, separators=(",", ":")) + "\n")
def sha_text(text: str) -> str:
return hashlib.sha256(text.encode("utf-8")).hexdigest()
def main() -> None:
parser = argparse.ArgumentParser()
parser.add_argument("--cases", type=Path, required=True)
parser.add_argument("--alignment-units", type=Path, required=True)
parser.add_argument("--generations", type=Path, required=True)
parser.add_argument("--output-dir", type=Path, required=True)
parser.add_argument("--suite-id", required=True)
parser.add_argument("--system-key", required=True)
parser.add_argument("--allow-incomplete", action="store_true")
args = parser.parse_args()
if not SAFE_ID.fullmatch(args.suite_id):
parser.error("--suite-id must be a path-safe identifier")
if not SAFE_ID.fullmatch(args.system_key):
parser.error("--system-key must be a path-safe identifier")
cases = read_jsonl(args.cases)
units = read_jsonl(args.alignment_units)
generations = read_jsonl(args.generations)
if not cases:
raise ValueError("Cases file is empty")
cases_by_id = {row["case_id"]: row for row in cases}
generations_by_id = {row["case_id"]: row for row in generations}
if len(cases_by_id) != len(cases) or len(generations_by_id) != len(generations):
raise ValueError("Duplicate case_id")
unexpected = set(generations_by_id) - set(cases_by_id)
if unexpected:
raise ValueError(f"Unexpected generations: {sorted(unexpected)}")
grouped_units: dict[str, list[dict]] = {case_id: [] for case_id in cases_by_id}
for unit in units:
grouped_units.setdefault(unit["case_id"], []).append(unit)
selected, failures = [], []
for case in cases:
case_id = case["case_id"]
run = generations_by_id.get(case_id)
if run is None:
if args.allow_incomplete:
failures.append({"case_id": case_id, "status": "missing"})
continue
raise ValueError(f"Missing generation for {case_id}")
status = run.get("status", "ok")
if not isinstance(status, str) or not status:
raise ValueError(f"Generation {case_id} has an invalid status")
if status != "ok":
failures.append({"case_id": case_id, "status": status})
if args.allow_incomplete:
continue
raise ValueError(f"Generation {case_id} has status={status}")
required = (
"mt", "finish_reason", "input_tokens", "output_tokens", "cap_hit",
"model_revision", "generation_config_sha256", "output_sha256"
)
missing = [key for key in required if key not in run]
if missing:
raise ValueError(f"Generation {case_id} missing {missing}")
if not isinstance(run["mt"], str) or not run["mt"]:
raise ValueError(f"Generation {case_id} has empty mt")
if sha_text(run["mt"]) != run["output_sha256"]:
raise ValueError(f"Generation {case_id} output hash mismatch")
case_units = sorted(grouped_units.get(case_id, []), key=lambda row: row["alignment_unit_index"])
if len(case_units) != case["alignment_unit_count"]:
raise ValueError(f"Alignment unit count mismatch for {case_id}")
canonical_source_lines = [row["source"] for row in case_units]
canonical_reference_lines = [row["reference"] for row in case_units]
reconstructed_source = "\n".join(canonical_source_lines)
reconstructed_reference = "\n".join(canonical_reference_lines)
source_matches = case["source"] in (reconstructed_source, reconstructed_source + "\n")
reference_matches = case["reference"] in (reconstructed_reference, reconstructed_reference + "\n")
if not source_matches or not reference_matches:
raise ValueError(f"Segment reconstruction mismatch for {case_id}")
# SEGALE aligns MT against source positions. Canonical units without a
# source position cannot enter VecAlign, but remain unchanged in the
# release alignment-units file and are explicitly counted here.
scored_units = [row for row in case_units if row["source"]]
if not scored_units:
raise ValueError(f"Generation {case_id} has no non-null source units")
source_lines = [row["source"] for row in scored_units]
reference_lines = [row["reference"] for row in scored_units]
segale_doc_id = "case-" + sha_text(case_id)[:24]
metadata = case.get("metadata", {})
if not isinstance(metadata, dict):
raise ValueError(f"Case {case_id} metadata must be an object")
metadata = dict(metadata)
for key in CASE_METADATA_FIELDS:
if key in case:
metadata[key] = case[key]
selected.append(
(case, run, source_lines, reference_lines, case_units, segale_doc_id, metadata)
)
segale_doc_ids = [row[5] for row in selected]
if len(segale_doc_ids) != len(set(segale_doc_ids)):
raise ValueError("SEGALE document ID collision")
args.output_dir.mkdir(parents=True, exist_ok=False)
reference_rows, system_rows, manifest_cases = [], [], []
for case, run, source_lines, reference_lines, canonical_units, segale_doc_id, metadata in selected:
case_id = case["case_id"]
for index, (source, reference) in enumerate(zip(source_lines, reference_lines, strict=True), 1):
reference_rows.append({"doc_id": segale_doc_id, "sys_id": "reference", "src": source, "tgt": reference, "seg_id": index})
system_rows.append({"doc_id": segale_doc_id, "sys_id": args.system_key, "src": case["source"], "tgt": run["mt"], "seg_id": 1})
manifest_cases.append({
"case_id": case_id,
"segale_doc_id": segale_doc_id,
"metadata": metadata,
"track_id": case.get("track_id"),
"split": case.get("split"),
"work_id": case.get("work_id"),
"official_directory_group": case.get("official_directory_group"),
"length_band": case.get("length_band"),
"window_family_id": case.get("window_family_id"),
"evaluation_source_lines": source_lines,
"canonical_alignment_unit_count": len(canonical_units),
"segale_source_unit_count": len(source_lines),
"canonical_null_source_count": sum(not row["source"] for row in canonical_units),
"canonical_null_reference_count": sum(not row["reference"] for row in canonical_units),
"segale_rendering": "non-null-source units in canonical order; canonical units remain in release alignment-units.jsonl",
"generation": {key: run.get(key) for key in (
"finish_reason", "input_tokens", "output_tokens", "cap_hit",
"model_revision", "generation_config_sha256", "output_sha256"
)},
})
write_jsonl(args.output_dir / "reference.jsonl", reference_rows)
write_jsonl(args.output_dir / "system.jsonl", system_rows)
manifest = {
"schema_version": "document-segale-adapter-v1",
"suite_id": args.suite_id,
"experiment": {
"suite_id": args.suite_id,
"system_key": args.system_key,
"track_ids": sorted(
{case["track_id"] for case, *_ in selected if case.get("track_id")}
),
"raw_output_preserved": True,
"output_cleanup": None,
},
"cases": manifest_cases,
"failures": failures,
}
(args.output_dir / "manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
print(f"Prepared {len(selected)} cases; omitted {len(failures)} non-success cases")
if __name__ == "__main__":
main()
|