scripts/pack_single_arm_task4.sh

#!/usr/bin/env bash
set -euo pipefail

SRC="${SRC:-/lumos-vePFS/suda/FastUMI_data/processed_data/umi_bechmark_dual/single_arm_task4}"
RELEASE="${RELEASE:-/lumos-vePFS/suda/FastUMI_release/UMI-Benchmark-v1}"
TASK_NAME="${TASK_NAME:-single_arm_task4}"
DATA_DIR="$RELEASE/data/$TASK_NAME"
META_DIR="$RELEASE/metadata/$TASK_NAME"
LIST_DIR="$META_DIR/lists"
CHUNK_SIZE="${CHUNK_SIZE:-100}"

mkdir -p "$DATA_DIR" "$LIST_DIR"

cd "$SRC"

python3 - <<'PY'
from pathlib import Path
import csv
import os
import subprocess

src = Path(os.environ.get("SRC", "/lumos-vePFS/suda/FastUMI_data/processed_data/umi_bechmark_dual/single_arm_task4"))
release = Path(os.environ.get("RELEASE", "/lumos-vePFS/suda/FastUMI_release/UMI-Benchmark-v1"))
task_name = os.environ.get("TASK_NAME", "single_arm_task4")
chunk_size = int(os.environ.get("CHUNK_SIZE", "100"))
data_dir = release / "data" / task_name
meta_dir = release / "metadata" / task_name
list_dir = meta_dir / "lists"

scene_targets = [
    ("T4_Remote_B_Holder_B", 489, "Da", "remote B", "holder B", "Remote B + Holder B"),
    ("T4_Remote_A_Holder_B", 500, "Ca", "remote A", "holder B", "Remote A + Holder B"),
    ("T4_Remote_B_Holder_A", 501, "Ba", "remote B", "holder A", "Remote B + Holder A"),
    ("T4_Remote_A_Holder_A", 511, "Aa", "remote A", "holder A", "Remote A + Holder A"),
]


def session_key(path: Path):
    return (path.parent.name.replace("multi_session_", ""), path.name.replace("session_", ""))


data_dir.mkdir(parents=True, exist_ok=True)
list_dir.mkdir(parents=True, exist_ok=True)

for old in data_dir.glob("T4_*/*.tar"):
    old.unlink()
for old in list_dir.glob("*.txt"):
    old.unlink()

mapping_rows = []
manifest_rows = []
all_session_rows = []

for setting, expected, source_suffix, remote_type, holder_type, description in scene_targets:
    root = src / setting / "good" / "background"
    sessions = sorted([p for p in root.glob("multi_session_*/session_*") if p.is_dir()], key=session_key)
    if len(sessions) != expected:
        raise SystemExit(f"{setting}: expected {expected} sessions, got {len(sessions)}")

    setting_data_dir = data_dir / setting
    setting_data_dir.mkdir(parents=True, exist_ok=True)

    setting_list = list_dir / f"{setting}_all_sessions.txt"
    with setting_list.open("w") as f:
        for session in sessions:
            rel = session.relative_to(src)
            f.write(f"{rel}\n")
            date, sess = session_key(session)
            all_session_rows.append({
                "task": task_name,
                "setting": setting,
                "source_suffix": source_suffix,
                "remote_type": remote_type,
                "holder_type": holder_type,
                "date": date,
                "session": sess,
                "session_path": str(rel),
            })

    mapping_rows.append({
        "task": task_name,
        "setting": setting,
        "source_suffix": source_suffix,
        "remote_type": remote_type,
        "holder_type": holder_type,
        "description": description,
        "session_count": len(sessions),
        "release_subdir": f"data/{task_name}/{setting}",
        "session_list": f"metadata/{task_name}/lists/{setting}_all_sessions.txt",
    })

    for chunk_idx, start in enumerate(range(0, len(sessions), chunk_size)):
        chunk_sessions = sessions[start:start + chunk_size]
        chunk_name = f"{setting}_chunk_{chunk_idx:03d}.tar"
        chunk_list = list_dir / f"{setting}_chunk_{chunk_idx:03d}.txt"
        tar_path = setting_data_dir / chunk_name
        with chunk_list.open("w") as f:
            for session in chunk_sessions:
                f.write(f"{session.relative_to(src)}\n")
        print(f"Packing {setting}/{chunk_name} ({len(chunk_sessions)} sessions)", flush=True)
        subprocess.run(["tar", "-C", str(src), "-cf", str(tar_path), "-T", str(chunk_list)], check=True)

        first_date, first_session = session_key(chunk_sessions[0])
        last_date, last_session = session_key(chunk_sessions[-1])
        manifest_rows.append({
            "task": task_name,
            "setting": setting,
            "source_suffix": source_suffix,
            "remote_type": remote_type,
            "holder_type": holder_type,
            "chunk_index": chunk_idx,
            "tar_path": f"data/{task_name}/{setting}/{chunk_name}",
            "session_list": f"metadata/{task_name}/lists/{setting}_chunk_{chunk_idx:03d}.txt",
            "session_count": len(chunk_sessions),
            "first_date": first_date,
            "first_session": first_session,
            "last_date": last_date,
            "last_session": last_session,
        })

with (meta_dir / "scene_mapping.csv").open("w", newline="") as f:
    fields = ["task", "setting", "source_suffix", "remote_type", "holder_type", "description", "session_count", "release_subdir", "session_list"]
    writer = csv.DictWriter(f, fieldnames=fields)
    writer.writeheader()
    writer.writerows(mapping_rows)

with (meta_dir / "chunk_manifest.csv").open("w", newline="") as f:
    fields = ["task", "setting", "source_suffix", "remote_type", "holder_type", "chunk_index", "tar_path", "session_list", "session_count", "first_date", "first_session", "last_date", "last_session"]
    writer = csv.DictWriter(f, fieldnames=fields)
    writer.writeheader()
    writer.writerows(manifest_rows)

with (meta_dir / "all_sessions.csv").open("w", newline="") as f:
    fields = ["task", "setting", "source_suffix", "remote_type", "holder_type", "date", "session", "session_path"]
    writer = csv.DictWriter(f, fieldnames=fields)
    writer.writeheader()
    writer.writerows(all_session_rows)

print(f"packed {len(manifest_rows)} tar files under {data_dir}", flush=True)
PY

cd "$DATA_DIR"
find . -name '*.tar' -type f -print0 | sort -z | xargs -0 sha256sum > "$META_DIR/sha256.txt"
find . -name '*.tar' -type f -print0 | sort -z | xargs -0 du -h > "$META_DIR/sizes.txt"
find . -name '*.tar' -type f -print0 | sort -z | xargs -0 du -sb > "$META_DIR/sizes_bytes.txt"

echo "Done: $DATA_DIR"