dG_prediction_modelseed_dev_branch.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "bc588d94",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd \n",
    "import numpy as np \n",
    "import json \n",
    "import pdb\n",
    "from tqdm import tqdm\n",
    "import re\n",
    "from PIL import Image\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": 5,
   "id": "bc4b66bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/gpfs/group/cdm8/default/vikas/dgtest/dGPredictor\r\n"
     ]
    }
   ],
   "source": [
    "!pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "ea1d9e0c",
   "metadata": {},
   "outputs": [],
   "source": [
    "json_fnames  = !ls ./../ModelSEEDDatabase/Biochemistry/*.json\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "1ab3f940",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 111/111 [00:00<00:00, 701156.24it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50\n",
      "61\n",
      "0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "Compound_fname_list = []\n",
    "Rxn_fname_list = []\n",
    "Others = []\n",
    "\n",
    "for fname in tqdm(json_fnames):\n",
    "    if \"compound\" in fname:\n",
    "        Compound_fname_list.append(fname)\n",
    "    elif \"reaction\" in fname:\n",
    "        Rxn_fname_list.append(fname)\n",
    "    else:\n",
    "        Others.append(fname)\n",
    "        \n",
    "\n",
    "print(len(Compound_fname_list))    \n",
    "print(len(Rxn_fname_list))\n",
    "print(len(Others))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b2c58011",
   "metadata": {},
   "outputs": [],
   "source": [
    "Rxn_f0 = Rxn_fname_list[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "5e878700",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "979"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "json_read = json.load(open(Rxn_f0))\n",
    "len(json_read)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "66a820db",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "979it [00:00, 301551.27it/s]\n"
     ]
    }
   ],
   "source": [
    "KEGG_id_ls = []\n",
    "mseed_rxn_id_ls = []\n",
    "\n",
    "for i, rxn in tqdm(enumerate(json_read)):\n",
    "    \n",
    "    try:\n",
    "        rxn_alias = rxn['aliases']\n",
    "        for ki in rxn_alias:\n",
    "            if 'KEGG' in ki:\n",
    "                kegg_id_str = ki\n",
    "        \n",
    "        KEGG_id = kegg_id_str.replace(' ', '').split(':')[1]\n",
    "        KEGG_id_ls.append(KEGG_id)\n",
    "        \n",
    "        mseed_rxn_id_ls.append(rxn['id'])\n",
    "    except:\n",
    "        KEGG_id_ls.append('No KEGG id')\n",
    "        mseed_rxn_id_ls.append(rxn['id'])\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "408b986a",
   "metadata": {},
   "outputs": [],
   "source": [
    "kegg_rxn_eqn = json.load(open('./data/KEGG_rxn_eqn_master_branch.json'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "dee18f46",
   "metadata": {},
   "outputs": [],
   "source": [
    "kegg_rxn_eqn_keys = list(kegg_rxn_eqn.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "aec83dcf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not in KEGG db:  R00016\n",
      "Not in KEGG db:  R00064\n",
      "Not in KEGG db:  R00419\n",
      "Not in KEGG db:  R00687\n",
      "Not in KEGG db:  R00979\n",
      "Not in KEGG db:  R01118\n",
      "Not in KEGG db:  R01285\n"
     ]
    }
   ],
   "source": [
    "for i in KEGG_id_ls:\n",
    "    temp = i.split(';')\n",
    "    if len(temp) == 1:\n",
    "        if i not in kegg_rxn_eqn_keys:\n",
    "            print('Not in KEGG db: ', i)\n",
    "    else:\n",
    "        for j in temp:\n",
    "            if j not in kegg_rxn_eqn_keys:\n",
    "                print(j)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48af0611",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "5it [05:57, 73.21s/it] "
     ]
    }
   ],
   "source": [
    "dG_dict = {}\n",
    "pH = 7.0\n",
    "I = 0.25\n",
    "\n",
    "for ix, mseed in tqdm(enumerate(mseed_rxn_id_ls)):\n",
    "    kid = KEGG_id_ls[ix]\n",
    "    multipleKEGG = kid.split(';')      ## split if there are multiple kegg ids associated with a single mseed reaction \n",
    "    \n",
    "    temp_dict = {}\n",
    "    for krxn in multipleKEGG:\n",
    "        try:\n",
    "            reqn = kegg_rxn_eqn[krxn]\n",
    "            mu, CI = get_dG0_only(kegg_rxn_eqn[krxn], krxn, pH, I, loaded_model, molsig_r1, molsig_r2, [], [], [])\n",
    "            temp_dict[krxn] = {'dG': mu, 'dG_ConfidenceInterval': CI}\n",
    "        except:\n",
    "            temp_dict[krxn] = {'dG': np.NaN, 'dG_ConfidenceInterval': np.NaN}\n",
    "    \n",
    "    dG_dict[mseed] = temp_dict\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "02e9dc4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C00166 + C00007 <=> C05852 + C00011'"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kegg_rxn_eqn[krxn]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "2d73fb52",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C00166 + C00007 <=> C05852 + C00011'"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kegg_rxn_eqn[krxn]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "36a25c3c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-429.1163856827397, 1.159507915559245)"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_dG0_only(parse_formula(kegg_rxn_eqn[krxn]), krxn, pH, I, loaded_model, molsig_r1, molsig_r2, [], [], [])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "b4e68b56",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'R01372'"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6e0fe5b8",
   "metadata": {},
   "source": [
    "# loading dG functions and model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "f5512f95",
   "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",
    "\n",
    "\n",
    "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",
    "\n",
    "\n",
    "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",
    "\n",
    "\n",
    "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",
    "\n",
    "\n",
    "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))\n",
    "\n",
    "\n",
    "\n",
    "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\n",
    "\n",
    "\n",
    "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\n",
    "\n",
    "\n",
    "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",
    "    CI = (ystd[0]*1.96)/np.sqrt(4001)\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), ystd[0], CI , rule_df1, rule_df2\n",
    "    # return ymean[0],ystd[0]\n",
    "    \n",
    "    \n",
    "\n",
    "def get_dG0_only(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",
    "    CI = (ystd[0]*1.96)/np.sqrt(4001)\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), CI\n",
    "    # return ymean[0],ystd[0]\n",
    "\n",
    "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",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c2dcc2e4",
   "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()"
   ]
  }
 ],
 "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": 5
}