enzymetk 0.0.1__py3-none-any.whl

enzymetk/metagenomics_porechop_trim_reads_step.py

@@ -0,0 +1,55 @@
+"""
+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 multiprocessing.dummy import Pool as ThreadPool
+from tempfile import TemporaryDirectory
+import os
+import subprocess
+import random
+import string
+
+
+class PoreChop(Step):
+    
+    def __init__(self, porechop_dir: str, input_column_name: str, output_column_name: str, num_threads=1):
+        self.porechop_dir = porechop_dir
+        self.input_column_name = input_column_name
+        self.output_column_name = output_column_name
+        self.num_threads = num_threads
+        
+    def __execute(self, data: list) -> np.array:
+        df = data
+        # f'./porechop-runner.py -i {data_dir}fastq/{l}.fastq -o {data_dir}trimmed/{l}.fastq'  
+        file_created = []
+        for input_filename, output_filename in df[[self.input_column_name, self.output_column_name]]:        
+            subprocess.run([f'{self.porechop_dir}./porechop-runner.py', '-i',  input_filename, '-o', output_filename], check=True)
+            # Check that the file was created 
+            if os.path.exists(output_filename):
+                file_created.append(True)
+            else:
+                file_created.append(False)
+        df['file_created'] = file_created
+        return df
+    
+    def execute(self, df: pd.DataFrame) -> pd.DataFrame:
+        with TemporaryDirectory() as tmp_dir:
+            if self.num_threads > 1:
+                data = []
+                df_list = np.array_split(df, self.num_threads)
+                pool = ThreadPool(self.num_threads)
+                for df_chunk in df_list:
+                    data.append([df_chunk, tmp_dir])
+                results = pool.map(self.__execute, data)
+                df = pd.DataFrame()
+                for dfs in results:
+                    df = pd.concat([df, dfs])
+                return df
+            else:
+                return self.__execute([df, tmp_dir])
+                return df

enzymetk/metagenomics_prokka_annotate_genes.py

@@ -0,0 +1,59 @@
+#./foldseek easy-search /home/ariane/degradeo/data/pipeline/p1_predict_activity/p1b_encode_protein/e1_esm/chai/Q0HLQ7/chai/Q0HLQ7_0.cif /home/ariane/degradeo/data/pipeline/p1_predict_activity/p1b_encode_protein/e1_esm/chai/Q0HLQ7/chai/Q0HLQ7_1.cif pdb test_aln.fasta tmp
+"""
+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 multiprocessing.dummy import Pool as ThreadPool
+from tempfile import TemporaryDirectory
+import os
+import subprocess
+import random
+import string
+
+
+""" Install: conda install -c conda-forge -c bioconda -c defaults prokka """
+class Prokka(Step):
+    
+    def __init__(self, porechop_dir: str, name: str, input_column_name: str, output_dir: str, num_threads=1):
+        self.porechop_dir = porechop_dir
+        self.name = name
+        self.input_column_name = input_column_name
+        self.output_dir = output_dir
+        self.num_threads = num_threads
+        
+    def __execute(self, data: list) -> np.array:
+        df = data
+        # f'prokka --outdir {data_dir}prokka/{l} --prefix {l} {data_dir}flye/{l}/assembly.fasta ')
+        file_created = []
+        for name, input_filename, output_dir in df[[self.name, self.input_column_name, self.output_dir]]:    
+            # Note it expects the input file name to be the outpt from flye
+            subprocess.run([f'prokka', '--outdir', output_dir, '--prefix', name, input_filename], check=True)
+            # Check that the file was created 
+            if os.path.exists(output_filename):
+                file_created.append(True)
+            else:
+                file_created.append(False)
+        df['file_created'] = file_created
+        return df
+    
+    def execute(self, df: pd.DataFrame) -> pd.DataFrame:
+        with TemporaryDirectory() as tmp_dir:
+            if self.num_threads > 1:
+                data = []
+                df_list = np.array_split(df, self.num_threads)
+                pool = ThreadPool(self.num_threads)
+                for df_chunk in df_list:
+                    data.append([df_chunk, tmp_dir])
+                results = pool.map(self.__execute, data)
+                df = pd.DataFrame()
+                for dfs in results:
+                    df = pd.concat([df, dfs])
+                return df
+            else:
+                return self.__execute([df, tmp_dir])
+                return df

enzymetk/pipeline.py

@@ -0,0 +1 @@
+

enzymetk/predict_catalyticsite_run.py

@@ -0,0 +1,47 @@
+import argparse
+import os
+
+
+def run_as_inference(output_dir, fasta_file, squidly_dir, toks_per_batch, as_threshold, bs_threshold, cr_model_as, 
+                     cr_model_bs, lstm_model_as, lstm_model_bs, esm2_model):
+    esm2_model = esm2_model or "esm2_t36_3B_UR50D"
+    if esm2_model == "esm2_t36_3B_UR50D":   
+        cr_model_as = cr_model_as or f"{squidly_dir}Squidly_CL_3B.pt"
+        lstm_model_as = lstm_model_as or f"{squidly_dir}Squidly_LSTM_3B.pth"
+    elif esm2_model == "esm2_t48_15B_UR50D":
+        cr_model_as = cr_model_as or f"{squidly_dir}Squidly_CL_15B.pt"
+        lstm_model_as = lstm_model_as or f"{squidly_dir}Squidly_LSTM_15B.pth"
+    as_threshold = 0.99
+    #esm2_model = "esm2_t48_15B_UR50D"
+    # 	python /scratch/project/squid/code_modular/SQUIDLY_run_model_LSTM.py ${FILE} ${ESM2_MODEL} ${CR_MODEL_AS}
+    # ${LSTM_MODEL_AS} ${OUT} --toks_per_batch ${TOKS_PER_BATCH} --AS_threshold ${AS_THRESHOLD} --monitor
+
+    command = f'conda run -n AS_inference python {squidly_dir}SQUIDLY_run_model_LSTM.py \
+              {fasta_file} {esm2_model} {cr_model_as} {lstm_model_as} {output_dir} \
+              --toks_per_batch {toks_per_batch} --AS_threshold {as_threshold}'
+    print(command)
+    os.system(command)
+    
+    
+def parse_args():
+    parser = argparse.ArgumentParser(description="Run as inference on a dataset")
+    parser.add_argument('-out', '--out', required=True, help='Path to the output directory')
+    parser.add_argument('-input', '--input', type=str, required=True, help='path to the dataframe')
+    parser.add_argument('--squidly_dir', type=str, required=True, help='path to the squidly_dir')
+    parser.add_argument('--toks_per_batch', type=int, default=5, help='How many tokens per batch')
+    parser.add_argument('--as_threshold', type=float, default=0.90, help='the threshold for active site.')
+    parser.add_argument('--bs_threshold', type=float, default=0.85, help='the threshold for binding site.')
+    parser.add_argument('--cr_model_as', type=str, help='the path to the active site CR model.')
+    parser.add_argument('--cr_model_bs', type=str, help='the path to the binding site CR model.')
+    parser.add_argument('--lstm_model_as', type=str, help='the path to the active site LSTM model.')
+    parser.add_argument('--lstm_model_bs', type=str, help='the path to the binding site LSTM model.')
+    parser.add_argument('--esm2_model', type=str, help='ESM2 model.')
+    return parser.parse_args()
+
+def main():
+    args = parse_args()
+    run_as_inference(args.out, args.input, args.squidly_dir, args.toks_per_batch, args.as_threshold, args.bs_threshold, 
+                     args.cr_model_as, args.cr_model_bs, args.lstm_model_as, args.lstm_model_bs, args.esm2_model)
+
+# Removed the if name since we run with subprocess
+main()

enzymetk/predict_catalyticsite_step.py

@@ -0,0 +1,70 @@
+from enzymetk.step import Step
+import pandas as pd
+from tempfile import TemporaryDirectory
+import subprocess
+from pathlib import Path
+import logging
+import numpy as np
+from tqdm import tqdm
+import random
+import string
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+    
+class ActiveSitePred(Step):
+    
+    def __init__(self, id_col: str, seq_col: str, squidly_dir: str, num_threads: int = 1, 
+                 esm2_model = 'esm2_t36_3B_UR50D', tmp_dir: str = None):
+        self.id_col = id_col
+        self.seq_col = seq_col  
+        self.num_threads = num_threads or 1
+        self.squidly_dir = squidly_dir
+        self.esm2_model = esm2_model
+        self.tmp_dir = tmp_dir
+
+    def __to_fasta(self, df: pd.DataFrame, tmp_dir: str):
+        tmp_label = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
+
+        input_filename = f'{tmp_dir}/as_inference_{tmp_label}.fasta'
+        # Save as a fasta
+        with open(input_filename, 'w+') as fout:
+            for entry, seq in df[[self.id_col, self.seq_col]].values:
+                fout.write(f'>{entry.strip()}\n{seq.strip()}\n')
+        return input_filename
+            
+    def __execute(self, df: pd.DataFrame, tmp_dir: str):
+        input_filename = self.__to_fasta(df, tmp_dir)
+        # Might have an issue if the things are not correctly installed in the same dicrectory 
+        result = subprocess.run(['python', Path(__file__).parent/'predict_catalyticsite_run.py', '--out', str(tmp_dir), 
+                                '--input', input_filename, '--squidly_dir', self.squidly_dir, '--esm2_model', self.esm2_model], capture_output=True, text=True)
+        output_filename = f'{input_filename.replace(".fasta", "_results.pkl")}'
+        if result.stderr:
+            logger.error(result.stderr)
+        logger.info(result.stdout)   
+        
+        return output_filename
+    
+    def execute(self, df: pd.DataFrame) -> pd.DataFrame:
+        with TemporaryDirectory() as tmp_dir:
+            tmp_dir = self.tmp_dir if self.tmp_dir is not None else tmp_dir
+            if self.num_threads > 1:
+                output_filenames = []
+                df_list = np.array_split(df, self.num_threads)
+                for df_chunk in tqdm(df_list):
+                    try:
+                        output_filenames.append(self.__execute(df_chunk, tmp_dir))
+                    except Exception as e:
+                         logger.error(f"Error in executing ESM2 model: {e}")
+                         continue
+                df = pd.DataFrame()
+                print(output_filenames)
+                for p in output_filenames:
+                    sub_df = pd.read_pickle(p)
+                    df = pd.concat([df, sub_df])
+                return df
+            
+            else:
+                output_filename = self.__execute(df, tmp_dir)
+                return pd.read_pickle(output_filename)

enzymetk/reducedim_pca_run.py

@@ -0,0 +1,67 @@
+import pickle
+import argparse
+import pandas as pd
+import numpy as np
+from scivae import VAE
+import json
+
+def run_vae(output_dir, input_filename, value_column, method, config_file, label, id_column):
+    
+    # Load the input dataset
+    with open(input_filename, 'rb') as file:
+            chem_df = pickle.load(file)
+
+    chem_encodings = np.asarray([np.asarray(x) for x in chem_df[value_column].values])
+    
+    # Load in the config
+    with open(config_file, 'r') as f:
+        config = json.load(f)
+        
+    # Add some defaults
+    if config.get('batch_size') is None:
+        config['batch_size'] = 100
+    if config.get('epochs') is None:
+        config['epochs'] = 100
+    if config.get('early_stop') is None:
+        config['early_stop'] = True
+    vae_mse = VAE(chem_encodings, chem_encodings, np.ones(len(chem_encodings)), config, 'esm_label')
+    # Set batch size and number of epochs
+    if method == 'train':
+        vae_mse.encode('default', epochs=config['epochs'], batch_size=config['batch_size'], early_stop=config['early_stop'])
+        # Save this
+        vae_mse.save(weight_file_path=f'{output_dir}{label}_model_weights.h5', optimizer_file_path=f'{output_dir}{label}_model_optimiser.json',
+                config_json=f'{output_dir}{label}_config.json')
+    elif method == 'encode':
+        # load this
+        vae_mse.load(weight_file_path=f'{output_dir}{label}_model_weights.h5', optimizer_file_path=f'{output_dir}{label}_model_optimiser.json',
+                config_json=f'{output_dir}{label}_config.json')
+            
+    encoded_data_vae_mse = vae_mse.encode_new_data(chem_encodings)
+    
+    df = pd.DataFrame()
+    df['id'] = chem_df[f'{id_column}'].values
+    df['encoding'] = [x for x in encoded_data_vae_mse]
+
+    # Save the encoded data
+    with open(f'{output_dir}{label}.pkl', 'wb') as file:
+        pickle.dump(df, file)
+        
+def parse_args():
+    parser = argparse.ArgumentParser(description="Run VAE dimensionality reduction on a dataset")
+    parser.add_argument('-o', '--out', required=True, help='Path to the output directory')
+    parser.add_argument('-i', '--input', type=str, required=True, help='path to the dataframe')
+    parser.add_argument('-v', '--value', type=str, required=True, help='label of the column which has the values for encoding')
+    parser.add_argument('-m', '--method', type=str, required=True, help='either to encode or train a VAE')
+    parser.add_argument('-c', '--config', type=str, required=True, help='config file path as JSON')
+    parser.add_argument('-l', '--label', type=str, required=True, help='run label for saving')
+    parser.add_argument('-d', '--id', type=str, required=True, help='id column')
+
+    return parser.parse_args()
+
+def main():
+    args = parse_args()
+    # def run_vae(output_filename, input_filename, value_column, method, config_file, label_column, id_column):
+    run_vae(args.out, args.input, args.value, args.method, args.config, args.label, args.id)
+
+
+main()

enzymetk/reducedim_vae_run.py

@@ -0,0 +1,67 @@
+import pickle
+import argparse
+import pandas as pd
+import numpy as np
+from scivae import VAE
+import json
+
+def run_vae(output_dir, input_filename, value_column, method, config_file, label, id_column):
+    
+    # Load the input dataset
+    with open(input_filename, 'rb') as file:
+            chem_df = pickle.load(file)
+
+    chem_encodings = np.asarray([np.asarray(x) for x in chem_df[value_column].values])
+    
+    # Load in the config
+    with open(config_file, 'r') as f:
+        config = json.load(f)
+        
+    # Add some defaults
+    if config.get('batch_size') is None:
+        config['batch_size'] = 100
+    if config.get('epochs') is None:
+        config['epochs'] = 100
+    if config.get('early_stop') is None:
+        config['early_stop'] = True
+    vae_mse = VAE(chem_encodings, chem_encodings, np.ones(len(chem_encodings)), config, 'esm_label')
+    # Set batch size and number of epochs
+    if method == 'train':
+        vae_mse.encode('default', epochs=config['epochs'], batch_size=config['batch_size'], early_stop=config['early_stop'])
+        # Save this
+        vae_mse.save(weight_file_path=f'{output_dir}{label}_model_weights.h5', optimizer_file_path=f'{output_dir}{label}_model_optimiser.json',
+                config_json=f'{output_dir}{label}_config.json')
+    elif method == 'encode':
+        # load this
+        vae_mse.load(weight_file_path=f'{output_dir}{label}_model_weights.h5', optimizer_file_path=f'{output_dir}{label}_model_optimiser.json',
+                config_json=f'{output_dir}{label}_config.json')
+            
+    encoded_data_vae_mse = vae_mse.encode_new_data(chem_encodings)
+    
+    df = pd.DataFrame()
+    df['id'] = chem_df[f'{id_column}'].values
+    df['encoding'] = [x for x in encoded_data_vae_mse]
+
+    # Save the encoded data
+    with open(f'{output_dir}{label}.pkl', 'wb') as file:
+        pickle.dump(df, file)
+        
+def parse_args():
+    parser = argparse.ArgumentParser(description="Run VAE dimensionality reduction on a dataset")
+    parser.add_argument('-o', '--out', required=True, help='Path to the output directory')
+    parser.add_argument('-i', '--input', type=str, required=True, help='path to the dataframe')
+    parser.add_argument('-v', '--value', type=str, required=True, help='label of the column which has the values for encoding')
+    parser.add_argument('-m', '--method', type=str, required=True, help='either to encode or train a VAE')
+    parser.add_argument('-c', '--config', type=str, required=True, help='config file path as JSON')
+    parser.add_argument('-l', '--label', type=str, required=True, help='run label for saving')
+    parser.add_argument('-d', '--id', type=str, required=True, help='id column')
+
+    return parser.parse_args()
+
+def main():
+    args = parse_args()
+    # def run_vae(output_filename, input_filename, value_column, method, config_file, label_column, id_column):
+    run_vae(args.out, args.input, args.value, args.method, args.config, args.label, args.id)
+
+
+main()

enzymetk/reducedim_vae_step.py

@@ -0,0 +1,12 @@
+from enzymetk.step import Step
+
+import pandas as pd
+from tempfile import TemporaryDirectory
+import subprocess
+from pathlib import Path
+import logging
+import datetime
+
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)

enzymetk/save_step.py

@@ -0,0 +1,13 @@
+from enzymetk.step import Step
+
+
+import pandas as pd
+
+class Save(Step):
+    
+    def __init__(self, output_filename: str):
+        self.output_filename = output_filename
+    
+    def execute(self, df: pd.DataFrame) -> pd.DataFrame:
+        df.to_pickle(self.output_filename)
+        return df

enzymetk/sequence_search_blast.py

@@ -0,0 +1,80 @@
+"""
+Step to run multiple sequence alignment with the Clustal Omega tool. 
+ ./clustalo -i /home/helen/degradeo/pipeline/helen_data/sequences_test_fasta.txt
+"""
+from enzymetk.step import Step
+
+import pandas as pd
+import numpy as np
+from multiprocessing.dummy import Pool as ThreadPool
+from tempfile import TemporaryDirectory
+import os
+import subprocess
+import random
+import string
+
+class BLAST(Step):
+    
+    def __init__(self, id_col: str, sequence_col: str, label_col=None, database=None, mode='blastp', args=None, tmp_dir=None):
+        self.id_col = id_col
+        self.seq_col = sequence_col
+        self.label_col = label_col  # This is whether it is query or reference
+        self.mode = mode
+        self.database = database
+        self.args = args
+        self.tmp_dir = tmp_dir
+        if self.database is None and self.label_col is None:
+            raise ValueError('Database is not set, you can pass a database that you have already created see diamond for more information or 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.')
+        
+    def __execute(self, data: list) -> np.array: 
+        df, tmp_dir = data
+        tmp_label = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
+        query_fasta = os.path.join(tmp_dir, f'{tmp_label}_query.fasta')
+        ref_fasta = os.path.join(tmp_dir, f'{tmp_label}_ref.fasta')
+        db_label = os.path.join(tmp_dir, f'{tmp_label}_db')
+        # write fasta file which is the input for proteinfer
+        if self.label_col is not None:
+            with open(query_fasta, 'w+') as fout:
+                query_df = df[df[self.label_col] == 'query']
+                print(query_df)
+                for entry, seq in query_df[[self.id_col, self.seq_col]].values:
+                    fout.write(f'>{entry.strip()}\n{seq.strip()}\n')
+
+            with open(ref_fasta, 'w+') as fout:
+                query_df = df[df[self.label_col] == 'reference']
+                print(query_df)
+                for entry, seq in query_df[[self.id_col, self.seq_col]].values:
+                    fout.write(f'>{entry.strip()}\n{seq.strip()}\n')
+            # Make the DB first 
+            db_label = os.path.join(tmp_dir, f'{tmp_label}_refdb')
+            subprocess.run(['diamond', 'makedb', '--in', ref_fasta, '-d', db_label], check=True)
+        else:
+            with open(query_fasta, 'w+') as fout:
+                for entry, seq in df[[self.id_col, self.seq_col]].values:
+                    fout.write(f'>{entry.strip()}\n{seq.strip()}\n')
+            if os.path.exists(self.database):
+                # Here we're assuming they're passing a database as a fasta file
+                subprocess.run(['diamond', 'makedb', '--in', self.database, '-d', db_label], check=True)
+            else:
+                db_label = self.database
+            
+        # Running Clustal Omega on the generated FASTA file
+        matches_filename = os.path.join(tmp_dir, f'{tmp_label}_matches.tsv')
+        cmd = ['diamond', self.mode]
+        if self.args is not None:
+            cmd.extend(self.args)
+        cmd.extend(['-d', db_label, '-q', query_fasta, '-o', matches_filename])
+        print(cmd)
+        self.run(cmd)
+        df = pd.read_csv(matches_filename, sep='\t', header=None)
+        print(df)
+        df.columns = ['query', 'target', 'sequence identity', 'length', 'mismatch', 'gapopen', 'query start', 'query end', 'target start', 'target end', 'e-value', 'bitscore']
+        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])

enzymetk/similarity_foldseek_step.py

@@ -0,0 +1,114 @@
+#./foldseek easy-search /home/ariane/degradeo/data/pipeline/p1_predict_activity/p1b_encode_protein/e1_esm/chai/Q0HLQ7/chai/Q0HLQ7_0.cif /home/ariane/degradeo/data/pipeline/p1_predict_activity/p1b_encode_protein/e1_esm/chai/Q0HLQ7/chai/Q0HLQ7_1.cif pdb test_aln.fasta tmp
+"""
+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 = ['foldseek_representative_cluster_structure', id_column_name]
+    clustering.drop_duplicates(subset=id_column_name, keep='first', inplace=True)
+    # Remove the chain to a separate column
+    clustering['chain'] = ['_'.join(c.split('_')[-1]) for c in clustering[id_column_name].values]
+    clustering[id_column_name] = ['_'.join(c.split('_')[:-1]) for c in clustering[id_column_name].values]
+    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 FoldSeek(Step):
+    
+    def __init__(self, id_column_name: str, query_column_name: str, reference_database: str, method='search', query_type='structures', 
+                 args=None, tmp_dir: str = None):
+        self.query_column_name = query_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.method = method
+        self.args = args
+        self.query_type = query_type
+        if self.method not in ['search', 'cluster']:
+            print('Method must be in "search" or "cluster". Will likely fail... ')
+        if self.query_type not in ['seqs', 'structures']:
+            print('query_type must be either "seqs" or "structures" i.e. is it an amino acid sequence or a path to pdb files?')
+
+    def __execute(self, data: list) -> np.array:
+        df, tmp_dir = data
+        tmp_label = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
+        
+        if self.query_type == 'seqs':
+            # Convert to a fasta
+            with open(f'{tmp_dir}/{tmp_label}_seqs.fasta', 'w') as f:
+                for i, row in df.iterrows():
+                    f.write(f'>{row[self.id_column_name]}\n{row[self.query_column_name]}\n')
+            
+        # Get the PDB files from the column
+        pdb_files = list(df[self.query_column_name].values)
+        
+        if self.method == 'search':
+            cmd = ['foldseek', 'easy-search']
+            if self.query_type == 'structures':
+                cmd += pdb_files + [f'{self.reference_database}', f'{tmp_dir}{tmp_label}.txt', 'tmp']
+            else:
+                # Convert the file to a fasta and then pass that file name 
+                # Make a db from the seqs
+                # ToDo: make this more efficient
+                subcmd = ['foldseek', 'databases', 'ProstT5', 'weights', 'tmp']
+                self.run(subcmd)
+                
+                subcmd = ['foldseek', 'createdb', f'{tmp_dir}/{tmp_label}_seqs.fasta', f'db_{tmp_label}', '--prostt5-model', 'weights']
+                self.run(subcmd)
+                
+                # Pass your newly created dB
+                cmd += [f'db_{tmp_label}', f'{self.reference_database}', f'{tmp_dir}{tmp_label}.txt', 'tmp']
+
+        elif self.method == 'cluster':
+            cmd = ['foldseek', 'easy-cluster']
+            if self.query_type == 'structures':
+                cmd += pdb_files + [f'{tmp_dir}/clusterFolds', f'{tmp_dir}']
+            else:
+                subcmd = ['foldseek', 'databases', 'ProstT5', 'weights', 'tmp']
+                self.run(subcmd)
+                subcmd = ['foldseek', 'createdb', f'{tmp_dir}/{tmp_label}_seqs.fasta', f'db_{tmp_label}', '--prostt5-model', 'weights']
+                self.run(subcmd)
+                cmd = ['foldseek', 'cluster']
+
+                # Convert the file to a fasta and then pass that file name 
+                cmd += [ f'db_{tmp_label}', f'{tmp_dir}/clusterFolds', f'{tmp_dir}']
+
+        # add in args
+        if self.args is not None:
+           cmd.extend(self.args)
+
+        self.run(cmd)
+        
+        if self.method == 'search':
+            df = pd.read_csv(f'{tmp_dir}{tmp_label}.txt', header=None, sep='\t')
+            df.columns = ['query', 'target', 'fident', 'alnlen', 'mismatch', 
+                      'gapopen', 'qstart', 'qend', 'tstart', 'tend', 'evalue', 'bits']
+        elif self.method == 'cluster':
+            df = process_clustering(f'{tmp_dir}/clusterFolds_cluster.tsv', df, self.id_column_name)   
+            return df
+        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