Datasets:

allenai
/

molmospaces

	"""Download molmospaces data.
	The repository contains 2GB tar shards of ``.tar.zst`` archives,
	with each archive's shard id / byte offset / size recorded in a
	parquet arrow table. The shards and two metadata files
	(a manifest JSON and an archive tries compressed JSON) are also stored
	under a `data_source_dir` such as ``mujoco/objects/thor/20251117``.
	This script auto-discovers every available
	source (by scanning for ``pkgs`` parquet files), downloads
	the metadata and shard tars, and decompresses + extracts each inner
	``.tar.zst`` on the fly into a local directory tree.
	"""

	import io
	import os
	import tarfile
	from pathlib import Path
	import json

	import datasets
	import zstandard as zstd
	from datasets import Dataset
	from huggingface_hub import HfApi, hf_hub_download
	from tqdm import tqdm

	datasets.logging.set_verbosity_error()
	datasets.disable_progress_bars()

	HF_REPO_ID = "allenai/molmospaces"
	HF_REPO_TYPE = "dataset"

	MANIFEST_NAME = "mjthor_resource_file_to_size_mb.json"
	TRIES_NAME = "mjthor_resources_combined_meta.json.gz"
	EXTRACTED_MANIFEST_NAME = "mjthor_data_type_to_source_to_versions.json"

	VALID_SOURCES = ("mujoco", "isaac", "all")

	# ------------------------------------------------------------------
	# Meta files
	# ------------------------------------------------------------------


	def download_meta(
	data_source_dir: str,
	target_dir: str,
	revision: str = "main",
	) -> dict[str, str]:
	"""Download the manifest and tries files.
	The files are fetched via ``hf_hub_download`` (which caches them
	locally) and then copied into ``<target_dir>`` so the output
	directory is self-contained.
	Parameters
	----------
	data_source_dir:
	Repository-relative directory, e.g.
	``"mujoco/objects/thor/20251117"``.
	target_dir:
	Local directory; meta files are placed in ``<target_dir>/``.
	revision:
	HF branch or revision.
	Returns
	-------
	dict[str, str]
	Mapping of filename to local path for each successfully
	downloaded meta file. Files that do not exist in the repo are
	silently skipped.
	"""
	downloaded: dict[str, str] = {}
	meta_dir = target_dir
	os.makedirs(meta_dir, exist_ok=True)

	for name in [MANIFEST_NAME, TRIES_NAME]:
	path_in_repo = f"{data_source_dir}/{name}"
	local_path = os.path.join(meta_dir, name)
	try:
	cached = hf_hub_download(
	repo_id=HF_REPO_ID,
	filename=path_in_repo,
	repo_type=HF_REPO_TYPE,
	revision=revision,
	)
	# Copy from HF cache into target_dir so the user has a
	# self-contained output directory.
	_copy_file(cached, local_path)
	downloaded[name] = local_path
	print(f"Downloaded meta: {name}")
	except Exception as e:
	print(f"Skipped meta (not found): {name} ({e})")

	return downloaded


	# ------------------------------------------------------------------
	# Arrow table
	# ------------------------------------------------------------------


	def load_arrow_table(data_source_dir: str, revision: str = "main") -> Dataset:
	"""Load the arrow table that describes the contents of each shard.
	Each row in the returned Dataset contains:
	- path (str): relative path of the ``.tar.zst`` member inside
	the shard tar.
	- shard_id (int): which shard tar the member lives in.
	- offset (int): byte offset of the member's data within the
	shard tar.
	- size (int): size in bytes of the ``.tar.zst`` payload.
	Parameters
	----------
	data_source_dir:
	Repository-relative directory, e.g.
	``"mujoco/objects/thor/20251117"``.
	revision:
	HF branch or revision.
	Returns
	-------
	Dataset
	Arrow table with one row per ``.tar.zst`` archive.
	Raises
	------
	FileNotFoundError
	If no ``pkgs`` parquet files are found under data_source_dir.
	"""
	api = HfApi()

	# Parquet configs live under a __-joined path.
	parquet_dir = data_source_dir.replace("/", "__")
	repo_items = api.list_repo_tree(
	repo_id=HF_REPO_ID,
	repo_type=HF_REPO_TYPE,
	path_in_repo=parquet_dir,
	revision=revision,
	)
	parquet_paths = sorted(
	item.path
	for item in repo_items
	if getattr(item, "path", "").endswith(".parquet") and "pkgs" in os.path.basename(item.path)
	)

	if not parquet_paths:
	raise FileNotFoundError(f"No parquet files found for split 'pkgs' under {data_source_dir}")

	# Download each parquet shard from the HF cache.
	local_paths = [
	hf_hub_download(
	repo_id=HF_REPO_ID,
	filename=pf,
	repo_type=HF_REPO_TYPE,
	revision=revision,
	)
	for pf in parquet_paths
	]

	ds = Dataset.from_parquet(local_paths if len(local_paths) > 1 else local_paths[0])
	return ds


	# ------------------------------------------------------------------
	# Extraction helpers
	# ------------------------------------------------------------------


	def _copy_file(src: str, dst: str) -> None:
	"""Copy src to dst, creating parent dirs as needed."""
	import shutil

	os.makedirs(os.path.dirname(dst), exist_ok=True)
	shutil.copy2(src, dst)


	def _extract_tar_zst_bytes(data: bytes, output_dir: str) -> None:
	"""Decompress a .tar.zst payload in-memory and stream-extract to output_dir."""
	dctx = zstd.ZstdDecompressor()
	with dctx.stream_reader(io.BytesIO(data)) as reader:
	with tarfile.open(fileobj=reader, mode="r\|") as tar:
	tar.extractall(path=output_dir)


	def _format_size(size_bytes: int) -> str:
	if size_bytes >= 1024**4:
	return f"{size_bytes / 1024**4:.2f} TiB"
	if size_bytes >= 1024**3:
	return f"{size_bytes / 1024**3:.2f} GiB"
	if size_bytes >= 1024**2:
	return f"{size_bytes / 1024**2:.2f} MiB"
	if size_bytes >= 1024:
	return f"{size_bytes / 1024:.2f} KiB"
	return f"{size_bytes} B"


	def estimate_sizes(data_source_dir: str, revision: str = "main") -> tuple[int, int \| None]:
	"""Return (download_bytes, extracted_bytes_or_None) for a source.
	download_bytes is the sum of compressed .tar.zst sizes (which equals
	both the network transfer and the HF cache disk usage).
	extracted_bytes is the sum of ``inflated_size`` if available in the
	arrow table, otherwise ``None``.
	"""
	ds = load_arrow_table(data_source_dir, revision=revision)
	rows = ds.to_list()
	download = sum(r["size"] for r in rows)
	if rows and "inflated_size" in rows[0]:
	extracted = sum(r["inflated_size"] for r in rows)
	else:
	extracted = None
	return download, extracted


	# ------------------------------------------------------------------
	# Main download-and-extract
	# ------------------------------------------------------------------


	def download_and_extract(
	data_source_dir: str,
	target_dir: str,
	revision: str = "main",
	versioned: bool = True,
	confirm: bool = True,
	) -> None:
	"""Download and extract a single data source.
	This is the main entry point for downloading one ``data_source_dir``. It
	performs three steps:
	1. Metadata -- download the manifest JSON and tries JSON file
	into ``<target_dir>/``.
	2. Arrow table -- load the parquet table to discover which
	shards exist and how many archives they contain.
	3. Shards -- for each shard tar, download it (via
	``hf_hub_download``, which caches locally), iterate through its
	members, decompress each ``.tar.zst`` payload with zstandard, and
	stream-extract the inner tar into target_dir.
	Parameters
	----------
	data_source_dir:
	Repository-relative directory, e.g.
	``"mujoco/objects/thor/20251117"``.
	target_dir:
	Local directory to extract all data into.
	revision:
	HF branch or revision.
	versioned:
	Whether to include the version string in the extracted data paths
	"""
	os.makedirs(target_dir, exist_ok=True)

	bucket, data_type, data_source, version = Path(data_source_dir).parts
	base_dir = Path().joinpath(*Path(target_dir).parts[:-4])
	extracted_manifest_path = base_dir / bucket / EXTRACTED_MANIFEST_NAME
	print("Using", extracted_manifest_path, "for", data_source_dir)

	manifest = {}
	if os.path.isfile(extracted_manifest_path):
	with open(extracted_manifest_path, "r") as f:
	manifest = json.load(f)
	if (
	data_type in manifest
	and data_source in manifest[data_type]
	and version in manifest[data_type][data_source]
	):
	print(f"\nPre-extracted archives for {target_dir}")
	return

	if not versioned:
	target_dir = Path(target_dir).parent

	# 1. Meta files ---------------------------------------------------
	print("=== Downloading metadata ===")
	download_meta(data_source_dir, target_dir, revision=revision)

	# 2. Arrow table --------------------------------------------------
	print("\n=== Loading arrow table ===")
	ds = load_arrow_table(data_source_dir, revision=revision)
	rows = ds.to_list()
	print(f"Arrow table has {len(rows)} entries")

	# Group entries by shard so we know which shards to fetch.
	shard_ids: set[int] = set()
	for row in rows:
	shard_ids.add(row["shard_id"])

	num_shards = len(shard_ids)
	total_entries = len(rows)

	# Size estimates
	download_bytes = sum(r["size"] for r in rows)
	has_inflated = rows and "inflated_size" in rows[0]
	extracted_bytes = sum(r["inflated_size"] for r in rows) if has_inflated else None

	print(f"{total_entries} entries spread across {num_shards} shard(s)")
	print(f" Download size : {_format_size(download_bytes)}")
	if extracted_bytes is not None:
	print(f" Extracted on disk : {_format_size(extracted_bytes)}")
	else:
	print(f" Extracted on disk : (unknown — inflated_size not yet backfilled)")

	if confirm:
	answer = input("\nProceed with download? [Y/n] ").strip().lower()
	if answer and answer not in ("y", "yes"):
	print("Skipped.")
	return

	# Resume support: track completed shards in a local file so that
	# interrupted downloads can skip already-extracted shards.
	progress_file = Path(target_dir) / f".progress_{data_source_dir.replace('/', '_')}.json"
	completed_shards: set[int] = set()
	if progress_file.is_file():
	with open(progress_file) as f:
	completed_shards = set(json.load(f))

	remaining_shards = sorted(shard_ids - completed_shards)
	if completed_shards:
	print(
	f"Resuming: {len(completed_shards)} shard(s) already extracted, "
	f"{len(remaining_shards)} remaining"
	)

	# 3. Download & extract shards ------------------------------------
	print(f"\n=== Downloading & extracting {len(remaining_shards)} shard(s) ===")

	extracted = 0
	for shard_id in tqdm(remaining_shards, desc="Shards"):
	shard_filename = f"{data_source_dir}/shards/{shard_id:05d}.tar"

	# hf_hub_download caches the file; repeated runs skip the download.
	shard_local = hf_hub_download(
	repo_id=HF_REPO_ID,
	filename=shard_filename,
	repo_type=HF_REPO_TYPE,
	revision=revision,
	)

	# Stream through the shard tar and extract each .tar.zst member.
	with tarfile.open(shard_local, "r:") as shard_tar:
	members = [m for m in shard_tar.getmembers() if m.isfile()]
	for member in tqdm(members, desc=f" Shard {shard_id}", leave=False):
	fobj = shard_tar.extractfile(member)
	if fobj is None:
	continue

	data = fobj.read()
	_extract_tar_zst_bytes(data, target_dir)
	extracted += 1

	# Free the cached shard to avoid accumulating disk usage.
	try:
	os.remove(shard_local)
	except OSError:
	pass

	completed_shards.add(shard_id)
	with open(progress_file, "w") as f:
	json.dump(sorted(completed_shards), f)

	if data_type not in manifest:
	manifest[data_type] = {}
	if data_source not in manifest[data_type]:
	manifest[data_type][data_source] = []
	manifest[data_type][data_source].append(version)

	with open(extracted_manifest_path, "w") as f:
	json.dump(manifest, f, indent=2)

	# Clean up progress file now that the source is fully extracted
	if progress_file.is_file():
	progress_file.unlink()

	print(f"\nDone. Extracted {extracted} archives into: {target_dir}")


	# ------------------------------------------------------------------
	# Discover & download all sources
	# ------------------------------------------------------------------


	def discover_sources(
	revision: str = "main",
	source: str = "all",
	) -> list[str]:
	"""Auto-discover every available source in the HF repo.
	Scans the full file listing of the repository and collects the
	parent directories of all parquet files whose name contains
	``pkgs`` (the split name used by ``mirror_shard.py``). Each such
	directory corresponds to one ``data_source_dir`` / config that was
	uploaded.
	Parameters
	----------
	revision:
	HF branch or revision.
	source:
	Which top-level prefix to include. One of `VALID_SOURCES`.
	Returns
	-------
	list[str]
	Sorted list of ``data_source_dir`` paths, e.g.::
	[
	"mujoco/benchmarks/molmospaces-bench-v1/20260210",
	"mujoco/objects/thor/20251117",
	...
	]
	"""
	if source not in VALID_SOURCES:
	raise ValueError(f"Invalid source {source!r}, must be one of {VALID_SOURCES}")

	api = HfApi()
	all_files = api.list_repo_files(
	repo_id=HF_REPO_ID,
	repo_type=HF_REPO_TYPE,
	revision=revision,
	)

	data_source_dirs: set[str] = set()
	for path in all_files:
	if path.endswith(".parquet") and "pkgs" in os.path.basename(path):
	parent = os.path.dirname(path)
	# Parquet configs use "__" as separator; convert back to "/"
	if "__" in parent:
	parent = parent.replace("__", "/")
	else:
	continue
	if source == "all" or parent.startswith(source + "/"):
	data_source_dirs.add(parent)

	sources = sorted(data_source_dirs)
	return sources


	def download_all(
	base_dir: str,
	revision: str = "main",
	source: str = "all",
	versioned: bool = True,
	) -> None:
	"""Discover and download every source in the HF repo.
	Calls :func:`discover_sources` to list all available ``data_source_dir``
	entries, then iterates through them calling
	:func:`download_and_extract` for each one. Each source's data is
	extracted into ``<base_dir>/<prefix>/<data_type>/<name>`` (the
	version segment is stripped -- see :func:`_target_dir_for_data_source_dir`).
	Sources that fail are logged and skipped so that a single failure
	does not abort the entire batch.
	Parameters
	----------
	base_dir:
	Root directory under which all sources are extracted.
	revision:
	HF branch or revision.
	source:
	Which top-level prefix to include. One of `VALID_SOURCES`.
	versioned:
	Whether to include the version string in the extracted data paths
	"""
	print("=== Discovering sources from HF repo ===")
	sources = discover_sources(revision=revision, source=source)
	print(f"Found {len(sources)} source(s):\n")

	total_download = 0
	total_extracted = 0
	has_all_inflated = True
	for s in sources:
	dl, ex = estimate_sizes(s, revision=revision)
	total_download += dl
	if ex is not None:
	total_extracted += ex
	else:
	has_all_inflated = False
	ex_str = _format_size(ex) if ex is not None else "unknown"
	print(f" {s:60s} dl: {_format_size(dl):>10s} extracted: {ex_str:>10s}")

	print(f"\n {'Total':60s} dl: {_format_size(total_download):>10s}", end="")
	if has_all_inflated:
	print(f" extracted: {_format_size(total_extracted):>10s}")
	print(
	f"\n Disk usage: {_format_size(total_extracted)} (data shards are deleted from cache after extraction)"
	)
	else:
	print(f" extracted: {'(partial)':>10s}")
	print(f"\n Some sources lack inflated_size — total extracted size is incomplete.")
	print()

	answer = input("Proceed with download? [Y/n] ").strip().lower()
	if answer and answer not in ("y", "yes"):
	print("Aborted.")
	return

	completed: list[str] = []
	failed: list[str] = []

	for data_source_dir in sources:
	target_dir = str(Path(base_dir) / data_source_dir)

	print(f"\n{'=' * 60}")
	print(f" HF dir : {data_source_dir}")
	print(f" Target dir: {target_dir}")
	print(f"{'=' * 60}")

	try:
	download_and_extract(
	data_source_dir,
	target_dir,
	revision=revision,
	versioned=versioned,
	confirm=False,
	)
	completed.append(data_source_dir)
	except KeyboardInterrupt:
	raise
	except Exception as e:
	print(f"FAILED: {data_source_dir} ({e})")
	failed.append(data_source_dir)

	print(f"\nCompleted: {len(completed)}/{len(sources)}")
	if failed:
	print(f"Failed ({len(failed)}):")
	for f in failed:
	print(f" - {f}")


	# ------------------------------------------------------------------
	# CLI
	# ------------------------------------------------------------------


	def main() -> None:
	import argparse

	parser = argparse.ArgumentParser(
	description="Download molmospaces",
	)
	parser.add_argument(
	"target_dir",
	help="Local root directory to extract into",
	)
	parser.add_argument(
	"--data_source_dir",
	default=None,
	help=(
	"Download a single source by its directory path, e.g."
	" mujoco/objects/thor/20251117. When omitted, all sources"
	" are auto-discovered from the repo and downloaded. Use --list"
	" to find valid directory paths"
	),
	)
	parser.add_argument(
	"--source",
	choices=VALID_SOURCES,
	default="all",
	help=(
	f"Which data source prefix to include among {VALID_SOURCES}, with "
	"'all' the default. Only affects --list and bulk download; "
	"ignored when --data_source_dir is given."
	),
	)
	parser.add_argument(
	"--list",
	action="store_true",
	dest="list_only",
	help="Only list discovered sources, don't download anything",
	)
	parser.add_argument(
	"--versioned",
	action=argparse.BooleanOptionalAction,
	default=True,
	help="Downloading as versioned enables the extracted data to be directly used"
	" by the MolmoSpaces codebase as extracted cache data, e.g. by exporting"
	" MLSPACES_CACHE_DIR=<target_dir>/mujoco and optionally exporting a different"
	" MLSPACES_ASSETS_DIR (where the cached contents will be symlinked)."
	" Disabling this flag enables directly visualizing scenes or using the"
	" data with external codebases, as the data versions do not get in the"
	" way of the expected relative paths between objects and scenes.",
	)
	parser.add_argument(
	"-y",
	"--yes",
	action="store_true",
	help="Skip confirmation prompts",
	)
	args = parser.parse_args()

	if args.list_only:
	sources = discover_sources(revision="main", source=args.source)
	print(f"Found {len(sources)} source(s):")
	for s in sources:
	print(f" {s}")
	elif args.data_source_dir:
	target = Path(args.target_dir) / args.data_source_dir
	download_and_extract(
	args.data_source_dir,
	str(target),
	revision="main",
	versioned=args.versioned,
	confirm=not args.yes,
	)
	else:
	download_all(
	args.target_dir,
	revision="main",
	source=args.source,
	versioned=args.versioned,
	)


	if __name__ == "__main__":
	main()