"""Build two lossless placement configurations from the frozen paired CoQAR run. Offline only: this module never generates new model outputs or contacts the Hub. """ from __future__ import annotations import argparse from collections import Counter from datetime import datetime, timezone import hashlib import importlib.metadata import json from pathlib import Path import platform import shlex import shutil import socket import subprocess import sys import pyarrow as pa import pyarrow.parquet as pq ROOT = Path(__file__).resolve().parent VERSION = "coqar-placements-v1" BUNDLED_RENAMES = {"test_export_hub.py": "check_export_hub.py", "test_publish_hub.py": "check_publish_hub.py"} SOURCE_HASHES = { "subset.json": "2f4bd4532b5844658c92556f71e27ebce81d529ad49936d63f5ab7e213183c58", "original_validation.json": "a0166311735f6e2e41472bb1e92fddaf7b168993b77e6f55857cdcaddb18bee7", "modified_validation.json": "c245e77812226e6e80732d587c84ceb037ab6c374f0d38624ebf8d55d9b4ba89", } def canonical(value): return json.dumps(value, ensure_ascii=False, sort_keys=True, allow_nan=False) def digest(path): h = hashlib.sha256() with Path(path).open("rb") as handle: for chunk in iter(lambda: handle.read(1024 * 1024), b""): h.update(chunk) return h.hexdigest() def save_json(path, value): Path(path).write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False) + "\n") def require(condition, message): if not condition: raise ValueError(message) def validate_example(example, source): original = example["original_story"] require(original == source["story"], "Original passage differs from raw source") q = next(q for q in source["questions"] if q["turn_id"] == example["turn_id"]) require(example["question"] == next(s for s in q["paraphrase"] if s.strip()), "Question differs from the first nonempty rewrite") a = next(a for a in source["answers"] if a["turn_id"] == example["turn_id"]) require(a == example["gold_answer_annotation"], "Rationale annotation differs from raw source") start, end = a["span_start"], a["span_end"] require(0 <= start < end <= len(original), "Invalid rationale interval") expected = [s for s in example["sentences"] if s["start"] < end and start < s["end"]] removed = example["removed_sentences"] require(removed == expected and bool(removed), "Wrong overlapping sentences") cursor, fragments = 0, [] for sentence in removed: lo, hi = sentence["start"], sentence["end"] require(cursor <= lo < hi <= len(original), "Unsorted or invalid deletion bounds") require(original[lo:hi] == sentence["text"], "Deleted sentence text mismatch") fragments.append(original[cursor:lo]) cursor = hi fragments.append(original[cursor:]) require("".join(fragments) == example["modified_story"], "Retained passage mismatch") return removed[0]["start"], removed[-1]["end"] def place_addition(story, raw_addition, placement, anchor): """Return reversible insertion metadata without changing existing characters.""" require(placement in ("appended", "inserted"), "Unknown placement") require(type(anchor) is int and 0 <= anchor <= len(story), "Invalid insertion offset") addition = raw_addition.strip() if placement == "appended": anchor = len(story) prefix = ("\n\n" if placement == "appended" or anchor > 0 else "") if addition else "" suffix = "\n\n" if addition and placement == "inserted" and anchor < len(story) else "" block = prefix + addition + suffix text = story[:anchor] + block + story[anchor:] result = { "applied_addition": addition, "clarified_story": text, "unchanged": text == story, "inserted_block_start": anchor, "inserted_block_end": anchor + len(block), "addition_start": anchor + len(prefix), "addition_end": anchor + len(prefix) + len(addition), "prefix_separator": prefix, "suffix_separator": suffix, } require(text[:result["inserted_block_start"]] + text[result["inserted_block_end"]:] == story, "Insertion is not reversible") require(text[result["addition_start"]:result["addition_end"]] == addition, "Inserted content differs from generated addition") return result def verify_call(call, story, question, menu=None, selected_id=None): require(call and call["status"] == "completed", "Missing completed generation call") request = call["request"] require(hashlib.sha256(canonical(request).encode()).hexdigest() == call["request_sha256"], "Generation request hash mismatch") require(json.loads(call["text"]) == call["parsed"], "Generation response mismatch") require(request["input"].startswith("Input JSON:\n"), "Unexpected request input") payload = json.loads(request["input"][len("Input JSON:\n"):]) expected = {"story": story, "question": question} if menu is not None: expected.update(menu=menu, selected_id=selected_id) require(payload == expected, "Unexpected model-visible fields or values") return request def recovery_record(row): if not row.get("recovery_history"): return None def trim_call(call): return {k: call.get(k) for k in ("id", "attempt_id", "status", "request", "request_sha256", "text")} return { "initial_failed_stages": row["initial_failed_stages"], "history": row["recovery_history"], "initial_failed_stage_calls": {stage: [trim_call(c) for c in calls] for stage, calls in row["initial_failed_stage_calls"].items()}, "recovery_attempt_calls": [trim_call(c) for c in row.get("recovery_attempt_calls", [])], "original_result_sha256": row["recovery_original_sha256"], } def make_row(example, saved, condition, placement, anchors): damaged = condition == "damaged" story = example["modified_story" if damaged else "original_story"] require(saved["input_story"] == story and saved["question"] == example["question"], "Saved generation uses different inputs") require(saved["original_story"] == example["original_story"] and saved["modified_story"] == example["modified_story"], "Source pair differs") require(not saved.get("missing") and len(saved["clarifications"]) == 5, "Incomplete source row") anchor = len(story) if placement == "appended" else anchors[0 if damaged else 1] menu = saved["interpretation_stage"]["menu"] menu_call = saved["interpretation_stage"]["call"] verify_call(menu_call, story, example["question"]) recovery = recovery_record(saved) samples = [] for index, sample in enumerate(saved["clarifications"]): require(sample["sample_index"] == index and sample["valid_format"], "Invalid sample ordering/format") require(not sample["provenance_errors"], "Source sample has provenance errors") request = verify_call(sample["generation_call"], story, example["question"], menu, sample["selected_id"]) parsed = sample["generation_call"]["parsed"] for key in ("status", "addition", "justification"): require(sample[key] == parsed[key], "Saved sample differs from raw model output") expected_append = story + "\n\n" + sample["addition"].strip() if sample["addition"].strip() else story require(sample["clarified_story"] == expected_append, "Saved appended story differs") materialized = place_addition(story, sample["addition"], placement, anchor) if placement == "appended": require(materialized["clarified_story"] == sample["clarified_story"], "Appended export differs") samples.append({ **{k: sample[k] for k in ("sample_index", "status", "addition", "justification", "selected_id", "uniform_draw", "seed_text", "normalization")}, **materialized, "generation_request_json": canonical(request), "generation_response_text": sample["generation_call"]["text"], "audit_json": canonical(sample["audit_assessment"]) if sample.get("audit_assessment") else None, "audit_applies_to_placement": "appended" if sample.get("audit_assessment") else None, "contract_errors": sample.get("business_contract_errors", []), }) return { "id": example["id"] + ":" + condition, "pair_id": example["id"], "source_split": example["split"], "story_id": example["story_id"], "turn_id": example["turn_id"], "source": example["source"], "condition": condition, "is_underspecified": damaged, "placement": placement, "question": example["question"], "input_story": story, "original_story": example["original_story"], "damaged_story": example["modified_story"], "gold_answer_original": example["gold_answer"], "rationale_start": example["span_diagnostics"]["start"], "rationale_end": example["span_diagnostics"]["end"], "rationale_text": example["span_diagnostics"]["offset_text"], "rationale_sentences": example["removed_sentences"], "removed_sentences": example["removed_sentences"] if damaged else [], "insertion_offset": anchor, "menu_json": canonical(menu), "menu_request_json": canonical(menu_call["request"]), "menu_response_text": menu_call["text"], "menu_contract_errors": saved["interpretation_stage"]["business_contract_errors"], "recovery_kind": "+".join(saved["initial_failed_stages"]) if recovery else None, "recovery_history_json": canonical(recovery) if recovery else None, "clarifications": samples, } def arrow_schema(metadata): sentence = pa.struct([(k, t) for k, t in (("sentence_index", pa.int64()), ("start", pa.int64()), ("end", pa.int64()), ("text", pa.string()))]) sample = pa.struct([ ("sample_index", pa.int64()), ("status", pa.string()), ("addition", pa.string()), ("applied_addition", pa.string()), ("justification", pa.string()), ("clarified_story", pa.string()), ("unchanged", pa.bool_()), ("selected_id", pa.string()), ("uniform_draw", pa.float64()), ("seed_text", pa.string()), ("normalization", pa.float64()), *[(key, pa.int64()) for key in ("inserted_block_start", "inserted_block_end", "addition_start", "addition_end")], *[(key, pa.string()) for key in ("prefix_separator", "suffix_separator", "generation_request_json", "generation_response_text", "audit_json", "audit_applies_to_placement")], ("contract_errors", pa.list_(pa.string())), ]) fields = [(k, pa.string()) for k in ("id", "pair_id", "source_split", "story_id")] fields += [("turn_id", pa.int64()), ("source", pa.string()), ("condition", pa.string()), ("is_underspecified", pa.bool_())] fields += [(k, pa.string()) for k in ("placement", "question", "input_story", "original_story", "damaged_story", "gold_answer_original")] fields += [("rationale_start", pa.int64()), ("rationale_end", pa.int64()), ("rationale_text", pa.string()), ("rationale_sentences", pa.list_(sentence)), ("removed_sentences", pa.list_(sentence)), ("insertion_offset", pa.int64())] fields += [(k, pa.string()) for k in ("menu_json", "menu_request_json", "menu_response_text")] fields += [("menu_contract_errors", pa.list_(pa.string())), ("recovery_kind", pa.string()), ("recovery_history_json", pa.string()), ("clarifications", pa.list_(sample))] return pa.schema(fields, metadata={b"coqar_provenance": canonical(metadata).encode()}) def capture_metadata(run, repo_id, manifest): def git(*args): return subprocess.check_output(["git", *args], cwd=ROOT, text=True).strip() require(not git("status", "--porcelain", "--untracked-files=all"), "Commit export code before generating artifacts") commit = git("rev-parse", "HEAD") sources = {name: digest(run / name) for name in (*SOURCE_HASHES, "manifest.json")} for name, expected in SOURCE_HASHES.items(): require(sources[name] == expected, f"Frozen source changed: {name}") for name, expected in manifest["implementation"].items(): require(digest(ROOT / name) == expected, f"Frozen generation code changed: {name}") publication_id = hashlib.sha256(canonical({"version": VERSION, "sources": sources, "commit": commit}).encode()).hexdigest() return { "schema_version": VERSION, "publication_id": publication_id, "commit_hash": commit, "bundled_source_renames": BUNDLED_RENAMES, "repo": {"path": str(ROOT), "remote": git("config", "--get-regexp", "^remote\\..*\\.url$") if git("remote") else None}, "git_clean": True, "timestamp_utc": datetime.now(timezone.utc).isoformat(), "commands": [{"cwd": str(Path.cwd()), "command": shlex.join([sys.executable, *sys.argv])}], "configs": {"repo_id": repo_id, "visibility": "public", "configurations": ["appended", "inserted"], "split": "dev", "rows_per_config": 2000, "samples_per_row": 5, "offsets": "half-open Python Unicode character indices", "empty_additions": "exact input preserved", "inserted_damaged_anchor": "first removed sentence start", "inserted_undamaged_anchor": "last overlapping sentence end", "inserted_separators": "two newlines on each nonempty input side; retain all existing whitespace"}, "dataset": {"name": "CoQAR", "upstream": manifest["dataset"], "source_file_sha256": sources}, "model": manifest["model"], "generation_commit_hash": manifest["commit_hash"], "generation_experiment_fingerprint": manifest["experiment_fingerprint"], "seeds": manifest["seeds"], "prompts": manifest["prompts"], "environment": {"python": sys.version, "platform": platform.platform(), "packages": {name: importlib.metadata.version(name) for name in ("pyarrow", "datasets", "huggingface_hub")}}, "compute": {"hostname": socket.gethostname(), "execution": "local CPU; offline transformation"}, } def public_metadata(metadata): """Keep provenance facts; omit host identity and local absolute paths from Hub files.""" result = json.loads(canonical(metadata)) result["repo"]["path"] = "coqar_experiment (absolute local path withheld)" result["commands"] = [{"cwd": "coqar_experiment", "command": "python export_hub.py --repo-id " + result["configs"]["repo_id"]}] result["commands_note"] = "Portable equivalent; exact invocation retained in local export_provenance.json" result["compute"]["hostname"] = "withheld from public release" for source in result["dataset"]["upstream"]["sources"]: source["path"] = Path(source["path"]).name return result def export_bundle(run, output, repo_id): manifest = json.loads((run / "manifest.json").read_text()) metadata = capture_metadata(run, repo_id, manifest) require(not output.exists() or not any(output.iterdir()), "Output bundle already exists; choose a new directory") output.mkdir(parents=True, exist_ok=True) save_json(output.parent / "export_provenance.json", metadata) metadata = public_metadata(metadata) subset = json.loads((run / "subset.json").read_text()) examples = subset["examples"] require(len(examples) == 1000 and len({e["id"] for e in examples}) == 1000, "Expected 1000 distinct turns") raw_path = ROOT / manifest["configs"]["source_path"] require(digest(raw_path) == manifest["dataset"]["sources"][0]["sha256"], "Raw source hash changed") raw = {s["id"]: s for s in json.loads(raw_path.read_text())["data"]} anchors = {e["id"]: validate_example(e, raw[e["story_id"]]) for e in examples} rows = {"appended": [], "inserted": []} for internal, condition in (("original", "undamaged"), ("modified", "damaged")): source = json.loads((run / f"{internal}_validation.json").read_text())["samples"] require(set(source) == {e["id"] for e in examples}, "Export membership differs from subset") for example in examples: pair = [make_row(example, source[example["id"]], condition, placement, anchors[example["id"]]) for placement in rows] for sample_a, sample_b in zip(pair[0]["clarifications"], pair[1]["clarifications"]): for key in ("addition", "generation_request_json", "generation_response_text", "selected_id", "uniform_draw"): require(sample_a[key] == sample_b[key], "Placement changed generation or sampling") for placement, row in zip(rows, pair): rows[placement].append(row) del source stats = {} for placement, records in rows.items(): path = output / "data" / placement / "dev.parquet" path.parent.mkdir(parents=True, exist_ok=True) table = pa.Table.from_pylist(records, schema=arrow_schema({**metadata, "placement": placement})) pq.write_table(table, path, compression="zstd", row_group_size=25) loaded = pq.read_table(path) require(loaded.to_pylist() == records, "Parquet round trip changed data") require(json.loads(loaded.schema.metadata[b"coqar_provenance"])["publication_id"] == metadata["publication_id"], "Embedded provenance missing") stats[placement] = {"rows": len(records), "outputs": sum(len(r["clarifications"]) for r in records), "conditions": dict(Counter(r["condition"] for r in records)), "unchanged": {c: sum(s["unchanged"] for r in records if r["condition"] == c for s in r["clarifications"]) for c in ("undamaged", "damaged")}} shutil.copyfile(ROOT / "hub_dataset_card.md", output / "README.md") shutil.copyfile(ROOT / "hub_LICENSE.txt", output / "LICENSE") save_json(output / "provenance.json", metadata) code = output / "code" code.mkdir() names = ["export_hub.py", "publish_hub.py", "test_export_hub.py", "test_publish_hub.py", "requirements-hub.txt", "hub_dataset_card.md", "hub_LICENSE.txt", "SCALE_RUN.md", "build_dataset.py", "scale_prepare.py", "scale_pipeline.py", "scale_client.py", "scale_export.py", "scale_recover.py", "scale_recovery_export.py", "scale_costs.py", "run_pilot.py", "requirements.txt", "configs/coqar_dev1000_low.json", "prompts/latent_v2_menu.txt", "prompts/latent_v2_render.txt", "prompts/audit_samples.txt"] for name in names: # Older datasets loaders scan test_* filenames before reading configs; # keep runnable test sources without advertising a spurious test split. destination = code / BUNDLED_RENAMES.get(name, name) destination.parent.mkdir(parents=True, exist_ok=True) shutil.copyfile(ROOT / name, destination) validation = {"metadata": metadata, "passed": True, "configurations": stats, "checks": ["source hashes", "all 1000 source reconstructions", "all 10000 generation requests and outputs", "exact saved appended outputs", "reversible insertion for every output", "paired additions and draws", "Parquet round trip and embedded provenance"], "published_files": {str(p.relative_to(output)): digest(p) for p in sorted(output.rglob("*")) if p.is_file()}} save_json(output / "validation.json", validation) return {"bundle": str(output), "publication_id": metadata["publication_id"], "configurations": stats, "bytes": sum(p.stat().st_size for p in output.rglob("*") if p.is_file())} def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--run-dir", type=Path, default=ROOT / "results/dev1000_low_seed20260911") parser.add_argument("--output-dir", type=Path, default=ROOT / "results/huggingface_coqar_v1") parser.add_argument("--repo-id", default="rvashurin/coqar-clarifications") args = parser.parse_args() print(json.dumps(export_bundle(args.run_dir.resolve(), args.output_dir.resolve(), args.repo_id), indent=2)) if __name__ == "__main__": main()