enzymetk 0.0.1__py3-none-any.whl

enzymetk/embedchem_selformer_run.py

@@ -0,0 +1,28 @@
+import argparse
+import os
+
+def run_selformer(output_filename, input_filename, label, selformer_dir, model_file):
+    print(f'Running selformer on {input_filename} with label {label}')
+    os.chdir(selformer_dir)
+    os.system(f'cp {input_filename} {selformer_dir}data/{label}.txt')
+    os.system(f'conda run -n SELFormer_env python3 {selformer_dir}generate_selfies.py --smiles_dataset=data/{label}.txt --selfies_dataset=data/{label}.csv')
+    os.system(f'conda run -n SELFormer_env python3 {selformer_dir}produce_embeddings.py --selfies_dataset=data/{label}.csv --model_file={model_file} --embed_file=data/{label}_embedding.csv')
+    os.system(f'cp {selformer_dir}data/{label}_embedding.csv {output_filename}')
+    os.system(f'rm data/{label}.txt')
+    os.system(f'rm data/{label}.csv')
+    os.system(f'rm data/{label}_embedding.csv')
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Run selformer 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('-label', '--label', type=str, required=True, help='label of the column')
+    parser.add_argument('-dir', '--dir', type=str, required=True, help='path to the directory')
+    parser.add_argument('-model', '--model', type=str, required=True, help='path to the model')
+    return parser.parse_args()
+
+def main():
+    args = parse_args()
+    run_selformer(args.out, args.input, args.label, args.dir, args.model)
+
+main()

enzymetk/embedchem_selformer_step.py

@@ -0,0 +1,39 @@
+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)
+
+
+class SelFormer(Step):
+    
+    def __init__(self, value_col: str, id_col: str, selformer_dir: str, model_file: str):
+        self.value_col = value_col
+        self.id_col = id_col
+        self.selformer_dir = selformer_dir
+        self.model_file = model_file
+
+    def execute(self, df: pd.DataFrame) -> pd.DataFrame:
+        sub_df = df[[self.id_col, self.value_col]]
+        # Have to change it so that selformer can run
+        sub_df.columns = ['chembl_id', 'canonical_smiles']
+        with TemporaryDirectory() as tmp_dir:
+            now = datetime.datetime.now()
+            formatted_date = now.strftime("%Y%m%d%H%M%S")
+            label = f'selformer_{formatted_date}'
+            output_filename = f'{tmp_dir}/{label}.csv'
+            input_filename = f'{tmp_dir}/{label}.tsv'
+            sub_df.to_csv(input_filename, sep='\t', index=False)
+            cmd = ['python', Path(__file__).parent/'selformer_run.py', '--out', output_filename, 
+                                     '--input', input_filename, '--label', label, '--dir', self.selformer_dir, 
+                                     '--model', self.model_file]
+            self.run(cmd)
+            df = pd.read_csv(output_filename)
+     
+        return df

enzymetk/embedchem_unimol_step.py

@@ -0,0 +1,57 @@
+from enzymetk.step import Step
+import pandas as pd
+from tempfile import TemporaryDirectory
+import logging
+import numpy as np
+from unimol_tools import UniMolRepr
+from multiprocessing.dummy import Pool as ThreadPool
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+# pip install unimol_tools
+
+
+class UniMol(Step):
+    
+    def __init__(self, smiles_col: str, unimol_model = 'unimolv2', unimol_size = '164m', num_threads = 1):
+        self.smiles_col = smiles_col
+        self.num_threads = num_threads
+        # single smiles unimol representation
+        clf = UniMolRepr(data_type='molecule', 
+                        remove_hs=False,
+                        model_name= unimol_model or 'unimolv2', # avaliable: unimolv1, unimolv2
+                        model_size= unimol_size or '164m', # work when model_name is unimolv2. avaliable: 84m, 164m, 310m, 570m, 1.1B.
+                        )
+        self.clf = clf
+
+    def __execute(self, df: pd.DataFrame) -> pd.DataFrame:
+        smiles_list = list(df[self.smiles_col].values)
+        reprs = []
+        for smile in smiles_list:
+            try:
+                unimol_repr = self.clf.get_repr([smile], return_atomic_reprs=True)
+                reprs.append(unimol_repr['cls_repr'])
+            except Exception as e:
+                logger.warning(f"Error embedding smile {smile}: {e}")
+                reprs.append(None)
+        df['unimol_repr']  = reprs
+        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)
+                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/embedprotein_esm_step.py

@@ -0,0 +1,123 @@
+from enzymetk.step import Step
+import pandas as pd
+from tempfile import TemporaryDirectory
+from pathlib import Path
+import numpy as np
+from tqdm import tqdm 
+import torch
+import os
+
+
+    
+# First run this: nohup python esm-extract.py esm2_t33_650M_UR50D /disk1/ariane/vscode/degradeo/data/DEHP/uniprot/EC3.1.1_training.fasta /disk1/ariane/vscode/degradeo/data/DEHP/uniprot/encodings --include per_tok & 
+def extract_active_site_embedding(df, id_column, residue_columns, encoding_dir, rep_num=33): 
+    """ Expects that the entries for the active site df are saved as the filenames in the encoding dir. """
+    combined_tensors = []
+    mean_tensors = []
+    count_fail = 0
+    count_success = 0
+    for entry, residues in tqdm(df[[id_column, residue_columns]].values):
+        try:
+            file = Path(encoding_dir + f'/{entry}.pt')
+            tensors = []
+            if residues is not None and residues != 'None': 
+                try:
+                    residues = [int(r) for r in residues.split('|')]
+                except:
+                    residues = []
+            else:
+                residues = []
+            embedding_file = torch.load(file)
+            tensor = embedding_file['representations'][rep_num] # have to get the last layer (36) of the embeddings... very dependant on ESM model used! 36 for medium ESM2
+            tensors = []
+            mean_tensors.append(np.mean(np.asarray(tensor).astype(np.float32), axis=0))
+            for residue in residues:
+                t = np.asarray(tensor[residue]).astype(np.float32)
+                tensors.append(t)
+            combined_tensors.append(tensors)
+        except Exception as e:
+            print(f'Error loading file {file}: {e}')
+            count_fail += 1
+            mean_tensors.append(None)
+            combined_tensors.append(None)
+    # HEre is where you do something on the combined tensors
+    df['active_embedding'] = combined_tensors
+    df['esm_embedding'] = mean_tensors
+    print(count_success, count_fail, count_fail + count_success)
+    return df
+
+# First run this: nohup python esm-extract.py esm2_t33_650M_UR50D /disk1/ariane/vscode/degradeo/data/DEHP/uniprot/EC3.1.1_training.fasta /disk1/ariane/vscode/degradeo/data/DEHP/uniprot/encodings --include per_tok & 
+def extract_mean_embedding(df, id_column, encoding_dir, rep_num=33): 
+    """ Expects that the entries for the active site df are saved as the filenames in the encoding dir. """
+    tensors = []
+    count_fail = 0
+    count_success = 0
+    for entry in tqdm(df[id_column].values):
+        try:
+            file = Path(os.path.join(encoding_dir, f'{entry}.pt'))
+            embedding_file = torch.load(file)
+            tensor = embedding_file['representations'][rep_num] # have to get the last layer (36) of the embeddings... very dependant on ESM model used! 36 for medium ESM2
+            t = np.mean(np.asarray(tensor).astype(np.float32), axis=0)
+            tensors.append(t)
+        except Exception as e:
+            print(f'Error loading file {file}: {e}')
+            count_fail += 1
+            tensors.append(None)
+
+    df['embedding'] = tensors
+    print(count_success, count_fail, count_fail + count_success)
+    return df
+
+class EmbedESM(Step):
+    
+    def __init__(self, id_col: str, seq_col: str, model='esm2_t33_650M_UR50D', extraction_method='mean', 
+                 active_site_col: str = None, num_threads=1, tmp_dir: str = None, env_name: str = 'enzymetk'):
+        self.seq_col = seq_col
+        self.id_col = id_col
+        self.active_site_col = active_site_col
+        self.model = model
+        self.num_threads = num_threads or 1
+        self.extraction_method = extraction_method
+        self.tmp_dir = tmp_dir
+        self.env_name = env_name
+
+    def __execute(self, df: pd.DataFrame, tmp_dir: str) -> pd.DataFrame:
+        input_filename = f'{tmp_dir}/input.fasta'
+        # Check the file doesn't exist in the tmp_dir
+        files = os.listdir(tmp_dir)
+        done_entries = set([f.split('.')[0] for f in files if f.endswith('.pt')])
+        # write fasta file which is the input for proteinfer
+        with open(input_filename, 'w+') as fout:
+            for entry, seq in df[[self.id_col, self.seq_col]].values:
+                if entry not in done_entries:
+                    fout.write(f'>{entry.strip()}\n{seq.strip()}\n')
+        # Might have an issue if the things are not correctly installed in the same dicrectory 
+        cmd = ['conda', 'run', '-n', self.env_name, 'python', Path(__file__).parent/'esm-extract.py', self.model, input_filename, tmp_dir, '--include', 'per_tok']
+        self.run(cmd)
+        if self.extraction_method == 'mean':
+            df = extract_mean_embedding(df, self.id_col, tmp_dir)
+        elif self.extraction_method == 'active_site':
+            if self.active_site_col is None:
+                raise ValueError('active_site_col must be provided if extraction_method is active_site')
+            df = extract_active_site_embedding(df, self.id_col, self.active_site_col, tmp_dir)
+        
+        return df
+    
+    def execute(self, df: pd.DataFrame) -> pd.DataFrame:
+        if self.tmp_dir is None:
+            with TemporaryDirectory() as tmp_dir:
+                if self.num_threads > 1:
+                    dfs = []
+                    df_list = np.array_split(df, self.num_threads)
+                    for df_chunk in tqdm(df_list):
+                        dfs.append(self.__execute(df_chunk, tmp_dir))
+                    df = pd.DataFrame()
+                    for tmp_df in tqdm(dfs):
+                        df = pd.concat([df, tmp_df])
+                    return df
+                else:
+                    df = self.__execute(df, tmp_dir)
+                    return df
+        else:
+            df = self.__execute(df, self.tmp_dir)
+            return df

enzymetk/esm-extract.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3 -u
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+import argparse
+import pathlib
+
+import torch
+
+from esm import Alphabet, FastaBatchedDataset, ProteinBertModel, pretrained, MSATransformer
+
+
+def create_parser():
+    parser = argparse.ArgumentParser(
+        description="Extract per-token representations and model outputs for sequences in a FASTA file"  # noqa
+    )
+
+    parser.add_argument(
+        "model_location",
+        type=str,
+        help="PyTorch model file OR name of pretrained model to download (see README for models)",
+    )
+    parser.add_argument(
+        "fasta_file",
+        type=pathlib.Path,
+        help="FASTA file on which to extract representations",
+    )
+    parser.add_argument(
+        "output_dir",
+        type=pathlib.Path,
+        help="output directory for extracted representations",
+    )
+
+    parser.add_argument("--toks_per_batch", type=int, default=4096, help="maximum batch size")
+    parser.add_argument(
+        "--repr_layers",
+        type=int,
+        default=[-1],
+        nargs="+",
+        help="layers indices from which to extract representations (0 to num_layers, inclusive)",
+    )
+    parser.add_argument(
+        "--include",
+        type=str,
+        nargs="+",
+        choices=["mean", "per_tok", "bos", "contacts"],
+        help="specify which representations to return",
+        required=True,
+    )
+    parser.add_argument(
+        "--truncation_seq_length",
+        type=int,
+        default=1022,
+        help="truncate sequences longer than the given value",
+    )
+
+    parser.add_argument("--nogpu", action="store_true", help="Do not use GPU even if available")
+    return parser
+
+
+def run(args):
+    model, alphabet = pretrained.load_model_and_alphabet(args.model_location)
+    model.eval()
+    if isinstance(model, MSATransformer):
+        raise ValueError(
+            "This script currently does not handle models with MSA input (MSA Transformer)."
+        )
+    if torch.cuda.is_available() and not args.nogpu:
+        model = model.cuda()
+        print("Transferred model to GPU")
+
+    dataset = FastaBatchedDataset.from_file(args.fasta_file)
+    batches = dataset.get_batch_indices(args.toks_per_batch, extra_toks_per_seq=1)
+    data_loader = torch.utils.data.DataLoader(
+        dataset, collate_fn=alphabet.get_batch_converter(args.truncation_seq_length), batch_sampler=batches
+    )
+    print(f"Read {args.fasta_file} with {len(dataset)} sequences")
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    return_contacts = "contacts" in args.include
+
+    assert all(-(model.num_layers + 1) <= i <= model.num_layers for i in args.repr_layers)
+    repr_layers = [(i + model.num_layers + 1) % (model.num_layers + 1) for i in args.repr_layers]
+
+    with torch.no_grad():
+        for batch_idx, (labels, strs, toks) in enumerate(data_loader):
+            print(
+                f"Processing {batch_idx + 1} of {len(batches)} batches ({toks.size(0)} sequences)"
+            )
+            if torch.cuda.is_available() and not args.nogpu:
+                toks = toks.to(device="cuda", non_blocking=True)
+
+            out = model(toks, repr_layers=repr_layers, return_contacts=return_contacts)
+
+            logits = out["logits"].to(device="cpu")
+            representations = {
+                layer: t.to(device="cpu") for layer, t in out["representations"].items()
+            }
+            if return_contacts:
+                contacts = out["contacts"].to(device="cpu")
+
+            for i, label in enumerate(labels):
+                args.output_file = args.output_dir / f"{label}.pt"
+                args.output_file.parent.mkdir(parents=True, exist_ok=True)
+                result = {"label": label}
+                truncate_len = min(args.truncation_seq_length, len(strs[i]))
+                # Call clone on tensors to ensure tensors are not views into a larger representation
+                # See https://github.com/pytorch/pytorch/issues/1995
+                if "per_tok" in args.include:
+                    result["representations"] = {
+                        layer: t[i, 1 : truncate_len + 1].clone()
+                        for layer, t in representations.items()
+                    }
+                if "mean" in args.include:
+                    result["mean_representations"] = {
+                        layer: t[i, 1 : truncate_len + 1].mean(0).clone()
+                        for layer, t in representations.items()
+                    }
+                if "bos" in args.include:
+                    result["bos_representations"] = {
+                        layer: t[i, 0].clone() for layer, t in representations.items()
+                    }
+                if return_contacts:
+                    result["contacts"] = contacts[i, : truncate_len, : truncate_len].clone()
+
+                torch.save(
+                    result,
+                    args.output_file,
+                )
+
+
+def main():
+    parser = create_parser()
+    args = parser.parse_args()
+    run(args)
+
+if __name__ == "__main__":
+    main()

enzymetk/generate_msa_step.py

@@ -0,0 +1,61 @@
+"""
+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 tempfile import TemporaryDirectory
+import os
+import subprocess
+import random
+import string
+
+class ClustalOmega(Step):
+    
+    def __init__(self, id_col: str, seq_col: str, tmp_dir: str = None):
+        self.seq_col = seq_col
+        self.id_col = id_col
+        self.tmp_dir = tmp_dir
+
+    def __execute(self, data: list) -> np.array: 
+        df, tmp_dir = data
+        tmp_label = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
+        fasta_file = os.path.join(tmp_dir, 'sequences.fasta')
+        output_file = os.path.join(tmp_dir, f"{tmp_label}.aln")
+
+        # Turn dataframe into fasta file
+        with open(fasta_file, 'w') as f:
+            for seq_id, seq in df[[self.id_col, self.seq_col]].values:
+                f.write(f">{seq_id}\n{seq}\n")
+
+        # Running Clustal Omega on the generated FASTA file
+        subprocess.run(['clustalo', '-i', fasta_file, '-o', output_file], check=True)
+
+        sequences = {}
+
+        # Read the output file
+        with open(output_file, 'r') as f:
+            current_id = None
+            for line in f:
+                line = line.strip()  # Remove leading/trailing whitespaces or newline characters
+                if line.startswith(">"):
+                    # Header line with sequence ID
+                    current_id = line[1:]  # Extract ID without ">"
+                    sequences[current_id] = ""  # Initialize an empty string for this ID
+                else:
+                    # Sequence line; append it to the current ID's sequence
+                    sequences[current_id] += line.strip()
+
+        # Convert the sequences dictionary into a DataFrame
+        df_aligned = pd.DataFrame(list(sequences.items()), columns=[self.id_col, 'aligned_sequence'])
+
+        df = pd.merge(df, df_aligned, on=self.id_col, how='left')
+                
+        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/generate_tree_step.py

@@ -0,0 +1,74 @@
+# /home/ikumi/degradeo/software/FastTree -gtr -nt /home/ikumi/degradeo/pipeline/ikumi_data/Q04457_esterase-2.msa > /home/ikumi/degradeo/pipeline/ikumi_data/output_tree.tree
+# /home/ikumi/degradeo/software/FastTree -wag /home/ikumi/degradeo/pipeline/ikumi_data/Q04457_esterase-2.msa > /home/ikumi/degradeo/pipeline/ikumi_data/output_tree.tree
+"""
+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 FastTree(Step):
+    def __init__(self, fasttree_dir: str, id_col: str, seq_col: str, csv_file: str, output_dir: str):
+        self.fasttree_dir = fasttree_dir
+        self.id_col = id_col
+        self.seq_col = seq_col
+        self.csv_file = csv_file
+        self.num_threads = 1
+        self.output_dir = output_dir
+
+    def create_alignment_file(self, df: pd.DataFrame) -> str:
+        print(f"Creating MSA file from {len(df)} sequences")
+        
+        # Create MSA file in the output directory
+        msa_file = os.path.join(self.output_dir, 'ikumi.data.msa')
+        with open(msa_file, 'w') as fout:
+            for entry, seq in df[[self.id_col, self.seq_col]].values:
+                fout.write(f">{entry.strip()}\n{seq.strip()}\n")
+                
+        print(f"Created MSA file at: {msa_file}")
+        return msa_file
+    
+    def __execute(self, data: list) -> pd.DataFrame:
+        df, tmp_dir = data
+        tmp_label = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
+        # Get the msa file
+        msa_file = self.create_alignment_file(df)
+
+        fasttree_executable = os.path.join(self.fasttree_dir, 'FastTree')
+        output_tree_file = os.path.join(tmp_dir, f'{tmp_label}.tree')
+        
+        # Run FastTree and redirect output to a file
+        with open(output_tree_file, 'w') as outfile:
+            subprocess.run([fasttree_executable, '-wag', msa_file], stdout=outfile, check=True)
+        
+        df = pd.read_csv(output_tree_file, header=None, sep='\t')
+        
+        print(df.head())
+        
+        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/inpaint_ligandMPNN_step.py

@@ -0,0 +1,65 @@
+# #os.system('python run.py --seed 111 --pdb_path "./test_outputs/QHH_0.pdb" --fixed_residues "A19 A20 A21 A59 A60 A61 A90 A91 A92" --checkpoint_path_sc "./model_params/ligandmpnn_sc_v_32_002_16.pt" --out_folder "./outputs/QHH"')
+#os.system('python run.py --seed 111 --pdb_path "./test_outputs/QHH_0.pdb" --fixed_residues "A19 A20 A21 A59 A60 A61 A90 A91 A92" --checkpoint_path_sc "./model_params/ligandmpnn_sc_v_32_002_16.pt" --out_folder "./outputs/QHH"')
+"""
+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 logging
+import os
+
+class LigandMPNN(Step):
+    
+    def __init__(self, pdb_column_name: str, ligand_mpnn_dir: str, output_dir: str, tmp_dir: str = None, args=None, num_threads: int = 1, env_name: str = 'ligandmpnn_env'):
+        self.pdb_column_name = pdb_column_name
+        self.ligand_mpnn_dir = ligand_mpnn_dir
+        self.output_dir = output_dir
+        self.tmp_dir = tmp_dir
+        self.args = args
+        self.num_threads = num_threads
+        self.env_name = env_name
+        self.logger = logging.getLogger(__name__)
+        
+    def __execute(self, data: list) -> np.array:
+        df, tmp_dir = data
+        # Get the PDB files from the column
+        output_filenames = []
+        # You have to change the directory to the ligandmpnn directory
+        os.chdir(self.ligand_mpnn_dir)
+        
+        for pdb_file in df[ self.pdb_column_name].values:
+            cmd = ['conda', 'run', '-n', self.env_name, 'python3', f'{self.ligand_mpnn_dir}run.py', '--pdb_path', pdb_file,  '--out_folder', f'{self.output_dir}']
+            if self.args is not None:
+                cmd.extend(self.args)
+            result = subprocess.run(cmd, check=True)
+            if result.stderr:
+                self.logger.error(result.stderr)
+            else:
+                output_filenames.append(f'{self.output_dir}{pdb_file.split("/")[-1].split(".")[0]}')
+            self.logger.info(result.stdout)
+        df['inpainted_pdb'] = output_filenames
+        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:
+            if self.num_threads > 1:
+                output_filenames = []
+                df_list = np.array_split(df, self.num_threads)
+                for df_chunk in df_list:
+                    output_filenames.append(self.__execute(df_chunk, tmp_dir))
+                    
+                df = pd.DataFrame()
+                for tmp_df in output_filenames:
+                    df = pd.concat([df, tmp_df])
+                return df
+    
+            return self.__execute([df, tmp_dir])
+            return df

enzymetk/main.py

@@ -0,0 +1,37 @@
+###############################################################################
+#                                                                             #
+#    This program is free software: you can redistribute it and/or modify     #
+#    it under the terms of the GNU General Public License as published by     #
+#    the Free Software Foundation, either version 3 of the License, or        #
+#    (at your option) any later version.                                      #
+#                                                                             #
+#    This program is distributed in the hope that it will be useful,          #
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of           #
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            #
+#    GNU General Public License for more details.                             #
+#                                                                             #
+#    You should have received a copy of the GNU General Public License        #
+#    along with this program. If not, see <http://www.gnu.org/licenses/>.     #
+#                                                                             #
+###############################################################################
+
+"""
+Author: Ariane Mora
+Date: September 2024
+"""
+from enzymetk import *
+import argparse
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Run on a dataframe")
+    parser.add_argument('-out', '--out', required=True, help='Path to the output directory')
+    parser.add_argument('-df', '--df', type=str, required=True, help='Fasta of the file of interest')
+    return parser.parse_args()
+
+def main():
+    args = parse_args()
+    #run(args.out, args.df)
+
+if __name__ == "__main__":
+    main()