#!/usr/bin/env python3 """Build the RoboSteer Level 1 publication tree without modifying source assets.""" import argparse import concurrent.futures import hashlib import io import json import os from pathlib import Path import shutil import tarfile import time import pyarrow as pa import pyarrow.parquet as pq VERSION = "v1.0.0" TEXT = [ ("txt_gen", "text/processed/TXT/IMIT/TXT_GEN", "text/txt_imit/txt_gen", "TXT_GEN", 38522), ("txt_comp_hands", "text/processed/TXT/IMIT/TXT_COMP_HANDS", "text/txt_imit/txt_comp_hands", "TXT_COMP_HANDS", 38522), ("txt_comp_legs", "text/processed/TXT/IMIT/TXT_COMP_LEGS", "text/txt_imit/txt_comp_legs", "TXT_COMP_LEGS", 38522), ("txt_fore", "text/processed/TXT/PRED/TXT_FORE", "text/txt_pred/txt_fore", "TXT_FORE", 14333), ("txt_retro", "text/processed/TXT/PRED/TXT_RETRO", "text/txt_pred/txt_retro", "TXT_RETRO", 14333), ("txt_inter", "text/processed/TXT/PRED/TXT_INTER", "text/txt_pred/txt_inter", "TXT_INTER", 7764), ("img_txt", "text/processed/IMG_TXT", "text/img_txt", "IMG_TXT_SKEL", 14333), ("mul_bal_txt", "text/processed/MUL_BAL_TXT", "text/mul_bal_txt", "MUL_BAL", 8193), ("audio_motion_instructions", "audio/processed/whisper_txt_preprocessed", "audio/motion_instructions", "AUDIO_MOTION_INSTRUCTIONS", 38522), ] def log(*args): print(time.strftime("%Y-%m-%d %H:%M:%S"), *args, flush=True) def digest(path): h = hashlib.sha256() with open(path, "rb") as f: for block in iter(lambda: f.read(4 * 1024 * 1024), b""): h.update(block) return h.hexdigest() def write_json(path, value): path.parent.mkdir(parents=True, exist_ok=True) path.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") def write_parquet(path, rows): path.parent.mkdir(parents=True, exist_ok=True) tmp = path.with_suffix(".parquet.tmp") pq.write_table(pa.Table.from_pylist(rows), tmp, compression="zstd", row_group_size=10000) tmp.replace(path) def source_id(stem, task): prefix = "L1_" + task + "_" if stem.startswith(prefix): return stem[len(prefix):] if task == "AUDIO_MOTION_INSTRUCTIONS" and stem.endswith("_audio"): return stem[:-len("_audio")] raise ValueError(f"Unrecognized sample naming: {task}: {stem}") def read_unchanged(path): before = path.stat() data = path.read_bytes() after = path.stat() assert (before.st_size, before.st_mtime_ns) == (after.st_size, after.st_mtime_ns), path return data def build_text(source, release): manifest = [] ids = {} for config, src, dst, task, expected in TEXT: files = sorted((source / src).rglob("*.txt")) assert len(files) == expected, (src, len(files), expected) def convert(path): assert not path.is_symlink(), path data = read_unchanged(path) return { "sample_id": path.stem, "source_sample_id": source_id(path.stem, task), "task": task, "level": "level1", "source_modality": "audio" if config.startswith("audio_") else "text", "text": data.decode("utf-8"), "original_relpath": str(path.relative_to(source)), "size_bytes": len(data), "sha256": hashlib.sha256(data).hexdigest(), } with concurrent.futures.ThreadPoolExecutor(max_workers=12) as pool: rows = list(pool.map(convert, files)) assert len({x["sample_id"] for x in rows}) == expected dest = release / "level1" / dst / "data.parquet" write_parquet(dest, rows) restored = pq.read_table(dest).to_pylist() assert len(restored) == expected for row in restored: raw = row["text"].encode("utf-8") assert len(raw) == row["size_bytes"] assert hashlib.sha256(raw).hexdigest() == row["sha256"] ids[config] = {x["source_sample_id"] for x in rows} manifest.append({"config": "level1_" + config, "task": task, "path": str(dest.relative_to(release)), "records": expected, "empty_text_records": sum(not x["text"].strip() for x in rows)}) log("TEXT_VERIFIED", config, expected) return manifest, ids class HashReader: def __init__(self, f): self.f = f self.hash = hashlib.sha256() def read(self, n=-1): data = self.f.read(n) self.hash.update(data) return data def public_relative(value): if "/public/" in value: value = value.split("/public/", 1)[1] p = Path(value) if p.is_absolute() or ".." in p.parts: raise ValueError("Image provenance must be relative to public root") return p.as_posix() def tar_info(name, size): entry = tarfile.TarInfo(name) entry.size = size entry.mode = 0o644 entry.uid = entry.gid = entry.mtime = 0 return entry def build_video(source, release, task, target_bytes): folder = release / "level1/image" / task.lower() folder.mkdir(parents=True, exist_ok=True) source_dir = source / "img+mul_bal/output" / task metadata_dir = source / "img+mul_bal/inputs/keyframe_static_videos" / task videos = sorted(source_dir.glob("*.mp4")) assert len(videos) == 14333 assert {p.stem for p in videos} == {p.stem for p in metadata_dir.glob("*.json")} groups, group, size = [], [], 0 for p in videos: estimate = ((p.stat().st_size + 511) // 512) * 512 + 8192 if group and size + estimate > target_bytes: groups.append(group) group, size = [], 0 group.append(p) size += estimate if group: groups.append(group) all_rows = [] for i, members in enumerate(groups): shard = folder / f"videos-{i:05d}-of-{len(groups):05d}.tar" checkpoint = shard.with_suffix(".index.parquet") if shard.exists() and checkpoint.exists(): rows = pq.read_table(checkpoint).to_pylist() assert [x["sample_id"] for x in rows] == [p.stem for p in members] all_rows.extend(rows) log("REUSE_SHARD", shard.name) continue rows = [] temp = shard.with_suffix(".tar.tmp") with tarfile.open(temp, "w", format=tarfile.PAX_FORMAT) as tar: for p in members: assert not p.is_symlink() before = p.stat() meta_path = metadata_dir / (p.stem + ".json") raw_meta = read_unchanged(meta_path) meta = json.loads(raw_meta) assert meta["task_id"] == p.stem meta["input_images"] = [public_relative(x) for x in meta["input_images"]] meta["input_images_base"] = "external_public_root" normalized = (json.dumps(meta, ensure_ascii=False, indent=2) + "\n").encode("utf-8") with p.open("rb") as f: reader = HashReader(f) tar.addfile(tar_info(p.name, before.st_size), reader) after = p.stat() assert (before.st_size, before.st_mtime_ns) == (after.st_size, after.st_mtime_ns) tar.addfile(tar_info(p.stem + ".json", len(normalized)), io.BytesIO(normalized)) rows.append({ "sample_id": p.stem, "source_sample_id": source_id(p.stem, task), "task": task, "level": "level1", "source_modality": "image", "shard": str(shard.relative_to(release)), "member_path": p.name, "metadata_member_path": p.stem + ".json", "original_relpath": str(p.relative_to(source)), "size_bytes": before.st_size, "sha256": reader.hash.hexdigest(), "metadata_sha256": hashlib.sha256(normalized).hexdigest(), "source_metadata_sha256": hashlib.sha256(raw_meta).hexdigest(), "text": meta["text"], "source_duration_seconds": float(meta["source_duration_seconds"]), "generated_duration_seconds": float(meta["generated_duration_seconds"]), "timestamps_seconds": meta["timestamps_seconds"], "static_frame_durations_seconds": meta["static_frame_durations_seconds"], "input_images": meta["input_images"], }) temp.replace(shard) write_parquet(checkpoint, rows) all_rows.extend(rows) log("SHARD_WRITTEN", task, shard.name, len(rows), shard.stat().st_size) assert len(all_rows) == 14333 assert len({x["sample_id"] for x in all_rows}) == 14333 write_parquet(folder / "index.parquet", all_rows) # Read all tar payloads back, checking hashes and exact archive membership. for shard in sorted(folder.glob("*.tar")): wanted = {} for row in all_rows: if row["shard"] == str(shard.relative_to(release)): wanted[row["member_path"]] = row["sha256"] wanted[row["metadata_member_path"]] = row["metadata_sha256"] seen = set() with tarfile.open(shard, "r|") as tar: for entry in tar: assert entry.isfile() and entry.name in wanted and entry.name not in seen f = tar.extractfile(entry) h = hashlib.sha256() for block in iter(lambda: f.read(1024 * 1024), b""): h.update(block) assert h.hexdigest() == wanted[entry.name] seen.add(entry.name) assert seen == set(wanted) log("SHARD_VERIFIED", task, shard.name) # Per-shard indexes are kept: they support selective download and resumable builds. return {"task": task, "path": str(folder.relative_to(release)), "records": len(all_rows), "shards": len(groups), "source_mp4_bytes": sum(x["size_bytes"] for x in all_rows)}, { x["source_sample_id"] for x in all_rows} def build_docs(release, texts, videos, validation): config = [] for row in texts: config += [f"- config_name: {row['config']}", " data_files:", " - split: data", f" path: {row['path']}"] for row in videos: config += [f"- config_name: level1_{row['task'].lower()}_index", " data_files:", " - split: data", f" path: {row['path']}/index.parquet"] readme = "---\npretty_name: RoboSteer Preprocessing\nlanguage:\n- en\ntags:\n- robosteer\n- preprocessing\n- motion-generation\n- intermediate-assets\nconfigs:\n" + "\n".join(config) + "\n---\n\n" readme += """# RoboSteer Preprocessing Reusable intermediate preprocessing assets for RoboSteer. This initial release contains Level 1 processed text instructions and image-conditioned static videos. Other levels and preprocessing stages can be added under their own directories. ## Release v1.0.0 - **213,044 text records** in nine lossless UTF-8 Parquet tables. - **28,666 original MP4 files**: 14,333 IMG_TXT_HUMAN and 14,333 IMG_TXT_SKEL. - Independent, uncompressed tar shards contain MP4 files and their normalized JSON metadata. - Per-sample indexes, release inventory, SHA-256 checksums, and validation report. These are preprocessing assets, not a declared train/validation/test split. The `data` split means the complete asset collection for a configuration. Audio motion instructions are text derived from audio; audio recordings and raw transcripts are not included. MUL_BAL is included as processed text; this release does not contain MUL_BAL videos. Prediction-video manifests are outside this release scope. ## Layout ```text level1/ text/txt_imit/{txt_gen,txt_comp_hands,txt_comp_legs}/data.parquet text/txt_pred/{txt_fore,txt_retro,txt_inter}/data.parquet text/{img_txt,mul_bal_txt}/data.parquet audio/motion_instructions/data.parquet image/{img_txt_human,img_txt_skel}/ videos-00000-of-NNNNN.tar videos-00000-of-NNNNN.index.parquet index.parquet manifests/{assets,validation,provenance}.json scripts/restore_text.py scripts/build_dataset.py SHA256SUMS CHANGELOG.md ``` ## Load text or an index ```python from datasets import load_dataset ds = load_dataset("PhoebeCC/RoboSteer-Preprocessing", "level1_txt_gen", split="data", revision="v1.0.0") video_index = load_dataset("PhoebeCC/RoboSteer-Preprocessing", "level1_img_txt_human_index", split="data", revision="v1.0.0") ``` Text columns: `sample_id`, `source_sample_id`, `task`, `level`, `source_modality`, `text`, `original_relpath`, `size_bytes`, `sha256`. Original UTF-8 bytes, including line endings, can be reconstructed with `text.encode('utf-8')`. Use `scripts/restore_text.py` to restore the original relative file layout. ## Download video shards ```python from huggingface_hub import snapshot_download snapshot_download("PhoebeCC/RoboSteer-Preprocessing", repo_type="dataset", revision="v1.0.0", local_dir="robosteer-preprocessing", allow_patterns=["level1/image/img_txt_human/*", "level1/manifests/*", "README.md", "SHA256SUMS"]) ``` Each tar is independently extractable. The index identifies its repository-relative `shard`, MP4 `member_path`, JSON `metadata_member_path`, and checksums. Video indexes are searchable tables; this release does not configure an embedded-video viewer. Extract each task into a separate folder. MP4 files are preserved byte for byte, without re-encoding. ## Provenance and alignment `sample_id` preserves the source filename stem. `source_sample_id` removes only the known task prefix (or audio suffix). Use `(task, sample_id)` as an asset key; use `source_sample_id` to join related tasks, without assuming all tasks cover the same samples. Coverage results are recorded in the validation report. Video metadata originates from existing sidecar JSON files. Metadata text is the original sidecar description, not necessarily the rewritten `text/img_txt` instruction. Image paths are converted to paths relative to the external public-data root. Source duration and generated duration are metadata values, not newly measured properties. The source generator specifies 25 FPS; this packaging run does not probe actual MP4 frame rates. Source images, external task JSONs, model weights, raw audio, audit logs, and organization backups are not bundled. ## Rights and citation The repository owner has not yet supplied a release license or complete upstream attribution. No blanket open-source license is asserted for these derived assets. Upstream restrictions remain applicable; consult the owner about permitted redistribution and use. Formal benchmark citation and upstream dataset attribution will be added when supplied. ## Reproducibility See `level1/manifests/provenance.json` for packaging rules and generator fingerprints, `assets.json` for counts, and `validation.json` for checks. `SHA256SUMS` covers all payload and documentation files except itself. SHA-256 verification can be performed with `sha256sum -c SHA256SUMS` after a full download. Release tags identify immutable intended snapshots; pin the tag or commit for experiments. Later assets should extend task-specific paths and receive a new version and changelog entry. """ (release / "README.md").write_text(readme) (release / "CHANGELOG.md").write_text("# Changelog\n\n## v1.0.0 — 2026-09-17\n\nInitial Level 1 release: nine processed-text tables, two static-video tasks, original-name recovery, metadata indexes, and SHA-256 verification. No source text rewriting or video re-encoding.\n") table = "\n".join(f"| {x['config']} | {x['records']:,} | `{x['path']}` |" for x in texts) (release / "level1/README.md").write_text("# Level 1 预处理中间资产\n\n本发布目录独立于工作目录，包含本次选定的整理后文本和 IMG_TXT 条件视频。\n\n| 文本配置 | 条数 | 仓库路径 |\n|---|---:|---|\n" + table + "\n\nHUMAN 与 SKEL 各 14,333 个 MP4，保存在 image/ 下独立 tar 分片中；index.parquet 可定位每个视频及 JSON 元数据。已有 JSON 中的服务器绝对图片路径已改为相对于外部 public 根的路径。\n\n音频类仅包含整理后的动作指令；本发布不含音频实体或转写全文。MUL_BAL 目前仅包含文本。各配置的 data 表示完整资产集合，不代表训练集划分。\n\n详见仓库根 README、manifests/ 清单和 SHA256SUMS。\n") write_json(release / "level1/manifests/assets.json", {"version": VERSION, "text": texts, "videos": videos}) write_json(release / "level1/manifests/validation.json", validation) def main(): parser = argparse.ArgumentParser() parser.add_argument("--source", type=Path, required=True, help="Current level1 work directory") parser.add_argument("--release", type=Path, required=True, help="Dedicated publication directory") parser.add_argument("--shard-bytes", type=int, default=1024**3) args = parser.parse_args() assert args.source.resolve() != args.release.resolve() args.release.mkdir(parents=True, exist_ok=True) text, ids = build_text(args.source, args.release) videos = [] for task in ["IMG_TXT_HUMAN", "IMG_TXT_SKEL"]: row, sample_ids = build_video(args.source, args.release, task, args.shard_bytes) videos.append(row) ids[task] = sample_ids validation = { "text_records": sum(x["records"] for x in text), "video_records": sum(x["records"] for x in videos), "text_utf8_roundtrip_sha256": "passed for every row", "video_and_metadata_tar_payload_sha256": "passed for every member", "duplicate_asset_ids": 0, "human_skel_matching_source_ids": len(ids["IMG_TXT_HUMAN"] & ids["IMG_TXT_SKEL"]), "img_text_skel_matching_source_ids": len(ids["img_txt"] & ids["IMG_TXT_SKEL"]), "empty_text_records": sum(x["empty_text_records"] for x in text), "mp4_decoding_test": "not performed; lossless packaging only", } assert validation["text_records"] == 213044 assert validation["human_skel_matching_source_ids"] == 14333 assert validation["img_text_skel_matching_source_ids"] == 14333 build_docs(args.release, text, videos, validation) scripts = args.release / "scripts" scripts.mkdir(exist_ok=True) shutil.copy2(__file__, scripts / "build_dataset.py") shutil.copy2(Path(__file__).with_name("restore_text.py"), scripts / "restore_text.py") generators = [args.source / "img+mul_bal/scripts/build_keyframe_static_videos.py", args.source.parent / "GEM/scripts/demo/run_img_txt_video_to_motion_fast.sh"] write_json(args.release / "level1/manifests/provenance.json", { "release": VERSION, "packaged_date": "2026-09-17", "packaging_script_sha256": digest(Path(__file__)), "pyarrow_version": pa.__version__, "text_policy": "strict UTF-8; bytes and line endings preserved", "mp4_policy": "unmodified source bytes", "metadata_policy": "external image paths normalized to public-root-relative", "shard_target_bytes": args.shard_bytes, "tar_policy": "independent PAX tar, sorted filenames, normalized headers", "source_generator_fingerprints": {p.name: digest(p) for p in generators}, "source_generation_commit": None, "source_generation_commit_note": "Historical generation commit was not recorded", }) checks = [] for p in sorted(args.release.rglob("*")): if p.is_file() and p.name != "SHA256SUMS" and ".cache" not in p.parts: checks.append(f"{digest(p)} {p.relative_to(args.release).as_posix()}") (args.release / "SHA256SUMS").write_text("\n".join(checks) + "\n") log("BUILD_COMPLETE", json.dumps(validation)) if __name__ == "__main__": main()