#!/usr/bin/env python3 """Build viewer-friendly file/shard index Parquet splits for LiteFold/NCBI.""" from __future__ import annotations import argparse import hashlib import json import os import re import shutil from pathlib import Path from typing import Any import pyarrow as pa import pyarrow.parquet as pq from huggingface_hub import HfApi, hf_hub_download INDEX_COLUMNS = [ "file_id", "repo_id", "source_sha", "dataset_id", "source_slug", "source_file", "path", "role", "shard_index", "size_bytes", "compression", "records_in_source", "residues_in_source", "shards_in_source", "records_total", "residues_total", "total_shards", "is_sequence_shard", "is_metadata_records", "download_pattern", "access_note", "split_bucket", ] SCHEMA = pa.schema( [ pa.field("file_id", pa.string()), pa.field("repo_id", pa.string()), pa.field("source_sha", pa.string()), pa.field("dataset_id", pa.string()), pa.field("source_slug", pa.string()), pa.field("source_file", pa.string()), pa.field("path", pa.string()), pa.field("role", pa.string()), pa.field("shard_index", pa.int64()), pa.field("size_bytes", pa.int64()), pa.field("compression", pa.string()), pa.field("records_in_source", pa.int64()), pa.field("residues_in_source", pa.int64()), pa.field("shards_in_source", pa.int64()), pa.field("records_total", pa.int64()), pa.field("residues_total", pa.int64()), pa.field("total_shards", pa.int64()), pa.field("is_sequence_shard", pa.bool_()), pa.field("is_metadata_records", pa.bool_()), pa.field("download_pattern", pa.string()), pa.field("access_note", pa.string()), pa.field("split_bucket", pa.int64()), ] ) def load_token() -> str | None: for key in ("HF_TOKEN", "HUGGINGFACE_HUB_TOKEN"): value = os.environ.get(key) if value: return value env_path = Path(".env") if env_path.exists(): for line in env_path.read_text().splitlines(): stripped = line.strip() if not stripped or stripped.startswith("#") or "=" not in stripped: continue key, value = stripped.split("=", 1) if key.strip() in {"HF_TOKEN", "HUGGINGFACE_HUB_TOKEN"}: value = value.strip().strip('"').strip("'") if value: return value return None def stable_bucket(value: str, buckets: int = 10) -> int: digest = hashlib.sha256(value.encode("utf-8")).hexdigest()[:16] return int(digest, 16) % buckets def role_for_path(path: str) -> tuple[str, str | None, int | None, bool, bool]: shard_match = re.search(r"sequences/([^/]+)/shard-(\d+)\.fasta\.zst$", path) if shard_match: return "sequence_shard", shard_match.group(1), int(shard_match.group(2)), True, False metadata_match = re.search(r"metadata/(.+)\.records\.jsonl$", path) if metadata_match: return "metadata_records", metadata_match.group(1), None, False, True manifest_match = re.search(r"manifests/(.+)\.json$", path) if manifest_match: return "source_manifest", manifest_match.group(1), None, False, False if path == "_MANIFEST.json": return "aggregate_manifest", None, None, False, False if path == "README.md": return "readme", None, None, False, False if path == ".gitattributes": return "git_attributes", None, None, False, False return "other", None, None, False, False def compression_for_path(path: str) -> str | None: if path.endswith(".fasta.zst"): return "zstd" return None def build_dataset(repo_id: str, raw_dir: Path, out_dir: Path) -> dict[str, Any]: token = load_token() api = HfApi(token=token) info = api.dataset_info(repo_id, files_metadata=True) raw_dir.mkdir(parents=True, exist_ok=True) manifest_path = Path( hf_hub_download( repo_id=repo_id, repo_type="dataset", filename="_MANIFEST.json", local_dir=raw_dir, token=token, ) ) manifest = json.loads(manifest_path.read_text()) dataset_id = str(manifest["dataset_id"]) total_records = int(manifest["total_records"]) total_residues = int(manifest["total_residues"]) total_shards = int(manifest["total_shards"]) sources_by_slug = {source["source_slug"]: source for source in manifest["sources"]} rows = [] for sibling in sorted(info.siblings or [], key=lambda item: item.rfilename): path = sibling.rfilename role, source_slug, shard_index, is_sequence_shard, is_metadata_records = role_for_path(path) source = sources_by_slug.get(source_slug or "") file_id = path rows.append( { "file_id": file_id, "repo_id": repo_id, "source_sha": info.sha, "dataset_id": dataset_id, "source_slug": source_slug, "source_file": source.get("source_file") if source else None, "path": path, "role": role, "shard_index": shard_index, "size_bytes": int(getattr(sibling, "size", 0) or 0), "compression": compression_for_path(path), "records_in_source": int(source["records"]) if source else None, "residues_in_source": int(source["residues"]) if source else None, "shards_in_source": int(source["shards"]) if source else None, "records_total": total_records, "residues_total": total_residues, "total_shards": total_shards, "is_sequence_shard": is_sequence_shard, "is_metadata_records": is_metadata_records, "download_pattern": f"sequences/{source_slug}/shard-*.fasta.zst" if is_sequence_shard else path, "access_note": "File/shard index for NCBI RefSeq protein; download sequence shards for FASTA records.", "split_bucket": stable_bucket(file_id), } ) if out_dir.exists(): shutil.rmtree(out_dir) data_dir = out_dir / "data" metadata_dir = out_dir / "metadata" data_dir.mkdir(parents=True, exist_ok=True) metadata_dir.mkdir(parents=True, exist_ok=True) train_rows = sorted((row for row in rows if row["split_bucket"] != 0), key=lambda row: row["path"]) test_rows = sorted((row for row in rows if row["split_bucket"] == 0), key=lambda row: row["path"]) pq.write_table(pa.Table.from_pylist(train_rows, schema=SCHEMA), data_dir / "train-00000-of-00001.parquet", compression="zstd") pq.write_table(pa.Table.from_pylist(test_rows, schema=SCHEMA), data_dir / "test-00000-of-00001.parquet", compression="zstd") pq.write_table(pa.Table.from_pylist(rows, schema=SCHEMA), metadata_dir / "source_files.parquet", compression="zstd") sequence_bytes = sum(int(row["size_bytes"]) for row in rows if row["is_sequence_shard"]) metadata_bytes = sum(int(row["size_bytes"]) for row in rows if row["is_metadata_records"]) role_counts: dict[str, int] = {} for row in rows: role_counts[row["role"]] = role_counts.get(row["role"], 0) + 1 summary = { "source": repo_id, "source_sha": info.sha, "viewer_table_scope": "file/shard index", "dataset_id": dataset_id, "source_count": int(manifest["source_count"]), "records_total": total_records, "residues_total": total_residues, "total_shards": total_shards, "index_rows": len(rows), "sequence_shard_rows": sum(1 for row in rows if row["is_sequence_shard"]), "sequence_shard_bytes": sequence_bytes, "metadata_records_bytes": metadata_bytes, "splits": {"train": len(train_rows), "test": len(test_rows)}, "split_strategy": "deterministic sha256(file_id) % 10; bucket 0 is test, buckets 1-9 are train", "role_counts": role_counts, "columns": INDEX_COLUMNS, } (out_dir / "dataset_summary.json").write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8") return summary def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--repo-id", default="LiteFold/NCBI") parser.add_argument("--raw-dir", type=Path, default=Path("LiteFold_NCBI_raw")) parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_NCBI_processed")) args = parser.parse_args() summary = build_dataset(args.repo_id, args.raw_dir, args.out_dir) print(json.dumps(summary, indent=2)) if __name__ == "__main__": main()