Upload 5 files

CHAFF_processing_scripts/st1_download_pubchem.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""
+Download canonical SMILES and assay outcome for all compounds in a PubChem BioAssay (AID).
+Uses ListKey interface to handle large assays (>10,000 compounds).
+
+Usage:
+    python download_pubchem.py 584 --output smiles_with_outcome.csv
+"""
+
+import argparse
+import csv
+import sys
+import time
+import requests
+from typing import Dict, Tuple
+from io import StringIO
+
+PUG_BASE = "https://pubchem.ncbi.nlm.nih.gov/rest/pug"
+
+def get_listkey_for_aid(aid: str) -> Tuple[str, int]:
+    """Get ListKey and size for a given AID (used to retrieve large CID sets)."""
+    url = f"{PUG_BASE}/assay/aid/{aid}/cids/JSON?list_return=listkey"
+    try:
+        resp = requests.get(url, timeout=20)
+        resp.raise_for_status()
+        data = resp.json()["IdentifierList"]
+        listkey = data["ListKey"]
+        size = data["Size"]
+        print(f"Retrieved ListKey: {listkey} with {size} CIDs.")
+        return listkey, size
+    except Exception as e:
+        print(f"Error retrieving ListKey for AID {aid}: {e}", file=sys.stderr)
+        sys.exit(1)
+
+def fetch_smiles_from_listkey(listkey: str) -> Dict[int, str]:
+    """Fetch SMILES in batches using ListKey."""
+    smiles_dict = {}
+    url = f"{PUG_BASE}/compound/listkey/{listkey}/property/SMILES/CSV"
+    try:
+        resp = requests.get(url, timeout=30)
+        resp.raise_for_status()
+        reader = csv.DictReader(StringIO(resp.text))
+        count = 0
+        for row in reader:
+            cid = int(row["CID"])
+            smiles = row["SMILES"]
+            smiles_dict[cid] = smiles
+            count += 1
+        print(f"Fetched {count} SMILES")
+    except Exception as e:
+        print(f"Error fetching SMILES: {e}", file=sys.stderr)
+    return smiles_dict
+
+def fetch_outcomes_from_listkey(aid: int, listkey: str, size: int, batch_size: int, delay: float) -> Dict[int, str]:
+    """Fetch outcomes in batches using ListKey."""
+    outcomes = {}
+    for start in range(0, size, batch_size):
+        url = f"{PUG_BASE}/assay/aid/{aid}/CSV?cid=listkey&listkey={listkey}&listkey_start={start}&listkey_count={batch_size}"
+        try:
+            resp = requests.get(url, timeout=30)
+            resp.raise_for_status()
+            reader = csv.DictReader(StringIO(resp.text))
+            for row in reader:
+                if "PUBCHEM_CID" in row and row["PUBCHEM_CID"].isdigit():
+                    cid = int(row["PUBCHEM_CID"])
+                    outcome = row.get("PUBCHEM_ACTIVITY_OUTCOME", "Unavailable")
+                    outcomes[cid] = outcome                
+            print(f"Fetched outcomes for {len(outcomes)} compounds.")
+            time.sleep(delay)
+        except Exception as e:
+            print(f"Error fetching assay outcomes: {e}", file=sys.stderr)
+            sys.exit(1)
+    return outcomes            
+
+def write_to_csv(smiles_dict: Dict[int, str], outcomes: Dict[int, str], output_file: str):
+    """Write combined CID, SMILES, and outcome to CSV."""
+    with open(output_file, "w", newline='') as f:
+        writer = csv.writer(f)
+        writer.writerow(["CID", "CanonicalSMILES", "AssayOutcome"])
+        for cid, smiles in smiles_dict.items():
+            outcome = outcomes.get(cid, "Unavailable")
+            writer.writerow([cid, smiles, outcome])
+    print(f"Saved {len(smiles_dict)} entries to {output_file}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Download SMILES and outcome using ListKey for a PubChem assay")
+    parser.add_argument("aid", help="PubChem Assay ID (AID)")
+    parser.add_argument("--output", "-o", default="smiles_with_outcome.csv", help="Output CSV file")
+    parser.add_argument("--batch-size", type=int, default=10000, help="Batch size for ListKey download")
+    parser.add_argument("--delay", type=float, default=0.5, help="Delay between batches (in seconds)")    
+    args = parser.parse_args()
+
+    listkey, size = get_listkey_for_aid(args.aid)
+    smiles_dict = fetch_smiles_from_listkey(listkey)
+    outcomes = fetch_outcomes_from_listkey(args.aid, listkey, size, batch_size=args.batch_size, delay=args.delay)
+    write_to_csv(smiles_dict, outcomes, args.output)
+
+if __name__ == "__main__":
+    main()

CHAFF_processing_scripts/st2_run_download_pubchem.py

@@ -0,0 +1,20 @@
+import os
+import subprocess
+
+aid_list = [
+    632, 1641, 1730, 1857, 1926, 435026, 504689, 720541, 1159604,
+    587, 588, 589, 590, 591, 592, 593, 594, 709, 923, 1480, 1483, 1696, 1775, 1776, 2124, 2757,
+    588517, 588620, 624483, 720675, 720678, 720680, 720681, 720682, 720686, 720687,
+    584, 585, 1476, 1478, 485294, 485341, # Detergents
+    411, 1006, 1269, 1379, 1891, 2515, 2530, 366887, 366889, 366891, 488838, 493175,
+    588342, 588498, 602357, 602358, 602364, 602474, 602475, 602476, 602477,
+    624030, 652016, 720522, 720835, 1224835, 1347047,
+    672, 682, 936,
+    878, 888, 929, 1234
+    ]
+
+for aid in aid_list:
+    output_file = f"./raw/pubchem_aid_{aid}.csv"
+    command = ["python", "st1_download_pubchem.py", str(aid), "--output", output_file]
+    print(f"Running: {' '.join(command)}")
+    subprocess.run(command)

CHAFF_processing_scripts/st3_extract_active_compounds.py

@@ -0,0 +1,25 @@
+import os
+import pandas as pd
+import glob
+
+file_path = "./raw/*.csv"
+
+# Extract active compounds from the datasets
+for file in glob.glob(file_path):
+    name = os.path.splitext(os.path.basename(file))[0]
+    output_path = f"./active/{name}_active.csv"
+
+    if os.path.exists(output_path):
+        print(f"Skipping {name}, already exists.")
+        continue
+
+    raw_df = pd.read_csv(file)
+    active_df = raw_df[raw_df['AssayOutcome'] == 'Active']
+   
+    # Save new CSV file
+    active_df.to_csv(output_path, index=False)
+    print(f"Saved {len(active_df)} active compounds out of {len(raw_df)} to {output_path}")
+
+
+
+

CHAFF_processing_scripts/st4_smiles_curation.py

@@ -0,0 +1,91 @@
+import os
+import pandas as pd
+import rdkit
+import molvs
+import tqdm
+import glob
+from rdkit import Chem
+
+standardizer = molvs.Standardizer()
+fragment_remover = molvs.fragment.FragmentRemover()
+
+
+excluded_aids = {"584", "585", "1478", "1476", "485294", "485341"}  # with/without detergents
+
+file_path = "./active/*.csv"
+
+for file in glob.glob(file_path):
+    file_name = os.path.splitext(os.path.basename(file))[0]
+    aid = file_name.replace("pubchem_aid_", "").replace("_active", "")
+
+    if aid in excluded_aids:
+        print(f"Skipping {aid} (excluded).")
+        continue
+
+    output_path = f"./curated/{file_name}_curated.csv"
+    if os.path.exists(output_path):
+        print(f"Skipping {file_name}, already exists.")
+        continue
+
+    active_df = pd.read_csv(file)
+    smiles_series = active_df["CanonicalSMILES"]
+    active_df["curated_SMILES"] = None
+    cid = active_df["CID"]
+
+    # --------- SMILES sanitization --------- 
+    valid_indices = []
+    invalid_smiles = []
+    warning_smiles = []
+
+    for idx, smiles in smiles_series.items():
+        mol = Chem.MolFromSmiles(smiles)
+        compound_cid = cid.iloc[idx]
+
+        if mol is None:
+            invalid_smiles.append({
+                'CID': compound_cid,
+                'SMILES': smiles,
+                'Reason': "MolFromSmiles returned None"
+            })
+            continue
+
+        results = molvs.validate_smiles(smiles)
+
+        if len(results) > 0:
+            warning_smiles.append({
+                'CID': compound_cid,
+                'SMILES': smiles,
+                'Reason': results
+            })
+            continue
+
+        mol = standardizer.standardize(mol)
+        mol = fragment_remover.remove(mol)
+        standardized = Chem.MolToSmiles(mol)
+
+        active_df.at[idx, "curated_SMILES"] = standardized
+        valid_indices.append(idx)
+
+    # Save valid entries
+    valid_df = active_df.loc[valid_indices].reset_index(drop=True)
+    valid_df = valid_df.drop(columns=["CanonicalSMILES"])
+    valid_df = valid_df.rename(columns={"curated_SMILES": "SMILES"})
+
+    # Create DataFrames for invalid and warning
+    invalid_df = pd.DataFrame(invalid_smiles)
+    warning_df = pd.DataFrame(warning_smiles)
+
+    # Add AID column to dataframes
+    valid_df.insert(0, "AID", aid)
+    invalid_df.insert(0, "AID", aid)
+    warning_df.insert(0, "AID", aid)
+
+    # Save csv files
+    valid_df.to_csv(f'./curated/{file_name}_curated.csv', index=False)
+    invalid_df.to_csv(f'./curated/{file_name}_invalid_smiles.csv', index=False)
+    warning_df.to_csv(f'./curated/{file_name}_molvs_validation.csv', index=False)
+
+    print(f"Number of compounds in {file_name}:", len(active_df))
+    print(f"Number of invalid smiles in {file_name}: {len(invalid_df)}")
+    print(f"Number of warning smiles in {file_name}: {len(warning_df)}\n")
+

CHAFF_processing_scripts/st5_detergent_smiles_curation.py

@@ -0,0 +1,121 @@
+import os
+import pandas as pd
+import rdkit
+import molvs
+import tqdm
+import glob
+from rdkit import Chem
+
+standardizer = molvs.Standardizer()
+fragment_remover = molvs.fragment.FragmentRemover()
+
+
+# AID mapping {without : with detergent}
+filter_map = {
+    "585": "584",
+    "1476": "1478",
+    "485341": "485294"
+}
+
+# AID -> CID set maaping
+cid_sets = {}
+
+# Gather CIDs
+for target_aid in filter_map.values():
+    file_name = f"pubchem_aid_{target_aid}_active.csv"
+    file_full_path = os.path.join("./active", file_name)
+
+    if os.path.exists(file_full_path):
+        df = pd.read_csv(file_full_path)
+        cid_sets[target_aid] = set(df["CID"].tolist())
+    else:
+        print(f"Warning: file for AID {target_aid} not found!")
+
+# Fliter
+for target_aid, filter_aid in filter_map.items():
+    file_name = f"pubchem_aid_{target_aid}_active.csv"
+    file_full_path = os.path.join("./active", file_name)
+
+    if not os.path.exists(file_full_path):
+        print(f"Skipping {target_aid}, file not found.")
+        continue
+
+    df = pd.read_csv(file_full_path)
+
+    before = len(df)
+    df = df[~df["CID"].isin(cid_sets[filter_aid])]
+    after = len(df)
+
+    output_path = f"./active/pubchem_aid_{target_aid}_active_filtered.csv"
+    df.to_csv(output_path, index=False)
+
+    print(f"{target_aid}: removed {before - after} compounds from {before}, saved to {output_path}")
+
+
+filtered_files = [
+    "pubchem_aid_585_active_filtered.csv",
+    "pubchem_aid_1476_active_filtered.csv",
+    "pubchem_aid_485341_active_filtered.csv"
+]
+
+
+for file in filtered_files:
+    file_path = os.path.join("./active", file)
+    file_name = os.path.splitext(file)[0]
+
+    # Read file
+    active_df = pd.read_csv(file_path)
+    smiles_series = active_df["CanonicalSMILES"]
+    active_df["curated_SMILES"] = None
+    cid = active_df["CID"]
+
+    valid_indices = []
+    invalid_smiles = []
+    warning_smiles = []
+
+    for idx, smiles in smiles_series.items():
+        mol = Chem.MolFromSmiles(smiles)
+        compound_cid = cid.iloc[idx]
+
+        if mol is None:
+            invalid_smiles.append({
+                'CID': compound_cid,
+                'SMILES': smiles,
+                'Reason': "MolFromSmiles returned None"
+            })
+            continue
+
+        results = molvs.validate_smiles(smiles)
+        if len(results) > 0:
+            warning_smiles.append({
+                'CID': compound_cid,
+                'SMILES': smiles,
+                'Reason': results
+            })
+            continue
+
+        mol = standardizer.standardize(mol)
+        mol = fragment_remover.remove(mol)
+        standardized = Chem.MolToSmiles(mol)
+
+        active_df.at[idx, "curated_SMILES"] = standardized
+        valid_indices.append(idx)
+
+    # Save outputs
+    valid_df = active_df.loc[valid_indices].reset_index(drop=True)
+    valid_df = valid_df.drop(columns=["CanonicalSMILES"])
+    valid_df = valid_df.rename(columns={"curated_SMILES": "SMILES"})
+    aid = file_name.replace("pubchem_aid_", "").replace("_active_filtered", "")
+    valid_df.insert(0, "AID", aid)
+
+    invalid_df = pd.DataFrame(invalid_smiles)
+    warning_df = pd.DataFrame(warning_smiles)
+    invalid_df.insert(0, "AID", aid)
+    warning_df.insert(0, "AID", aid)
+
+    valid_df.to_csv(f'./curated/{file_name}_curated.csv', index=False)
+    invalid_df.to_csv(f'./curated/{file_name}_invalid_smiles.csv', index=False)
+    warning_df.to_csv(f'./curated/{file_name}_molvs_validation.csv', index=False)
+
+    print(f"Finished curation for {file_name}")
+    print(f"  Valid: {len(valid_df)}, Invalid: {len(invalid_df)}, Warnings: {len(warning_df)}\n")