Simplify dataset builder

scripts/build_dataset.py

@@ -5,10 +5,8 @@ from __future__ import annotations
 
 import argparse
 import copy
-import hashlib
 import json
 import re
-import zipfile
 from collections import Counter
 from pathlib import Path
 from typing import Any
@@ -77,7 +75,11 @@ EXPECTED_BASE_COUNTS = {
     5: 60,
     13: 60,
 }
-EXPECTED_DERIVED_COUNTS = {14: 30, 15: 80}
+EXPECTED_BENCHMARK_COUNTS = {
+    **EXPECTED_BASE_COUNTS,
+    14: 30,
+    15: 80,
+}
 
 
 def snake_case(name: str) -> str:
@@ -106,15 +108,7 @@ def read_task_file(path: Path) -> dict[str, Any]:
     return task
 
 
-def make_record(
-    task: dict[str, Any],
-    *,
-    source_file: str,
-    release_role: str,
-    is_derived: bool,
-    derivation: str = "",
-    variant_prefix: str = "",
-) -> dict[str, Any]:
+def make_record(task: dict[str, Any]) -> dict[str, Any]:
     task_type_id = int(task["type"])
     if task_type_id not in TYPE_INFO:
         raise ValueError(f"{task['id']}: unsupported task type {task_type_id}")
@@ -123,7 +117,7 @@ def make_record(
     payload = snake_case_keys(copy.deepcopy(task))
     task_id = str(payload.pop("id"))
     payload.pop("type")
-    source_task_id = str(payload.pop("source_task_id", "") or "")
+    payload.pop("source_task_id", None)
 
     qa_answer_text = ""
     qa_options = payload.get("qa_options", [])
@@ -143,12 +137,6 @@ def make_record(
         "task_abbreviation": abbreviation,
         "capability_level": level,
         "capability_name": capability,
-        "release_role": release_role,
-        "is_derived": is_derived,
-        "derivation": derivation,
-        "source_task_id": source_task_id,
-        "source_file": source_file,
-        "variant_prefix": variant_prefix,
         "qa_answer_text": qa_answer_text,
         "poi_category_name": poi_category_name,
     }
@@ -156,18 +144,21 @@ def make_record(
     return record
 
 
-def derive_level_five(source: dict[str, Any], target_type: int) -> dict[str, Any]:
+def make_level_five_task(source: dict[str, Any], target_type: int) -> dict[str, Any]:
     if target_type == 14 and source["type"] != 11:
-        raise ValueError("DCR must be derived from a constrained-navigation task")
+        raise ValueError("DCR requires constrained-navigation task geometry")
     if target_type == 15 and source["type"] != 2:
-        raise ValueError("NP must be derived from a long-range navigation task")
+        raise ValueError("NP requires long-range navigation task geometry")
 
-    derived = copy.deepcopy(source)
+    task = copy.deepcopy(source)
     abbreviation = TYPE_INFO[target_type][1]
-    derived["id"] = f"{abbreviation}::{source['id']}"
-    derived["type"] = target_type
-    derived["sourceTaskId"] = source["id"]
-    return derived
+    _, separator, suffix = str(source["id"]).partition("-")
+    if not separator:
+        raise ValueError(f"{source['id']}: expected a prefixed task id")
+    task["id"] = f"{abbreviation}-{suffix}"
+    task["type"] = target_type
+    task["sourceTaskId"] = ""
+    return task
 
 
 def write_jsonl(path: Path, records: list[dict[str, Any]]) -> None:
@@ -177,40 +168,6 @@ def write_jsonl(path: Path, records: list[dict[str, Any]]) -> None:
             handle.write("\n")
 
 
-def write_raw_archive(
-    archive_path: Path,
-    task_paths: list[Path],
-    manifest: dict[str, Any],
-) -> list[str]:
-    checksums: list[str] = []
-    with zipfile.ZipFile(
-        archive_path,
-        "w",
-        compression=zipfile.ZIP_DEFLATED,
-        compresslevel=9,
-    ) as archive:
-        for path in task_paths:
-            raw = path.read_bytes()
-            digest = hashlib.sha256(raw).hexdigest()
-            checksums.append(f"{digest}  task/{path.name}")
-
-            info = zipfile.ZipInfo(f"task/{path.name}", date_time=(1980, 1, 1, 0, 0, 0))
-            info.compress_type = zipfile.ZIP_DEFLATED
-            info.external_attr = 0o644 << 16
-            archive.writestr(info, raw, compresslevel=9)
-
-        manifest_info = zipfile.ZipInfo("manifest.json", date_time=(1980, 1, 1, 0, 0, 0))
-        manifest_info.compress_type = zipfile.ZIP_DEFLATED
-        manifest_info.external_attr = 0o644 << 16
-        archive.writestr(
-            manifest_info,
-            json.dumps(manifest, ensure_ascii=False, indent=2, sort_keys=True).encode("utf-8")
-            + b"\n",
-            compresslevel=9,
-        )
-    return checksums
-
-
 def build(source_dir: Path, output_dir: Path) -> None:
     task_paths = sorted(source_dir.glob("*.json"), key=lambda path: path.name)
     if not task_paths:
@@ -221,64 +178,33 @@ def build(source_dir: Path, output_dir: Path) -> None:
     if len(ids) != len(set(ids)):
         raise ValueError("duplicate task ids found")
 
-    base_tasks: list[tuple[Path, dict[str, Any]]] = []
-    auxiliary_tasks: list[tuple[Path, dict[str, Any]]] = []
+    benchmark_source_tasks: list[dict[str, Any]] = []
     for path, task in stored_tasks:
         prefix = task["id"].split("-", 1)[0]
         expected_type = BASE_PREFIX_TO_TYPE.get(prefix)
         if expected_type is None:
-            auxiliary_tasks.append((path, task))
             continue
         if task["type"] != expected_type:
             raise ValueError(
                 f"{task['id']}: prefix expects type {expected_type}, got {task['type']}"
             )
-        base_tasks.append((path, task))
+        benchmark_source_tasks.append(task)
 
-    base_counts = Counter(task["type"] for _, task in base_tasks)
+    base_counts = Counter(task["type"] for task in benchmark_source_tasks)
     if dict(base_counts) != EXPECTED_BASE_COUNTS:
         raise ValueError(
             f"base task counts changed: expected {EXPECTED_BASE_COUNTS}, got {dict(base_counts)}"
         )
 
-    base_ids = {task["id"] for _, task in base_tasks}
-    for _, task in auxiliary_tasks:
-        source_id = str(task.get("sourceTaskId", "") or "")
-        if source_id and source_id not in base_ids:
-            raise ValueError(f"{task['id']}: missing source task {source_id}")
-
     benchmark_records: list[dict[str, Any]] = []
-    for path, task in base_tasks:
-        benchmark_records.append(
-            make_record(
-                task,
-                source_file=f"task/{path.name}",
-                release_role="stored_base",
-                is_derived=False,
-            )
-        )
+    for task in benchmark_source_tasks:
+        benchmark_records.append(make_record(task))
 
-    for path, task in base_tasks:
+    for task in benchmark_source_tasks:
         if task["type"] == 11:
-            benchmark_records.append(
-                make_record(
-                    derive_level_five(task, 14),
-                    source_file=f"task/{path.name}",
-                    release_role="derived_level_5",
-                    is_derived=True,
-                    derivation="dynamic_road_closure_from_constrained_navigation",
-                )
-            )
+            benchmark_records.append(make_record(make_level_five_task(task, 14)))
         elif task["type"] == 2:
-            benchmark_records.append(
-                make_record(
-                    derive_level_five(task, 15),
-                    source_file=f"task/{path.name}",
-                    release_role="derived_level_5",
-                    is_derived=True,
-                    derivation="pedestrian_navigation_from_long_range_navigation",
-                )
-            )
+            benchmark_records.append(make_record(make_level_five_task(task, 15)))
 
     benchmark_records.sort(
         key=lambda record: (
@@ -290,54 +216,29 @@ def build(source_dir: Path, output_dir: Path) -> None:
     for index, record in enumerate(benchmark_records):
         record["instance_index"] = index
 
-    derived_counts = Counter(
-        record["task_type_id"] for record in benchmark_records if record["is_derived"]
-    )
-    if dict(derived_counts) != EXPECTED_DERIVED_COUNTS:
+    benchmark_type_counts = Counter(record["task_type_id"] for record in benchmark_records)
+    if dict(benchmark_type_counts) != EXPECTED_BENCHMARK_COUNTS:
         raise ValueError(
-            f"derived task counts changed: expected {EXPECTED_DERIVED_COUNTS}, got {dict(derived_counts)}"
+            "benchmark task counts changed: "
+            f"expected {EXPECTED_BENCHMARK_COUNTS}, got {dict(benchmark_type_counts)}"
         )
     if len(benchmark_records) != 810:
         raise ValueError(f"expected 810 benchmark instances, got {len(benchmark_records)}")
 
-    auxiliary_records: list[dict[str, Any]] = []
-    for path, task in auxiliary_tasks:
-        prefix = task["id"].split("-", 1)[0]
-        auxiliary_records.append(
-            make_record(
-                task,
-                source_file=f"task/{path.name}",
-                release_role="auxiliary_variant",
-                is_derived=False,
-                variant_prefix=prefix,
-            )
-        )
-    auxiliary_records.sort(key=lambda record: record["id"])
-    for index, record in enumerate(auxiliary_records):
-        record["instance_index"] = index
-    if len(auxiliary_records) != 28:
-        raise ValueError(f"expected 28 auxiliary variants, got {len(auxiliary_records)}")
-
     data_dir = output_dir / "data"
-    raw_dir = output_dir / "raw"
     metadata_dir = output_dir / "metadata"
     data_dir.mkdir(parents=True, exist_ok=True)
-    raw_dir.mkdir(parents=True, exist_ok=True)
     metadata_dir.mkdir(parents=True, exist_ok=True)
 
     write_jsonl(data_dir / "benchmark.jsonl", benchmark_records)
-    write_jsonl(data_dir / "auxiliary_variants.jsonl", auxiliary_records)
 
     benchmark_counts = Counter(
         (record["capability_level"], record["task_abbreviation"])
         for record in benchmark_records
     )
     statistics = {
-        "stored_task_files": len(stored_tasks),
-        "stored_benchmark_source_files": len(base_tasks),
-        "stored_auxiliary_variant_files": len(auxiliary_tasks),
-        "materialized_level_5_instances": sum(EXPECTED_DERIVED_COUNTS.values()),
-        "paper_benchmark_instances": len(benchmark_records),
+        "total_instances": len(benchmark_records),
+        "splits": {"test": len(benchmark_records)},
         "benchmark_counts": [
             {
                 "capability_level": level,
@@ -352,31 +253,7 @@ def build(source_dir: Path, output_dir: Path) -> None:
         encoding="utf-8",
     )
 
-    manifest = {
-        "dataset": "UrbanGround Tasks",
-        "dataset_url": "https://huggingface.co/datasets/jometeorie/urbanground-tasks",
-        "format_version": 1,
-        "license": "MIT",
-        "paper": "arXiv:2608.27456",
-        "paper_url": "https://arxiv.org/abs/2608.27456",
-        "project_url": "https://github.com/UrbanGround/UrbanGround",
-        "source_application_release": "v1.0.0",
-        **statistics,
-    }
-    checksums = write_raw_archive(
-        raw_dir / "urbanground-app-task-files-v1.0.0.zip",
-        task_paths,
-        manifest,
-    )
-    (raw_dir / "task-files.sha256").write_text("\n".join(checksums) + "\n", encoding="utf-8")
-    (raw_dir / "manifest.json").write_text(
-        json.dumps(manifest, ensure_ascii=False, indent=2, sort_keys=True) + "\n",
-        encoding="utf-8",
-    )
-
-    print(f"Built {len(benchmark_records)} benchmark records")
-    print(f"Built {len(auxiliary_records)} auxiliary records")
-    print(f"Archived {len(task_paths)} App-compatible task files")
+    print(f"Built {len(benchmark_records)} UrbanGround task records")
 
 
 def parse_args() -> argparse.Namespace: