#!/usr/bin/env python3 """Build viewer-friendly file/shard index Parquet splits for LiteFold/UniRef90.""" 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 pandas as pd from huggingface_hub import HfApi, hf_hub_download INDEX_COLUMNS = [ "file_id", "repo_id", "source_sha", "source_slug", "path", "role", "shard_index", "size_bytes", "compression", "records_total", "residues_total", "total_shards", "is_sequence_shard", "is_metadata_records", "download_pattern", "access_note", "split_bucket", ] 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" if path.endswith(".jsonl"): return None if path.endswith(".json"): return None 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()) source = manifest["sources"][0] source_slug = source["source_slug"] records_total = int(source["records"]) residues_total = int(source["residues"]) total_shards = int(source["shards"]) rows = [] for sibling in sorted(info.siblings or [], key=lambda item: item.rfilename): path = sibling.rfilename role, inferred_slug, shard_index, is_sequence_shard, is_metadata_records = role_for_path(path) slug = inferred_slug or source_slug file_id = path rows.append( { "file_id": file_id, "repo_id": repo_id, "source_sha": info.sha, "source_slug": slug, "path": path, "role": role, "shard_index": shard_index, "size_bytes": int(getattr(sibling, "size", 0) or 0), "compression": compression_for_path(path), "records_total": records_total, "residues_total": residues_total, "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 UniRef90; 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) df = pd.DataFrame.from_records(rows, columns=INDEX_COLUMNS) train = df[df["split_bucket"].ne(0)].sort_values("path", kind="mergesort") test = df[df["split_bucket"].eq(0)].sort_values("path", kind="mergesort") train.to_parquet(data_dir / "train-00000-of-00001.parquet", index=False, compression="zstd") test.to_parquet(data_dir / "test-00000-of-00001.parquet", index=False, compression="zstd") df.to_parquet(metadata_dir / "source_files.parquet", index=False, compression="zstd") sequence_bytes = int(df[df["is_sequence_shard"]]["size_bytes"].sum()) metadata_bytes = int(df[df["is_metadata_records"]]["size_bytes"].sum()) summary = { "source": repo_id, "source_sha": info.sha, "viewer_table_scope": "file/shard index", "source_slug": source_slug, "records_total": records_total, "residues_total": residues_total, "total_shards": total_shards, "index_rows": int(len(df)), "sequence_shard_rows": int(df["is_sequence_shard"].sum()), "sequence_shard_bytes": sequence_bytes, "metadata_records_bytes": metadata_bytes, "splits": {"train": int(len(train)), "test": int(len(test))}, "split_strategy": "deterministic sha256(file_id) % 10; bucket 0 is test, buckets 1-9 are train", "role_counts": {str(k): int(v) for k, v in df["role"].value_counts().to_dict().items()}, "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/UniRef90") parser.add_argument("--raw-dir", type=Path, default=Path("LiteFold_UniRef90_raw")) parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_UniRef90_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()