initial commit

.gitattributes

@@ -0,0 +1 @@
+data/pdb.parquet filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1 @@
+slurm-*

README.md

@@ -0,0 +1,34 @@
+## How to use the data sets
+
+This dataset contains more about 80,000 unique pairs of protein sequences and ligand SMILES, and the coordinates
+of their complexes from the PDB. Only ligands with a molecular weight >= 100 Da are included.
+
+SMILES are assumed to be tokenized by the regex from P. Schwaller.
+
+Every (x,y,z) ligand coordinate maps onto a SMILES token, and is *nan* if the token does not represent an atom
+
+Every receptor coordinate maps onto the Calpha coordinate of that residue.
+
+The dataset can be used to fine-tune a language model, all data comes from PDBind-cn.
+
+### Use the already preprocessed data
+
+Load a test/train split using
+
+```
+from datasets import load_dataset
+train = load_dataset("jglaser/pdb_protein_ligand_complexes",split='train[:90%]')
+validation = load_dataset("jglaser/pdb_protein_ligand_complexes",split='train[90%:]')
+```
+
+### Manual update from PDB
+
+```
+# download the PDB archive into folder pdb/
+sh rsync.sh 24 # number of parallel download processes
+
+# extract sequences and coordinates in parallel
+sbatch pdb.slurm
+# or
+mpirun -n 42 parse_complexes.py # desired number of tasks
+```

batch_download.sh

@@ -0,0 +1,114 @@
+#!/bin/bash
+
+# Script to download files from RCSB http file download services.
+# Use the -h switch to get help on usage.
+
+if ! command -v curl &> /dev/null
+then
+    echo "'curl' could not be found. You need to install 'curl' for this script to work."
+    exit 1
+fi
+
+PROGNAME=$0
+BASE_URL="https://files.rcsb.org/download"
+
+usage() {
+  cat << EOF >&2
+Usage: $PROGNAME -f <file> [-o <dir>] [-c] [-p]
+
+ -f <file>: the input file containing a comma-separated list of PDB ids
+ -o  <dir>: the output dir, default: current dir
+ -c       : download a cif.gz file for each PDB id
+ -p       : download a pdb.gz file for each PDB id (not available for large structures)
+ -a       : download a pdb1.gz file (1st bioassembly) for each PDB id (not available for large structures)
+ -x       : download a xml.gz file for each PDB id
+ -s       : download a sf.cif.gz file for each PDB id (diffraction only)
+ -m       : download a mr.gz file for each PDB id (NMR only)
+ -r       : download a mr.str.gz for each PDB id (NMR only)
+EOF
+  exit 1
+}
+
+download() {
+  url="$BASE_URL/$1"
+  out=$2/$1
+  echo "Downloading $url to $out"
+  curl -s -f $url -o $out || echo "Failed to download $url"
+}
+
+listfile=""
+outdir="."
+cif=false
+pdb=false
+pdb1=false
+xml=false
+sf=false
+mr=false
+mrstr=false
+while getopts f:o:cpaxsmr o
+do
+  case $o in
+    (f) listfile=$OPTARG;;
+    (o) outdir=$OPTARG;;
+    (c) cif=true;;
+    (p) pdb=true;;
+    (a) pdb1=true;;
+    (x) xml=true;;
+    (s) sf=true;;
+    (m) mr=true;;
+    (r) mrstr=true;;
+    (*) usage
+  esac
+done
+shift "$((OPTIND - 1))"
+
+if [ "$listfile" == "" ]
+then
+  echo "Parameter -f must be provided"
+  exit 1
+fi
+contents=$(cat $listfile)
+
+# see https://stackoverflow.com/questions/918886/how-do-i-split-a-string-on-a-delimiter-in-bash#tab-top
+IFS=',' read -ra tokens <<< "$contents"
+
+for token in "${tokens[@]}"
+do
+  if [ "$cif" == true ]
+  then
+    download ${token}.cif.gz $outdir
+  fi
+  if [ "$pdb" == true ]
+  then
+    download ${token}.pdb.gz $outdir
+  fi
+  if [ "$pdb1" == true ]
+  then
+    download ${token}.pdb1.gz $outdir
+  fi
+  if [ "$xml" == true ]
+  then
+    download ${token}.xml.gz $outdir
+  fi
+  if [ "$sf" == true ]
+  then
+    download ${token}-sf.cif.gz $outdir
+  fi
+  if [ "$mr" == true ]
+  then
+    download ${token}.mr.gz $outdir
+  fi
+  if [ "$mrstr" == true ]
+  then
+    download ${token}_mr.str.gz $outdir
+  fi
+
+done
+
+
+
+
+
+
+
+

data/pdb.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c503ec9218e87f192d710838a0123f01ac1e48b75b288f0adc229cb025d1b592
+size 1005021071

get_pdb_ids.py

@@ -0,0 +1,14 @@
+from rcsbsearch import Terminal
+from rcsbsearch import rcsb_attributes as attrs
+
+# Create terminals for each query
+q1 = attrs.rcsb_entry_info.nonpolymer_entity_count > 0
+q2 = attrs.rcsb_entry_info.polymer_entity_count_protein > 0
+q3 = Terminal('chem_comp.formula_weight','greater_or_equal',150,service='text_chem')
+
+# combined using bitwise operators (&, |, ~, etc)
+query = q1 & q2 & q3  # AND of all queries
+
+# Call the query to execute it
+for assemblyid in query("entry"):
+    print(assemblyid)

parse_complexes.py

@@ -0,0 +1,196 @@
+#!/usr/bin/env python
+
+# Split a protein-ligand complex into protein and ligands and assign ligand bond orders using SMILES strings from Ligand Export
+# Code requires Python 3.6
+
+import sys
+from prody import *
+import pandas as pd
+from rdkit import Chem
+from rdkit.Chem import AllChem
+from io import StringIO
+import requests
+
+from mpi4py import MPI
+from mpi4py.futures import MPICommExecutor
+from mpi4py.futures import MPIPoolExecutor
+
+import re
+from functools import partial
+import gzip
+from rdkit.Chem.Descriptors import ExactMolWt
+import numpy as np
+
+import os
+
+# minimum molecular weight to consider sth a ligand
+mol_wt_cutoff = 100
+
+# all punctuation
+punctuation_regex  = r"""(\(|\)|\.|=|#|-|\+|\\|\/|:|~|@|\?|>>?|\*|\$|\%[0-9]{2}|[0-9])"""
+
+# tokenization regex (Schwaller)
+molecule_regex = r"""(\[[^\]]+]|Br?|Cl?|N|O|S|P|F|I|b|c|n|o|s|p|\(|\)|\.|=|#|-|\+|\\|\/|:|~|@|\?|>>?|\*|\$|\%[0-9]{2}|[0-9])"""
+
+max_seq = 2046 # = 2048 - 2 (accounting for [CLS] and [SEP])
+max_smiles = 510 # = 512 - 2
+
+def get_protein_sequence_and_coords(receptor):
+    calpha = receptor.select('calpha')
+    xyz = calpha.getCoords()
+    seq = calpha.getSequence()
+    return seq, xyz.tolist()
+
+def tokenize_ligand(mol):
+    # convert to SMILES and map atoms
+    smi = Chem.MolToSmiles(mol)
+
+    # position of atoms in SMILES (not counting punctuation)
+    atom_order = [int(s) for s in list(filter(None,re.sub(r'[\[\]]','',mol.GetProp("_smilesAtomOutputOrder")).split(',')))]
+
+    # tokenize the SMILES
+    tokens = list(filter(None, re.split(molecule_regex, smi)))
+
+    # remove punctuation
+    masked_tokens = [re.sub(punctuation_regex,'',s) for s in tokens]
+
+    k = 0
+    token_pos = []
+    for i,token in enumerate(masked_tokens):
+        if token != '':
+            token_pos.append(tuple(mol.GetConformer().GetAtomPosition(atom_order[k])))
+            k += 1
+        else:
+            token_pos.append((np.nan, np.nan, np.nan))
+
+    return smi, token_pos
+
+def read_ligand_expo():
+    """
+    Read Ligand Expo data, try to find a file called
+    Components-smiles-stereo-oe.smi in the current directory.
+    If you can't find the file, grab it from the RCSB
+    :return: Ligand Expo as a dictionary with ligand id as the key
+    """
+    file_name = "Components-smiles-stereo-oe.smi"
+    try:
+        df = pd.read_csv(file_name, sep="\t",
+                         header=None,
+                         names=["SMILES", "ID", "Name"])
+    except FileNotFoundError:
+        url = f"http://ligand-expo.rcsb.org/dictionaries/{file_name}"
+        print(url)
+        r = requests.get(url, allow_redirects=True)
+        open('Components-smiles-stereo-oe.smi', 'wb').write(r.content)
+        df = pd.read_csv(file_name, sep="\t",
+                         header=None,
+                         names=["SMILES", "ID", "Name"])
+    df.set_index("ID", inplace=True)
+    return df.to_dict()
+
+
+def get_pdb_components(pdb_id):
+    """
+    Split a protein-ligand pdb into protein and ligand components
+    :param pdb_id:
+    :return:
+    """
+    with gzip.open(pdb_id,'rt') as f:
+        pdb = parsePDBStream(f)
+
+    protein = pdb.select('protein')
+    ligand = pdb.select('not protein and not water')
+    return protein, ligand
+
+
+def process_ligand(ligand, res_name, expo_dict):
+    """
+    Add bond orders to a pdb ligand
+    1. Select the ligand component with name "res_name"
+    2. Get the corresponding SMILES from the Ligand Expo dictionary
+    3. Create a template molecule from the SMILES in step 2
+    4. Write the PDB file to a stream
+    5. Read the stream into an RDKit molecule
+    6. Assign the bond orders from the template from step 3
+    :param ligand: ligand as generated by prody
+    :param res_name: residue name of ligand to extract
+    :param expo_dict: dictionary with LigandExpo
+    :return: molecule with bond orders assigned
+    """
+    output = StringIO()
+    sub_mol = ligand.select(f"resname {res_name}")
+    sub_smiles = expo_dict['SMILES'][res_name]
+    template = AllChem.MolFromSmiles(sub_smiles)
+    writePDBStream(output, sub_mol)
+    pdb_string = output.getvalue()
+    rd_mol = AllChem.MolFromPDBBlock(pdb_string)
+    new_mol = AllChem.AssignBondOrdersFromTemplate(template, rd_mol)
+    return new_mol, template
+
+def process_entry(df_dict, pdb_fn):
+    try:
+        """
+        Slit pdb into protein and ligands,
+        parse protein sequence and ligand tokens
+        :param df_dict: ligand expo data
+        :param pdb_fn: pdb entry file name
+        :return:
+        """
+        protein, ligand = get_pdb_components(pdb_fn)
+
+        ligand_mols = []
+        ligand_names = []
+
+        if ligand is not None:
+            # filter ligands by molecular weight
+            res_name_list = list(set(ligand.getResnames()))
+            for res in res_name_list:
+                mol, template = process_ligand(ligand, res, df_dict)
+
+                mol_wt = ExactMolWt(template)
+
+                if mol_wt >= mol_wt_cutoff:
+                    ligand_mols.append(mol)
+                    ligand_names.append(res)
+
+        ligand_smiles = []
+        ligand_xyz = []
+
+        pdb_name = os.path.basename(pdb_fn).split('.')[-3][3:]
+        for mol, name in zip(ligand_mols, ligand_names):
+            print('Processing {} and {}'.format(pdb_name, name))
+            smi, xyz = tokenize_ligand(mol)
+            ligand_smiles.append(smi)
+            ligand_xyz.append(xyz)
+
+        seq, receptor_xyz = get_protein_sequence_and_coords(protein)
+        return pdb_name, seq, receptor_xyz, ligand_names, ligand_smiles, ligand_xyz
+    except Exception as e:
+        print(repr(e))
+
+if __name__ == '__main__':
+    import glob
+
+    filenames = glob.glob('pdb/*/*.gz')
+    filenames = sorted(filenames)
+    comm = MPI.COMM_WORLD
+    with MPICommExecutor(comm, root=0) as executor:
+#    with MPIPoolExecutor() as executor:
+        if executor is not None:
+            # read ligand table
+            df_dict = read_ligand_expo()
+
+            result = executor.map(partial(process_entry, df_dict), filenames, chunksize=512)
+            result = list(result)
+
+            # expand sequences and ligands
+            pdb_id = [r[0] for r in result if r is not None for ligand in r[3]]
+            seq = [r[1] for r in result if r is not None for ligand in r[3]]
+            receptor_xyz = [r[2] for r in result if r is not None for ligand in r[3]]
+            lig_id = [l for r in result if r is not None for l in r[3]]
+            lig_smiles = [s for r in result if r is not None for s in r[4]]
+            lig_xyz = [xyz for r in result if r is not None for xyz in r[5]]
+
+            import pandas as pd
+            df = pd.DataFrame({'pdb_id': pdb_id, 'lig_id': lig_id, 'seq': seq, 'smiles': lig_smiles, 'receptor_xyz': receptor_xyz, 'ligand_xyz': lig_xyz})
+            df.to_parquet('data/pdb.parquet',index=False)

pdb.slurm

@@ -0,0 +1,10 @@
+#!/bin/bash
+#SBATCH -J preprocess
+#SBATCH -p batch
+#SBATCH -A STF006
+#SBATCH -t 3:00:00
+#SBATCH -N 36
+#SBATCH --ntasks-per-node=16
+
+export PYTHONUNBUFFERED=1
+srun python parse_complexes.py

pdb_protein_ligand_complexes.py

@@ -0,0 +1,130 @@
+# coding=utf-8
+# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""TODO: A dataset of protein sequences, ligand SMILES, and complex coordinates."""
+
+import huggingface_hub
+import os
+import pyarrow.parquet as pq
+import datasets
+
+
+# TODO: Add BibTeX citation
+# Find for instance the citation on arxiv or on the dataset repo/website
+_CITATION = """\
+@InProceedings{huggingface:dataset,
+title = {jglaser/pdb_protein_ligand_complexes},
+author={Jens Glaser, ORNL
+},
+year={2022}
+}
+"""
+
+# TODO: Add description of the dataset here
+# You can copy an official description
+_DESCRIPTION = """\
+A dataset to fine-tune language models on protein-ligand complex structures
+"""
+
+# TODO: Add a link to an official homepage for the dataset here
+_HOMEPAGE = ""
+
+# TODO: Add the licence for the dataset here if you can find it
+_LICENSE = "BSD two-clause"
+
+# TODO: Add link to the official dataset URLs here
+# The HuggingFace dataset library don't host the datasets but only point to the original files
+# This can be an arbitrary nested dict/list of URLs (see below in `_split_generators` method)
+_URL = "https://huggingface.co/datasets/jglaser/pdb_protein_ligand_complexes/resolve/main/"
+_data_dir = "data/"
+_file_names = {'default': _data_dir+'pdb.parquet'}
+
+_URLs = {name: _URL+_file_names[name] for name in _file_names}
+
+
+# TODO: Name of the dataset usually match the script name with CamelCase instead of snake_case
+class ProteinLigandContacts(datasets.ArrowBasedBuilder):
+    """List of protein sequences, ligand SMILES, and complex contacts."""
+
+    VERSION = datasets.Version("1.0.0")
+
+    def _info(self):
+        # TODO: This method specifies the datasets.DatasetInfo object which contains informations and typings for the dataset
+        #if self.config.name == "first_domain":  # This is the name of the configuration selected in BUILDER_CONFIGS above
+        #    features = datasets.Features(
+        #        {
+        #            "sentence": datasets.Value("string"),
+        #             "option1": datasets.Value("string"),
+        #            "answer": datasets.Value("string")
+        #            # These are the features of your dataset like images, labels ...
+        #        }
+        #    )
+        #else:  # This is an example to show how to have different features for "first_domain" and "second_domain"
+        features = datasets.Features(
+            {
+                "pdb_id": datasets.Value("string"),
+                "lig_id": datasets.Value("string"),
+                "seq": datasets.Value("string"),
+                "smiles": datasets.Value("string"),
+                "ligand_xyz": datasets.Sequence(datasets.Sequence(datasets.Value('float32'))),
+                "receptor_xyz": datasets.Sequence(datasets.Sequence(datasets.Value('float32'))),
+                # These are the features of your dataset like images, labels ...
+            }
+        )
+        return datasets.DatasetInfo(
+            # This is the description that will appear on the datasets page.
+            description=_DESCRIPTION,
+            # This defines the different columns of the dataset and their types
+            features=features,  # Here we define them above because they are different between the two configurations
+            # If there's a common (input, target) tuple from the features,
+            # specify them here. They'll be used if as_supervised=True in
+            # builder.as_dataset.
+            supervised_keys=None,
+            # Homepage of the dataset for documentation
+            homepage=_HOMEPAGE,
+            # License for the dataset if available
+            license=_LICENSE,
+            # Citation for the dataset
+            citation=_CITATION,
+        )
+
+    def _split_generators(self, dl_manager):
+        """Returns SplitGenerators."""
+        # TODO: This method is tasked with downloading/extracting the data and defining the splits depending on the configuration
+        # If several configurations are possible (listed in BUILDER_CONFIGS), the configuration selected by the user is in self.config.name
+
+        # dl_manager is a datasets.download.DownloadManager that can be used to download and extract URLs
+        # It can accept any type or nested list/dict and will give back the same structure with the url replaced with path to local files.
+        # By default the archives will be extracted and a path to a cached folder where they are extracted is returned instead of the archive
+        files = dl_manager.download_and_extract(_URLs)
+
+        return [
+            datasets.SplitGenerator(
+                # These kwargs will be passed to _generate_examples
+                name=datasets.Split.TRAIN,
+                gen_kwargs={
+                    'filepath': files["default"],
+                },
+            ),
+
+        ]
+
+    def _generate_tables(
+        self, filepath
+    ):
+        from pyarrow import fs
+        local = fs.LocalFileSystem()
+
+        for i, f in enumerate([filepath]):
+            yield i, pq.read_table(f,filesystem=local)

requirements.txt

@@ -0,0 +1,5 @@
+prody
+mpi4py
+numpy
+pandas
+rdkit

rsync.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+NPROCS=$1
+MIRRORDIR=pdb                # your top level rsync directory
+RSYNC=rsync                             # location of local rsync
+
+SERVER=rsync.wwpdb.org::ftp                                   # RCSB PDB server name
+PORT=33444                                                    # port RCSB PDB server is using
+
+# get file list, remove first and last 3 lines from output (double-check that these lines are not needed)
+${RSYNC} -lpt -v -z --delete --port=$PORT --no-h --list-only ${SERVER}/data/structures/divided/pdb/ | cut -c 44- | head -n -3 | tail -n +3 > dirlist.txt
+
+cat dirlist.txt | xargs -n1 -P${NPROCS} -I% rsync -rlpt -v -z --port=$PORT -P ${SERVER}/data/structures/divided/pdb/% $MIRRORDIR
+rm dirlist.txt

split_complex.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python
+
+# Split a protein-ligand complex into protein and ligands and assign ligand bond orders using SMILES strings from Ligand Export
+# Code requires Python 3.6
+
+import sys
+from prody import *
+import pandas as pd
+from rdkit import Chem
+from rdkit.Chem import AllChem
+from io import StringIO
+import requests
+
+
+def read_ligand_expo():
+    """
+    Read Ligand Expo data, try to find a file called
+    Components-smiles-stereo-oe.smi in the current directory.
+    If you can't find the file, grab it from the RCSB
+    :return: Ligand Expo as a dictionary with ligand id as the key
+    """
+    file_name = "Components-smiles-stereo-oe.smi"
+    try:
+        df = pd.read_csv(file_name, sep="\t",
+                         header=None,
+                         names=["SMILES", "ID", "Name"])
+    except FileNotFoundError:
+        url = f"http://ligand-expo.rcsb.org/dictionaries/{file_name}"
+        print(url)
+        r = requests.get(url, allow_redirects=True)
+        open('Components-smiles-stereo-oe.smi', 'wb').write(r.content)
+        df = pd.read_csv(file_name, sep="\t",
+                         header=None,
+                         names=["SMILES", "ID", "Name"])
+    df.set_index("ID", inplace=True)
+    return df.to_dict()
+
+
+def get_pdb_components(pdb_id):
+    """
+    Split a protein-ligand pdb into protein and ligand components
+    :param pdb_id:
+    :return:
+    """
+    pdb = parsePDB(pdb_id)
+    protein = pdb.select('protein')
+    ligand = pdb.select('not protein and not water')
+    return protein, ligand
+
+
+def process_ligand(ligand, res_name, expo_dict):
+    """
+    Add bond orders to a pdb ligand
+    1. Select the ligand component with name "res_name"
+    2. Get the corresponding SMILES from the Ligand Expo dictionary
+    3. Create a template molecule from the SMILES in step 2
+    4. Write the PDB file to a stream
+    5. Read the stream into an RDKit molecule
+    6. Assign the bond orders from the template from step 3
+    :param ligand: ligand as generated by prody
+    :param res_name: residue name of ligand to extract
+    :param expo_dict: dictionary with LigandExpo
+    :return: molecule with bond orders assigned
+    """
+    output = StringIO()
+    sub_mol = ligand.select(f"resname {res_name}")
+    sub_smiles = expo_dict['SMILES'][res_name]
+    template = AllChem.MolFromSmiles(sub_smiles)
+    writePDBStream(output, sub_mol)
+    pdb_string = output.getvalue()
+    rd_mol = AllChem.MolFromPDBBlock(pdb_string)
+    new_mol = AllChem.AssignBondOrdersFromTemplate(template, rd_mol)
+    return new_mol
+
+
+def write_pdb(protein, pdb_name):
+    """
+    Write a prody protein to a pdb file
+    :param protein: protein object from prody
+    :param pdb_name: base name for the pdb file
+    :return: None
+    """
+    output_pdb_name = f"{pdb_name}_protein.pdb"
+    writePDB(f"{output_pdb_name}", protein)
+    print(f"wrote {output_pdb_name}")
+
+
+def write_sdf(new_mol, pdb_name, res_name):
+    """
+    Write an RDKit molecule to an SD file
+    :param new_mol:
+    :param pdb_name:
+    :param res_name:
+    :return:
+    """
+    outfile_name = f"{pdb_name}_{res_name}_ligand.sdf"
+    writer = Chem.SDWriter(f"{outfile_name}")
+    writer.write(new_mol)
+    print(f"wrote {outfile_name}")
+
+
+def main(pdb_name):
+    """
+    Read Ligand Expo data, split pdb into protein and ligands,
+    write protein pdb, write ligand sdf files
+    :param pdb_name: id from the pdb, doesn't need to have an extension
+    :return:
+    """
+    df_dict = read_ligand_expo()
+    protein, ligand = get_pdb_components(pdb_name)
+    write_pdb(protein, pdb_name)
+
+    res_name_list = list(set(ligand.getResnames()))
+    for res in res_name_list:
+        new_mol = process_ligand(ligand, res, df_dict)
+        write_sdf(new_mol, pdb_name, res)
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 2:
+        main(sys.argv[1])
+    else:
+        print("Usage: {sys.argv[1]} pdb_id", file=sys.stderr)