| """Restore RF-Loc-Sim2Real datasets from Hugging Face crop shards.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import shutil |
| import tarfile |
| from pathlib import Path |
|
|
| try: |
| import zstandard as zstd |
| except ImportError as exc: |
| raise SystemExit("Missing dependency: zstandard. Install with `python -m pip install zstandard`.") from exc |
|
|
| try: |
| from tqdm import tqdm |
| except ImportError: |
| tqdm = None |
|
|
|
|
| def sha256_file(path: Path, chunk_size: int = 8 * 1024 * 1024) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as handle: |
| for chunk in iter(lambda: handle.read(chunk_size), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def safe_extract_tar_zst(shard: Path, target_dir: Path) -> None: |
| target_resolved = target_dir.resolve() |
| dctx = zstd.ZstdDecompressor() |
| with shard.open("rb") as raw: |
| with dctx.stream_reader(raw) as reader: |
| with tarfile.open(fileobj=reader, mode="r|") as tar: |
| for member in tar: |
| destination = (target_dir / member.name).resolve() |
| if not str(destination).startswith(str(target_resolved)): |
| raise RuntimeError(f"Refusing to extract unsafe path {member.name!r} from {shard}") |
| tar.extract(member, target_dir) |
|
|
|
|
| def copy_tree(src: Path, dst: Path) -> None: |
| if not src.exists(): |
| return |
| for path in src.rglob("*"): |
| if path.is_dir(): |
| continue |
| rel = path.relative_to(src) |
| target = dst / rel |
| target.parent.mkdir(parents=True, exist_ok=True) |
| shutil.copy2(path, target) |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--input", required=True, type=Path, help="HF dataset export directory.") |
| parser.add_argument("--output", required=True, type=Path, help="Restored dataset output directory.") |
| parser.add_argument("--datasets", nargs="*", default=None, help="Optional subset of datasets to restore.") |
| parser.add_argument("--skip-checksums", action="store_true", help="Skip shard checksum validation.") |
| parser.add_argument("--overwrite", action="store_true", help="Allow writing into a non-empty output directory.") |
| args = parser.parse_args() |
|
|
| export_root = args.input.expanduser().resolve() |
| output_root = args.output.expanduser().resolve() |
| manifest_path = export_root / "dataset_manifest.json" |
| if not manifest_path.exists(): |
| raise SystemExit(f"Missing manifest: {manifest_path}") |
| manifest = json.loads(manifest_path.read_text(encoding="utf-8")) |
|
|
| if output_root.exists() and any(output_root.iterdir()) and not args.overwrite: |
| raise SystemExit(f"Output directory is not empty: {output_root}. Use --overwrite to continue.") |
| output_root.mkdir(parents=True, exist_ok=True) |
|
|
| datasets = args.datasets or list(manifest["datasets"].keys()) |
| for dataset in datasets: |
| if dataset not in manifest["datasets"]: |
| raise SystemExit(f"Dataset {dataset!r} not found in manifest.") |
| print(f"Restoring {dataset}") |
| src_dataset = export_root / dataset |
| dst_dataset = output_root / dataset |
| copy_tree(src_dataset / "splits", dst_dataset / "splits") |
| copy_tree(src_dataset / "tabular", dst_dataset / "tabular") |
| crops_dir = dst_dataset / "crops" |
| crops_dir.mkdir(parents=True, exist_ok=True) |
|
|
| shards = manifest["datasets"][dataset]["crops"]["shards"] |
| iterator = shards |
| if tqdm is not None: |
| iterator = tqdm(shards, desc=f"extracting {dataset}", unit="shard") |
| for shard_info in iterator: |
| shard = src_dataset / "crops_shards" / shard_info["name"] |
| if not shard.exists(): |
| raise SystemExit(f"Missing shard: {shard}") |
| if not args.skip_checksums: |
| actual = sha256_file(shard) |
| if actual != shard_info["sha256"]: |
| raise SystemExit(f"Checksum mismatch for {shard}: {actual} != {shard_info['sha256']}") |
| safe_extract_tar_zst(shard, crops_dir) |
|
|
| print(f"Restored datasets to: {output_root}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
