Add normalized Parquet train/test CycPepMPDB table

README.md

@@ -1,133 +1,92 @@
 ---
+pretty_name: CycPepMPDB Peptides And Monomers
 license: other
-pretty_name: CycPepMPDB
-size_categories:
-  - 10K<n<100K
-task_categories:
-  - other
-language:
-  - en
 tags:
-  - chemistry
-  - peptides
-  - cyclic-peptides
-  - membrane-permeability
-  - jsonl
+- chemistry
+- peptide
+- cyclic-peptide
+- permeability
+- cycpeptmpdb
+- parquet
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*.parquet
+  - split: test
+    path: data/test-*.parquet
 ---
 
-# CycPepMPDB
-
-CycPepMPDB cyclic peptide membrane-permeability dataset (monomers and analogs), normalized to newline-delimited JSON with row-level provenance.
-
-Processed and uploaded by the [MegaData](https://github.com/) post-download pipeline
-(internal repo). Original source: <http://cycpeptmpdb.com/>.
-
-## Statistics
-
-| | |
-|---|---|
-| Table files | 99 |
-| Total rows | 43,514 |
-| Total bytes | 259.87 MiB (272,498,665) |
-
-## Tables
-
-| Table | Rows | Bytes |
-|---|---:|---:|
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_All.csv.jsonl` | 385 | 2.23 MiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_A.csv.jsonl` | 34 | 216.30 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_C.csv.jsonl` | 4 | 22.01 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_D.csv.jsonl` | 6 | 39.63 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_E.csv.jsonl` | 5 | 25.48 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_F.csv.jsonl` | 63 | 364.35 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_G.csv.jsonl` | 47 | 265.58 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_H.csv.jsonl` | 3 | 15.38 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_I.csv.jsonl` | 8 | 46.23 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_K.csv.jsonl` | 13 | 66.15 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_L.csv.jsonl` | 19 | 191.37 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_M.csv.jsonl` | 3 | 15.24 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_N.csv.jsonl` | 7 | 35.72 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_P.csv.jsonl` | 12 | 110.07 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_Q.csv.jsonl` | 10 | 51.57 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_R.csv.jsonl` | 4 | 20.67 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_S.csv.jsonl` | 29 | 151.32 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_T.csv.jsonl` | 6 | 48.74 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_V.csv.jsonl` | 15 | 84.60 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_W.csv.jsonl` | 8 | 41.30 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_X.csv.jsonl` | 78 | 417.57 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Monomer_Analog_Y.csv.jsonl` | 11 | 58.28 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_All.csv.jsonl` | 8,466 | 50.54 MiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Assay_Caco2.csv.jsonl` | 1,332 | 8.23 MiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Assay_MDCK.csv.jsonl` | 64 | 396.71 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Assay_PAMPA.csv.jsonl` | 7,298 | 43.31 MiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Assay_RRCK.csv.jsonl` | 186 | 1.09 MiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Length_10.csv.jsonl` | 1,777 | 10.82 MiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Length_11.csv.jsonl` | 675 | 4.23 MiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Length_12.csv.jsonl` | 632 | 3.98 MiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Length_13.csv.jsonl` | 234 | 1.49 MiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Length_14.csv.jsonl` | 125 | 825.96 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Length_15.csv.jsonl` | 26 | 174.11 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Length_2.csv.jsonl` | 4 | 22.71 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Length_3.csv.jsonl` | 69 | 387.80 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Length_4.csv.jsonl` | 55 | 313.75 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Length_5.csv.jsonl` | 88 | 512.88 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Length_6.csv.jsonl` | 2,167 | 12.50 MiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Length_7.csv.jsonl` | 2,071 | 12.09 MiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Length_8.csv.jsonl` | 120 | 730.00 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Length_9.csv.jsonl` | 423 | 2.57 MiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Shape_Circle.csv.jsonl` | 5,530 | 32.46 MiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Shape_Lariat.csv.jsonl` | 2,936 | 18.15 MiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Source_2006_Rezai_1.csv.jsonl` | 10 | 60.53 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Source_2006_Rezai_2.csv.jsonl` | 11 | 65.58 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Source_2011_White.csv.jsonl` | 10 | 60.81 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Source_2012_Rand.csv.jsonl` | 16 | 95.80 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Source_2013_CHUGAI.csv.jsonl` | 878 | 5.51 MiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Source_2013_Zaretsky.csv.jsonl` | 2 | 11.60 KiB |
-| `peptide_cycpeptmpdb_CycPeptMPDB_Peptide_Source_2014_Nielsen.csv.jsonl` | 4 | 23.96 KiB |
-| _… 49 more table file(s) …_ | | |
-
-## Layout
+# LiteFold/CycPepMPDB
 
-```
-.
-├── _MANIFEST.json                 # aggregate manifest (per-table counts)
-└── tables/<source_slug>.jsonl    # normalized rows (one JSON object per line)
-```
+This repository now includes a Dataset Viewer-friendly Parquet version of the LiteFold CycPepMPDB tables. The default `load_dataset()` configuration reads the normalized Parquet files in `data/`.
+
+The normalized default table contains 8,851 rows from the `CycPeptMPDB_Peptide_All.csv` and `CycPeptMPDB_Monomer_All.csv` source tables. These all-record tables are used as the default view to avoid duplicating rows from overlapping subset tables. The original wrapped JSONL source tables remain available in the repository under `tables/`.
+
+## Splits
+
+- `train`: 7,983 rows
+- `test`: 868 rows
+
+Rows are assigned with a deterministic hash split: `sha256(record_id) % 10`, where bucket `0` is test and buckets `1-9` are train.
+
+## Columns
+
+The table includes common browsing and modeling columns:
+
+- `record_id`: stable SHA-256 row identifier
+- `dataset_id`, `source_file`, `source_table`, `source_row_index`: source provenance
+- `entity_type`: `peptide` or `monomer`
+- `assay_name`, `sequence`, `sequence_length`, `target`, `score_value`, `label`: normalized convenience fields when present
+- `split_bucket`: deterministic split bucket
 
-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.
+Original descriptor and assay fields are preserved as snake_case string columns, including fields such as `smiles`, `permeability`, `caco2`, `pampa`, `mdck`, `rrck`, and molecular descriptor columns. See `metadata/column_mapping.parquet` for the original field-name mapping and `metadata/source_tables.parquet` for per-table row counts.
 
-## Loading
+## Usage
 
-```bash
-hf download LiteFold/CycPepMPDB --repo-type dataset --local-dir ./cycpeptmpdb
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/CycPepMPDB")
+print(ds)
+print(ds["train"][0])
 ```
 
-Programmatic streaming:
+Load selected columns:
 
 ```python
-import json
-from pathlib import Path
-from huggingface_hub import snapshot_download
-
-local = snapshot_download(repo_id="LiteFold/CycPepMPDB", 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
+
+cols = ["record_id", "entity_type", "sequence", "smiles", "permeability", "score_value"]
+train = load_dataset("LiteFold/CycPepMPDB", split="train", columns=cols)
 ```
 
-## License
+Filter to peptides:
+
+```python
+from datasets import load_dataset
 
-See upstream license at CycPepMPDB.
+train = load_dataset("LiteFold/CycPepMPDB", split="train")
+peptides = train.filter(lambda row: row["entity_type"] == "peptide")
+```
 
-## Citation
+Metadata tables can be loaded directly:
 
-> Li J, et al. CycPeptMPDB: A Comprehensive Database of Membrane Permeability of Cyclic Peptides. J. Chem. Inf. Model., 2023.
+```python
+from datasets import load_dataset
+
+source_tables = load_dataset(
+    "parquet",
+    data_files="hf://datasets/LiteFold/CycPepMPDB/metadata/source_tables.parquet",
+    split="train",
+)
+column_mapping = load_dataset(
+    "parquet",
+    data_files="hf://datasets/LiteFold/CycPepMPDB/metadata/column_mapping.parquet",
+    split="train",
+)
+```
 
-## Provenance
+## Rebuild
 
-Built from the local manifest entry `cycpeptmpdb` of `manifests/atlas_download_plan.json`.
-Pipeline source: `megadata-post normalize --dataset cycpeptmpdb --tables-only`.
+The normalization script used for this upload is included at `scripts/prepare_wrapped_jsonl_dataset.py`.

data/test-00000-of-00001.parquet

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

data/train-00000-of-00001.parquet

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

dataset_summary.json

@@ -0,0 +1,303 @@
+{
+  "source": "LiteFold/CycPepMPDB",
+  "mode": "cycpeptmpdb",
+  "source_table_rows": 2,
+  "entry_rows": 8851,
+  "raw_field_count": 265,
+  "splits": {
+    "train": 7983,
+    "test": 868
+  },
+  "split_strategy": "deterministic sha256(record_id) % 10; bucket 0 is test, buckets 1-9 are train",
+  "table_group_counts": {
+    "cycpeptmpdb": 2
+  },
+  "columns": [
+    "record_id",
+    "dataset_id",
+    "source_file",
+    "source_table",
+    "source_row_index",
+    "table_group",
+    "task_name",
+    "subtask_name",
+    "entity_type",
+    "assay_name",
+    "sequence",
+    "sequence_length",
+    "mutation",
+    "target",
+    "score_value",
+    "label",
+    "split_bucket",
+    "bcut2d_chghi",
+    "bcut2d_chglo",
+    "bcut2d_logphi",
+    "bcut2d_logplow",
+    "bcut2d_mrhi",
+    "bcut2d_mrlow",
+    "bcut2d_mwhi",
+    "bcut2d_mwlow",
+    "balabanj",
+    "bertzct",
+    "chcl3_3dpsa",
+    "cxsmiles",
+    "caco2",
+    "chi0",
+    "chi0n",
+    "chi0v",
+    "chi1",
+    "chi1n",
+    "chi1v",
+    "chi2n",
+    "chi2v",
+    "chi3n",
+    "chi3v",
+    "chi4n",
+    "chi4v",
+    "compound_name",
+    "detection_limit_1",
+    "detection_limit_2",
+    "epsa",
+    "estate_vsa1",
+    "estate_vsa10",
+    "estate_vsa11",
+    "estate_vsa2",
+    "estate_vsa3",
+    "estate_vsa4",
+    "estate_vsa5",
+    "estate_vsa6",
+    "estate_vsa7",
+    "estate_vsa8",
+    "estate_vsa9",
+    "exactmolwt",
+    "fpdensitymorgan1",
+    "fpdensitymorgan2",
+    "fpdensitymorgan3",
+    "fractioncsp3",
+    "h2o_3dpsa",
+    "helm",
+    "helm_url",
+    "hallkieralpha",
+    "heavyatomcount",
+    "heavyatommolwt",
+    "id",
+    "iupac_condensed",
+    "iupac_name",
+    "ipc",
+    "kappa1",
+    "kappa2",
+    "kappa3",
+    "labuteasa",
+    "mdck",
+    "maxabsestateindex",
+    "maxabspartialcharge",
+    "maxestateindex",
+    "maxpartialcharge",
+    "minabsestateindex",
+    "minabspartialcharge",
+    "minestateindex",
+    "minpartialcharge",
+    "mollogp",
+    "molmr",
+    "molwt",
+    "molecule_shape",
+    "monomer_length",
+    "monomer_length_in_main_chain",
+    "monomer_type",
+    "nhohcount",
+    "nocount",
+    "null",
+    "natural_analog",
+    "numaliphaticcarbocycles",
+    "numaliphaticheterocycles",
+    "numaliphaticrings",
+    "numaromaticcarbocycles",
+    "numaromaticheterocycles",
+    "numaromaticrings",
+    "numhacceptors",
+    "numhdonors",
+    "numheteroatoms",
+    "numradicalelectrons",
+    "numrotatablebonds",
+    "numsaturatedcarbocycles",
+    "numsaturatedheterocycles",
+    "numsaturatedrings",
+    "numvalenceelectrons",
+    "original_name_in_source_literature",
+    "pampa",
+    "pc1",
+    "pc2",
+    "peoe_vsa1",
+    "peoe_vsa10",
+    "peoe_vsa11",
+    "peoe_vsa12",
+    "peoe_vsa13",
+    "peoe_vsa14",
+    "peoe_vsa2",
+    "peoe_vsa3",
+    "peoe_vsa4",
+    "peoe_vsa5",
+    "peoe_vsa6",
+    "peoe_vsa7",
+    "peoe_vsa8",
+    "peoe_vsa9",
+    "psa",
+    "permeability",
+    "polymer_type",
+    "pubchem_cid",
+    "r1",
+    "r2",
+    "r3",
+    "rrck",
+    "r_caco2",
+    "r_mdck",
+    "r_pamap",
+    "r_rrck",
+    "ringcount",
+    "smiles",
+    "smr_vsa1",
+    "smr_vsa10",
+    "smr_vsa2",
+    "smr_vsa3",
+    "smr_vsa4",
+    "smr_vsa5",
+    "smr_vsa6",
+    "smr_vsa7",
+    "smr_vsa8",
+    "smr_vsa9",
+    "same_peptides_assay",
+    "same_peptides_id",
+    "same_peptides_permeability",
+    "same_peptides_source",
+    "raw_sequence",
+    "sequence_logp",
+    "sequence_tpsa",
+    "slogp_vsa1",
+    "slogp_vsa10",
+    "slogp_vsa11",
+    "slogp_vsa12",
+    "slogp_vsa2",
+    "slogp_vsa3",
+    "slogp_vsa4",
+    "slogp_vsa5",
+    "slogp_vsa6",
+    "slogp_vsa7",
+    "slogp_vsa8",
+    "slogp_vsa9",
+    "source",
+    "structurally_unique_id",
+    "symbol",
+    "tpsa",
+    "t_pampa",
+    "vsa_estate1",
+    "vsa_estate10",
+    "vsa_estate2",
+    "vsa_estate3",
+    "vsa_estate4",
+    "vsa_estate5",
+    "vsa_estate6",
+    "vsa_estate7",
+    "vsa_estate8",
+    "vsa_estate9",
+    "version",
+    "year",
+    "x_3dpsa",
+    "capped_smiles",
+    "contain_id",
+    "contain_count",
+    "contain_pepnum",
+    "contain_perme",
+    "fr_al_coo",
+    "fr_al_oh",
+    "fr_al_oh_notert",
+    "fr_arn",
+    "fr_ar_coo",
+    "fr_ar_n",
+    "fr_ar_nh",
+    "fr_ar_oh",
+    "fr_coo",
+    "fr_coo2",
+    "fr_c_o",
+    "fr_c_o_nocoo",
+    "fr_c_s",
+    "fr_hoccn",
+    "fr_imine",
+    "fr_nh0",
+    "fr_nh1",
+    "fr_nh2",
+    "fr_n_o",
+    "fr_ndealkylation1",
+    "fr_ndealkylation2",
+    "fr_nhpyrrole",
+    "fr_sh",
+    "fr_aldehyde",
+    "fr_alkyl_carbamate",
+    "fr_alkyl_halide",
+    "fr_allylic_oxid",
+    "fr_amide",
+    "fr_amidine",
+    "fr_aniline",
+    "fr_aryl_methyl",
+    "fr_azide",
+    "fr_azo",
+    "fr_barbitur",
+    "fr_benzene",
+    "fr_benzodiazepine",
+    "fr_bicyclic",
+    "fr_diazo",
+    "fr_dihydropyridine",
+    "fr_epoxide",
+    "fr_ester",
+    "fr_ether",
+    "fr_furan",
+    "fr_guanido",
+    "fr_halogen",
+    "fr_hdrzine",
+    "fr_hdrzone",
+    "fr_imidazole",
+    "fr_imide",
+    "fr_isocyan",
+    "fr_isothiocyan",
+    "fr_ketone",
+    "fr_ketone_topliss",
+    "fr_lactam",
+    "fr_lactone",
+    "fr_methoxy",
+    "fr_morpholine",
+    "fr_nitrile",
+    "fr_nitro",
+    "fr_nitro_arom",
+    "fr_nitro_arom_nonortho",
+    "fr_nitroso",
+    "fr_oxazole",
+    "fr_oxime",
+    "fr_para_hydroxylation",
+    "fr_phenol",
+    "fr_phenol_noorthohbond",
+    "fr_phos_acid",
+    "fr_phos_ester",
+    "fr_piperdine",
+    "fr_piperzine",
+    "fr_priamide",
+    "fr_prisulfonamd",
+    "fr_pyridine",
+    "fr_quatn",
+    "fr_sulfide",
+    "fr_sulfonamd",
+    "fr_sulfone",
+    "fr_term_acetylene",
+    "fr_tetrazole",
+    "fr_thiazole",
+    "fr_thiocyan",
+    "fr_thiophene",
+    "fr_unbrch_alkane",
+    "fr_urea",
+    "qed",
+    "replaced_smiles"
+  ],
+  "metadata_tables": [
+    "metadata/source_tables.parquet",
+    "metadata/column_mapping.parquet"
+  ]
+}

metadata/column_mapping.parquet

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

metadata/source_tables.parquet

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

scripts/prepare_wrapped_jsonl_dataset.py

@@ -0,0 +1,416 @@
+#!/usr/bin/env python3
+"""Build viewer-friendly Parquet splits for LiteFold wrapped JSONL table repos."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import os
+import re
+import shutil
+from collections import Counter
+from pathlib import Path
+from typing import Any, Iterable
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+import pandas as pd
+from huggingface_hub import HfApi, hf_hub_download
+
+
+BASE_COLUMNS = [
+    "record_id",
+    "dataset_id",
+    "source_file",
+    "source_table",
+    "source_row_index",
+    "table_group",
+    "task_name",
+    "subtask_name",
+    "entity_type",
+    "assay_name",
+    "sequence",
+    "sequence_length",
+    "mutation",
+    "target",
+    "score_value",
+    "label",
+    "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 normalize_name(name: str) -> str:
+    normalized = re.sub(r"[^0-9A-Za-z]+", "_", name).strip("_").lower()
+    if not normalized:
+        normalized = "field"
+    if normalized[0].isdigit():
+        normalized = f"x_{normalized}"
+    return normalized
+
+
+def unique_names(keys: Iterable[str]) -> dict[str, str]:
+    mapping: dict[str, str] = {}
+    used: Counter[str] = Counter()
+    for key in sorted(keys):
+        base = normalize_name(key)
+        candidate = base
+        if candidate in BASE_COLUMNS:
+            candidate = f"raw_{candidate}"
+        used[candidate] += 1
+        if used[candidate] > 1:
+            candidate = f"{candidate}_{used[candidate]}"
+        mapping[key] = candidate
+    return mapping
+
+
+def scalar_string(value: Any) -> str | None:
+    if value is None or value == "":
+        return None
+    if isinstance(value, (dict, list)):
+        return json.dumps(value, sort_keys=True, ensure_ascii=False)
+    return str(value)
+
+
+def parse_float(value: Any) -> float | None:
+    if value is None or value == "":
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def first_present(row: dict[str, Any], keys: list[str]) -> Any:
+    for key in keys:
+        value = row.get(key)
+        if value is not None and value != "":
+            return value
+    return None
+
+
+def table_path_from_manifest(output_file: str) -> str:
+    prefix = "data/processed/"
+    if output_file.startswith(prefix):
+        parts = output_file.split("/tables/", 1)
+        if len(parts) == 2:
+            return "tables/" + parts[1]
+    return output_file
+
+
+def get_table_files(repo_id: str, mode: str, raw_dir: Path, token: str | None) -> tuple[list[str], list[dict[str, Any]]]:
+    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())
+    manifest_tables = manifest.get("tables") or []
+    if manifest_tables:
+        table_paths = [table_path_from_manifest(item["output_file"]) for item in manifest_tables]
+    else:
+        api = HfApi(token=token)
+        info = api.dataset_info(repo_id, files_metadata=True)
+        table_paths = [s.rfilename for s in info.siblings or [] if s.rfilename.startswith("tables/")]
+        manifest_tables = []
+
+    if mode == "cycpeptmpdb":
+        table_paths = [
+            path for path in table_paths if path.endswith("_Peptide_All.csv.jsonl") or path.endswith("_Monomer_All.csv.jsonl")
+        ]
+    if mode == "proteingym":
+        table_paths = [path for path in table_paths if ".ipynb_checkpoints" not in path]
+    return sorted(set(table_paths)), manifest_tables
+
+
+def classify(mode: str, source_file: str, source_table: str) -> dict[str, Any]:
+    source_parts = Path(source_file).parts
+    basename = Path(source_file).name.removesuffix(".csv")
+    if mode == "proteingym":
+        lower = source_file.lower()
+        if "indels" in lower:
+            table_group = "indels"
+        elif "substitutions" in lower:
+            table_group = "substitutions"
+        elif "clinical" in lower:
+            table_group = "clinical"
+        else:
+            table_group = "other"
+        if "raw_dms" in lower:
+            task_name = "DMS"
+        elif "clinical" in lower:
+            task_name = "clinical"
+        else:
+            task_name = None
+        return {
+            "table_group": table_group,
+            "task_name": task_name,
+            "subtask_name": None,
+            "entity_type": "variant",
+            "assay_name": basename,
+        }
+    if mode == "flip2":
+        task_name = source_parts[-2] if len(source_parts) >= 2 else None
+        return {
+            "table_group": "benchmark",
+            "task_name": task_name,
+            "subtask_name": basename,
+            "entity_type": "sequence",
+            "assay_name": f"{task_name}/{basename}" if task_name else basename,
+        }
+    if mode == "cycpeptmpdb":
+        entity_type = "peptide" if "Peptide" in basename else "monomer" if "Monomer" in basename else None
+        return {
+            "table_group": "all",
+            "task_name": "CycPeptMPDB",
+            "subtask_name": basename,
+            "entity_type": entity_type,
+            "assay_name": basename,
+        }
+    return {"table_group": None, "task_name": None, "subtask_name": None, "entity_type": None, "assay_name": basename}
+
+
+def derived_values(mode: str, wrapper: dict[str, Any]) -> dict[str, Any]:
+    row = wrapper.get("row") or {}
+    source_file = wrapper.get("source_file") or ""
+    source_table = wrapper.get("_source_table") or ""
+    source_row_index = wrapper.get("row_index")
+    record_seed = f"{source_file}|{source_row_index}|{json.dumps(row, sort_keys=True, ensure_ascii=False)}"
+    record_id = hashlib.sha256(record_seed.encode("utf-8")).hexdigest()
+    derived = {
+        "record_id": record_id,
+        "dataset_id": wrapper.get("dataset_id"),
+        "source_file": source_file,
+        "source_table": source_table,
+        "source_row_index": int(source_row_index) if source_row_index is not None else None,
+        "split_bucket": stable_bucket(record_id),
+    }
+    derived.update(classify(mode, source_file, source_table))
+
+    sequence = first_present(
+        row,
+        [
+            "mutated_sequence",
+            "mutant_sequence",
+            "sequence",
+            "Sequence",
+            "aa_seq",
+            "aa_seq_full",
+            "wildtype_sequence",
+            "WT_sequence",
+        ],
+    )
+    target = first_present(row, ["target", "DMS_score", "fitness", "score", "Permeability", "deltaG", "dG_ML"])
+    score_value = None
+    for key in ["target", "DMS_score", "fitness", "score", "Permeability", "deltaG", "dG_ML", "ddG_ML", "Caco2", "PAMPA", "MDCK", "RRCK"]:
+        score_value = parse_float(row.get(key))
+        if score_value is not None:
+            break
+    mutation = first_present(row, ["mutant", "mutation", "mutations", "name", "mut_class", "ID", "id"])
+    label = first_present(row, ["DMS_score_bin", "label", "set", "validation", "class", "mut_type", "Molecule_Shape"])
+
+    derived.update(
+        {
+            "sequence": scalar_string(sequence),
+            "sequence_length": len(str(sequence)) if sequence is not None else None,
+            "mutation": scalar_string(mutation),
+            "target": scalar_string(target),
+            "score_value": score_value,
+            "label": scalar_string(label),
+        }
+    )
+    return derived
+
+
+def iter_wrappers(path: Path, source_table: str) -> Iterable[dict[str, Any]]:
+    with path.open("r", encoding="utf-8", errors="replace") as handle:
+        for line in handle:
+            if not line.strip():
+                continue
+            item = json.loads(line)
+            item["_source_table"] = source_table
+            yield item
+
+
+def download_tables(repo_id: str, table_paths: list[str], raw_dir: Path, token: str | None) -> list[Path]:
+    paths = []
+    for index, table_path in enumerate(table_paths, start=1):
+        local = Path(hf_hub_download(repo_id=repo_id, repo_type="dataset", filename=table_path, local_dir=raw_dir, token=token))
+        paths.append(local)
+        if index == 1 or index % 25 == 0 or index == len(table_paths):
+            print(f"downloaded {index}/{len(table_paths)} {table_path}", flush=True)
+    return paths
+
+
+def write_split_shards(
+    out_dir: Path,
+    rows_iter: Iterable[dict[str, Any]],
+    schema: pa.Schema,
+    chunk_rows: int,
+) -> dict[str, int]:
+    data_dir = out_dir / "data"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    buffers: dict[str, list[dict[str, Any]]] = {"train": [], "test": []}
+    counts = {"train": 0, "test": 0}
+    shard_counts = {"train": 0, "test": 0}
+
+    def flush(split: str) -> None:
+        if not buffers[split]:
+            return
+        shard = shard_counts[split]
+        path = data_dir / f"{split}-{shard:05d}-of-XXXXX.parquet"
+        table = pa.Table.from_pylist(buffers[split], schema=schema)
+        pq.write_table(table, path, compression="zstd")
+        counts[split] += len(buffers[split])
+        shard_counts[split] += 1
+        buffers[split].clear()
+
+    for row in rows_iter:
+        split = "test" if row["split_bucket"] == 0 else "train"
+        buffers[split].append(row)
+        if len(buffers[split]) >= chunk_rows:
+            flush(split)
+    flush("train")
+    flush("test")
+
+    for split in ["train", "test"]:
+        total = shard_counts[split]
+        for path in sorted(data_dir.glob(f"{split}-*-of-XXXXX.parquet")):
+            new_name = path.name.replace("of-XXXXX", f"of-{total:05d}")
+            path.rename(path.with_name(new_name))
+    return counts
+
+
+def build_dataset(repo_id: str, mode: str, raw_dir: Path, out_dir: Path, chunk_rows: int) -> dict[str, Any]:
+    token = load_token()
+    raw_dir.mkdir(parents=True, exist_ok=True)
+    table_paths, manifest_tables = get_table_files(repo_id, mode, raw_dir, token)
+    local_paths = download_tables(repo_id, table_paths, raw_dir, token)
+
+    raw_keys: set[str] = set()
+    table_stats: list[dict[str, Any]] = []
+    total_rows = 0
+    for source_table, local_path in zip(table_paths, local_paths):
+        rows = 0
+        dataset_id = None
+        source_file = None
+        for wrapper in iter_wrappers(local_path, source_table):
+            row = wrapper.get("row") or {}
+            raw_keys.update(row.keys())
+            rows += 1
+            dataset_id = wrapper.get("dataset_id")
+            source_file = wrapper.get("source_file")
+        total_rows += rows
+        table_stats.append(
+            {
+                "source_table": source_table,
+                "source_file": source_file,
+                "dataset_id": dataset_id,
+                "rows": rows,
+                "size_bytes": local_path.stat().st_size,
+            }
+        )
+        print(f"scanned {source_table}: {rows} rows", flush=True)
+
+    raw_mapping = unique_names(raw_keys)
+    raw_columns = [raw_mapping[key] for key in sorted(raw_mapping)]
+    schema_fields = [
+        pa.field("record_id", pa.string()),
+        pa.field("dataset_id", pa.string()),
+        pa.field("source_file", pa.string()),
+        pa.field("source_table", pa.string()),
+        pa.field("source_row_index", pa.int64()),
+        pa.field("table_group", pa.string()),
+        pa.field("task_name", pa.string()),
+        pa.field("subtask_name", pa.string()),
+        pa.field("entity_type", pa.string()),
+        pa.field("assay_name", pa.string()),
+        pa.field("sequence", pa.string()),
+        pa.field("sequence_length", pa.int64()),
+        pa.field("mutation", pa.string()),
+        pa.field("target", pa.string()),
+        pa.field("score_value", pa.float64()),
+        pa.field("label", pa.string()),
+        pa.field("split_bucket", pa.int64()),
+    ] + [pa.field(column, pa.string()) for column in raw_columns]
+    schema = pa.schema(schema_fields)
+
+    if out_dir.exists():
+        shutil.rmtree(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    def row_iter() -> Iterable[dict[str, Any]]:
+        emitted = 0
+        for source_table, local_path in zip(table_paths, local_paths):
+            for wrapper in iter_wrappers(local_path, source_table):
+                raw = wrapper.get("row") or {}
+                row = {column: None for column in BASE_COLUMNS + raw_columns}
+                row.update(derived_values(mode, wrapper))
+                for original_key, column in raw_mapping.items():
+                    row[column] = scalar_string(raw.get(original_key))
+                emitted += 1
+                if emitted % 250000 == 0:
+                    print(f"prepared {emitted}/{total_rows} rows", flush=True)
+                yield row
+
+    split_counts = write_split_shards(out_dir, row_iter(), schema, chunk_rows)
+
+    metadata_dir = out_dir / "metadata"
+    metadata_dir.mkdir(parents=True, exist_ok=True)
+    pd.DataFrame.from_records(table_stats).to_parquet(metadata_dir / "source_tables.parquet", index=False, compression="zstd")
+    pd.DataFrame.from_records(
+        [{"raw_key": key, "column": raw_mapping[key]} for key in sorted(raw_mapping)]
+    ).to_parquet(metadata_dir / "column_mapping.parquet", index=False, compression="zstd")
+
+    summary = {
+        "source": repo_id,
+        "mode": mode,
+        "source_table_rows": len(table_stats),
+        "entry_rows": int(total_rows),
+        "raw_field_count": len(raw_columns),
+        "splits": split_counts,
+        "split_strategy": "deterministic sha256(record_id) % 10; bucket 0 is test, buckets 1-9 are train",
+        "table_group_counts": dict(Counter(item["source_file"].split("/")[-2] if item["source_file"] and "/" in item["source_file"] else "unknown" for item in table_stats).most_common()),
+        "columns": BASE_COLUMNS + raw_columns,
+        "metadata_tables": ["metadata/source_tables.parquet", "metadata/column_mapping.parquet"],
+    }
+    (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", required=True)
+    parser.add_argument("--mode", required=True, choices=["proteingym", "flip2", "cycpeptmpdb"])
+    parser.add_argument("--raw-dir", type=Path, required=True)
+    parser.add_argument("--out-dir", type=Path, required=True)
+    parser.add_argument("--chunk-rows", type=int, default=200000)
+    args = parser.parse_args()
+    summary = build_dataset(args.repo_id, args.mode, args.raw_dir, args.out_dir, args.chunk_rows)
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()