Add normalized Parquet train/test SwissSidechain table

README.md

@@ -0,0 +1,206 @@
+---
+pretty_name: SwissSidechain Residues
+license: other
+tags:
+- biology
+- chemistry
+- protein
+- amino-acids
+- sidechains
+- molecular-dynamics
+- smiles
+- pdb
+- mol2
+- parquet
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*.parquet
+  - split: test
+    path: data/test-*.parquet
+---
+
+# SwissSidechain Residues
+
+This dataset contains a viewer-friendly Parquet table derived from the SwissSidechain archives in this repository. Each row is one unique residue entry from the L or D SMI archives, with parsed availability and summary fields for PDB, MOL2, CHARMM topology, GROMACS RTP/HDB, bundle files, and rotamer libraries.
+
+The original ZIP archives remain in the repository. The default `datasets` configuration uses the normalized Parquet files under `data/` so that the Hugging Face Dataset Viewer and `load_dataset()` can read the residue table directly.
+
+The source library comments state that the SwissSidechain entries are copyright of the Swiss Institute of Bioinformatics, with non-profit use allowed when the content is not modified and the copyright statement is retained. Commercial use requires a license agreement. Check the original SwissSidechain terms before commercial use.
+
+## Splits
+
+The split is deterministic by entry identifier: `sha256(entry_id) % 10`. Bucket `0` is `test`; buckets `1` through `9` are `train`.
+
+| Split | Rows |
+|---|---:|
+| train | 400 |
+| test | 59 |
+| total | 459 |
+
+## Dataset Statistics
+
+| Field | Value |
+|---|---:|
+| Unique residue entries | 459 |
+| L entries | 230 |
+| D entries | 229 |
+| Entries with PDB | 459 |
+| Entries with MOL2 | 459 |
+| Entries with CHARMM topologies | 437 |
+| Entries with GROMACS RTP/HDB | 437 |
+| Entries with source bundles | 459 |
+| Entries with backbone-dependent rotamers | 454 |
+| Entries with backbone-independent rotamers | 453 |
+| Backbone-dependent rotamer rows | 15,256,136 |
+| Backbone-independent rotamer rows | 11,144 |
+
+## Usage
+
+Install the Hugging Face Datasets library:
+
+```bash
+pip install datasets
+```
+
+Load all splits:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/SwissSidechain")
+print(ds)
+
+row = ds["train"][0]
+print(row["entry_id"], row["residue_code"], row["smiles"])
+```
+
+Load one split:
+
+```python
+from datasets import load_dataset
+
+train = load_dataset("LiteFold/SwissSidechain", split="train")
+test = load_dataset("LiteFold/SwissSidechain", split="test")
+```
+
+Stream rows without downloading the full table first:
+
+```python
+from datasets import load_dataset
+
+stream = load_dataset("LiteFold/SwissSidechain", split="train", streaming=True)
+for row in stream.take(5):
+    print(row["entry_id"], row["stereochemistry"], row["pdb_atom_count"])
+```
+
+Filter D residues with complete topology files:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/SwissSidechain", split="train")
+d_topologies = ds.filter(
+    lambda row: row["stereochemistry"] == "D"
+    and row["has_top"]
+    and row["has_rtp"]
+    and row["has_hdb"]
+)
+print(d_topologies[0])
+```
+
+Find entries with rotamer data:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/SwissSidechain", split="train")
+with_rotamers = ds.filter(lambda row: row["bbdep_rotamer_rows"] > 0)
+print(with_rotamers[0]["entry_id"], with_rotamers[0]["bbdep_rotamer_rows"])
+```
+
+Load metadata tables directly:
+
+```python
+import pandas as pd
+from huggingface_hub import hf_hub_download
+
+rotamer_path = hf_hub_download(
+    repo_id="LiteFold/SwissSidechain",
+    repo_type="dataset",
+    filename="metadata/rotamer_library_counts.parquet",
+)
+rotamers = pd.read_parquet(rotamer_path)
+print(rotamers.head())
+
+manifest_path = hf_hub_download(
+    repo_id="LiteFold/SwissSidechain",
+    repo_type="dataset",
+    filename="metadata/archive_manifest.parquet",
+)
+manifest = pd.read_parquet(manifest_path)
+print(manifest)
+```
+
+## Columns
+
+| Column | Description |
+|---|---|
+| `entry_id` | Stable table ID in the form `L:<code>` or `D:<code>`. |
+| `residue_code` | Residue code from the source file names. |
+| `stereochemistry` | Source stereochemistry group: `L` or `D`. |
+| `smiles` | SMILES string from the SMI archive. |
+| `smiles_reference_file` | Filename referenced inside the SMI row. |
+| `source_*_path` | Source archive path used for each parsed format. |
+| `has_smi` | Whether an SMI file exists. |
+| `has_pdb` | Whether a PDB file exists. |
+| `has_mol2` | Whether a MOL2 file exists. |
+| `has_top` | Whether a CHARMM `.top` file exists. |
+| `has_rtp` | Whether a GROMACS `.rtp` file exists. |
+| `has_hdb` | Whether a GROMACS `.hdb` file exists. |
+| `has_bundle` | Whether the entry appears in `L_sidechain.zip` or `D_residues.zip`. |
+| `has_png` | Whether the source bundle contains a PNG image. |
+| `has_bundle_bbdep_lib` | Whether the source bundle contains a per-entry backbone-dependent rotamer ZIP. |
+| `has_bundle_bbind_lib` | Whether the source bundle contains a per-entry backbone-independent rotamer ZIP. |
+| `bundle_file_extensions` | File extensions found in the source bundle. |
+| `pdb_residue_names` | Residue names parsed from PDB records. |
+| `pdb_atom_names` | Atom names parsed from PDB records. |
+| `pdb_elements` | Element symbols parsed from PDB records. |
+| `pdb_atom_count` | Number of PDB atoms. |
+| `pdb_heavy_atom_count` | Number of non-hydrogen PDB atoms. |
+| `pdb_hydrogen_atom_count` | Number of hydrogen PDB atoms. |
+| `mol2_molecule_name` | Molecule name from the MOL2 file. |
+| `mol2_molecule_type` | MOL2 molecule type. |
+| `mol2_charge_type` | MOL2 charge type. |
+| `mol2_atom_names` | Atom names parsed from MOL2. |
+| `mol2_atom_types` | Atom types parsed from MOL2. |
+| `mol2_atom_charges` | Partial charges parsed from MOL2. |
+| `mol2_atom_count` | Number of MOL2 atoms. |
+| `mol2_bond_count` | Number of MOL2 bonds. |
+| `mol2_total_partial_charge` | Sum of MOL2 partial charges. |
+| `charmm_residue_name` | Residue name parsed from CHARMM `RESI`. |
+| `charmm_residue_charge` | Residue charge parsed from CHARMM `RESI`. |
+| `charmm_residue_comment` | Comment attached to the CHARMM `RESI` line. |
+| `charmm_atom_names` | Atom names from CHARMM topology. |
+| `charmm_atom_types` | Atom types from CHARMM topology. |
+| `charmm_atom_charges` | Atom charges from CHARMM topology. |
+| `charmm_atom_count` | Number of CHARMM atoms. |
+| `charmm_bond_count` | Number of CHARMM bond pairs. |
+| `gromacs_residue_name` | Residue name from GROMACS RTP. |
+| `gromacs_residue_comment` | Comment attached to the GROMACS residue header. |
+| `gromacs_atom_names` | Atom names from GROMACS RTP. |
+| `gromacs_atom_types` | Atom types from GROMACS RTP. |
+| `gromacs_atom_charges` | Atom charges from GROMACS RTP. |
+| `gromacs_atom_count` | Number of GROMACS RTP atoms. |
+| `gromacs_bond_count` | Number of GROMACS RTP bonds. |
+| `gromacs_improper_count` | Number of GROMACS RTP impropers. |
+| `hdb_rule_count` | Number of hydrogen database rules. |
+| `hdb_declared_rule_count` | Rule count declared in the HDB header. |
+| `bbind_rotamer_rows` | Rows in the backbone-independent rotamer library for this residue code. |
+| `bbdep_rotamer_rows` | Rows in the backbone-dependent rotamer library for this residue code. |
+| `split_bucket` | Deterministic split bucket from `sha256(entry_id) % 10`. |
+
+## Preparation
+
+The normalization script used to create the Parquet files is included at `scripts/prepare_swisssidechain_dataset.py`.

data/test-00000-of-00001.parquet

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

data/train-00000-of-00001.parquet

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

dataset_summary.json

@@ -0,0 +1,103 @@
+{
+  "source": "LiteFold/SwissSidechain",
+  "entry_rows": 459,
+  "splits": {
+    "train": 400,
+    "test": 59
+  },
+  "split_strategy": "deterministic sha256(entry_id) % 10; bucket 0 is test, buckets 1-9 are train",
+  "stereochemistry_counts": {
+    "L": 230,
+    "D": 229
+  },
+  "entries_with_pdb": 459,
+  "entries_with_mol2": 459,
+  "entries_with_top": 437,
+  "entries_with_rtp": 437,
+  "entries_with_hdb": 437,
+  "entries_with_bundle": 459,
+  "entries_with_bbdep_rotamers": 454,
+  "entries_with_bbind_rotamers": 453,
+  "total_bbdep_rotamer_rows": 15256136,
+  "total_bbind_rotamer_rows": 11144,
+  "archive_manifest_rows": 12,
+  "rotamer_library_count_rows": 907,
+  "columns": [
+    "entry_id",
+    "residue_code",
+    "stereochemistry",
+    "smiles",
+    "smiles_reference_file",
+    "source_smi_path",
+    "source_pdb_path",
+    "source_mol2_path",
+    "source_top_path",
+    "source_rtp_path",
+    "source_hdb_path",
+    "has_smi",
+    "has_pdb",
+    "has_mol2",
+    "has_top",
+    "has_rtp",
+    "has_hdb",
+    "has_bundle",
+    "has_png",
+    "has_bundle_bbdep_lib",
+    "has_bundle_bbind_lib",
+    "bundle_file_extensions",
+    "pdb_residue_names",
+    "pdb_atom_names",
+    "pdb_elements",
+    "pdb_atom_count",
+    "pdb_heavy_atom_count",
+    "pdb_hydrogen_atom_count",
+    "mol2_molecule_name",
+    "mol2_molecule_type",
+    "mol2_charge_type",
+    "mol2_atom_names",
+    "mol2_atom_types",
+    "mol2_atom_charges",
+    "mol2_atom_count",
+    "mol2_bond_count",
+    "mol2_total_partial_charge",
+    "charmm_residue_name",
+    "charmm_residue_charge",
+    "charmm_residue_comment",
+    "charmm_atom_names",
+    "charmm_atom_types",
+    "charmm_atom_charges",
+    "charmm_atom_count",
+    "charmm_bond_count",
+    "gromacs_residue_name",
+    "gromacs_residue_comment",
+    "gromacs_atom_names",
+    "gromacs_atom_types",
+    "gromacs_atom_charges",
+    "gromacs_atom_count",
+    "gromacs_bond_count",
+    "gromacs_improper_count",
+    "hdb_rule_count",
+    "hdb_declared_rule_count",
+    "bbind_rotamer_rows",
+    "bbdep_rotamer_rows",
+    "split_bucket"
+  ],
+  "source_files_used": [
+    "D_MOL2.zip",
+    "D_PDB.zip",
+    "D_SMI.zip",
+    "D_bbdep_Gfeller.lib.zip",
+    "D_bbind_Gfeller.lib.zip",
+    "D_residues.zip",
+    "D_rtp.zip",
+    "D_top.zip",
+    "L_MOL2.zip",
+    "L_PDB.zip",
+    "L_SMI.zip",
+    "L_bbdep_Gfeller.lib.zip",
+    "L_bbind_Gfeller.lib.zip",
+    "L_rtp.zip",
+    "L_sidechain.zip",
+    "L_top.zip"
+  ]
+}

metadata/archive_manifest.parquet

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

metadata/rotamer_library_counts.parquet

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

scripts/prepare_swisssidechain_dataset.py

@@ -0,0 +1,519 @@
+#!/usr/bin/env python3
+"""Build viewer-friendly Parquet splits for LiteFold/SwissSidechain."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+import shutil
+import zipfile
+from collections import Counter, defaultdict
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+
+
+ENTRY_COLUMNS = [
+    "entry_id",
+    "residue_code",
+    "stereochemistry",
+    "smiles",
+    "smiles_reference_file",
+    "source_smi_path",
+    "source_pdb_path",
+    "source_mol2_path",
+    "source_top_path",
+    "source_rtp_path",
+    "source_hdb_path",
+    "has_smi",
+    "has_pdb",
+    "has_mol2",
+    "has_top",
+    "has_rtp",
+    "has_hdb",
+    "has_bundle",
+    "has_png",
+    "has_bundle_bbdep_lib",
+    "has_bundle_bbind_lib",
+    "bundle_file_extensions",
+    "pdb_residue_names",
+    "pdb_atom_names",
+    "pdb_elements",
+    "pdb_atom_count",
+    "pdb_heavy_atom_count",
+    "pdb_hydrogen_atom_count",
+    "mol2_molecule_name",
+    "mol2_molecule_type",
+    "mol2_charge_type",
+    "mol2_atom_names",
+    "mol2_atom_types",
+    "mol2_atom_charges",
+    "mol2_atom_count",
+    "mol2_bond_count",
+    "mol2_total_partial_charge",
+    "charmm_residue_name",
+    "charmm_residue_charge",
+    "charmm_residue_comment",
+    "charmm_atom_names",
+    "charmm_atom_types",
+    "charmm_atom_charges",
+    "charmm_atom_count",
+    "charmm_bond_count",
+    "gromacs_residue_name",
+    "gromacs_residue_comment",
+    "gromacs_atom_names",
+    "gromacs_atom_types",
+    "gromacs_atom_charges",
+    "gromacs_atom_count",
+    "gromacs_bond_count",
+    "gromacs_improper_count",
+    "hdb_rule_count",
+    "hdb_declared_rule_count",
+    "bbind_rotamer_rows",
+    "bbdep_rotamer_rows",
+    "split_bucket",
+]
+
+
+def stable_bucket(value: str, buckets: int = 10) -> int:
+    digest = hashlib.sha256(value.encode("utf-8")).hexdigest()[:16]
+    return int(digest, 16) % buckets
+
+
+def parse_float(value: str | None) -> float | None:
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except ValueError:
+        return None
+
+
+def is_canonical_zip_path(name: str, expected_prefix: str) -> bool:
+    parts = Path(name).parts
+    return len(parts) >= 2 and parts[0] == expected_prefix
+
+
+def read_zip_text_by_stem(path: Path, expected_prefix: str, suffixes: tuple[str, ...]) -> dict[str, dict[str, str]]:
+    items: dict[str, dict[str, str]] = {}
+    with zipfile.ZipFile(path) as zf:
+        for name in zf.namelist():
+            if name.endswith("/") or not name.lower().endswith(suffixes):
+                continue
+            stem = Path(name).stem
+            text = zf.read(name).decode("utf-8", errors="replace")
+            existing = items.get(stem)
+            if existing is None or (
+                is_canonical_zip_path(name, expected_prefix) and not is_canonical_zip_path(existing["path"], expected_prefix)
+            ):
+                items[stem] = {"path": name, "text": text}
+    return items
+
+
+def read_rtp_hdb_zip(path: Path, expected_prefix: str) -> tuple[dict[str, dict[str, str]], dict[str, dict[str, str]]]:
+    rtp: dict[str, dict[str, str]] = {}
+    hdb: dict[str, dict[str, str]] = {}
+    with zipfile.ZipFile(path) as zf:
+        for name in zf.namelist():
+            if name.endswith("/"):
+                continue
+            stem = Path(name).stem
+            suffix = Path(name).suffix.lower()
+            target = rtp if suffix == ".rtp" else hdb if suffix == ".hdb" else None
+            if target is None:
+                continue
+            text = zf.read(name).decode("utf-8", errors="replace")
+            existing = target.get(stem)
+            if existing is None or (
+                is_canonical_zip_path(name, expected_prefix) and not is_canonical_zip_path(existing["path"], expected_prefix)
+            ):
+                target[stem] = {"path": name, "text": text}
+    return rtp, hdb
+
+
+def parse_smi(text: str) -> tuple[str | None, str | None]:
+    for line in text.splitlines():
+        stripped = line.strip()
+        if not stripped:
+            continue
+        parts = stripped.split()
+        return parts[0], parts[1] if len(parts) > 1 else None
+    return None, None
+
+
+def parse_pdb(text: str) -> dict[str, Any]:
+    atom_names: list[str] = []
+    elements: list[str] = []
+    residue_names: set[str] = set()
+    for line in text.splitlines():
+        if not (line.startswith("ATOM") or line.startswith("HETATM")):
+            continue
+        atom_name = line[12:16].strip()
+        residue_name = line[17:20].strip()
+        element = line[76:78].strip() if len(line) >= 78 else ""
+        if not element:
+            element = re.sub(r"[^A-Za-z]", "", atom_name)[:1]
+        if atom_name:
+            atom_names.append(atom_name)
+        if residue_name:
+            residue_names.add(residue_name)
+        if element:
+            elements.append(element.upper())
+    return {
+        "pdb_residue_names": sorted(residue_names),
+        "pdb_atom_names": atom_names,
+        "pdb_elements": elements,
+        "pdb_atom_count": len(atom_names),
+        "pdb_heavy_atom_count": sum(1 for element in elements if element != "H"),
+        "pdb_hydrogen_atom_count": sum(1 for element in elements if element == "H"),
+    }
+
+
+def parse_mol2(text: str) -> dict[str, Any]:
+    section: str | None = None
+    molecule_lines: list[str] = []
+    atom_names: list[str] = []
+    atom_types: list[str] = []
+    charges: list[float] = []
+    bond_count = 0
+    for raw in text.splitlines():
+        line = raw.rstrip()
+        if line.startswith("@<TRIPOS>"):
+            section = line.removeprefix("@<TRIPOS>").strip()
+            continue
+        if not line.strip():
+            continue
+        if section == "MOLECULE":
+            molecule_lines.append(line.strip())
+        elif section == "ATOM":
+            parts = line.split()
+            if len(parts) >= 6:
+                atom_names.append(parts[1])
+                atom_types.append(parts[5])
+                if len(parts) >= 9:
+                    charge = parse_float(parts[8])
+                    if charge is not None:
+                        charges.append(charge)
+        elif section == "BOND":
+            parts = line.split()
+            if len(parts) >= 4:
+                bond_count += 1
+
+    counts = molecule_lines[1].split() if len(molecule_lines) > 1 else []
+    declared_bonds = int(counts[1]) if len(counts) > 1 and counts[1].isdigit() else bond_count
+    return {
+        "mol2_molecule_name": molecule_lines[0] if molecule_lines else None,
+        "mol2_molecule_type": molecule_lines[2] if len(molecule_lines) > 2 else None,
+        "mol2_charge_type": molecule_lines[3] if len(molecule_lines) > 3 else None,
+        "mol2_atom_names": atom_names,
+        "mol2_atom_types": atom_types,
+        "mol2_atom_charges": charges,
+        "mol2_atom_count": len(atom_names),
+        "mol2_bond_count": declared_bonds,
+        "mol2_total_partial_charge": round(sum(charges), 6) if charges else None,
+    }
+
+
+def parse_charmm_top(text: str) -> dict[str, Any]:
+    residue_name = None
+    residue_charge = None
+    residue_comment = None
+    atom_names: list[str] = []
+    atom_types: list[str] = []
+    atom_charges: list[float] = []
+    bond_count = 0
+    for raw in text.splitlines():
+        line = raw.strip()
+        if not line or line.startswith("!"):
+            continue
+        data, _, comment = line.partition("!")
+        parts = data.split()
+        if not parts:
+            continue
+        keyword = parts[0].upper()
+        if keyword == "RESI" and len(parts) >= 3:
+            residue_name = parts[1]
+            residue_charge = parse_float(parts[2])
+            residue_comment = comment.strip() or None
+        elif keyword == "ATOM" and len(parts) >= 4:
+            atom_names.append(parts[1])
+            atom_types.append(parts[2])
+            charge = parse_float(parts[3])
+            if charge is not None:
+                atom_charges.append(charge)
+        elif keyword in {"BOND", "DOUBLE"}:
+            bond_count += len(parts[1:]) // 2
+    return {
+        "charmm_residue_name": residue_name,
+        "charmm_residue_charge": residue_charge,
+        "charmm_residue_comment": residue_comment,
+        "charmm_atom_names": atom_names,
+        "charmm_atom_types": atom_types,
+        "charmm_atom_charges": atom_charges,
+        "charmm_atom_count": len(atom_names),
+        "charmm_bond_count": bond_count,
+    }
+
+
+def parse_gromacs_rtp(text: str) -> dict[str, Any]:
+    residue_name = None
+    residue_comment = None
+    section = None
+    atom_names: list[str] = []
+    atom_types: list[str] = []
+    atom_charges: list[float] = []
+    bond_count = 0
+    improper_count = 0
+    for raw in text.splitlines():
+        line = raw.strip()
+        if not line or line.startswith(";"):
+            continue
+        data, _, comment = line.partition(";")
+        data = data.strip()
+        if data.startswith("[") and data.endswith("]"):
+            label = data.strip("[]").strip()
+            if residue_name is None and label not in {"atoms", "bonds", "impropers", "cmap"}:
+                residue_name = label
+                residue_comment = comment.strip() or None
+                section = None
+            else:
+                section = label.lower()
+            continue
+        parts = data.split()
+        if section == "atoms" and len(parts) >= 3:
+            atom_names.append(parts[0])
+            atom_types.append(parts[1])
+            charge = parse_float(parts[2])
+            if charge is not None:
+                atom_charges.append(charge)
+        elif section == "bonds" and len(parts) >= 2:
+            bond_count += 1
+        elif section == "impropers" and len(parts) >= 4:
+            improper_count += 1
+    return {
+        "gromacs_residue_name": residue_name,
+        "gromacs_residue_comment": residue_comment,
+        "gromacs_atom_names": atom_names,
+        "gromacs_atom_types": atom_types,
+        "gromacs_atom_charges": atom_charges,
+        "gromacs_atom_count": len(atom_names),
+        "gromacs_bond_count": bond_count,
+        "gromacs_improper_count": improper_count,
+    }
+
+
+def parse_hdb(text: str) -> dict[str, Any]:
+    lines = [line.strip() for line in text.splitlines() if line.strip() and not line.strip().startswith(";")]
+    declared = None
+    if lines:
+        parts = lines[0].split()
+        if len(parts) >= 2:
+            try:
+                declared = int(parts[1])
+            except ValueError:
+                declared = None
+    return {
+        "hdb_rule_count": max(len(lines) - 1, 0),
+        "hdb_declared_rule_count": declared,
+    }
+
+
+def archive_bundle_manifest(path: Path, stereochemistry: str) -> dict[str, dict[str, Any]]:
+    manifest: dict[str, dict[str, Any]] = defaultdict(lambda: {"extensions": Counter(), "paths": []})
+    with zipfile.ZipFile(path) as zf:
+        for name in zf.namelist():
+            if name.endswith("/"):
+                continue
+            parts = Path(name).parts
+            if len(parts) < 2:
+                continue
+            residue_code = parts[-2]
+            suffix = Path(name).suffix.lower() or "<none>"
+            manifest[residue_code]["extensions"][suffix] += 1
+            manifest[residue_code]["paths"].append(name)
+    result = {}
+    for residue_code, item in manifest.items():
+        extensions = item["extensions"]
+        result[residue_code] = {
+            "bundle_file_extensions": sorted(extensions),
+            "has_png": extensions.get(".png", 0) > 0,
+            "has_bundle_bbdep_lib": any(path.endswith("_bbdep_Gfeller.lib.zip") for path in item["paths"]),
+            "has_bundle_bbind_lib": any(path.endswith("_bbind_Gfeller.lib.zip") for path in item["paths"]),
+            "stereochemistry": stereochemistry,
+        }
+    return result
+
+
+def parse_rotamer_counts(path: Path, stereochemistry: str, library_type: str) -> tuple[dict[str, int], list[dict[str, Any]]]:
+    counts: Counter[str] = Counter()
+    with zipfile.ZipFile(path) as zf:
+        name = next(n for n in zf.namelist() if n.endswith(".lib"))
+        with zf.open(name) as handle:
+            for raw in handle:
+                line = raw.decode("utf-8", errors="replace").strip()
+                if not line or line.startswith("#"):
+                    continue
+                counts[line.split()[0]] += 1
+    rows = [
+        {
+            "stereochemistry": stereochemistry,
+            "library_type": library_type,
+            "residue_code": residue_code,
+            "row_count": int(row_count),
+        }
+        for residue_code, row_count in sorted(counts.items())
+    ]
+    return dict(counts), rows
+
+
+def build_rows_for_stereo(raw_dir: Path, stereochemistry: str) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+    prefix = "L" if stereochemistry == "L" else "D"
+    smi = read_zip_text_by_stem(raw_dir / f"{prefix}_SMI.zip", f"{prefix}_SMI", (".smi",))
+    pdb = read_zip_text_by_stem(raw_dir / f"{prefix}_PDB.zip", f"{prefix}_PDB", (".pdb",))
+    mol2 = read_zip_text_by_stem(raw_dir / f"{prefix}_MOL2.zip", f"{prefix}_MOL2", (".mol2",))
+    top = read_zip_text_by_stem(raw_dir / f"{prefix}_top.zip", f"{prefix}_top", (".top",))
+    rtp, hdb = read_rtp_hdb_zip(raw_dir / f"{prefix}_rtp.zip", f"{prefix}_rtp")
+    bundle = archive_bundle_manifest(
+        raw_dir / ("L_sidechain.zip" if stereochemistry == "L" else "D_residues.zip"),
+        stereochemistry=stereochemistry,
+    )
+    bbind_counts, bbind_rows = parse_rotamer_counts(
+        raw_dir / f"{prefix}_bbind_Gfeller.lib.zip",
+        stereochemistry=stereochemistry,
+        library_type="bbind",
+    )
+    bbdep_counts, bbdep_rows = parse_rotamer_counts(
+        raw_dir / f"{prefix}_bbdep_Gfeller.lib.zip",
+        stereochemistry=stereochemistry,
+        library_type="bbdep",
+    )
+
+    rows: list[dict[str, Any]] = []
+    for residue_code in sorted(smi):
+        smiles, reference_file = parse_smi(smi[residue_code]["text"])
+        entry_id = f"{stereochemistry}:{residue_code}"
+        row = {
+            "entry_id": entry_id,
+            "residue_code": residue_code,
+            "stereochemistry": stereochemistry,
+            "smiles": smiles,
+            "smiles_reference_file": reference_file,
+            "source_smi_path": smi[residue_code]["path"],
+            "source_pdb_path": pdb.get(residue_code, {}).get("path"),
+            "source_mol2_path": mol2.get(residue_code, {}).get("path"),
+            "source_top_path": top.get(residue_code, {}).get("path"),
+            "source_rtp_path": rtp.get(residue_code, {}).get("path"),
+            "source_hdb_path": hdb.get(residue_code, {}).get("path"),
+            "has_smi": True,
+            "has_pdb": residue_code in pdb,
+            "has_mol2": residue_code in mol2,
+            "has_top": residue_code in top,
+            "has_rtp": residue_code in rtp,
+            "has_hdb": residue_code in hdb,
+            "has_bundle": residue_code in bundle,
+            "has_png": bool(bundle.get(residue_code, {}).get("has_png", False)),
+            "has_bundle_bbdep_lib": bool(bundle.get(residue_code, {}).get("has_bundle_bbdep_lib", False)),
+            "has_bundle_bbind_lib": bool(bundle.get(residue_code, {}).get("has_bundle_bbind_lib", False)),
+            "bundle_file_extensions": bundle.get(residue_code, {}).get("bundle_file_extensions", []),
+            "bbind_rotamer_rows": int(bbind_counts.get(residue_code, 0)),
+            "bbdep_rotamer_rows": int(bbdep_counts.get(residue_code, 0)),
+            "split_bucket": stable_bucket(entry_id),
+        }
+        row.update(parse_pdb(pdb[residue_code]["text"]) if residue_code in pdb else parse_pdb(""))
+        row.update(parse_mol2(mol2[residue_code]["text"]) if residue_code in mol2 else parse_mol2(""))
+        row.update(parse_charmm_top(top[residue_code]["text"]) if residue_code in top else parse_charmm_top(""))
+        row.update(parse_gromacs_rtp(rtp[residue_code]["text"]) if residue_code in rtp else parse_gromacs_rtp(""))
+        row.update(parse_hdb(hdb[residue_code]["text"]) if residue_code in hdb else parse_hdb(""))
+        rows.append(row)
+
+    manifest_rows = []
+    for label, mapping in [
+        ("SMI", smi),
+        ("PDB", pdb),
+        ("MOL2", mol2),
+        ("top", top),
+        ("rtp", rtp),
+        ("hdb", hdb),
+    ]:
+        manifest_rows.append(
+            {
+                "stereochemistry": stereochemistry,
+                "archive_kind": label,
+                "unique_residue_codes": len(mapping),
+                "residue_codes": sorted(mapping),
+            }
+        )
+    return rows, bbind_rows + bbdep_rows + manifest_rows
+
+
+def build_dataset(raw_dir: Path, out_dir: Path) -> dict[str, Any]:
+    l_rows, l_metadata = build_rows_for_stereo(raw_dir, "L")
+    d_rows, d_metadata = build_rows_for_stereo(raw_dir, "D")
+    rows = l_rows + d_rows
+
+    if out_dir.exists():
+        shutil.rmtree(out_dir)
+    data_dir = out_dir / "data"
+    metadata_dir = out_dir / "metadata"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    metadata_dir.mkdir(parents=True, exist_ok=True)
+
+    df = pd.DataFrame.from_records(rows, columns=ENTRY_COLUMNS)
+    df = df.sort_values(["split_bucket", "entry_id"], kind="mergesort")
+    train = df[df["split_bucket"].ne(0)].sort_values("entry_id", kind="mergesort")
+    test = df[df["split_bucket"].eq(0)].sort_values("entry_id", kind="mergesort")
+    train.to_parquet(data_dir / "train-00000-of-00001.parquet", index=False, compression="zstd")
+    test.to_parquet(data_dir / "test-00000-of-00001.parquet", index=False, compression="zstd")
+
+    rotamer_rows = [row for row in l_metadata + d_metadata if row.get("library_type")]
+    manifest_rows = [row for row in l_metadata + d_metadata if row.get("archive_kind")]
+    pd.DataFrame.from_records(rotamer_rows).to_parquet(
+        metadata_dir / "rotamer_library_counts.parquet", index=False, compression="zstd"
+    )
+    pd.DataFrame.from_records(manifest_rows).to_parquet(
+        metadata_dir / "archive_manifest.parquet", index=False, compression="zstd"
+    )
+
+    stereo_counts = df["stereochemistry"].value_counts().to_dict()
+    summary = {
+        "source": "LiteFold/SwissSidechain",
+        "entry_rows": int(len(df)),
+        "splits": {
+            "train": int(len(train)),
+            "test": int(len(test)),
+        },
+        "split_strategy": "deterministic sha256(entry_id) % 10; bucket 0 is test, buckets 1-9 are train",
+        "stereochemistry_counts": {str(k): int(v) for k, v in stereo_counts.items()},
+        "entries_with_pdb": int(df["has_pdb"].sum()),
+        "entries_with_mol2": int(df["has_mol2"].sum()),
+        "entries_with_top": int(df["has_top"].sum()),
+        "entries_with_rtp": int(df["has_rtp"].sum()),
+        "entries_with_hdb": int(df["has_hdb"].sum()),
+        "entries_with_bundle": int(df["has_bundle"].sum()),
+        "entries_with_bbdep_rotamers": int(df["bbdep_rotamer_rows"].gt(0).sum()),
+        "entries_with_bbind_rotamers": int(df["bbind_rotamer_rows"].gt(0).sum()),
+        "total_bbdep_rotamer_rows": int(df["bbdep_rotamer_rows"].sum()),
+        "total_bbind_rotamer_rows": int(df["bbind_rotamer_rows"].sum()),
+        "archive_manifest_rows": int(len(manifest_rows)),
+        "rotamer_library_count_rows": int(len(rotamer_rows)),
+        "columns": ENTRY_COLUMNS,
+        "source_files_used": sorted(path.name for path in raw_dir.glob("*.zip")),
+    }
+    (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_SwissSidechain_raw"))
+    parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_SwissSidechain_processed"))
+    args = parser.parse_args()
+    summary = build_dataset(args.raw_dir, args.out_dir)
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()