enzymetk 0.0.1__py3-none-any.whl → 0.0.6__py3-none-any.whl

enzymetk/__init__.py

@@ -22,34 +22,11 @@ Date: March 2025
 __title__ = 'enzymetk'
 __description__ = 'Toolkit for enzymes and what not'
 __url__ = 'https://github.com/arianemora/enzyme-tk/'
-__version__ = '0.0.1'
+__version__ = '0.0.6'
 __author__ = 'Ariane Mora'
 __author_email__ = 'ariane.n.mora@gmail.com'
 __license__ = 'GPL3'
 
-# from enzymetk.step import *
-# from enzymetk.generate_msa_step import ClustalOmega
-# from enzymetk.annotateEC_CLEAN_step import CLEAN
-# from enzymetk.annotateEC_proteinfer_step import ProteInfer
-# from enzymetk.dock_chai_step import Chai
-# from enzymetk.dock_vina_step import Vina
-# from enzymetk.embedchem_chemberta_step import ChemBERT
-# from enzymetk.embedchem_rxnfp_step import RxnFP
-# from enzymetk.embedchem_selformer_step import SelFormer
-# from enzymetk.embedchem_unimol_step import UniMol
-# from enzymetk.embedprotein_esm_step import EmbedESM
-# from enzymetk.generate_tree_step import FastTree
-# from enzymetk.inpaint_ligandMPNN_step import LigandMPNN
-# from enzymetk.metagenomics_porechop_trim_reads_step import PoreChop
-# from enzymetk.metagenomics_prokka_annotate_genes import Prokka
-# #from enzymetk.predict_activity_step import 
-# from enzymetk.predict_catalyticsite_step import ActiveSitePred
-# from enzymetk.sequence_search_blast import BLAST
-# from enzymetk.similarity_foldseek_step import FoldSeek
-# from enzymetk.similarity_mmseqs_step import MMseqs
-# from enzymetk.similarity_reaction_step import ReactionDist
-# from enzymetk.similarity_substrate_step import SubstrateDist
-
 
 
 

enzymetk/annotateEC_CLEAN_step.py

@@ -116,7 +116,7 @@ class CLEAN(Step):
                 print(output_filenames)
                 for sub_df in output_filenames:
                     df = pd.concat([df, sub_df])
-                return df
+                return self.__filter_df(df)
             else:
-                return self.__execute([df, tmp_dir])
+                return self.__filter_df(self.__execute([df, tmp_dir]))
                 return df

enzymetk/annotateEC_CREEP_step.py

@@ -38,7 +38,7 @@ class CREEP(Step):
         self.args_extract = args_extract
         self.args_retrieval = args_retrieval
             
-    def __execute(self, df: pd.DataFrame, tmp_dir: str) -> pd.DataFrame:
+    def __execute(self, df: pd.DataFrame, tmp_dir: str):
         tmp_dir = '/disk1/ariane/vscode/degradeo/pipeline/tmp/'
         input_filename = f'{tmp_dir}/creepasjkdkajshdkja.csv'
         df.to_csv(input_filename, index=False)

enzymetk/dock_boltz_step.py

@@ -0,0 +1,46 @@
+from enzymetk.step import Step
+import pandas as pd
+from docko.boltz import run_boltz_affinity
+import logging
+import numpy as np
+from multiprocessing.dummy import Pool as ThreadPool
+
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+    
+class Boltz(Step):
+    
+    def __init__(self, id_col: str, seq_col: str, substrate_col: str, intermediate_col: str, output_dir: str, num_threads: int):
+        self.id_col = id_col
+        self.seq_col = seq_col
+        self.substrate_col = substrate_col
+        self.intermediate_col = intermediate_col
+        self.output_dir = output_dir or None
+        self.num_threads = num_threads or 1
+
+    def __execute(self, df: pd.DataFrame) -> pd.DataFrame:
+        output_filenames = []
+        
+        for run_id, seq, substrate, intermediate in df[[self.id_col, self.seq_col, self.substrate_col, self.intermediate_col]].values:
+            # Might have an issue if the things are not correctly installed in the same dicrectory 
+            if not isinstance(substrate, str):
+                substrate = ''
+            print(run_id, seq, substrate)
+            run_boltz_affinity(run_id, seq, substrate, self.output_dir, intermediate)
+            output_filenames.append(f'{self.output_dir}/{run_id}/')
+        return output_filenames
+    
+    def execute(self, df: pd.DataFrame) -> pd.DataFrame:
+        if self.output_dir:
+            if self.num_threads > 1:
+                pool = ThreadPool(self.num_threads)
+                df_list = np.array_split(df, self.num_threads)
+                results = pool.map(self.__execute, df_list)
+            else:
+                results = self.__execute(df)
+            df['output_dir'] = results
+            return df
+        else:
+            print('No output directory provided')

enzymetk/dock_chai_step.py

@@ -11,16 +11,17 @@ logger.setLevel(logging.INFO)
     
 class Chai(Step):
     
-    def __init__(self, id_col: str, seq_col: str, substrate_col: str, output_dir: str, num_threads: int):
+    def __init__(self, id_col: str, seq_col: str, substrate_col: str, cofactor_col: str, output_dir: str, num_threads: int):
         self.id_col = id_col
         self.seq_col = seq_col
         self.substrate_col = substrate_col
+        self.cofactor_col = cofactor_col
         self.output_dir = output_dir or None
         self.num_threads = num_threads or 1
 
     def __execute(self, df: pd.DataFrame, tmp_dir: str) -> pd.DataFrame:
         output_filenames = []
-        for run_id, seq, substrate in df[[self.id_col, self.seq_col, self.substrate_col]].values:
+        for run_id, seq, substrate, cofactor in df[[self.id_col, self.seq_col, self.substrate_col, self.cofactor_col]].values:
             # Might have an issue if the things are not correctly installed in the same dicrectory 
             if not isinstance(substrate, str):
                 substrate = ''
@@ -28,7 +29,8 @@ class Chai(Step):
             run_chai(run_id, # name
                     seq, # sequence
                     substrate, # ligand as smiles
-                    tmp_dir)
+                    tmp_dir,
+                    cofactor) # cofactor as smiles
             output_filenames.append(f'{tmp_dir}/{run_id}/')
         return output_filenames
     

enzymetk/dock_vina_step.py

@@ -4,6 +4,7 @@ from docko.docko import *
 import logging
 import numpy as np
 import os
+from pathlib import Path
 from multiprocessing.dummy import Pool as ThreadPool
 
 logger = logging.getLogger(__name__)
@@ -21,34 +22,66 @@ class Vina(Step):
         self.substrate_col = substrate_col
         self.substrate_name_col = substrate_name_col
         self.active_site_col = active_site_col  # Expects active site residues as a string separated by |
-        self.output_dir = output_dir or None
+        self.output_dir = Path( output_dir) or None
         self.num_threads = num_threads or 1
 
     def __execute(self, df: pd.DataFrame) -> pd.DataFrame:
         output_filenames = []
         # ToDo: update to create from sequence if the path doesn't exist.
         for label, structure_path, seq, substrate_smiles, substrate_name, residues in df[[self.id_col, self.structure_col, self.sequence_col, self.substrate_col, self.substrate_name_col, self.active_site_col]].values:
-            os.system(f'mkdir {self.output_dir}{label}')
+
             try:
+                structure_path = str(structure_path)
                 residues = str(residues)
                 residues = [int(r) + 1 for r in residues.split('|')]
-                if not os.path.exists(f'{structure_path}'):
-                    # Try get the AF2 structure we expect the label to be the uniprot id
-                    get_alphafold_structure(label, f'{self.output_dir}{label}/{label}_AF2.pdb')
-                    structure_path = f'{self.output_dir}{label}/{label}_AF2.pdb'
-                clean_one_pdb(f'{structure_path}', f'{self.output_dir}{label}/{label}.pdb')
-                pdb_to_pdbqt_protein(f'{self.output_dir}{label}/{label}.pdb', f'{self.output_dir}{label}/{label}.pdbqt')
-                score = dock(sequence='', protein_name=label, smiles=substrate_smiles, ligand_name=substrate_name, residues=residues, 
-                            protein_dir=f'{self.output_dir}', ligand_dir=f'{self.output_dir}', output_dir=f'{self.output_dir}{label}/', pH=7.4,
-                            method='vina', size_x=10.0, size_y=10.0, size_z=10.0)
-                output_filename = f'{self.output_dir}{label}/{label}.pdb'
-                output_filenames.append(output_filename)
+
+                label_dir = self.output_dir / label
+                label_dir.mkdir(parents=True, exist_ok=True)
+                structure_path = Path(structure_path)
+
+                if not structure_path.exists():
+                    # Try to download AF2 structure
+                    get_alphafold_structure(label, label_dir / f"{label}_AF2.pdb")
+                    structure_path = label_dir / f"{label}_AF2.pdb"
+
+                # Skip if still not found
+                if not structure_path.exists():
+                    print(f"Skipping {label}: AF2 structure not found.")
+                    output_filenames.append(None)
+                    continue
+            
+                # Proceed with docking
+                pdb_path = label_dir / f"{label}.pdb"
+                pdbqt_path = label_dir / f"{label}.pdbqt"
+
+                clean_one_pdb(str(structure_path), str(pdb_path))
+                pdb_to_pdbqt_protein(str(pdb_path), str(pdbqt_path))
+
+                score = dock(
+                    sequence='',
+                    protein_name=label,
+                    smiles=substrate_smiles,
+                    ligand_name=substrate_name,
+                    residues=residues,
+                    protein_dir=str(self.output_dir),
+                    ligand_dir=str(self.output_dir),
+                    output_dir=str(label_dir),
+                    pH=7.4,
+                    method='vina',
+                    size_x=10.0,
+                    size_y=10.0,
+                    size_z=10.0
+                )
+
+                output_filenames.append(str(pdb_path))
+                
             except Exception as e:
                 print(f'Error docking {label}: {e}')
                 output_filenames.append(None)
+            
         return output_filenames
-        
-    
+
+ 
     def execute(self, df: pd.DataFrame) -> pd.DataFrame:
         if self.output_dir:
             if self.num_threads > 1:
@@ -60,4 +93,4 @@ class Vina(Step):
             df['output_dir'] = results
             return df
         else:
-            print('No output directory provided')
+            print('No output directory provided')

enzymetk/embedprotein_esm3_step.py

@@ -0,0 +1,71 @@
+# ESM 3 script
+from esm.sdk.api import ESMProtein
+from tempfile import TemporaryDirectory
+import torch
+import os
+import pandas as pd
+from esm.models.esm3 import ESM3
+from esm.sdk.api import ESMProtein, SamplingConfig
+from huggingface_hub import login
+from enzymetk.step import Step
+import numpy as np
+from tqdm import tqdm 
+
+# CUDA setup
+os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"   # see issue #152
+cuda = True
+DEVICE = torch.device("cuda" if cuda else "cpu")
+device = DEVICE 
+
+
+class EmbedESM3(Step):
+    
+    def __init__(self, id_col: str, seq_col: str, extraction_method='mean', num_threads=1, 
+                 tmp_dir: str = None, env_name: str = 'enzymetk', save_tensors=False): # type: ignore
+        login()
+        self.client = ESM3.from_pretrained("esm3-open").to("cuda")
+        self.seq_col = seq_col
+        self.id_col = id_col
+        self.num_threads = num_threads or 1
+        self.extraction_method = extraction_method
+        self.tmp_dir = tmp_dir
+        self.env_name = env_name
+        self.save_tensors = save_tensors
+
+    def __execute(self, df: pd.DataFrame, tmp_dir: str) -> pd.DataFrame: 
+        client = self.client
+        means = []
+        for id, seq in tqdm(df[[self.id_col, self.seq_col]].values):
+            protein = ESMProtein(
+                sequence=(
+                    seq
+                )
+            )
+            protein_tensor = client.encode(protein)
+            output = client.forward_and_sample(
+                protein_tensor, SamplingConfig(return_per_residue_embeddings=True)
+            )
+            if self.save_tensors:
+                torch.save(output.per_residue_embedding, os.path.join(tmp_dir, f'{id}.pt'))
+            means.append(np.array(output.per_residue_embedding.mean(dim=0).cpu()))
+        df['esm3_mean']  = means
+        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/embedprotein_esm_step.py

@@ -70,8 +70,8 @@ def extract_mean_embedding(df, id_column, encoding_dir, rep_num=33):
 
 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'):
+    def __init__(self, id_col: str, seq_col: str, model='esm2_t36_3B_UR50D', extraction_method='mean', 
+                 active_site_col: str = None, num_threads=1, tmp_dir: str = None, env_name: str = 'enzymetk', rep_num=36):
         self.seq_col = seq_col
         self.id_col = id_col
         self.active_site_col = active_site_col
@@ -80,6 +80,7 @@ class EmbedESM(Step):
         self.extraction_method = extraction_method
         self.tmp_dir = tmp_dir
         self.env_name = env_name
+        self.rep_num = rep_num
 
     def __execute(self, df: pd.DataFrame, tmp_dir: str) -> pd.DataFrame:
         input_filename = f'{tmp_dir}/input.fasta'
@@ -95,11 +96,11 @@ class EmbedESM(Step):
         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)
+            df = extract_mean_embedding(df, self.id_col, tmp_dir, rep_num=self.rep_num)
         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)
+            df = extract_active_site_embedding(df, self.id_col, self.active_site_col, tmp_dir, rep_num=self.rep_num)
         
         return df
     

enzymetk/inpaint_ligandMPNN_step.py

@@ -16,7 +16,8 @@ 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'):
+    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
@@ -34,7 +35,7 @@ class LigandMPNN(Step):
         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}']
+            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)

enzymetk/predict_catalyticsite_run.py

@@ -11,7 +11,7 @@ def run_as_inference(output_dir, fasta_file, squidly_dir, toks_per_batch, as_thr
     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
+    as_threshold = 0.97
     #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

enzymetk/predict_catalyticsite_step.py

@@ -8,6 +8,8 @@ import numpy as np
 from tqdm import tqdm
 import random
 import string
+import logging
+import os
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
@@ -15,15 +17,17 @@ 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):
+    def __init__(self, id_col: str, seq_col: str, num_threads: int = 1, 
+                 esm2_model = 'esm2_t36_3B_UR50D', tmp_dir: str = None, args=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
-
+        self.args = None
+        self.logger = logging.getLogger(__name__)
+        print('Predicting Active Sites using Squidly')
+        
     def __to_fasta(self, df: pd.DataFrame, tmp_dir: str):
         tmp_label = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
 
@@ -37,13 +41,17 @@ class ActiveSitePred(Step):
     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")}'
+        cmd = []
+        cmd = ['squidly', 'run', input_filename, self.esm2_model, tmp_dir]
+        if self.args is not None:
+            cmd.extend(self.args)
+        result = self.run(cmd)
         if result.stderr:
-            logger.error(result.stderr)
-        logger.info(result.stdout)   
-        
+            self.logger.error(result.stderr)
+            print(result.stderr)
+        else:
+            self.logger.info(result.stdout)
+        output_filename = os.path.join(tmp_dir, 'squidly_ensemble.csv')
         return output_filename
     
     def execute(self, df: pd.DataFrame) -> pd.DataFrame:
@@ -61,10 +69,10 @@ class ActiveSitePred(Step):
                 df = pd.DataFrame()
                 print(output_filenames)
                 for p in output_filenames:
-                    sub_df = pd.read_pickle(p)
+                    sub_df = pd.read_csv(p)
                     df = pd.concat([df, sub_df])
                 return df
             
             else:
                 output_filename = self.__execute(df, tmp_dir)
-                return pd.read_pickle(output_filename)
+                return pd.read_csv(output_filename)

enzymetk/sequence_search_blast.py

@@ -3,6 +3,7 @@ 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 logging
 
 import pandas as pd
 import numpy as np
@@ -12,10 +13,17 @@ import os
 import subprocess
 import random
 import string
+from tqdm import tqdm 
+
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
 
 class BLAST(Step):
     
-    def __init__(self, id_col: str, sequence_col: str, label_col=None, database=None, mode='blastp', args=None, tmp_dir=None):
+    def __init__(self, id_col: str, sequence_col: str, label_col=None, database=None,
+                 mode='blastp', args=None, tmp_dir=None, num_threads=1):
         self.id_col = id_col
         self.seq_col = sequence_col
         self.label_col = label_col  # This is whether it is query or reference
@@ -23,6 +31,7 @@ class BLAST(Step):
         self.database = database
         self.args = args
         self.tmp_dir = tmp_dir
+        self.num_threads = num_threads
         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 \
@@ -74,7 +83,27 @@ class BLAST(Step):
         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])
+            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()
+                for sub_df in output_filenames:
+                    df = pd.concat([df, sub_df])
+                return df
+            
+            else:
+                return self.__execute([df, tmp_dir])
+            
+    # 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

@@ -7,13 +7,17 @@ repo and then copy it out of it.
 """
 from enzymetk.step import Step
 
-
+import logging
 import pandas as pd
 import numpy as np
 from tempfile import TemporaryDirectory
 import subprocess
 import random
 import string
+from tqdm import tqdm 
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
 
 
 def process_clustering(filename, df, id_column_name):
@@ -34,13 +38,14 @@ def process_clustering(filename, df, id_column_name):
 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):
+                 args=None, num_threads=1, 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.num_threads = num_threads
         self.query_type = query_type
         if self.method not in ['search', 'cluster']:
             print('Method must be in "search" or "cluster". Will likely fail... ')
@@ -107,8 +112,23 @@ class FoldSeek(Step):
         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
+            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 sub_df in output_filenames:
+                    df = pd.concat([df, sub_df])
+                return df
+            
+            else:
+                df = self.__execute([df, tmp_dir])
+                return df

enzymetk/similarity_reaction_step.py

@@ -24,22 +24,26 @@ class ReactionDist(Step):
         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)
+        reaction_df = data        
         rows = []
+        fp_params = rdChemReactions.ReactionFingerprintParams()
+        rxn = rdChemReactions.ReactionFromSmarts(self.smiles_string)
+        rxn_fp = rdChemReactions.CreateStructuralFingerprintForReaction(rxn, ReactionFingerPrintParams=fp_params) #rdChemReactions.CreateStructuralFingerprintForReaction(rxn, ReactionFingerPrintParams=fp_params)
+
         # 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, 
+            # Note: if you don't pass , ReactionFingerPrintParams=fp_params you get different results
+            # i.e. reactions that don't appear to be the same are reported as similar of 1.0
+            # https://github.com/rdkit/rdkit/discussions/5263
+            fps = rdChemReactions.CreateStructuralFingerprintForReaction(mol_, ReactionFingerPrintParams=fp_params)
+            rows.append([smile_id,
+                         self.smiles_string, 
                          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'])
+        distance_df = pd.DataFrame(rows, columns=[self.id_column_name, 'QuerySmiles', 'TargetSmiles', 'TanimotoSimilarity', 'RusselSimilarity', 'CosineSimilarity'])
         return distance_df
         
     def execute(self, df: pd.DataFrame) -> pd.DataFrame:

enzymetk/similarity_substrate_step.py

@@ -1,3 +1,5 @@
+import sys
+sys.path.append('/disk1/ariane/vscode/enzyme-tk/')
 from enzymetk.step import Step
 import pandas as pd
 import numpy as np
@@ -8,6 +10,7 @@ from rdkit.Chem import rdChemReactions
 import pandas as pd
 import os
 from rdkit.DataStructs import FingerprintSimilarity
+from rdkit.Chem import rdFingerprintGenerator
 from rdkit.Chem.Fingerprints import FingerprintMols
 import random
 import string
@@ -28,12 +31,15 @@ class SubstrateDist(Step):
         tmp_label = ''.join(random.choices(string.ascii_letters + string.digits, k=10))
         
         rxn = Chem.MolFromSmiles(self.smiles_string)
-        rxn_fp = FingerprintMols.FingerprintMol(rxn)
+        # Switched to using morgan fingerprints https://greglandrum.github.io/rdkit-blog/posts/2023-01-18-fingerprint-generator-tutorial.html
+        # followed this tutorial
+        mfpgen = rdFingerprintGenerator.GetMorganGenerator(radius=2,fpSize=2048)
+        rxn_fp = mfpgen.GetFingerprint(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_)
+            fps = mfpgen.GetFingerprint(mol_)
             rows.append([smile_id, 
                          smiles, 
                          DataStructs.TanimotoSimilarity(fps, rxn_fp), 

enzymetk/step.py

@@ -36,8 +36,9 @@ class Step():
         """ Execute some shit """ 
         return df
     
-    def run(self, cmd: list) -> None:
-        """ Run a command """
+    def run(self, cmd: list):
+        """ Run a command """   
+        result = None
         start = timeit.default_timer()
         u.dp(['Running command', ' '.join([str(c) for c in cmd])])
         result = subprocess.run(cmd, capture_output=True, text=True)       
@@ -48,8 +49,9 @@ class Step():
             logger.error(result.stderr)
         logger.info(result.stdout)
         u.dp(['Time for command to run (min): ', (timeit.default_timer() - start)/60])
+        return result
 
-    def __rshift__(self, other: Step) -> Step:
+    def __rshift__(self, other: Step)   :
         return Pipeline(self, other)
         
     def __rlshift__(self, other: pd.DataFrame) -> pd.DataFrame:

{enzymetk-0.0.1.dist-info → enzymetk-0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: enzymetk
-Version: 0.0.1
+Version: 0.0.6
 Home-page: https://github.com/arianemora/enzyme-tk/
 Author: Ariane Mora
 Author-email: ariane.n.mora@gmail.com
@@ -18,17 +18,12 @@ 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: pandas
 Requires-Dist: biopython
-Requires-Dist: sentence_transformers
-Requires-Dist: pubchempy
-Requires-Dist: pyfaidx
-Requires-Dist: spacy
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -37,6 +32,7 @@ Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: keywords
 Dynamic: license
+Dynamic: license-file
 Dynamic: project-url
 Dynamic: requires-dist
 Dynamic: requires-python
@@ -45,26 +41,36 @@ Dynamic: requires-python
 
 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). 
 
+
+**If you have any issues installing, let me know - this has been tested only on Linux/Ubuntu. Please post an issue!**
+
 ## Installation
 
+## Install base package to import modules
+
 ```bash
-source enzymetk/conda_envs/install_all.sh
+pip install enzymetk
 ```
 
-## Install subsets of enzyme-tk
+### Install only the specific requirements you need (recomended) 
 
+For this clone the repo and then install the requirements for the specific modules you use 
 ```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
+cd enzymetk/conda_envs/ # would recommend looking at thes
+# e.g. to install all from within that folder you would do
+source install_all.sh
 ```
 
 ## Usage
 
 If you have any issues at all just email me using my caltech email: `amora at caltech . edu`
 
+This is a work-in progress! e.g. some tools (e.g. proteInfer and CLEAN) require extra data to be downloaded in order to run (like model weights.) I'm working on integrating these atm, buzz me if you need this!
+
 Here are some of the tools that have been implemented to be chained together as a pipeline:
 
+[boltz2](https://github.com/jwohlwend/boltz)
 [mmseqs2](https://github.com/soedinglab/mmseqs2)  
 [foldseek](https://github.com/steineggerlab/foldseek)  
 [diamond](https://github.com/bbuchfink/diamond)  
@@ -83,6 +89,7 @@ Here are some of the tools that have been implemented to be chained together as
 [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.
@@ -114,6 +121,8 @@ The steps are the main building blocks of the pipeline. They are responsible for
 
 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.
 
+Note you need to have installed the BLAST environment.
+
 ```python
 id_col = 'Entry'
 seq_col = 'Sequence'
@@ -142,6 +151,34 @@ 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'))
 
+```
+### Boltz2
+
+Boltz2 is a model for predicting structures. Note you need docko installed as I run via that.
+
+Below is an example using boltz with 4 threads, and uses a cofactor (intermediate in this case). Just set to be None for a single substrate version.
+```
+import sys
+from enzymetk.dock_boltz_step import Boltz
+from enzymetk.save_step import Save
+import pandas as pd
+import os
+os.environ['MKL_THREADING_LAYER'] = 'GNU'
+
+output_dir = 'tmp/'
+num_threads = 4
+id_col = 'Entry'
+seq_col = 'Sequence'
+substrate_col = 'Substrate'
+intermediate_col = 'Intermediate'
+
+rows = [['P0DP23_boltz_8999', 'MALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAA', 'CCCCC(CC)COC(=O)C1=CC=CC=C1C(=O)OCC(CC)CCCC', 'CC1=C(C2=CC3=C(C(=C([N-]3)C=C4C(=C(C(=N4)C=C5C(=C(C(=N5)C=C1[N-]2)C)C=C)C)C=C)C)CCC(=O)[O-])CCC(=O)[O-].[Fe]'], 
+        ['P0DP24_boltz_p1', 'MALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAA', 'CCCCC(CC)COC(=O)C1=CC=CC=C1C(=O)OCC(CC)CCCC', 'CC1=C(C2=CC3=C(C(=C([N-]3)C=C4C(=C(C(=N4)C=C5C(=C(C(=N5)C=C1[N-]2)C)C=C)C)C=C)C)CCC(=O)[O-])CCC(=O)[O-].[Fe]'],
+        ['P0DP23_boltz_p2', 'MALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAA', 'CCCCC(CC)COC(=O)C1=CC=CC=C1C(=O)OCC(CC)CCCC', 'CC1=C(C2=CC3=C(C(=C([N-]3)C=C4C(=C(C(=N4)C=C5C(=C(C(=N5)C=C1[N-]2)C)C=C)C)C=C)C)CCC(=O)[O-])CCC(=O)[O-].[Fe]'], 
+        ['P0DP24_boltz_p3', 'MALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAA', 'CCCCC(CC)COC(=O)C1=CC=CC=C1C(=O)OCC(CC)CCCC', 'CC1=C(C2=CC3=C(C(=C([N-]3)C=C4C(=C(C(=N4)C=C5C(=C(C(=N5)C=C1[N-]2)C)C=C)C)C=C)C)CCC(=O)[O-])CCC(=O)[O-].[Fe]'],
+        ['P0DP24_boltz_p4', 'MALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAAMALWMRLLPLLALLALWGPDPAAA', 'CCCCC(CC)COC(=O)C1=CC=CC=C1C(=O)OCC(CC)CCCC', 'CC1=C(C2=CC3=C(C(=C([N-]3)C=C4C(=C(C(=N4)C=C5C(=C(C(=N5)C=C1[N-]2)C)C=C)C)C=C)C)CCC(=O)[O-])CCC(=O)[O-].[Fe]']]
+df = pd.DataFrame(rows, columns=[id_col, seq_col, substrate_col, intermediate_col])
+df << (Boltz(id_col, seq_col, substrate_col, intermediate_col, f'{output_dir}', num_threads) >> Save(f'{output_dir}test.pkl'))
 ```
 
 ### Chai
@@ -169,8 +206,8 @@ df << (Chai(id_col, seq_col, substrate_col, f'{output_dir}', num_threads) >> Sav
 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
+from enzymetk.embedchem_chemberta_step import ChemBERT
+from enzymetk.save_step import Save
 
 output_dir = 'tmp/'
 num_threads = 1
@@ -180,7 +217,7 @@ 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'))
+new_df = (df << (ChemBERT(id_col, substrate_col, num_threads) >> Save(f'{output_dir}chemberta.pkl')))
 ```
 
 ### CLEAN
@@ -206,11 +243,11 @@ df << (CLEAN(id_col, seq_col, clean_dir, num_threads=num_threads) >> Save(f'clea
 ```
 ### 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.
+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. You need to have installed it first (check out the `conda_envs` directory in enzymetk.)
 
 ```python
-from steps.generate_msa_step import ClustalOmega
-from steps.save_step import Save
+from enzymetk.generate_msa_step import ClustalOmega
+from enzymetk.save_step import Save
 import pandas as pd
 
 id_col = 'Entry'
@@ -230,8 +267,8 @@ df << (ClustalOmega(id_col, seq_col) >> Save('tmp/clustalomega_test.pkl'))
 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
+from enzymetk.annotateEC_CREEP_step import CREEP
+from enzymetk.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
@@ -252,8 +289,8 @@ df << (CREEP(id_col, reaction_col, CREEP_cache_dir='/disk1/share/software/CREEP/
 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
+from enzymetk.embedprotein_esm_step import EmbedESM
+from enzymetk.save_step import Save
 import pandas as pd
 
 id_col = 'Entry'
@@ -280,8 +317,8 @@ 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
+from enzymetk.similarity_foldseek_step import FoldSeek
+from enzymetk.save_step import Save
 import pandas as pd
 
 # id_col: str, seq_col: str, proteinfer_dir: str,

{enzymetk-0.0.1.dist-info → enzymetk-0.0.6.dist-info}/RECORD

@@ -1,44 +1,46 @@
-enzymetk/__init__.py,sha256=hJvEiNN7n7w7Z8iPgWs2yi0lesggWT6-bG9CcHbSoSw,2770
-enzymetk/annotateEC_CLEAN_step.py,sha256=J9_ybM8VGgH0DQ7ZR2q5eXWzgHGOs9LKUeYJLS1WLRA,5412
-enzymetk/annotateEC_CREEP_step.py,sha256=4OnqQJa0CJF-xb8zWyih5-SFHiqV-yPfUiqKUbsCLwE,4231
+enzymetk/__init__.py,sha256=q1VxzDTE-F13VrPzIJjRJmwyPEaPfZyqKdkIJx406Ag,1575
+enzymetk/annotateEC_CLEAN_step.py,sha256=Id4uMtETKjvsnz58SGXlw9r-5T0TYOcvhS3Mi9xhHTw,5448
+enzymetk/annotateEC_CREEP_step.py,sha256=CZ0mh1UhVp0VShAzHnr9iifB2h1bCeMaHmBUj__t80Y,4215
 enzymetk/annotateEC_proteinfer_step.py,sha256=GTy27Z5SyG2EPvlf9HTZZ-HRG8FrAs9p0G0OCPmcIW4,6245
-enzymetk/dock_chai_step.py,sha256=3LFnsmxmkKWesbM1pXxCUlPDDD0E93ezpojBdEEdVzw,1871
-enzymetk/dock_vina_step.py,sha256=_pPJ9ClpMYwPUl6Y7udqzrRzBJeKhENk3U3zy238PVY,3220
+enzymetk/dock_boltz_step.py,sha256=pHkJSMTgKq0deEM-_cphXlQH1VL73BvRh8JEpv8ighA,1779
+enzymetk/dock_chai_step.py,sha256=YVHJHm1oAN6oOVfi7aV-6cqlQdA05yEIN0lhWAsj4oI,2011
+enzymetk/dock_vina_step.py,sha256=o1M7En9DQPMTJx5Lh29cAPkZTvD3EkNrBvFMGlT-HAo,3826
 enzymetk/embedchem_chemberta_step.py,sha256=uS7qf_adO0X_sACnCp3ULakTtepx0soHL9y6WMnaaqk,2328
 enzymetk/embedchem_rxnfp_run.py,sha256=n6ERAhql947-L0-_xvsBHLFyixjUW5yknDPHdM4CNOQ,1061
 enzymetk/embedchem_rxnfp_step.py,sha256=fmkJcuKpHllDNxkq0zV1jM2R7KREyEEG1KrVngOcvC8,2111
 enzymetk/embedchem_selformer_run.py,sha256=ibN7pbSRl1YqpHgVVaQKWpUk0E80U5ue_2dDlttn10M,1566
 enzymetk/embedchem_selformer_step.py,sha256=UQkRc6V7N1Zk3p4gR_MEKALX45bhhGw_8_xc5kM44Yw,1461
 enzymetk/embedchem_unimol_step.py,sha256=9KL4bto2O1YujZy5UpauBtGlIEUwTRMa8raVqFnX0zQ,2133
-enzymetk/embedprotein_esm_step.py,sha256=Qw4UiftDh5wptvy2NVW-yZmuk__yVHSIL_h-vqeMHqc,5811
+enzymetk/embedprotein_esm3_step.py,sha256=l_8Bfyh0JgJ5R3xo2tPVgrfFBsHqoNGeIIwWwIXzPQI,2575
+enzymetk/embedprotein_esm_step.py,sha256=f99unRqyfw9Gsr2j7-7rwqtnxdYAZ3RXppLW549vpaE,5896
 enzymetk/esm-extract.py,sha256=W9n9--Pde2uUuIQP9LrPMHlLZGfpKvrJQ-SuTvGRYmc,5160
 enzymetk/filter_sequence_step.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 enzymetk/filter_structure_step.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 enzymetk/generate_msa_step.py,sha256=w-CrKPMxAwqjsbPQcRq3HP12FyiyuDq0qnt0ObsVhPk,2325
 enzymetk/generate_oligopool_step.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 enzymetk/generate_tree_step.py,sha256=eee2pILdm3lxVYTsO3CoTCwbY7MfdSK3ve84uMkLwnY,3130
-enzymetk/inpaint_ligandMPNN_step.py,sha256=t3A0znvgB44MnAQn_hebOMuhASN2qObbzYLGf8nTPbo,3013
+enzymetk/inpaint_ligandMPNN_step.py,sha256=DOHXTo6BUeEqzYsoJrS5komi1R0yMybeh5ljyRQLIGs,3032
 enzymetk/main.py,sha256=aY9dEM0a_1jnIJaRTrysLD4KqD5vWMx2OTavh3s4ZxA,1789
 enzymetk/metagenomics_porechop_trim_reads_step.py,sha256=0-wEDqMRFr5c8TtzUmbgUL6S1UgigR5oOano1l_MYDU,2156
 enzymetk/metagenomics_prokka_annotate_genes.py,sha256=VdBTkzUUwq4dMHMm-fb7CBVjTH57gRULLfrGJzqBbWg,2572
 enzymetk/pipeline.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 enzymetk/predict_activity_step.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-enzymetk/predict_catalyticsite_run.py,sha256=CqAgQQ6b_ZqAzAqVUBXNuy0GWZ73vc3acOWI44L0KEo,2782
-enzymetk/predict_catalyticsite_step.py,sha256=Hdon3Ua-kJBABfln148gBNug3E3hpPrxDuVO_3BeC68,2904
+enzymetk/predict_catalyticsite_run.py,sha256=cZVda3bTufV6jwXm5puymYyFIYq3SHon3bhIHXIRYMA,2782
+enzymetk/predict_catalyticsite_step.py,sha256=j6bAxnsQ6h0pfGkFXVVgp54oZm6dFaV1vaJSYHnUXF4,2966
 enzymetk/reducedim_pca_run.py,sha256=SUCLrs9P2L8uGuWnkMcbn_mihtMzhVu3PynCaCjUA1Y,2969
 enzymetk/reducedim_vae_run.py,sha256=SUCLrs9P2L8uGuWnkMcbn_mihtMzhVu3PynCaCjUA1Y,2969
 enzymetk/reducedim_vae_step.py,sha256=bAp1jJESawvxyf2_PKXQAr9JsUcO6vWuHAU3PT0ScJA,235
 enzymetk/save_step.py,sha256=g-1XvurzUNoIRO8pNOHlvVUyTU_87JW-ZFGf5asna2A,293
-enzymetk/sequence_search_blast.py,sha256=WZd5yGynmcX3BRwMdTiBelzpRYbiK_qr8flTxWe33rw,3949
-enzymetk/similarity_foldseek_step.py,sha256=fw0o2xOgMzaMtVQw-cXEIYCaadUvEwp3sz_sYrzQS8c,5356
+enzymetk/sequence_search_blast.py,sha256=rqtse4lG2Zeg3UgtMIV6RLu7wyv7q7w0SxPia_4N4zE,5022
+enzymetk/similarity_foldseek_step.py,sha256=_Vrvv6UCwHBP94lS9V5QX61dyxsoAr10gjp1PubXUig,6185
 enzymetk/similarity_mmseqs_step.py,sha256=FSne7ATtkPBDJzk_-c6W-ZHfGStiGNEtpWMerXlEZZU,3494
-enzymetk/similarity_reaction_step.py,sha256=foreZD3rrIfso_XitfOtqL6bFR_WEXKFCy1spPAWWF8,2477
-enzymetk/similarity_substrate_step.py,sha256=JknH0uhLc1OKVJbnXWtBIArgthXteijl7MuGWzBqVlA,2386
-enzymetk/step.py,sha256=Nqkr6h9NT7_snkrxaRuze-qxUy3_aVzN8ciilkXGahs,1728
-enzymetk-0.0.1.data/data/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-enzymetk-0.0.1.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-enzymetk-0.0.1.dist-info/METADATA,sha256=Pn3pl8TFitYoMFWisQiehqqNwkcaifEFf4HZHQsaN2o,20171
-enzymetk-0.0.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-enzymetk-0.0.1.dist-info/entry_points.txt,sha256=RU3pSTXg2RyNLlc0asRpBYRkmv5GpRP7teeDY7Tr7e0,52
-enzymetk-0.0.1.dist-info/top_level.txt,sha256=Qct8wLw9EjZ4yfKaKeJHBjWWuoK_FwHZgbIBb6PwBgg,9
-enzymetk-0.0.1.dist-info/RECORD,,
+enzymetk/similarity_reaction_step.py,sha256=yQRyipdG2CyjEZ7hmr4Y-pGa32eAmxjWm4zqABCh6-g,2942
+enzymetk/similarity_substrate_step.py,sha256=Sw8C2TCDHLMoYeay69bj6p_dKhmpMV4hBUkm4pYBBxQ,2732
+enzymetk/step.py,sha256=LmcIyUh7XFxyt2P2LwtFJZ8Ca9Nyo7nLz6dRejHxkoc,1762
+enzymetk-0.0.6.data/data/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+enzymetk-0.0.6.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+enzymetk-0.0.6.dist-info/METADATA,sha256=vgGo4q5EI_j-lv9EMy16BJOIuiaTgZcC1xMGdLRAc80,22931
+enzymetk-0.0.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+enzymetk-0.0.6.dist-info/entry_points.txt,sha256=RU3pSTXg2RyNLlc0asRpBYRkmv5GpRP7teeDY7Tr7e0,52
+enzymetk-0.0.6.dist-info/top_level.txt,sha256=Qct8wLw9EjZ4yfKaKeJHBjWWuoK_FwHZgbIBb6PwBgg,9
+enzymetk-0.0.6.dist-info/RECORD,,

{enzymetk-0.0.1.dist-info → enzymetk-0.0.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any