Add default Parquet file/table index for UniProtKB

README.md

@@ -17,7 +17,16 @@ tags:
   - protein-sequences
   - bioinformatics
   - train-validation-test-split
+  - parquet
 configs:
+  - config_name: default
+    data_files:
+      - split: train
+        path:
+          - data/train-*.parquet
+      - split: test
+        path:
+          - data/test-*.parquet
   - config_name: sprot
     data_files:
       - split: train
@@ -55,41 +64,68 @@ configs:
 
 # UniProtKB Processed
 
-This dataset is a table-friendly, split-aware version of LiteFold/UniProtKB.
-It converts UniProtKB FASTA headers into normalized records that can be browsed
-in the Hugging Face Dataset Viewer and loaded with the `datasets` library.
+This repository contains two useful views of LiteFold/UniProtKB:
 
-The table contains parsed protein metadata and deterministic train/validation/test
-split assignments. To keep the dataset practical for table viewing, full amino
-acid sequences are not duplicated here; each record includes `sequence_sha256`
-for sequence-level identity and deduplication.
+- `default`: a compact Parquet file/table shard index that is easy to browse in the Hugging Face Dataset Viewer.
+- `sprot`, `sprot_varsplic`, and `trembl`: the full parsed UniProtKB protein-entry tables from the original repository.
+
+The `default` config does not duplicate all 203M protein rows. It indexes the repository files, table shards, source sets, source sizes, and split-level row counts so the dataset has a stable table preview while the full source-specific tables remain available through named configs.
 
 ## Dataset Summary
 
-| Source set | Description | Records |
+| Source set | Description | Protein records |
 |---|---|---:|
 | `sprot` | Swiss-Prot reviewed canonical proteins | 574,627 |
 | `sprot_varsplic` | Swiss-Prot alternative isoform sequences | 41,333 |
 | `trembl` | TrEMBL unreviewed proteins | 202,556,314 |
 | **Total** |  | **203,172,274** |
 
-## Splits
+Additional source totals:
+
+| Metric | Value |
+|---|---:|
+| Total residues | 75,747,523,712 |
+| Sequence shards | 205 |
+| Protein-entry table shards | 615 |
+| Default index rows | 830 |
+| Sequence shard bytes | 46,504,287,641 |
+| Metadata records bytes | 74,373,082,266 |
+| Protein-entry table bytes | 18,549,213,567 |
 
-Splits are deterministic and assigned from the exact amino-acid sequence hash.
-Exact duplicate sequences are kept in the same split.
+## Default Index Splits
 
-| Split | Records |
+The default Dataset Viewer index is split deterministically by `sha256(file_id) % 10`: bucket `0` is `test`, and buckets `1` through `9` are `train`.
+
+| Split | Rows |
+|---|---:|
+| `train` | 733 |
+| `test` | 97 |
+
+## Protein-Entry Splits
+
+The full protein-entry tables use deterministic exact-sequence hash splits. Exact duplicate amino-acid sequences are kept in the same split.
+
+| Split | Protein records |
 |---|---:|
 | `train` | 162,548,965 |
 | `validation` | 20,308,533 |
 | `test` | 20,314,776 |
 
-These are exact-sequence splits, not homology-cluster splits. For strict
-homology-aware model evaluation, split again by UniRef/MMseqs cluster ids.
+These are exact-sequence splits, not homology-cluster splits. For strict homology-aware model evaluation, create an additional split using UniRef, MMseqs, or another sequence-clustering method.
+
+## Loading With `datasets`
+
+Load the default file/table index:
 
-## Loading
+```python
+from datasets import load_dataset
+
+index = load_dataset("LiteFold/UniProtKB")
+print(index)
+print(index["train"][0])
+```
 
-Load Swiss-Prot reviewed entries:
+Load Swiss-Prot reviewed protein entries:
 
 ```python
 from datasets import load_dataset
@@ -100,7 +136,7 @@ valid = sprot["validation"]
 test = sprot["test"]
 ```
 
-Load Swiss-Prot alternative isoforms:
+Load Swiss-Prot alternative isoform entries:
 
 ```python
 from datasets import load_dataset
@@ -108,82 +144,72 @@ from datasets import load_dataset
 isoforms = load_dataset("LiteFold/UniProtKB", "sprot_varsplic")
 ```
 
-Load only TrEMBL:
+Stream TrEMBL entries:
 
 ```python
 from datasets import load_dataset
 
-trembl = load_dataset("LiteFold/UniProtKB", "trembl", streaming=True)
-for row in trembl["train"]:
+rows = load_dataset("LiteFold/UniProtKB", "trembl", split="train", streaming=True)
+for row in rows:
     print(row["accession"], row["protein_name"])
     break
 ```
 
-Filter examples:
-
-```python
-from datasets import load_dataset
-
-ds = load_dataset("LiteFold/UniProtKB", "sprot", split="train")
-human = ds.filter(lambda x: x["taxon_id"] == 9606)
-reviewed_kinases = human.filter(lambda x: "kinase" in x["protein_name"].lower())
-```
-
-For large-scale TrEMBL use, prefer streaming:
+Use the default index to discover table shards:
 
 ```python
 from datasets import load_dataset
 
-rows = load_dataset("LiteFold/UniProtKB", "trembl", split="train", streaming=True)
-for row in rows:
-    ...
+index = load_dataset("LiteFold/UniProtKB", split="train")
+trembl_train_shards = index.filter(
+    lambda row: row["role"] == "protein_entry_table_shard"
+    and row["source_set"] == "trembl"
+    and row["table_split"] == "train"
+)
+print(trembl_train_shards[0]["path"])
 ```
 
-Because the source sets are very different in size, this dataset does not define
-a single mixed `default` config. Load one of `sprot`, `sprot_varsplic`, or
-`trembl` explicitly.
-
-## Columns
+## Default Columns
 
 | Column | Type | Description |
 |---|---|---|
-| `record_id` | string | Full UniProt FASTA record id, e.g. `sp|Q6GZX4|001R_FRG3G` |
-| `accession` | string | UniProt accession |
-| `base_accession` | string | Accession without isoform suffix |
-| `entry_name` | string | UniProt entry name |
-| `reviewed` | bool | `true` for Swiss-Prot reviewed entries |
-| `source_set` | string | `sprot`, `sprot_varsplic`, or `trembl` |
-| `is_isoform` | bool | Whether the row is an isoform entry |
-| `isoform_number` | int | Isoform suffix number, or `-1` if not applicable |
-| `protein_name` | string | Parsed protein name from the FASTA header |
-| `organism_name` | string | Parsed organism name |
-| `taxon_id` | int | NCBI taxonomy id |
-| `gene_name` | string | Parsed gene name, or `""` if unavailable |
-| `protein_existence` | int | UniProt PE value, or `-1` if unavailable |
-| `sequence_version` | int | UniProt sequence version, or `-1` if unavailable |
-| `length` | int | Amino-acid sequence length |
-| `sequence_sha256` | string | SHA-256 hash of the amino-acid sequence |
-| `split` | string | `train`, `validation`, or `test` |
-
-## Missing Values
-
-For stable Hugging Face Dataset Viewer schema inference, table files do not use
-JSON `null` values.
-
-- Missing optional integer values are encoded as `-1`.
-- Missing optional string values are encoded as `""`.
-
-## Processing Notes
-
-The public tables intentionally omit internal provenance columns such as raw
-FASTA header, source shard, source file, record index, and split internals.
-The postprocessing manifest is available in `_POSTPROCESS_MANIFEST.json`.
-
-## Source
-
-Derived from LiteFold/UniProtKB, which was built from UniProtKB FASTA releases.
-
-Original source: UniProtKB.
+| `file_id` | string | Stable file identifier, currently the repository path. |
+| `repo_id` | string | Hugging Face dataset repository id. |
+| `source_sha` | string | Source repository commit used to build the index. |
+| `dataset_id` | string | Source dataset id from `_MANIFEST.json`. |
+| `source_set` | string | `sprot`, `sprot_varsplic`, `trembl`, or empty for repository-level files. |
+| `source_slug` | string | Source file slug used in the original manifests. |
+| `source_file` | string | Original source file path. |
+| `path` | string | Path in this Hugging Face repository. |
+| `role` | string | File role such as `protein_entry_table_shard`, `sequence_shard`, or `metadata_records`. |
+| `table_split` | string | Protein-entry split for table shards. |
+| `shard_index` | int64 | Parsed shard index when present. |
+| `size_bytes` | int64 | File size in bytes. |
+| `compression` | string | Compression format when applicable. |
+| `records_in_source` | int64 | Protein records in the source set. |
+| `residues_in_source` | int64 | Residues in the source set. |
+| `shards_in_source` | int64 | Number of sequence shards in the source set. |
+| `records_in_table_split` | int64 | Protein records in that source set and split. |
+| `records_total` | int64 | Total protein records across UniProtKB. |
+| `residues_total` | int64 | Total residues across UniProtKB. |
+| `total_sequence_shards` | int64 | Total sequence shards. |
+| `is_sequence_shard` | bool | Whether the row points to a FASTA sequence shard. |
+| `is_table_shard` | bool | Whether the row points to a parsed protein-entry table shard. |
+| `is_metadata_records` | bool | Whether the row points to metadata records. |
+| `download_pattern` | string | Glob or exact path that can be used for file downloads. |
+| `access_note` | string | Short note describing how to load the row's data. |
+| `split_bucket` | int64 | Deterministic bucket used for the default train/test split. |
+
+## Files
+
+- `data/*.parquet`: default file/table index for Dataset Viewer.
+- `tables/source_set=*/split=*/*.jsonl.gz`: full parsed protein-entry tables.
+- `sequences/*/*.fasta.zst`: compressed source sequence shards.
+- `metadata/*.records.jsonl`: source metadata records.
+- `_MANIFEST.json`: source sequence manifest.
+- `_POSTPROCESS_MANIFEST.json`: table-generation manifest.
+- `dataset_summary.json`: summary of the default index build.
+- `scripts/prepare_uniprotkb_dataset.py`: script used to generate the default index.
 
 ## License
 
@@ -191,7 +217,6 @@ CC BY 4.0.
 
 ## Citation
 
-If you use this dataset, cite UniProt:
+If you use the UniProtKB records, cite UniProt:
 
-The UniProt Consortium. UniProt: the Universal Protein Knowledgebase in 2023.
-Nucleic Acids Research, 51(D1):D523-D531, 2023.
+The UniProt Consortium. UniProt: the Universal Protein Knowledgebase in 2023. Nucleic Acids Research, 51(D1):D523-D531, 2023.

data/test-00000-of-00001.parquet

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

data/train-00000-of-00001.parquet

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

dataset_summary.json

@@ -0,0 +1,70 @@
+{
+  "source": "LiteFold/UniProtKB",
+  "source_sha": "d8eb6d76820f33ce4e3d6bcee582f6b474f3bbd9",
+  "viewer_table_scope": "file/table shard index",
+  "dataset_id": "uniprotkb",
+  "source_count": 3,
+  "records_total": 203172274,
+  "residues_total": 75747523712,
+  "total_sequence_shards": 205,
+  "protein_entry_table_shards": 615,
+  "index_rows": 830,
+  "sequence_shard_rows": 205,
+  "sequence_shard_bytes": 46504287641,
+  "metadata_records_bytes": 74373082266,
+  "protein_entry_table_bytes": 18549213567,
+  "protein_entry_split_counts": {
+    "test": 20314776,
+    "train": 162548965,
+    "validation": 20308533
+  },
+  "splits": {
+    "train": 733,
+    "test": 97
+  },
+  "split_strategy": "default index uses deterministic sha256(file_id) % 10; bucket 0 is test, buckets 1-9 are train",
+  "protein_entry_split_strategy": "uniprotkb_exact_sequence_hash_v1",
+  "role_counts": {
+    "git_attributes": 1,
+    "readme": 1,
+    "aggregate_manifest": 1,
+    "postprocess_manifest": 1,
+    "source_manifest": 3,
+    "metadata_records": 3,
+    "sequence_shard": 205,
+    "protein_entry_table_shard": 615
+  },
+  "source_set_index_counts": {
+    "sprot": 6,
+    "sprot_varsplic": 6,
+    "trembl": 814
+  },
+  "columns": [
+    "file_id",
+    "repo_id",
+    "source_sha",
+    "dataset_id",
+    "source_set",
+    "source_slug",
+    "source_file",
+    "path",
+    "role",
+    "table_split",
+    "shard_index",
+    "size_bytes",
+    "compression",
+    "records_in_source",
+    "residues_in_source",
+    "shards_in_source",
+    "records_in_table_split",
+    "records_total",
+    "residues_total",
+    "total_sequence_shards",
+    "is_sequence_shard",
+    "is_table_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:d69339351bc5098075c828e72cb58eb90206744e2106e7f11bbcb6eed4eff7e8
+size 20213

scripts/prepare_uniprotkb_dataset.py

@@ -0,0 +1,330 @@
+#!/usr/bin/env python3
+"""Build a viewer-friendly default file/table index for LiteFold/UniProtKB."""
+
+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_set",
+    "source_slug",
+    "source_file",
+    "path",
+    "role",
+    "table_split",
+    "shard_index",
+    "size_bytes",
+    "compression",
+    "records_in_source",
+    "residues_in_source",
+    "shards_in_source",
+    "records_in_table_split",
+    "records_total",
+    "residues_total",
+    "total_sequence_shards",
+    "is_sequence_shard",
+    "is_table_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_set", 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("table_split", 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_in_table_split", pa.int64()),
+        pa.field("records_total", pa.int64()),
+        pa.field("residues_total", pa.int64()),
+        pa.field("total_sequence_shards", pa.int64()),
+        pa.field("is_sequence_shard", pa.bool_()),
+        pa.field("is_table_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()),
+    ]
+)
+
+
+SOURCE_SET_BY_SLUG = {
+    "sequence_uniprotkb_uniprot_sprot.fasta.gz": "sprot",
+    "sequence_uniprotkb_uniprot_sprot_varsplic.fasta.gz": "sprot_varsplic",
+    "sequence_uniprotkb_uniprot_trembl.fasta.gz": "trembl",
+}
+
+
+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 parse_path(path: str) -> dict[str, Any]:
+    table_match = re.search(r"tables/source_set=([^/]+)/split=([^/]+)/protein_entries_shard-(\d+)\.jsonl\.gz$", path)
+    if table_match:
+        return {
+            "role": "protein_entry_table_shard",
+            "source_set": table_match.group(1),
+            "table_split": table_match.group(2),
+            "source_slug": None,
+            "shard_index": int(table_match.group(3)),
+            "is_sequence_shard": False,
+            "is_table_shard": True,
+            "is_metadata_records": False,
+        }
+    sequence_match = re.search(r"sequences/([^/]+)/shard-(\d+)\.fasta\.zst$", path)
+    if sequence_match:
+        source_slug = sequence_match.group(1)
+        return {
+            "role": "sequence_shard",
+            "source_set": SOURCE_SET_BY_SLUG.get(source_slug),
+            "table_split": None,
+            "source_slug": source_slug,
+            "shard_index": int(sequence_match.group(2)),
+            "is_sequence_shard": True,
+            "is_table_shard": False,
+            "is_metadata_records": False,
+        }
+    metadata_match = re.search(r"metadata/(.+)\.records\.jsonl$", path)
+    if metadata_match:
+        source_slug = metadata_match.group(1)
+        return {
+            "role": "metadata_records",
+            "source_set": SOURCE_SET_BY_SLUG.get(source_slug),
+            "table_split": None,
+            "source_slug": source_slug,
+            "shard_index": None,
+            "is_sequence_shard": False,
+            "is_table_shard": False,
+            "is_metadata_records": True,
+        }
+    manifest_match = re.search(r"manifests/(.+)\.json$", path)
+    if manifest_match:
+        source_slug = manifest_match.group(1)
+        return {
+            "role": "source_manifest",
+            "source_set": SOURCE_SET_BY_SLUG.get(source_slug),
+            "table_split": None,
+            "source_slug": source_slug,
+            "shard_index": None,
+            "is_sequence_shard": False,
+            "is_table_shard": False,
+            "is_metadata_records": False,
+        }
+    role = {
+        "_MANIFEST.json": "aggregate_manifest",
+        "_POSTPROCESS_MANIFEST.json": "postprocess_manifest",
+        "README.md": "readme",
+        ".gitattributes": "git_attributes",
+    }.get(path, "other")
+    return {
+        "role": role,
+        "source_set": None,
+        "table_split": None,
+        "source_slug": None,
+        "shard_index": None,
+        "is_sequence_shard": False,
+        "is_table_shard": False,
+        "is_metadata_records": False,
+    }
+
+
+def compression_for_path(path: str) -> str | None:
+    if path.endswith(".fasta.zst"):
+        return "zstd"
+    if path.endswith(".jsonl.gz"):
+        return "gzip"
+    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)
+    )
+    postprocess_path = Path(
+        hf_hub_download(
+            repo_id=repo_id,
+            repo_type="dataset",
+            filename="_POSTPROCESS_MANIFEST.json",
+            local_dir=raw_dir,
+            token=token,
+        )
+    )
+    manifest = json.loads(manifest_path.read_text())
+    postprocess = json.loads(postprocess_path.read_text())
+
+    dataset_id = str(manifest["dataset_id"])
+    total_records = int(manifest["total_records"])
+    total_residues = int(manifest["total_residues"])
+    total_sequence_shards = int(manifest["total_shards"])
+    sources_by_slug = {source["source_slug"]: source for source in manifest["sources"]}
+    post_by_source_set = {source["source_set"]: source for source in postprocess["sources"]}
+
+    rows = []
+    for sibling in sorted(info.siblings or [], key=lambda item: item.rfilename):
+        path = sibling.rfilename
+        if path.startswith("data/") or path.startswith("dataset_summary") or path.startswith("scripts/"):
+            continue
+        parsed = parse_path(path)
+        source_slug = parsed["source_slug"]
+        source_set = parsed["source_set"]
+        if source_slug is None and source_set:
+            post_source = post_by_source_set.get(source_set)
+            if post_source:
+                source_slug = post_source["source_slug"]
+        source = sources_by_slug.get(source_slug or "")
+        post_source = post_by_source_set.get(source_set or "")
+        table_split = parsed["table_split"]
+        file_id = path
+        rows.append(
+            {
+                "file_id": file_id,
+                "repo_id": repo_id,
+                "source_sha": info.sha,
+                "dataset_id": dataset_id,
+                "source_set": source_set,
+                "source_slug": source_slug,
+                "source_file": source.get("source_file") if source else (post_source.get("source_file") if post_source else None),
+                "path": path,
+                "role": parsed["role"],
+                "table_split": table_split,
+                "shard_index": parsed["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 (int(post_source["records_written"]) if post_source else None),
+                "residues_in_source": int(source["residues"]) if source else None,
+                "shards_in_source": int(source["shards"]) if source else None,
+                "records_in_table_split": int(post_source["split_counts"][table_split])
+                if post_source and table_split
+                else None,
+                "records_total": total_records,
+                "residues_total": total_residues,
+                "total_sequence_shards": total_sequence_shards,
+                "is_sequence_shard": parsed["is_sequence_shard"],
+                "is_table_shard": parsed["is_table_shard"],
+                "is_metadata_records": parsed["is_metadata_records"],
+                "download_pattern": f"tables/source_set={source_set}/split={table_split}/*.jsonl.gz"
+                if parsed["is_table_shard"]
+                else (f"sequences/{source_slug}/shard-*.fasta.zst" if parsed["is_sequence_shard"] else path),
+                "access_note": "Default index over UniProtKB files. Load configs sprot, sprot_varsplic, or trembl for protein-entry rows.",
+                "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")
+
+    role_counts: dict[str, int] = {}
+    source_set_counts: dict[str, int] = {}
+    for row in rows:
+        role_counts[row["role"]] = role_counts.get(row["role"], 0) + 1
+        if row["source_set"]:
+            source_set_counts[row["source_set"]] = source_set_counts.get(row["source_set"], 0) + 1
+
+    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"])
+    table_bytes = sum(int(row["size_bytes"]) for row in rows if row["is_table_shard"])
+    summary = {
+        "source": repo_id,
+        "source_sha": info.sha,
+        "viewer_table_scope": "file/table shard index",
+        "dataset_id": dataset_id,
+        "source_count": int(manifest["source_count"]),
+        "records_total": total_records,
+        "residues_total": total_residues,
+        "total_sequence_shards": total_sequence_shards,
+        "protein_entry_table_shards": sum(1 for row in rows if row["is_table_shard"]),
+        "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,
+        "protein_entry_table_bytes": table_bytes,
+        "protein_entry_split_counts": postprocess["split_counts"],
+        "splits": {"train": len(train_rows), "test": len(test_rows)},
+        "split_strategy": "default index uses deterministic sha256(file_id) % 10; bucket 0 is test, buckets 1-9 are train",
+        "protein_entry_split_strategy": postprocess["split_version"],
+        "role_counts": role_counts,
+        "source_set_index_counts": source_set_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/UniProtKB")
+    parser.add_argument("--raw-dir", type=Path, default=Path("LiteFold_UniProtKB_raw"))
+    parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_UniProtKB_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()