| |
| """Build schema-stable JSONL files for the Hugging Face Dataset Viewer.""" |
|
|
| from __future__ import annotations |
|
|
| import json |
| import re |
| from pathlib import Path |
| from typing import Any |
|
|
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| OUTPUT_DIR = ROOT / "viewer" |
| IMAGE_TOKEN = re.compile(r"<image:([^>]+)>") |
|
|
| CONFIGS = { |
| "implicit_pattern": ( |
| "Implicit Pattern Induction", |
| "Implicit Pattern Generation", |
| 86, |
| ), |
| "symbolic_constraint": ( |
| "Ad-hoc Constraint Execution", |
| "Symbolic Constraint Generation", |
| 153, |
| ), |
| "visual_constraint": ( |
| "Ad-hoc Constraint Execution", |
| "Visual Constraint Generation", |
| 60, |
| ), |
| "prior_conflicting": ( |
| "Contextual Knowledge Adaptation", |
| "Prior-Conflicting Generation", |
| 101, |
| ), |
| "multi_semantic": ( |
| "Contextual Knowledge Adaptation", |
| "Multi-Semantic Generation", |
| 110, |
| ), |
| } |
|
|
|
|
| def normalize_hint(value: Any) -> str | None: |
| """Represent every optional hint as one nullable string column.""" |
| if value is None: |
| return None |
| if isinstance(value, str): |
| return value |
| if isinstance(value, list) and all(isinstance(item, str) for item in value): |
| return "\n".join(value) |
| raise TypeError(f"Unsupported hint value: {value!r}") |
|
|
|
|
| def image_paths(config_name: str, row: dict[str, Any]) -> list[str]: |
| """Resolve ordered, unique image tokens to repository-relative paths.""" |
| text_parts = [ |
| row.get("context", ""), |
| row.get("instruction", ""), |
| row.get("rc_hint", ""), |
| normalize_hint(row.get("vc_hint")) or "", |
| ] |
| names = IMAGE_TOKEN.findall("\n".join(text_parts)) |
| return list(dict.fromkeys(f"{config_name}/images/{name}.png" for name in names)) |
|
|
|
|
| def build_config(config_name: str, dimension: str, task: str, expected: int) -> int: |
| source_path = ROOT / config_name / "test_data.json" |
| rows = json.loads(source_path.read_text(encoding="utf-8")) |
| if not isinstance(rows, list) or len(rows) != expected: |
| raise ValueError(f"{source_path}: expected {expected} rows, found {len(rows)}") |
|
|
| output_path = OUTPUT_DIR / f"{config_name}.jsonl" |
| with output_path.open("w", encoding="utf-8") as output: |
| for source in rows: |
| record = { |
| "id": source["id"], |
| "dimension": dimension, |
| "task": task, |
| "sub_dimension": source["sub_dimension"], |
| "sub_sub_dimension": source.get("sub_sub_dimension"), |
| "context": source["context"], |
| "instruction": source["instruction"], |
| "rc_hint": source["rc_hint"], |
| "vc_hint": normalize_hint(source.get("vc_hint")), |
| "image_paths": image_paths(config_name, source), |
| } |
| output.write(json.dumps(record, ensure_ascii=False, separators=(",", ":"))) |
| output.write("\n") |
| return len(rows) |
|
|
|
|
| def main() -> None: |
| OUTPUT_DIR.mkdir(exist_ok=True) |
| total = sum( |
| build_config(config_name, dimension, task, expected) |
| for config_name, (dimension, task, expected) in CONFIGS.items() |
| ) |
| if total != 510: |
| raise ValueError(f"Expected 510 total rows, found {total}") |
| print(f"Wrote {total} records across {len(CONFIGS)} files to {OUTPUT_DIR}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
