initial push

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/cleaned_fireprotdb.csv filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+data/fireprotdb_20251015-164116.csv
+intermediate/*

data/cleaned_fireprotdb.csv

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

fireprot.py

@@ -0,0 +1,339 @@
+# fireprotdb.py
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+import datasets
+
+
+# Change these when publishing:
+_CITATION = """\
+@misc{fireprotdb2,
+  title = {FireProtDB 2.0},
+  note  = {See original FireProtDB 2.0 publication and ProTherm sources}
+}
+"""
+
+_DESCRIPTION = """\
+ML-ready views of FireProtDB 2.0 derived from the raw CSV:
+- mutation-level regression/classification (ddg, dtm, stabilizing)
+- protein-level aggregated landscape view
+- mutation language modeling view
+
+This dataset is intended for Rosetta Commons / protein ML benchmarking.
+"""
+
+_HOMEPAGE = "https://github.com/drake463/FireProtDB"  # update
+_LICENSE = "cc-by-4.0"  # update to correct license if different
+
+
+# If you publish to HF, include the cleaned parquet in the repo and set this relative path.
+# For local testing, replace with your local path.
+_DEFAULT_DATA_FILE = "../data/cleaned_fireportdb.csv"
+
+
+class FireProtDBConfig(datasets.BuilderConfig):
+    def __init__(self, task: str, **kwargs):
+        super().__init__(**kwargs)
+        self.task = task
+
+
+_BUILDER_CONFIGS = [
+    FireProtDBConfig(
+        name="mutation_ddg",
+        version=datasets.Version("1.0.0"),
+        description="Mutation-level ΔΔG regression (row-per-experiment where ddg present).",
+        task="mutation_ddg",
+    ),
+    FireProtDBConfig(
+        name="mutation_dtm",
+        version=datasets.Version("1.0.0"),
+        description="Mutation-level ΔTm regression (row-per-experiment where dtm present).",
+        task="mutation_dtm",
+    ),
+    FireProtDBConfig(
+        name="mutation_binary",
+        version=datasets.Version("1.0.0"),
+        description="Mutation-level binary stability classification (explicit stabilizing or ddg-sign-derived).",
+        task="mutation_binary",
+    ),
+    FireProtDBConfig(
+        name="mutation_lm",
+        version=datasets.Version("1.0.0"),
+        description="Mutation language-modeling view: (sequence, mutation, position, target_aa).",
+        task="mutation_lm",
+    ),
+    FireProtDBConfig(
+        name="protein_landscape",
+        version=datasets.Version("1.0.0"),
+        description="Protein-level aggregated landscapes: one row per protein with list of variants.",
+        task="protein_landscape",
+    ),
+]
+
+
+def _stable_hash(s: str) -> int:
+    h = hashlib.sha256(s.encode("utf-8")).hexdigest()
+    return int(h[:8], 16)
+
+
+def _split_by_protein(uniprot: Optional[str], sequence_id: Optional[str], ratios=(0.8, 0.1, 0.1)) -> str:
+    """
+    Deterministic protein-level split using (uniprotkb if present else sequence_id).
+    """
+    key = (uniprot or "").strip()
+    if not key:
+        key = f"seqid:{(sequence_id or '').strip()}"
+    if not key.strip():
+        key = "unknown"
+    r = _stable_hash(key) / 0xFFFFFFFF
+    if r < ratios[0]:
+        return "train"
+    if r < ratios[0] + ratios[1]:
+        return "validation"
+    return "test"
+
+
+class FireProtDB(datasets.GeneratorBasedBuilder):
+    BUILDER_CONFIGS = _BUILDER_CONFIGS
+    DEFAULT_CONFIG_NAME = "mutation_ddg"
+
+    def _info(self) -> datasets.DatasetInfo:
+        # Base schema for mutation-level records
+        mutation_features = datasets.Features(
+            {
+                "experiment_id": datasets.Value("string"),
+                "sequence_id": datasets.Value("string"),
+                "uniprotkb": datasets.Value("string"),
+                "protein_name": datasets.Value("string"),
+                "organism": datasets.Value("string"),
+                "sequence_length": datasets.Value("int32"),
+                "mutation": datasets.Value("string"),
+                "wt_residue": datasets.Value("string"),
+                "position": datasets.Value("int32"),
+                "mut_residue": datasets.Value("string"),
+                "ddg": datasets.Value("float32"),
+                "dtm": datasets.Value("float32"),
+                "tm": datasets.Value("float32"),
+                "ph": datasets.Value("float32"),
+                "buffer": datasets.Value("string"),
+                "method": datasets.Value("string"),
+                "measure": datasets.Value("string"),
+                "pmid": datasets.Value("string"),
+                "doi": datasets.Value("string"),
+                "publication_year": datasets.Value("int32"),
+                "split": datasets.ClassLabel(names=["train", "validation", "test"]),
+				"pdb_id": datasets.Value("string"),
+				"pdb_ids": datasets.Sequence(datasets.Value("string")),
+            }
+        )
+
+        if self.config.task == "mutation_lm":
+            features = datasets.Features(
+                {
+                    "experiment_id": datasets.Value("string"),
+                    "sequence_id": datasets.Value("string"),
+                    "uniprotkb": datasets.Value("string"),
+                    "sequence": datasets.Value("string"),  # optional if you later join sequences
+                    "mutation": datasets.Value("string"),
+                    "position": datasets.Value("int32"),
+                    "target_aa": datasets.Value("string"),
+                    "split": datasets.ClassLabel(names=["train", "validation", "test"]),
+                }
+            )
+        elif self.config.task == "protein_landscape":
+            features = datasets.Features(
+                {
+                    "protein_key": datasets.Value("string"),
+                    "uniprotkb": datasets.Value("string"),
+                    "sequence_id": datasets.Value("string"),
+                    "protein_name": datasets.Value("string"),
+                    "organism": datasets.Value("string"),
+                    "sequence_length": datasets.Value("int32"),
+                    "variants": datasets.Sequence(
+                        {
+                            "experiment_id": datasets.Value("string"),
+                            "mutation": datasets.Value("string"),
+                            "position": datasets.Value("int32"),
+                            "wt_residue": datasets.Value("string"),
+                            "mut_residue": datasets.Value("string"),
+                            "ddg": datasets.Value("float32"),
+                            "dtm": datasets.Value("float32"),
+                            "ph": datasets.Value("float32"),
+                            "buffer": datasets.Value("string"),
+                            "method": datasets.Value("string"),
+							"pdb_id": datasets.Value("string"),
+							"pdb_ids": datasets.Sequence(datasets.Value("string")),
+                        }
+                    ),
+                    "split": datasets.ClassLabel(names=["train", "validation", "test"]),
+                }
+            )
+        else:
+            features = mutation_features
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager: datasets.DownloadManager):
+        # You can also host the cleaned file and put a URL here.
+        data_path = dl_manager.download(_DEFAULT_DATA_FILE)
+
+        # We'll generate ALL examples in one pass and assign split label per protein_key.
+        return [
+            datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"path": data_path, "wanted_split": "train"}),
+            datasets.SplitGenerator(name=datasets.Split.VALIDATION, gen_kwargs={"path": data_path, "wanted_split": "validation"}),
+            datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={"path": data_path, "wanted_split": "test"}),
+        ]
+
+    def _generate_examples(self, path: str, wanted_split: str):
+        import pandas as pd
+
+        # Read cleaned canonical table
+        if path.endswith(".parquet"):
+            df = pd.read_parquet(path)
+        else:
+            df = pd.read_csv(path)
+
+        # Ensure types
+        # (pandas nullable ints may appear; keep safe casting below)
+        def _to_int(x):
+            try:
+                return int(x)
+            except Exception:
+                return None
+
+        def _to_float(x):
+            try:
+                return float(x)
+            except Exception:
+                return None
+
+        # Task-specific filtering and shaping
+        if self.config.task in ("mutation_ddg", "mutation_binary", "mutation_lm"):
+            df_task = df[df["mutation"].notna()].copy()
+        elif self.config.task == "mutation_dtm":
+            df_task = df[df["mutation"].notna()].copy()
+        elif self.config.task == "protein_landscape":
+            df_task = df[df["mutation"].notna()].copy()
+        else:
+            df_task = df.copy()
+
+        # Apply label availability filters
+        if self.config.task == "mutation_ddg":
+            df_task = df_task[df_task["ddg"].notna()]
+        elif self.config.task == "mutation_dtm":
+            df_task = df_task[df_task["dtm"].notna()]
+        elif self.config.task == "mutation_binary":
+            df_task = df_task[df_task["stabilizing"].notna()]
+        elif self.config.task == "mutation_lm":
+            # Needs position and mut_residue for target_aa
+            df_task = df_task[df_task["position"].notna() & df_task["mut_residue"].notna()]
+
+        # Assign protein-level split deterministically
+        def protein_split(row) -> str:
+            return _split_by_protein(
+                uniprot=str(row.get("uniprotkb") or "").strip() or None,
+                sequence_id=str(row.get("sequence_id") or "").strip() or None,
+            )
+
+        df_task["split_name"] = df_task.apply(protein_split, axis=1)
+        df_task = df_task[df_task["split_name"] == wanted_split]
+
+        if self.config.task == "protein_landscape":
+            # Aggregate into one row per protein_key (uniprot preferred)
+            def protein_key(row) -> str:
+                u = str(row.get("uniprotkb") or "").strip()
+                if u:
+                    return u
+                sid = str(row.get("sequence_id") or "").strip()
+                return f"seqid:{sid}" if sid else "unknown"
+
+            df_task["protein_key"] = df_task.apply(protein_key, axis=1)
+
+            grouped = df_task.groupby("protein_key", dropna=False)
+
+            idx = 0
+            for pk, g in grouped:
+                # Representative metadata
+                first = g.iloc[0]
+                record = {
+                    "protein_key": str(pk),
+                    "uniprotkb": str(first.get("uniprotkb") or ""),
+                    "sequence_id": str(first.get("sequence_id") or ""),
+                    "protein_name": str(first.get("protein_name") or ""),
+                    "organism": str(first.get("organism") or ""),
+                    "sequence_length": _to_int(first.get("sequence_length")) or 0,
+                    "variants": [],
+                    "split": wanted_split,
+                }
+                for _, r in g.iterrows():
+                    record["variants"].append(
+                        {
+                            "experiment_id": str(r.get("experiment_id") or ""),
+                            "mutation": str(r.get("mutation") or ""),
+                            "position": _to_int(r.get("position")) or -1,
+                            "wt_residue": str(r.get("wt_residue") or ""),
+                            "mut_residue": str(r.get("mut_residue") or ""),
+                            "ddg": _to_float(r.get("ddg")),
+                            "dtm": _to_float(r.get("dtm")),
+                            "ph": _to_float(r.get("ph")),
+                            "buffer": str(r.get("buffer_norm") or r.get("buffer_raw") or ""),
+                            "method": str(r.get("method_norm") or ""),
+							"pdb_id": str(r.get("pdb_id") or ""),
+							"pdb_ids": list(r.get("pdb_ids") or []),
+                        }
+                    )
+                yield idx, record
+                idx += 1
+            return
+
+        # Mutation LM view
+        if self.config.task == "mutation_lm":
+            for i, r in df_task.reset_index(drop=True).iterrows():
+                yield i, {
+                    "experiment_id": str(r.get("experiment_id") or ""),
+                    "sequence_id": str(r.get("sequence_id") or ""),
+                    "uniprotkb": str(r.get("uniprotkb") or ""),
+                    "sequence": "",  # left blank unless you join real sequences elsewhere
+                    "mutation": str(r.get("mutation") or ""),
+                    "position": _to_int(r.get("position")) or -1,
+                    "target_aa": str(r.get("mut_residue") or ""),
+                    "split": wanted_split,
+                }
+            return
+
+        # Standard mutation-level views
+        for i, r in df_task.reset_index(drop=True).iterrows():
+            yield i, {
+                "experiment_id": str(r.get("experiment_id") or ""),
+                "sequence_id": str(r.get("sequence_id") or ""),
+                "uniprotkb": str(r.get("uniprotkb") or ""),
+                "protein_name": str(r.get("protein_name") or ""),
+                "organism": str(r.get("organism") or ""),
+                "sequence_length": _to_int(r.get("sequence_length")) or 0,
+                "mutation": str(r.get("mutation") or ""),
+                "wt_residue": str(r.get("wt_residue") or ""),
+                "position": _to_int(r.get("position")) or -1,
+                "mut_residue": str(r.get("mut_residue") or ""),
+                "ddg": _to_float(r.get("ddg")),
+                "dtm": _to_float(r.get("dtm")),
+                "tm": _to_float(r.get("tm")),
+                "ph": _to_float(r.get("ph")),
+                "buffer": str(r.get("buffer_norm") or r.get("buffer_raw") or ""),
+                "method": str(r.get("method_norm") or ""),
+                "measure": str(r.get("measure_norm") or ""),
+                "pmid": str(r.get("pmid") or ""),
+                "doi": str(r.get("doi") or ""),
+				"pdb_id": str(r.get("pdb_id") or ""),
+				"pdb_ids": list(r.get("pdb_ids") or []),
+                "publication_year": int(r.get("publication_year")) if str(r.get("publication_year") or "").isdigit() else 0,
+                "split": wanted_split,
+            }

src/01.1_process_csv.py

@@ -0,0 +1,330 @@
+#!/usr/bin/env python3
+"""
+Clean FireProtDB 2.0 CSV into ML-ready canonical table.
+
+Outputs:
+- A canonical row-per-experiment table with parsed mutation fields and normalized columns.
+- Optionally writes Parquet for speed.
+
+Usage:
+  python scripts/clean_fireprotdb.py \
+    --input fireprotdb_2_0.csv \
+    --output data/fireprotdb_clean.parquet
+
+Notes:
+- This script is conservative: it does NOT impute missing ddg/dtm.
+- It standardizes a few categorical fields; extend mappings as needed.
+"""
+
+from __future__ import annotations
+
+import argparse
+import math
+import re
+from typing import Optional, Tuple, Dict
+
+import pandas as pd
+###PDB parsing
+_PDB_SPLIT = re.compile(r"[;,| ]+")
+_PDB_ID = re.compile(r"^[0-9][A-Za-z0-9]{3}$")  # 4-char PDB id, first char numeric
+
+def parse_pdb_ids(x: object):
+    """
+    Returns (pdb_id, pdb_ids) where:
+      - pdb_id: first valid 4-char PDB id (lowercase), or None
+      - pdb_ids: sorted unique list of valid ids (lowercase)
+    """
+    if not isinstance(x, str):
+        return None, []
+    s = x.strip()
+    if not s:
+        return None, []
+
+    parts = [p.strip() for p in _PDB_SPLIT.split(s) if p.strip()]
+    ids = []
+    for p in parts:
+        p = p.strip()
+        # sometimes entries include chain like "1ABC:A" or "1ABC_A"
+        p = re.split(r"[:_]", p)[0].strip()
+        if _PDB_ID.match(p):
+            ids.append(p.lower())
+
+    ids = sorted(set(ids))
+    return (ids[0] if ids else None), ids
+
+# --- Mutation parsing ---
+# Accept common patterns:
+#   A123V
+#   p.Ala123Val (rare)
+#   123A>V (rare)
+_MUT_A123V = re.compile(r"^(?P<wt>[ACDEFGHIKLMNPQRSTVWY])(?P<pos>\d+)(?P<mut>[ACDEFGHIKLMNPQRSTVWY])$")
+_MUT_123A_GT_V = re.compile(r"^(?P<pos>\d+)(?P<wt>[ACDEFGHIKLMNPQRSTVWY])>(?P<mut>[ACDEFGHIKLMNPQRSTVWY])$")
+
+
+def parse_substitution(s: str) -> Tuple[Optional[str], Optional[int], Optional[str], Optional[str]]:
+    """
+    Returns (wt_residue, position, mut_residue, normalized_mutation_string)
+    """
+    if not isinstance(s, str) or not s.strip():
+        return None, None, None, None
+    s = s.strip()
+
+    m = _MUT_A123V.match(s)
+    if m:
+        wt = m.group("wt")
+        pos = int(m.group("pos"))
+        mut = m.group("mut")
+        return wt, pos, mut, f"{wt}{pos}{mut}"
+
+    m = _MUT_123A_GT_V.match(s)
+    if m:
+        pos = int(m.group("pos"))
+        wt = m.group("wt")
+        mut = m.group("mut")
+        return wt, pos, mut, f"{wt}{pos}{mut}"
+
+    # If it's something else (multi-mutation, insertion/deletion notation, etc.),
+    # keep it in "mutation_raw" but do not parse.
+    return None, None, None, None
+
+
+# --- Categorical normalization ---
+def norm_str(x: object) -> Optional[str]:
+    if not isinstance(x, str):
+        return None
+    x = x.strip()
+    return x if x else None
+
+
+BUFFER_MAP: Dict[str, str] = {
+    "sodium tetraborate": "Sodium tetraborate",
+    "tetra-borate": "Sodium tetraborate",
+    "tetraborate": "Sodium tetraborate",
+    "sodium phosphate": "Sodium phosphate",
+}
+
+
+METHOD_MAP: Dict[str, str] = {
+    "dsc": "DSC",
+    "cd": "CD",
+}
+
+
+MEASURE_MAP: Dict[str, str] = {
+    "thermal": "Thermal",
+}
+
+
+def normalize_categoricals(df: pd.DataFrame) -> pd.DataFrame:
+    def map_lower(series: pd.Series, mapping: Dict[str, str]) -> pd.Series:
+        s = series.astype("string")
+        s_lower = s.str.lower().str.strip()
+        return s_lower.map(mapping).fillna(s.str.strip())
+
+    if "BUFFER" in df.columns:
+        df["buffer_norm"] = map_lower(df["BUFFER"], BUFFER_MAP)
+    else:
+        df["buffer_norm"] = pd.NA
+
+    if "METHOD" in df.columns:
+        df["method_norm"] = map_lower(df["METHOD"], METHOD_MAP)
+    else:
+        df["method_norm"] = pd.NA
+
+    if "MEASURE" in df.columns:
+        df["measure_norm"] = map_lower(df["MEASURE"], MEASURE_MAP)
+    else:
+        df["measure_norm"] = pd.NA
+
+    return df
+
+
+# --- Numeric cleanup ---
+def to_float(x: object) -> Optional[float]:
+    if x is None or (isinstance(x, float) and math.isnan(x)):
+        return None
+    if isinstance(x, (int, float)):
+        return float(x)
+    if isinstance(x, str):
+        s = x.strip()
+        if not s:
+            return None
+        # Handle "1mM" vs "1 mM" etc. for numeric fields by stripping units if present.
+        # For now: attempt raw float parse.
+        try:
+            return float(s)
+        except ValueError:
+            # try to extract first float substring
+            m = re.search(r"[-+]?\d*\.?\d+(?:[eE][-+]?\d+)?", s)
+            if m:
+                try:
+                    return float(m.group(0))
+                except ValueError:
+                    return None
+    return None
+
+
+def clean_numeric_columns(df: pd.DataFrame) -> pd.DataFrame:
+    # ddg-like
+    for col in ["DDG", "DOMAINOME_DDG", "DG", "DH", "DHVH"]:
+        if col in df.columns:
+            df[col.lower()] = df[col].map(to_float)
+        else:
+            df[col.lower()] = pd.NA
+
+    # temperature-like
+    for col in ["TM", "DTM", "EXP_TEMPERATURE"]:
+        if col in df.columns:
+            df[col.lower()] = df[col].map(to_float)
+        else:
+            df[col.lower()] = pd.NA
+
+    # pH
+    if "PH" in df.columns:
+        df["ph"] = df["PH"].map(to_float)
+    else:
+        df["ph"] = pd.NA
+
+    return df
+
+
+def derive_labels(df: pd.DataFrame) -> pd.DataFrame:
+    # Stabilizing classification: prefer explicit STABILIZING column if present,
+    # else use ddg sign if ddg available.
+    if "STABILIZING" in df.columns:
+        s = df["STABILIZING"].astype("string").str.lower().str.strip()
+        df["stabilizing_explicit"] = s.map({"yes": True, "no": False})
+    else:
+        df["stabilizing_explicit"] = pd.NA
+
+    # ddg-based label (common convention: ddg < 0 stabilizing)
+    df["stabilizing_ddg"] = df["ddg"].apply(lambda v: True if isinstance(v, float) and v < 0 else (False if isinstance(v, float) and v > 0 else pd.NA))
+
+    # unified label: explicit if available else ddg-based
+    df["stabilizing"] = df["stabilizing_explicit"]
+    df.loc[df["stabilizing"].isna(), "stabilizing"] = df.loc[df["stabilizing"].isna(), "stabilizing_ddg"]
+
+    return df
+
+
+def select_and_rename(df: pd.DataFrame) -> pd.DataFrame:
+    # canonical columns (keep more if you want)
+    keep = {
+        "EXPERIMENT_ID": "experiment_id",
+        "SEQUENCE_ID": "sequence_id",
+        "MUTANT_ID": "mutant_id",
+        "SOURCE_SEQUENCE_ID": "source_sequence_id",
+        "TARGET_SEQUENCE_ID": "target_sequence_id",
+        "SEQUENCE_LENGTH": "sequence_length",
+        "SUBSTITUTION": "substitution_raw",
+        "INSERTION": "insertion_raw",
+        "DELETION": "deletion_raw",
+        "PROTEIN": "protein_name",
+        "ORGANISM": "organism",
+        "UNIPROTKB": "uniprotkb",
+        "EC_NUMBER": "ec_number",
+        "INTERPRO": "interpro",
+        "PUBLICATION_PMID": "pmid",
+        "PUBLICATION_DOI": "doi",
+        "PUBLICATION_YEAR": "publication_year",
+        "SOURCE_DATASET": "source_dataset",
+        "REFERENCING_DATASET": "referencing_dataset",
+        "WWPDB": "wwpdb_raw",
+    }
+
+    out = pd.DataFrame()
+    for src, dst in keep.items():
+        out[dst] = df[src] if src in df.columns else pd.NA
+
+    # numeric & normalized categorical fields added earlier
+    extra_cols = [
+        "ddg", "domainome_ddg", "dg", "dh", "dhvh",
+        "tm", "dtm", "exp_temperature",
+        "ph",
+        "buffer_norm", "method_norm", "measure_norm",
+        "stabilizing",
+    ]
+    for c in extra_cols:
+        out[c] = df[c] if c in df.columns else pd.NA
+
+    # keep raw text fields that matter for conditions (optional)
+    for src, dst in [("BUFFER", "buffer_raw"), ("BUFFER_CONC", "buffer_conc_raw"), ("ION", "ion_raw"), ("ION_CONC", "ion_conc_raw"), ("STATE", "state")]:
+        out[dst] = df[src] if src in df.columns else pd.NA
+    out["pdb_id"] = df["pdb_id"] if "pdb_id" in df.columns else pd.NA
+    out["pdb_ids"] = df["pdb_ids"] if "pdb_ids" in df.columns else [[] for _ in range(len(df))]
+    return out
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--input", required=True, help="Path to raw FireProtDB 2.0 CSV")
+    ap.add_argument("--output", required=True, help="Path to output .parquet or .csv")
+    ap.add_argument("--min_seq_len", type=int, default=1, help="Drop sequences shorter than this")
+    ap.add_argument("--drop_no_label", action="store_true", help="Drop rows with neither ddg nor dtm")
+    args = ap.parse_args()
+
+    # Load as strings to avoid pandas guessing mixed types
+    df = pd.read_csv(args.input, dtype="string", keep_default_na=False, na_values=["", "NA", "NaN", "nan"])
+    df = df.replace({"": pd.NA})
+
+    # Basic trimming
+    for c in df.columns:
+        if pd.api.types.is_string_dtype(df[c]):
+            df[c] = df[c].astype("string").str.strip()
+
+    # Normalize & parse
+    df = normalize_categoricals(df)
+    df = clean_numeric_columns(df)
+
+    # Parse substitution into structured columns
+    parsed = df["SUBSTITUTION"].apply(lambda x: parse_substitution(x) if "SUBSTITUTION" in df.columns else (None, None, None, None))
+    df["wt_residue"] = parsed.map(lambda t: t[0])
+    df["position"] = parsed.map(lambda t: t[1]).astype("Int64")
+    df["mut_residue"] = parsed.map(lambda t: t[2])
+    df["mutation"] = parsed.map(lambda t: t[3])
+
+    df = derive_labels(df)
+
+    if "WWPDB" in df.columns:
+        parsed_pdb = df["WWPDB"].astype("string").fillna("").apply(lambda v: parse_pdb_ids(str(v)))
+        df["pdb_id"] = parsed_pdb.map(lambda t: t[0])
+        df["pdb_ids"] = parsed_pdb.map(lambda t: t[1])
+    else:
+        df["pdb_id"] = pd.NA
+        df["pdb_ids"] = [[] for _ in range(len(df))]
+
+    # Filter
+    if "SEQUENCE_LENGTH" in df.columns:
+        seq_len = df["SEQUENCE_LENGTH"].map(to_float)
+        df["sequence_length_num"] = seq_len
+        df = df[df["sequence_length_num"].fillna(0) >= args.min_seq_len]
+
+    if args.drop_no_label:
+        df = df[~(df["ddg"].isna() & df["dtm"].isna())]
+
+    # Select final schema
+    out = select_and_rename(df)
+
+    # Add parsed mutation columns
+    out["wt_residue"] = df["wt_residue"]
+    out["position"] = df["position"]
+    out["mut_residue"] = df["mut_residue"]
+    out["mutation"] = df["mutation"]
+
+    # De-dupe obvious duplicates (same experiment id)
+    if "experiment_id" in out.columns:
+        out = out.drop_duplicates(subset=["experiment_id"])
+
+    # Write
+    if args.output.lower().endswith(".parquet"):
+        out.to_parquet(args.output, index=False)
+    elif args.output.lower().endswith(".csv"):
+        out.to_csv(args.output, index=False)
+    else:
+        raise ValueError("Output must end with .parquet or .csv")
+
+    print(f"Wrote {len(out):,} rows to {args.output}")
+
+
+if __name__ == "__main__":
+    main()

src/01.2_gen_datasets.py

@@ -0,0 +1,339 @@
+# fireprotdb.py
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from typing import Dict, List, Optional
+
+import datasets
+
+
+# Change these when publishing:
+_CITATION = """\
+@misc{fireprotdb2,
+  title = {FireProtDB 2.0},
+  note  = {See original FireProtDB 2.0 publication and ProTherm sources}
+}
+"""
+
+_DESCRIPTION = """\
+ML-ready views of FireProtDB 2.0 derived from the raw CSV:
+- mutation-level regression/classification (ddg, dtm, stabilizing)
+- protein-level aggregated landscape view
+- mutation language modeling view
+
+This dataset is intended for Rosetta Commons / protein ML benchmarking.
+"""
+
+_HOMEPAGE = "https://github.com/drake463/FireProtDB"  # update
+_LICENSE = "cc-by-4.0"  # update to correct license if different
+
+
+# If you publish to HF, include the cleaned parquet in the repo and set this relative path.
+# For local testing, replace with your local path.
+_DEFAULT_DATA_FILE = "../data/cleaned_fireportdb.csv"
+
+
+class FireProtDBConfig(datasets.BuilderConfig):
+    def __init__(self, task: str, **kwargs):
+        super().__init__(**kwargs)
+        self.task = task
+
+
+_BUILDER_CONFIGS = [
+    FireProtDBConfig(
+        name="mutation_ddg",
+        version=datasets.Version("1.0.0"),
+        description="Mutation-level ΔΔG regression (row-per-experiment where ddg present).",
+        task="mutation_ddg",
+    ),
+    FireProtDBConfig(
+        name="mutation_dtm",
+        version=datasets.Version("1.0.0"),
+        description="Mutation-level ΔTm regression (row-per-experiment where dtm present).",
+        task="mutation_dtm",
+    ),
+    FireProtDBConfig(
+        name="mutation_binary",
+        version=datasets.Version("1.0.0"),
+        description="Mutation-level binary stability classification (explicit stabilizing or ddg-sign-derived).",
+        task="mutation_binary",
+    ),
+    FireProtDBConfig(
+        name="mutation_lm",
+        version=datasets.Version("1.0.0"),
+        description="Mutation language-modeling view: (sequence, mutation, position, target_aa).",
+        task="mutation_lm",
+    ),
+    FireProtDBConfig(
+        name="protein_landscape",
+        version=datasets.Version("1.0.0"),
+        description="Protein-level aggregated landscapes: one row per protein with list of variants.",
+        task="protein_landscape",
+    ),
+]
+
+
+def _stable_hash(s: str) -> int:
+    h = hashlib.sha256(s.encode("utf-8")).hexdigest()
+    return int(h[:8], 16)
+
+
+def _split_by_protein(uniprot: Optional[str], sequence_id: Optional[str], ratios=(0.8, 0.1, 0.1)) -> str:
+    """
+    Deterministic protein-level split using (uniprotkb if present else sequence_id).
+    """
+    key = (uniprot or "").strip()
+    if not key:
+        key = f"seqid:{(sequence_id or '').strip()}"
+    if not key.strip():
+        key = "unknown"
+    r = _stable_hash(key) / 0xFFFFFFFF
+    if r < ratios[0]:
+        return "train"
+    if r < ratios[0] + ratios[1]:
+        return "validation"
+    return "test"
+
+
+class FireProtDB(datasets.GeneratorBasedBuilder):
+    BUILDER_CONFIGS = _BUILDER_CONFIGS
+    DEFAULT_CONFIG_NAME = "mutation_ddg"
+
+    def _info(self) -> datasets.DatasetInfo:
+        # Base schema for mutation-level records
+        mutation_features = datasets.Features(
+            {
+                "experiment_id": datasets.Value("string"),
+                "sequence_id": datasets.Value("string"),
+                "uniprotkb": datasets.Value("string"),
+                "protein_name": datasets.Value("string"),
+                "organism": datasets.Value("string"),
+                "sequence_length": datasets.Value("int32"),
+                "mutation": datasets.Value("string"),
+                "wt_residue": datasets.Value("string"),
+                "position": datasets.Value("int32"),
+                "mut_residue": datasets.Value("string"),
+                "ddg": datasets.Value("float32"),
+                "dtm": datasets.Value("float32"),
+                "tm": datasets.Value("float32"),
+                "ph": datasets.Value("float32"),
+                "buffer": datasets.Value("string"),
+                "method": datasets.Value("string"),
+                "measure": datasets.Value("string"),
+                "pmid": datasets.Value("string"),
+                "doi": datasets.Value("string"),
+                "publication_year": datasets.Value("int32"),
+                "split": datasets.ClassLabel(names=["train", "validation", "test"]),
+				"pdb_id": datasets.Value("string"),
+				"pdb_ids": datasets.Sequence(datasets.Value("string")),
+            }
+        )
+
+        if self.config.task == "mutation_lm":
+            features = datasets.Features(
+                {
+                    "experiment_id": datasets.Value("string"),
+                    "sequence_id": datasets.Value("string"),
+                    "uniprotkb": datasets.Value("string"),
+                    "sequence": datasets.Value("string"),  # optional if you later join sequences
+                    "mutation": datasets.Value("string"),
+                    "position": datasets.Value("int32"),
+                    "target_aa": datasets.Value("string"),
+                    "split": datasets.ClassLabel(names=["train", "validation", "test"]),
+                }
+            )
+        elif self.config.task == "protein_landscape":
+            features = datasets.Features(
+                {
+                    "protein_key": datasets.Value("string"),
+                    "uniprotkb": datasets.Value("string"),
+                    "sequence_id": datasets.Value("string"),
+                    "protein_name": datasets.Value("string"),
+                    "organism": datasets.Value("string"),
+                    "sequence_length": datasets.Value("int32"),
+                    "variants": datasets.Sequence(
+                        {
+                            "experiment_id": datasets.Value("string"),
+                            "mutation": datasets.Value("string"),
+                            "position": datasets.Value("int32"),
+                            "wt_residue": datasets.Value("string"),
+                            "mut_residue": datasets.Value("string"),
+                            "ddg": datasets.Value("float32"),
+                            "dtm": datasets.Value("float32"),
+                            "ph": datasets.Value("float32"),
+                            "buffer": datasets.Value("string"),
+                            "method": datasets.Value("string"),
+							"pdb_id": datasets.Value("string"),
+							"pdb_ids": datasets.Sequence(datasets.Value("string")),
+                        }
+                    ),
+                    "split": datasets.ClassLabel(names=["train", "validation", "test"]),
+                }
+            )
+        else:
+            features = mutation_features
+
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=features,
+            homepage=_HOMEPAGE,
+            license=_LICENSE,
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager: datasets.DownloadManager):
+        # You can also host the cleaned file and put a URL here.
+        data_path = dl_manager.download(_DEFAULT_DATA_FILE)
+
+        # We'll generate ALL examples in one pass and assign split label per protein_key.
+        return [
+            datasets.SplitGenerator(name=datasets.Split.TRAIN, gen_kwargs={"path": data_path, "wanted_split": "train"}),
+            datasets.SplitGenerator(name=datasets.Split.VALIDATION, gen_kwargs={"path": data_path, "wanted_split": "validation"}),
+            datasets.SplitGenerator(name=datasets.Split.TEST, gen_kwargs={"path": data_path, "wanted_split": "test"}),
+        ]
+
+    def _generate_examples(self, path: str, wanted_split: str):
+        import pandas as pd
+
+        # Read cleaned canonical table
+        if path.endswith(".parquet"):
+            df = pd.read_parquet(path)
+        else:
+            df = pd.read_csv(path)
+
+        # Ensure types
+        # (pandas nullable ints may appear; keep safe casting below)
+        def _to_int(x):
+            try:
+                return int(x)
+            except Exception:
+                return None
+
+        def _to_float(x):
+            try:
+                return float(x)
+            except Exception:
+                return None
+
+        # Task-specific filtering and shaping
+        if self.config.task in ("mutation_ddg", "mutation_binary", "mutation_lm"):
+            df_task = df[df["mutation"].notna()].copy()
+        elif self.config.task == "mutation_dtm":
+            df_task = df[df["mutation"].notna()].copy()
+        elif self.config.task == "protein_landscape":
+            df_task = df[df["mutation"].notna()].copy()
+        else:
+            df_task = df.copy()
+
+        # Apply label availability filters
+        if self.config.task == "mutation_ddg":
+            df_task = df_task[df_task["ddg"].notna()]
+        elif self.config.task == "mutation_dtm":
+            df_task = df_task[df_task["dtm"].notna()]
+        elif self.config.task == "mutation_binary":
+            df_task = df_task[df_task["stabilizing"].notna()]
+        elif self.config.task == "mutation_lm":
+            # Needs position and mut_residue for target_aa
+            df_task = df_task[df_task["position"].notna() & df_task["mut_residue"].notna()]
+
+        # Assign protein-level split deterministically
+        def protein_split(row) -> str:
+            return _split_by_protein(
+                uniprot=str(row.get("uniprotkb") or "").strip() or None,
+                sequence_id=str(row.get("sequence_id") or "").strip() or None,
+            )
+
+        df_task["split_name"] = df_task.apply(protein_split, axis=1)
+        df_task = df_task[df_task["split_name"] == wanted_split]
+
+        if self.config.task == "protein_landscape":
+            # Aggregate into one row per protein_key (uniprot preferred)
+            def protein_key(row) -> str:
+                u = str(row.get("uniprotkb") or "").strip()
+                if u:
+                    return u
+                sid = str(row.get("sequence_id") or "").strip()
+                return f"seqid:{sid}" if sid else "unknown"
+
+            df_task["protein_key"] = df_task.apply(protein_key, axis=1)
+
+            grouped = df_task.groupby("protein_key", dropna=False)
+
+            idx = 0
+            for pk, g in grouped:
+                # Representative metadata
+                first = g.iloc[0]
+                record = {
+                    "protein_key": str(pk),
+                    "uniprotkb": str(first.get("uniprotkb") or ""),
+                    "sequence_id": str(first.get("sequence_id") or ""),
+                    "protein_name": str(first.get("protein_name") or ""),
+                    "organism": str(first.get("organism") or ""),
+                    "sequence_length": _to_int(first.get("sequence_length")) or 0,
+                    "variants": [],
+                    "split": wanted_split,
+                }
+                for _, r in g.iterrows():
+                    record["variants"].append(
+                        {
+                            "experiment_id": str(r.get("experiment_id") or ""),
+                            "mutation": str(r.get("mutation") or ""),
+                            "position": _to_int(r.get("position")) or -1,
+                            "wt_residue": str(r.get("wt_residue") or ""),
+                            "mut_residue": str(r.get("mut_residue") or ""),
+                            "ddg": _to_float(r.get("ddg")),
+                            "dtm": _to_float(r.get("dtm")),
+                            "ph": _to_float(r.get("ph")),
+                            "buffer": str(r.get("buffer_norm") or r.get("buffer_raw") or ""),
+                            "method": str(r.get("method_norm") or ""),
+							"pdb_id": str(r.get("pdb_id") or ""),
+							"pdb_ids": list(r.get("pdb_ids") or []),
+                        }
+                    )
+                yield idx, record
+                idx += 1
+            return
+
+        # Mutation LM view
+        if self.config.task == "mutation_lm":
+            for i, r in df_task.reset_index(drop=True).iterrows():
+                yield i, {
+                    "experiment_id": str(r.get("experiment_id") or ""),
+                    "sequence_id": str(r.get("sequence_id") or ""),
+                    "uniprotkb": str(r.get("uniprotkb") or ""),
+                    "sequence": "",  # left blank unless you join real sequences elsewhere
+                    "mutation": str(r.get("mutation") or ""),
+                    "position": _to_int(r.get("position")) or -1,
+                    "target_aa": str(r.get("mut_residue") or ""),
+                    "split": wanted_split,
+                }
+            return
+
+        # Standard mutation-level views
+        for i, r in df_task.reset_index(drop=True).iterrows():
+            yield i, {
+                "experiment_id": str(r.get("experiment_id") or ""),
+                "sequence_id": str(r.get("sequence_id") or ""),
+                "uniprotkb": str(r.get("uniprotkb") or ""),
+                "protein_name": str(r.get("protein_name") or ""),
+                "organism": str(r.get("organism") or ""),
+                "sequence_length": _to_int(r.get("sequence_length")) or 0,
+                "mutation": str(r.get("mutation") or ""),
+                "wt_residue": str(r.get("wt_residue") or ""),
+                "position": _to_int(r.get("position")) or -1,
+                "mut_residue": str(r.get("mut_residue") or ""),
+                "ddg": _to_float(r.get("ddg")),
+                "dtm": _to_float(r.get("dtm")),
+                "tm": _to_float(r.get("tm")),
+                "ph": _to_float(r.get("ph")),
+                "buffer": str(r.get("buffer_norm") or r.get("buffer_raw") or ""),
+                "method": str(r.get("method_norm") or ""),
+                "measure": str(r.get("measure_norm") or ""),
+                "pmid": str(r.get("pmid") or ""),
+                "doi": str(r.get("doi") or ""),
+				"pdb_id": str(r.get("pdb_id") or ""),
+				"pdb_ids": list(r.get("pdb_ids") or []),
+                "publication_year": int(r.get("publication_year")) if str(r.get("publication_year") or "").isdigit() else 0,
+                "split": wanted_split,
+            }