Upload 6 files

README.md

@@ -135,77 +135,163 @@ Due to the large scale of PhysInOne, the rendered data and annotations are split
 
 For large-scale downloading and filtering, please refer to the **How to Use** section below.
 
-# 📥 How to Use(Used only as a temporary placeholder, still in progress.)
+# 📥 How to Use
 
-TODO
+PhysInOne is distributed across multiple Hugging Face dataset repositories because of its large scale. We provide two scripts for selecting and downloading cases:
 
-### Filtering and Search
+- `filter_cases.py`: parses the case-to-repository assignment file and exports selected cases to JSON.
+- `download.py`: downloads the selected case zip files from the corresponding Hugging Face shard repositories.
 
-The dataset should support filtering by:
+The scripts support selection by:
 
 - **Split**: `train`, `val`, `test`
+- **Activity complexity**: `single`, `double`, `triple`
+- **Physical phenomenon abbreviation**: `MovingHitsFixed`, `FrictionStop`, `LiquidTension`, ..., `GranularFall`
+- **Number of cases**: globally sample `N` cases after filtering
+
+## 1. Prepare Metadata Files
+
+Place the metadata files as follows:
+
+```text
+metadata/
+  repo_assignment.txt
+  repo_map.json
+scripts/
+  filter_cases.py
+  download.py
+```
+
+`repo_assignment.txt` stores the uploaded case-to-part mapping. Each line should follow:
+
+```text
+<Game UE path>    <part_id>
+```
 
-- **Activity complexity:** `single`, `double`, `triple`
+Example:
 
-- **Physical domain:** `mechanics`, `fluid_dynamics`, `optics`, `magnetism`
+```text
+/Game/PhysInOne/Scenes/Train/DoublePhysics/AccelConcaveSpin_AccelSurfaceSpin__bg070__K5ER39.AccelConcaveSpin_AccelSurfaceSpin__bg070__K5ER39    physinone_part1
+```
 
-- **Abbreviation:** `MovingHitsFixed`, `FrictionStop`, `LiquidTension`, ... , `GranularFall`
+`repo_map.json` maps each part to its Hugging Face repository ID:
 
-### Install Dependencies
+```json
+{
+  "physinone_part1": "PhysInOneP01/PhysInOneP01"
+}
+```
+
+## 2. Install Dependencies
 
 ```bash
-pip install datasets huggingface_hub pandas tqdm
+pip install huggingface_hub tqdm
 ```
 
-### Download a Split
+## 3. Filter Cases
+
+### Filter by split
 
 ```bash
-python scripts/download.py \
+python scripts/filter_cases.py \
   --split train \
-  --output_dir ./PhysInOne
+  --output selected_cases.json
 ```
 
-### Download via Filters
+### Filter by split and activity complexity
 
 ```bash
-python scripts/download.py \
+python scripts/filter_cases.py \
   --split train \
   --activity_type double \
-  --domain mechanics \
-  --phenomena P01 P03 \
-  --output_dir ./PhysInOne
+  --output selected_cases.json
 ```
 
-### Download a certain number of cases (random sampling) via Filters
+### Filter by physical phenomenon abbreviation
+
+By default, phenomenon matching uses `contains` mode. For example, the following command selects all double-physics cases that contain `FrictionStop`:
 
 ```bash
-python scripts/download.py \
+python scripts/filter_cases.py \
   --split train \
   --activity_type double \
-  --domain mechanics \
-  --phenomena P01 P03 \
-  --num 3000 \
-  --output_dir ./PhysInOne
+  --phenomena FrictionStop \
+  --match_mode contains \
+  --output selected_cases.json
 ```
 
-### Download by Exported JSON
+For exact matching, use `--match_mode exact`. Order does not matter. For example, this command selects cases whose phenomenon set is exactly `{AccelConcaveSpin, AccelSurfaceSpin}`:
 
 ```bash
 python scripts/filter_cases.py \
   --split train \
   --activity_type double \
-  --domain mechanics \
-  --phenomena P01 P03 \
+  --phenomena AccelConcaveSpin AccelSurfaceSpin \
+  --match_mode exact \
+  --output selected_cases.json
+```
+
+### Randomly sample a fixed number of cases
+
+`--num` is the global number of cases sampled after filtering. The default random seed is `42`.
+
+```bash
+python scripts/filter_cases.py \
+  --split train \
+  --activity_type double \
+  --phenomena FrictionStop \
+  --match_mode contains \
   --num 3000 \
-  --output_dir selected_cases.json
+  --seed 42 \
+  --output selected_cases.json
 ```
 
+## 4. Download Selected Cases
+
+Each selected case is downloaded as a zip file from the corresponding Hugging Face shard repository.
+
 ```bash
 python scripts/download.py \
-  --selection selected_scenes.json \
+  --selection selected_cases.json \
   --output_dir ./PhysInOne
 ```
 
+If the dataset repositories are gated or private, pass a Hugging Face token:
+
+```bash
+python scripts/download.py \
+  --selection selected_cases.json \
+  --output_dir ./PhysInOne \
+  --token YOUR_HF_TOKEN
+```
+
+Preview the planned downloads without actually downloading files:
+
+```bash
+python scripts/download.py \
+  --selection selected_cases.json \
+  --dry_run
+```
+
+By default, downloaded zip files are saved into a flat output folder. To preserve shard/split/activity structure:
+
+```bash
+python scripts/download.py \
+  --selection selected_cases.json \
+  --output_dir ./PhysInOne \
+  --keep_shard_structure
+```
+
+The preserved structure is:
+
+```text
+PhysInOne/
+  physinone_part1/
+    Train/
+      DoublePhysics/
+        AccelConcaveSpin_AccelSurfaceSpin__bg070__K5ER39_trajectory.zip
+```
+
 # 🎬 Visual Overview
 
 <p align="center">
@@ -234,7 +320,6 @@ This design guarantees that training, validation, and test sets are fully separa
 
 ### Physical Phenomenon and Abbreviations
 
-
 <details>
 <summary>Click to expand full abbreviation table</summary>
 

assets/metadata/repo_map.json

@@ -0,0 +1,3 @@
+{
+  "physinone_part1": "PhysInOneP01/PhysInOneP01"
+}

assets/scripts/download.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""
+Download selected PhysInOne case zip files from Hugging Face shard repositories.
+
+Input:
+    selected_cases.json produced by filter_cases.py
+    repo_map.json mapping part IDs to Hugging Face repo IDs
+
+Recommended repo_map.json format:
+{
+  "physinone_part1": "PhysInOneP01/PhysInOneP01",
+  "physinone_part2": "PhysInOneP02/PhysInOneP02"
+}
+
+The script downloads each selected case zip using huggingface_hub.hf_hub_download.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import shutil
+from pathlib import Path
+from urllib.parse import urlparse
+
+from huggingface_hub import hf_hub_download
+from tqdm import tqdm
+
+
+DEFAULT_SELECTION_FILE = Path("selected_cases.json")
+DEFAULT_REPO_MAP_FILE = Path("metadata/repo_map.json")
+
+
+def normalize_repo_id(value: str) -> str:
+    """Accept either a repo id or a Hugging Face URL and return repo id."""
+    value = value.strip().rstrip("/")
+    if value.startswith("http://") or value.startswith("https://"):
+        parsed = urlparse(value)
+        # Expected: /datasets/PhysInOneP01/PhysInOneP01[/tree/main]
+        parts = [p for p in parsed.path.split("/") if p]
+        if len(parts) >= 3 and parts[0] == "datasets":
+            return f"{parts[1]}/{parts[2]}"
+        raise ValueError(f"Cannot parse Hugging Face dataset repo URL: {value}")
+    return value
+
+
+def load_json(path: Path) -> dict:
+    if not path.exists():
+        raise FileNotFoundError(f"File not found: {path}")
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def load_repo_map(path: Path) -> dict[str, str]:
+    data = load_json(path)
+    if not isinstance(data, dict):
+        raise ValueError("repo_map.json must be a dictionary: part_id -> repo_id")
+    return {str(k): normalize_repo_id(str(v)) for k, v in data.items()}
+
+
+def safe_output_path(output_dir: Path, case: dict, keep_shard_structure: bool) -> Path:
+    filename = Path(case["hf_zip_path"]).name
+    if keep_shard_structure:
+        # Preserve Split/ActivityType layout.
+        return output_dir / case["part_id"] / case["split"] / case["activity_type"] / filename
+    return output_dir / filename
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Download PhysInOne selected case zips.")
+    parser.add_argument(
+        "--selection",
+        type=Path,
+        default=DEFAULT_SELECTION_FILE,
+        help=f"selected_cases.json from filter_cases.py. Default: {DEFAULT_SELECTION_FILE}",
+    )
+    parser.add_argument(
+        "--repo_map",
+        type=Path,
+        default=DEFAULT_REPO_MAP_FILE,
+        help=f"JSON mapping part_id to HF repo id. Default: {DEFAULT_REPO_MAP_FILE}",
+    )
+    parser.add_argument(
+        "--output_dir",
+        type=Path,
+        default=Path("./PhysInOne"),
+        help="Local output directory. Default: ./PhysInOne",
+    )
+    parser.add_argument(
+        "--repo_type",
+        type=str,
+        default="dataset",
+        help="Hugging Face repo type. Default: dataset",
+    )
+    parser.add_argument(
+        "--revision",
+        type=str,
+        default="main",
+        help="Hugging Face revision/branch. Default: main",
+    )
+    parser.add_argument(
+        "--token",
+        type=str,
+        default=None,
+        help="Optional Hugging Face token for gated/private repos.",
+    )
+    parser.add_argument(
+        "--keep_shard_structure",
+        action="store_true",
+        help="Save as output_dir/part_id/Split/ActivityType/*.zip instead of a flat folder.",
+    )
+    parser.add_argument(
+        "--dry_run",
+        action="store_true",
+        help="Print planned downloads without downloading.",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Overwrite local files if they already exist.",
+    )
+
+    args = parser.parse_args()
+
+    selection = load_json(args.selection)
+    repo_map = load_repo_map(args.repo_map)
+    cases = selection.get("cases", [])
+    if not isinstance(cases, list):
+        raise ValueError("selection JSON must contain a list field named 'cases'.")
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+
+    missing_parts = sorted({case["part_id"] for case in cases if case["part_id"] not in repo_map})
+    if missing_parts:
+        raise KeyError(
+            "The following part IDs are missing from repo_map.json: "
+            + ", ".join(missing_parts)
+        )
+
+    print(f"Cases to download: {len(cases)}")
+    if args.dry_run:
+        for case in cases[:20]:
+            repo_id = repo_map[case["part_id"]]
+            out_path = safe_output_path(args.output_dir, case, args.keep_shard_structure)
+            print(f"{repo_id} :: {case['hf_zip_path']} -> {out_path}")
+        if len(cases) > 20:
+            print(f"... and {len(cases) - 20} more")
+        return
+
+    failures = []
+    for case in tqdm(cases, desc="Downloading cases"):
+        repo_id = repo_map[case["part_id"]]
+        filename = case["hf_zip_path"]
+        out_path = safe_output_path(args.output_dir, case, args.keep_shard_structure)
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if out_path.exists() and not args.overwrite:
+            continue
+
+        try:
+            cached_file = hf_hub_download(
+                repo_id=repo_id,
+                filename=filename,
+                repo_type=args.repo_type,
+                revision=args.revision,
+                token=args.token,
+            )
+            shutil.copy2(cached_file, out_path)
+        except Exception as exc:  # Keep going and summarize failures.
+            failures.append(
+                {
+                    "case_id": case.get("case_id"),
+                    "part_id": case.get("part_id"),
+                    "repo_id": repo_id,
+                    "hf_zip_path": filename,
+                    "error": repr(exc),
+                }
+            )
+
+    if failures:
+        failure_path = args.output_dir / "download_failures.json"
+        failure_path.write_text(json.dumps(failures, indent=2, ensure_ascii=False), encoding="utf-8")
+        print(f"Finished with {len(failures)} failures. See: {failure_path}")
+    else:
+        print("All downloads completed successfully.")
+
+
+if __name__ == "__main__":
+    main()

assets/scripts/filter_cases.py

@@ -0,0 +1,433 @@
+#!/usr/bin/env python3
+"""
+Filter PhysInOne cases from repo_assignment.txt.
+
+Expected assignment file format:
+    /Game/PhysInOne/Scenes/Train/DoublePhysics/CaseName.CaseName    physinone_part1
+
+The script parses:
+    split: Train / Val / Test
+    activity_type: SinglePhysics / DoublePhysics / TriplePhysics
+    phenomena: abbreviations before "__bg..."
+    background: bgXXX
+    hash: final six-character code
+    part_id: e.g. physinone_part1
+    hf_zip_path: expected zip path inside the shard repo, e.g.
+        Train/DoublePhysics/AccelConcaveSpin_AccelSurfaceSpin__bg070__K5ER39_trajectory.zip
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import random
+import re
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Iterable, Literal
+
+
+DEFAULT_ASSIGNMENT_FILE = Path("metadata/repo_assignment.txt")
+
+
+SUPPORTED_PHENOMENA = {
+    "MovingHitsFixed",
+    "MovingHitsStationary",
+    "MovingHitsMoving",
+    "WindGravityBalance",
+    "WindPushStationary",
+    "WindPushSameDir",
+    "WindPushOppDir",
+    "WindDeflectMotion",
+    "ObliqueProjectile",
+    "VerticalFall",
+    "RollDownSlope",
+    "RollUpSlope",
+    "MagnetAttract",
+    "MagnetRepel",
+    "UniformPanelSpin",
+    "AccelPanelSpin",
+    "UniformConcaveSpin",
+    "AccelConcaveSpin",
+    "UniformSurfaceSpin",
+    "AccelSurfaceSpin",
+    "FrictionStop",
+    "SpringCompress",
+    "SpringStretch",
+    "ImpactFracture",
+    "MirrorFragmentReflect",
+    "ElasticCouple",
+    "SpringboardRebound",
+    "SeesawCenterPivot",
+    "SeesawOffsetPivot",
+    "BalloonFloat",
+    "BalloonTether",
+    "BalloonLift",
+    "FixedPlanarRedirect",
+    "FixedArrayRedirect",
+    "FixedConcaveRedirect",
+    "FixedConvexRedirect",
+    "DynMirrorRedirect",
+    "LaserBlock",
+    "MirrorReflect",
+    "CartMove",
+    "RotTurnableInertia",
+    "RotBoardInertia",
+    "LinCarryInertia",
+    "CatapultLaunch",
+    "ChainSuspend",
+    "SimplePendulum",
+    "DoublePendulum",
+    "CrankPush",
+    "BlockWallCollapse",
+    "StickSupportFail",
+    "FloatOnLiquid",
+    "DropInLiquid",
+    "MovingObjDriveLiquid",
+    "LiquidCarryMovingObj",
+    "LiquidHitFixedObj",
+    "LiquidTransfer",
+    "LiquidMultiTransfers",
+    "LiquidThroughGrid",
+    "LiquidAcrossUneven",
+    "LiquidRise",
+    "LiquidAlongContours",
+    "JetLiquid",
+    "LiquidTension",
+    "LiquidRefraction",
+    "StickyToObjects",
+    "StickyFromObjects",
+    "ElasticFall",
+    "PlasticineFall",
+    "NewtonianFluidFall",
+    "NonNewtonianFluidFall",
+    "GranularFall",
+}
+
+
+SPLIT_ALIASES = {
+    "train": "Train",
+    "val": "Val",
+    "validation": "Val",
+    "test": "Test",
+}
+
+ACTIVITY_ALIASES = {
+    "single": "SinglePhysics",
+    "singlephysics": "SinglePhysics",
+    "double": "DoublePhysics",
+    "doublephysics": "DoublePhysics",
+    "triple": "TriplePhysics",
+    "triplephysics": "TriplePhysics",
+}
+
+
+@dataclass
+class CaseRecord:
+    case_id: str
+    split: str
+    activity_type: str
+    phenomena: list[str]
+    background: str
+    hash: str
+    ue_path: str
+    part_id: str
+    hf_zip_path: str
+
+
+def normalize_split(value: str | None) -> str | None:
+    if value is None:
+        return None
+    key = value.strip().lower()
+    if key not in SPLIT_ALIASES:
+        raise ValueError(
+            f"Unknown split '{value}'. Expected one of: train, val, test."
+        )
+    return SPLIT_ALIASES[key]
+
+
+def normalize_activity(value: str | None) -> str | None:
+    if value is None:
+        return None
+    key = value.strip().lower()
+    if key not in ACTIVITY_ALIASES:
+        raise ValueError(
+            f"Unknown activity_type '{value}'. Expected one of: single, double, triple."
+        )
+    return ACTIVITY_ALIASES[key]
+
+
+def validate_phenomena(values: list[str] | None) -> list[str] | None:
+    if not values:
+        return values
+
+    invalid = sorted(set(values) - SUPPORTED_PHENOMENA)
+    if invalid:
+        valid_preview = ", ".join(sorted(SUPPORTED_PHENOMENA))
+        raise ValueError(
+            "Unsupported phenomenon abbreviation(s): "
+            + ", ".join(invalid)
+            + "\nExpected one or more of the 71 supported abbreviations:\n"
+            + valid_preview
+        )
+    return values
+
+
+def parse_case_line(line: str, line_no: int) -> CaseRecord | None:
+    line = line.strip()
+    if not line or line.startswith("#"):
+        return None
+
+    parts = re.split(r"\s+", line, maxsplit=1)
+    if len(parts) != 2:
+        raise ValueError(f"Line {line_no}: expected two columns: <ue_path> <part_id>")
+
+    ue_path, part_id = parts[0], parts[1].strip()
+    path_parts = ue_path.split("/")
+
+    try:
+        scenes_idx = path_parts.index("Scenes")
+        split = path_parts[scenes_idx + 1]
+        activity_type = path_parts[scenes_idx + 2]
+        object_ref = path_parts[scenes_idx + 3]
+    except (ValueError, IndexError) as exc:
+        raise ValueError(f"Line {line_no}: cannot parse UE path: {ue_path}") from exc
+
+    if split not in {"Train", "Val", "Test"}:
+        raise ValueError(
+            f"Line {line_no}: unsupported split '{split}' in assignment file. "
+            "Expected Train, Val, or Test."
+        )
+
+    if activity_type not in {"SinglePhysics", "DoublePhysics", "TriplePhysics"}:
+        raise ValueError(
+            f"Line {line_no}: unsupported activity type '{activity_type}' in assignment file. "
+            "Expected SinglePhysics, DoublePhysics, or TriplePhysics."
+        )
+
+    case_id = object_ref.split(".")[-1]
+
+    if "__" not in case_id:
+        raise ValueError(f"Line {line_no}: cannot parse case_id: {case_id}")
+
+    tokens = case_id.split("__")
+    phenomenon_token = tokens[0]
+    phenomena = phenomenon_token.split("_") if phenomenon_token else []
+
+    invalid_in_file = sorted(set(phenomena) - SUPPORTED_PHENOMENA)
+    if invalid_in_file:
+        raise ValueError(
+            f"Line {line_no}: assignment file contains unsupported phenomenon "
+            f"abbreviation(s): {', '.join(invalid_in_file)} in case_id {case_id}"
+        )
+
+    expected_count = {
+        "SinglePhysics": 1,
+        "DoublePhysics": 2,
+        "TriplePhysics": 3,
+    }[activity_type]
+    if len(phenomena) != expected_count:
+        raise ValueError(
+            f"Line {line_no}: activity type {activity_type} expects "
+            f"{expected_count} phenomenon abbreviation(s), but got {len(phenomena)} "
+            f"in case_id {case_id}"
+        )
+
+    background = ""
+    hash_code = ""
+    for token in tokens[1:]:
+        if re.fullmatch(r"bg\d+", token):
+            background = token
+        else:
+            hash_code = token
+
+    if not background:
+        raise ValueError(f"Line {line_no}: background token not found in case_id: {case_id}")
+    if not hash_code:
+        raise ValueError(f"Line {line_no}: hash token not found in case_id: {case_id}")
+
+    hf_zip_path = f"{split}/{activity_type}/{case_id}_trajectory.zip"
+
+    return CaseRecord(
+        case_id=case_id,
+        split=split,
+        activity_type=activity_type,
+        phenomena=phenomena,
+        background=background,
+        hash=hash_code,
+        ue_path=ue_path,
+        part_id=part_id,
+        hf_zip_path=hf_zip_path,
+    )
+
+
+def load_assignment(path: Path) -> list[CaseRecord]:
+    if not path.exists():
+        raise FileNotFoundError(
+            f"Assignment file not found: {path}\n"
+            f"Put repo_assignment.txt at {DEFAULT_ASSIGNMENT_FILE} or pass --assignment_file."
+        )
+
+    records: list[CaseRecord] = []
+    with path.open("r", encoding="utf-8") as f:
+        for line_no, line in enumerate(f, start=1):
+            record = parse_case_line(line, line_no)
+            if record is not None:
+                records.append(record)
+    return records
+
+
+def record_matches_phenomena(
+    record: CaseRecord,
+    requested: Iterable[str] | None,
+    match_mode: Literal["contains", "exact"],
+) -> bool:
+    requested_list = list(requested or [])
+    if not requested_list:
+        return True
+
+    requested_set = set(requested_list)
+    record_set = set(record.phenomena)
+
+    if match_mode == "contains":
+        return requested_set.issubset(record_set)
+    if match_mode == "exact":
+        return requested_set == record_set
+
+    raise ValueError(f"Unsupported match_mode: {match_mode}")
+
+
+def filter_records(
+    records: list[CaseRecord],
+    split: str | None = None,
+    activity_type: str | None = None,
+    phenomena: list[str] | None = None,
+    match_mode: Literal["contains", "exact"] = "contains",
+) -> list[CaseRecord]:
+    split_norm = normalize_split(split)
+    activity_norm = normalize_activity(activity_type)
+    phenomena = validate_phenomena(phenomena)
+
+    out = []
+    for record in records:
+        if split_norm is not None and record.split != split_norm:
+            continue
+        if activity_norm is not None and record.activity_type != activity_norm:
+            continue
+        if not record_matches_phenomena(record, phenomena, match_mode):
+            continue
+        out.append(record)
+    return out
+
+
+def build_stats(records: list[CaseRecord]) -> dict:
+    stats: dict = {
+        "num_cases": len(records),
+        "by_split": {},
+        "by_activity_type": {},
+        "by_part": {},
+    }
+    for r in records:
+        stats["by_split"][r.split] = stats["by_split"].get(r.split, 0) + 1
+        stats["by_activity_type"][r.activity_type] = stats["by_activity_type"].get(r.activity_type, 0) + 1
+        stats["by_part"][r.part_id] = stats["by_part"].get(r.part_id, 0) + 1
+    return stats
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Filter PhysInOne cases.")
+    parser.add_argument(
+        "--assignment_file",
+        type=Path,
+        default=DEFAULT_ASSIGNMENT_FILE,
+        help=f"Path to repo_assignment.txt. Default: {DEFAULT_ASSIGNMENT_FILE}",
+    )
+    parser.add_argument("--split", type=str, default=None, help="train, val, or test.")
+    parser.add_argument(
+        "--activity_type",
+        type=str,
+        default=None,
+        help="single, double, or triple.",
+    )
+    parser.add_argument(
+        "--phenomena",
+        nargs="*",
+        default=None,
+        help="One or more phenomenon abbreviations, e.g. AccelConcaveSpin FrictionStop.",
+    )
+    parser.add_argument(
+        "--match_mode",
+        choices=["contains", "exact"],
+        default="contains",
+        help=(
+            "contains: selected cases contain all requested phenomena; "
+            "exact: selected cases have exactly the requested phenomena. "
+            "Order is ignored in both modes."
+        ),
+    )
+    parser.add_argument(
+        "--num",
+        type=int,
+        default=None,
+        help="Global number of cases to sample after filtering. Default: keep all matches.",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed used when --num is specified. Default: 42.",
+    )
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=Path("selected_cases.json"),
+        help="Output JSON path. Default: selected_cases.json",
+    )
+    parser.add_argument(
+        "--show_stats",
+        action="store_true",
+        help="Print dataset/filtering statistics.",
+    )
+
+    args = parser.parse_args()
+
+    records = load_assignment(args.assignment_file)
+    matches = filter_records(
+        records,
+        split=args.split,
+        activity_type=args.activity_type,
+        phenomena=args.phenomena,
+        match_mode=args.match_mode,
+    )
+
+    if args.num is not None:
+        if args.num < 0:
+            raise ValueError("--num must be non-negative.")
+        rng = random.Random(args.seed)
+        if args.num < len(matches):
+            matches = rng.sample(matches, args.num)
+
+    result = {
+        "filters": {
+            "split": args.split,
+            "activity_type": args.activity_type,
+            "phenomena": args.phenomena or [],
+            "match_mode": args.match_mode,
+            "num": args.num,
+            "seed": args.seed,
+        },
+        "stats": build_stats(matches),
+        "cases": [asdict(r) for r in matches],
+    }
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(json.dumps(result, indent=2, ensure_ascii=False), encoding="utf-8")
+
+    print(f"Matched cases: {len(matches)}")
+    print(f"Saved selection to: {args.output}")
+    if args.show_stats:
+        print(json.dumps(result["stats"], indent=2, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()