scripts/build_hf_release.py

"""Build the TRIP50 Hugging Face release artefacts under ../data/.

Reads from /Users/rpaton/TRIP50/production/:
  - trip50_reference_energies.csv   (DLPNO + 46 DFT totals, Hartree)
  - trip50_species_aliases.csv      (alias → canonical map)
  - xyz_corrected/*.xyz             (156 standard XYZ files; comment line = multiplicity)

Writes to ../data/:
  - trip50.extxyz        : 156 frames, ASE-readable, all energies in info dict
  - species.parquet      : per-species table with atomic_numbers/positions/energies
  - reactions.parquet    : 50 rxn rows, alias-resolved species ids + reference Δs (kcal/mol)
  - aliases.parquet      : alias map mirrored as parquet (CSV is also copied)
  - aliases.csv          : verbatim copy of source alias table
  - methods.json         : slug ↔ display-name mapping for the 46 DFT columns
  - MANIFEST.sha256      : SHA-256 of every payload file (deterministic check)

The build is deterministic: sorted iteration, no timestamps in any payload.
"""

from __future__ import annotations

import hashlib
import json
import shutil
from pathlib import Path

import numpy as np
import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq
from ase import Atoms
from ase.io import write as ase_write

from trip50_core import (
    HARTREE_TO_KCAL,
    ROLES,
    lookup,
    reaction_quantities,
    slugify_method,
)

SRC = Path("/Users/rpaton/TRIP50/production")
OUT = Path(__file__).resolve().parent.parent / "data"
XYZ_DIR = SRC / "xyz_corrected"

REF_CSV = SRC / "trip50_reference_energies.csv"
ALIAS_CSV = SRC / "trip50_species_aliases.csv"

MULT_TO_INT = {"singlet": 1, "doublet": 2, "triplet": 3}

# Reaction categories from Figure 2 of Hughes, Popescu, Paton, JCTC 2026, 22, 3530.
RXN_CATEGORIES = (
    ("C-C",   range(1, 13)),
    ("C-O",   range(13, 18)),
    ("C-S",   range(18, 22)),
    ("HAT",   range(22, 31)),
    ("Si-X",  range(31, 38)),
    ("C-Hal", range(38, 42)),
    ("N-X",   range(42, 51)),
)
RXN_CATEGORY = {r: name for name, rng in RXN_CATEGORIES for r in rng}
assert set(RXN_CATEGORY) == set(range(1, 51)), "category ranges must tile 1..50 exactly"


def parse_xyz(path: Path) -> tuple[Atoms, str]:
    """Parse a TRIP50 standard-XYZ file. Returns (Atoms, multiplicity_label)."""
    lines = path.read_text().splitlines()
    n = int(lines[0].strip())
    mult = lines[1].strip()
    symbols, coords = [], []
    for line in lines[2:2 + n]:
        parts = line.split()
        symbols.append(parts[0])
        coords.append([float(x) for x in parts[1:4]])
    atoms = Atoms(symbols=symbols, positions=np.asarray(coords, dtype=np.float64))
    return atoms, mult


def species_id_from_filename(path: Path) -> str:
    return path.stem  # e.g. "1-R1.xyz" → "1-R1"


def split_rxn_role(species_id: str) -> tuple[int, str]:
    rxn_str, role = species_id.split("-", 1)
    return int(rxn_str), role


def build():
    OUT.mkdir(parents=True, exist_ok=True)

    # -------------------- inputs --------------------
    ref = pd.read_csv(REF_CSV).set_index("Species")
    aliases_df = pd.read_csv(ALIAS_CSV)
    alias_map = dict(zip(aliases_df["alias"], aliases_df["canonical"]))
    dlpno_col = "DLPNO-CCSD(T)"

    # Method display names → slugs (DLPNO + 46 DFT)
    method_columns = list(ref.columns)
    slug_map = {col: ("energy_dlpno_ccsd_t" if col == dlpno_col
                      else f"energy_{slugify_method(col)}")
                for col in method_columns}
    # Verify uniqueness
    if len(set(slug_map.values())) != len(slug_map):
        dupes = [s for s in slug_map.values() if list(slug_map.values()).count(s) > 1]
        raise RuntimeError(f"Slug collision: {set(dupes)}")

    methods_meta = {
        "energy_columns": [
            {"slug": slug_map[col], "display_name": col,
             "is_reference": col == dlpno_col,
             "units": "hartree"}
            for col in method_columns
        ],
    }
    (OUT / "methods.json").write_text(json.dumps(methods_meta, indent=2) + "\n")

    # -------------------- structures + per-species rows --------------------
    xyz_paths = sorted(XYZ_DIR.glob("*.xyz"),
                       key=lambda p: split_rxn_role(p.stem))

    species_rows = []
    frames: list[Atoms] = []

    for xyz_path in xyz_paths:
        species_id = species_id_from_filename(xyz_path)
        atoms, mult_label = parse_xyz(xyz_path)
        rxn_id, role = split_rxn_role(species_id)

        if mult_label not in MULT_TO_INT:
            raise ValueError(f"Unknown multiplicity {mult_label!r} in {xyz_path}")
        spin_mult = MULT_TO_INT[mult_label]

        # Pull every method's total energy for this species (alias-resolved)
        per_method = {}
        for col in method_columns:
            val = lookup(species_id, ref[col], alias_map)
            if val is None:
                raise RuntimeError(f"Missing {col} energy for {species_id}")
            per_method[slug_map[col]] = float(val)

        # Frame info dict — ASE will serialise this onto the comment line
        info = {
            "species_id": species_id,
            "rxn": rxn_id,
            "role": role,
            "multiplicity": mult_label,
            "spin_multiplicity": spin_mult,
            "charge": 0,
            "units_energy": "hartree",
            **per_method,
        }
        atoms.info.update(info)
        frames.append(atoms)

        species_rows.append({
            "species_id": species_id,
            "rxn_id": rxn_id,
            "role": role,
            "n_atoms": len(atoms),
            "atomic_numbers": atoms.numbers.tolist(),
            "positions": atoms.positions.tolist(),
            "charge": 0,
            "multiplicity": mult_label,
            "spin_multiplicity": spin_mult,
            **per_method,
        })

    # -------------------- write extxyz --------------------
    extxyz_path = OUT / "trip50.extxyz"
    ase_write(extxyz_path, frames, format="extxyz")

    # -------------------- write species.parquet --------------------
    species_df = pd.DataFrame(species_rows)
    species_schema = pa.schema([
        ("species_id", pa.string()),
        ("rxn_id", pa.int32()),
        ("role", pa.string()),
        ("n_atoms", pa.int32()),
        ("atomic_numbers", pa.list_(pa.int8())),
        ("positions", pa.list_(pa.list_(pa.float64(), 3))),
        ("charge", pa.int8()),
        ("multiplicity", pa.string()),
        ("spin_multiplicity", pa.int8()),
        *[(slug_map[col], pa.float64()) for col in method_columns],
    ])
    species_table = pa.Table.from_pandas(species_df, schema=species_schema, preserve_index=False)
    pq.write_table(species_table, OUT / "species.parquet", compression="zstd")

    # -------------------- reactions.parquet --------------------
    dlpno_series = ref[dlpno_col]
    dE_rxn, dE_fwd, dE_rev = reaction_quantities(dlpno_series, dlpno_series, alias_map)

    reaction_rows = []
    for r in range(1, 51):
        present = {role: lookup(f"{r}-{role}", dlpno_series, alias_map) is not None
                   for role in ROLES}

        def canonical(role):
            sid = f"{r}-{role}"
            return alias_map.get(sid, sid) if present[role] else None

        reaction_rows.append({
            "rxn_id": r,
            "category": RXN_CATEGORY[r],
            "r1_species_id": canonical("R1"),
            "r2_species_id": canonical("R2"),
            "ts_species_id": canonical("TS"),
            "p1_species_id": canonical("P1"),
            "p2_species_id": canonical("P2"),
            "is_unimolecular_reactant": not present["R2"],
            "is_unimolecular_product": not present["P2"],
            "dE_rxn_kcal_dlpno": dE_rxn.get(r),
            "dE_fwd_kcal_dlpno": dE_fwd.get(r),
            "dE_rev_kcal_dlpno": dE_rev.get(r),
        })

    reactions_df = pd.DataFrame(reaction_rows)
    reactions_schema = pa.schema([
        ("rxn_id", pa.int32()),
        ("category", pa.string()),
        ("r1_species_id", pa.string()),
        ("r2_species_id", pa.string()),
        ("ts_species_id", pa.string()),
        ("p1_species_id", pa.string()),
        ("p2_species_id", pa.string()),
        ("is_unimolecular_reactant", pa.bool_()),
        ("is_unimolecular_product", pa.bool_()),
        ("dE_rxn_kcal_dlpno", pa.float64()),
        ("dE_fwd_kcal_dlpno", pa.float64()),
        ("dE_rev_kcal_dlpno", pa.float64()),
    ])
    reactions_table = pa.Table.from_pandas(reactions_df, schema=reactions_schema, preserve_index=False)
    pq.write_table(reactions_table, OUT / "reactions.parquet", compression="zstd")

    # -------------------- aliases --------------------
    shutil.copyfile(ALIAS_CSV, OUT / "aliases.csv")
    aliases_table = pa.Table.from_pandas(aliases_df, preserve_index=False)
    pq.write_table(aliases_table, OUT / "aliases.parquet", compression="zstd")

    # -------------------- MANIFEST --------------------
    payload = sorted([
        OUT / "trip50.extxyz",
        OUT / "species.parquet",
        OUT / "reactions.parquet",
        OUT / "aliases.parquet",
        OUT / "aliases.csv",
        OUT / "methods.json",
    ])
    manifest_lines = []
    for path in payload:
        digest = hashlib.sha256(path.read_bytes()).hexdigest()
        manifest_lines.append(f"{digest}  {path.name}")
    (OUT / "MANIFEST.sha256").write_text("\n".join(manifest_lines) + "\n")

    print(f"Wrote {len(species_df)} species frames, {len(reactions_df)} reactions to {OUT}")
    for path in payload + [OUT / "MANIFEST.sha256"]:
        size = path.stat().st_size
        print(f"  {path.name:30s} {size:>10,} B")


if __name__ == "__main__":
    build()