#!/usr/bin/env python3 """Build the minimal, fully rehydrated WildDelusion benchmark release.""" from __future__ import annotations import argparse import hashlib import json from collections import Counter from pathlib import Path from typing import Any import pyarrow as pa import pyarrow.parquet as pq ROLE_ALIASES = { "user": "user", "human": "user", "assistant": "assistant", "llm": "assistant", "model": "assistant", "ai": "assistant", } def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--verified-targets", type=Path, required=True) parser.add_argument("--rehydrated-histories", type=Path, required=True) parser.add_argument("--output-dir", type=Path, default=Path("hf_dataset")) return parser.parse_args() def sha256(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for chunk in iter(lambda: handle.read(1024 * 1024), b""): digest.update(chunk) return digest.hexdigest() def target_key(row: dict[str, Any]) -> tuple[str, str]: return str(row["source"]), str(row["message_hash"]) def normalize_messages(messages: list[dict[str, Any]]) -> list[dict[str, str]]: normalized = [] for message in messages: raw_role = str(message.get("role", "")).strip().lower() role = ROLE_ALIASES.get(raw_role) if role is None: raise ValueError(f"Unsupported message role: {raw_role!r}") content = str(message.get("content") or "") if not content: raise ValueError("Empty message content in rehydrated transcript") normalized.append({"role": role, "content": content}) return normalized def canonical_digest(rows: list[dict[str, Any]]) -> str: payload = json.dumps( rows, ensure_ascii=False, sort_keys=True, separators=(",", ":"), ).encode("utf-8") return hashlib.sha256(payload).hexdigest() def main() -> None: args = parse_args() verified = pq.read_table(args.verified_targets).to_pylist() rehydrated = pq.read_table(args.rehydrated_histories).to_pylist() history_by_key = {target_key(row): row for row in rehydrated} if len(history_by_key) != len(rehydrated): raise ValueError("Rehydrated input contains duplicate source/message keys") rows: list[dict[str, Any]] = [] history_methods: Counter[str] = Counter() unavailable_nontext_rows = 0 unavailable_nontext_messages = 0 for verified_row in verified: key = target_key(verified_row) if key not in history_by_key: raise ValueError(f"No rehydrated history for {key}") history = history_by_key[key] messages = normalize_messages(history["messages"]) target_index = int(history["target_message_index"]) target_text = str(verified_row["target_text"]) if not bool(history.get("history_complete")): raise ValueError(f"History is not marked complete for {key}") if not 0 <= target_index < len(messages): raise ValueError(f"Target index is out of range for {key}") if messages[target_index]["role"] != "user": raise ValueError(f"Target does not point to a user turn for {key}") if messages[target_index]["content"] != target_text: raise ValueError(f"Target text/index mismatch for {key}") if str(history["target_text"]) != target_text: raise ValueError(f"Verified and rehydrated target text differ for {key}") if not any(message["role"] == "assistant" for message in messages): raise ValueError(f"Transcript has no assistant messages for {key}") unavailable = int(history.get("history_unavailable_message_count") or 0) unavailable_nontext_rows += int(unavailable > 0) unavailable_nontext_messages += unavailable history_methods[str(history.get("history_rehydration_method"))] += 1 rows.append( { "example_id": str(verified_row["message_hash"]), "source": str(verified_row["source"]), "conversation_id": str(verified_row["conversation_id"]), "messages": messages, "target_message_index": target_index, "target_text": target_text, } ) if len(rows) != len(verified): raise ValueError("Output row count differs from verified target count") if len({row["example_id"] for row in rows}) != len(rows): raise ValueError("Output contains duplicate example IDs") schema = pa.schema( [ pa.field("example_id", pa.string(), nullable=False), pa.field("source", pa.string(), nullable=False), pa.field("conversation_id", pa.string(), nullable=False), pa.field( "messages", pa.list_( pa.struct( [ pa.field("role", pa.string(), nullable=False), pa.field("content", pa.string(), nullable=False), ] ) ), nullable=False, ), pa.field("target_message_index", pa.int32(), nullable=False), pa.field("target_text", pa.string(), nullable=False), ] ) data_dir = args.output_dir / "data" data_dir.mkdir(parents=True, exist_ok=True) output_path = data_dir / "train-00000-of-00001.parquet" table = pa.Table.from_pylist(rows, schema=schema) pq.write_table(table, output_path, compression="zstd") role_counts = Counter( message["role"] for row in rows for message in row["messages"] ) source_counts = Counter(row["source"] for row in rows) prior_assistant_rows = sum( any(message["role"] == "assistant" for message in row["messages"][: row["target_message_index"]]) for row in rows ) integrity = { "passed": True, "rows": len(rows), "distinct_source_conversations": len( {(row["source"], row["conversation_id"]) for row in rows} ), "duplicate_example_ids": 0, "target_index_errors": 0, "target_text_errors": 0, "non_user_targets": 0, "rows_without_assistant_messages": 0, "rows_with_prior_assistant_context": prior_assistant_rows, "rows_without_prior_assistant_context": len(rows) - prior_assistant_rows, "message_role_counts": dict(sorted(role_counts.items())), "message_count_total": sum(len(row["messages"]) for row in rows), "message_count_min": min(len(row["messages"]) for row in rows), "message_count_max": max(len(row["messages"]) for row in rows), "rows_with_nontext_assistant_placeholders": unavailable_nontext_rows, "nontext_assistant_placeholders": unavailable_nontext_messages, "history_rehydration_method_counts": dict(sorted(history_methods.items())), "parquet_sha256": sha256(output_path), "canonical_sha256": canonical_digest(rows), } manifest = { "dataset": "danielfein/WildDelusionBenchmark", "unit": "Gemini-verified user target turn in a complete source conversation", "rows": len(rows), "source_target_counts": dict(sorted(source_counts.items())), "selection": { "source_dataset": "danielfein/WildDelusionCombined", "source_revision": "4749e769261c6b068da4a42aa0f91ff4903c2985", "source_parquet_sha256": sha256(args.verified_targets), "judge_model": "gemini-3-flash-preview", "taxonomy": "Moore et al. user-endorses-delusion", "threshold": 7, "required_views": ["target_only", "three_preceding_turns"], "pre_filter_rows": len(rehydrated), "retained_rows": len(rows), }, "history": { "rehydrated_parquet_sha256": sha256(args.rehydrated_histories), "sharechat_revision": "6fb3e27bba4185e8c05f9b8b3c5ca972192ad036", "wildchat_revision": "eedff4afb0239e69217ffd1c276e2ba45bbfdd45", "roles_normalized_to": ["user", "assistant"], }, "data_file": str(output_path.relative_to(args.output_dir)), "data_file_sha256": integrity["parquet_sha256"], "integrity_report": "integrity_report.json", } (args.output_dir / "integrity_report.json").write_text( json.dumps(integrity, indent=2) + "\n", encoding="utf-8" ) (args.output_dir / "manifest.json").write_text( json.dumps(manifest, indent=2) + "\n", encoding="utf-8" ) print(json.dumps({"manifest": manifest, "integrity": integrity}, indent=2)) if __name__ == "__main__": main()