Update bulk_download.py

bulk_download.py

@@ -3,7 +3,7 @@
 Downloads whole shard tars from allenai/molmobot-data, decompresses each
 inner .tar.zst archive, and extracts its contents into:
 
-    <target_dir>/<task_config>/part<X>/train/…
+    <target_dir>/<task_config>/part<X>/<split>/…
 
 A local JSON manifest tracks progress per-shard so that interrupted
 downloads can be resumed without re-extracting already-completed shards.
@@ -74,8 +74,10 @@ def _load_manifest(target_dir: str) -> dict:
 
         {
             "<config_name>": {
-                "num_completed_entries": [120, 124, ...]
-                "completed_shards": [0, 1, ...]
+                "<split>": {
+                    "num_completed_entries": [120, 124, ...],
+                    "completed_shards": [0, 1, ...],
+                }
             },
             ...
         }
@@ -99,13 +101,13 @@ def _save_manifest(target_dir: str, manifest: dict) -> None:
     tmp.replace(p)
 
 
-def load_entries(config_name: str) -> list[dict]:
+def load_entries(config_name: str, split: str) -> list[dict]:
     """Load the parquet arrow table for a task config as a list of dicts."""
-    ds = load_dataset(REPO, name=config_name, split="pkgs")
+    ds = load_dataset(REPO, name=config_name, split=f"{split}_pkgs")
     return [row for row in ds]
 
 
-def summarize_config(config_name: str, entries: list[dict]) -> dict:
+def summarize_config(config_name: str, split: str, entries: list[dict]) -> dict:
     """Return a summary dict with sizes, shard/part counts."""
     compressed = sum(e["size"] for e in entries)
     inflated = sum(e.get("inflated_size", 0) for e in entries)
@@ -126,6 +128,7 @@ def summarize_config(config_name: str, entries: list[dict]) -> dict:
 
     return {
         "config": config_name,
+        "split": split,
         "entries": len(entries),
         "compressed": compressed,
         "inflated": inflated if has_inflated else None,
@@ -147,7 +150,11 @@ def print_summary(summary: dict) -> None:
         print(f"  Extracted size: (unknown)")
     for p, info in sorted(summary["per_part"].items()):
         dl = _format_size(info["compressed"])
-        ex = _format_size(info["inflated"]) if info["inflated"] is not None else "unknown"
+        ex = (
+            _format_size(info["inflated"])
+            if info["inflated"] is not None
+            else "unknown"
+        )
         print(f"    part {p}: {info['entries']} entries, dl {dl}, extracted {ex}")
 
 
@@ -163,7 +170,9 @@ def main() -> None:
     parser = argparse.ArgumentParser(
         description="Download molmobot training data from Hugging Face.",
         formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=("Available task configs:\n" + "\n".join(f"  - {c}" for c in TASK_CONFIGS)),
+        epilog=(
+            "Available task configs:\n" + "\n".join(f"  - {c}" for c in TASK_CONFIGS)
+        ),
     )
     parser.add_argument(
         "target_dir",
@@ -201,6 +210,12 @@ def main() -> None:
         action="store_true",
         help="Skip confirmation prompts.",
     )
+    parser.add_argument(
+        "--split",
+        type=str,
+        default="all",
+        help="Extract only the given split (`train`, `val`, or `all`). Default is `all`.",
+    )
     parser.add_argument(
         "--max_part_shards",
         type=int,
@@ -220,8 +235,15 @@ def main() -> None:
     else:
         parser.error("Specify --config <NAME>, --all, or --list.")
 
+    split_choices = dict(
+        train=["train"],
+        val=["val"],
+        all=["val", "train"],
+    )
+    splits = split_choices[args.split]
+
     # Load entries and compute summaries
-    all_entries: dict[str, list[dict]] = {}
+    all_entries: dict[str, dict[str, list[dict]]] = {split: {} for split in splits}
     total_compressed = 0
     total_inflated = 0
     has_all_inflated = True
@@ -230,86 +252,100 @@ def main() -> None:
 
     manifest = _load_manifest(args.target_dir)
 
-    configs_to_skip = set()
+    configs_to_skip = {split: set() for split in splits}
     for config_name in configs_to_process:
-        part_to_shard_to_entries: dict[int, dict[int, list[dict]]] = {}
-        entries = load_entries(config_name)
-
-        part_entries = defaultdict(list)
-        for e in entries:
-            part_entries[e["part"]].append(e)
-
-        for part in part_entries:
-            shard_to_entries = defaultdict(list)
-            for e in part_entries[part]:
-                shard_to_entries[e["shard_id"]].append(e)
-            part_to_shard_to_entries[part] = {**shard_to_entries}
-
-        if args.part is not None:
-            if args.part not in part_to_shard_to_entries:
-                print(f"  {config_name} has no part {args.part}. Skipping")
-                configs_to_skip.add(config_name)
-                continue
-            if args.max_part_shards is not None:
-                shard_to_entries = part_to_shard_to_entries[args.part]
-                shards = sorted(shard_to_entries.keys())[: args.max_part_shards]
-                part_to_shard_to_entries = {args.part: {s: shard_to_entries[s] for s in shards}}
-        else:
-            if args.max_part_shards is not None:
-                for part in part_to_shard_to_entries:
-                    shard_to_entries = part_to_shard_to_entries[part]
+        for split in splits:
+            part_to_shard_to_entries: dict[int, dict[int, list[dict]]] = {}
+            entries = load_entries(config_name, split)
+
+            part_entries = defaultdict(list)
+            for e in entries:
+                part_entries[e["part"]].append(e)
+
+            for part in part_entries:
+                shard_to_entries = defaultdict(list)
+                for e in part_entries[part]:
+                    shard_to_entries[e["shard_id"]].append(e)
+                part_to_shard_to_entries[part] = {**shard_to_entries}
+
+            if args.part is not None:
+                if args.part not in part_to_shard_to_entries:
+                    print(f"  {config_name} has no part {args.part}. Skipping")
+                    configs_to_skip[split].add(config_name)
+                    continue
+                if args.max_part_shards is not None:
+                    shard_to_entries = part_to_shard_to_entries[args.part]
                     shards = sorted(shard_to_entries.keys())[: args.max_part_shards]
-                    part_to_shard_to_entries[part] = {s: shard_to_entries[s] for s in shards}
-
-        # Show resume status and filter out fully-completed configs
-        cfg_m = manifest.get(config_name, {})
-        done_shards = set(cfg_m.get("completed_shards", []))
-        if done_shards:
-            required_shards = set(
-                sum(
-                    [
-                        list(shard_to_entries.keys())
-                        for part, shard_to_entries in part_to_shard_to_entries.items()
-                    ],
-                    [],
-                )
-            )
-            missing_shards = required_shards - done_shards
-            if not missing_shards:
-                print(f"  {config_name}: already fully extracted, skipping")
-                configs_to_skip.add(config_name)
-                continue
+                    part_to_shard_to_entries = {
+                        args.part: {s: shard_to_entries[s] for s in shards}
+                    }
             else:
-                print(
-                    f"  {config_name}: {len(missing_shards)}/{len(required_shards)} "
-                    f"shards pending extraction (will resume)"
+                if args.max_part_shards is not None:
+                    for part in part_to_shard_to_entries:
+                        shard_to_entries = part_to_shard_to_entries[part]
+                        shards = sorted(shard_to_entries.keys())[: args.max_part_shards]
+                        part_to_shard_to_entries[part] = {
+                            s: shard_to_entries[s] for s in shards
+                        }
+
+            # Show resume status and filter out fully-completed configs
+            cfg_m = manifest.get(config_name, {}).get(split, {})
+            done_shards = set(cfg_m.get("completed_shards", []))
+            if done_shards:
+                required_shards = set(
+                    sum(
+                        [
+                            list(shard_to_entries.keys())
+                            for part, shard_to_entries in part_to_shard_to_entries.items()
+                        ],
+                        [],
+                    )
                 )
-
-        entries = [
-            e
-            for part, shard_to_entries in part_to_shard_to_entries.items()
-            for shard, entries in shard_to_entries.items()
-            for e in entries
-            if shard not in done_shards
+                missing_shards = required_shards - done_shards
+                if not missing_shards:
+                    print(f"  {config_name}: already fully extracted, skipping")
+                    configs_to_skip[split].add(config_name)
+                    continue
+                else:
+                    print(
+                        f"  {config_name}: {len(missing_shards)}/{len(required_shards)} "
+                        f"shards pending extraction (will resume)"
+                    )
+
+            entries = [
+                e
+                for part, shard_to_entries in part_to_shard_to_entries.items()
+                for shard, entries in shard_to_entries.items()
+                for e in entries
+                if shard not in done_shards
+            ]
+
+            all_entries[split][config_name] = entries
+            summary = summarize_config(config_name, split, entries)
+
+            print_summary(summary)
+            total_compressed += summary["compressed"]
+            if summary["inflated"] is not None:
+                total_inflated += summary["inflated"]
+            else:
+                has_all_inflated = False
+            print()
+
+    configs_to_process = {
+        split: [
+            config_name
+            for config_name in configs_to_process
+            if config_name not in configs_to_skip[split]
         ]
+        for split in splits
+    }
 
-        all_entries[config_name] = entries
-        summary = summarize_config(config_name, entries)
-
-        print_summary(summary)
-        total_compressed += summary["compressed"]
-        if summary["inflated"] is not None:
-            total_inflated += summary["inflated"]
-        else:
-            has_all_inflated = False
-        print()
-
-    configs_to_process = [
-        config_name for config_name in configs_to_process if config_name not in configs_to_skip
-    ]
+    all_configs_to_process = sum(
+        len(split_cfg) for split_cfg in configs_to_process.values()
+    )
 
-    if len(configs_to_process) > 1:
-        print(f"Total across {len(configs_to_process)} configs:")
+    if all_configs_to_process > 1:
+        print(f"Total across {all_configs_to_process} configs:")
         print(f"  Download size:  {_format_size(total_compressed)}")
         if has_all_inflated:
             print(f"  Extracted size: {_format_size(total_inflated)}")
@@ -330,21 +366,23 @@ def main() -> None:
             print("Aborted.")
             return
 
-    for config_name in configs_to_process:
-        print(f"\n{'=' * 60}")
-        print(f"  {config_name}")
-        print(f"{'=' * 60}")
-        try:
-            download_and_extract_config(
-                config_name,
-                args.target_dir,
-                entries=all_entries[config_name],
-            )
-        except KeyboardInterrupt:
-            print("\nInterrupted. Progress has been saved; re-run to resume.")
-            raise SystemExit(1)
-        except Exception as e:
-            print(f"FAILED: {config_name} — {e}")
+    for split in splits:
+        for config_name in configs_to_process[split]:
+            print(f"\n{'=' * 60}")
+            print(f"  {config_name} {split}")
+            print(f"{'=' * 60}")
+            try:
+                download_and_extract_config(
+                    config_name,
+                    args.target_dir,
+                    split=split,
+                    entries=all_entries[split][config_name],
+                )
+            except KeyboardInterrupt:
+                print("\nInterrupted. Progress has been saved; re-run to resume.")
+                raise SystemExit(1)
+            except Exception as e:
+                print(f"FAILED: {config_name} {split} — {e}")
 
     print("\nAll done.")
 
@@ -352,20 +390,21 @@ def main() -> None:
 def download_and_extract_config(
     config_name: str,
     target_dir: str,
+    split: str,
     entries: list[dict] | None = None,
 ) -> None:
     """Download and extract all shards for a single task config.
 
     Whole shard tars are downloaded via ``hf_hub_download`` (which caches
     them).  Each inner ``.tar.zst`` member is decompressed and extracted
-    into ``<target_dir>/<config_name>/part<X>/train/``.
+    into ``<target_dir>/<config_name>/part<X>/<split>/``.
 
     Progress is tracked per-shard in a local manifest so that interrupted
     runs can be resumed.
     """
     if entries is None:
         print(f"Loading entry table for {config_name}...")
-        entries = load_entries(config_name)
+        entries = load_entries(config_name, split)
 
     # Build lookup: path -> entry (for part resolution)
     path_to_entry = {e["path"]: e for e in entries}
@@ -378,7 +417,7 @@ def download_and_extract_config(
 
     # Load manifest for resume
     manifest = _load_manifest(target_dir)
-    cfg_manifest = manifest.setdefault(config_name, {})
+    cfg_manifest = manifest.setdefault(config_name, {}).setdefault(split, {})
     completed_shards: set[int] = set(cfg_manifest.get("completed_shards", []))
     num_completed_entries: list[int] = cfg_manifest.get("num_completed_entries", [])
 
@@ -393,7 +432,9 @@ def download_and_extract_config(
         print(f"All shards for {config_name} already extracted.")
         return
 
-    print(f"Downloading & extracting {len(remaining_shards)} shard(s) for {config_name}...")
+    print(
+        f"Downloading & extracting {len(remaining_shards)} shard(s) for {config_name} {split}..."
+    )
 
     # Use a temporary cache dir so shard downloads don't accumulate
     # in the default HF cache (~/.cache/huggingface/hub/).
@@ -404,7 +445,7 @@ def download_and_extract_config(
         for shard_id in tqdm(remaining_shards, desc=f"{config_name} shards"):
             entries_count = 0
 
-            shard_filename = f"{config_name}/shards/{shard_id:05d}.tar"
+            shard_filename = f"{config_name}/{split}_shards/{shard_id:05d}.tar"
 
             shard_local = hf_hub_download(
                 repo_id=REPO,
@@ -428,7 +469,9 @@ def download_and_extract_config(
                         continue
 
                     part = entry["part"]
-                    extract_dir = os.path.join(target_dir, config_name, f"part{part}", "train")
+                    extract_dir = os.path.join(
+                        target_dir, config_name, f"part{part}", split
+                    )
                     os.makedirs(extract_dir, exist_ok=True)
 
                     fobj = shard_tar.extractfile(member)