scripts/prepare_pdb_dataset.py

#!/usr/bin/env python3
"""Build viewer-friendly Parquet splits for LiteFold/PDB."""

from __future__ import annotations

import argparse
import hashlib
import json
import re
from datetime import date, datetime
from pathlib import Path

import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq
from huggingface_hub import HfApi


ENTRY_COLUMNS = [
    "pdb_id",
    "classification",
    "accession_date",
    "title",
    "source_organism",
    "authors",
    "raw_resolution",
    "experimental_method",
]


def load_hf_token(env_path: Path) -> str | None:
    if not env_path.exists():
        return None
    for line in env_path.read_text(encoding="utf-8").splitlines():
        line = line.strip()
        if not line or line.startswith("#") or "=" not in line:
            continue
        key, value = line.split("=", 1)
        if key.strip() in {"HF_TOKEN", "HUGGINGFACE_HUB_TOKEN"}:
            return value.strip().strip('"').strip("'")
    return None


def parse_accession_date(value: str, current_year: int) -> str | None:
    value = (value or "").strip()
    if not value:
        return None
    try:
        month, day, year = [int(part) for part in value.split("/")]
    except ValueError:
        return None

    current_two_digit_year = current_year % 100
    full_year = 2000 + year if year <= current_two_digit_year else 1900 + year
    try:
        return date(full_year, month, day).isoformat()
    except ValueError:
        return None


def parse_entries_idx(path: Path) -> pd.DataFrame:
    rows = []
    current_year = datetime.utcnow().year
    with path.open("r", encoding="utf-8", errors="replace") as handle:
        for line_number, line in enumerate(handle, start=1):
            line = line.rstrip("\n")
            if line_number <= 2 or not line:
                continue
            parts = line.split("\t")
            if len(parts) < len(ENTRY_COLUMNS):
                parts = parts + [""] * (len(ENTRY_COLUMNS) - len(parts))
            elif len(parts) > len(ENTRY_COLUMNS):
                parts = parts[: len(ENTRY_COLUMNS) - 1] + [" ".join(parts[len(ENTRY_COLUMNS) - 1 :])]
            rows.append(dict(zip(ENTRY_COLUMNS, parts)))

    df = pd.DataFrame.from_records(rows)
    df["pdb_id"] = df["pdb_id"].str.lower()
    df["accession_date_iso"] = df["accession_date"].map(
        lambda value: parse_accession_date(value, current_year)
    )
    df["resolution_angstrom"] = pd.to_numeric(df["raw_resolution"], errors="coerce")
    df["resolution_is_unknown"] = df["resolution_angstrom"].isna()
    for column in ["classification", "title", "source_organism", "authors", "experimental_method"]:
        df[column] = df[column].fillna("").str.strip()
    return df


def mmcif_rows_from_hub(repo_id: str, token: str | None) -> pd.DataFrame:
    api = HfApi(token=token)
    info = api.dataset_info(repo_id, files_metadata=True)
    records = []
    for sibling in info.siblings or []:
        path = sibling.rfilename
        if not path.startswith("mmcif/") or not path.endswith(".cif.gz"):
            continue
        filename = Path(path).name
        pdb_id = filename.removesuffix(".cif.gz").lower()
        records.append(
            {
                "pdb_id": pdb_id,
                "mmcif_path": path,
                "mmcif_file_size_bytes": int(sibling.size) if sibling.size is not None else None,
                "mmcif_blob_id": sibling.blob_id,
            }
        )
    return pd.DataFrame.from_records(records)


def stable_bucket(value: str, buckets: int = 10) -> int:
    digest = hashlib.sha256(value.encode("utf-8")).hexdigest()[:16]
    return int(digest, 16) % buckets


def write_parquet(df: pd.DataFrame, path: Path) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    table = pa.Table.from_pandas(df, preserve_index=False)
    pq.write_table(table, path, compression="zstd")


def build_dataset(raw_dir: Path, out_dir: Path, repo_id: str, token: str | None) -> dict:
    entries = parse_entries_idx(raw_dir / "entries.idx")
    mmcif = mmcif_rows_from_hub(repo_id, token)
    if mmcif.empty:
        raise RuntimeError(f"No mmCIF files found in {repo_id}")

    df = mmcif.merge(entries, on="pdb_id", how="left", validate="one_to_one")
    df["has_entries_idx_metadata"] = df["title"].notna()
    for column in ["classification", "accession_date", "accession_date_iso", "title", "source_organism", "authors", "raw_resolution", "experimental_method"]:
        df[column] = df[column].fillna("")
    df["resolution_angstrom"] = df["resolution_angstrom"].astype("Float64")
    df["resolution_is_unknown"] = df["resolution_angstrom"].isna()
    df["pdb_url"] = "https://www.rcsb.org/structure/" + df["pdb_id"].str.upper()
    df["rcsb_download_url"] = "https://files.rcsb.org/download/" + df["pdb_id"] + ".cif.gz"
    df["split_bucket"] = df["pdb_id"].map(stable_bucket).astype("int64")
    df["split"] = df["split_bucket"].map(lambda bucket: "test" if bucket == 0 else "train")

    ordered_columns = [
        "pdb_id",
        "mmcif_path",
        "mmcif_file_size_bytes",
        "mmcif_blob_id",
        "pdb_url",
        "rcsb_download_url",
        "classification",
        "accession_date",
        "accession_date_iso",
        "title",
        "source_organism",
        "authors",
        "raw_resolution",
        "resolution_angstrom",
        "resolution_is_unknown",
        "experimental_method",
        "has_entries_idx_metadata",
        "split_bucket",
    ]
    df = df[ordered_columns + ["split"]].sort_values(["split", "pdb_id"], kind="mergesort")

    data_dir = out_dir / "data"
    for split in ["train", "test"]:
        split_df = df[df["split"].eq(split)].drop(columns=["split"])
        write_parquet(split_df, data_dir / f"{split}-00000-of-00001.parquet")

    metadata_dir = out_dir / "metadata"
    write_parquet(entries.sort_values("pdb_id", kind="mergesort"), metadata_dir / "entries_idx.parquet")

    method_counts = (
        df["experimental_method"].replace("", "UNKNOWN").value_counts().head(20).to_dict()
    )
    class_counts = df["classification"].replace("", "UNKNOWN").value_counts().head(20).to_dict()
    summary = {
        "source": repo_id,
        "full_entries_idx_rows": int(len(entries)),
        "mmcif_rows_in_repo": int(len(df)),
        "metadata_joined_rows": int(df["has_entries_idx_metadata"].sum()),
        "splits": {
            "train": int(df["split"].eq("train").sum()),
            "test": int(df["split"].eq("test").sum()),
        },
        "split_strategy": "deterministic sha256(pdb_id) % 10; bucket 0 is test, buckets 1-9 are train",
        "total_mmcif_size_bytes": int(df["mmcif_file_size_bytes"].fillna(0).sum()),
        "resolution": {
            "known_rows": int(df["resolution_angstrom"].notna().sum()),
            "unknown_rows": int(df["resolution_angstrom"].isna().sum()),
            "min": float(df["resolution_angstrom"].min(skipna=True)),
            "median": float(df["resolution_angstrom"].median(skipna=True)),
            "mean": float(df["resolution_angstrom"].mean(skipna=True)),
            "max": float(df["resolution_angstrom"].max(skipna=True)),
        },
        "top_experimental_methods": method_counts,
        "top_classifications": class_counts,
        "columns": ordered_columns,
    }
    (out_dir / "dataset_summary.json").write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")
    return summary


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--raw-dir", type=Path, default=Path("LiteFold_PDB_raw"))
    parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_PDB_processed"))
    parser.add_argument("--repo-id", default="LiteFold/PDB")
    parser.add_argument("--env-file", type=Path, default=Path(".env"))
    args = parser.parse_args()

    summary = build_dataset(args.raw_dir, args.out_dir, args.repo_id, load_hf_token(args.env_file))
    print(json.dumps(summary, indent=2))


if __name__ == "__main__":
    main()