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