Add normalized Parquet train/test NCBI shard index

README.md

@@ -1,97 +1,151 @@
 ---
+pretty_name: NCBI RefSeq Protein Shard Index
 license: other
-pretty_name: NCBI RefSeq Protein
-size_categories:
-  - 100M<n<1B
-task_categories:
-  - other
-language:
-  - en
 tags:
-  - biology
-  - proteins
-  - sequences
-  - fasta
-  - refseq
-  - ncbi
+- biology
+- proteins
+- sequences
+- fasta
+- ncbi
+- refseq
+- parquet
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*.parquet
+  - split: test
+    path: data/test-*.parquet
 ---
 
-# NCBI RefSeq Protein
+# NCBI RefSeq Protein Shard Index
 
-Normalized FASTA shards of the NCBI Reference Sequence (RefSeq) protein release.
+This dataset contains the original NCBI RefSeq protein FASTA shards plus a viewer-friendly file/shard index. The full sequence data is stored as 1,725 `.fasta.zst` shards and the per-record metadata JSONL files are very large, so the default Dataset Viewer table indexes repository files instead of expanding all 459,415,871 protein records.
 
-Processed and uploaded by the [MegaData](https://github.com/) post-download pipeline
-(internal repo). Original source: <https://www.ncbi.nlm.nih.gov/refseq/>.
+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, record counts, and download patterns.
 
-## Statistics
+## Splits
 
-| | |
-|---|---|
-| Source files | 1,725 |
-| Shards | 1,725 |
-| Compressed shard bytes | 72.74 GiB (78,108,688,857) |
-| Records (per-source manifest sum) | 459,415,871 |
-| Residues (per-source manifest sum) | 179,203,453,293 |
-| Aggregate manifest `total_records` | 459415871 |
+The split is deterministic by file ID: `sha256(file_id) % 10`. Bucket `0` is `test`; buckets `1` through `9` are `train`.
+
+| Split | Rows |
+|---|---:|
+| train | 4,676 |
+| test | 502 |
+| total | 5,178 |
+
+## Source Statistics
+
+| Field | Value |
+|---|---:|
+| Source FASTA files | 1,725 |
+| RefSeq protein records | 459,415,871 |
+| Residues | 179,203,453,293 |
+| Sequence shards | 1,725 |
+| Compressed sequence shard bytes | 78,108,688,857 |
+| Metadata JSONL bytes | 158,533,041,909 |
+
+## Usage
+
+```bash
+pip install datasets
+```
+
+Load the shard index:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/NCBI")
+print(ds)
+print(ds["train"][0])
+```
+
+Load one split:
+
+```python
+from datasets import load_dataset
+
+train = load_dataset("LiteFold/NCBI", split="train")
+test = load_dataset("LiteFold/NCBI", split="test")
+```
+
+List sequence shards:
 
-## Layout
+```python
+from datasets import load_dataset
 
+index = load_dataset("LiteFold/NCBI", split="train")
+shards = index.filter(lambda row: row["is_sequence_shard"])
+print(shards[0]["path"])
 ```
-.
-├── _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
+
+Find a source FASTA and its files:
+
+```python
+from datasets import load_dataset
+
+index = load_dataset("LiteFold/NCBI", split="train")
+rows = index.filter(lambda row: row["source_file"] == "sequence/ncbi_refseq/release_complete/complete.1486.protein.faa.gz")
+for row in rows:
+    print(row["role"], row["path"], row["size_bytes"])
 ```
 
-`<source_slug>` corresponds 1:1 with an upstream source archive; e.g.
-`sequence_uniprotkb_uniprot_sprot.fasta.gz`.
+Download all sequence shards:
 
-## Loading
+```bash
+hf download LiteFold/NCBI --repo-type dataset \
+  --include 'sequences/*/shard-*.fasta.zst' \
+  --local-dir ./ncbi_refseq_protein
+```
 
-Stream every shard of one source (replace `<source_slug>` with the directory of
-interest under `sequences/`):
+Download one source shard:
 
 ```bash
 hf download LiteFold/NCBI --repo-type dataset \
-  --include 'sequences/<source_slug>/shard-*.fasta.zst' \
+  --include 'sequences/sequence_ncbi_refseq_release_complete_complete.1486.protein.faa.gz/shard-*.fasta.zst' \
   --local-dir ./ncbi_refseq_protein
-zstd -dc ./ncbi_refseq_protein/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/NCBI",
-    repo_type="dataset",
-    allow_patterns=["sequences/*/shard-*.fasta.zst"],
-)
-
+shard = next(Path("./ncbi_refseq_protein").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
-
-Public Domain (US Government work, NCBI RefSeq policy).
+## Columns
 
-## Citation
-
-> O'Leary NA, et al. Reference sequence (RefSeq) database at NCBI: current status, taxonomic expansion, and functional annotation. Nucleic Acids Research, 44(D1):D733-45, 2016.
-
-## Provenance
-
-Built from the local manifest entry `ncbi_refseq_protein` of `manifests/atlas_download_plan.json`.
-Pipeline source: `megadata-post normalize --dataset ncbi_refseq_protein`.
+| 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. |
+| `dataset_id` | Source dataset identifier from the manifest. |
+| `source_slug` | Source slug from the original pipeline manifest. |
+| `source_file` | Original source FASTA file path. |
+| `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_in_source` | Protein record count for the source FASTA file. |
+| `residues_in_source` | Residue count for the source FASTA file. |
+| `shards_in_source` | Shard count for the source FASTA file. |
+| `records_total` | Total protein record count from the aggregate manifest. |
+| `residues_total` | Total residue count from the aggregate 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 a 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_ncbi_dataset.py`.

data/test-00000-of-00001.parquet

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

data/train-00000-of-00001.parquet

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

dataset_summary.json

@@ -0,0 +1,51 @@
+{
+  "source": "LiteFold/NCBI",
+  "source_sha": "ca26266937eac32428823d12614ba3c639a36ba0",
+  "viewer_table_scope": "file/shard index",
+  "dataset_id": "ncbi_refseq_protein",
+  "source_count": 1725,
+  "records_total": 459415871,
+  "residues_total": 179203453293,
+  "total_shards": 1725,
+  "index_rows": 5178,
+  "sequence_shard_rows": 1725,
+  "sequence_shard_bytes": 78108688857,
+  "metadata_records_bytes": 158533041909,
+  "splits": {
+    "train": 4676,
+    "test": 502
+  },
+  "split_strategy": "deterministic sha256(file_id) % 10; bucket 0 is test, buckets 1-9 are train",
+  "role_counts": {
+    "git_attributes": 1,
+    "readme": 1,
+    "aggregate_manifest": 1,
+    "source_manifest": 1725,
+    "metadata_records": 1725,
+    "sequence_shard": 1725
+  },
+  "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"
+  ]
+}

metadata/source_files.parquet

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

scripts/prepare_ncbi_dataset.py

@@ -0,0 +1,231 @@
+#!/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()