Upload process_atomica.py

process_atomica.py

@@ -0,0 +1,240 @@
+import os
+import tempfile
+import logging
+import requests
+import pandas as pd
+from tqdm import tqdm
+from rdkit import Chem
+import pooch
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from lobster.data import upload_to_s3
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+S3_BASE_URI = os.environ["S3_BASE_URI"]
+S3_RAW = f"{S3_BASE_URI}/raw"
+S3_PROCESSED = f"{S3_BASE_URI}/pre-processed"
+
+MAX_WORKERS = 16  # for threading
+
+MODALITY_MAPPING = {
+    "polypeptide(L)": "amino_acid",
+    "polynucleotide": "nucleotide",
+    "polyribonucleotide": "nucleotide",
+    "polynucleotide (RNA)": "nucleotide",
+    "polynucleotide (DNA)": "nucleotide",
+    "polydeoxyribonucleotide": "nucleotide",
+    "polydeoxyribonucleotide/polyribonucleotide hybrid ": "nucleotide",
+    "smiles": "smiles",
+}
+
+IDENTIFIERS = {
+    "protein-peptide": "11033993",
+    "protein-rna": "11033983",
+    "protein-protein": "11033984",
+    "rna-small_molecule": "11033985",
+    "protein-small_molecule": "11033996",
+    "protein-ion": "11033989",
+    "protein-dna": "11033982",
+    "small_molecule-small_molecule": "11033997",
+}
+
+def upload_raw_datasets_to_s3() -> None:
+    for fname, identifier in IDENTIFIERS.items():
+        with tempfile.TemporaryDirectory() as tmpdir:
+            local_path = pooch.retrieve(
+                f"https://dataverse.harvard.edu/api/access/datafile/{identifier}",
+                fname=f"{fname}.csv",
+                known_hash=None,
+                path=tmpdir,
+                progressbar=True,
+            )
+            upload_to_s3(
+                s3_uri=f"{S3_RAW}/{fname}.csv",
+                local_filepath=local_path,
+            )
+
+
+def _canonicalize_smiles(smiles: str) -> str | None:
+    """Canonicalize SMILES string."""
+    mol = Chem.MolFromSmiles(smiles)
+    return Chem.MolToSmiles(mol, canonical=True) if mol else None
+
+
+def _fetch_pdb_data(pdb_id: str) -> list[dict]:
+    """Fetch molecular data from PDBe API for a given PDB ID."""
+    res = requests.get(f"https://www.ebi.ac.uk/pdbe/api/pdb/entry/molecules/{pdb_id}")
+
+    if res.status_code != 200:
+        raise Exception(f"Failed to fetch data for {pdb_id}: {res.status_code}")
+    
+    return res.json().get(pdb_id.lower(), [])
+
+
+def _fetch_smiles_data(ligand_id: str) -> str | None:
+    """Fetch SMILES string for ligand from PDBe."""
+    try:
+        res = requests.get(f"https://www.ebi.ac.uk/pdbe/api/pdb/compound/summary/{ligand_id.lower()}")
+        
+        if res.status_code != 200:
+            raise Exception(f"Failed to fetch data for {ligand_id}: {res.status_code}")
+        
+        ligand_data = res.json().get(ligand_id)[0]
+        ligand_data = iter(ligand_data["smiles"])
+        while True:
+            try:
+                smiles = next(ligand_data)["name"]
+                return _canonicalize_smiles(smiles)
+            except StopIteration:
+                break
+            except Exception:
+                continue
+    except Exception as e:
+        raise Exception(f"Failed to fetch SMILES for {ligand_id}") from e
+
+
+def _safe_extract(row_id: str, sequence_extractor: callable) -> dict | None:
+    """Safely extract sequences and modalities given a row ID and extractor."""
+    try:
+        sequences, modalities = sequence_extractor(row_id)
+    except Exception as e:
+        logger.info(f"Error processing {row_id}: {e}")
+        return None
+
+    combined = list(zip(sequences, modalities))
+    combined.sort(key=lambda x: x[1] != "polypeptide(L)")
+    sequences, modalities = zip(*combined) if combined else ([], [])
+
+    sequences = (list(sequences) + [None] * 5)[:5]
+    modalities = (list(modalities) + [None] * 5)[:5]
+
+    return {
+        "id": row_id,
+        **{f"sequence{i + 1}": sequences[i] for i in range(5)},
+        **{f"modality{i + 1}": modalities[i] for i in range(5)},
+    }
+
+
+def process_rows(df: pd.DataFrame, sequence_extractor: callable, debug: bool = False) -> pd.DataFrame:
+    """
+    Process rows in the dataframe to extract sequence and modality information.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        Input dataframe with 'id' column.
+    sequence_extractor : callable
+        Function to extract sequences and modalities given a row id.
+    debug : bool, optional
+        If True, only processes first 10 rows.
+
+    Returns
+    -------
+    pd.DataFrame
+        Dataframe with sequence and modality columns.
+    """
+    row_ids = df["id"].tolist()[:10] if debug else df["id"].tolist()
+    results = []
+    with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
+        futures = {executor.submit(_safe_extract, rid, sequence_extractor): rid for rid in row_ids}
+        for future in tqdm(as_completed(futures), total=len(futures)):
+            result = future.result()
+            if result:
+                results.append(result)
+    return pd.DataFrame(results).replace(MODALITY_MAPPING)
+
+
+
+def extract_protein_nucleotide(row_id: str) -> tuple[list[str], list[str]]:
+    """Example ID: 3adi_1.pdb_3adi_1_RNA_D&E.pdb"""
+    pdb_id = row_id.split("_")[0]
+    pdb_data = _fetch_pdb_data(pdb_id)
+    sequences, types = (
+        zip(*[(m["sequence"], m["molecule_type"]) for m in pdb_data if "sequence" in m]) if pdb_data else ([], [])
+    )
+    return list(sequences), list(types)
+
+
+def extract_protein_small_molecule(row_id: str) -> tuple[list[str], list[str]]:
+    """Example ID: 4h4e_1.pdb_4h4e_1_10G_D.pdb"""
+    parts = row_id.split("_")
+    pdb_id, ligand_id = parts[2], parts[4]
+    pdb_data = _fetch_pdb_data(pdb_id)
+    sequences, types = (
+        zip(*[(m["sequence"], m["molecule_type"]) for m in pdb_data if "sequence" in m]) if pdb_data else ([], [])
+    )
+    ligand = _fetch_smiles_data(ligand_id)
+    if ligand:
+        sequences += (ligand,)
+        types += ("smiles",)
+    return list(sequences), list(types)
+
+
+def extract_interacting_chains(row_id: str) -> tuple[list[str], list[str]]:
+    """Example ID: 2uxq_2_A_B"""
+    pdb_id, _, chain_a, chain_b = row_id.split("_")
+    chains_of_interest = {chain_a, chain_b}
+    molecules = _fetch_pdb_data(pdb_id)
+    chain_map = {}
+    for m in molecules:
+        if "sequence" not in m or "in_chains" not in m:
+            continue
+        for chain in m["in_chains"]:
+            if chain in chains_of_interest:
+                chain_map[chain] = (m["sequence"], m["molecule_type"])
+    sequences, types = [], []
+    for chain in [chain_a, chain_b]:
+        if chain in chain_map:
+            seq, mol_type = chain_map[chain]
+            sequences.append(seq)
+            types.append(mol_type)
+        else:
+            sequences.append(None)
+            types.append(None)
+    return sequences, types
+
+
+def process_protein_nucleotide(debug: bool = False) -> None:
+    df = pd.read_csv(f"{S3_RAW}/protein-dna.csv", sep="\t")
+    df_out = process_rows(df, extract_protein_nucleotide, debug=debug)
+    df_out = df_out.drop_duplicates().reset_index(drop=True)
+    df_out.to_parquet(f"{S3_PROCESSED}/protein-dna.parquet", index=False)
+
+    df = pd.read_csv(f"{S3_RAW}/protein-rna.csv", sep="\t")
+    df_out = process_rows(df, extract_protein_nucleotide, debug=debug)
+    df_out = df_out.drop_duplicates().reset_index(drop=True)
+    df_out.to_parquet(f"{S3_PROCESSED}/protein-rna.parquet", index=False)
+
+
+def process_protein_protein(debug: bool = False) -> None:
+    df = pd.read_csv(f"{S3_RAW}/protein-protein.csv", sep="\t")
+    df_out = process_rows(df, extract_interacting_chains, debug=debug)
+    df_out = df_out.drop_duplicates().reset_index(drop=True)
+    df_out.to_parquet(f"{S3_PROCESSED}/protein-protein.parquet", index=False)
+
+
+def process_protein_small_molecule(debug: bool = False) -> None:
+    df = pd.read_csv(f"{S3_RAW}/protein-small_molecule.csv", sep="\t")
+    df_out = process_rows(df, extract_protein_small_molecule, debug=debug)
+    df_out = df_out.dropna(how="all", axis=1).drop_duplicates().reset_index(drop=True)
+    df_out.to_parquet(f"{S3_PROCESSED}/protein-small_molecule.parquet", index=False)
+
+
+def process_smiles_smiles() -> None:
+    df = pd.read_csv(f"{S3_RAW}/small_molecule-small_molecule.csv")
+    df = df["id"].str.split("_", expand=True)
+    df.columns = ["id", "sequence1", "num_1", "sequence2", "num_2"]
+    df = df[df["sequence1"] != df["sequence2"]][["sequence1", "sequence2"]]
+    df.insert(1, "modality1", "smiles")
+    df.insert(3, "modality2", "smiles")
+    df = df.drop_duplicates().reset_index(drop=True)
+    df.to_parquet(f"{S3_PROCESSED}/small_molecule-small_molecule.parquet", index=False)
+
+
+if __name__ == "__main__":
+    upload_raw_datasets_to_s3()
+    process_protein_nucleotide(debug=False)
+    process_protein_protein(debug=False)
+    process_protein_small_molecule(debug=False)
+    process_smiles_smiles()