variantfold 0.1.0__tar.gz

variantfold-0.1.0/PKG-INFO

@@ -0,0 +1,151 @@
+Metadata-Version: 2.4
+Name: variantfold
+Version: 0.1.0
+Summary: Classify variants of uncertain significance using AlphaFold-predicted protein structures and graph neural networks.
+Author: VariantFold Contributors
+License: MIT
+Project-URL: Homepage, https://github.com/comparativechrono/VariantFold
+Project-URL: Repository, https://github.com/comparativechrono/VariantFold
+Project-URL: Issues, https://github.com/comparativechrono/VariantFold/issues
+Keywords: bioinformatics,alphafold,variant classification,GNN,VUS,ACMG
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: biopython>=1.80
+Requires-Dist: biopandas>=0.4
+Requires-Dist: numpy>=1.22
+Requires-Dist: pandas>=1.4
+Requires-Dist: scikit-learn>=1.0
+Requires-Dist: torch>=2.0
+Requires-Dist: torch-geometric>=2.3
+Provides-Extra: structure
+Requires-Dist: colabfold[alphafold-minus-jax]; extra == "structure"
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.5; extra == "viz"
+Requires-Dist: seaborn>=0.12; extra == "viz"
+Requires-Dist: networkx>=2.8; extra == "viz"
+Requires-Dist: py3Dmol>=1.8; extra == "viz"
+Provides-Extra: dgl
+Requires-Dist: dgl>=1.0; extra == "dgl"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+Provides-Extra: all
+Requires-Dist: variantfold[dev,dgl,structure,viz]; extra == "all"
+
+# VariantFold
+
+Classify **Variants of Uncertain Significance (VUS)** using AlphaFold-predicted protein structures and Graph Neural Networks.
+
+VariantFold leverages protein structure predictions from ColabFold/AlphaFold and a Graph Convolutional Network (GCN) to classify VUS based on the standardised ACMG-AMP variant classification system.
+
+## Workflow
+
+```
+ClinVar data → Parse variants → Mutate sequences → ColabFold 3-D prediction
+    → PDB-to-graph conversion → Train GCN (benign vs pathogenic) → Classify VUS
+```
+
+1. **Parse** — Extract missense variants from ClinVar downloads (benign, pathogenic, VUS).
+2. **Mutate** — Apply each variant to the reference protein sequence.
+3. **Predict** — Run ColabFold to generate 3-D structure models for every variant.
+4. **Convert** — Transform PDB files into PyTorch Geometric residue-level graphs with rich node features (one-hot amino acid, 3-D coordinates, pLDDT).
+5. **Train** — Train a multi-layer GCN on the benign vs pathogenic graph dataset.
+6. **Classify** — Run the trained model on VUS structures to predict likely benign / likely pathogenic with probabilities.
+
+## Installation
+
+```bash
+# Core package (graph conversion + GCN training/inference)
+pip install .
+
+# With ColabFold for structure prediction (GPU recommended)
+pip install ".[structure]"
+
+# With visualisation tools
+pip install ".[viz]"
+
+# Everything
+pip install ".[all]"
+```
+
+## Quick start — Python API
+
+```python
+from variantfold import VariantFoldConfig, VariantFoldPipeline
+
+cfg = VariantFoldConfig(
+    gene_symbol="VHL",
+    entrez_email="your_email@example.com",
+)
+
+pipe = VariantFoldPipeline(cfg)
+pipe.step1_parse_variants()       # Parse ClinVar files + fetch sequence
+# pipe.step2_predict_structures() # Run ColabFold (long — needs GPU)
+pipe.step3_collect_models()       # Gather best PDB models
+metrics = pipe.step4_train()      # Train GCN
+print(f"Test accuracy: {metrics['accuracy']:.2%}")
+
+vus_df = pipe.step5_classify_vus()
+print(vus_df)
+```
+
+## Quick start — CLI
+
+```bash
+# Run steps 1, 3, 4, 5 (assumes PDB libraries are already populated)
+variantfold run --gene VHL --email you@example.com --steps 1,3,4,5
+
+# Standalone inference on new PDB files
+variantfold predict --model variantfold_VHL/variantfold_model.pt \
+                    --pdb-dir ./new_vus_pdbs/
+```
+
+## Input data
+
+Place these files in the working directory (`./variantfold_<gene>/`):
+
+| File | Description |
+|------|-------------|
+| `clinvar_result_bng.txt` | ClinVar download filtered to **benign** variants |
+| `clinvar_result_ptg.txt` | ClinVar download filtered to **pathogenic** variants |
+| `clinvar_result_vus.txt` | ClinVar download filtered to **VUS** *(optional)* |
+
+Download from [ClinVar](https://www.ncbi.nlm.nih.gov/clinvar/) using the tab-delimited download with default settings.
+
+## Configuration
+
+All parameters are set via `VariantFoldConfig`:
+
+```python
+cfg = VariantFoldConfig(
+    gene_symbol="TP53",
+    entrez_email="you@example.com",
+    distance_threshold=6.5,   # Å, residue contact cutoff
+    gcn_hidden_dim=64,        # GCN layer width
+    gcn_num_layers=3,         # depth
+    epochs=200,
+    learning_rate=0.01,
+    train_fraction=0.8,
+    use_residue_features=True, # 24-dim features (set False for legacy 1-dim)
+)
+```
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## Licence
+
+MIT

variantfold-0.1.0/README.md

@@ -0,0 +1,108 @@
+# VariantFold
+
+Classify **Variants of Uncertain Significance (VUS)** using AlphaFold-predicted protein structures and Graph Neural Networks.
+
+VariantFold leverages protein structure predictions from ColabFold/AlphaFold and a Graph Convolutional Network (GCN) to classify VUS based on the standardised ACMG-AMP variant classification system.
+
+## Workflow
+
+```
+ClinVar data → Parse variants → Mutate sequences → ColabFold 3-D prediction
+    → PDB-to-graph conversion → Train GCN (benign vs pathogenic) → Classify VUS
+```
+
+1. **Parse** — Extract missense variants from ClinVar downloads (benign, pathogenic, VUS).
+2. **Mutate** — Apply each variant to the reference protein sequence.
+3. **Predict** — Run ColabFold to generate 3-D structure models for every variant.
+4. **Convert** — Transform PDB files into PyTorch Geometric residue-level graphs with rich node features (one-hot amino acid, 3-D coordinates, pLDDT).
+5. **Train** — Train a multi-layer GCN on the benign vs pathogenic graph dataset.
+6. **Classify** — Run the trained model on VUS structures to predict likely benign / likely pathogenic with probabilities.
+
+## Installation
+
+```bash
+# Core package (graph conversion + GCN training/inference)
+pip install .
+
+# With ColabFold for structure prediction (GPU recommended)
+pip install ".[structure]"
+
+# With visualisation tools
+pip install ".[viz]"
+
+# Everything
+pip install ".[all]"
+```
+
+## Quick start — Python API
+
+```python
+from variantfold import VariantFoldConfig, VariantFoldPipeline
+
+cfg = VariantFoldConfig(
+    gene_symbol="VHL",
+    entrez_email="your_email@example.com",
+)
+
+pipe = VariantFoldPipeline(cfg)
+pipe.step1_parse_variants()       # Parse ClinVar files + fetch sequence
+# pipe.step2_predict_structures() # Run ColabFold (long — needs GPU)
+pipe.step3_collect_models()       # Gather best PDB models
+metrics = pipe.step4_train()      # Train GCN
+print(f"Test accuracy: {metrics['accuracy']:.2%}")
+
+vus_df = pipe.step5_classify_vus()
+print(vus_df)
+```
+
+## Quick start — CLI
+
+```bash
+# Run steps 1, 3, 4, 5 (assumes PDB libraries are already populated)
+variantfold run --gene VHL --email you@example.com --steps 1,3,4,5
+
+# Standalone inference on new PDB files
+variantfold predict --model variantfold_VHL/variantfold_model.pt \
+                    --pdb-dir ./new_vus_pdbs/
+```
+
+## Input data
+
+Place these files in the working directory (`./variantfold_<gene>/`):
+
+| File | Description |
+|------|-------------|
+| `clinvar_result_bng.txt` | ClinVar download filtered to **benign** variants |
+| `clinvar_result_ptg.txt` | ClinVar download filtered to **pathogenic** variants |
+| `clinvar_result_vus.txt` | ClinVar download filtered to **VUS** *(optional)* |
+
+Download from [ClinVar](https://www.ncbi.nlm.nih.gov/clinvar/) using the tab-delimited download with default settings.
+
+## Configuration
+
+All parameters are set via `VariantFoldConfig`:
+
+```python
+cfg = VariantFoldConfig(
+    gene_symbol="TP53",
+    entrez_email="you@example.com",
+    distance_threshold=6.5,   # Å, residue contact cutoff
+    gcn_hidden_dim=64,        # GCN layer width
+    gcn_num_layers=3,         # depth
+    epochs=200,
+    learning_rate=0.01,
+    train_fraction=0.8,
+    use_residue_features=True, # 24-dim features (set False for legacy 1-dim)
+)
+```
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## Licence
+
+MIT

variantfold-0.1.0/pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "variantfold"
+version = "0.1.0"
+description = "Classify variants of uncertain significance using AlphaFold-predicted protein structures and graph neural networks."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [
+    {name = "VariantFold Contributors"},
+]
+keywords = ["bioinformatics", "alphafold", "variant classification", "GNN", "VUS", "ACMG"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+dependencies = [
+    "biopython>=1.80",
+    "biopandas>=0.4",
+    "numpy>=1.22",
+    "pandas>=1.4",
+    "scikit-learn>=1.0",
+    "torch>=2.0",
+    "torch-geometric>=2.3",
+]
+
+[project.optional-dependencies]
+structure = [
+    # ColabFold and its AlphaFold dependency — heavy, GPU-only
+    "colabfold[alphafold-minus-jax]",
+]
+viz = [
+    "matplotlib>=3.5",
+    "seaborn>=0.12",
+    "networkx>=2.8",
+    "py3Dmol>=1.8",
+]
+dgl = [
+    # Only needed for the legacy DGL-based analysis path
+    "dgl>=1.0",
+]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "ruff>=0.1",
+]
+all = ["variantfold[structure,viz,dgl,dev]"]
+
+[project.scripts]
+variantfold = "variantfold.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/comparativechrono/VariantFold"
+Repository = "https://github.com/comparativechrono/VariantFold"
+Issues = "https://github.com/comparativechrono/VariantFold/issues"
+
+[tool.setuptools.packages.find]
+include = ["variantfold*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-v --tb=short"
+
+[tool.ruff]
+target-version = "py39"
+line-length = 95

variantfold-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

variantfold-0.1.0/tests/test_variantfold.py

@@ -0,0 +1,305 @@
+"""
+Tests for VariantFold.
+
+Run with:  pytest tests/
+"""
+
+import os
+import tempfile
+from pathlib import Path
+
+import numpy as np
+import pytest
+import torch
+
+# ============================================================================
+# Tests for variantfold.variants  (BUG-1, BUG-2, BUG-9)
+# ============================================================================
+
+from variantfold.variants import (
+    parse_clinvar_variant,
+    load_clinvar_table,
+    swap_amino_acid,
+    generate_mutant_sequences,
+)
+
+
+class TestParseClinvarVariant:
+    """BUG-1: The old regex only handled single-letter codes.
+    These tests verify all ClinVar formats are parsed correctly."""
+
+    def test_three_letter_codes(self):
+        assert parse_clinvar_variant("p.Val600Glu") == ("V", 600, "E")
+
+    def test_three_letter_with_parens(self):
+        assert parse_clinvar_variant("p.(Arg100Trp)") == ("R", 100, "W")
+
+    def test_single_letter_with_prefix(self):
+        assert parse_clinvar_variant("p.R155W") == ("R", 155, "W")
+
+    def test_single_letter_bare(self):
+        assert parse_clinvar_variant("V600E") == ("V", 600, "E")
+
+    def test_nonsense_returns_none(self):
+        # Ter = stop codon — not a missense variant
+        assert parse_clinvar_variant("p.Arg214Ter") is None
+
+    def test_frameshift_returns_none(self):
+        assert parse_clinvar_variant("p.Ter214GlnfsTer59") is None
+
+    def test_deletion_returns_none(self):
+        assert parse_clinvar_variant("p.Val600del") is None
+
+    def test_insertion_returns_none(self):
+        assert parse_clinvar_variant("p.Ala100_Glu101insGly") is None
+
+    def test_synonymous_returns_none(self):
+        # Same AA → synonymous, should be skipped
+        assert parse_clinvar_variant("p.Val600Val") is None
+
+    def test_empty_returns_none(self):
+        assert parse_clinvar_variant("") is None
+        assert parse_clinvar_variant("-") is None
+
+    def test_comma_separated_takes_first(self):
+        result = parse_clinvar_variant("p.Val600Glu, p.Val600Ala")
+        assert result == ("V", 600, "E")
+
+    def test_duplication_returns_none(self):
+        assert parse_clinvar_variant("p.Ala100dup") is None
+
+
+class TestLoadClinvarTable:
+    """Test ClinVar file loading with realistic data."""
+
+    def test_loads_valid_file(self, tmp_path):
+        tsv = tmp_path / "test_clinvar.txt"
+        tsv.write_text(
+            "Name\tProtein change\tOther\n"
+            "var1\tp.Val600Glu\tinfo\n"
+            "var2\tp.Arg100Trp\tinfo\n"
+            "var3\tp.Ter214GlnfsTer59\tinfo\n"  # should be skipped
+            "var4\t\tinfo\n"                     # NaN, skipped
+        )
+        result = load_clinvar_table(str(tsv))
+        assert len(result) == 2
+        assert result[0] == ("V", 600, "E")
+        assert result[1] == ("R", 100, "W")
+
+    def test_missing_file_raises(self):
+        with pytest.raises(FileNotFoundError):
+            load_clinvar_table("/nonexistent/file.txt")
+
+    def test_missing_column_raises(self, tmp_path):
+        tsv = tmp_path / "bad.txt"
+        tsv.write_text("Name\tWrong Column\n")
+        with pytest.raises(ValueError, match="Protein change"):
+            load_clinvar_table(str(tsv))
+
+
+class TestSwapAminoAcid:
+    """BUG-9: Validate original residue before swapping."""
+
+    def test_basic_swap(self):
+        seq = "MVLSPADKTN"
+        result = swap_amino_acid(seq, 1, "A")
+        assert result == "AVLSPADKTN"
+
+    def test_last_position(self):
+        seq = "MVLSPADKTN"
+        result = swap_amino_acid(seq, 10, "A")
+        assert result == "MVLSPADKTA"
+
+    def test_validation_passes(self):
+        seq = "MVLSPADKTN"
+        result = swap_amino_acid(seq, 1, "A", expected_ref="M")
+        assert result[0] == "A"
+
+    def test_validation_fails(self):
+        seq = "MVLSPADKTN"
+        with pytest.raises(ValueError, match="Expected G at position 1"):
+            swap_amino_acid(seq, 1, "A", expected_ref="G")
+
+    def test_position_out_of_range(self):
+        with pytest.raises(ValueError, match="out of range"):
+            swap_amino_acid("MVLS", 0, "A")
+        with pytest.raises(ValueError, match="out of range"):
+            swap_amino_acid("MVLS", 5, "A")
+
+    def test_invalid_aa_code(self):
+        with pytest.raises(ValueError, match="Invalid amino acid"):
+            swap_amino_acid("MVLS", 1, "X")
+
+
+class TestGenerateMutantSequences:
+    def test_generates_fasta_files(self, tmp_path):
+        ref_seq = "MVLSPADKTNVKAAWGKVGA"
+        variants = [("M", 1, "A"), ("V", 2, "G")]
+        results = generate_mutant_sequences(ref_seq, variants, str(tmp_path))
+
+        assert len(results) == 2
+        assert results[0][0] == "M1A"
+        assert results[0][1].exists()
+
+        content = results[0][1].read_text()
+        assert content.startswith(">M1A\n")
+        assert content.strip().split("\n")[1][0] == "A"
+
+    def test_skips_mismatched_variants(self, tmp_path):
+        ref_seq = "MVLS"
+        variants = [("G", 1, "A")]  # G ≠ M at position 1
+        results = generate_mutant_sequences(ref_seq, variants, str(tmp_path))
+        assert len(results) == 0  # skipped
+
+
+# ============================================================================
+# Tests for variantfold.graphs
+# ============================================================================
+
+from variantfold.graphs import pdb_to_graph, load_pdb_directory
+
+
+def _make_minimal_pdb(path: str, n_residues: int = 10) -> None:
+    """Write a minimal valid PDB file for testing."""
+    lines = []
+    for i in range(n_residues):
+        atom_num = i + 1
+        res_num = i + 1
+        x = float(i * 3.8)
+        y = 0.0
+        z = 0.0
+        b_factor = 80.0 + i
+        lines.append(
+            f"ATOM  {atom_num:5d}  CA  ALA A{res_num:4d}    "
+            f"{x:8.3f}{y:8.3f}{z:8.3f}  1.00{b_factor:6.2f}           C  "
+        )
+    lines.append("END")
+    with open(path, "w") as f:
+        f.write("\n".join(lines) + "\n")
+
+
+class TestPdbToGraph:
+    def test_creates_graph(self, tmp_path):
+        pdb = tmp_path / "test.pdb"
+        _make_minimal_pdb(str(pdb), n_residues=10)
+
+        data = pdb_to_graph(str(pdb), distance_threshold=6.5, label=0)
+        assert data.x is not None
+        assert data.edge_index.shape[0] == 2
+        assert data.y.item() == 0
+
+    def test_rich_features_shape(self, tmp_path):
+        pdb = tmp_path / "test.pdb"
+        _make_minimal_pdb(str(pdb), n_residues=5)
+
+        data = pdb_to_graph(str(pdb), use_residue_features=True, label=1)
+        assert data.x.shape == (5, 24)  # 20 AA + 3 coords + 1 pLDDT
+
+    def test_legacy_features_shape(self, tmp_path):
+        pdb = tmp_path / "test.pdb"
+        _make_minimal_pdb(str(pdb), n_residues=5)
+
+        data = pdb_to_graph(str(pdb), use_residue_features=False, label=0)
+        assert data.x.shape == (5, 1)
+
+    def test_vus_label_is_none(self, tmp_path):
+        pdb = tmp_path / "test.pdb"
+        _make_minimal_pdb(str(pdb), n_residues=5)
+
+        data = pdb_to_graph(str(pdb), label=None)
+        assert data.y is None
+
+
+class TestLoadPdbDirectory:
+    def test_loads_multiple_pdbs(self, tmp_path):
+        for i in range(3):
+            _make_minimal_pdb(str(tmp_path / f"var_{i}.pdb"), n_residues=8)
+
+        graphs = load_pdb_directory(str(tmp_path), label=1)
+        assert len(graphs) == 3
+        assert all(g.y.item() == 1 for g in graphs)
+
+    def test_empty_directory(self, tmp_path):
+        graphs = load_pdb_directory(str(tmp_path), label=0)
+        assert graphs == []
+
+
+# ============================================================================
+# Tests for variantfold.model
+# ============================================================================
+
+from variantfold.model import VariantGCN, train_model, predict_vus, save_model, load_model
+
+
+class TestVariantGCN:
+    def test_forward_pass(self):
+        from torch_geometric.data import Batch
+
+        model = VariantGCN(input_dim=24, hidden_dim=16, num_layers=2).float()
+
+        # Create a small fake batch
+        data1 = torch_geometric.data.Data(
+            x=torch.randn(10, 24),
+            edge_index=torch.tensor([[0,1,2,3], [1,2,3,4]], dtype=torch.long),
+            y=torch.tensor([0]),
+        )
+        data2 = torch_geometric.data.Data(
+            x=torch.randn(8, 24),
+            edge_index=torch.tensor([[0,1,2], [1,2,3]], dtype=torch.long),
+            y=torch.tensor([1]),
+        )
+        batch = Batch.from_data_list([data1, data2])
+
+        out = model(batch)
+        assert out.shape == (2, 2)  # 2 graphs, 2 classes
+
+
+class TestSaveLoadModel:
+    def test_round_trip(self, tmp_path):
+        model = VariantGCN(input_dim=24, hidden_dim=16, num_layers=2)
+        path = str(tmp_path / "model.pt")
+
+        save_model(model, path, config={"input_dim": 24, "hidden_dim": 16, "num_layers": 2})
+        loaded = load_model(path)
+
+        # Check that parameters match
+        for (n1, p1), (n2, p2) in zip(
+            model.named_parameters(), loaded.named_parameters()
+        ):
+            assert n1 == n2
+            assert torch.equal(p1, p2)
+
+
+# ============================================================================
+# Tests for variantfold.config
+# ============================================================================
+
+from variantfold.config import VariantFoldConfig
+
+
+class TestConfig:
+    def test_defaults(self):
+        cfg = VariantFoldConfig(gene_symbol="TP53", entrez_email="test@test.com")
+        assert cfg.work_dir == "./variantfold_TP53"
+        assert cfg.distance_threshold == 6.5
+        assert cfg.num_node_features == 24
+
+    def test_legacy_features(self):
+        cfg = VariantFoldConfig(
+            gene_symbol="TP53", entrez_email="test@test.com",
+            use_residue_features=False,
+        )
+        assert cfg.num_node_features == 1
+
+    def test_ensure_directories(self, tmp_path):
+        cfg = VariantFoldConfig(
+            gene_symbol="VHL", entrez_email="test@test.com",
+            work_dir=str(tmp_path / "test_run"),
+        )
+        cfg.ensure_directories()
+        assert os.path.isdir(cfg.benign_library)
+        assert os.path.isdir(cfg.vus_library)
+
+
+# Need this import for the model test
+import torch_geometric.data

variantfold-0.1.0/variantfold/__init__.py

@@ -0,0 +1,41 @@
+"""
+VariantFold — Classify variants of uncertain significance using
+AlphaFold-predicted protein structures and graph neural networks.
+
+Workflow
+--------
+1. Parse ClinVar variant data
+2. Mutate reference protein sequences
+3. Predict 3-D structures with ColabFold / AlphaFold
+4. Convert PDB structures to residue-level graphs
+5. Train a GCN classifier (benign vs pathogenic)
+6. Classify VUS with the trained model
+"""
+
+__version__ = "0.1.0"
+
+from variantfold.config import VariantFoldConfig
+from variantfold.variants import (
+    parse_clinvar_variant,
+    load_clinvar_table,
+    swap_amino_acid,
+    generate_mutant_sequences,
+)
+from variantfold.graphs import pdb_to_graph, load_pdb_directory
+from variantfold.model import VariantGCN, train_model, evaluate_model, predict_vus
+from variantfold.pipeline import VariantFoldPipeline
+
+__all__ = [
+    "VariantFoldConfig",
+    "parse_clinvar_variant",
+    "load_clinvar_table",
+    "swap_amino_acid",
+    "generate_mutant_sequences",
+    "pdb_to_graph",
+    "load_pdb_directory",
+    "VariantGCN",
+    "train_model",
+    "evaluate_model",
+    "predict_vus",
+    "VariantFoldPipeline",
+]