File size: 5,330 Bytes
9c51095 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 | #!/usr/bin/env python3
"""Build viewer-friendly source index Parquet splits for LiteFold/BFD."""
from __future__ import annotations
import argparse
import hashlib
import json
import os
import shutil
from math import ceil
from pathlib import Path
from typing import Any
import pandas as pd
from huggingface_hub import HfApi
INDEX_COLUMNS = [
"index_id",
"repo_id",
"source_file",
"source_sha",
"source_format",
"chunk_index",
"byte_start",
"byte_end_exclusive",
"chunk_size_bytes",
"total_size_bytes",
"chunk_size_gib",
"is_first_chunk",
"is_last_chunk",
"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 build_dataset(repo_id: str, out_dir: Path, chunk_size_gib: int) -> dict[str, Any]:
token = load_token()
api = HfApi(token=token)
info = api.dataset_info(repo_id, files_metadata=True)
source = next(
sibling for sibling in info.siblings or [] if sibling.rfilename.endswith(".tar.gz")
)
source_file = source.rfilename
total_size = int(getattr(source, "size", 0) or 0)
chunk_size = int(chunk_size_gib * 1024**3)
chunk_count = ceil(total_size / chunk_size)
rows = []
for chunk_index in range(chunk_count):
byte_start = chunk_index * chunk_size
byte_end = min(byte_start + chunk_size, total_size)
index_id = f"{source_file}:chunk-{chunk_index:06d}"
rows.append(
{
"index_id": index_id,
"repo_id": repo_id,
"source_file": source_file,
"source_sha": info.sha,
"source_format": "tar.gz",
"chunk_index": chunk_index,
"byte_start": byte_start,
"byte_end_exclusive": byte_end,
"chunk_size_bytes": byte_end - byte_start,
"total_size_bytes": total_size,
"chunk_size_gib": chunk_size_gib,
"is_first_chunk": chunk_index == 0,
"is_last_chunk": chunk_index == chunk_count - 1,
"access_note": "Compressed byte-range index for the BFD source archive; download or stream the original tar.gz for sequence records.",
"split_bucket": stable_bucket(index_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("chunk_index", kind="mergesort")
test = df[df["split_bucket"].eq(0)].sort_values("chunk_index", 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")
source_files = pd.DataFrame.from_records(
[
{
"repo_id": repo_id,
"filename": sibling.rfilename,
"size_bytes": int(getattr(sibling, "size", 0) or 0),
"source_sha": info.sha,
}
for sibling in sorted(info.siblings or [], key=lambda item: item.rfilename)
]
)
source_files.to_parquet(metadata_dir / "source_files.parquet", index=False, compression="zstd")
summary = {
"source": repo_id,
"source_sha": info.sha,
"viewer_table_scope": "compressed archive byte-range index",
"source_file": source_file,
"source_size_bytes": total_size,
"chunk_size_gib": chunk_size_gib,
"chunk_rows": int(len(df)),
"splits": {"train": int(len(train)), "test": int(len(test))},
"split_strategy": "deterministic sha256(index_id) % 10; bucket 0 is test, buckets 1-9 are train",
"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/BFD")
parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_BFD_processed"))
parser.add_argument("--chunk-size-gib", type=int, default=1)
args = parser.parse_args()
summary = build_dataset(args.repo_id, args.out_dir, args.chunk_size_gib)
print(json.dumps(summary, indent=2))
if __name__ == "__main__":
main()
|