Add normalized Parquet train/test PDB CCD table

README.md

@@ -0,0 +1,181 @@
+---
+pretty_name: PDB Chemical Component Dictionary
+license: other
+tags:
+- biology
+- chemistry
+- structural-biology
+- pdb
+- chemical-components
+- mmcif
+- parquet
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*.parquet
+  - split: test
+    path: data/test-*.parquet
+---
+
+# PDB Chemical Component Dictionary
+
+This dataset contains a viewer-friendly Parquet table derived from the PDB Chemical Component Dictionary file in this repository. Each row is one chemical component from `components.cif.gz`.
+
+The original source file remains 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 component records directly.
+
+## Splits
+
+The split is deterministic by component identifier: `sha256(component_id) % 10`. Bucket `0` is `test`; buckets `1` through `9` are `train`.
+
+| Split | Rows |
+|---|---:|
+| train | 45,045 |
+| test | 5,009 |
+| total | 50,054 |
+
+## Dataset Statistics
+
+| Field | Value |
+|---|---:|
+| Components | 50,054 |
+| Released components | 49,292 |
+| Obsolete components | 762 |
+| Components with atoms | 49,947 |
+| Components with bonds | 49,921 |
+| Components with descriptors | 50,052 |
+| Components with identifiers | 37,058 |
+| Components with PCM annotations | 613 |
+| Latest modified date in source | `2026-04-24` |
+
+| Common component type | Rows |
+|---|---:|
+| NON-POLYMER | 26,117 |
+| non-polymer | 19,493 |
+| L-PEPTIDE LINKING | 923 |
+| L-peptide linking | 580 |
+| peptide-like | 556 |
+| D-saccharide | 405 |
+| DNA LINKING | 325 |
+| RNA LINKING | 223 |
+
+## Usage
+
+Install the Hugging Face Datasets library:
+
+```bash
+pip install datasets
+```
+
+Load all splits:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/PDB-CCD")
+print(ds)
+
+row = ds["train"][0]
+print(row["component_id"], row["name"], row["formula"])
+```
+
+Load one split:
+
+```python
+from datasets import load_dataset
+
+train = load_dataset("LiteFold/PDB-CCD", split="train")
+test = load_dataset("LiteFold/PDB-CCD", split="test")
+```
+
+Stream rows without downloading the full table first:
+
+```python
+from datasets import load_dataset
+
+stream = load_dataset("LiteFold/PDB-CCD", split="train", streaming=True)
+for row in stream.take(5):
+    print(row["component_id"], row["canonical_smiles"], row["atom_count"])
+```
+
+Filter released non-polymer components with InChIKeys:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/PDB-CCD", split="train")
+released = ds.filter(
+    lambda row: row["release_status"] == "REL"
+    and row["component_type"] in {"NON-POLYMER", "non-polymer"}
+    and row["inchikey"] is not None
+)
+print(released[0])
+```
+
+Find components modified after a date:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/PDB-CCD", split="train")
+recent = ds.filter(lambda row: row["modified_date"] is not None and row["modified_date"] >= "2026-01-01")
+print(recent[0]["component_id"], recent[0]["modified_date"])
+```
+
+## Columns
+
+| Column | Description |
+|---|---|
+| `component_id` | Chemical component identifier. |
+| `name` | Component name from `_chem_comp.name`. |
+| `component_type` | Raw `_chem_comp.type` value. |
+| `pdbx_type` | Raw `_chem_comp.pdbx_type` value. |
+| `formula` | Chemical formula. |
+| `formula_weight` | Formula weight as a float. |
+| `formal_charge` | Formal charge as an integer. |
+| `mon_nstd_parent_comp_id` | Parent component ID for non-standard monomers, when present. |
+| `one_letter_code` | One-letter code, when present. |
+| `three_letter_code` | Three-letter code, when present. |
+| `pdbx_synonyms` | Synonym field from `_chem_comp`. |
+| `synonym_names` | Synonyms from `pdbx_chem_comp_synonyms`. |
+| `initial_date` | Initial component date. |
+| `modified_date` | Last modified date. |
+| `release_status` | Release status, such as `REL` or `OBS`. |
+| `replaced_by` | Replacement component ID, when present. |
+| `replaces` | Component ID replaced by this component, when present. |
+| `atom_ids` | Atom identifiers from `chem_comp_atom`. |
+| `atom_elements` | Element symbols for `atom_ids`. |
+| `atom_charges` | Atom charges. |
+| `atom_aromatic_flags` | Atom aromatic flags. |
+| `atom_leaving_flags` | Atom leaving-atom flags. |
+| `atom_stereo_configs` | Atom stereochemistry flags. |
+| `atom_count` | Number of atoms. |
+| `heavy_atom_count` | Number of non-hydrogen atoms. |
+| `hydrogen_atom_count` | Number of hydrogen atoms. |
+| `bond_atom_id_1` | First atom ID for each bond. |
+| `bond_atom_id_2` | Second atom ID for each bond. |
+| `bond_orders` | Bond order values. |
+| `bond_aromatic_flags` | Bond aromatic flags. |
+| `bond_stereo_configs` | Bond stereochemistry flags. |
+| `bond_count` | Number of bonds. |
+| `descriptor_types` | Descriptor types such as `SMILES`, `SMILES_CANONICAL`, `InChI`, and `InChIKey`. |
+| `descriptors` | Descriptor values. |
+| `canonical_smiles` | First `SMILES_CANONICAL` descriptor. |
+| `smiles` | First `SMILES` descriptor. |
+| `inchi` | First `InChI` descriptor. |
+| `inchikey` | First `InChIKey` descriptor. |
+| `identifier_types` | Identifier types from `pdbx_chem_comp_identifier`. |
+| `identifiers` | Identifier values. |
+| `systematic_names` | Identifier values whose type is `SYSTEMATIC NAME`. |
+| `audit_actions` | Audit action types. |
+| `audit_dates` | Audit dates. |
+| `related_component_ids` | Related component IDs, when present. |
+| `pcm_ids` | Protein modification annotation IDs, when present. |
+| `pcm_modified_residue_ids` | Modified residue IDs from PCM annotations. |
+| `feature_types` | Feature types from `pdbx_chem_comp_feature`. |
+| `feature_values` | Feature values from `pdbx_chem_comp_feature`. |
+| `split_bucket` | Deterministic split bucket from `sha256(component_id) % 10`. |
+
+## Preparation
+
+The normalization script used to create the Parquet files is included at `scripts/prepare_pdb_ccd_dataset.py`.

data/test-00000-of-00001.parquet

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

data/train-00000-of-00001.parquet

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

dataset_summary.json

@@ -0,0 +1,195 @@
+{
+  "source": "LiteFold/PDB-CCD",
+  "component_rows": 50054,
+  "splits": {
+    "train": 45045,
+    "test": 5009
+  },
+  "split_strategy": "deterministic sha256(component_id) % 10; bucket 0 is test, buckets 1-9 are train",
+  "release_status_counts": {
+    "REL": 49292,
+    "OBS": 762
+  },
+  "component_type_counts": {
+    "NON-POLYMER": 26117,
+    "non-polymer": 19493,
+    "L-PEPTIDE LINKING": 923,
+    "L-peptide linking": 580,
+    "peptide-like": 556,
+    "D-saccharide": 405,
+    "DNA LINKING": 325,
+    "RNA LINKING": 223,
+    "D-saccharide, alpha linking": 203,
+    "D-saccharide, beta linking": 173,
+    "saccharide": 137,
+    "DNA linking": 134,
+    "RNA linking": 129,
+    "D-PEPTIDE LINKING": 96,
+    "D-peptide linking": 68,
+    "L-saccharide, alpha linking": 63,
+    "peptide linking": 62,
+    "L-saccharide": 60,
+    "SACCHARIDE": 51,
+    "PEPTIDE-LIKE": 48,
+    "PEPTIDE LINKING": 44,
+    "D-SACCHARIDE": 43,
+    "L-saccharide, beta linking": 35,
+    "L-peptide NH3 amino terminus": 25,
+    "L-peptide COOH carboxy terminus": 13,
+    "L-SACCHARIDE": 8,
+    "RNA OH 3 prime terminus": 5,
+    "L-RNA LINKING": 5,
+    "L-DNA LINKING": 4,
+    "D-beta-peptide, C-gamma linking": 3,
+    "DNA OH 3 prime terminus": 3,
+    "L-beta-peptide, C-gamma linking": 3,
+    "RNA OH 5 prime terminus": 2,
+    "L-gamma-peptide, C-delta linking": 2,
+    "L-RNA linking": 2,
+    "L-PEPTIDE COOH CARBOXY TERMINUS": 2,
+    "DNA OH 5 prime terminus": 2,
+    "D-gamma-peptide, C-delta linking": 1,
+    "D-PEPTIDE NH3 AMINO TERMINUS": 1,
+    "Peptide-like": 1,
+    "L-DNA linking": 1,
+    "D-peptide COOH carboxy terminus": 1,
+    "DNA OH 3 PRIME TERMINUS": 1,
+    "D-peptide NH3 amino terminus": 1
+  },
+  "pdbx_type_counts": {
+    "HETAIN": 45506,
+    "ATOMP": 1831,
+    "ATOMS": 1182,
+    "ATOMN": 820,
+    "missing": 256,
+    "HETAD": 247,
+    "HETAI": 135,
+    "HETIC": 38,
+    "HETAC": 32,
+    "HETAS": 5,
+    "hetain": 2
+  },
+  "max_modified_date": "2026-04-24",
+  "components_with_atoms": 49947,
+  "components_with_bonds": 49921,
+  "components_with_descriptors": 50052,
+  "components_with_identifiers": 37058,
+  "components_with_pcm": 613,
+  "top_elements": {
+    "H": 1082721,
+    "C": 898683,
+    "O": 199913,
+    "N": 152744,
+    "F": 17030,
+    "S": 15656,
+    "CL": 8840,
+    "P": 7757,
+    "BR": 1827,
+    "B": 983,
+    "FE": 445,
+    "I": 427,
+    "W": 426,
+    "MO": 205,
+    "V": 195,
+    "RU": 156,
+    "SE": 154,
+    "CO": 78,
+    "SI": 63,
+    "CU": 63,
+    "PT": 58,
+    "MG": 41,
+    "NI": 40,
+    "RH": 38,
+    "MN": 36,
+    "AS": 32,
+    "IR": 28,
+    "D": 23,
+    "HG": 22,
+    "ZN": 20
+  },
+  "descriptor_type_counts": {
+    "SMILES": 134251,
+    "SMILES_CANONICAL": 100067,
+    "InChI": 50046,
+    "InChIKey": 50045,
+    "INCHI": 4
+  },
+  "identifier_type_counts": {
+    "SYSTEMATIC NAME": 70318,
+    "IUPAC CARBOHYDRATE SYMBOL": 301,
+    "CONDENSED IUPAC CARBOHYDRATE SYMBOL": 173,
+    "COMMON NAME": 169,
+    "SNFG CARBOHYDRATE SYMBOL": 122
+  },
+  "columns": [
+    "component_id",
+    "name",
+    "component_type",
+    "pdbx_type",
+    "formula",
+    "formula_weight",
+    "formal_charge",
+    "mon_nstd_parent_comp_id",
+    "one_letter_code",
+    "three_letter_code",
+    "pdbx_synonyms",
+    "synonym_names",
+    "synonym_provenances",
+    "synonym_types",
+    "initial_date",
+    "modified_date",
+    "release_status",
+    "ambiguous_flag",
+    "replaced_by",
+    "replaces",
+    "model_coordinates_missing_flag",
+    "ideal_coordinates_missing_flag",
+    "model_coordinates_db_code",
+    "processing_site",
+    "atom_ids",
+    "atom_alt_ids",
+    "atom_elements",
+    "atom_charges",
+    "atom_aromatic_flags",
+    "atom_leaving_flags",
+    "atom_stereo_configs",
+    "atom_count",
+    "heavy_atom_count",
+    "hydrogen_atom_count",
+    "bond_atom_id_1",
+    "bond_atom_id_2",
+    "bond_orders",
+    "bond_aromatic_flags",
+    "bond_stereo_configs",
+    "bond_count",
+    "descriptor_types",
+    "descriptor_programs",
+    "descriptor_program_versions",
+    "descriptors",
+    "canonical_smiles",
+    "smiles",
+    "inchi",
+    "inchikey",
+    "identifier_types",
+    "identifier_programs",
+    "identifier_program_versions",
+    "identifiers",
+    "systematic_names",
+    "audit_actions",
+    "audit_dates",
+    "audit_processing_sites",
+    "related_component_ids",
+    "related_relationship_types",
+    "pcm_ids",
+    "pcm_modified_residue_ids",
+    "pcm_types",
+    "pcm_categories",
+    "pcm_positions",
+    "feature_types",
+    "feature_values",
+    "split_bucket"
+  ],
+  "source_files_used": [
+    "components.cif.gz"
+  ]
+}

scripts/prepare_pdb_ccd_dataset.py

@@ -0,0 +1,443 @@
+#!/usr/bin/env python3
+"""Build viewer-friendly Parquet splits for LiteFold/PDB-CCD."""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import hashlib
+import json
+import re
+import shutil
+from collections import Counter
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Iterator
+
+import pandas as pd
+
+
+COMPONENT_COLUMNS = [
+    "component_id",
+    "name",
+    "component_type",
+    "pdbx_type",
+    "formula",
+    "formula_weight",
+    "formal_charge",
+    "mon_nstd_parent_comp_id",
+    "one_letter_code",
+    "three_letter_code",
+    "pdbx_synonyms",
+    "synonym_names",
+    "synonym_provenances",
+    "synonym_types",
+    "initial_date",
+    "modified_date",
+    "release_status",
+    "ambiguous_flag",
+    "replaced_by",
+    "replaces",
+    "model_coordinates_missing_flag",
+    "ideal_coordinates_missing_flag",
+    "model_coordinates_db_code",
+    "processing_site",
+    "atom_ids",
+    "atom_alt_ids",
+    "atom_elements",
+    "atom_charges",
+    "atom_aromatic_flags",
+    "atom_leaving_flags",
+    "atom_stereo_configs",
+    "atom_count",
+    "heavy_atom_count",
+    "hydrogen_atom_count",
+    "bond_atom_id_1",
+    "bond_atom_id_2",
+    "bond_orders",
+    "bond_aromatic_flags",
+    "bond_stereo_configs",
+    "bond_count",
+    "descriptor_types",
+    "descriptor_programs",
+    "descriptor_program_versions",
+    "descriptors",
+    "canonical_smiles",
+    "smiles",
+    "inchi",
+    "inchikey",
+    "identifier_types",
+    "identifier_programs",
+    "identifier_program_versions",
+    "identifiers",
+    "systematic_names",
+    "audit_actions",
+    "audit_dates",
+    "audit_processing_sites",
+    "related_component_ids",
+    "related_relationship_types",
+    "pcm_ids",
+    "pcm_modified_residue_ids",
+    "pcm_types",
+    "pcm_categories",
+    "pcm_positions",
+    "feature_types",
+    "feature_values",
+    "split_bucket",
+]
+
+
+@dataclass
+class TokenStream:
+    iterator: Iterator[str]
+    pushed: list[str]
+
+    def next(self) -> str | None:
+        if self.pushed:
+            return self.pushed.pop()
+        return next(self.iterator, None)
+
+    def push(self, token: str) -> None:
+        self.pushed.append(token)
+
+
+def cif_tokens(path: Path) -> Iterator[str]:
+    with gzip.open(path, "rt", encoding="utf-8", errors="replace") as handle:
+        multiline: list[str] | None = None
+        for raw_line in handle:
+            line = raw_line.rstrip("\n")
+            if multiline is not None:
+                if line.startswith(";"):
+                    yield "\n".join(multiline).strip()
+                    multiline = None
+                else:
+                    multiline.append(line)
+                continue
+            if line.startswith(";"):
+                multiline = [line[1:]]
+                continue
+
+            i = 0
+            length = len(line)
+            while i < length:
+                while i < length and line[i].isspace():
+                    i += 1
+                if i >= length:
+                    break
+                if line[i] == "#":
+                    break
+                if line[i] in {"'", '"'}:
+                    quote = line[i]
+                    i += 1
+                    value: list[str] = []
+                    while i < length:
+                        char = line[i]
+                        if char == quote:
+                            next_index = i + 1
+                            if next_index >= length or line[next_index].isspace() or line[next_index] == "#":
+                                i += 1
+                                break
+                        value.append(char)
+                        i += 1
+                    yield "".join(value)
+                    continue
+
+                start = i
+                while i < length and not line[i].isspace() and line[i] != "#":
+                    i += 1
+                yield line[start:i]
+                if i < length and line[i] == "#":
+                    break
+
+
+def clean_value(value: str | None) -> Any:
+    if value in {None, "?", "."}:
+        return None
+    return re.sub(r"\s+", " ", value).strip()
+
+
+def parse_int(value: Any) -> int | None:
+    value = clean_value(value)
+    if value is None:
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def parse_float(value: Any) -> float | None:
+    value = clean_value(value)
+    if value is None:
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def stable_bucket(value: str, buckets: int = 10) -> int:
+    digest = hashlib.sha256(value.encode("utf-8")).hexdigest()[:16]
+    return int(digest, 16) % buckets
+
+
+def split_tag(tag: str) -> tuple[str, str]:
+    body = tag[1:]
+    category, field = body.split(".", 1)
+    return category, field
+
+
+def finish_loop(tags: list[str], values: list[str], loops: dict[str, list[dict[str, Any]]]) -> None:
+    if not tags:
+        return
+    categories = {split_tag(tag)[0] for tag in tags}
+    if len(categories) != 1:
+        return
+    category = categories.pop()
+    fields = [split_tag(tag)[1] for tag in tags]
+    width = len(fields)
+    rows = []
+    for start in range(0, len(values) - (len(values) % width), width):
+        rows.append({field: clean_value(values[start + index]) for index, field in enumerate(fields)})
+    loops.setdefault(category, []).extend(rows)
+
+
+def parse_cif_blocks(path: Path) -> Iterator[dict[str, Any]]:
+    stream = TokenStream(cif_tokens(path), [])
+    block: dict[str, Any] | None = None
+
+    while True:
+        token = stream.next()
+        if token is None:
+            if block is not None:
+                yield block
+            break
+
+        if token.startswith("data_"):
+            if block is not None:
+                yield block
+            block = {"name": token[5:], "scalars": {}, "loops": {}}
+            continue
+
+        if block is None:
+            continue
+
+        if token == "loop_":
+            tags: list[str] = []
+            values: list[str] = []
+            while True:
+                item = stream.next()
+                if item is None:
+                    break
+                if item.startswith("_"):
+                    tags.append(item)
+                    continue
+                stream.push(item)
+                break
+            while True:
+                item = stream.next()
+                if item is None:
+                    finish_loop(tags, values, block["loops"])
+                    return
+                if item == "loop_" or item.startswith("data_") or item.startswith("_"):
+                    stream.push(item)
+                    break
+                values.append(item)
+            finish_loop(tags, values, block["loops"])
+            continue
+
+        if token.startswith("_"):
+            value = stream.next()
+            if value is None:
+                continue
+            if value == "loop_" or value.startswith("data_") or value.startswith("_"):
+                stream.push(value)
+                continue
+            category, field = split_tag(token)
+            block["scalars"].setdefault(category, {})[field] = clean_value(value)
+
+
+def first_by_type(rows: list[dict[str, Any]], wanted_type: str) -> str | None:
+    for row in rows:
+        if row.get("type") == wanted_type and row.get("descriptor"):
+            return str(row["descriptor"])
+    return None
+
+
+def values(rows: list[dict[str, Any]], field: str) -> list[Any]:
+    return [row[field] for row in rows if row.get(field) is not None]
+
+
+def string_values(rows: list[dict[str, Any]], field: str) -> list[str]:
+    return [str(row[field]) for row in rows if row.get(field) is not None]
+
+
+def int_values(rows: list[dict[str, Any]], field: str) -> list[int]:
+    parsed = []
+    for row in rows:
+        value = parse_int(row.get(field))
+        if value is not None:
+            parsed.append(value)
+    return parsed
+
+
+def component_row(block: dict[str, Any]) -> dict[str, Any]:
+    scalars = block["scalars"].get("chem_comp", {})
+    loops = block["loops"]
+    atoms = loops.get("chem_comp_atom", [])
+    bonds = loops.get("chem_comp_bond", [])
+    descriptors = loops.get("pdbx_chem_comp_descriptor", [])
+    identifiers = loops.get("pdbx_chem_comp_identifier", [])
+    audits = loops.get("pdbx_chem_comp_audit", [])
+    synonyms = loops.get("pdbx_chem_comp_synonyms", [])
+    related = loops.get("pdbx_chem_comp_related", [])
+    pcms = loops.get("pdbx_chem_comp_pcm", [])
+    features = loops.get("pdbx_chem_comp_feature", [])
+
+    component_id = str(scalars.get("id") or block["name"])
+    atom_elements = string_values(atoms, "type_symbol")
+    heavy_atom_count = sum(1 for element in atom_elements if element.upper() != "H")
+    hydrogen_atom_count = sum(1 for element in atom_elements if element.upper() == "H")
+
+    return {
+        "component_id": component_id,
+        "name": scalars.get("name"),
+        "component_type": scalars.get("type"),
+        "pdbx_type": scalars.get("pdbx_type"),
+        "formula": scalars.get("formula"),
+        "formula_weight": parse_float(scalars.get("formula_weight")),
+        "formal_charge": parse_int(scalars.get("pdbx_formal_charge")),
+        "mon_nstd_parent_comp_id": scalars.get("mon_nstd_parent_comp_id"),
+        "one_letter_code": scalars.get("one_letter_code"),
+        "three_letter_code": scalars.get("three_letter_code"),
+        "pdbx_synonyms": scalars.get("pdbx_synonyms"),
+        "synonym_names": string_values(synonyms, "name"),
+        "synonym_provenances": string_values(synonyms, "provenance"),
+        "synonym_types": string_values(synonyms, "type"),
+        "initial_date": scalars.get("pdbx_initial_date"),
+        "modified_date": scalars.get("pdbx_modified_date"),
+        "release_status": scalars.get("pdbx_release_status"),
+        "ambiguous_flag": scalars.get("pdbx_ambiguous_flag"),
+        "replaced_by": scalars.get("pdbx_replaced_by"),
+        "replaces": scalars.get("pdbx_replaces"),
+        "model_coordinates_missing_flag": scalars.get("pdbx_model_coordinates_missing_flag"),
+        "ideal_coordinates_missing_flag": scalars.get("pdbx_ideal_coordinates_missing_flag"),
+        "model_coordinates_db_code": scalars.get("pdbx_model_coordinates_db_code"),
+        "processing_site": scalars.get("pdbx_processing_site"),
+        "atom_ids": string_values(atoms, "atom_id"),
+        "atom_alt_ids": string_values(atoms, "alt_atom_id"),
+        "atom_elements": atom_elements,
+        "atom_charges": int_values(atoms, "charge"),
+        "atom_aromatic_flags": string_values(atoms, "pdbx_aromatic_flag"),
+        "atom_leaving_flags": string_values(atoms, "pdbx_leaving_atom_flag"),
+        "atom_stereo_configs": string_values(atoms, "pdbx_stereo_config"),
+        "atom_count": len(atoms),
+        "heavy_atom_count": heavy_atom_count,
+        "hydrogen_atom_count": hydrogen_atom_count,
+        "bond_atom_id_1": string_values(bonds, "atom_id_1"),
+        "bond_atom_id_2": string_values(bonds, "atom_id_2"),
+        "bond_orders": string_values(bonds, "value_order"),
+        "bond_aromatic_flags": string_values(bonds, "pdbx_aromatic_flag"),
+        "bond_stereo_configs": string_values(bonds, "pdbx_stereo_config"),
+        "bond_count": len(bonds),
+        "descriptor_types": string_values(descriptors, "type"),
+        "descriptor_programs": string_values(descriptors, "program"),
+        "descriptor_program_versions": string_values(descriptors, "program_version"),
+        "descriptors": string_values(descriptors, "descriptor"),
+        "canonical_smiles": first_by_type(descriptors, "SMILES_CANONICAL"),
+        "smiles": first_by_type(descriptors, "SMILES"),
+        "inchi": first_by_type(descriptors, "InChI"),
+        "inchikey": first_by_type(descriptors, "InChIKey"),
+        "identifier_types": string_values(identifiers, "type"),
+        "identifier_programs": string_values(identifiers, "program"),
+        "identifier_program_versions": string_values(identifiers, "program_version"),
+        "identifiers": string_values(identifiers, "identifier"),
+        "systematic_names": [
+            str(row["identifier"])
+            for row in identifiers
+            if row.get("type") == "SYSTEMATIC NAME" and row.get("identifier") is not None
+        ],
+        "audit_actions": string_values(audits, "action_type"),
+        "audit_dates": string_values(audits, "date"),
+        "audit_processing_sites": string_values(audits, "processing_site"),
+        "related_component_ids": string_values(related, "related_comp_id"),
+        "related_relationship_types": string_values(related, "relationship_type"),
+        "pcm_ids": string_values(pcms, "pcm_id"),
+        "pcm_modified_residue_ids": string_values(pcms, "modified_residue_id"),
+        "pcm_types": string_values(pcms, "type"),
+        "pcm_categories": string_values(pcms, "category"),
+        "pcm_positions": string_values(pcms, "position"),
+        "feature_types": string_values(features, "type"),
+        "feature_values": string_values(features, "value"),
+        "split_bucket": stable_bucket(component_id),
+    }
+
+
+def build_dataset(raw_dir: Path, out_dir: Path) -> dict[str, Any]:
+    cif_path = raw_dir / "components.cif.gz"
+    rows = [component_row(block) for block in parse_cif_blocks(cif_path)]
+
+    if out_dir.exists():
+        shutil.rmtree(out_dir)
+    data_dir = out_dir / "data"
+    data_dir.mkdir(parents=True, exist_ok=True)
+
+    df = pd.DataFrame.from_records(rows, columns=COMPONENT_COLUMNS)
+    df = df.sort_values(["split_bucket", "component_id"], kind="mergesort")
+    train = df[df["split_bucket"].ne(0)].sort_values("component_id", kind="mergesort")
+    test = df[df["split_bucket"].eq(0)].sort_values("component_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")
+
+    def count_column(column: str) -> dict[str, int]:
+        return {
+            str(key): int(value)
+            for key, value in df[column].fillna("missing").value_counts(dropna=False).to_dict().items()
+        }
+
+    release_status_counts = count_column("release_status")
+    type_counts = count_column("component_type")
+    pdbx_type_counts = count_column("pdbx_type")
+    element_counts = Counter(element for elements in df["atom_elements"] for element in elements)
+    descriptor_type_counts = Counter(kind for kinds in df["descriptor_types"] for kind in kinds)
+    identifier_type_counts = Counter(kind for kinds in df["identifier_types"] for kind in kinds)
+    max_modified_date = max((value for value in df["modified_date"].dropna().tolist()), default=None)
+
+    summary = {
+        "source": "LiteFold/PDB-CCD",
+        "component_rows": int(len(df)),
+        "splits": {
+            "train": int(len(train)),
+            "test": int(len(test)),
+        },
+        "split_strategy": "deterministic sha256(component_id) % 10; bucket 0 is test, buckets 1-9 are train",
+        "release_status_counts": release_status_counts,
+        "component_type_counts": type_counts,
+        "pdbx_type_counts": pdbx_type_counts,
+        "max_modified_date": max_modified_date,
+        "components_with_atoms": int(df["atom_count"].gt(0).sum()),
+        "components_with_bonds": int(df["bond_count"].gt(0).sum()),
+        "components_with_descriptors": int(df["descriptors"].map(len).gt(0).sum()),
+        "components_with_identifiers": int(df["identifiers"].map(len).gt(0).sum()),
+        "components_with_pcm": int(df["pcm_ids"].map(len).gt(0).sum()),
+        "top_elements": dict(element_counts.most_common(30)),
+        "descriptor_type_counts": dict(descriptor_type_counts.most_common()),
+        "identifier_type_counts": dict(identifier_type_counts.most_common()),
+        "columns": COMPONENT_COLUMNS,
+        "source_files_used": ["components.cif.gz"],
+    }
+    (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_CCD_raw"))
+    parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_PDB_CCD_processed"))
+    args = parser.parse_args()
+    summary = build_dataset(args.raw_dir, args.out_dir)
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()