Add normalized Parquet train/test UniRef50 shard index

README.md

@@ -1,97 +1,126 @@
 ---
+pretty_name: UniRef50 Shard Index
 license: cc-by-4.0
-pretty_name: UniRef50
-size_categories:
-  - 10M<n<100M
-task_categories:
-  - other
-language:
-  - en
 tags:
-  - biology
-  - proteins
-  - sequences
-  - fasta
-  - uniref
-  - clustering
+- biology
+- proteins
+- sequences
+- fasta
+- uniref
+- clustering
+- parquet
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*.parquet
+  - split: test
+    path: data/test-*.parquet
 ---
 
-# UniRef50
+# UniRef50 Shard Index
 
-Normalized FASTA shards of UniRef50 cluster representative sequences (50% sequence identity threshold).
+This dataset contains the original UniRef50 FASTA shards plus a viewer-friendly file/shard index. The full sequence data is stored as 61 `.fasta.zst` shards and the per-record metadata JSONL is very large, so the default Dataset Viewer table indexes repository files instead of expanding all 60,315,044 sequence records.
 
-Processed and uploaded by the [MegaData](https://github.com/) post-download pipeline
-(internal repo). Original source: <https://www.uniprot.org/help/uniref>.
+Use the original `sequences/.../shard-*.fasta.zst` files for complete FASTA records. Use the default Parquet table for Dataset Viewer previews, source discovery, file sizes, and download patterns.
 
-## Statistics
+## Splits
 
-| | |
-|---|---|
-| Source files | 1 |
-| Shards | 61 |
-| Compressed shard bytes | 10.74 GiB (11,527,890,402) |
-| Records (per-source manifest sum) | 60,315,044 |
-| Residues (per-source manifest sum) | 17,282,055,793 |
-| Aggregate manifest `total_records` | 60315044 |
+The split is deterministic by file ID: `sha256(file_id) % 10`. Bucket `0` is `test`; buckets `1` through `9` are `train`.
+
+| Split | Rows |
+|---|---:|
+| train | 60 |
+| test | 6 |
+| total | 66 |
+
+## Source Statistics
 
-## Layout
+| Field | Value |
+|---|---:|
+| UniRef50 records | 60,315,044 |
+| Residues | 17,282,055,793 |
+| Sequence shards | 61 |
+| Compressed sequence shard bytes | 11,527,890,402 |
+| Metadata JSONL bytes | 20,952,410,229 |
 
+## Usage
+
+```bash
+pip install datasets
 ```
-.
-├── _MANIFEST.json                      # aggregate manifest written by the pipeline
-├── manifests/<source_slug>.json        # per-source manifest (records, residues, shards)
-├── metadata/<source_slug>.records.jsonl  # per-record provenance
-└── sequences/<source_slug>/shard-NNNNNN.fasta.zst
+
+Load the shard index:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/UniRef50")
+print(ds)
+print(ds["train"][0])
 ```
 
-`<source_slug>` corresponds 1:1 with an upstream source archive; e.g.
-`sequence_uniprotkb_uniprot_sprot.fasta.gz`.
+Load one split:
 
-## Loading
+```python
+from datasets import load_dataset
+
+train = load_dataset("LiteFold/UniRef50", split="train")
+test = load_dataset("LiteFold/UniRef50", split="test")
+```
 
-Stream every shard of one source (replace `<source_slug>` with the directory of
-interest under `sequences/`):
+List sequence shards:
+
+```python
+from datasets import load_dataset
+
+index = load_dataset("LiteFold/UniRef50", split="train")
+shards = index.filter(lambda row: row["is_sequence_shard"])
+print(shards[0]["path"])
+```
+
+Download sequence shards:
 
 ```bash
 hf download LiteFold/UniRef50 --repo-type dataset \
-  --include 'sequences/<source_slug>/shard-*.fasta.zst' \
+  --include 'sequences/sequence_uniref50_uniref50.fasta.gz/shard-*.fasta.zst' \
   --local-dir ./uniref50
-zstd -dc ./uniref50/sequences/<source_slug>/shard-*.fasta.zst | head
 ```
 
-Programmatic streaming with [`zstandard`](https://pypi.org/project/zstandard/):
+Stream a downloaded shard with Python:
 
 ```python
-from huggingface_hub import snapshot_download
 from pathlib import Path
 import zstandard as zstd
 
-local = snapshot_download(
-    repo_id="LiteFold/UniRef50",
-    repo_type="dataset",
-    allow_patterns=["sequences/*/shard-*.fasta.zst"],
-)
-
+shard = next(Path("./uniref50").rglob("shard-*.fasta.zst"))
 dctx = zstd.ZstdDecompressor()
-for shard in sorted(Path(local).rglob("shard-*.fasta.zst")):
-    with shard.open("rb") as f, dctx.stream_reader(f) as reader:
-        buf = b""
-        while chunk := reader.read(1 << 20):
-            buf += chunk
-            *lines, buf = buf.split(b"\n")
-            for line in lines:
-                ...  # naive splitter; swap in your FASTA parser
+with shard.open("rb") as f, dctx.stream_reader(f) as reader:
+    print(reader.read(1024).decode("utf-8", errors="replace"))
 ```
 
-## License
+## Columns
 
-CC BY 4.0 (UniProt Consortium).
-
-## Citation
-
-> Suzek BE, Wang Y, Huang H, McGarvey PB, Wu CH; UniProt Consortium. UniRef clusters: a comprehensive and scalable alternative for improving sequence similarity searches. Bioinformatics, 31(6):926-32, 2015.
-
-## Provenance
-
-Built from the local manifest entry `uniref50` of `manifests/atlas_download_plan.json`.
-Pipeline source: `megadata-post normalize --dataset uniref50`.
+| Column | Description |
+|---|---|
+| `file_id` | Stable row ID, equal to the repository path. |
+| `repo_id` | Hugging Face dataset repository. |
+| `source_sha` | Source repository commit used to build the index. |
+| `source_slug` | Source slug from the original pipeline manifest. |
+| `path` | File path in the repository. |
+| `role` | File role, such as `sequence_shard`, `metadata_records`, or `source_manifest`. |
+| `shard_index` | Numeric shard index for sequence shards. |
+| `size_bytes` | File size in bytes. |
+| `compression` | Compression format, when applicable. |
+| `records_total` | Total UniRef50 records from the manifest. |
+| `residues_total` | Total residue count from the manifest. |
+| `total_shards` | Total sequence shard count. |
+| `is_sequence_shard` | Whether the row points to a FASTA shard. |
+| `is_metadata_records` | Whether the row points to the per-record metadata JSONL. |
+| `download_pattern` | Recommended path or glob for downloading. |
+| `access_note` | Note describing the index scope. |
+| `split_bucket` | Deterministic split bucket from `sha256(file_id) % 10`. |
+
+## Preparation
+
+The normalization script used to create the Parquet files is included at `scripts/prepare_uniref50_dataset.py`.

data/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1808c2d557216240386f8ed9a2ca0ae387d91d6efd2a6835fdab7b6d75565d3
+size 12024

data/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5da513a8582a409da3851d079324345aebc337ebd351673e691cc32659c1b460
+size 12890

dataset_summary.json

@@ -0,0 +1,45 @@
+{
+  "source": "LiteFold/UniRef50",
+  "source_sha": "45f6d1f6eb68c847f89b719d7f1da3e7fa9e6611",
+  "viewer_table_scope": "file/shard index",
+  "source_slug": "sequence_uniref50_uniref50.fasta.gz",
+  "records_total": 60315044,
+  "residues_total": 17282055793,
+  "total_shards": 61,
+  "index_rows": 66,
+  "sequence_shard_rows": 61,
+  "sequence_shard_bytes": 11527890402,
+  "metadata_records_bytes": 20952410229,
+  "splits": {
+    "train": 60,
+    "test": 6
+  },
+  "split_strategy": "deterministic sha256(file_id) % 10; bucket 0 is test, buckets 1-9 are train",
+  "role_counts": {
+    "sequence_shard": 61,
+    "git_attributes": 1,
+    "readme": 1,
+    "aggregate_manifest": 1,
+    "source_manifest": 1,
+    "metadata_records": 1
+  },
+  "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"
+  ]
+}

metadata/source_files.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5b52a47516fb4ecfb44e002f618a132219e9c2b9d26fb14e78cf21044e32321a
+size 13100

scripts/prepare_uniref50_dataset.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""Build viewer-friendly file/shard index Parquet splits for LiteFold/UniRef50."""
+
+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"
+    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)
+        file_id = path
+        rows.append(
+            {
+                "file_id": file_id,
+                "repo_id": repo_id,
+                "source_sha": info.sha,
+                "source_slug": inferred_slug or source_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 UniRef50; 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/UniRef50")
+    parser.add_argument("--raw-dir", type=Path, default=Path("LiteFold_UniRef50_raw"))
+    parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_UniRef50_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()