| |
| """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() |
|
|
