Replace nested FireProtDB rows with flat Parquet train/test table

README.md

@@ -13,72 +13,148 @@ tags:
   - stability
   - mutation
   - fireprotdb
-  - jsonl
+  - protein-engineering
+  - train-test-split
+  - parquet
+configs:
+  - config_name: default
+    data_files:
+      - split: train
+        path:
+          - data/train-*.parquet
+      - split: test
+        path:
+          - data/test-*.parquet
 ---
 
 # FireProtDB
 
-FireProtDB protein stability mutation dataset, normalized to newline-delimited JSON with row-level provenance.
+This is a flat, Dataset Viewer-friendly version of LiteFold/FireProtDB. The previous repository layout stored each row as a deeply nested `row` object, which made schema inference fail in the Hugging Face Dataset Viewer. This version keeps one row per upstream FireProtDB sequence or mutant experiment and exposes the main protein, mutation, structure, experiment, measurement, annotation, and publication fields as scalar columns.
 
-Processed and uploaded by the [MegaData](https://github.com/) post-download pipeline
-(internal repo). Original source: <https://loschmidt.chemi.muni.cz/fireprotdb/>.
+Variable upstream lists are summarized into pipe-delimited columns such as `measurement_types`, `annotation_types`, `uniprot_accessions`, `interpro_accessions`, and `pdb_ids`. The original annotation, measurement, and feature lists are also retained as JSON strings in `annotations_json`, `measurements_json`, and `features_json`.
 
-## Statistics
+## Dataset Summary
 
-| | |
-|---|---|
-| Table files | 1 |
-| Total rows | 5,465,660 |
-| Total bytes | 8.48 GiB (9,105,270,725) |
+| Metric | Value |
+|---|---:|
+| Rows | 5,465,660 |
+| Columns | 99 |
+| Source table bytes | 8,466,920,603 |
+| Mutant rows | 5,453,252 |
+| Sequence rows | 12,408 |
+| Substitution events | 5,543,778 |
+| Deletion events | 54,296 |
+| Insertion events | 50,613 |
 
-## Tables
+## Splits
 
-| Table | Rows | Bytes |
-|---|---:|---:|
-| `labeled_fireprotdb_fireprotdb_search_all.jsonl.jsonl` | 5,465,660 | 8.48 GiB |
+Splits are deterministic by source row id:
 
-## Layout
+`sha256("fireprotdb:{row_index}") % 10`
 
+Bucket `0` is `test`; buckets `1` through `9` are `train`.
+
+| Split | Rows |
+|---|---:|
+| `train` | 4,919,161 |
+| `test` | 546,499 |
+
+## Source Datasets
+
+| Experiment dataset | Rows |
+|---|---:|
+| Domainome DDG | 4,071,188 |
+| MegaScale | 775,235 |
+| Domainome FITNESS | 591,671 |
+| ProTherm | 27,406 |
+| COZYME | 160 |
+
+## Common Measurement Columns
+
+The table includes scalar columns for common FireProtDB measurements:
+
+`tm`, `dtm`, `dg`, `dg_text`, `ddg`, `dh`, `dcp`, `dhvh`, `cm`, `m_value`, `trypsin_ml`, `chymotrypsin_ml`, `stabilizing`, `stabilizing_text`, `domainome_fitness`, `domainome_fitness_std`, `domainome_ddg`, `domainome_ddg_std`, `reversibility`, and `state`.
+
+If a row has multiple measurements of the same type, the scalar column stores the first value and `measurements_json` retains the full upstream measurement list.
+
+## Loading With `datasets`
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/FireProtDB")
+train = ds["train"]
+test = ds["test"]
+
+print(train[0]["protein_name"], train[0]["mutations"], train[0]["tm"])
 ```
-.
-├── _MANIFEST.json                 # aggregate manifest (per-table counts)
-└── tables/<source_slug>.jsonl    # normalized rows (one JSON object per line)
+
+Load a split directly:
+
+```python
+from datasets import load_dataset
+
+train = load_dataset("LiteFold/FireProtDB", split="train")
 ```
 
-Each line in a `tables/*.jsonl` file is a JSON object with at least
-`dataset_id`, `row` (the raw upstream row), `row_index`, and `source_file`
-fields, so every row carries its upstream provenance.
+Filter for rows with DDG measurements:
 
-## Loading
+```python
+from datasets import load_dataset
 
-```bash
-hf download LiteFold/FireProtDB --repo-type dataset --local-dir ./fireprotdb
+train = load_dataset("LiteFold/FireProtDB", split="train")
+ddg_rows = train.filter(lambda row: row["ddg"] is not None)
 ```
 
-Programmatic streaming:
+Stream rows without downloading the full table first:
 
 ```python
-import json
-from pathlib import Path
-from huggingface_hub import snapshot_download
-
-local = snapshot_download(repo_id="LiteFold/FireProtDB", repo_type="dataset")
-for jsonl in sorted(Path(local, "tables").glob("*.jsonl")):
-    with jsonl.open() as f:
-        for line in f:
-            row = json.loads(line)
-            ...  # row["row"] is the upstream record
+from datasets import load_dataset
+
+rows = load_dataset("LiteFold/FireProtDB", split="train", streaming=True)
+for row in rows:
+    print(row["row_id"], row["experiment_dataset"], row["measurement_types"])
+    break
 ```
 
+## Column Groups
+
+Provenance:
+`row_id`, `dataset_id`, `source_dataset`, `source_file`, `source_table`, `source_sha`, `row_index`, `split`, `subject_type`.
+
+Protein and sequence:
+`entry_id`, `sequence_id`, `target_sequence_id`, `source_sequence_length`, `target_sequence_length`, `protein_id`, `protein_name`, `organism`, `isoform`, `protein_ids`, `protein_names`, `organisms`, `isoforms`, `uniprot_accessions`, `interpro_accessions`, `ec_numbers`, `megascale_ids`, `other_references`.
+
+Mutation and features:
+`mutations`, `substitutions`, `deletions`, `insertions`, `mutation_count`, `substitution_count`, `deletion_count`, `insertion_count`, `first_position`, `first_source_aa`, `first_target_aa`, `conservation`, `feature_types`, `features_json`.
+
+Structure:
+`pdb_ids`, `afdb_ids`, `structure_ids`, `structure_methods`, `structure_resolution_min`, `residue_positions`, `residue_chain_names`, `residue_secondary_structures`, `residue_in_pocket_any`, `residue_in_tunnel_any`, `residue_asa_mean`, `residue_bfactor_mean`.
+
+Experiment and measurements:
+`experiment_id`, `experiment_dataset`, `ph`, `measure`, `method`, `buffer`, `buffer_conc`, `exp_temperature`, `ion`, `ion_conc`, `pdb_chain_mutation`, measurement columns, `measurement_types`, `measurement_datasets`, `annotation_types`, `annotations_json`, `measurements_json`.
+
+Publication:
+`publication_id`, `publication_type`, `publication_title`, `publication_year`, `publication_doi`, `publication_pmid`, `publication_journal`, `publication_url`, `publication_author_count`, `publication_authors`.
+
+## Files
+
+- `data/train-*.parquet`: train split.
+- `data/test-*.parquet`: test split.
+- `_MANIFEST.json`: source provenance, split counts, and output schema.
+- `dataset_summary.json`: processing summary and source/measurement counts.
+- `scripts/prepare_fireprotdb_dataset.py`: script used to generate the flat table.
+
+## Source
+
+Derived from LiteFold/FireProtDB, originally sourced from FireProtDB.
+
 ## License
 
-CC BY 4.0 (FireProtDB).
+CC BY 4.0.
 
 ## Citation
 
-> Stourac J, et al. FireProtDB: database of manually curated protein stability data. Nucleic Acids Research, 49(D1):D319-D324, 2021.
-
-## Provenance
+If you use this dataset, cite FireProtDB:
 
-Built from the local manifest entry `fireprotdb` of `manifests/atlas_download_plan.json`.
-Pipeline source: `megadata-post normalize --dataset fireprotdb --tables-only`.
+Stourac J, et al. FireProtDB: database of manually curated protein stability data. Nucleic Acids Research, 49(D1):D319-D324, 2021.

_MANIFEST.json

@@ -1,17 +1,131 @@
 {
-  "category": "labeled",
   "dataset_id": "fireprotdb",
-  "format": "jsonl table rows with provenance",
-  "tables": [
-    {
-      "bytes": 8466920603,
-      "category": "labeled",
-      "dataset_id": "fireprotdb",
-      "output_file": "data/processed/labeled/fireprotdb/tables/labeled_fireprotdb_fireprotdb_search_all.jsonl.jsonl",
-      "rows": 5465660,
-      "source_file": "labeled/fireprotdb/fireprotdb_search_all.jsonl",
-      "status": "ok"
-    }
+  "source_repo": "LiteFold/FireProtDB",
+  "source_sha": "79354b4f8754e21c3eb41aaf3dd63ba34ae750cd",
+  "source_table": "tables/labeled_fireprotdb_fireprotdb_search_all.jsonl.jsonl",
+  "format": "flat parquet table rows",
+  "total_rows": 5465660,
+  "split_counts": {
+    "test": 546499,
+    "train": 4919161
+  },
+  "split_strategy": "deterministic sha256('fireprotdb:{row_index}') % 10; bucket 0 is test, buckets 1-9 are train",
+  "columns": [
+    "row_id",
+    "dataset_id",
+    "source_dataset",
+    "source_file",
+    "source_table",
+    "source_sha",
+    "row_index",
+    "split",
+    "subject_type",
+    "entry_id",
+    "sequence_id",
+    "target_sequence_id",
+    "source_sequence_length",
+    "target_sequence_length",
+    "protein_id",
+    "protein_name",
+    "organism",
+    "isoform",
+    "protein_ids",
+    "protein_names",
+    "organisms",
+    "isoforms",
+    "uniprot_accessions",
+    "interpro_accessions",
+    "ec_numbers",
+    "megascale_ids",
+    "other_references",
+    "mutations",
+    "substitutions",
+    "deletions",
+    "insertions",
+    "mutation_count",
+    "substitution_count",
+    "deletion_count",
+    "insertion_count",
+    "first_position",
+    "first_source_aa",
+    "first_target_aa",
+    "conservation",
+    "feature_types",
+    "pdb_ids",
+    "afdb_ids",
+    "structure_ids",
+    "structure_methods",
+    "structure_resolution_min",
+    "residue_positions",
+    "residue_chain_names",
+    "residue_secondary_structures",
+    "residue_in_pocket_any",
+    "residue_in_tunnel_any",
+    "residue_asa_mean",
+    "residue_bfactor_mean",
+    "experiment_id",
+    "experiment_dataset",
+    "ph",
+    "measure",
+    "method",
+    "buffer",
+    "buffer_conc",
+    "exp_temperature",
+    "ion",
+    "ion_conc",
+    "pdb_chain_mutation",
+    "tm",
+    "dtm",
+    "dg",
+    "dg_text",
+    "ddg",
+    "dh",
+    "dcp",
+    "dhvh",
+    "cm",
+    "m_value",
+    "trypsin_ml",
+    "chymotrypsin_ml",
+    "stabilizing",
+    "stabilizing_text",
+    "domainome_fitness",
+    "domainome_fitness_std",
+    "domainome_ddg",
+    "domainome_ddg_std",
+    "reversibility",
+    "state",
+    "measurement_types",
+    "measurement_datasets",
+    "annotation_types",
+    "publication_id",
+    "publication_type",
+    "publication_title",
+    "publication_year",
+    "publication_doi",
+    "publication_pmid",
+    "publication_journal",
+    "publication_url",
+    "publication_author_count",
+    "publication_authors",
+    "annotations_json",
+    "measurements_json",
+    "features_json"
   ],
-  "total_rows": 5465660
-}
+  "source_manifest": {
+    "category": "labeled",
+    "dataset_id": "fireprotdb",
+    "format": "jsonl table rows with provenance",
+    "tables": [
+      {
+        "bytes": 8466920603,
+        "category": "labeled",
+        "dataset_id": "fireprotdb",
+        "output_file": "data/processed/labeled/fireprotdb/tables/labeled_fireprotdb_fireprotdb_search_all.jsonl.jsonl",
+        "rows": 5465660,
+        "source_file": "labeled/fireprotdb/fireprotdb_search_all.jsonl",
+        "status": "ok"
+      }
+    ],
+    "total_rows": 5465660
+  }
+}

tables/labeled_fireprotdb_fireprotdb_search_all.jsonl.jsonl → data/test-00000-of-00001.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:93e3a0cba25344711fd3cd90e48031edf91651fc8e1b009c5f171fce894dfedc
-size 9105270725
+oid sha256:1888126fe69ee587d9cee5a16fe971c151b91aa14e693d172deab33da7ac492c
+size 38378731

data/train-00000-of-00001.parquet

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

dataset_summary.json

@@ -0,0 +1,171 @@
+{
+  "source": "LiteFold/FireProtDB",
+  "source_sha": "79354b4f8754e21c3eb41aaf3dd63ba34ae750cd",
+  "source_table": "tables/labeled_fireprotdb_fireprotdb_search_all.jsonl.jsonl",
+  "source_table_rows": 5465660,
+  "source_table_bytes": 8466920603,
+  "viewer_table_scope": "flat FireProtDB experiment/mutation rows",
+  "data_format": "parquet",
+  "rows": 5465660,
+  "splits": {
+    "test": 546499,
+    "train": 4919161
+  },
+  "subject_type_counts": {
+    "mutant": 5453252,
+    "sequence": 12408
+  },
+  "experiment_dataset_counts": {
+    "Domainome DDG": 4071188,
+    "MegaScale": 775235,
+    "Domainome FITNESS": 591671,
+    "ProTherm": 27406,
+    "COZYME": 160
+  },
+  "measurement_type_counts": {
+    "DOMAINOME_DDG": 4071188,
+    "DOMAINOME_DDG_STD": 4071188,
+    "DG": 780672,
+    "TRYPSIN_ML": 769050,
+    "CHYMOTRYPSIN_ML": 768452,
+    "DDG": 613208,
+    "DOMAINOME_FITNESS": 591671,
+    "DOMAINOME_FITNESS_STD": 591671,
+    "STABILIZING": 580091,
+    "REVERSIBILITY": 26618,
+    "TM": 13640,
+    "CM": 7134,
+    "M": 6910,
+    "DTM": 5995,
+    "STATE": 5362,
+    "DHVH": 4866,
+    "DH": 4632,
+    "DCP": 2923
+  },
+  "annotation_type_counts": {
+    "METHOD": 27552,
+    "PH": 27499,
+    "MEASURE": 27351,
+    "BUFFER": 27139,
+    "BUFFER_CONC": 25232,
+    "_PDB_CHAIN_MUTATION": 17064,
+    "EXP_TEMPERATURE": 13590,
+    "ION": 11599,
+    "ION_CONC": 11528
+  },
+  "feature_type_counts": {
+    "CONSERVATION": 5141973,
+    "BINDING_SITE": 17238,
+    "ACTIVE_SITE": 240
+  },
+  "mutation_event_counts": {
+    "deletions": 54296,
+    "insertions": 50613,
+    "substitutions": 5543778
+  },
+  "columns": [
+    "row_id",
+    "dataset_id",
+    "source_dataset",
+    "source_file",
+    "source_table",
+    "source_sha",
+    "row_index",
+    "split",
+    "subject_type",
+    "entry_id",
+    "sequence_id",
+    "target_sequence_id",
+    "source_sequence_length",
+    "target_sequence_length",
+    "protein_id",
+    "protein_name",
+    "organism",
+    "isoform",
+    "protein_ids",
+    "protein_names",
+    "organisms",
+    "isoforms",
+    "uniprot_accessions",
+    "interpro_accessions",
+    "ec_numbers",
+    "megascale_ids",
+    "other_references",
+    "mutations",
+    "substitutions",
+    "deletions",
+    "insertions",
+    "mutation_count",
+    "substitution_count",
+    "deletion_count",
+    "insertion_count",
+    "first_position",
+    "first_source_aa",
+    "first_target_aa",
+    "conservation",
+    "feature_types",
+    "pdb_ids",
+    "afdb_ids",
+    "structure_ids",
+    "structure_methods",
+    "structure_resolution_min",
+    "residue_positions",
+    "residue_chain_names",
+    "residue_secondary_structures",
+    "residue_in_pocket_any",
+    "residue_in_tunnel_any",
+    "residue_asa_mean",
+    "residue_bfactor_mean",
+    "experiment_id",
+    "experiment_dataset",
+    "ph",
+    "measure",
+    "method",
+    "buffer",
+    "buffer_conc",
+    "exp_temperature",
+    "ion",
+    "ion_conc",
+    "pdb_chain_mutation",
+    "tm",
+    "dtm",
+    "dg",
+    "dg_text",
+    "ddg",
+    "dh",
+    "dcp",
+    "dhvh",
+    "cm",
+    "m_value",
+    "trypsin_ml",
+    "chymotrypsin_ml",
+    "stabilizing",
+    "stabilizing_text",
+    "domainome_fitness",
+    "domainome_fitness_std",
+    "domainome_ddg",
+    "domainome_ddg_std",
+    "reversibility",
+    "state",
+    "measurement_types",
+    "measurement_datasets",
+    "annotation_types",
+    "publication_id",
+    "publication_type",
+    "publication_title",
+    "publication_year",
+    "publication_doi",
+    "publication_pmid",
+    "publication_journal",
+    "publication_url",
+    "publication_author_count",
+    "publication_authors",
+    "annotations_json",
+    "measurements_json",
+    "features_json"
+  ],
+  "files": {
+    "train": "data/train-00000-of-00001.parquet",
+    "test": "data/test-00000-of-00001.parquet"
+  }
+}

scripts/prepare_fireprotdb_dataset.py

@@ -0,0 +1,656 @@
+#!/usr/bin/env python3
+"""Build a flat, viewer-friendly FireProtDB table."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+import shutil
+import sys
+from collections import Counter
+from pathlib import Path
+from typing import Any, Iterable
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+from huggingface_hub import HfApi, HfFileSystem, hf_hub_download
+
+try:
+    import orjson
+except ImportError:  # pragma: no cover - optional speedup
+    orjson = None
+
+
+SOURCE_TABLE = "tables/labeled_fireprotdb_fireprotdb_search_all.jsonl.jsonl"
+COMMON_MEASUREMENTS = {
+    "TM": "tm",
+    "DTM": "dtm",
+    "DG": "dg",
+    "DDG": "ddg",
+    "DH": "dh",
+    "DCP": "dcp",
+    "DHVH": "dhvh",
+    "CM": "cm",
+    "M": "m_value",
+    "TRYPSIN_ML": "trypsin_ml",
+    "CHYMOTRYPSIN_ML": "chymotrypsin_ml",
+    "STABILIZING": "stabilizing",
+    "DOMAINOME_FITNESS": "domainome_fitness",
+    "DOMAINOME_FITNESS_STD": "domainome_fitness_std",
+    "DOMAINOME_DDG": "domainome_ddg",
+    "DOMAINOME_DDG_STD": "domainome_ddg_std",
+}
+
+
+SCHEMA = pa.schema(
+    [
+        pa.field("row_id", pa.string()),
+        pa.field("dataset_id", pa.string()),
+        pa.field("source_dataset", pa.string()),
+        pa.field("source_file", pa.string()),
+        pa.field("source_table", pa.string()),
+        pa.field("source_sha", pa.string()),
+        pa.field("row_index", pa.int64()),
+        pa.field("split", pa.string()),
+        pa.field("subject_type", pa.string()),
+        pa.field("entry_id", pa.int64()),
+        pa.field("sequence_id", pa.int64()),
+        pa.field("target_sequence_id", pa.int64()),
+        pa.field("source_sequence_length", pa.int64()),
+        pa.field("target_sequence_length", pa.int64()),
+        pa.field("protein_id", pa.int64()),
+        pa.field("protein_name", pa.string()),
+        pa.field("organism", pa.string()),
+        pa.field("isoform", pa.int64()),
+        pa.field("protein_ids", pa.string()),
+        pa.field("protein_names", pa.string()),
+        pa.field("organisms", pa.string()),
+        pa.field("isoforms", pa.string()),
+        pa.field("uniprot_accessions", pa.string()),
+        pa.field("interpro_accessions", pa.string()),
+        pa.field("ec_numbers", pa.string()),
+        pa.field("megascale_ids", pa.string()),
+        pa.field("other_references", pa.string()),
+        pa.field("mutations", pa.string()),
+        pa.field("substitutions", pa.string()),
+        pa.field("deletions", pa.string()),
+        pa.field("insertions", pa.string()),
+        pa.field("mutation_count", pa.int64()),
+        pa.field("substitution_count", pa.int64()),
+        pa.field("deletion_count", pa.int64()),
+        pa.field("insertion_count", pa.int64()),
+        pa.field("first_position", pa.int64()),
+        pa.field("first_source_aa", pa.string()),
+        pa.field("first_target_aa", pa.string()),
+        pa.field("conservation", pa.float64()),
+        pa.field("feature_types", pa.string()),
+        pa.field("pdb_ids", pa.string()),
+        pa.field("afdb_ids", pa.string()),
+        pa.field("structure_ids", pa.string()),
+        pa.field("structure_methods", pa.string()),
+        pa.field("structure_resolution_min", pa.float64()),
+        pa.field("residue_positions", pa.string()),
+        pa.field("residue_chain_names", pa.string()),
+        pa.field("residue_secondary_structures", pa.string()),
+        pa.field("residue_in_pocket_any", pa.bool_()),
+        pa.field("residue_in_tunnel_any", pa.bool_()),
+        pa.field("residue_asa_mean", pa.float64()),
+        pa.field("residue_bfactor_mean", pa.float64()),
+        pa.field("experiment_id", pa.int64()),
+        pa.field("experiment_dataset", pa.string()),
+        pa.field("ph", pa.float64()),
+        pa.field("measure", pa.string()),
+        pa.field("method", pa.string()),
+        pa.field("buffer", pa.string()),
+        pa.field("buffer_conc", pa.string()),
+        pa.field("exp_temperature", pa.float64()),
+        pa.field("ion", pa.string()),
+        pa.field("ion_conc", pa.string()),
+        pa.field("pdb_chain_mutation", pa.string()),
+        pa.field("tm", pa.float64()),
+        pa.field("dtm", pa.float64()),
+        pa.field("dg", pa.float64()),
+        pa.field("dg_text", pa.string()),
+        pa.field("ddg", pa.float64()),
+        pa.field("dh", pa.float64()),
+        pa.field("dcp", pa.float64()),
+        pa.field("dhvh", pa.float64()),
+        pa.field("cm", pa.float64()),
+        pa.field("m_value", pa.float64()),
+        pa.field("trypsin_ml", pa.float64()),
+        pa.field("chymotrypsin_ml", pa.float64()),
+        pa.field("stabilizing", pa.float64()),
+        pa.field("stabilizing_text", pa.string()),
+        pa.field("domainome_fitness", pa.float64()),
+        pa.field("domainome_fitness_std", pa.float64()),
+        pa.field("domainome_ddg", pa.float64()),
+        pa.field("domainome_ddg_std", pa.float64()),
+        pa.field("reversibility", pa.string()),
+        pa.field("state", pa.string()),
+        pa.field("measurement_types", pa.string()),
+        pa.field("measurement_datasets", pa.string()),
+        pa.field("annotation_types", pa.string()),
+        pa.field("publication_id", pa.string()),
+        pa.field("publication_type", pa.string()),
+        pa.field("publication_title", pa.string()),
+        pa.field("publication_year", pa.int64()),
+        pa.field("publication_doi", pa.string()),
+        pa.field("publication_pmid", pa.string()),
+        pa.field("publication_journal", pa.string()),
+        pa.field("publication_url", pa.string()),
+        pa.field("publication_author_count", pa.int64()),
+        pa.field("publication_authors", pa.string()),
+        pa.field("annotations_json", pa.string()),
+        pa.field("measurements_json", pa.string()),
+        pa.field("features_json", pa.string()),
+    ]
+)
+
+
+STRING_DEFAULTS = {field.name for field in SCHEMA if pa.types.is_string(field.type)}
+INT_DEFAULTS = {field.name for field in SCHEMA if pa.types.is_int64(field.type)}
+BOOL_DEFAULTS = {field.name for field in SCHEMA if pa.types.is_boolean(field.type)}
+
+
+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 as_int(value: Any) -> int:
+    if value is None or value == "":
+        return -1
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return -1
+
+
+def as_float(value: Any) -> float | None:
+    if value is None or value == "":
+        return None
+    try:
+        numeric = float(value)
+    except (TypeError, ValueError):
+        return None
+    if math.isnan(numeric) or math.isinf(numeric):
+        return None
+    return numeric
+
+
+def as_str(value: Any) -> str:
+    if value is None:
+        return ""
+    return str(value)
+
+
+def compact_json(value: Any) -> str:
+    if not value:
+        return ""
+    if orjson is not None:
+        return orjson.dumps(value, option=orjson.OPT_SORT_KEYS).decode("utf-8")
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+
+
+def load_json_line(line: str) -> dict[str, Any]:
+    if orjson is not None:
+        return orjson.loads(line)
+    return json.loads(line)
+
+
+def join_unique(values: Iterable[Any], sep: str = "|") -> str:
+    seen = set()
+    out = []
+    for value in values:
+        if value is None or value == "":
+            continue
+        text = str(value)
+        if text not in seen:
+            seen.add(text)
+            out.append(text)
+    return sep.join(out)
+
+
+def first_value(values: list[Any]) -> Any:
+    return values[0] if values else None
+
+
+def extract_subject(row: dict[str, Any]) -> tuple[str, dict[str, Any], dict[str, Any], dict[str, Any] | None]:
+    mutant = row.get("mutant")
+    if mutant:
+        return "mutant", mutant, mutant.get("sourceSequence") or {}, mutant.get("targetSequence")
+    sequence = row.get("sequence") or {}
+    return "sequence", sequence, sequence, None
+
+
+def reference_groups(protein_links: list[dict[str, Any]]) -> dict[str, list[str]]:
+    grouped: dict[str, list[str]] = {
+        "UNIPROTKB": [],
+        "INTERPRO": [],
+        "EC_NUMBER": [],
+        "MEGASCALE": [],
+        "OTHER": [],
+    }
+    for link in protein_links:
+        protein = link.get("protein") or {}
+        for ref in protein.get("references") or []:
+            ref_type = as_str(ref.get("type"))
+            accession = as_str(ref.get("accession"))
+            if not accession:
+                continue
+            if ref_type in grouped:
+                grouped[ref_type].append(accession)
+            else:
+                grouped["OTHER"].append(f"{ref_type}:{accession}" if ref_type else accession)
+    return grouped
+
+
+def mutation_strings(subject_type: str, subject: dict[str, Any]) -> dict[str, Any]:
+    if subject_type != "mutant":
+        return {
+            "mutations": "",
+            "substitutions": "",
+            "deletions": "",
+            "insertions": "",
+            "mutation_count": 0,
+            "substitution_count": 0,
+            "deletion_count": 0,
+            "insertion_count": 0,
+            "first_position": -1,
+            "first_source_aa": "",
+            "first_target_aa": "",
+        }
+
+    substitutions = subject.get("substitutions") or []
+    deletions = subject.get("deletions") or []
+    insertions = subject.get("insertions") or []
+
+    sub_strings = [
+        f"{as_str(item.get('sourceAa'))}{as_int(item.get('position'))}{as_str(item.get('targetAa'))}"
+        for item in substitutions
+    ]
+    del_strings = [f"del{as_str(item.get('aminoAcids'))}{as_int(item.get('position'))}" for item in deletions]
+    ins_strings = [f"ins{as_str(item.get('aminoAcids'))}{as_int(item.get('position'))}" for item in insertions]
+    all_mutations = sub_strings + del_strings + ins_strings
+
+    first_position = -1
+    first_source_aa = ""
+    first_target_aa = ""
+    if substitutions:
+        first = substitutions[0]
+        first_position = as_int(first.get("position"))
+        first_source_aa = as_str(first.get("sourceAa"))
+        first_target_aa = as_str(first.get("targetAa"))
+    elif deletions:
+        first = deletions[0]
+        first_position = as_int(first.get("position"))
+        first_source_aa = as_str(first.get("aminoAcids"))
+        first_target_aa = "-"
+    elif insertions:
+        first = insertions[0]
+        first_position = as_int(first.get("position"))
+        first_source_aa = "-"
+        first_target_aa = as_str(first.get("aminoAcids"))
+
+    return {
+        "mutations": join_unique(all_mutations),
+        "substitutions": join_unique(sub_strings),
+        "deletions": join_unique(del_strings),
+        "insertions": join_unique(ins_strings),
+        "mutation_count": len(all_mutations),
+        "substitution_count": len(substitutions),
+        "deletion_count": len(deletions),
+        "insertion_count": len(insertions),
+        "first_position": first_position,
+        "first_source_aa": first_source_aa,
+        "first_target_aa": first_target_aa,
+    }
+
+
+def feature_values(features: list[dict[str, Any]]) -> dict[str, Any]:
+    conservation = None
+    types = []
+    for feature in features:
+        feature_type = as_str(feature.get("type"))
+        types.append(feature_type)
+        if feature_type == "CONSERVATION" and conservation is None:
+            conservation = as_float(feature.get("numValue"))
+    return {
+        "conservation": conservation,
+        "feature_types": join_unique(types),
+        "features_json": compact_json(features),
+    }
+
+
+def structure_values(structures: list[dict[str, Any]]) -> dict[str, Any]:
+    residues = []
+    for structure in structures:
+        residues.extend(structure.get("residues") or [])
+    asa_values = [as_float(residue.get("asa")) for residue in residues]
+    bfactor_values = [as_float(residue.get("bFactor")) for residue in residues]
+    asa_values = [value for value in asa_values if value is not None]
+    bfactor_values = [value for value in bfactor_values if value is not None]
+    resolutions = [as_float(structure.get("resolution")) for structure in structures]
+    resolutions = [value for value in resolutions if value is not None]
+    afdb_ids = []
+    for structure in structures:
+        afdb = structure.get("afdb")
+        if isinstance(afdb, dict):
+            afdb_ids.append(afdb.get("accession") or afdb.get("id"))
+        else:
+            afdb_ids.append(afdb)
+    return {
+        "pdb_ids": join_unique(structure.get("wwpdb") for structure in structures),
+        "afdb_ids": join_unique(afdb_ids),
+        "structure_ids": join_unique(structure.get("id") for structure in structures),
+        "structure_methods": join_unique(structure.get("method") for structure in structures),
+        "structure_resolution_min": min(resolutions) if resolutions else None,
+        "residue_positions": join_unique(residue.get("seqPosition") for residue in residues),
+        "residue_chain_names": join_unique(residue.get("chainName") for residue in residues),
+        "residue_secondary_structures": join_unique(residue.get("secondaryStructure") for residue in residues),
+        "residue_in_pocket_any": any(bool(residue.get("inPocket")) for residue in residues),
+        "residue_in_tunnel_any": any(bool(residue.get("inTunnel")) for residue in residues),
+        "residue_asa_mean": sum(asa_values) / len(asa_values) if asa_values else None,
+        "residue_bfactor_mean": sum(bfactor_values) / len(bfactor_values) if bfactor_values else None,
+    }
+
+
+def annotation_map(annotations: list[dict[str, Any]]) -> dict[str, list[Any]]:
+    values: dict[str, list[Any]] = {}
+    for annotation in annotations:
+        annotation_type = as_str(annotation.get("type"))
+        if not annotation_type:
+            continue
+        value = annotation.get("strValue")
+        if value is None:
+            value = annotation.get("numValue")
+        values.setdefault(annotation_type, []).append(value)
+    return values
+
+
+def measurement_map(measurements: list[dict[str, Any]]) -> tuple[dict[str, list[Any]], list[str]]:
+    values: dict[str, list[Any]] = {}
+    datasets = []
+    for measurement in measurements:
+        measurement_type = as_str(measurement.get("type"))
+        if not measurement_type:
+            continue
+        value = measurement.get("numValue")
+        if value is None:
+            value = measurement.get("strValue")
+        values.setdefault(measurement_type, []).append(value)
+        datasets.extend(measurement.get("datasets") or [])
+    return values, datasets
+
+
+def flatten_record(obj: dict[str, Any], source_sha: str) -> dict[str, Any]:
+    row = obj.get("row") or {}
+    subject_type, subject, source_sequence, target_sequence = extract_subject(row)
+    protein_links = source_sequence.get("proteinLinks") or []
+    first_link = protein_links[0] if protein_links else {}
+    first_protein = first_link.get("protein") or {}
+    refs = reference_groups(protein_links)
+    experiment = subject.get("experiment") or {}
+    publication = experiment.get("publication") or {}
+    annotations = experiment.get("annotations") or []
+    measurements = experiment.get("measurements") or []
+    features = subject.get("features") or []
+    structures = subject.get("structures") or []
+    ann = annotation_map(annotations)
+    meas, measurement_datasets = measurement_map(measurements)
+
+    flat = {
+        "row_id": f"fireprotdb:{as_int(obj.get('row_index'))}",
+        "dataset_id": as_str(obj.get("dataset_id") or "fireprotdb"),
+        "source_dataset": "LiteFold/FireProtDB",
+        "source_file": as_str(obj.get("source_file")),
+        "source_table": SOURCE_TABLE,
+        "source_sha": source_sha,
+        "row_index": as_int(obj.get("row_index")),
+        "split": "test" if stable_bucket(f"fireprotdb:{as_int(obj.get('row_index'))}") == 0 else "train",
+        "subject_type": subject_type,
+        "entry_id": as_int(subject.get("id")),
+        "sequence_id": as_int(source_sequence.get("id")),
+        "target_sequence_id": as_int((target_sequence or {}).get("id")),
+        "source_sequence_length": as_int(source_sequence.get("length")),
+        "target_sequence_length": as_int((target_sequence or {}).get("length")),
+        "protein_id": as_int(first_protein.get("id")),
+        "protein_name": as_str(first_protein.get("name")),
+        "organism": as_str(first_protein.get("organism")),
+        "isoform": as_int(first_link.get("isoform")),
+        "protein_ids": join_unique((link.get("protein") or {}).get("id") for link in protein_links),
+        "protein_names": join_unique((link.get("protein") or {}).get("name") for link in protein_links),
+        "organisms": join_unique((link.get("protein") or {}).get("organism") for link in protein_links),
+        "isoforms": join_unique(link.get("isoform") for link in protein_links),
+        "uniprot_accessions": join_unique(refs["UNIPROTKB"]),
+        "interpro_accessions": join_unique(refs["INTERPRO"]),
+        "ec_numbers": join_unique(refs["EC_NUMBER"]),
+        "megascale_ids": join_unique(refs["MEGASCALE"]),
+        "other_references": join_unique(refs["OTHER"]),
+        "experiment_id": as_int(experiment.get("id")),
+        "experiment_dataset": as_str(experiment.get("dataset")),
+        "ph": as_float(first_value(ann.get("PH", []))),
+        "measure": join_unique(ann.get("MEASURE", [])),
+        "method": join_unique(ann.get("METHOD", [])),
+        "buffer": join_unique(ann.get("BUFFER", [])),
+        "buffer_conc": join_unique(ann.get("BUFFER_CONC", [])),
+        "exp_temperature": as_float(first_value(ann.get("EXP_TEMPERATURE", []))),
+        "ion": join_unique(ann.get("ION", [])),
+        "ion_conc": join_unique(ann.get("ION_CONC", [])),
+        "pdb_chain_mutation": join_unique(ann.get("_PDB_CHAIN_MUTATION", [])),
+        "dg_text": join_unique(value for value in meas.get("DG", []) if as_float(value) is None),
+        "stabilizing_text": join_unique(value for value in meas.get("STABILIZING", []) if as_float(value) is None),
+        "reversibility": join_unique(meas.get("REVERSIBILITY", [])),
+        "state": join_unique(meas.get("STATE", [])),
+        "measurement_types": join_unique(meas.keys()),
+        "measurement_datasets": join_unique(measurement_datasets),
+        "annotation_types": join_unique(ann.keys()),
+        "publication_id": as_str(publication.get("id")),
+        "publication_type": as_str(publication.get("type")),
+        "publication_title": as_str(publication.get("title")),
+        "publication_year": as_int(publication.get("year")),
+        "publication_doi": as_str(publication.get("doi")),
+        "publication_pmid": as_str(publication.get("pmid")),
+        "publication_journal": as_str(publication.get("journal")),
+        "publication_url": as_str(publication.get("url")),
+        "publication_author_count": len(publication.get("authors") or []),
+        "publication_authors": join_unique(author.get("name") for author in publication.get("authors") or []),
+        "annotations_json": compact_json(annotations),
+        "measurements_json": compact_json(measurements),
+    }
+    for measurement_type, column in COMMON_MEASUREMENTS.items():
+        flat[column] = as_float(first_value(meas.get(measurement_type, [])))
+    flat.update(mutation_strings(subject_type, subject))
+    flat.update(feature_values(features))
+    flat.update(structure_values(structures))
+    return normalize_flat(flat)
+
+
+def normalize_flat(flat: dict[str, Any]) -> dict[str, Any]:
+    normalized = {}
+    for field in SCHEMA:
+        value = flat.get(field.name)
+        if value is None:
+            if field.name in STRING_DEFAULTS:
+                value = ""
+            elif field.name in INT_DEFAULTS:
+                value = -1
+            elif field.name in BOOL_DEFAULTS:
+                value = False
+        normalized[field.name] = value
+    return normalized
+
+
+def write_chunk(writer: pq.ParquetWriter | None, path: Path, rows: list[dict[str, Any]]) -> pq.ParquetWriter | None:
+    if not rows:
+        return writer
+    table = pa.Table.from_pylist(rows, schema=SCHEMA)
+    if writer is None:
+        writer = pq.ParquetWriter(path, SCHEMA, compression="zstd", use_dictionary=True)
+    writer.write_table(table)
+    return writer
+
+
+def iter_source(repo_id: str, token: str | None, input_file: Path | None) -> Iterable[str]:
+    if input_file:
+        with input_file.open("r", encoding="utf-8") as handle:
+            yield from handle
+        return
+    fs = HfFileSystem(token=token)
+    with fs.open(f"datasets/{repo_id}/{SOURCE_TABLE}", "rt") as handle:
+        yield from handle
+
+
+def build_dataset(repo_id: str, raw_dir: Path, out_dir: Path, input_file: Path | None, chunk_size: int) -> 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())
+    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_path = data_dir / "train-00000-of-00001.parquet"
+    test_path = data_dir / "test-00000-of-00001.parquet"
+    train_writer = None
+    test_writer = None
+    train_rows: list[dict[str, Any]] = []
+    test_rows: list[dict[str, Any]] = []
+
+    total_rows = 0
+    split_counts: Counter[str] = Counter()
+    subject_counts: Counter[str] = Counter()
+    experiment_dataset_counts: Counter[str] = Counter()
+    measurement_type_counts: Counter[str] = Counter()
+    annotation_type_counts: Counter[str] = Counter()
+    feature_type_counts: Counter[str] = Counter()
+    mutation_event_counts: Counter[str] = Counter()
+
+    try:
+        for line in iter_source(repo_id, token, input_file):
+            obj = load_json_line(line)
+            row = flatten_record(obj, info.sha)
+            total_rows += 1
+            split_counts[row["split"]] += 1
+            subject_counts[row["subject_type"]] += 1
+            if row["experiment_dataset"]:
+                experiment_dataset_counts[row["experiment_dataset"]] += 1
+            for item in row["measurement_types"].split("|"):
+                if item:
+                    measurement_type_counts[item] += 1
+            for item in row["annotation_types"].split("|"):
+                if item:
+                    annotation_type_counts[item] += 1
+            for item in row["feature_types"].split("|"):
+                if item:
+                    feature_type_counts[item] += 1
+            mutation_event_counts["substitutions"] += row["substitution_count"]
+            mutation_event_counts["deletions"] += row["deletion_count"]
+            mutation_event_counts["insertions"] += row["insertion_count"]
+            if row["split"] == "test":
+                test_rows.append(row)
+            else:
+                train_rows.append(row)
+            if len(train_rows) >= chunk_size:
+                train_writer = write_chunk(train_writer, train_path, train_rows)
+                train_rows.clear()
+            if len(test_rows) >= chunk_size:
+                test_writer = write_chunk(test_writer, test_path, test_rows)
+                test_rows.clear()
+            if total_rows % 100000 == 0:
+                print(f"processed {total_rows:,} rows", file=sys.stderr, flush=True)
+        train_writer = write_chunk(train_writer, train_path, train_rows)
+        test_writer = write_chunk(test_writer, test_path, test_rows)
+    finally:
+        if train_writer is not None:
+            train_writer.close()
+        if test_writer is not None:
+            test_writer.close()
+
+    expected_rows = int(manifest.get("total_rows") or 0)
+    if expected_rows and total_rows != expected_rows:
+        raise RuntimeError(f"Expected {expected_rows} rows from manifest, wrote {total_rows}")
+
+    source_table_meta = manifest["tables"][0]
+    new_manifest = {
+        "dataset_id": "fireprotdb",
+        "source_repo": repo_id,
+        "source_sha": info.sha,
+        "source_table": SOURCE_TABLE,
+        "format": "flat parquet table rows",
+        "total_rows": total_rows,
+        "split_counts": dict(sorted(split_counts.items())),
+        "split_strategy": "deterministic sha256('fireprotdb:{row_index}') % 10; bucket 0 is test, buckets 1-9 are train",
+        "columns": [field.name for field in SCHEMA],
+        "source_manifest": manifest,
+    }
+    (out_dir / "_MANIFEST.json").write_text(json.dumps(new_manifest, indent=2) + "\n", encoding="utf-8")
+    summary = {
+        "source": repo_id,
+        "source_sha": info.sha,
+        "source_table": SOURCE_TABLE,
+        "source_table_rows": int(source_table_meta["rows"]),
+        "source_table_bytes": int(source_table_meta["bytes"]),
+        "viewer_table_scope": "flat FireProtDB experiment/mutation rows",
+        "data_format": "parquet",
+        "rows": total_rows,
+        "splits": dict(sorted(split_counts.items())),
+        "subject_type_counts": dict(sorted(subject_counts.items())),
+        "experiment_dataset_counts": dict(experiment_dataset_counts.most_common()),
+        "measurement_type_counts": dict(measurement_type_counts.most_common()),
+        "annotation_type_counts": dict(annotation_type_counts.most_common()),
+        "feature_type_counts": dict(feature_type_counts.most_common()),
+        "mutation_event_counts": dict(sorted(mutation_event_counts.items())),
+        "columns": [field.name for field in SCHEMA],
+        "files": {
+            "train": str(train_path.relative_to(out_dir)),
+            "test": str(test_path.relative_to(out_dir)),
+        },
+    }
+    (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/FireProtDB")
+    parser.add_argument("--raw-dir", type=Path, default=Path("LiteFold_FireProtDB_raw"))
+    parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_FireProtDB_processed"))
+    parser.add_argument("--input-file", type=Path)
+    parser.add_argument("--chunk-size", type=int, default=50000)
+    args = parser.parse_args()
+    summary = build_dataset(args.repo_id, args.raw_dir, args.out_dir, args.input_file, args.chunk_size)
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()