uploading dataset

.gitignore

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

README.md

@@ -1,3 +0,0 @@
----
-license: cc-by-4.0
----

src/01.1_process_csv.py

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

@@ -1,339 +0,0 @@
-# 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,
-            }