retrieve_bulk_database.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-08-11 14:12:53.224 INFO    rdkit: Enabling RDKit 2020.09.1 jupyter extensions\n"
     ]
    }
   ],
   "source": [
    "import streamlit as st\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import re\n",
    "from PIL import Image\n",
    "import webbrowser\n",
    "import json\n",
    "import pickle\n",
    "import sys \n",
    "import joblib\n",
    "from tqdm import tqdm \n",
    "\n",
    "sys.path.append('./CC/')\n",
    "\n",
    "import chemaxon\n",
    "from chemaxon import *\n",
    "from compound import Compound\n",
    "from compound_cacher import CompoundCacher\n",
    "from rdkit.Chem import rdChemReactions as Reactions\n",
    "from rdkit.Chem import Draw\n",
    "from rdkit import Chem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_smiles():\n",
    "    db = pd.read_csv('./data/cache_compounds_20160818.csv',\n",
    "                     index_col='compound_id')\n",
    "    db_smiles = db['smiles_pH7'].to_dict()\n",
    "    return db_smiles\n",
    "\n",
    "def load_molsig_rad1():\n",
    "    molecular_signature_r1 = json.load(open('./data/decompose_vector_ac.json'))\n",
    "    return molecular_signature_r1\n",
    "\n",
    "\n",
    "def load_molsig_rad2():\n",
    "    molecular_signature_r2 = json.load(\n",
    "        open('./data/decompose_vector_ac_r2_py3_indent_modified_manual.json'))\n",
    "    return molecular_signature_r2\n",
    "\n",
    "\n",
    "def load_model():\n",
    "    filename = './model/M12_model_BR.pkl'\n",
    "    loaded_model = joblib.load(open(filename, 'rb'))\n",
    "    return loaded_model\n",
    "\n",
    "\n",
    "def load_compound_cache():\n",
    "    ccache = CompoundCacher()\n",
    "    return ccache\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def count_substructures(radius, molecule):\n",
    "    \"\"\"Helper function for get the information of molecular signature of a\n",
    "    metabolite. The relaxed signature requires the number of each substructure\n",
    "    to construct a matrix for each molecule.\n",
    "    Parameters\n",
    "    ----------\n",
    "    radius : int\n",
    "        the radius is bond-distance that defines how many neighbor atoms should\n",
    "        be considered in a reaction center.\n",
    "    molecule : Molecule\n",
    "        a molecule object create by RDkit (e.g. Chem.MolFromInchi(inchi_code)\n",
    "        or Chem.MolToSmiles(smiles_code))\n",
    "    Returns\n",
    "    -------\n",
    "    dict\n",
    "        dictionary of molecular signature for a molecule,\n",
    "        {smiles: molecular_signature}\n",
    "    \"\"\"\n",
    "    m = molecule\n",
    "    smi_count = dict()\n",
    "    atomList = [atom for atom in m.GetAtoms()]\n",
    "\n",
    "    for i in range(len(atomList)):\n",
    "        env = Chem.FindAtomEnvironmentOfRadiusN(m, radius, i)\n",
    "        atoms = set()\n",
    "        for bidx in env:\n",
    "            atoms.add(m.GetBondWithIdx(bidx).GetBeginAtomIdx())\n",
    "            atoms.add(m.GetBondWithIdx(bidx).GetEndAtomIdx())\n",
    "\n",
    "        # only one atom is in this environment, such as O in H2O\n",
    "        if len(atoms) == 0:\n",
    "            atoms = {i}\n",
    "\n",
    "        smi = Chem.MolFragmentToSmiles(m, atomsToUse=list(atoms),\n",
    "                                       bondsToUse=env, canonical=True)\n",
    "\n",
    "        if smi in smi_count:\n",
    "            smi_count[smi] = smi_count[smi] + 1\n",
    "        else:\n",
    "            smi_count[smi] = 1\n",
    "    return smi_count\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def decompse_novel_mets_rad1(novel_smiles, radius=1):\n",
    "    decompose_vector = dict()\n",
    "\n",
    "    for cid, smiles_pH7 in novel_smiles.items():\n",
    "        mol = Chem.MolFromSmiles(smiles_pH7)\n",
    "        mol = Chem.RemoveHs(mol)\n",
    "        # Chem.RemoveStereochemistry(mol)\n",
    "        smi_count = count_substructures(radius, mol)\n",
    "        decompose_vector[cid] = smi_count\n",
    "    return decompose_vector\n",
    "\n",
    "\n",
    "def decompse_novel_mets_rad2(novel_smiles, radius=2):\n",
    "    decompose_vector = dict()\n",
    "\n",
    "    for cid, smiles_pH7 in novel_smiles.items():\n",
    "        mol = Chem.MolFromSmiles(smiles_pH7)\n",
    "        mol = Chem.RemoveHs(mol)\n",
    "        # Chem.RemoveStereochemistry(mol)\n",
    "        smi_count = count_substructures(radius, mol)\n",
    "        decompose_vector[cid] = smi_count\n",
    "    return decompose_vector\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_reaction_formula_side(s):\n",
    "    \"\"\"\n",
    "        Parses the side formula, e.g. '2 C00001 + C00002 + 3 C00003'\n",
    "        Ignores stoichiometry.\n",
    "\n",
    "        Returns:\n",
    "            The set of CIDs.\n",
    "    \"\"\"\n",
    "    if s.strip() == \"null\":\n",
    "        return {}\n",
    "\n",
    "    compound_bag = {}\n",
    "    for member in re.split('\\s+\\+\\s+', s):\n",
    "        tokens = member.split(None, 1)\n",
    "        if len(tokens) == 0:\n",
    "            continue\n",
    "        if len(tokens) == 1:\n",
    "            amount = 1\n",
    "            key = member\n",
    "        else:\n",
    "            amount = float(tokens[0])\n",
    "            key = tokens[1]\n",
    "\n",
    "        compound_bag[key] = compound_bag.get(key, 0) + amount\n",
    "\n",
    "    return compound_bag\n",
    "\n",
    "\n",
    "def parse_formula(formula, arrow='<=>', rid=None):\n",
    "    \"\"\"\n",
    "        Parses a two-sided formula such as: 2 C00001 => C00002 + C00003\n",
    "\n",
    "        Return:\n",
    "            The set of substrates, products and the direction of the reaction\n",
    "    \"\"\"\n",
    "    tokens = formula.split(arrow)\n",
    "    if len(tokens) < 2:\n",
    "        print(('Reaction does not contain the arrow sign (%s): %s'\n",
    "               % (arrow, formula)))\n",
    "    if len(tokens) > 2:\n",
    "        print(('Reaction contains more than one arrow sign (%s): %s'\n",
    "               % (arrow, formula)))\n",
    "\n",
    "    left = tokens[0].strip()\n",
    "    right = tokens[1].strip()\n",
    "\n",
    "    sparse_reaction = {}\n",
    "    for cid, count in parse_reaction_formula_side(left).items():\n",
    "        sparse_reaction[cid] = sparse_reaction.get(cid, 0) - count\n",
    "\n",
    "    for cid, count in parse_reaction_formula_side(right).items():\n",
    "        sparse_reaction[cid] = sparse_reaction.get(cid, 0) + count\n",
    "\n",
    "    return sparse_reaction\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def draw_rxn_figure(rxn_dict, db_smiles, novel_smiles):\n",
    "    # db_smiles = load_smiles()\n",
    "\n",
    "    left = ''\n",
    "    right = ''\n",
    "\n",
    "    for met, stoic in rxn_dict.items():\n",
    "        if met == \"C00080\" or met == \"C00282\":\n",
    "            continue  # hydogen is not considered\n",
    "        if stoic > 0:\n",
    "            if met in db_smiles:\n",
    "                right = right + db_smiles[met] + '.'\n",
    "            else:\n",
    "                right = right + novel_smiles[met] + '.'\n",
    "        else:\n",
    "            if met in db_smiles:\n",
    "                left = left + db_smiles[met] + '.'\n",
    "            else:\n",
    "                left = left + novel_smiles[met] + '.'\n",
    "    smarts = left[:-1] + '>>' + right[:-1]\n",
    "    # print smarts\n",
    "    smarts = str(smarts)\n",
    "    rxn = Reactions.ReactionFromSmarts(smarts, useSmiles=True)\n",
    "    return Draw.ReactionToImage(rxn)  # , subImgSize=(400, 400))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_rule(rxn_dict, molsig1, molsig2, novel_decomposed1, novel_decomposed2):\n",
    "    if novel_decomposed1 != None:\n",
    "        for cid in novel_decomposed1:\n",
    "            molsig1[cid] = novel_decomposed1[cid]\n",
    "    if novel_decomposed2 != None:\n",
    "        for cid in novel_decomposed2:\n",
    "            molsig2[cid] = novel_decomposed2[cid]\n",
    "\n",
    "    molsigna_df1 = pd.DataFrame.from_dict(molsig1).fillna(0)\n",
    "    all_mets1 = molsigna_df1.columns.tolist()\n",
    "    all_mets1.append(\"C00080\")\n",
    "    all_mets1.append(\"C00282\")\n",
    "\n",
    "    molsigna_df2 = pd.DataFrame.from_dict(molsig2).fillna(0)\n",
    "    all_mets2 = molsigna_df2.columns.tolist()\n",
    "    all_mets2.append(\"C00080\")\n",
    "    all_mets2.append(\"C00282\")\n",
    "\n",
    "    moieties_r1 = open('./data/group_names_r1.txt')\n",
    "    moieties_r2 = open('./data/group_names_r2_py3_modified_manual.txt')\n",
    "    moie_r1 = moieties_r1.read().splitlines()\n",
    "    moie_r2 = moieties_r2.read().splitlines()\n",
    "\n",
    "    molsigna_df1 = molsigna_df1.reindex(moie_r1)\n",
    "    molsigna_df2 = molsigna_df2.reindex(moie_r2)\n",
    "\n",
    "    rule_df1 = pd.DataFrame(index=molsigna_df1.index)\n",
    "    rule_df2 = pd.DataFrame(index=molsigna_df2.index)\n",
    "    # for rid, value in reaction_dict.items():\n",
    "    #     # skip the reactions with missing metabolites\n",
    "    #     mets = value.keys()\n",
    "    #     flag = False\n",
    "    #     for met in mets:\n",
    "    #         if met not in all_mets:\n",
    "    #             flag = True\n",
    "    #             break\n",
    "    #     if flag: continue\n",
    "\n",
    "    rule_df1['change'] = 0\n",
    "    for met, stoic in rxn_dict.items():\n",
    "        if met == \"C00080\" or met == \"C00282\":\n",
    "            continue  # hydogen is zero\n",
    "        rule_df1['change'] += molsigna_df1[met] * stoic\n",
    "\n",
    "    rule_df2['change'] = 0\n",
    "    for met, stoic in rxn_dict.items():\n",
    "        if met == \"C00080\" or met == \"C00282\":\n",
    "            continue  # hydogen is zero\n",
    "        rule_df2['change'] += molsigna_df2[met] * stoic\n",
    "\n",
    "    rule_vec1 = rule_df1.to_numpy().T\n",
    "    rule_vec2 = rule_df2.to_numpy().T\n",
    "\n",
    "    m1, n1 = rule_vec1.shape\n",
    "    m2, n2 = rule_vec2.shape\n",
    "\n",
    "    zeros1 = np.zeros((m1, 44))\n",
    "    zeros2 = np.zeros((m2, 44))\n",
    "    X1 = np.concatenate((rule_vec1, zeros1), 1)\n",
    "    X2 = np.concatenate((rule_vec2, zeros2), 1)\n",
    "\n",
    "    rule_comb = np.concatenate((X1, X2), 1)\n",
    "\n",
    "    # rule_df_final = {}\n",
    "    # rule_df_final['rad1'] = rule_df1\n",
    "    # rule_df_final['rad2'] = rule_df2\n",
    "    return rule_comb, rule_df1, rule_df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_ddG0(rxn_dict, pH, I, novel_mets):\n",
    "    ccache = CompoundCacher()\n",
    "    # ddG0 = get_transform_ddG0(rxn_dict, ccache, pH, I, T)\n",
    "    T = 298.15\n",
    "    ddG0_forward = 0\n",
    "    for compound_id, coeff in rxn_dict.items():\n",
    "        if novel_mets != None and compound_id in novel_mets:\n",
    "            comp = novel_mets[compound_id]\n",
    "        else:\n",
    "            comp = ccache.get_compound(compound_id)\n",
    "        ddG0_forward += coeff * comp.transform_pH7(pH, I, T)\n",
    "\n",
    "    return ddG0_forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_dG0(rxn_dict, rid, pH, I, loaded_model, molsig_r1, molsig_r2, novel_decomposed_r1, novel_decomposed_r2, novel_mets):\n",
    "\n",
    "    # rule_df = get_rxn_rule(rid)\n",
    "    rule_comb, rule_df1, rule_df2 = get_rule(\n",
    "        rxn_dict, molsig_r1, molsig_r2, novel_decomposed_r1, novel_decomposed_r2)\n",
    "\n",
    "    X = rule_comb\n",
    "\n",
    "    ymean, ystd = loaded_model.predict(X, return_std=True)\n",
    "    \n",
    "    #estimating uncertainty \n",
    "    conf_int = 1.96*ystd[0]/np.sqrt(4001)      ## uncertainty for 95% confidence \n",
    "\n",
    "    result = {}\n",
    "    # result['dG0'] = ymean[0] + get_ddG0(rxn_dict, pH, I)\n",
    "    # result['standard deviation'] = ystd[0]\n",
    "\n",
    "    # result_df = pd.DataFrame([result])\n",
    "    # result_df.style.hide_index()\n",
    "    # return result_df\n",
    "    return ymean[0] + get_ddG0(rxn_dict, pH, I, novel_mets), conf_int, rule_df1, rule_df2\n",
    "    # return ymean[0],ystd[0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def parse_novel_molecule(add_info):\n",
    "    result = {}\n",
    "    for cid, InChI in add_info.items():\n",
    "        c = Compound.from_inchi('Test', cid, InChI)\n",
    "        result[cid] = c\n",
    "    return result\n",
    "\n",
    "\n",
    "def parse_novel_smiles(result):\n",
    "    novel_smiles = {}\n",
    "    for cid, c in result.items():\n",
    "        smiles = c.smiles_pH7\n",
    "        novel_smiles[cid] = smiles\n",
    "    return novel_smiles\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "db_smiles = load_smiles()\n",
    "molsig_r1 = load_molsig_rad1()\n",
    "molsig_r2 = load_molsig_rad2()\n",
    "\n",
    "loaded_model = load_model()\n",
    "ccache = load_compound_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estimating dG for reaction "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Rxn_str_test = \"C00031 + 1.14 C00014 <=> 0.29 C00011 + 3.14 C00001\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Rxn_dict_test = parse_formula(Rxn_str_test)\n",
    "pH = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu_test, std_test, rule_df1_test, rule_df2_test = get_dG0(Rxn_dict_test, 'Rxn_test', pH, 0.25, loaded_model, molsig_r1, molsig_r2, [], [], [])\n",
    "\n",
    "print(\"dG = %.2f ± %.2f kJ/mol\" % (mu_test, std_test))\n",
    "\n",
    "\n",
    "# print(mu_test)\n",
    "# print(mu1_test)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# bulk dG function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reached here...\n"
     ]
    }
   ],
   "source": [
    "pH = 7 # any number between 0-14 \n",
    "I = 0.1    #min_value=0.0, max_value=0.5)\n",
    "\n",
    "print('reached here...')\n",
    "\n",
    "def bulk_dG_pred(Rxn_list, pH, I):\n",
    "    print('started!!!')\n",
    "\n",
    "    mu_ls = []\n",
    "    std_ls = []\n",
    "    kegg_id_ls = []\n",
    "    for keys in tqdm(Rxn_list):\n",
    "        kegg_rxn_string = Rxn_list[keys]\n",
    "        kegg_rxn_dict = parse_formula(kegg_rxn_string)\n",
    "        kegg_id_ls.append(keys)\n",
    "        try: \n",
    "            mu, std, rule_df1, rule_df2 = get_dG0(kegg_rxn_dict, keys, pH, I, loaded_model, molsig_r1, molsig_r2, [], [], [])\n",
    "            mu_ls.append(mu)\n",
    "            std_ls.append(std)\n",
    "        except: \n",
    "            mu_ls.append(np.NaN)\n",
    "            std_ls.append(np.NaN)\n",
    "    \n",
    "    final_out_dict= {'ID': kegg_id_ls, 'dG': mu_ls, 'std': std_ls}\n",
    "    output_df = pd.DataFrame(final_out_dict)\n",
    "    return output_df    \n",
    "    \n",
    "        \n",
    "        # print(keys)\n",
    "        # print(kegg_rxn_string)\n",
    "        # print(\"dG = %.2f ± %.2f kJ/mol\" % (mu, std))\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bulk ModelSeed database dG generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "rxn_alias_fread = open('./data/Unique_ModelSEED_Reaction_Aliases.txt').readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 343680/343680 [00:00<00:00, 945228.12it/s]\n"
     ]
    }
   ],
   "source": [
    "ModelSEED_ID = []\n",
    "External_ID = []\n",
    "Source = []\n",
    "\n",
    "for i in tqdm(rxn_alias_fread):\n",
    "    temp = i.split('\\t')\n",
    "    ModelSEED_ID.append(temp[0])\n",
    "    External_ID.append(temp[1])\n",
    "    Source.append(temp[2])\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "ModelSEED_ID_header = ModelSEED_ID[0]\n",
    "External_ID_header = External_ID[0]\n",
    "Source_header = Source[0]\n",
    "\n",
    "ModelSEED_ID = ModelSEED_ID[1:]\n",
    "External_ID = External_ID[1:]\n",
    "Source = Source[1:]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "ModelSEED_alias_dict = {}\n",
    "ModelSEED_alias_dict[ModelSEED_ID_header] = ModelSEED_ID\n",
    "ModelSEED_alias_dict[External_ID_header] = External_ID\n",
    "ModelSEED_alias_dict[Source_header] = Source"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "ModelSEED_alias_df = pd.DataFrame(ModelSEED_alias_dict, index=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ModelSEED ID</th>\n",
       "      <th>External ID</th>\n",
       "      <th>Source\\n</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>rxn00001</td>\n",
       "      <td>R_R00004_c</td>\n",
       "      <td>AlgaGEM\\n</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>rxn00001</td>\n",
       "      <td>INORGPYROPHOSPHAT-RXN</td>\n",
       "      <td>AraCyc\\n</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>rxn00001</td>\n",
       "      <td>R_R00004_c</td>\n",
       "      <td>AraGEM\\n</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>rxn00001</td>\n",
       "      <td>IPP1</td>\n",
       "      <td>BiGG\\n</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>rxn00001</td>\n",
       "      <td>PPA</td>\n",
       "      <td>BiGG\\n</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  ModelSEED ID            External ID   Source\\n\n",
       "0     rxn00001             R_R00004_c  AlgaGEM\\n\n",
       "1     rxn00001  INORGPYROPHOSPHAT-RXN   AraCyc\\n\n",
       "2     rxn00001             R_R00004_c   AraGEM\\n\n",
       "3     rxn00001                   IPP1     BiGG\\n\n",
       "4     rxn00001                    PPA     BiGG\\n"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ModelSEED_alias_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "343679"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ModelSEED_ID)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "ModelSEED_ID_unique = set(ModelSEED_ID)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "ModelSEED_alias_df.to_csv('./data/modelSEED_alias.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Source[15].strip() == 'KEGG'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "343679it [00:00, 1798623.49it/s]\n"
     ]
    }
   ],
   "source": [
    "KEGG_idx_ls = []\n",
    "KEGG_ids = []\n",
    "Modelseed_ids = []\n",
    "Source_ids = []\n",
    "\n",
    "\n",
    "for idx, src in tqdm(enumerate(Source)):\n",
    "    if src.strip() == 'KEGG':\n",
    "        KEGG_idx_ls.append(idx)\n",
    "        \n",
    "        Modelseed_ids.append(ModelSEED_ID[idx])\n",
    "        KEGG_ids.append(External_ID[idx])\n",
    "        Source_ids.append(Source[idx])\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14618"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(Modelseed_ids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>ModelSEED ID</th>\n",
       "      <th>External ID</th>\n",
       "      <th>Source\\n</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>rxn00001</td>\n",
       "      <td>R00004</td>\n",
       "      <td>KEGG\\n</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>rxn00002</td>\n",
       "      <td>R00005</td>\n",
       "      <td>KEGG\\n</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>rxn00003</td>\n",
       "      <td>R00006</td>\n",
       "      <td>KEGG\\n</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>rxn00004</td>\n",
       "      <td>R00008</td>\n",
       "      <td>KEGG\\n</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>rxn00006</td>\n",
       "      <td>R00009</td>\n",
       "      <td>KEGG\\n</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  ModelSEED ID External ID Source\\n\n",
       "0     rxn00001      R00004   KEGG\\n\n",
       "1     rxn00002      R00005   KEGG\\n\n",
       "2     rxn00003      R00006   KEGG\\n\n",
       "3     rxn00004      R00008   KEGG\\n\n",
       "4     rxn00006      R00009   KEGG\\n"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_modelseed_to_kegg = {}\n",
    "dict_modelseed_to_kegg[ModelSEED_ID_header] = Modelseed_ids\n",
    "dict_modelseed_to_kegg[External_ID_header]  = KEGG_ids\n",
    "dict_modelseed_to_kegg[Source_header] = Source_ids\n",
    "\n",
    "modelSEED_to_kegg_df = pd.DataFrame(dict_modelseed_to_kegg)\n",
    "\n",
    "modelSEED_to_kegg_df.head()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "equilibrator = pd.read_table('./data/MetaNetX_Reaction_Energies_equilibrator.tbl', header=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "equilibrator_rxnid_mseeed = list(equilibrator[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "KEGG_db_mseed = pd.read_table('./data/KEGG_Reactions_modelseed.tbl') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "KEGG_db_ids_mseed = list(KEGG_db_mseed['ID'])\n",
    "KEGG_db_rxn_eqn_mseed = list(KEGG_db_mseed['EQUATION'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 9722/9722 [00:00<00:00, 844716.99it/s]\n"
     ]
    }
   ],
   "source": [
    "KEGG_db_rxn_eqn_mseed_clean = []\n",
    "\n",
    "for eqn in tqdm(KEGG_db_rxn_eqn_mseed):\n",
    "    temp = eqn.replace('[0]', '').replace('(', '').replace(')', \"\")\n",
    "    KEGG_db_rxn_eqn_mseed_clean.append(temp)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "9722it [00:00, 1618456.98it/s]\n"
     ]
    }
   ],
   "source": [
    "KEGG_rxn_list_mseed = {}\n",
    "\n",
    "for ix, ids in tqdm(enumerate(KEGG_db_ids_mseed)):\n",
    "    KEGG_rxn_list_mseed[ids] = KEGG_db_rxn_eqn_mseed_clean[ix]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('./data/KEGG_rxn_eqn_master_branch.json', 'w') as of:\n",
    "    json.dump(KEGG_rxn_list_mseed, of, indent=4)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## bulk KEGG dG gen using modelseed file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = bulk_dG_pred(KEGG_rxn_list_mseed, 7, 0.25) ## if wants to run everything at once"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## splitting data for parallel dG prediction- saves time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "KEGG_db_ids_mseed_ar = np.array(KEGG_db_ids_mseed)\n",
    "split_100_KEGG_ids_mseed = np.array_split(KEGG_db_ids_mseed_ar, 100)\n",
    "\n",
    "KEGG_db_rxn_eqn_mseed_clean_ar = np.array(KEGG_db_rxn_eqn_mseed_clean)\n",
    "split_100_KEGG_rxn_eqn_mseed_clean = np.array_split(KEGG_db_rxn_eqn_mseed_clean_ar, 100)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(100):\n",
    "    id_ls = list(split_100_KEGG_ids_mseed[i])\n",
    "    eqn_ls = list(split_100_KEGG_rxn_eqn_mseed_clean[i])\n",
    "    \n",
    "    temp_dict = {}\n",
    "    for j, idis in enumerate(id_ls):\n",
    "        temp_dict[idis] = eqn_ls[j]\n",
    "        \n",
    "        \n",
    "    fname = './data/KEGG_split_rxn_data/KEGG_rxn_eqn_mseed_split_' + str(i)+'.json'\n",
    "    \n",
    "    with open(fname, 'w') as of:\n",
    "        json.dump(temp_dict, of, indent=4)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## shell script to generate multiple run and job submission files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!for i in {1..100}; do  cp subScript.pbs subScript_$i.pbs ; done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!for i in {1..100}; do  cp db_bulk_dg_gen.py db_bulk_dg_gen_$i.py ; done"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## bulk edit of model run python files for splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:00<00:00, 465.98it/s]\n"
     ]
    }
   ],
   "source": [
    "for i in tqdm(range(100)):\n",
    "    fread_name = 'db_bulk_dg_gen_' + str(i+1) + '.py'\n",
    "    with open(fread_name, 'r') as f:\n",
    "        temp_data = f.readlines()\n",
    "        \n",
    "#     print(temp_data[-7])\n",
    "    temp_data[-3] = temp_data[-3].replace('0', str(i))\n",
    "    temp_data[-7] = temp_data[-7].replace('0', str(i))\n",
    "    \n",
    "    with open(fread_name, 'w') as fl:\n",
    "        fl.writelines(temp_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:00<00:00, 385.26it/s]\n"
     ]
    }
   ],
   "source": [
    "from tqdm import tqdm\n",
    "\n",
    "for i in tqdm(range(100)):\n",
    "    fread_name = './run_script/subScript_' + str(i+1) + '.pbs'\n",
    "    with open(fread_name, 'r') as f:\n",
    "        temp_data = f.readlines()\n",
    "        \n",
    "    temp_data[-5] = temp_data[-5].replace('0', str(i + 1))\n",
    "    \n",
    "    with open(fread_name, 'w') as fl:\n",
    "        fl.writelines(temp_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## loading split data dG's to generate final file\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 100/100 [00:02<00:00, 40.33it/s]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "for i in tqdm(range(100)):\n",
    "    fname = './modelseed/dG_kegg_split_' + str(i) + '.csv'\n",
    "    \n",
    "    csv_read = pd.read_csv(fname)\n",
    "    \n",
    "    if i == 0:\n",
    "        csv_final = csv_read\n",
    "    else:\n",
    "        csv_final = pd.concat([csv_final, csv_read])\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "csv_final.to_csv('./data/KEGG_dG_modelseed_ref.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "dG_kegg_id = list(csv_final['ID'])\n",
    "dG_Kegg = list(csv_final['dG'])\n",
    "dG_std_kegg = list(csv_final['std'])\n",
    "\n",
    "dG_kegg_id_ar = np.array(csv_final['ID'])\n",
    "dG_Kegg_ar = np.array(csv_final['dG'])\n",
    "dG_std_kegg_ar = np.array(csv_final['std'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "Modelseed_ids_ar = np.array(Modelseed_ids)\n",
    "KEGG_ids_ar = np.array(KEGG_ids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[12]"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(np.where(Modelseed_ids_ar == 'rxn00013')[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'R00016'"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "KEGG_ids[Modelseed_ids.index('rxn00013')] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = json.load(open('./data/optstoic_v3_Sji_dict.json'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "14618it [00:05, 2909.88it/s]\n"
     ]
    }
   ],
   "source": [
    "mseed_dict_dup = {}\n",
    "mseed_dict = {}\n",
    "rid_not_inmseed_table = []\n",
    "\n",
    "\n",
    "for i, mseedids in tqdm(enumerate(Modelseed_ids)):\n",
    "    try:\n",
    "        dG_val = dG_Kegg[dG_kegg_id.index(KEGG_ids[i])]\n",
    "        std_val = dG_std_kegg[dG_kegg_id.index(KEGG_ids[i])]\n",
    "    except: \n",
    "        dG_val = ''\n",
    "        std_val = ''\n",
    "        rid_not_inmseed_table.append(KEGG_ids[i])\n",
    "        \n",
    "    mseed_dict_keys = list(mseed_dict.keys())\n",
    "    \n",
    "    mseed_dict_dup[i] = {'ID': mseedids, 'KEGG': KEGG_ids[i], 'dG': dG_val, 'std': std_val}\n",
    "    \n",
    "    if mseedids in mseed_dict_keys:\n",
    "        dG_dup = mseed_dict[mseedids]\n",
    "        if dG_dup == np.NaN:\n",
    "            mseed_dict[i] = {'ID': mseedids, 'dG': dG_val, 'std': std_val}\n",
    "    else:\n",
    "        mseed_dict[i] = {'ID': mseedids, 'dG': dG_val, 'std': std_val}\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "mseed_dG_df = pd.DataFrame(mseed_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "mseed_dG_df_t = mseed_dG_df.transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "mseed_dG_df_t.to_csv('./data/modelseed_first_dG.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reached here...\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rxn00001',\n",
       " 'rxn00002',\n",
       " 'rxn00003',\n",
       " 'rxn00004',\n",
       " 'rxn00006',\n",
       " 'rxn00007',\n",
       " 'rxn00007',\n",
       " 'rxn00008',\n",
       " 'rxn00009',\n",
       " 'rxn00010',\n",
       " 'rxn00011',\n",
       " 'rxn00012',\n",
       " 'rxn00013',\n",
       " 'rxn00014',\n",
       " 'rxn00015',\n",
       " 'rxn00016',\n",
       " 'rxn00017',\n",
       " 'rxn00018',\n",
       " 'rxn00020',\n",
       " 'rxn00020',\n",
       " 'rxn00021',\n",
       " 'rxn00022',\n",
       " 'rxn00022',\n",
       " 'rxn00023',\n",
       " 'rxn00024',\n",
       " 'rxn00025',\n",
       " 'rxn00026',\n",
       " 'rxn00027',\n",
       " 'rxn00028',\n",
       " 'rxn00029',\n",
       " 'rxn00030',\n",
       " 'rxn00031',\n",
       " 'rxn00033',\n",
       " 'rxn00034',\n",
       " 'rxn00035',\n",
       " 'rxn00036',\n",
       " 'rxn00038',\n",
       " 'rxn00039',\n",
       " 'rxn00040',\n",
       " 'rxn00041',\n",
       " 'rxn00042',\n",
       " 'rxn00043',\n",
       " 'rxn00044',\n",
       " 'rxn00045',\n",
       " 'rxn00046',\n",
       " 'rxn00047',\n",
       " 'rxn00048',\n",
       " 'rxn00051',\n",
       " 'rxn00052',\n",
       " 'rxn00054',\n",
       " 'rxn00055',\n",
       " 'rxn00056',\n",
       " 'rxn00057',\n",
       " 'rxn00058',\n",
       " 'rxn00060',\n",
       " 'rxn00061',\n",
       " 'rxn00062',\n",
       " 'rxn00063',\n",
       " 'rxn00064',\n",
       " 'rxn00065',\n",
       " 'rxn00066',\n",
       " 'rxn00067',\n",
       " 'rxn00068',\n",
       " 'rxn00069',\n",
       " 'rxn00070',\n",
       " 'rxn00071',\n",
       " 'rxn00072',\n",
       " 'rxn00074',\n",
       " 'rxn00075',\n",
       " 'rxn00076',\n",
       " 'rxn00077',\n",
       " 'rxn00078',\n",
       " 'rxn00079',\n",
       " 'rxn00080',\n",
       " 'rxn00083',\n",
       " 'rxn00084',\n",
       " 'rxn00085',\n",
       " 'rxn00086',\n",
       " 'rxn00088',\n",
       " 'rxn00089',\n",
       " 'rxn00090',\n",
       " 'rxn00092',\n",
       " 'rxn00093',\n",
       " 'rxn00095',\n",
       " 'rxn00096',\n",
       " 'rxn00097',\n",
       " 'rxn00098',\n",
       " 'rxn00099',\n",
       " 'rxn00100',\n",
       " 'rxn00101',\n",
       " 'rxn00102',\n",
       " 'rxn00102',\n",
       " 'rxn00103',\n",
       " 'rxn00105',\n",
       " 'rxn00106',\n",
       " 'rxn00107',\n",
       " 'rxn00108',\n",
       " 'rxn00109',\n",
       " 'rxn00113',\n",
       " 'rxn00114',\n",
       " 'rxn00115',\n",
       " 'rxn00116',\n",
       " 'rxn00117',\n",
       " 'rxn00118',\n",
       " 'rxn00119',\n",
       " 'rxn00120',\n",
       " 'rxn00121',\n",
       " 'rxn00122',\n",
       " 'rxn00123',\n",
       " 'rxn00124',\n",
       " 'rxn00125',\n",
       " 'rxn00126',\n",
       " 'rxn00127',\n",
       " 'rxn00128',\n",
       " 'rxn00129',\n",
       " 'rxn00130',\n",
       " 'rxn00131',\n",
       " 'rxn00132',\n",
       " 'rxn00133',\n",
       " 'rxn00134',\n",
       " 'rxn00136',\n",
       " 'rxn00137',\n",
       " 'rxn00138',\n",
       " 'rxn00139',\n",
       " 'rxn00140',\n",
       " 'rxn00141',\n",
       " 'rxn00142',\n",
       " 'rxn00143',\n",
       " 'rxn00144',\n",
       " 'rxn00145',\n",
       " 'rxn00146',\n",
       " 'rxn00147',\n",
       " 'rxn00148',\n",
       " 'rxn00149',\n",
       " 'rxn00150',\n",
       " 'rxn00151',\n",
       " 'rxn00152',\n",
       " 'rxn00153',\n",
       " 'rxn00154',\n",
       " 'rxn00155',\n",
       " 'rxn00156',\n",
       " 'rxn00157',\n",
       " 'rxn00158',\n",
       " 'rxn00159',\n",
       " 'rxn00160',\n",
       " 'rxn00161',\n",
       " 'rxn00162',\n",
       " 'rxn00163',\n",
       " 'rxn00164',\n",
       " 'rxn00165',\n",
       " 'rxn00166',\n",
       " 'rxn00168',\n",
       " 'rxn00170',\n",
       " 'rxn00171',\n",
       " 'rxn00172',\n",
       " 'rxn00173',\n",
       " 'rxn00174',\n",
       " 'rxn00175',\n",
       " 'rxn00176',\n",
       " 'rxn00177',\n",
       " 'rxn00178',\n",
       " 'rxn00179',\n",
       " 'rxn00181',\n",
       " 'rxn00182',\n",
       " 'rxn00183',\n",
       " 'rxn00184',\n",
       " 'rxn00185',\n",
       " 'rxn00186',\n",
       " 'rxn00187',\n",
       " 'rxn00188',\n",
       " 'rxn00189',\n",
       " 'rxn00190',\n",
       " 'rxn00191',\n",
       " 'rxn00192',\n",
       " 'rxn00193',\n",
       " 'rxn00194',\n",
       " 'rxn00195',\n",
       " 'rxn00196',\n",
       " 'rxn00197',\n",
       " 'rxn00198',\n",
       " 'rxn00199',\n",
       " 'rxn00200',\n",
       " 'rxn00201',\n",
       " 'rxn00202',\n",
       " 'rxn00203',\n",
       " 'rxn00204',\n",
       " 'rxn00205',\n",
       " 'rxn00206',\n",
       " 'rxn00207',\n",
       " 'rxn00208',\n",
       " 'rxn00209',\n",
       " 'rxn00210',\n",
       " 'rxn00211',\n",
       " 'rxn00212',\n",
       " 'rxn00213',\n",
       " 'rxn00214',\n",
       " 'rxn00215',\n",
       " 'rxn00216',\n",
       " 'rxn00217',\n",
       " 'rxn00218',\n",
       " 'rxn00219',\n",
       " 'rxn00220',\n",
       " 'rxn00221',\n",
       " 'rxn00222',\n",
       " 'rxn00222',\n",
       " 'rxn00223',\n",
       " 'rxn00224',\n",
       " 'rxn00225',\n",
       " 'rxn00226',\n",
       " 'rxn00227',\n",
       " 'rxn00228',\n",
       " 'rxn00229',\n",
       " 'rxn00230',\n",
       " 'rxn00231',\n",
       " 'rxn00232',\n",
       " 'rxn00233',\n",
       " 'rxn00234',\n",
       " 'rxn00235',\n",
       " 'rxn00236',\n",
       " 'rxn00237',\n",
       " 'rxn00238',\n",
       " 'rxn00239',\n",
       " 'rxn00240',\n",
       " 'rxn00241',\n",
       " 'rxn00242',\n",
       " 'rxn00243',\n",
       " 'rxn00244',\n",
       " 'rxn00245',\n",
       " 'rxn00247',\n",
       " 'rxn00248',\n",
       " 'rxn00249',\n",
       " 'rxn00250',\n",
       " 'rxn00251',\n",
       " 'rxn00252',\n",
       " 'rxn00253',\n",
       " 'rxn00254',\n",
       " 'rxn00255',\n",
       " 'rxn00256',\n",
       " 'rxn00257',\n",
       " 'rxn00258',\n",
       " 'rxn00259',\n",
       " 'rxn00260',\n",
       " 'rxn00262',\n",
       " 'rxn00263',\n",
       " 'rxn00264',\n",
       " 'rxn00265',\n",
       " 'rxn00266',\n",
       " 'rxn00267',\n",
       " 'rxn00268',\n",
       " 'rxn00269',\n",
       " 'rxn00270',\n",
       " 'rxn00271',\n",
       " 'rxn00272',\n",
       " 'rxn00274',\n",
       " 'rxn00275',\n",
       " 'rxn00276',\n",
       " 'rxn00278',\n",
       " 'rxn00279',\n",
       " 'rxn00280',\n",
       " 'rxn00282',\n",
       " 'rxn00283',\n",
       " 'rxn00284',\n",
       " 'rxn00285',\n",
       " 'rxn00286',\n",
       " 'rxn00287',\n",
       " 'rxn00288',\n",
       " 'rxn00289',\n",
       " 'rxn00290',\n",
       " 'rxn00291',\n",
       " 'rxn00292',\n",
       " 'rxn00293',\n",
       " 'rxn00295',\n",
       " 'rxn00296',\n",
       " 'rxn00297',\n",
       " 'rxn00298',\n",
       " 'rxn00299',\n",
       " 'rxn00300',\n",
       " 'rxn00301',\n",
       " 'rxn00302',\n",
       " 'rxn00303',\n",
       " 'rxn00304',\n",
       " 'rxn00305',\n",
       " 'rxn00306',\n",
       " 'rxn00307',\n",
       " 'rxn00308',\n",
       " 'rxn00309',\n",
       " 'rxn00310',\n",
       " 'rxn00311',\n",
       " 'rxn00312',\n",
       " 'rxn00313',\n",
       " 'rxn00314',\n",
       " 'rxn00315',\n",
       " 'rxn00316',\n",
       " 'rxn00317',\n",
       " 'rxn00318',\n",
       " 'rxn00319',\n",
       " 'rxn00320',\n",
       " 'rxn00321',\n",
       " 'rxn00322',\n",
       " 'rxn00323',\n",
       " 'rxn00324',\n",
       " 'rxn00325',\n",
       " 'rxn00326',\n",
       " 'rxn00327',\n",
       " 'rxn00328',\n",
       " 'rxn00330',\n",
       " 'rxn00331',\n",
       " 'rxn00332',\n",
       " 'rxn00333',\n",
       " 'rxn00334',\n",
       " 'rxn00335',\n",
       " 'rxn00336',\n",
       " 'rxn00337',\n",
       " 'rxn00338',\n",
       " 'rxn00339',\n",
       " 'rxn00340',\n",
       " 'rxn00341',\n",
       " 'rxn00342',\n",
       " 'rxn00343',\n",
       " 'rxn00344',\n",
       " 'rxn00345',\n",
       " 'rxn00346',\n",
       " 'rxn00347',\n",
       " 'rxn00348',\n",
       " 'rxn00350',\n",
       " 'rxn00351',\n",
       " 'rxn00352',\n",
       " 'rxn00354',\n",
       " 'rxn00355',\n",
       " 'rxn00356',\n",
       " 'rxn00356',\n",
       " 'rxn00357',\n",
       " 'rxn00358',\n",
       " 'rxn00359',\n",
       " 'rxn00360',\n",
       " 'rxn00361',\n",
       " 'rxn00362',\n",
       " 'rxn00363',\n",
       " 'rxn00364',\n",
       " 'rxn00365',\n",
       " 'rxn00366',\n",
       " 'rxn00367',\n",
       " 'rxn00368',\n",
       " 'rxn00369',\n",
       " 'rxn00370',\n",
       " 'rxn00371',\n",
       " 'rxn00372',\n",
       " 'rxn00373',\n",
       " 'rxn00374',\n",
       " 'rxn00375',\n",
       " 'rxn00376',\n",
       " 'rxn00377',\n",
       " 'rxn00378',\n",
       " 'rxn00379',\n",
       " 'rxn00380',\n",
       " 'rxn00381',\n",
       " 'rxn00382',\n",
       " 'rxn00383',\n",
       " 'rxn00384',\n",
       " 'rxn00385',\n",
       " 'rxn00386',\n",
       " 'rxn00387',\n",
       " 'rxn00388',\n",
       " 'rxn00389',\n",
       " 'rxn00390',\n",
       " 'rxn00391',\n",
       " 'rxn00392',\n",
       " 'rxn00393',\n",
       " 'rxn00394',\n",
       " 'rxn00395',\n",
       " 'rxn00396',\n",
       " 'rxn00400',\n",
       " 'rxn00401',\n",
       " 'rxn00402',\n",
       " 'rxn00403',\n",
       " 'rxn00404',\n",
       " 'rxn00405',\n",
       " 'rxn00406',\n",
       " 'rxn00407',\n",
       " 'rxn00408',\n",
       " 'rxn00409',\n",
       " 'rxn00410',\n",
       " 'rxn00411',\n",
       " 'rxn00412',\n",
       " 'rxn00413',\n",
       " 'rxn00414',\n",
       " 'rxn00415',\n",
       " 'rxn00416',\n",
       " 'rxn00417',\n",
       " 'rxn00419',\n",
       " 'rxn00420',\n",
       " 'rxn00421',\n",
       " 'rxn00422',\n",
       " 'rxn00423',\n",
       " 'rxn00424',\n",
       " 'rxn00425',\n",
       " 'rxn00426',\n",
       " 'rxn00427',\n",
       " 'rxn00428',\n",
       " 'rxn00429',\n",
       " 'rxn00430',\n",
       " 'rxn00432',\n",
       " 'rxn00433',\n",
       " 'rxn00434',\n",
       " 'rxn00435',\n",
       " 'rxn00436',\n",
       " 'rxn00437',\n",
       " 'rxn00438',\n",
       " 'rxn00439',\n",
       " 'rxn00440',\n",
       " 'rxn00441',\n",
       " 'rxn00443',\n",
       " 'rxn00444',\n",
       " 'rxn00445',\n",
       " 'rxn00448',\n",
       " 'rxn00449',\n",
       " 'rxn00450',\n",
       " 'rxn00451',\n",
       " 'rxn00452',\n",
       " 'rxn00453',\n",
       " 'rxn00454',\n",
       " 'rxn00455',\n",
       " 'rxn00456',\n",
       " 'rxn00457',\n",
       " 'rxn00458',\n",
       " 'rxn00459',\n",
       " 'rxn00460',\n",
       " 'rxn00461',\n",
       " 'rxn00462',\n",
       " 'rxn00463',\n",
       " 'rxn00464',\n",
       " 'rxn00465',\n",
       " 'rxn00466',\n",
       " 'rxn00467',\n",
       " 'rxn00468',\n",
       " 'rxn00469',\n",
       " 'rxn00470',\n",
       " 'rxn00471',\n",
       " 'rxn00472',\n",
       " 'rxn00473',\n",
       " 'rxn00474',\n",
       " 'rxn00475',\n",
       " 'rxn00476',\n",
       " 'rxn00477',\n",
       " 'rxn00478',\n",
       " 'rxn00479',\n",
       " 'rxn00480',\n",
       " 'rxn00481',\n",
       " 'rxn00482',\n",
       " 'rxn00483',\n",
       " 'rxn00484',\n",
       " 'rxn00485',\n",
       " 'rxn00486',\n",
       " 'rxn00487',\n",
       " 'rxn00488',\n",
       " 'rxn00489',\n",
       " 'rxn00489',\n",
       " 'rxn00490',\n",
       " 'rxn00491',\n",
       " 'rxn00492',\n",
       " 'rxn00493',\n",
       " 'rxn00494',\n",
       " 'rxn00495',\n",
       " 'rxn00497',\n",
       " 'rxn00498',\n",
       " 'rxn00499',\n",
       " 'rxn00500',\n",
       " 'rxn00501',\n",
       " 'rxn00502',\n",
       " 'rxn00503',\n",
       " 'rxn00504',\n",
       " 'rxn00505',\n",
       " 'rxn00506',\n",
       " 'rxn00507',\n",
       " 'rxn00508',\n",
       " 'rxn00509',\n",
       " 'rxn00510',\n",
       " 'rxn00511',\n",
       " 'rxn00512',\n",
       " 'rxn00513',\n",
       " 'rxn00514',\n",
       " 'rxn00515',\n",
       " 'rxn00516',\n",
       " 'rxn00517',\n",
       " 'rxn00518',\n",
       " 'rxn00519',\n",
       " 'rxn00520',\n",
       " 'rxn00521',\n",
       " 'rxn00522',\n",
       " 'rxn00523',\n",
       " 'rxn00524',\n",
       " 'rxn00525',\n",
       " 'rxn00526',\n",
       " 'rxn00527',\n",
       " 'rxn00528',\n",
       " 'rxn00529',\n",
       " 'rxn00530',\n",
       " 'rxn00531',\n",
       " 'rxn00532',\n",
       " 'rxn00533',\n",
       " 'rxn00534',\n",
       " 'rxn00536',\n",
       " 'rxn00537',\n",
       " 'rxn00538',\n",
       " 'rxn00539',\n",
       " 'rxn00540',\n",
       " 'rxn00541',\n",
       " 'rxn00542',\n",
       " 'rxn00543',\n",
       " 'rxn00544',\n",
       " 'rxn00545',\n",
       " 'rxn00546',\n",
       " 'rxn00547',\n",
       " 'rxn00548',\n",
       " 'rxn00549',\n",
       " 'rxn00550',\n",
       " 'rxn00551',\n",
       " 'rxn00552',\n",
       " 'rxn00553',\n",
       " 'rxn00553',\n",
       " 'rxn00554',\n",
       " 'rxn00555',\n",
       " 'rxn00556',\n",
       " 'rxn00557',\n",
       " 'rxn00558',\n",
       " 'rxn00559',\n",
       " 'rxn00560',\n",
       " 'rxn00561',\n",
       " 'rxn00562',\n",
       " 'rxn00563',\n",
       " 'rxn00564',\n",
       " 'rxn00565',\n",
       " 'rxn00566',\n",
       " 'rxn00567',\n",
       " 'rxn00568',\n",
       " 'rxn00569',\n",
       " 'rxn00570',\n",
       " 'rxn00571',\n",
       " 'rxn00572',\n",
       " 'rxn00573',\n",
       " 'rxn00575',\n",
       " 'rxn00575',\n",
       " 'rxn00577',\n",
       " 'rxn00577',\n",
       " 'rxn00578',\n",
       " 'rxn00578',\n",
       " 'rxn00579',\n",
       " 'rxn00579',\n",
       " 'rxn00580',\n",
       " 'rxn00580',\n",
       " 'rxn00581',\n",
       " 'rxn00581',\n",
       " 'rxn00582',\n",
       " 'rxn00582',\n",
       " 'rxn00583',\n",
       " 'rxn00584',\n",
       " 'rxn00585',\n",
       " 'rxn00586',\n",
       " 'rxn00587',\n",
       " 'rxn00588',\n",
       " 'rxn00589',\n",
       " 'rxn00592',\n",
       " 'rxn00593',\n",
       " 'rxn00594',\n",
       " 'rxn00595',\n",
       " 'rxn00596',\n",
       " 'rxn00596',\n",
       " 'rxn00598',\n",
       " 'rxn00599',\n",
       " 'rxn00601',\n",
       " 'rxn00602',\n",
       " 'rxn00603',\n",
       " 'rxn00604',\n",
       " 'rxn00605',\n",
       " 'rxn00605',\n",
       " 'rxn00606',\n",
       " 'rxn00606',\n",
       " 'rxn00607',\n",
       " 'rxn00607',\n",
       " 'rxn00608',\n",
       " 'rxn00610',\n",
       " 'rxn00611',\n",
       " 'rxn00612',\n",
       " 'rxn00613',\n",
       " 'rxn00614',\n",
       " 'rxn00615',\n",
       " 'rxn00616',\n",
       " 'rxn00617',\n",
       " 'rxn00618',\n",
       " 'rxn00619',\n",
       " 'rxn00620',\n",
       " 'rxn00621',\n",
       " 'rxn00622',\n",
       " 'rxn00623',\n",
       " 'rxn00624',\n",
       " 'rxn00625',\n",
       " 'rxn00626',\n",
       " 'rxn00627',\n",
       " 'rxn00629',\n",
       " 'rxn00629',\n",
       " 'rxn00629',\n",
       " 'rxn00629',\n",
       " 'rxn00629',\n",
       " 'rxn00629',\n",
       " 'rxn00629',\n",
       " 'rxn00629',\n",
       " 'rxn00629',\n",
       " 'rxn00629',\n",
       " 'rxn00629',\n",
       " 'rxn00630',\n",
       " 'rxn00630',\n",
       " 'rxn00630',\n",
       " 'rxn00630',\n",
       " 'rxn00630',\n",
       " 'rxn00630',\n",
       " 'rxn00630',\n",
       " 'rxn00630',\n",
       " 'rxn00630',\n",
       " 'rxn00630',\n",
       " 'rxn00630',\n",
       " 'rxn00631',\n",
       " 'rxn00631',\n",
       " 'rxn00631',\n",
       " 'rxn00631',\n",
       " 'rxn00631',\n",
       " 'rxn00631',\n",
       " 'rxn00631',\n",
       " 'rxn00631',\n",
       " 'rxn00631',\n",
       " 'rxn00631',\n",
       " 'rxn00631',\n",
       " 'rxn00632',\n",
       " 'rxn00633',\n",
       " 'rxn00634',\n",
       " 'rxn00634',\n",
       " 'rxn00634',\n",
       " 'rxn00634',\n",
       " 'rxn00634',\n",
       " 'rxn00634',\n",
       " 'rxn00634',\n",
       " 'rxn00634',\n",
       " 'rxn00634',\n",
       " 'rxn00634',\n",
       " 'rxn00634',\n",
       " 'rxn00635',\n",
       " 'rxn00636',\n",
       " 'rxn00638',\n",
       " 'rxn00639',\n",
       " 'rxn00640',\n",
       " 'rxn00641',\n",
       " 'rxn00642',\n",
       " 'rxn00643',\n",
       " 'rxn00644',\n",
       " 'rxn00645',\n",
       " 'rxn00646',\n",
       " 'rxn00647',\n",
       " 'rxn00649',\n",
       " 'rxn00650',\n",
       " 'rxn00651',\n",
       " 'rxn00652',\n",
       " 'rxn00653',\n",
       " 'rxn00654',\n",
       " 'rxn00655',\n",
       " 'rxn00656',\n",
       " 'rxn00657',\n",
       " 'rxn00658',\n",
       " 'rxn00659',\n",
       " 'rxn00660',\n",
       " 'rxn00661',\n",
       " 'rxn00662',\n",
       " 'rxn00664',\n",
       " 'rxn00665',\n",
       " 'rxn00668',\n",
       " 'rxn00669',\n",
       " 'rxn00670',\n",
       " 'rxn00671',\n",
       " 'rxn00672',\n",
       " 'rxn00673',\n",
       " 'rxn00674',\n",
       " 'rxn00675',\n",
       " 'rxn00676',\n",
       " 'rxn00677',\n",
       " 'rxn00678',\n",
       " 'rxn00679',\n",
       " 'rxn00680',\n",
       " 'rxn00682',\n",
       " 'rxn00684',\n",
       " 'rxn00686',\n",
       " 'rxn00688',\n",
       " 'rxn00689',\n",
       " 'rxn00690',\n",
       " 'rxn00691',\n",
       " 'rxn00692',\n",
       " 'rxn00693',\n",
       " 'rxn00695',\n",
       " 'rxn00696',\n",
       " 'rxn00697',\n",
       " 'rxn00698',\n",
       " 'rxn00698',\n",
       " 'rxn00699',\n",
       " 'rxn00699',\n",
       " 'rxn00700',\n",
       " 'rxn00701',\n",
       " 'rxn00702',\n",
       " 'rxn00703',\n",
       " 'rxn00703',\n",
       " 'rxn00704',\n",
       " 'rxn00704',\n",
       " 'rxn00705',\n",
       " 'rxn00706',\n",
       " 'rxn00707',\n",
       " 'rxn00708',\n",
       " 'rxn00709',\n",
       " 'rxn00710',\n",
       " 'rxn00711',\n",
       " 'rxn00712',\n",
       " 'rxn00713',\n",
       " 'rxn00714',\n",
       " 'rxn00715',\n",
       " 'rxn00716',\n",
       " 'rxn00717',\n",
       " 'rxn00718',\n",
       " 'rxn00719',\n",
       " 'rxn00720',\n",
       " 'rxn00721',\n",
       " 'rxn00722',\n",
       " 'rxn00723',\n",
       " 'rxn00724',\n",
       " 'rxn00725',\n",
       " 'rxn00726',\n",
       " 'rxn00727',\n",
       " 'rxn00728',\n",
       " 'rxn00729',\n",
       " 'rxn00730',\n",
       " 'rxn00731',\n",
       " 'rxn00732',\n",
       " 'rxn00735',\n",
       " 'rxn00736',\n",
       " 'rxn00737',\n",
       " 'rxn00738',\n",
       " 'rxn00739',\n",
       " 'rxn00740',\n",
       " 'rxn00741',\n",
       " 'rxn00742',\n",
       " 'rxn00743',\n",
       " 'rxn00744',\n",
       " 'rxn00745',\n",
       " 'rxn00746',\n",
       " 'rxn00747',\n",
       " 'rxn00748',\n",
       " 'rxn00749',\n",
       " 'rxn00751',\n",
       " 'rxn00752',\n",
       " 'rxn00753',\n",
       " 'rxn00754',\n",
       " 'rxn00755',\n",
       " 'rxn00756',\n",
       " 'rxn00757',\n",
       " 'rxn00758',\n",
       " 'rxn00762',\n",
       " 'rxn00763',\n",
       " 'rxn00764',\n",
       " 'rxn00765',\n",
       " 'rxn00766',\n",
       " 'rxn00767',\n",
       " 'rxn00768',\n",
       " 'rxn00769',\n",
       " 'rxn00770',\n",
       " 'rxn00771',\n",
       " 'rxn00772',\n",
       " 'rxn00773',\n",
       " 'rxn00774',\n",
       " 'rxn00775',\n",
       " 'rxn00776',\n",
       " 'rxn00777',\n",
       " 'rxn00778',\n",
       " 'rxn00779',\n",
       " 'rxn00780',\n",
       " 'rxn00781',\n",
       " 'rxn00782',\n",
       " 'rxn00783',\n",
       " 'rxn00784',\n",
       " 'rxn00785',\n",
       " 'rxn00786',\n",
       " 'rxn00787',\n",
       " 'rxn00789',\n",
       " 'rxn00790',\n",
       " 'rxn00791',\n",
       " 'rxn00792',\n",
       " 'rxn00793',\n",
       " 'rxn00794',\n",
       " 'rxn00795',\n",
       " 'rxn00797',\n",
       " 'rxn00798',\n",
       " 'rxn00799',\n",
       " 'rxn00800',\n",
       " 'rxn00801',\n",
       " 'rxn00802',\n",
       " 'rxn00803',\n",
       " 'rxn00804',\n",
       " 'rxn00805',\n",
       " 'rxn00806',\n",
       " 'rxn00807',\n",
       " 'rxn00808',\n",
       " 'rxn00810',\n",
       " 'rxn00812',\n",
       " 'rxn00813',\n",
       " 'rxn00814',\n",
       " 'rxn00815',\n",
       " 'rxn00816',\n",
       " 'rxn00816',\n",
       " 'rxn00817',\n",
       " 'rxn00817',\n",
       " 'rxn00818',\n",
       " 'rxn00818',\n",
       " 'rxn00819',\n",
       " 'rxn00821',\n",
       " 'rxn00822',\n",
       " 'rxn00824',\n",
       " 'rxn00826',\n",
       " 'rxn00827',\n",
       " 'rxn00828',\n",
       " 'rxn00829',\n",
       " 'rxn00830',\n",
       " 'rxn00831',\n",
       " 'rxn00832',\n",
       " 'rxn00833',\n",
       " 'rxn00834',\n",
       " 'rxn00835',\n",
       " 'rxn00836',\n",
       " 'rxn00837',\n",
       " 'rxn00838',\n",
       " 'rxn00839',\n",
       " 'rxn00840',\n",
       " 'rxn00841',\n",
       " 'rxn00842',\n",
       " 'rxn00843',\n",
       " 'rxn00844',\n",
       " 'rxn00845',\n",
       " 'rxn00846',\n",
       " 'rxn00848',\n",
       " 'rxn00849',\n",
       " 'rxn00850',\n",
       " 'rxn00851',\n",
       " 'rxn00852',\n",
       " 'rxn00853',\n",
       " 'rxn00854',\n",
       " 'rxn00855',\n",
       " 'rxn00856',\n",
       " 'rxn00857',\n",
       " 'rxn00858',\n",
       " 'rxn00859',\n",
       " 'rxn00860',\n",
       " 'rxn00861',\n",
       " 'rxn00862',\n",
       " 'rxn00863',\n",
       " 'rxn00864',\n",
       " 'rxn00865',\n",
       " 'rxn00866',\n",
       " 'rxn00867',\n",
       " 'rxn00868',\n",
       " 'rxn00869',\n",
       " 'rxn00870',\n",
       " 'rxn00871',\n",
       " 'rxn00872',\n",
       " 'rxn00873',\n",
       " 'rxn00874',\n",
       " 'rxn00875',\n",
       " 'rxn00876',\n",
       " 'rxn00877',\n",
       " 'rxn00878',\n",
       " 'rxn00879',\n",
       " 'rxn00880',\n",
       " 'rxn00881',\n",
       " 'rxn00882',\n",
       " 'rxn00883',\n",
       " 'rxn00884',\n",
       " 'rxn00885',\n",
       " 'rxn00886',\n",
       " 'rxn00888',\n",
       " 'rxn00888',\n",
       " 'rxn00889',\n",
       " 'rxn00890',\n",
       " 'rxn00890',\n",
       " 'rxn00891',\n",
       " 'rxn00892',\n",
       " 'rxn00893',\n",
       " 'rxn00894',\n",
       " 'rxn00895',\n",
       " 'rxn00896',\n",
       " 'rxn00896',\n",
       " 'rxn00897',\n",
       " 'rxn00897',\n",
       " 'rxn00898',\n",
       " 'rxn00899',\n",
       " 'rxn00900',\n",
       " 'rxn00901',\n",
       " 'rxn00902',\n",
       " 'rxn00903',\n",
       " 'rxn00904',\n",
       " 'rxn00905',\n",
       " 'rxn00906',\n",
       " 'rxn00907',\n",
       " 'rxn00908',\n",
       " 'rxn00910',\n",
       " 'rxn00911',\n",
       " 'rxn00912',\n",
       " 'rxn00913',\n",
       " 'rxn00914',\n",
       " 'rxn00915',\n",
       " 'rxn00916',\n",
       " 'rxn00917',\n",
       " 'rxn00918',\n",
       " 'rxn00919',\n",
       " 'rxn00920',\n",
       " 'rxn00921',\n",
       " 'rxn00922',\n",
       " 'rxn00923',\n",
       " 'rxn00924',\n",
       " 'rxn00924',\n",
       " 'rxn00925',\n",
       " 'rxn00926',\n",
       " 'rxn00927',\n",
       " 'rxn00928',\n",
       " 'rxn00929',\n",
       " 'rxn00930',\n",
       " 'rxn00931',\n",
       " 'rxn00932',\n",
       " 'rxn00933',\n",
       " 'rxn00934',\n",
       " 'rxn00935',\n",
       " 'rxn00936',\n",
       " 'rxn00937',\n",
       " 'rxn00938',\n",
       " 'rxn00939',\n",
       " 'rxn00940',\n",
       " 'rxn00941',\n",
       " 'rxn00942',\n",
       " 'rxn00943',\n",
       " 'rxn00944',\n",
       " 'rxn00945',\n",
       " 'rxn00946',\n",
       " 'rxn00947',\n",
       " 'rxn00948',\n",
       " 'rxn00949',\n",
       " 'rxn00950',\n",
       " 'rxn00952',\n",
       " 'rxn00953',\n",
       " 'rxn00956',\n",
       " 'rxn00956',\n",
       " 'rxn00957',\n",
       " 'rxn00958',\n",
       " 'rxn00959',\n",
       " 'rxn00960',\n",
       " 'rxn00961',\n",
       " 'rxn00962',\n",
       " 'rxn00963',\n",
       " 'rxn00964',\n",
       " 'rxn00965',\n",
       " 'rxn00966',\n",
       " 'rxn00967',\n",
       " 'rxn00968',\n",
       " 'rxn00970',\n",
       " 'rxn00971',\n",
       " 'rxn00972',\n",
       " 'rxn00973',\n",
       " 'rxn00974',\n",
       " 'rxn00975',\n",
       " 'rxn00976',\n",
       " 'rxn00977',\n",
       " 'rxn00977',\n",
       " 'rxn00978',\n",
       " 'rxn00979',\n",
       " 'rxn00980',\n",
       " 'rxn00981',\n",
       " 'rxn00982',\n",
       " 'rxn00983',\n",
       " 'rxn00983',\n",
       " 'rxn00984',\n",
       " 'rxn00985',\n",
       " 'rxn00986',\n",
       " 'rxn00987',\n",
       " 'rxn00988',\n",
       " 'rxn00989',\n",
       " 'rxn00990',\n",
       " 'rxn00991',\n",
       " 'rxn00992',\n",
       " 'rxn00993',\n",
       " 'rxn00994',\n",
       " 'rxn00995',\n",
       " 'rxn00996',\n",
       " 'rxn00997',\n",
       " 'rxn00998',\n",
       " 'rxn00999',\n",
       " 'rxn01000',\n",
       " 'rxn01001',\n",
       " 'rxn01002',\n",
       " 'rxn01003',\n",
       " 'rxn01004',\n",
       " 'rxn01005',\n",
       " ...]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}