Datasets:

kunikohunter
/

CatPred-DB

import os
import json
import time
import pandas as pd
import numpy as np
import requests
import ete3
import re
import rdkit
from tqdm import tqdm
from rdkit import Chem
from rdkit.Chem import AllChem
from rdkit import DataStructs
from rdkit.Chem import rdChemReactions
from joblib import delayed, Parallel
from rdkit.Chem import Descriptors
from rdkit import RDLogger
RDLogger.DisableLog('rdApp.*')

import requests
import sys
import argparse

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument("--rawdata_dir", help="raw data directory", type=str, required=True)
    parser.add_argument("--processed_dir", help="processed dir to save", 
                        type=str, required=True)
    parser.add_argument("--out_file_name", help="name for out file", 
                        type=str, required=True)

    args, unparsed = parser.parse_known_args()
    parser = argparse.ArgumentParser()

    return args

args = parse_args()
PARAMETERS_OF_INTEREST = ['km_value','kcat_km','ki_value','ic50','turnover_number']
EC_WORD_NAMES = ["ec1", "ec2", "ec3", "ec"]
TAX_WORD_NAMES = [
"superkingdom",
"phylum",
"class",
"order",
"family",
"genus",
"species"]
INCLUDE_OTHERS_AS_WILDTYPE = True
N_PROCS = 30

DATA_DIR = args.rawdata_dir
out_path = args.processed_dir + '/'+ args.out_file_name

# Load BRENDA raw data
# Downloaded from https://www.brenda-enzymes.org/download.php
data = json.load(open(f'{DATA_DIR}/brenda_2022_2.json'))['data']

## Ligand data
# Go to https://www.brenda-enzymes.org/search_result.php?a=13 and place a blank query to get all ligands and their InChi strings
# Downloaded and pre-processed this along with missing metabolites using PubChem id-exchange service
# https://pubchem.ncbi.nlm.nih.gov/idexchange/idexchange.cgi

metabolite_inchi_smiles_dic = pd.read_csv(f'{DATA_DIR}/metabolite_inchi_smiles_brenda_pubchem.tsv',sep='\t',
                                          index_col='metabolite')

# Create an empty dataframe and columns
df = pd.DataFrame()

# storing ec numbers
eccol = []
# storing organism names
orgcol = []

# storing parameter type (like turnover_number, km_value etc.)
paramcol = []
# storing parameter values (like km,ki etc.)
valcol = []

# storing reactions (reactants, products)
rxncol = []

# storing substrates
subcol = []

# storing if the substrate is from a natural reaction or not
natural_substrate_col = []

# storing uniprots wherever available
unicol = []

# storing comment strings
commentcol = []

# storing ph optimum & temperature optimum
phopt_col = []
topt_col = []

# all
all_metabolite_names = set()
all_natural_metabolite_names = set()

#metals and ions list
metals_ions_list = set()

for ec in tqdm(data):
    if not ('proteins' in data[ec] or 'organisms' in data[ec]):
        # this means we cannot featurize entries from this ec, so skip it
        continue
    
    # not all entries for an ec number have all params
    # see which among the parameters of interest are present
    params_present = []
    for parameter_data in PARAMETERS_OF_INTEREST:
        if parameter_data in data[ec]: params_present.append(parameter_data)
    
    # for mapping organisms
    if 'organisms' in data[ec]: orgs_ec = data[ec]['organisms']
    else: orgs_ec = {}
    if 'proteins' in data[ec]: orgs_protein = data[ec]['proteins']
    else: orgs_protein = orgs_ec
    
    metals_ions_now = set()
    if 'metals_ions' in data[ec]:
        for metalion_dict in data[ec]['metals_ions']:
            metals_ions_now.add(metalion_dict['value'])
            metals_ions_list = metals_ions_list.union(metals_ions_now)
    
    cofactors_now = set()
    if 'cofactor' in data[ec]:
        for cof_dict in data[ec]['cofactor']:
            cofactors_now.add(cof_dict['value'])
    # for mapping optimum temperatures by organism
    topt_by_org = {}
    if 'temperature_optimum' in data[ec]:
        topt_data = data[ec]['temperature_optimum']
        for each in topt_data:
            if 'organisms' in each:
                org_topt = each['organisms'][0]
                if 'num_value' in each:
                    topt_val = each['num_value']
                elif 'min_value' in each and 'max_value' in each:
                    topt_val = (each['min_value'] + each['max_value'])/2.0
                else:
                    topt_val = None
                    continue
                    
                if org_topt in topt_by_org:
                    topt_by_org[org_topt].append(topt_val)
                else:
                    topt_by_org[org_topt] = [topt_val]
    
    # for mapping optimum ph by organism
    ph_by_org = {}
    if 'ph_optimum' in data[ec]:
        ph_data = data[ec]['ph_optimum']
        for each in ph_data:
            if 'organisms' in each:
                org_ph = each['organisms'][0]
                if 'num_value' in each:
                    ph_val = each['num_value']
                elif 'min_value' in each and 'max_value' in each:
                    ph_val = (each['min_value'] + each['max_value'])/2.0
                else:
                    ph_val = None
                    continue
                if org_ph in ph_by_org:
                    ph_by_org[org_ph].append(ph_val)
                else:
                    ph_by_org[org_ph] = [ph_val]
    

    # collect all the reactions of this EC grouped by substrates
    sub_to_reactions = {}
    
    def _reaction_string(reacs,prods):
        return f'{" + ".join(reacs)} >> {" + ".join(prods)}'
    
    if 'reaction' in data[ec]: 
        for rxn in data[ec]['reaction']:
            try:
                reacs = rxn['educts']
                prods = rxn['products']
            except KeyError:
                reacs = []
                prods = []
            
            each_rxn_str = _reaction_string(reacs,prods)
            
            for each in reacs:
                if each in sub_to_reactions:
                    sub_to_reactions[each].add(each_rxn_str)
                else:
                    sub_to_reactions[each] = set([each_rxn_str])
                
    # collect any reactant or product from natural_reaction (s) as natural_substrates
    natural_substrates = []
    if 'natural_reaction' in data[ec]: 
        for rxn in data[ec]['natural_reaction']:
            found = False
            try:
                reacs = rxn['educts']
                prods = rxn['products']
            except KeyError:
                reacs = []
                prods = []
                
            each_rxn_str = _reaction_string(reacs,prods)
            natural_substrates.extend(reacs)
            natural_substrates.extend(prods)
            for natural_met in reacs+prods:
                all_natural_metabolite_names.add(natural_met)
            for each in reacs:
                if each in sub_to_reactions:
                    sub_to_reactions[each].add(each_rxn_str)
                else:
                    sub_to_reactions[each] = set([each_rxn_str])
        
    # now collect parameters
    for parameter_data in params_present:
        for entry in data[ec][parameter_data]:
            if 'num_value' in entry and 'value' in entry and 'organisms' in entry:
                val = entry['num_value']
                if 'organisms' in entry:
                    org_now = entry['organisms']
                    prot_now = org_now
                elif 'proteins' in entry:
                    prot_now = entry['proteins']

                subname = entry['value']
                if parameter_data=='turnover_number' and (subname in cofactors_now or subname in metals_ions_now):
                    continue
                if not pd.isna(val) and not pd.isna(subname):
                    try:
                        val = float(val)
                    except ValueError:
                        continue
                    # get orgname if present, skip entry otherwise
                    try:
                        orgname = data[ec]['organisms'][org_now[0]]['value']
                    except KeyError:
                        continue
                    # get uniprot accessions , organism names

                    unis = []
                    orgnames = []

                    for org in prot_now:
                        if org in orgs_protein:
                            for each in orgs_protein[org]:
                                if 'accessions' in each:
                                    unis.append(each['accessions'])
                                else:
                                    unis.append(None)

                    for org in org_now:
                        if org in orgs_ec:
                            if 'value' in orgs_ec[org]: 
                                orgnames.append(orgs_ec[org]['value'])
                            else:
                                orgnames.append(None)

                    orgcol.append(orgnames[0])
                    if org_now[0] in ph_by_org:
                        phopt_col.append(ph_by_org[org_now[0]])
                    else:
                        phopt_col.append([])
                        
                    if org_now[0] in topt_by_org:
                        topt_col.append(topt_by_org[org_now[0]])
                    else:
                        topt_col.append([])
                        
                    unis_ = []
                    for u in unis:
                        if u is None: continue
                        unis_.append(u)

                    if not unis_: unis_ = None

                    unicol.append(unis_)
                    valcol.append(val)
                    paramcol.append(parameter_data)
                    subcol.append(subname)
                    all_metabolite_names.add(subname)
                    if subname in natural_substrates:
                        natural_substrate_col.append(True)
                    else:
                        natural_substrate_col.append(False)
                    eccol.append(ec)
                    rxncol.append(sub_to_reactions)
                    # natrxncol.append(natural_reactions)

                    if 'comment' in entry:
                        commentcol.append(entry['comment'])
                    else:
                        commentcol.append('')
                    
df['value'] = valcol
df['parameter'] = paramcol
df['substrate'] = subcol
df['natural_substrate'] = natural_substrate_col
df['organism'] = orgcol
df['ph_opt'] = phopt_col
df['temp_opt'] = topt_col
df['comment'] = commentcol
df['uniprot'] = unicol
df['ec'] = eccol
df['reactions'] = rxncol

import ipdb
ipdb.set_trace()

f = open('all_natural_metabolite_names.json','w')
f.write(json.dumps(list(all_natural_metabolite_names), indent=True))
f.close()

sys.exit(0)

# Get NCBI Taxonomy parser - to convert organism names into their taxonomic lineages
ncbi = ete3.NCBITaxa()
get_taxid_from_organism = lambda organism: ncbi.get_name_translator([organism])[organism][0]

ec_embed_cols = ["ec1", "ec2", "ec3", "ec"]
tax_embed_cols = [
    "superkingdom",
    "phylum",
    "class",
    "order",
    "family",
    "genus",
    "species",
]

def get_ec_words(ec):
    if '-' in ec: ec.replace('-','UNK')
    ec_chars = ec.split('.')
    ec_words = {f"ec{i}": '.'.join(ec_chars[:i]) for i in range(1,4)}
    ec_words['ec'] = ec
    return ec_words

def get_tax_words(taxid, ncbi):   
    try:
        lineage = ncbi.get_lineage(taxid)
        rank_dict = ncbi.get_rank(lineage)
        rank_dict_return = {}
        for rankid, rankname in rank_dict.items():
            if rankname.lower() in tax_embed_cols: rank_dict_return[rankname.lower()] = ncbi.get_taxid_translator([rankid])[rankid]
    except:
        rank_dict_return = {tax: 'UNK' for tax in tax_embed_cols}
    return rank_dict_return

taxid_col = []
for ind, row in tqdm(df.iterrows()):
    org = row.organism
    try:
        taxid = get_taxid_from_organism(org)
    except KeyError:
        taxid = None
    taxid_col.append(taxid)
df['taxonomy_id'] = taxid_col

ec_words = []
for ind, row in df.iterrows():
    words = get_ec_words(row.ec)
    ec_words.append(words)
for col in ec_embed_cols:
    col_values = [ec_words[i][col] for i in range(len(df))]
    df[col] = col_values

tax_words = []
for ind, row in df.iterrows():
    words = get_tax_words(row.taxonomy_id, ncbi)
    tax_words.append(words)
for col in tax_embed_cols:
    col_values = []
    for i in range(len(df)):
        if col in tax_words[i]:
            col_values.append(tax_words[i][col])
        else:
            col_values.append('UNK')
    df[col] = col_values

# import ipdb
# ipdb.set_trace()

# now SMILES mapping
smiles_col = []
for ind, row in tqdm(df.iterrows()):
    sub = row.substrate
    if not sub in metabolite_inchi_smiles_dic.index: 
        smiles_col.append(None)
    else: 
        smiles_col.append(metabolite_inchi_smiles_dic.loc[sub].smiles)
        
df['substrate_smiles'] = smiles_col

mwcol = []

for smi in tqdm(metabolite_inchi_smiles_dic.smiles):
    mw = None
    if not smi is None: 
        try:
            mol = Chem.MolFromSmiles(smi)
            mw = Descriptors.MolWt(mol)
        except:
            pass
    mwcol.append(mw)
metabolite_inchi_smiles_dic['MW'] = mwcol

def sort_by_second(item): return item[1]

smi_to_mw_dic = {}
for smi, mw in zip(metabolite_inchi_smiles_dic.smiles, metabolite_inchi_smiles_dic.MW):
    smi_to_mw_dic[smi] = mw
    
def sum_mwts(smis):
    mw = 0
    for smi in smis:
        mw+=smi_to_mw_dic[smi]
    return mw

# Assign enzyme type by parsing comments
# Assign everything as wild type first and filter out entries that are 'not possibly' wild-type 
df["enzyme_type"] = np.nan
df.loc[pd.isnull(df["comment"])] = ""
df["enzyme_type"] = "wild type"
df["enzyme_type"][df['comment'].str.contains("mutant")] = "mutant"
df["enzyme_type"][df['comment'].str.contains("mutate")] = "mutant"
df["enzyme_type"][df['comment'].str.contains("chimera")] = "mutant"
df["enzyme_type"][df['comment'].str.contains("inhibitor")] = "inhibition"
df["enzyme_type"][df['comment'].str.contains("inhibition")] = "inhibition"
df["enzyme_type"][df['comment'].str.contains("presence of")] = "regulated"
df["enzyme_type"][df['comment'].str.contains("recombinant")] = "recombinant"
df["enzyme_type"][df['comment'].str.contains("allozyme")] = "allozyme"
df["enzyme_type"][df['comment'].str.contains("alloenzyme")] = "allozyme"
df["enzyme_type"][df['comment'].str.contains("isozyme")] = "isozyme"
df["enzyme_type"][df['comment'].str.contains("isoenzyme")] = "isozyme"
df["enzyme_type"][df['comment'].str.contains("isoform")] = "isozyme"

# some entries still belong to mutants 
# check for X__Y type of comments (eg: W358A)
# these correspond to mutations should be removed
pat = r'[ACDEFGHIKLMNPQRSTVWY][0-9]+[ACDEFGHIKLMNPQRSTVWY]'
mutations_col = []
enztype_col = []
for com,enz_type in zip(df.comment,df.enzyme_type):
    items = re.findall(pattern=pat, string=com)
    if len(items)>0:
        mutations_col.append(';'.join(items))
        enztype_col.append('mutant')
    else:
        mutations_col.append(None)
        enztype_col.append(enz_type)
df['enzyme_type'] = enztype_col
df['mutations'] = mutations_col

# Now assigne ph and temperature first from comments
# then from optimum values for organism, ec
phrow = []
temprow = []
for com,phopt,topt in zip(df.comment,df.ph_opt,df.temp_opt):
    pat = r'[0-9][0-9].C'
    try:
        temp = int(re.findall(pattern=pat, string=com)[0].split('C')[0][:2])
        pat = r'pH [0-9]\.[0-9]'
        ph = float(re.findall(pattern=pat, string=com)[0].split('pH')[-1].strip())
    except:
        if phopt: ph = np.average(phopt)
        else: ph = None
        if topt: temp = np.average(topt)
        else: temp = None
    phrow.append(ph)
    temprow.append(temp)
    
df['ph'] = phrow
df['temperature'] = temprow

# fill in for missing ph, temperature using org,ec groups
orgec_to_topt = {}
orgec_to_phopt = {}
org_to_topt = {}
org_to_phopt = {}
for _, row in df.iterrows():
    org = row.organism
    ec = row.ec
    orgec = org+'__'+ec
    if not orgec in orgec_to_topt:
        orgec_to_topt[orgec] = []
    if not orgec in orgec_to_phopt:
        orgec_to_phopt[orgec] = []
    if not org in org_to_topt:
        org_to_topt[org] = []
    if not org in org_to_phopt:
        org_to_phopt[org] = []
    if not pd.isna(row.temperature): 
        orgec_to_topt[orgec].append(row.temperature)
        org_to_topt[org].append(row.temperature)
    if not pd.isna(row.ph): 
        orgec_to_phopt[orgec].append(row.ph)
        org_to_phopt[org].append(row.ph)

tempcol = []
phcol = []
for org, ec, temp, ph in zip(df.organism, df.ec, df.temperature,df.ph):
    orgec = org+'__'+ec
    if pd.isna(temp):
        if len(orgec_to_topt[orgec])>0:
            temp = np.median(orgec_to_topt[orgec])
        else:
            if len(org_to_topt[org])>0:
                temp = np.median(org_to_topt[org])
            else:
                temp = None
    if pd.isna(ph):
        if len(orgec_to_phopt[orgec])>0:
            ph = np.median(orgec_to_phopt[orgec])
        else:
            if len(org_to_phopt[org])>0:
                ph = np.median(org_to_phopt[org])
            else:
                ph = None
    tempcol.append(temp)
    phcol.append(ph)

df['temperature'] = tempcol
df['ph'] = phcol

def _split_reaction(reaction):
    reacs, prods = reaction.split(" >> ")
    reacs = reacs.split(' + ')
    prods = prods.split(' + ')
    return reacs, prods

rxnsmi_col = []
mwdiff_col = []
mw_col = []
all_rxnsmis = []
for substrate, subsmi, sub_to_reactions in tqdm(zip(df.substrate,
                                                    df.substrate_smiles,
                                                    df.reactions)):
    rxnsmis = []
    for sub, reactions in sub_to_reactions.items():
        try:
            subsminow = metabolite_inchi_smiles_dic.loc[sub].smiles
        except KeyError:
            continue
        if subsminow!=subsmi: 
            continue 
        for reaction in reactions:
            reacs, prods = _split_reaction(reaction)
            reacsmis = []
            prodsmis = []
            for reac in reacs:
                if reac in metabolite_inchi_smiles_dic.index: 
                    reacsmis.append(metabolite_inchi_smiles_dic.loc[reac].smiles)
            for prod in prods:
                if prod in metabolite_inchi_smiles_dic.index: 
                    prodsmis.append(metabolite_inchi_smiles_dic.loc[prod].smiles)
                    
            try:
                reac_mw = sum_mwts(reacsmis)
            except:
                reac_mw = None
                
            try:
                prod_mw = sum_mwts(prodsmis)
            except:
                prod_mw = None

            reacsmis_ = []
            for smi in reacsmis:
                if pd.isna(smi): 
                    continue
                else:
                    reacsmis_.append(smi)
            prodsmis_ = []
            for smi in prodsmis:
                if pd.isna(smi): 
                    continue
                else:
                    prodsmis_.append(smi)
                    
            reaction_smiles = f'{".".join(reacsmis_)}>>{".".join(prodsmis_)}'
            
            if pd.isna(reac_mw) or pd.isna(prod_mw): 
                rxnsmis.append((reaction_smiles,100000,0))
            else:
                rxnsmis.append((reaction_smiles,abs(reac_mw-prod_mw),reac_mw+prod_mw))
    
    rxn_now = None
    mwdiff_now = None
    mw_now = None
    # if something found, add 
    if len(rxnsmis)>0:
        rxnsmis_sorted = sorted(rxnsmis,key=sort_by_second)
        for rxnsmi, mwdiff,mw in rxnsmis_sorted:
            reacside, prodside = rxnsmi.split('>>')
            if subsmi in reacside: 
                rxn_now = rxnsmi
                mwdiff_now = mwdiff
                mw_now = mw
                break
                               
    mwdiff_col.append(mwdiff_now)
    mw_col.append(mw_now)
    rxnsmi_col.append(rxn_now)
    all_rxnsmis.append(rxnsmis)
    
df['reaction_smiles'] = rxnsmi_col
df['reaction_mw_difference'] = mwdiff_col
df['reaction_mw'] = mw_col

unicol = []
for ind, row in tqdm(df.iterrows()):
    if not type(row.uniprot) is list:
        if pd.isna(row.uniprot):
            unicol.append(None)
            continue
    unis = np.array(row.uniprot).flatten()
    try:
        unicol.append(';'.join(unis))
    except TypeError:
        unis_ = []
        for each in unis:
            unis_.extend(each)
        unis_ = np.array(unis_).flatten()
        unicol.append(';'.join(unis_))
            
df['uniprot'] = unicol

seqcol = []
uniset = set()
for uni in df.uniprot:
    if pd.isna(uni): continue
    else: 
        unis = uni.split(';')
        for each in unis:
            uniset.add(each)
            
def _get_sequence(uni): 
    r = requests.get(f'https://rest.uniprot.org/uniprotkb/{uni}.fasta')
    if r.status_code==200:
        lines = r.text.split('\n')
        seq = ''.join(lines[1:])
        return seq
    
outputs = Parallel(n_jobs=30, verbose=5)(delayed(_get_sequence)(uni) for uni in uniset)
uni_to_seq = {}
for uni, seq in zip(uniset, outputs):
    uni_to_seq[uni] = seq
    
seqrow = []
seq_srcrow = []
for ind, row in tqdm(df.iterrows()):
    uni = row.uniprot
    if pd.isna(uni): 
        seqrow.append(None)
        seq_srcrow.append(None)
    else: 
        unis = row.uniprot.split(';')
        seqs = []
        for uni in unis:
            if uni in uni_to_seq: 
                seqs.append(uni_to_seq[uni])
            else: 
                continue
        set_seqs = set(seqs)
        if len(set_seqs)>=1:
            seqrow.append(';'.join(set_seqs))
            seq_srcrow.append('brenda')
        else:
            seqrow.append(None)
            seq_srcrow.append(None)
            
df['sequence'] = seqrow
df['sequence_source'] = seq_srcrow
noseq_pairs = []
for ind, row in df.iterrows():
    if pd.isna(seq) or seq.strip()=='':
        if not pd.isna(tax) and not pd.isna(ec):
            seq = row.sequence
            tax = str(int(row.taxonomy_id))
            ec = row.ec
            noseq_pairs.append(tax+'__'+ec)
            
noseq_pairs = set(noseq_pairs)
noseq_tax_ec = []
for each in noseq_pairs:
    tax, ec = each.split('__')
    noseq_tax_ec.append((tax, ec))
    
def get_url(taxid,ec):
    return f"https://rest.uniprot.org/uniprotkb/stream?fields=accession%2Cid%2Csequence&format=tsv&query=%28%28organism_id%3A{taxid}%29+AND+%28ec%3A{ec}%29%29"

import requests
def fetch_and_process(items):
    ec,tax = items
    url = get_url(ec, tax)
    key = f'{tax}__{ec}.tsv'
    keydir = f'{args.processed_dir}/tax_ec_seqdata/'
    failed = False
    dic = {}
    if os.path.exists(keydir+key): 
         _df = pd.read_csv(keydir+key, sep='\t')
    else:
        r = requests.get(url)
        if r.status_code==200:
            text = r.text
            try:
                f = open(keydir + key, 'w')
                f.write(text)
                f.close()
            except:
                pass
            _df = pd.read_csv(keydir+key, sep='\t')
        else:
            failed = True
    if not failed:
        for entry, seq in zip(_df.Entry, _df.Sequence):
            dic[entry] = seq
        
    return dic
    
noseq_tax_ec = list(noseq_tax_ec)
seq_dicts = Parallel(n_jobs=30, verbose=100)(delayed(fetch_and_process)(items) for items in noseq_tax_ec)

tax_ec_seqs_dict = {}

for (tax,ec), seqs in zip(noseq_tax_ec, seq_dicts):
    tax_ec_seqs_dict[str(tax)+'__'+ec] = seqs
    
f = open(f'{args.processed_dir}/tax_ec_seqs_dict.json','w')
f.write(json.dumps(tax_ec_seqs_dict,indent=True))
f.close()

seqrow = []
srcrow = []
unirow = []
for ind, row in tqdm(df.iterrows()):
    seq = row.sequence
    src = row.sequence_source
    uni = row.uniprot
    if pd.isna(seq) and not pd.isna(row.taxonomy_id):
        tax = str(int(row.taxonomy_id))
        ec = str(row.ec)
        pair = tax+'__'+ec
        if pair in tax_ec_seqs_dict:
            seq_dict = tax_ec_seqs_dict[pair]
        else:
            seq_dict = {}
        if len(seq_dict)>0: 
            unis = []
            seqs = []
            for uni, seq in seq_dict.items():
                unis.append(uni)
                seqs.append(seq)
            seqrow.append(';'.join(seqs))
            unirow.append(';'.join(unis))
            srcrow.append('uniprot_search')
        else: 
            seqrow.append(seq)
            unirow.append(uni)
            srcrow.append('brenda')
    else:
        seqrow.append(seq)
        unirow.append(uni)
        srcrow.append('brenda')

df['uniprot'] = unirow
df['sequence'] = seqrow
df['sequence_source'] = srcrow

nseq_col = []
for ind, row in tqdm(df.iterrows()):
    if pd.isna(row.sequence): 
        nseq_col.append(0)
        seqcol.append(None)
    else:
        seqs = row.sequence.split(';')
        nseq_col.append(len(seqs))
    
df['n_sequence'] = nseq_col
        
df.dropna(subset=['sequence'],inplace=True)
df.reset_index(inplace=True, drop=True)

dfseq1 = df[df.n_sequence==1]
dfseq1.drop(columns=['reactions'],inplace=True)
dfseq1.reset_index(inplace=True, drop=True)
dfseq1.to_csv(f'{args.processed_dir}/brenda_processed_all_singleSeqs.csv')

dfseq1_wt = dfseq1[dfseq1.enzyme_type=='wild type']
dfseq1_wt.reset_index(inplace=True, drop=True)
dfseq1_wt.to_csv(f'{args.processed_dir}/brenda_processed_wt_singleSeqs.csv')

dfseq2 = df[df.n_sequence>=1]
dfseq2 = df[df.n_sequence<=10]
dfseq2.drop(columns=['reactions'],inplace=True)
dfseq2.reset_index(inplace=True, drop=True)
dfseq2.to_csv(f'{args.processed_dir}/brenda_processed_all_multipleSeqs.csv')

dfseq2_wt = dfseq2[dfseq2.enzyme_type=='wild type']
dfseq2_wt.reset_index(inplace=True, drop=True)
dfseq2_wt.to_csv(f'{args.processed_dir}/brenda_processed_wt_multipleSeqs.csv')

	import os
	import json
	import time
	import pandas as pd
	import numpy as np
	import requests
	import ete3
	import re
	import rdkit
	from tqdm import tqdm
	from rdkit import Chem
	from rdkit.Chem import AllChem
	from rdkit import DataStructs
	from rdkit.Chem import rdChemReactions
	from joblib import delayed, Parallel
	from rdkit.Chem import Descriptors
	from rdkit import RDLogger
	RDLogger.DisableLog('rdApp.*')

	import requests
	import sys
	import argparse

	def parse_args():
	parser = argparse.ArgumentParser()
	parser.add_argument("--rawdata_dir", help="raw data directory", type=str, required=True)
	parser.add_argument("--processed_dir", help="processed dir to save",
	type=str, required=True)
	parser.add_argument("--out_file_name", help="name for out file",
	type=str, required=True)

	args, unparsed = parser.parse_known_args()
	parser = argparse.ArgumentParser()

	return args

	args = parse_args()
	PARAMETERS_OF_INTEREST = ['km_value','kcat_km','ki_value','ic50','turnover_number']
	EC_WORD_NAMES = ["ec1", "ec2", "ec3", "ec"]
	TAX_WORD_NAMES = [
	"superkingdom",
	"phylum",
	"class",
	"order",
	"family",
	"genus",
	"species"]
	INCLUDE_OTHERS_AS_WILDTYPE = True
	N_PROCS = 30

	DATA_DIR = args.rawdata_dir
	out_path = args.processed_dir + '/'+ args.out_file_name

	# Load BRENDA raw data
	# Downloaded from https://www.brenda-enzymes.org/download.php
	data = json.load(open(f'{DATA_DIR}/brenda_2022_2.json'))['data']

	## Ligand data
	# Go to https://www.brenda-enzymes.org/search_result.php?a=13 and place a blank query to get all ligands and their InChi strings
	# Downloaded and pre-processed this along with missing metabolites using PubChem id-exchange service
	# https://pubchem.ncbi.nlm.nih.gov/idexchange/idexchange.cgi

	metabolite_inchi_smiles_dic = pd.read_csv(f'{DATA_DIR}/metabolite_inchi_smiles_brenda_pubchem.tsv',sep='\t',
	index_col='metabolite')

	# Create an empty dataframe and columns
	df = pd.DataFrame()

	# storing ec numbers
	eccol = []
	# storing organism names
	orgcol = []

	# storing parameter type (like turnover_number, km_value etc.)
	paramcol = []
	# storing parameter values (like km,ki etc.)
	valcol = []

	# storing reactions (reactants, products)
	rxncol = []

	# storing substrates
	subcol = []

	# storing if the substrate is from a natural reaction or not
	natural_substrate_col = []

	# storing uniprots wherever available
	unicol = []

	# storing comment strings
	commentcol = []

	# storing ph optimum & temperature optimum
	phopt_col = []
	topt_col = []

	# all
	all_metabolite_names = set()
	all_natural_metabolite_names = set()

	#metals and ions list
	metals_ions_list = set()

	for ec in tqdm(data):
	if not ('proteins' in data[ec] or 'organisms' in data[ec]):
	# this means we cannot featurize entries from this ec, so skip it
	continue

	# not all entries for an ec number have all params
	# see which among the parameters of interest are present
	params_present = []
	for parameter_data in PARAMETERS_OF_INTEREST:
	if parameter_data in data[ec]: params_present.append(parameter_data)

	# for mapping organisms
	if 'organisms' in data[ec]: orgs_ec = data[ec]['organisms']
	else: orgs_ec = {}
	if 'proteins' in data[ec]: orgs_protein = data[ec]['proteins']
	else: orgs_protein = orgs_ec

	metals_ions_now = set()
	if 'metals_ions' in data[ec]:
	for metalion_dict in data[ec]['metals_ions']:
	metals_ions_now.add(metalion_dict['value'])
	metals_ions_list = metals_ions_list.union(metals_ions_now)

	cofactors_now = set()
	if 'cofactor' in data[ec]:
	for cof_dict in data[ec]['cofactor']:
	cofactors_now.add(cof_dict['value'])
	# for mapping optimum temperatures by organism
	topt_by_org = {}
	if 'temperature_optimum' in data[ec]:
	topt_data = data[ec]['temperature_optimum']
	for each in topt_data:
	if 'organisms' in each:
	org_topt = each['organisms'][0]
	if 'num_value' in each:
	topt_val = each['num_value']
	elif 'min_value' in each and 'max_value' in each:
	topt_val = (each['min_value'] + each['max_value'])/2.0
	else:
	topt_val = None
	continue

	if org_topt in topt_by_org:
	topt_by_org[org_topt].append(topt_val)
	else:
	topt_by_org[org_topt] = [topt_val]

	# for mapping optimum ph by organism
	ph_by_org = {}
	if 'ph_optimum' in data[ec]:
	ph_data = data[ec]['ph_optimum']
	for each in ph_data:
	if 'organisms' in each:
	org_ph = each['organisms'][0]
	if 'num_value' in each:
	ph_val = each['num_value']
	elif 'min_value' in each and 'max_value' in each:
	ph_val = (each['min_value'] + each['max_value'])/2.0
	else:
	ph_val = None
	continue
	if org_ph in ph_by_org:
	ph_by_org[org_ph].append(ph_val)
	else:
	ph_by_org[org_ph] = [ph_val]


	# collect all the reactions of this EC grouped by substrates
	sub_to_reactions = {}

	def _reaction_string(reacs,prods):
	return f'{" + ".join(reacs)} >> {" + ".join(prods)}'

	if 'reaction' in data[ec]:
	for rxn in data[ec]['reaction']:
	try:
	reacs = rxn['educts']
	prods = rxn['products']
	except KeyError:
	reacs = []
	prods = []

	each_rxn_str = _reaction_string(reacs,prods)

	for each in reacs:
	if each in sub_to_reactions:
	sub_to_reactions[each].add(each_rxn_str)
	else:
	sub_to_reactions[each] = set([each_rxn_str])

	# collect any reactant or product from natural_reaction (s) as natural_substrates
	natural_substrates = []
	if 'natural_reaction' in data[ec]:
	for rxn in data[ec]['natural_reaction']:
	found = False
	try:
	reacs = rxn['educts']
	prods = rxn['products']
	except KeyError:
	reacs = []
	prods = []

	each_rxn_str = _reaction_string(reacs,prods)
	natural_substrates.extend(reacs)
	natural_substrates.extend(prods)
	for natural_met in reacs+prods:
	all_natural_metabolite_names.add(natural_met)
	for each in reacs:
	if each in sub_to_reactions:
	sub_to_reactions[each].add(each_rxn_str)
	else:
	sub_to_reactions[each] = set([each_rxn_str])

	# now collect parameters
	for parameter_data in params_present:
	for entry in data[ec][parameter_data]:
	if 'num_value' in entry and 'value' in entry and 'organisms' in entry:
	val = entry['num_value']
	if 'organisms' in entry:
	org_now = entry['organisms']
	prot_now = org_now
	elif 'proteins' in entry:
	prot_now = entry['proteins']

	subname = entry['value']
	if parameter_data=='turnover_number' and (subname in cofactors_now or subname in metals_ions_now):
	continue
	if not pd.isna(val) and not pd.isna(subname):
	try:
	val = float(val)
	except ValueError:
	continue
	# get orgname if present, skip entry otherwise
	try:
	orgname = data[ec]['organisms'][org_now[0]]['value']
	except KeyError:
	continue
	# get uniprot accessions , organism names

	unis = []
	orgnames = []

	for org in prot_now:
	if org in orgs_protein:
	for each in orgs_protein[org]:
	if 'accessions' in each:
	unis.append(each['accessions'])
	else:
	unis.append(None)

	for org in org_now:
	if org in orgs_ec:
	if 'value' in orgs_ec[org]:
	orgnames.append(orgs_ec[org]['value'])
	else:
	orgnames.append(None)

	orgcol.append(orgnames[0])
	if org_now[0] in ph_by_org:
	phopt_col.append(ph_by_org[org_now[0]])
	else:
	phopt_col.append([])

	if org_now[0] in topt_by_org:
	topt_col.append(topt_by_org[org_now[0]])
	else:
	topt_col.append([])

	unis_ = []
	for u in unis:
	if u is None: continue
	unis_.append(u)

	if not unis_: unis_ = None

	unicol.append(unis_)
	valcol.append(val)
	paramcol.append(parameter_data)
	subcol.append(subname)
	all_metabolite_names.add(subname)
	if subname in natural_substrates:
	natural_substrate_col.append(True)
	else:
	natural_substrate_col.append(False)
	eccol.append(ec)
	rxncol.append(sub_to_reactions)
	# natrxncol.append(natural_reactions)

	if 'comment' in entry:
	commentcol.append(entry['comment'])
	else:
	commentcol.append('')

	df['value'] = valcol
	df['parameter'] = paramcol
	df['substrate'] = subcol
	df['natural_substrate'] = natural_substrate_col
	df['organism'] = orgcol
	df['ph_opt'] = phopt_col
	df['temp_opt'] = topt_col
	df['comment'] = commentcol
	df['uniprot'] = unicol
	df['ec'] = eccol
	df['reactions'] = rxncol

	import ipdb
	ipdb.set_trace()

	f = open('all_natural_metabolite_names.json','w')
	f.write(json.dumps(list(all_natural_metabolite_names), indent=True))
	f.close()

	sys.exit(0)

	# Get NCBI Taxonomy parser - to convert organism names into their taxonomic lineages
	ncbi = ete3.NCBITaxa()
	get_taxid_from_organism = lambda organism: ncbi.get_name_translator([organism])[organism][0]

	ec_embed_cols = ["ec1", "ec2", "ec3", "ec"]
	tax_embed_cols = [
	"superkingdom",
	"phylum",
	"class",
	"order",
	"family",
	"genus",
	"species",
	]

	def get_ec_words(ec):
	if '-' in ec: ec.replace('-','UNK')
	ec_chars = ec.split('.')
	ec_words = {f"ec{i}": '.'.join(ec_chars[:i]) for i in range(1,4)}
	ec_words['ec'] = ec
	return ec_words

	def get_tax_words(taxid, ncbi):
	try:
	lineage = ncbi.get_lineage(taxid)
	rank_dict = ncbi.get_rank(lineage)
	rank_dict_return = {}
	for rankid, rankname in rank_dict.items():
	if rankname.lower() in tax_embed_cols: rank_dict_return[rankname.lower()] = ncbi.get_taxid_translator([rankid])[rankid]
	except:
	rank_dict_return = {tax: 'UNK' for tax in tax_embed_cols}
	return rank_dict_return

	taxid_col = []
	for ind, row in tqdm(df.iterrows()):
	org = row.organism
	try:
	taxid = get_taxid_from_organism(org)
	except KeyError:
	taxid = None
	taxid_col.append(taxid)
	df['taxonomy_id'] = taxid_col

	ec_words = []
	for ind, row in df.iterrows():
	words = get_ec_words(row.ec)
	ec_words.append(words)
	for col in ec_embed_cols:
	col_values = [ec_words[i][col] for i in range(len(df))]
	df[col] = col_values

	tax_words = []
	for ind, row in df.iterrows():
	words = get_tax_words(row.taxonomy_id, ncbi)
	tax_words.append(words)
	for col in tax_embed_cols:
	col_values = []
	for i in range(len(df)):
	if col in tax_words[i]:
	col_values.append(tax_words[i][col])
	else:
	col_values.append('UNK')
	df[col] = col_values

	# import ipdb
	# ipdb.set_trace()

	# now SMILES mapping
	smiles_col = []
	for ind, row in tqdm(df.iterrows()):
	sub = row.substrate
	if not sub in metabolite_inchi_smiles_dic.index:
	smiles_col.append(None)
	else:
	smiles_col.append(metabolite_inchi_smiles_dic.loc[sub].smiles)

	df['substrate_smiles'] = smiles_col

	mwcol = []

	for smi in tqdm(metabolite_inchi_smiles_dic.smiles):
	mw = None
	if not smi is None:
	try:
	mol = Chem.MolFromSmiles(smi)
	mw = Descriptors.MolWt(mol)
	except:
	pass
	mwcol.append(mw)
	metabolite_inchi_smiles_dic['MW'] = mwcol

	def sort_by_second(item): return item[1]

	smi_to_mw_dic = {}
	for smi, mw in zip(metabolite_inchi_smiles_dic.smiles, metabolite_inchi_smiles_dic.MW):
	smi_to_mw_dic[smi] = mw

	def sum_mwts(smis):
	mw = 0
	for smi in smis:
	mw+=smi_to_mw_dic[smi]
	return mw

	# Assign enzyme type by parsing comments
	# Assign everything as wild type first and filter out entries that are 'not possibly' wild-type
	df["enzyme_type"] = np.nan
	df.loc[pd.isnull(df["comment"])] = ""
	df["enzyme_type"] = "wild type"
	df["enzyme_type"][df['comment'].str.contains("mutant")] = "mutant"
	df["enzyme_type"][df['comment'].str.contains("mutate")] = "mutant"
	df["enzyme_type"][df['comment'].str.contains("chimera")] = "mutant"
	df["enzyme_type"][df['comment'].str.contains("inhibitor")] = "inhibition"
	df["enzyme_type"][df['comment'].str.contains("inhibition")] = "inhibition"
	df["enzyme_type"][df['comment'].str.contains("presence of")] = "regulated"
	df["enzyme_type"][df['comment'].str.contains("recombinant")] = "recombinant"
	df["enzyme_type"][df['comment'].str.contains("allozyme")] = "allozyme"
	df["enzyme_type"][df['comment'].str.contains("alloenzyme")] = "allozyme"
	df["enzyme_type"][df['comment'].str.contains("isozyme")] = "isozyme"
	df["enzyme_type"][df['comment'].str.contains("isoenzyme")] = "isozyme"
	df["enzyme_type"][df['comment'].str.contains("isoform")] = "isozyme"

	# some entries still belong to mutants
	# check for X__Y type of comments (eg: W358A)
	# these correspond to mutations should be removed
	pat = r'[ACDEFGHIKLMNPQRSTVWY][0-9]+[ACDEFGHIKLMNPQRSTVWY]'
	mutations_col = []
	enztype_col = []
	for com,enz_type in zip(df.comment,df.enzyme_type):
	items = re.findall(pattern=pat, string=com)
	if len(items)>0:
	mutations_col.append(';'.join(items))
	enztype_col.append('mutant')
	else:
	mutations_col.append(None)
	enztype_col.append(enz_type)
	df['enzyme_type'] = enztype_col
	df['mutations'] = mutations_col

	# Now assigne ph and temperature first from comments
	# then from optimum values for organism, ec
	phrow = []
	temprow = []
	for com,phopt,topt in zip(df.comment,df.ph_opt,df.temp_opt):
	pat = r'[0-9][0-9].C'
	try:
	temp = int(re.findall(pattern=pat, string=com)[0].split('C')[0][:2])
	pat = r'pH [0-9]\.[0-9]'
	ph = float(re.findall(pattern=pat, string=com)[0].split('pH')[-1].strip())
	except:
	if phopt: ph = np.average(phopt)
	else: ph = None
	if topt: temp = np.average(topt)
	else: temp = None
	phrow.append(ph)
	temprow.append(temp)

	df['ph'] = phrow
	df['temperature'] = temprow

	# fill in for missing ph, temperature using org,ec groups
	orgec_to_topt = {}
	orgec_to_phopt = {}
	org_to_topt = {}
	org_to_phopt = {}
	for _, row in df.iterrows():
	org = row.organism
	ec = row.ec
	orgec = org+'__'+ec
	if not orgec in orgec_to_topt:
	orgec_to_topt[orgec] = []
	if not orgec in orgec_to_phopt:
	orgec_to_phopt[orgec] = []
	if not org in org_to_topt:
	org_to_topt[org] = []
	if not org in org_to_phopt:
	org_to_phopt[org] = []
	if not pd.isna(row.temperature):
	orgec_to_topt[orgec].append(row.temperature)
	org_to_topt[org].append(row.temperature)
	if not pd.isna(row.ph):
	orgec_to_phopt[orgec].append(row.ph)
	org_to_phopt[org].append(row.ph)

	tempcol = []
	phcol = []
	for org, ec, temp, ph in zip(df.organism, df.ec, df.temperature,df.ph):
	orgec = org+'__'+ec
	if pd.isna(temp):
	if len(orgec_to_topt[orgec])>0:
	temp = np.median(orgec_to_topt[orgec])
	else:
	if len(org_to_topt[org])>0:
	temp = np.median(org_to_topt[org])
	else:
	temp = None
	if pd.isna(ph):
	if len(orgec_to_phopt[orgec])>0:
	ph = np.median(orgec_to_phopt[orgec])
	else:
	if len(org_to_phopt[org])>0:
	ph = np.median(org_to_phopt[org])
	else:
	ph = None
	tempcol.append(temp)
	phcol.append(ph)

	df['temperature'] = tempcol
	df['ph'] = phcol

	def _split_reaction(reaction):
	reacs, prods = reaction.split(" >> ")
	reacs = reacs.split(' + ')
	prods = prods.split(' + ')
	return reacs, prods

	rxnsmi_col = []
	mwdiff_col = []
	mw_col = []
	all_rxnsmis = []
	for substrate, subsmi, sub_to_reactions in tqdm(zip(df.substrate,
	df.substrate_smiles,
	df.reactions)):
	rxnsmis = []
	for sub, reactions in sub_to_reactions.items():
	try:
	subsminow = metabolite_inchi_smiles_dic.loc[sub].smiles
	except KeyError:
	continue
	if subsminow!=subsmi:
	continue
	for reaction in reactions:
	reacs, prods = _split_reaction(reaction)
	reacsmis = []
	prodsmis = []
	for reac in reacs:
	if reac in metabolite_inchi_smiles_dic.index:
	reacsmis.append(metabolite_inchi_smiles_dic.loc[reac].smiles)
	for prod in prods:
	if prod in metabolite_inchi_smiles_dic.index:
	prodsmis.append(metabolite_inchi_smiles_dic.loc[prod].smiles)

	try:
	reac_mw = sum_mwts(reacsmis)
	except:
	reac_mw = None

	try:
	prod_mw = sum_mwts(prodsmis)
	except:
	prod_mw = None

	reacsmis_ = []
	for smi in reacsmis:
	if pd.isna(smi):
	continue
	else:
	reacsmis_.append(smi)
	prodsmis_ = []
	for smi in prodsmis:
	if pd.isna(smi):
	continue
	else:
	prodsmis_.append(smi)

	reaction_smiles = f'{".".join(reacsmis_)}>>{".".join(prodsmis_)}'

	if pd.isna(reac_mw) or pd.isna(prod_mw):
	rxnsmis.append((reaction_smiles,100000,0))
	else:
	rxnsmis.append((reaction_smiles,abs(reac_mw-prod_mw),reac_mw+prod_mw))

	rxn_now = None
	mwdiff_now = None
	mw_now = None
	# if something found, add
	if len(rxnsmis)>0:
	rxnsmis_sorted = sorted(rxnsmis,key=sort_by_second)
	for rxnsmi, mwdiff,mw in rxnsmis_sorted:
	reacside, prodside = rxnsmi.split('>>')
	if subsmi in reacside:
	rxn_now = rxnsmi
	mwdiff_now = mwdiff
	mw_now = mw
	break

	mwdiff_col.append(mwdiff_now)
	mw_col.append(mw_now)
	rxnsmi_col.append(rxn_now)
	all_rxnsmis.append(rxnsmis)

	df['reaction_smiles'] = rxnsmi_col
	df['reaction_mw_difference'] = mwdiff_col
	df['reaction_mw'] = mw_col

	unicol = []
	for ind, row in tqdm(df.iterrows()):
	if not type(row.uniprot) is list:
	if pd.isna(row.uniprot):
	unicol.append(None)
	continue
	unis = np.array(row.uniprot).flatten()
	try:
	unicol.append(';'.join(unis))
	except TypeError:
	unis_ = []
	for each in unis:
	unis_.extend(each)
	unis_ = np.array(unis_).flatten()
	unicol.append(';'.join(unis_))

	df['uniprot'] = unicol

	seqcol = []
	uniset = set()
	for uni in df.uniprot:
	if pd.isna(uni): continue
	else:
	unis = uni.split(';')
	for each in unis:
	uniset.add(each)

	def _get_sequence(uni):
	r = requests.get(f'https://rest.uniprot.org/uniprotkb/{uni}.fasta')
	if r.status_code==200:
	lines = r.text.split('\n')
	seq = ''.join(lines[1:])
	return seq

	outputs = Parallel(n_jobs=30, verbose=5)(delayed(_get_sequence)(uni) for uni in uniset)
	uni_to_seq = {}
	for uni, seq in zip(uniset, outputs):
	uni_to_seq[uni] = seq

	seqrow = []
	seq_srcrow = []
	for ind, row in tqdm(df.iterrows()):
	uni = row.uniprot
	if pd.isna(uni):
	seqrow.append(None)
	seq_srcrow.append(None)
	else:
	unis = row.uniprot.split(';')
	seqs = []
	for uni in unis:
	if uni in uni_to_seq:
	seqs.append(uni_to_seq[uni])
	else:
	continue
	set_seqs = set(seqs)
	if len(set_seqs)>=1:
	seqrow.append(';'.join(set_seqs))
	seq_srcrow.append('brenda')
	else:
	seqrow.append(None)
	seq_srcrow.append(None)

	df['sequence'] = seqrow
	df['sequence_source'] = seq_srcrow
	noseq_pairs = []
	for ind, row in df.iterrows():
	if pd.isna(seq) or seq.strip()=='':
	if not pd.isna(tax) and not pd.isna(ec):
	seq = row.sequence
	tax = str(int(row.taxonomy_id))
	ec = row.ec
	noseq_pairs.append(tax+'__'+ec)

	noseq_pairs = set(noseq_pairs)
	noseq_tax_ec = []
	for each in noseq_pairs:
	tax, ec = each.split('__')
	noseq_tax_ec.append((tax, ec))

	def get_url(taxid,ec):
	return f"https://rest.uniprot.org/uniprotkb/stream?fields=accession%2Cid%2Csequence&format=tsv&query=%28%28organism_id%3A{taxid}%29+AND+%28ec%3A{ec}%29%29"

	import requests
	def fetch_and_process(items):
	ec,tax = items
	url = get_url(ec, tax)
	key = f'{tax}__{ec}.tsv'
	keydir = f'{args.processed_dir}/tax_ec_seqdata/'
	failed = False
	dic = {}
	if os.path.exists(keydir+key):
	_df = pd.read_csv(keydir+key, sep='\t')
	else:
	r = requests.get(url)
	if r.status_code==200:
	text = r.text
	try:
	f = open(keydir + key, 'w')
	f.write(text)
	f.close()
	except:
	pass
	_df = pd.read_csv(keydir+key, sep='\t')
	else:
	failed = True
	if not failed:
	for entry, seq in zip(_df.Entry, _df.Sequence):
	dic[entry] = seq

	return dic

	noseq_tax_ec = list(noseq_tax_ec)
	seq_dicts = Parallel(n_jobs=30, verbose=100)(delayed(fetch_and_process)(items) for items in noseq_tax_ec)

	tax_ec_seqs_dict = {}

	for (tax,ec), seqs in zip(noseq_tax_ec, seq_dicts):
	tax_ec_seqs_dict[str(tax)+'__'+ec] = seqs

	f = open(f'{args.processed_dir}/tax_ec_seqs_dict.json','w')
	f.write(json.dumps(tax_ec_seqs_dict,indent=True))
	f.close()

	seqrow = []
	srcrow = []
	unirow = []
	for ind, row in tqdm(df.iterrows()):
	seq = row.sequence
	src = row.sequence_source
	uni = row.uniprot
	if pd.isna(seq) and not pd.isna(row.taxonomy_id):
	tax = str(int(row.taxonomy_id))
	ec = str(row.ec)
	pair = tax+'__'+ec
	if pair in tax_ec_seqs_dict:
	seq_dict = tax_ec_seqs_dict[pair]
	else:
	seq_dict = {}
	if len(seq_dict)>0:
	unis = []
	seqs = []
	for uni, seq in seq_dict.items():
	unis.append(uni)
	seqs.append(seq)
	seqrow.append(';'.join(seqs))
	unirow.append(';'.join(unis))
	srcrow.append('uniprot_search')
	else:
	seqrow.append(seq)
	unirow.append(uni)
	srcrow.append('brenda')
	else:
	seqrow.append(seq)
	unirow.append(uni)
	srcrow.append('brenda')

	df['uniprot'] = unirow
	df['sequence'] = seqrow
	df['sequence_source'] = srcrow

	nseq_col = []
	for ind, row in tqdm(df.iterrows()):
	if pd.isna(row.sequence):
	nseq_col.append(0)
	seqcol.append(None)
	else:
	seqs = row.sequence.split(';')
	nseq_col.append(len(seqs))

	df['n_sequence'] = nseq_col

	df.dropna(subset=['sequence'],inplace=True)
	df.reset_index(inplace=True, drop=True)

	dfseq1 = df[df.n_sequence==1]
	dfseq1.drop(columns=['reactions'],inplace=True)
	dfseq1.reset_index(inplace=True, drop=True)
	dfseq1.to_csv(f'{args.processed_dir}/brenda_processed_all_singleSeqs.csv')

	dfseq1_wt = dfseq1[dfseq1.enzyme_type=='wild type']
	dfseq1_wt.reset_index(inplace=True, drop=True)
	dfseq1_wt.to_csv(f'{args.processed_dir}/brenda_processed_wt_singleSeqs.csv')

	dfseq2 = df[df.n_sequence>=1]
	dfseq2 = df[df.n_sequence<=10]
	dfseq2.drop(columns=['reactions'],inplace=True)
	dfseq2.reset_index(inplace=True, drop=True)
	dfseq2.to_csv(f'{args.processed_dir}/brenda_processed_all_multipleSeqs.csv')

	dfseq2_wt = dfseq2[dfseq2.enzyme_type=='wild type']
	dfseq2_wt.reset_index(inplace=True, drop=True)
	dfseq2_wt.to_csv(f'{args.processed_dir}/brenda_processed_wt_multipleSeqs.csv')