enzymetk 0.0.1__py3-none-any.whl

enzymetk/similarity_mmseqs_step.py

@@ -0,0 +1,80 @@
+"""
+Install clean and then you need to activate the environment and install and run via that. 
+
+Honestly it's a bit hacky the way they do it, not bothered to change things so have to save the data to their
+repo and then copy it out of it.
+"""
+from enzymetk.step import Step
+
+import pandas as pd
+import numpy as np
+from tempfile import TemporaryDirectory
+import subprocess
+import random
+import string
+
+
+def process_clustering(filename, df, id_column_name):
+    clustering = pd.read_csv(filename, delimiter='\t', header=None)
+    #rename heading as cluster reference and id
+    clustering.columns = ['mmseqs_representative_cluster_seq', id_column_name]
+    clustering.drop_duplicates(subset=id_column_name, keep='first', inplace=True)
+    clustering.set_index(id_column_name, inplace=True)
+    # Join the clustering with the df
+    df = df.set_index(id_column_name)
+    df = df.join(clustering, how='left')
+    df.reset_index(inplace=True)
+    return df
+
+class MMseqs(Step):
+    
+    def __init__(self, id_column_name: str, seq_column_name: str, method='search',reference_database: str = None, tmp_dir: str = None, args: list = None):
+        self.seq_column_name = seq_column_name
+        self.id_column_name = id_column_name
+        self.reference_database = reference_database # pdb should be the default
+        self.tmp_dir = tmp_dir
+        self.args = args
+        self.method = method
+        
+    def __execute(self, data: list) -> np.array:
+        df, tmp_dir = data
+        tmp_label = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
+        # Convert to a fasta
+        with open(f'{tmp_dir}/seqs.fasta', 'w') as f:
+            for i, row in df.iterrows():
+                f.write(f'>{row[self.id_column_name]}\n{row[self.seq_column_name]}\n')
+            
+        if self.reference_database is None and self.method == 'search':
+            print('Creating database')
+            cmd = ['mmseqs', 'createdb', f'{tmp_dir}/seqs.fasta', 'targetDB']
+            self.run(cmd)
+            cmd = ['mmseqs', 'createindex', 'targetDB', 'tmp']
+            self.run(cmd)
+            self.reference_database = 'targetDB'
+
+        # e.g. args --min-seq-id 0.5 -c 0.8 --cov-mode 1
+        if self.method == 'search':
+            cmd = ['mmseqs', 'easy-search', f'{tmp_dir}/seqs.fasta', self.reference_database, f'{tmp_dir}/{tmp_label}.txt', f'{tmp_dir}/tmp']
+        elif self.method == 'cluster':
+            cmd = ['mmseqs', 'easy-cluster', f'{tmp_dir}/seqs.fasta', f'{tmp_dir}/clusterRes', f'{tmp_dir}/tmp']
+        # add in args
+        if self.args is not None:
+           cmd.extend(self.args)
+
+        self.run(cmd)
+        # https://github.com/soedinglab/MMseqs2/issues/458
+        if self.method == 'search':
+            df = pd.read_csv(f'{tmp_dir}/{tmp_label}.txt', header=None, sep='\t')
+            df.columns = ['Query', 'Target', 'Sequence Identity', 'Alignment Length', 'Mismatches',  'Gap Opens', 
+                          'Query Start', 'Query End', 'Target Start', 'Target End', 'E-value', 'Bit Score']
+            return df
+        elif self.method == 'cluster':
+            df = process_clustering(f'{tmp_dir}/clusterRes_cluster.tsv', df, self.id_column_name)   
+            return df
+    
+    def execute(self, df: pd.DataFrame) -> pd.DataFrame:
+        if self.tmp_dir is not None:
+            return self.__execute([df, self.tmp_dir])
+        with TemporaryDirectory() as tmp_dir:
+            return self.__execute([df, tmp_dir])
+            return df

enzymetk/similarity_reaction_step.py

@@ -0,0 +1,60 @@
+from enzymetk.step import Step
+import pandas as pd
+import numpy as np
+from tempfile import TemporaryDirectory
+from rdkit import Chem
+from rdkit import DataStructs
+from rdkit.Chem import rdChemReactions
+import pandas as pd
+import os
+from rdkit.DataStructs import FingerprintSimilarity
+from rdkit.Chem.Fingerprints import FingerprintMols
+import random
+import string
+from tqdm import tqdm
+from multiprocessing.dummy import Pool as ThreadPool
+
+
+class ReactionDist(Step):
+    
+    def __init__(self, id_column_name: str, smiles_column_name: str, smiles_string: str, num_threads=1):
+        self.smiles_column_name = smiles_column_name
+        self.id_column_name = id_column_name
+        self.smiles_string = smiles_string
+        self.num_threads = num_threads
+        
+    def __execute(self, data: list) -> np.array:
+        reaction_df = data
+        tmp_label = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
+        
+        rxn = rdChemReactions.ReactionFromSmarts(self.smiles_string)
+        rxn_fp = rdChemReactions.CreateStructuralFingerprintForReaction(rxn)
+        rows = []
+        # compare all fp pairwise without duplicates
+        for smile_id, smiles in tqdm(reaction_df[[self.id_column_name, self.smiles_column_name]].values): # -1 so the last fp will not be used
+            mol_ = rdChemReactions.ReactionFromSmarts(smiles)
+            fps = rdChemReactions.CreateStructuralFingerprintForReaction(mol_)
+            rows.append([smile_id, 
+                         smiles, 
+                         DataStructs.TanimotoSimilarity(fps, rxn_fp), 
+                         DataStructs.RusselSimilarity(fps, rxn_fp), 
+                         DataStructs.CosineSimilarity(fps, rxn_fp)])
+        distance_df = pd.DataFrame(rows, columns=[self.id_column_name, 'TargetSmiles', 'TanimotoSimilarity', 'RusselSimilarity', 'CosineSimilarity'])
+        return distance_df
+        
+    def execute(self, df: pd.DataFrame) -> pd.DataFrame:
+        if self.num_threads > 1:
+            data = []
+            df_list = np.array_split(df, self.num_threads)
+            for df_chunk in df_list:
+                data.append(df_chunk)
+            pool = ThreadPool(self.num_threads)
+            output_filenames = pool.map(self.__execute, data)
+            df = pd.DataFrame()
+            for tmp_df in output_filenames:
+                df = pd.concat([df, tmp_df])
+            return df
+        
+        else:
+            return self.__execute(df)
+            

enzymetk/similarity_substrate_step.py

@@ -0,0 +1,59 @@
+from enzymetk.step import Step
+import pandas as pd
+import numpy as np
+from tempfile import TemporaryDirectory
+from rdkit import Chem
+from rdkit import DataStructs
+from rdkit.Chem import rdChemReactions
+import pandas as pd
+import os
+from rdkit.DataStructs import FingerprintSimilarity
+from rdkit.Chem.Fingerprints import FingerprintMols
+import random
+import string
+from tqdm import tqdm
+from multiprocessing.dummy import Pool as ThreadPool
+
+
+class SubstrateDist(Step):
+    
+    def __init__(self, id_column_name: str, smiles_column_name: str, smiles_string: str, num_threads=1):
+        self.smiles_column_name = smiles_column_name
+        self.id_column_name = id_column_name
+        self.smiles_string = smiles_string
+        self.num_threads = num_threads
+        
+    def __execute(self, data: list) -> np.array:
+        reaction_df = data
+        tmp_label = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
+        
+        rxn = Chem.MolFromSmiles(self.smiles_string)
+        rxn_fp = FingerprintMols.FingerprintMol(rxn)
+        rows = []
+        # compare all fp pairwise without duplicates
+        for smile_id, smiles in tqdm(reaction_df[[self.id_column_name, self.smiles_column_name]].values): # -1 so the last fp will not be used
+            mol_ = Chem.MolFromSmiles(smiles)
+            fps = FingerprintMols.FingerprintMol(mol_)
+            rows.append([smile_id, 
+                         smiles, 
+                         DataStructs.TanimotoSimilarity(fps, rxn_fp), 
+                         DataStructs.RusselSimilarity(fps, rxn_fp), 
+                         DataStructs.CosineSimilarity(fps, rxn_fp)])
+        distance_df = pd.DataFrame(rows, columns=[self.id_column_name, 'TargetSmiles', 'TanimotoSimilarity', 'RusselSimilarity', 'CosineSimilarity'])
+        return distance_df
+        
+    def execute(self, df: pd.DataFrame) -> pd.DataFrame:
+        if self.num_threads > 1:
+            data = []
+            df_list = np.array_split(df, self.num_threads)
+            for df_chunk in df_list:
+                data.append(df_chunk)
+            pool = ThreadPool(self.num_threads)
+            output_filenames = pool.map(self.__execute, data)
+            df = pd.DataFrame()
+            for tmp_df in output_filenames:
+                df = pd.concat([df, tmp_df])
+            return df
+        
+        else:
+            return self.__execute(df)

enzymetk/step.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+import pandas as pd
+from sciutil import SciUtil
+import timeit
+import logging
+import subprocess
+
+u = SciUtil()
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+ 
+
+class Pipeline():
+    
+    def __init__(self, *steps: Step):
+        self.steps = list(steps)
+        
+    def __rshift__(self, other: Step) -> Step:
+        return Pipeline(*self.steps, other)
+                        
+    def execute(self, df: pd.DataFrame) -> pd.DataFrame:
+        """ 
+        Execute some shit.
+        """      
+        for step in self.steps:
+            df = step.execute(df)
+        return df
+    
+    def __rlshift__(self, other: pd.DataFrame) -> pd.DataFrame:
+        return self.execute(other)
+        
+
+class Step():
+    
+    def execute(self, df: pd.DataFrame) -> pd.DataFrame:
+        """ Execute some shit """ 
+        return df
+    
+    def run(self, cmd: list) -> None:
+        """ Run a command """
+        start = timeit.default_timer()
+        u.dp(['Running command', ' '.join([str(c) for c in cmd])])
+        result = subprocess.run(cmd, capture_output=True, text=True)       
+        u.warn_p(['Output:'])
+        print(result.stdout)
+        u.err_p(['Error:', result.stderr])
+        if result.stderr:
+            logger.error(result.stderr)
+        logger.info(result.stdout)
+        u.dp(['Time for command to run (min): ', (timeit.default_timer() - start)/60])
+
+    def __rshift__(self, other: Step) -> Step:
+        return Pipeline(self, other)
+        
+    def __rlshift__(self, other: pd.DataFrame) -> pd.DataFrame:
+        """
+        Overriding the right shift operator to allow for the pipeline to be executed.
+        """
+        return self.execute(other)
+    

enzymetk-0.0.1.dist-info/METADATA

@@ -0,0 +1,370 @@
+Metadata-Version: 2.2
+Name: enzymetk
+Version: 0.0.1
+Home-page: https://github.com/arianemora/enzyme-tk/
+Author: Ariane Mora
+Author-email: ariane.n.mora@gmail.com
+License: GPL3
+Project-URL: Bug Tracker, https://github.com/arianemora/enzyme-tk/
+Project-URL: Documentation, https://github.com/arianemora/enzyme-tk/
+Project-URL: Source Code, https://github.com/arianemora/enzyme-tk/
+Keywords: enzymes,protein-engineering
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fair-esm
+Requires-Dist: scikit-learn
+Requires-Dist: numpy
+Requires-Dist: seaborn
+Requires-Dist: sciutil
+Requires-Dist: pandas==2.1.4
+Requires-Dist: biopython
+Requires-Dist: sentence_transformers
+Requires-Dist: pubchempy
+Requires-Dist: pyfaidx
+Requires-Dist: spacy
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+
+# A pipeline for enzyme engineering
+
+Enzyme-tk is a collection of tools for enzyme engineering, setup as interoperable modules that act on dataframes. These modules are designed to be imported into pipelines for specific function. For this reason, `steps` as each module is called (e.g. finding similar proteins with `BLAST` would be considered a step) are designed to be as light as possible. An example of a pipeline is the [annotate-e](https://github.com/ArianeMora/annotate-e)  ` pipeline, this acts to annotate a fasta with an ensemble of methods (each is designated as an Enzyme-tk step). 
+
+## Installation
+
+```bash
+source enzymetk/conda_envs/install_all.sh
+```
+
+## Install subsets of enzyme-tk
+
+```bash
+git clone git@github.com:ArianeMora/enzyme-tk.git
+python setup.py sdist bdist_wheel
+pip install dist/enzymetk-0.0.1.tar.gz
+```
+
+## Usage
+
+If you have any issues at all just email me using my caltech email: `amora at caltech . edu`
+
+Here are some of the tools that have been implemented to be chained together as a pipeline:
+
+[mmseqs2](https://github.com/soedinglab/mmseqs2)  
+[foldseek](https://github.com/steineggerlab/foldseek)  
+[diamond](https://github.com/bbuchfink/diamond)  
+[proteinfer](https://github.com/google-research/proteinfer)  
+[CLEAN](https://github.com/tttianhao/CLEAN)  
+[chai](https://github.com/chaidiscovery/chai-lab/)  
+[chemBERTa2](https://github.com/seyonechithrananda/bert-loves-chemistry)  
+[SELFormer](https://github.com/HUBioDataLab/SELFormer)  
+[rxnfp](https://github.com/rxn4chemistry/rxnfp)  
+[clustalomega](http://www.clustal.org/omega/)  
+[CREEP](https://github.com/jsunn-y/CARE)  
+[esm](https://github.com/facebookresearch/esm)  
+[LigandMPNN](https://github.com/dauparas/LigandMPNN)  
+[vina](https://vina.scripps.edu/)  
+[Uni-Mol](https://github.com/deepmodeling/Uni-Mol)  
+[fasttree](https://morgannprice.github.io/fasttree/)  
+[Porechop](https://github.com/rrwick/Porechop)  
+[prokka](https://github.com/tseemann/prokka)  
+## Things to note
+
+All the tools use the conda env of `enzymetk` by default.
+
+If you want to use a different conda env, you can do so by passing the `env_name` argument to the constructor of the step.
+
+For example:
+
+```python
+proteinfer = ProteInfer(env_name='proteinfer')
+```
+
+## Arguments
+
+All the arguments are passed to the constructor of the step, the ones that are required are passed as arguments to the constructor and the ones that are optional are passed as a list to the `args` argument, this needs to be a list as one would normally pass arguments to a command line tool.
+
+For example:
+
+```python
+proteinfer = ProteInfer(env_name='proteinfer', args=['--num_threads', '10'])
+```
+For those wanting to use specific arguments, check the individual tools for specifics. 
+
+## Steps
+
+The steps are the main building blocks of the pipeline. They are responsible for executing the individual tools.
+
+### BLAST
+
+BLAST is a tool for searching a database of sequences for similar sequences. Here you can either pass a database that you have already created or pass the sequences as part of your dataframe and pass the label column (this needs to have two values: reference and query) reference refers to sequences that you want to search against and query refers to sequences that you want to search for.
+
+```python
+id_col = 'Entry'
+seq_col = 'Sequence'
+label_col = 'label'
+rows = [['AXE2_TALPU', 'query', 'MHSKFFAASLLGLGAAAIPLEGVMEKRSCPAIHVFGARETTASPGYGSSSTVVNGVLSAYPGSTAEAINYPACGGQSSCGGASYSSSVAQGIAAVASAVNSFNSQCPSTKIVLVGYSQGGEIMDVALCGGGDPNQGYTNTAVQLSSSAVNMVKAAIFMGDPMFRAGLSYEVGTCAAGGFDQRPAGFSCPSAAKIKSYCDASDPYCCNGSNAATHQGYGSEYGSQALAFVKSKLG'],
+        ['AXE2_TALPU', 'reference', 'MHSKFFAASLLGLGAAAIPLEGVMEKRSCPAIHVFGARETTASPGYGSSSTVVNGVLSAYPGSTAEAINYPACGGQSSCGGASYSSSVAQGIAAVASAVNSFNSQCPSTKIVLVGYSQGGEIMDVALCGGGDPNQGYTNTAVQLSSSAVNMVKAAIFMGDPMFRAGLSYEVGTCAAGGFDQRPAGFSCPSAAKIKSYCDASDPYCCNGSNAATHQGYGSEYGSQALAFVKSKLG'],
+        ['AXE2_GEOSE', 'reference', 'MKIGSGEKLLFIGDSITDCGRARPEGEGSFGALGTGYVAYVVGLLQAVYPELGIRVVNKGISGNTVRDLKARWEEDVIAQKPDWVSIMIGINDVWRQYDLPFMKEKHVYLDEYEATLRSLVLETKPLVKGIILMTPFYIEGNEQDPMRRTMDQYGRVVKQIAEETNSLFVDTQAAFNEVLKTLYPAALAWDRVHPSVAGHMILARAFLREIGFEWVRSR'], 
+        ['AXE7A_XYLR2', 'referece', 'MFNFAPKQTTEMKKLLFTLVFVLGSMATALAENYPYRADYLWLTVPNHADWLYKTGERAKVEVSFCLYGMPQNVEVAYEIGPDMMPATSSGKVTLKNGRAVIDMGTMKKPGFLDMRLSVDGKYQHHVKVGFSPELLKPYTKNPQDFDAFWKANLDEARKTPVSVSCNKVDKYTTDAFDCYLLKIKTDRRHSIYGYLTKPKKAGKYPVVLCPPGAGIKTIKEPMRSTFYAKNGFIRLEMEIHGLNPEMTDEQFKEITTAFDYENGYLTNGLDDRDNYYMKHVYVACVRAIDYLTSLPDWDGKNVFVQGGSQGGALSLVTAGLDPRVTACVANHPALSDMAGYLDNRAGGYPHFNRLKNMFTPEKVNTMAYYDVVNFARRITCPVYITWGYNDNVCPPTTSYIVWNLITAPKESLITPINEHWTTSETNYTQMLWLKKQVK'], 
+        ['A0A0B8RHP0_LISMN', 'reference', 'MKKLLFLGDSVTDAGRDFENDRELGHGYVKIIADQLEQEDVTVINRGVSANRVADLHRRIEADAISLQPDVVTIMIGINDTWFSFSRWEDTSVTAFKEVYRVILNRIKTETNAELILMEPFVLPYPEDRKEWRGDLDPKIGAVRELAAEFGATLIPLDGLMNALAIKHGPTFLAEDGVHPTKAGHEAIASTWLEFTK']]
+df = pd.DataFrame(rows, columns=[id_col, label_col, seq_col])
+df << (BLAST(id_col, seq_col, label_col) >> Save('tmp/blast_test.pkl'))
+```
+
+### ActiveSitePred
+
+ActiveSitePred is a tool for predicting the active site of an enzyme. This returns a dataframe with the active site prediction for each sequence, and the probability of the active site. Note we use a zero index for the active site prediction while UniProt uses a one index.
+
+```python
+squidly_dir = '/disk1/share/software/AS_inference/' # This should be where you downloaded the data from zotero, there is a folder in there called AS_inference
+num_threads = 1
+id_col = 'Entry'
+seq_col = 'Sequence'
+rows = [['AXE2', 'MKIGSGEKLLFIGDSITDCGRARPEGEGSFGALGTGYVAYVVGLLQAVYPELGIRVVNKGISGNTVRDLKARWEEDVIAQKPDWVSIMIGINDVWRQYDLPFMKEKHVYLDEYEATLRSLVLETKPLVKGIILMTPFYIEGNEQDPMRRTMDQYGRVVKQIAEETNSLFVDTQAAFNEVLKTLYPAALAWDRVHPSVAGHMILARAFLREIGFEWVRSR'], 
+        ['H7C0D0', 'XRAHREIKDIFYKAIQKRRQSQEKIDDILQTLLDATYKDGRPLTDDEVAGMLIGLLLAGQHTSSTTSAWMGFFLARDKTLQKKCYLEQKTVCGENLPPLTYDQLKDLNLLDRCIKETLRLRPPIMIMMRMARTPQTVAGYTIPPGHQDNPASGEKFAYVPFGAGRHRCIGENFAYVQIKTIWSTMLRLYEFDLIDGYFPTVNYTTMIHTPENPVIRYKRRSK']]
+df = pd.DataFrame(rows, columns=[id_col, seq_col])
+print(df)
+df << (ActiveSitePred(id_col, seq_col, squidly_dir, num_threads) >> Save('tmp/squidly_as_pred.pkl'))
+
+```
+
+### Chai
+
+Chai is a tool for predicting the structure of a protein and a ligand, this tool outputs the data to a new folder and creates directories based on the id that is passed. We return the paths to the specific structure for each id in the returned dataframe.
+
+Requres the `docko` conda environment to be created.
+
+```python
+output_dir = 'tmp/'
+num_threads = 1
+id_col = 'Entry'
+seq_col = 'Sequence'
+substrate_col = 'Substrate'
+rows = [['P0DP23', 'MALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAA', 'CCCCC(CC)COC(=O)C1=CC=CC=C1C(=O)OCC(CC)CCCC'], 
+        ['AXE2', 'MKIGSGEKLLFIGDSITDCGRARPEGEGSFGALGTGYVAYVVGLLQAVYPELGIRVVNKGISGNTVRDLKARWEEDVIAQKPDWVSIMIGINDVWRQYDLPFMKEKHVYLDEYEATLRSLVLETKPLVKGIILMTPFYIEGNEQDPMRRTMDQYGRVVKQIAEETNSLFVDTQAAFNEVLKTLYPAALAWDRVHPSVAGHMILARAFLREIGFEWVRSR', 'CCCCC(CC)COC(=O)C1=CC=CC=C1C(=O)OCC(CC)CCCC']]
+df = pd.DataFrame(rows, columns=[id_col, seq_col, substrate_col])
+print(df)
+df << (Chai(id_col, seq_col, substrate_col, f'{output_dir}', num_threads) >> Save(f'{output_dir}test.pkl'))
+
+```
+
+### ChemBERTa
+
+ChemBERTa2 encodes reactions and SMILES strings into a vector space. Note this requires the base environment, i.e. `enzymetk` conda env.
+
+```python
+from steps.embedchem_chemberta_step import ChemBERT
+from steps.save_step import Save
+
+output_dir = 'tmp/'
+num_threads = 1
+id_col = 'Entry'
+seq_col = 'Sequence'
+substrate_col = 'Substrate'
+rows = [['P0DP23', 'MALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAA', 'CCCCC(CC)COC(=O)C1=CC=CC=C1C(=O)OCC(CC)CCCC'], 
+        ['P0DP24', 'MALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAA', 'CCCCC(CC)COC(=O)C1=CC=CC=C1C(=O)OCC(CC)CCCC']]
+df = pd.DataFrame(rows, columns=[id_col, seq_col, substrate_col])
+df << (ChemBERT(id_col, substrate_col, num_threads) >> Save(f'{output_dir}chemberta.pkl'))
+```
+
+### CLEAN
+
+CLEAN is a tool for predicting the EC number of an enzyme.
+
+```python
+
+output_dir = 'tmp/'
+num_threads = 1
+id_col = 'Entry'
+seq_col = 'Sequence'
+substrate_col = 'Substrate'
+rows = [['P0DP23', 'MALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAA', 'CCCCC(CC)COC(=O)C1=CC=CC=C1C(=O)OCC(CC)CCCC'], 
+        ['AXE2', 'MKIGSGEKLLFIGDSITDCGRARPEGEGSFGALGTGYVAYVVGLLQAVYPELGIRVVNKGISGNTVRDLKARWEEDVIAQKPDWVSIMIGINDVWRQYDLPFMKEKHVYLDEYEATLRSLVLETKPLVKGIILMTPFYIEGNEQDPMRRTMDQYGRVVKQIAEETNSLFVDTQAAFNEVLKTLYPAALAWDRVHPSVAGHMILARAFLREIGFEWVRSR', 'CCCCC(CC)COC(=O)C1=CC=CC=C1C(=O)OCC(CC)CCCC']]
+df = pd.DataFrame(rows, columns=[id_col, seq_col, substrate_col])
+# This should be relative to the location of the script if you installed via the install_all.sh script
+# Note you need to have downloaded their predictive models (ToDo )
+clean_dir = 'software/CLEAN/app/'
+df << (CLEAN(id_col, seq_col, clean_dir, num_threads=num_threads) >> Save(f'clean_missing_EC_seqs.pkl'))
+
+
+```
+### ClustalOmega
+
+ClustalOmega is a tool for aligning a set of sequences. This gets installed to the system (expecting a linux machine) and added to the bash path.
+
+```python
+from steps.generate_msa_step import ClustalOmega
+from steps.save_step import Save
+import pandas as pd
+
+id_col = 'Entry'
+seq_col = 'Sequence'
+label_col = 'label'
+rows = [['AXE2_TALPU', 'query', 'MHSKFFAASLLGLGAAAIPLEGVMEKRSCPAIHVFGARETTASPGYGSSSTVVNGVLSAYPGSTAEAINYPACGGQSSCGGASYSSSVAQGIAAVASAVNSFNSQCPSTKIVLVGYSQGGEIMDVALCGGGDPNQGYTNTAVQLSSSAVNMVKAAIFMGDPMFRAGLSYEVGTCAAGGFDQRPAGFSCPSAAKIKSYCDASDPYCCNGSNAATHQGYGSEYGSQALAFVKSKLG'],
+        ['AXE2_TALPU', 'reference', 'MHSKFFAASLLGLGAAAIPLEGVMEKRSCPAIHVFGARETTASPGYGSSSTVVNGVLSAYPGSTAEAINYPACGGQSSCGGASYSSSVAQGIAAVASAVNSFNSQCPSTKIVLVGYSQGGEIMDVALCGGGDPNQGYTNTAVQLSSSAVNMVKAAIFMGDPMFRAGLSYEVGTCAAGGFDQRPAGFSCPSAAKIKSYCDASDPYCCNGSNAATHQGYGSEYGSQALAFVKSKLG'],
+        ['AXE2_GEOSE', 'reference', 'MKIGSGEKLLFIGDSITDCGRARPEGEGSFGALGTGYVAYVVGLLQAVYPELGIRVVNKGISGNTVRDLKARWEEDVIAQKPDWVSIMIGINDVWRQYDLPFMKEKHVYLDEYEATLRSLVLETKPLVKGIILMTPFYIEGNEQDPMRRTMDQYGRVVKQIAEETNSLFVDTQAAFNEVLKTLYPAALAWDRVHPSVAGHMILARAFLREIGFEWVRSR'], 
+        ['AXE7A_XYLR2', 'referece', 'MFNFAPKQTTEMKKLLFTLVFVLGSMATALAENYPYRADYLWLTVPNHADWLYKTGERAKVEVSFCLYGMPQNVEVAYEIGPDMMPATSSGKVTLKNGRAVIDMGTMKKPGFLDMRLSVDGKYQHHVKVGFSPELLKPYTKNPQDFDAFWKANLDEARKTPVSVSCNKVDKYTTDAFDCYLLKIKTDRRHSIYGYLTKPKKAGKYPVVLCPPGAGIKTIKEPMRSTFYAKNGFIRLEMEIHGLNPEMTDEQFKEITTAFDYENGYLTNGLDDRDNYYMKHVYVACVRAIDYLTSLPDWDGKNVFVQGGSQGGALSLVTAGLDPRVTACVANHPALSDMAGYLDNRAGGYPHFNRLKNMFTPEKVNTMAYYDVVNFARRITCPVYITWGYNDNVCPPTTSYIVWNLITAPKESLITPINEHWTTSETNYTQMLWLKKQVK'], 
+        ['A0A0B8RHP0_LISMN', 'reference', 'MKKLLFLGDSVTDAGRDFENDRELGHGYVKIIADQLEQEDVTVINRGVSANRVADLHRRIEADAISLQPDVVTIMIGINDTWFSFSRWEDTSVTAFKEVYRVILNRIKTETNAELILMEPFVLPYPEDRKEWRGDLDPKIGAVRELAAEFGATLIPLDGLMNALAIKHGPTFLAEDGVHPTKAGHEAIASTWLEFTK']]
+df = pd.DataFrame(rows, columns=[id_col, label_col, seq_col])
+df << (ClustalOmega(id_col, seq_col) >> Save('tmp/clustalomega_test.pkl'))
+```
+
+### CREEP
+
+CREEP is a tool for predicting the EC number of a reaction. At the moment it only supports reactions to EC however we are extending this to other modalities. 
+
+```python
+from steps.annotateEC_CREEP_step import CREEP
+from steps.save_step import Save
+import pandas as pd
+
+# CREEP expects you to have downloaded the data from the zotero page and put it in the data/CREEP folder
+output_dir = 'tmp/'
+df = pd.DataFrame({'EC number': ['1.1.1.1', '1.1.1.2'], 
+                   'Sequence': ['MALWMRLLPLLALLALWGPDPAAA', 'MALWMRLLPLLALLALWGPDPAAA'], 
+                   'Reaction': ['O=P(OC1=CC=CC=C1)(OC2=CC=CC=C2)OC3=CC=CC=C3>>O=P(O)(OC4=CC=CC=C4)OC5=CC=CC=C5.OC6=CC=CC=C6',
+                                'O=P(OC1=CC=CC=C1)(OC2=CC=CC=C2)OC3=CC=CC=C3>>O=P(O)(OC4=CC=CC=C4)OC5=CC=CC=C5.OC6=CC=CC=C6']})
+id_col = 'Entry'
+reaction_col = 'Reaction'
+
+df << (CREEP(id_col, reaction_col, CREEP_cache_dir='/disk1/share/software/CREEP/data/', CREEP_dir='/disk1/share/software/CREEP/',
+            modality='reaction', reference_modality='protein') >> Save(f'{output_dir}CREEP_test_protein.pkl'))
+```
+
+### EmbedESM
+
+EmbedESM is a tool for embedding a set of sequences using ESM2.
+
+```python
+from steps.embedprotein_esm_step import EmbedESM
+from steps.save_step import Save
+import pandas as pd
+
+id_col = 'Entry'
+seq_col = 'Sequence'
+label_col = 'ActiveSite'
+rows = [['AXE2_TALPU', '10', 'MHSKFFAASLLGLGAAAIPLEGVMEKRSCPAIHVFGARETTASPGYGSSSTVVNGVLSAYPGSTAEAINYPACGGQSSCGGASYSSSVAQGIAAVASAVNSFNSQCPSTKIVLVGYSQGGEIMDVALCGGGDPNQGYTNTAVQLSSSAVNMVKAAIFMGDPMFRAGLSYEVGTCAAGGFDQRPAGFSCPSAAKIKSYCDASDPYCCNGSNAATHQGYGSEYGSQALAFVKSKLG'],
+        ['AXE2_GEOSE', '1|2', 'MKIGSGEKLLFIGDSITDCGRARPEGEGSFGALGTGYVAYVVGLLQAVYPELGIRVVNKGISGNTVRDLKARWEEDVIAQKPDWVSIMIGINDVWRQYDLPFMKEKHVYLDEYEATLRSLVLETKPLVKGIILMTPFYIEGNEQDPMRRTMDQYGRVVKQIAEETNSLFVDTQAAFNEVLKTLYPAALAWDRVHPSVAGHMILARAFLREIGFEWVRSR'], 
+        ['AXE7A_XYLR2', '1', 'MFNFAPKQTTEMKKLLFTLVFVLGSMATALAENYPYRADYLWLTVPNHADWLYKTGERAKVEVSFCLYGMPQNVEVAYEIGPDMMPATSSGKVTLKNGRAVIDMGTMKKPGFLDMRLSVDGKYQHHVKVGFSPELLKPYTKNPQDFDAFWKANLDEARKTPVSVSCNKVDKYTTDAFDCYLLKIKTDRRHSIYGYLTKPKKAGKYPVVLCPPGAGIKTIKEPMRSTFYAKNGFIRLEMEIHGLNPEMTDEQFKEITTAFDYENGYLTNGLDDRDNYYMKHVYVACVRAIDYLTSLPDWDGKNVFVQGGSQGGALSLVTAGLDPRVTACVANHPALSDMAGYLDNRAGGYPHFNRLKNMFTPEKVNTMAYYDVVNFARRITCPVYITWGYNDNVCPPTTSYIVWNLITAPKESLITPINEHWTTSETNYTQMLWLKKQVK'], 
+        ['A0A0B8RHP0_LISMN', '2', 'MKKLLFLGDSVTDAGRDFENDRELGHGYVKIIADQLEQEDVTVINRGVSANRVADLHRRIEADAISLQPDVVTIMIGINDTWFSFSRWEDTSVTAFKEVYRVILNRIKTETNAELILMEPFVLPYPEDRKEWRGDLDPKIGAVRELAAEFGATLIPLDGLMNALAIKHGPTFLAEDGVHPTKAGHEAIASTWLEFTK']]
+df = pd.DataFrame(rows, columns=[id_col, label_col, seq_col])
+df << (EmbedESM(id_col, seq_col, extraction_method='mean', tmp_dir='tmp/') >> Save('tmp/esm2_test.pkl'))
+# You can also extract the active site embedding in addition to the mean embedding
+df << (EmbedESM(id_col, seq_col, extraction_method='active_site', active_site_col='ActiveSite', tmp_dir='tmp/') >> Save('tmp/esm2_test_active_site.pkl'))
+```
+
+### FoldSeek
+
+See: [FoldSeek](https://github.com/steineggerlab/foldseek)
+
+FoldSeek does a similarity search against a database of structures, it runs in the `enzyme-tk` environment. Similarly to the diamond blast, you can either create databases yourself before hand using the 
+foldseek documentation or you can create a database on the fly by passing the dataframe with a column called `label` that has two values: `reference` and `query`.
+If you pass a database, you need to pass the path to the database.
+
+The columns expect a path to a pdb file i.e. the output from the `Chai` step.
+
+```python
+from steps.similarity_foldseek_step import FoldSeek
+from steps.save_step import Save
+import pandas as pd
+
+# id_col: str, seq_col: str, proteinfer_dir: str,
+output_dir = 'tmp/'
+rows = [['tmp/P0DP24/chai/P0DP24_3.cif'],
+        ['tmp/P0DP24/chai/P0DP24_1.cif']]
+df = pd.DataFrame(rows, columns=['pdbs'])
+# foldseek_dir: str, pdb_column_name: str, reference_database: str
+pdb_column_name = 'pdbs'
+# The foldseek database was created using the folldwing command in this location:
+# foldseek databases PDB pdb tmp 
+reference_database = '/disk1/share/software/foldseek/structures/pdb/pdb'
+df << (FoldSeek(pdb_column_name, reference_database) >> Save(f'{output_dir}pdb_files.pkl'))
+
+```
+
+### LigandMPNN
+
+LigandMPNN is a tool for inpainting the sequence for a protein backbone that has been generated by a generative model.
+
+See: [LigandMPNN](https://github.com/dauparas/LigandMPNN)
+
+```python
+from steps.inpaint_ligandMPNN_step import LigandMPNN
+from steps.save_step import Save
+import pandas as pd
+
+# id_col: str, seq_col: str, proteinfer_dir: str,
+# This needs to be the full path to the file since LigandMPNN requires the full path (otherwise it will save to the ligandmpnn directory)
+output_dir = '/disk1/ariane/vscode/enzyme-tk/examples/tmp/'
+# These have to be the full path to the file since LigandMPNN requires the full path.
+rows = [['/disk1/ariane/vscode/enzyme-tk/examples/tmp/P0DP24/chai/P0DP24_3.cif'],
+        ['/disk1/ariane/vscode/enzyme-tk/examples/tmp/P0DP24/chai/P0DP24_1.cif']]
+df = pd.DataFrame(rows, columns=['pdbs'])
+# foldseek_dir: str, pdb_column_name: str, reference_database: str
+pdb_column_name = 'pdbs'
+ligand_mpnn_dir = '/disk1/share/software/LigandMPNN/'
+# See how you need to enclose the fixed residues in quotes make sure any spaces are closed in double quotes!
+args = ['--fixed_residues', '"A19 A20 A21 A59 A60 A61 A90 A91 A92"', '--checkpoint_path_sc', f'{ligand_mpnn_dir}model_params/ligandmpnn_sc_v_32_002_16.pt']
+df << (LigandMPNN(pdb_column_name, ligand_mpnn_dir, output_dir,args=args) >> Save(f'{output_dir}ligandmpnn_inpainted.pkl'))
+
+```
+
+### Proteinfer
+
+Proteinfer is a tool for predicting the EC number of an enzyme.
+
+```python
+
+output_dir = 'tmp/'
+num_threads = 1
+id_col = 'Entry'
+seq_col = 'Sequence'
+substrate_col = 'Substrate'
+rows = [['P0DP23', 'MALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAA', 'CCCCC(CC)COC(=O)C1=CC=CC=C1C(=O)OCC(CC)CCCC'], 
+        ['AXE2', 'MKIGSGEKLLFIGDSITDCGRARPEGEGSFGALGTGYVAYVVGLLQAVYPELGIRVVNKGISGNTVRDLKARWEEDVIAQKPDWVSIMIGINDVWRQYDLPFMKEKHVYLDEYEATLRSLVLETKPLVKGIILMTPFYIEGNEQDPMRRTMDQYGRVVKQIAEETNSLFVDTQAAFNEVLKTLYPAALAWDRVHPSVAGHMILARAFLREIGFEWVRSR', 'CCCCC(CC)COC(=O)C1=CC=CC=C1C(=O)OCC(CC)CCCC']]
+df = pd.DataFrame(rows, columns=[id_col, seq_col, substrate_col])
+# This should be relative to the location of the script if you installed via the install_all.sh script
+# Note you need to have downloaded their predictive models (ToDo )
+proteinfer_dir = 'software/proteinfer/'
+df << (ProteInfer(id_col, seq_col, proteinfer_dir, num_threads=num_threads) >> Save(f'proteinfer.pkl'))
+```
+
+## Tools and references
+Being a toolkit this is a collection of other tools, which means if you use any of these tools then cite the ones relevant to your work:
+
+[mmseqs2](https://github.com/soedinglab/mmseqs2)  
+[foldseek](https://github.com/steineggerlab/foldseek)  
+[diamond](https://github.com/bbuchfink/diamond)  
+[proteinfer](https://github.com/google-research/proteinfer)  
+[CLEAN](https://github.com/tttianhao/CLEAN)  
+[chai](https://github.com/chaidiscovery/chai-lab/)  
+[chemBERTa2](https://github.com/seyonechithrananda/bert-loves-chemistry)  
+[SELFormer](https://github.com/HUBioDataLab/SELFormer)  
+[rxnfp](https://github.com/rxn4chemistry/rxnfp)  
+[clustalomega](http://www.clustal.org/omega/)  
+[CREEP](https://github.com/jsunn-y/CARE)  
+[esm](https://github.com/facebookresearch/esm)  
+[LigandMPNN](https://github.com/dauparas/LigandMPNN)  
+[vina](https://vina.scripps.edu/)  
+[Uni-Mol](https://github.com/deepmodeling/Uni-Mol)  
+[fasttree](https://morgannprice.github.io/fasttree/)  
+[Porechop](https://github.com/rrwick/Porechop)  
+[prokka](https://github.com/tseemann/prokka)  
+
+