QMiBi_GSMM-cobrapy_L1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/uliebal/RWTH-QMB1/blob/master/2001_GSMM_cobrapy_QuantMiBi.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_XiYNRBT5sFj"
   },
   "source": [
    "# Seminar Quantitative Mikrobiologie: Hands-on simulation genome scale metabolic models\n",
    "## Introduction\n",
    "\n",
    "The seminar provides a guide of how to work with genome scale metabolic models (GSMM) of micro-organisms. The example organism we use is *E. coli*, for which reliable models are available in online databases. The goal is to get insight into flux distributions and general metabolic state as well as to find flux solutions that represent the highest possible over-produce of a metabolite, in our example succinate.\n",
    "\n",
    "The seminar uses Jupyter notebooks, a new way to use and visualize code in the web. Such a notebook is composed of a sequence of cells. Cellls can be either text/comments, like this introduction, or it contains python code to be run. In this example the code is evaluated by the cloud service [Binder](https://mybinder.org/). The output for each code-cell is shown directly below it. For a overview on Jupyter notebooks read [this review](https://www.nature.com/articles/d41586-018-07196-1). Another usefull resource to develop Jupyter notebooks is via [Google Colaboration](https://colab.research.google.com).\n",
    "\n",
    "The content of the seminar is adapted from a tutorial by the project Data-Driven Design of Cell Factories and Communities (DD-DeCaF) as well as workshop information available [here](https://biosustain.github.io/cell-factory-design-course/). More information on DD-DeDaF and the original files are [here](https://github.com/DD-DeCaF/tutorials). The simulations are performed using cobrapy (see [Ebrahim et al., 2013](https://doi.org/10.1186/1752-0509-7-74)), the most widely used analysis tool for genome scale metabolic models.\n",
    "\n",
    "**The steps of this tutorial are:**\n",
    " * [Set-up compute environment](#Python-setup)\n",
    "   * loading programs for analysis (data analysis, plotting, cobrapy, escher)\n",
    "   * downloading *E. coli* GSMM (iJO1366)\n",
    " * [Model Analysis](#Model-Analysis)\n",
    "   * loading the model into cobrapy\n",
    "   * examining model structure and details (metabolites, reactions, medium)\n",
    "   * solving reaction flux distribution for optimal growth\n",
    "   * investigating reaction statistics within the solution (NADH and ATP turnover)\n",
    "   * visualizing flux activities in metabolic network\n",
    " * [Model Manipulation](#Model-Manipulation)\n",
    "   * setting new objective function\n",
    "   * visualizing optimal succinate flux distribution\n",
    "   * generating production envelope for the effect of growth rate on succinate production rate\n",
    " \n",
    "\n",
    "**Skills you learn:**\n",
    "* Familiarizing with Jupyter notebooks\n",
    "* Retrieving genome scale model files\n",
    "* Manipulating and Simulating GSMM with cobrapy   \n",
    "\n",
    "\n",
    "**Practical comments:**\n",
    "* In some code cells you are supposed to enter input. The location at which input is required is marked by ''**?...?**''.\n",
    "\n",
    "* Comments to explain details in the code bock are written with a hash **plus blank**. \n",
    "Alternative commands and commands providing somewhat more detailed information are deactivated with a hash **without blank**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "J5iOaouMfopo"
   },
   "source": [
    "## 1 Set-up compute environment <a id='Python-setup'></a>\n",
    "\n",
    "Before we can analyse GSMM, we have adjust the python environment that it integrates the cobrapy toolbox and downloading the GSMM."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DEvLgrLm9EOG"
   },
   "source": [
    "### 1.1 Basic Python libraries \n",
    "Some libraries that facilitate data manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Qi9yV4bm9JpE"
   },
   "outputs": [],
   "source": [
    "import sys # loading commands to control/navigate within the system architecture\n",
    "# Loading pandas, a library for data manipulation\n",
    "import pandas as pd\n",
    "\n",
    "# Loading numpy, a library fo manipulation of numbers\n",
    "import numpy as np\n",
    "\n",
    "# loading matplotlib, a library for visualization\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "# loading cobrapy, a library dedicated to the analysis of genome scale metabolic models\n",
    "from cobra.io import read_sbml_model\n",
    "from cobra.util import create_stoichiometric_matrix\n",
    "from cobra.flux_analysis import production_envelope\n",
    "\n",
    "# loading Escher for metabolic pathway visualization\n",
    "import escher\n",
    "from escher import Builder\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "boR9WTVXio4f"
   },
   "source": [
    "### 1.2 GSMM Download from BIGG\n",
    "\n",
    "[BiGG](https://doi.org/10.1186/1471-2105-11-213) is a knowledgebase of Biochemically, Genetically and Genomically structured genome-scale metabolic network reconstructions. BiGG integrates several published genome-scale metabolic networks into one resource with standard nomenclature which allows components to be compared across different organisms. BiGG can be used to browse model content, visualize metabolic pathway maps, and export SBML files of the models for further analysis by external software packages. Users may follow links from BiGG to several external databases to obtain additional information on genes, proteins, reactions, metabolites and citations of interest.\n",
    "\n",
    "In the following we download the *E. coli* model iJO1366 ([Orth et al., 2011](http://dx.doi.org/10.1038/msb.2011.65)), as well as the visualization JSON file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Ayk-ws_F0g5n"
   },
   "outputs": [],
   "source": [
    "!wget http://bigg.ucsd.edu/static/models/iJO1366.xml.gz\n",
    "\n",
    "# list of available maps\n",
    "escher.list_available_maps() \n",
    "\n",
    "# loading a visualization file of the metabolic network. \n",
    "# For frequently used models, like iJO1366, Escher automatically retrieves the visualization file.  \n",
    "#!wget http://bigg.ucsd.edu/static/models/iJO1366.json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kydPvEnWjgK1"
   },
   "source": [
    "## 2. Model Analysis <a id='Model-Analysis'></a>\n",
    "\n",
    "First we have a look at general features of the model. Then we check which reaction is optimized and perform a simulation to find the optimal flux distribution to maximize the optimized reaction."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "kACRk6bUkPuu"
   },
   "source": [
    "### 2.1 Inspection of model features"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "QIfWKtApmfgj"
   },
   "source": [
    "Converting the GSMM file from the BIGG database into the 'model' data-structure that can be evaluated by the cobrapy toolbox. Just calling the variable 'model' shows some basic features of the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5MWD8v28z30_"
   },
   "outputs": [],
   "source": [
    "# generating cobra variable from SBML/xml file\n",
    "model = read_sbml_model('iJO1366.xml.gz')\n",
    "model\n",
    "\n",
    "# Display model objective (a reverse reaction is present as well, just for mathematical reasons)\n",
    "#print(model.objective)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "aczhIFJC1qo9"
   },
   "source": [
    "Generate a visualization of the stoichiometric matrix.\n",
    "\n",
    "* What do you see on x-axis, y-axis? Complete the code!\n",
    "* Why do the first few hundred columns look different?\n",
    "* What are the connected diagonal rows?\n",
    "* What do highly colored horizontal/vertical lines represent?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "jETqvMPa1uZ2"
   },
   "outputs": [],
   "source": [
    "stoich_matrix = create_stoichiometric_matrix(model)\n",
    "plt.spy(stoich_matrix, precision=0.01, markersize=.2)\n",
    "\n",
    "plt.xlabel('?..?');\n",
    "plt.ylabel('?..?');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Medium composition\n",
    "\n",
    "Before simulating a model, familiarize yourself with the medium composition. The medium composition defines which metabolites can be exchanged with the environment.\n",
    "\n",
    " -  What is the carbon source and the associated uptake rate in mmol/gCDW/h?\n",
    " -  Are the protons (h_e) consumed or produced in *E. coli*?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Medium components:\\n')\n",
    "print('{:<15} {:<8}'.format('Reaction','Magnitude'))\n",
    "[print('{:<15} {:<8}'.format(keys, val)) for keys,val in model.medium.items()];"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "j6DhooOirvqr"
   },
   "source": [
    "### Details to metabolite glyceraldehyde-3-phosphate\n",
    "\n",
    "In the following we extract information of cytoplasmic glyceraldehyde-3-phosphate.\n",
    "Finding metabolites that contain 'g3p_c'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "071vAEIov7mF"
   },
   "outputs": [],
   "source": [
    "model.metabolites.query('g3p_c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ra9noHxBr0pd"
   },
   "source": [
    "More specific information"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "IcU6K5Xoq5WF"
   },
   "outputs": [],
   "source": [
    "model.metabolites.get_by_id('g3p_c')\n",
    "\n",
    "# displays all reactions associated with g3p_c\n",
    "#model.metabolites.g3p_c.reactions\n",
    "# dot notation only works for 'proper' variable names, i.e. not for names starting with numbers (e.g. 10fthf_c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6cJEODhfsUeW"
   },
   "source": [
    "Explicit list of reactions with reactants"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9cujzjsBsaUe"
   },
   "outputs": [],
   "source": [
    "for reaction in model.metabolites.g3p_c.reactions:\n",
    "    print(reaction, reaction.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "r-iTdtzBtez8"
   },
   "source": [
    "Investigating a particular reaction: GAPD\n",
    "\n",
    "GPR shows the 'Gene-Protein-Reaction' relationship, i.e. it shows an ID for a gene."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "FsLRzVTXtibU"
   },
   "outputs": [],
   "source": [
    "model.reactions.GAPD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "ssAaIxcAnLXt"
   },
   "source": [
    "### 2.2 Simulation of optimal growth"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "lnoHdnOE4MW0"
   },
   "outputs": [],
   "source": [
    "# displaying which solver is used to perform FBA\n",
    "#model.solver\n",
    "\n",
    "solution = model.optimize()\n",
    "print('Growth rate: {:.2f}'.format(solution.objective_value))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "qXAdkcXQ5dTD"
   },
   "source": [
    "Models solved using FBA can be further analyzed by using summary methods, which output printed text to give a quick representation of model behavior. Calling the summary method on the entire model displays information on the input and output behavior of the model, along with the optimized objective.\n",
    "\n",
    "* Check which medium components were not used for growth.\n",
    "* Check which substrate was limiting growth.\n",
    "* What is the metabolic mode used for catabolism? (fermentation, Glycolysis+TCA)\n",
    "* What is the major source of NADH/ATP?\n",
    "* What is the major sink of NADH/ATP?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "NWHpKEmM5fzP"
   },
   "outputs": [],
   "source": [
    "model.summary()\n",
    "\n",
    "# information for specific reactions\n",
    "#solution.fluxes.BIOMASS_Ec_iJO1366_core_53p95M\n",
    "#solution.fluxes.ATPM"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "_CYfTRQq5-PN"
   },
   "source": [
    "In addition, the input-output behavior of individual metabolites can also be inspected using summary methods. For instance, the following commands can be used to examine the overall redox balance of the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "QyIbxcxH6BiH"
   },
   "outputs": [],
   "source": [
    "model.metabolites.nadh_c.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sdELSxCR6Q7P"
   },
   "source": [
    "Or to get a sense of the main energy production and consumption reactions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "5AunmY3e6RmD"
   },
   "outputs": [],
   "source": [
    "model.metabolites.atp_c.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vMLajfXXQEzG"
   },
   "source": [
    "### 2.3 Visualization\n",
    "\n",
    "Escher is a web-based tool for building, viewing, and sharing visualizations of biological pathways. These 'pathway maps' are a great way to contextualize data about metabolism. In this example the maps are directly exported as html-file.\n",
    "\n",
    "Best help [here](https://escher.readthedocs.io/en/latest/escher-python.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-wAeRsXJQI6e"
   },
   "outputs": [],
   "source": [
    "builder = Builder()\n",
    "# Load an Escher map\n",
    "builder.map_name = 'iJO1366.Central metabolism'\n",
    "builder.model = model\n",
    "builder.reaction_data = solution.fluxes\n",
    "# Add some data for metabolites\n",
    "#builder.metabolite_data = solution.shadow_prices\n",
    "# Simplify the map by hiding some labels\n",
    "builder.hide_secondary_metabolites = True\n",
    "#builder.hide_all_labels = True\n",
    "builder.reaction_scale = [\n",
    "    { 'type': 'min', 'color': '#000000', 'size': 12 },\n",
    "    { 'type': 'median', 'color': '#ffffff', 'size': 20 },\n",
    "    { 'type': 'max', 'color': '#ff0000', 'size': 25 }\n",
    "]\n",
    "builder.reaction_scale_preset = 'GaBuRd'\n",
    "\n",
    "# Make all the arrows three times as thick\n",
    "builder.reaction_scale = [\n",
    "    {k: v * 3 if k == 'size' else v for k, v in x.items()}\n",
    "    for x in builder.reaction_scale\n",
    "]\n",
    "builder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sI9W_vTi_LAw"
   },
   "source": [
    "## 3. Model Manipulation <a id='Model-Manipulation'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "2pbYhxox81cM"
   },
   "source": [
    "### 3.1 Setting new objective\n",
    "\n",
    "The objective function is determined from the objective_coefficient attribute of the objective reaction(s). Generally, a “biomass” function which describes the composition of metabolites which make up a cell is used.\n",
    "\n",
    "The objective function can be changed by assigning Model.objective, which can be a reaction object (or just it’s name)\n",
    "\n",
    "* Complete the code! (2x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "hoyWMiuz9Ue7"
   },
   "outputs": [],
   "source": [
    "# copy model for changes to succinate\n",
    "SucModel = model.copy()\n",
    "\n",
    "# change objective to the synthesis of succinate\n",
    "SucModel.objective = SucModel.reactions.EX_succ_e\n",
    "\n",
    "# Because biomass is not anymore optimized, the biomass reactions will be zero for optimization to succinate because it only drains the result.\n",
    "# Assuming that there is still some growth occuring, we raise the lower boundary for the growth reaction\n",
    "SucModel.reactions.get_by_id('BIOMASS_Ec_iJO1366_core_53p95M').lower_bound = ?..?\n",
    "\n",
    "# storing the simulation in a variable\n",
    "Suc_Solution = SucModel.optimize()\n",
    "\n",
    "# print overview of exchange reactions\n",
    "?...?.summary()\n",
    "#SucModel.reactions.ATPM.flux\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "BTV32gOyTN5e"
   },
   "source": [
    "### 3.2 Visualization of succinate optimized flux distribution\n",
    "\n",
    "The optimization of succinate from glucose shows a theoretical conversion mechanism. Let's visualize the optmized reaction fluxes in Escher.\n",
    "\n",
    "* Complete the code!\n",
    "* Describe similarities and differences of the metabolism for succinate production compared to growth."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "fd070k8SWUxC"
   },
   "outputs": [],
   "source": [
    "builder.reaction_data = ?...?.fluxes \n",
    "builder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "MHp_d657VTBk"
   },
   "source": [
    "### 3.3 Generating production envelopes\n",
    "Production envelopes (aka phenotype phase planes) will show distinct phases of optimal growth with different use of two different substrates. For more information, see [Edwards et al.](http://dx.doi.org/10.1002/bit.10047).\n",
    "\n",
    "* Complete the code! (2x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "JX4ggZgqTBHw"
   },
   "outputs": [],
   "source": [
    "# setting lowest growth boundary back to '0'\n",
    "SucModel.reactions.get_by_id('BIOMASS_Ec_iJO1366_core_53p95M').lower_bound = 0.\n",
    "\n",
    "# Calculation of production envelope \n",
    "prod_env = production_envelope(SucModel, reactions=SucModel.reactions.BIOMASS_Ec_iJO1366_core_53p95M, \n",
    "                               objective=SucModel.reactions.EX_succ_e)\n",
    "prod_env.head(3)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "9SHFRnWdM4jc"
   },
   "outputs": [],
   "source": [
    "# Visualization\n",
    "plt.plot(prod_env['BIOMASS_Ec_iJO1366_core_53p95M'], prod_env['carbon_yield_maximum'], color='blue', linestyle='solid', linewidth=2)\n",
    "plt.xlabel('?...?');\n",
    "plt.ylabel('?...?');\n",
    "plt.title('Production Envelope of Succinate for different growth rates');\n",
    "\n",
    "# save figure in Jupyter notebook\n",
    "plt.savefig('production-envelope_suc-growth.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Enit3zYyyiu7"
   },
   "source": [
    "## Further Tasks\n",
    "\n",
    "An equally important organism for biotechnology is *S. cerevisiae* with one of the main models called iMM904. Your goal is to visualize the effect of different oxygen uptake rates on the growth rate. This can be achieved using the production envelope if you plot growth as dependent variable against oxygen exchange (uptake rate/ transport). \n",
    "\n",
    "1.   Find the iMM904 model in the BIGG database.\n",
    "2.   Extract the map name from Escher for visualization.\n",
    "3.   Check growth on glucose and visualize the fluxes.\n",
    "4.   Use the production envelope command to check the dependence of growth on oxygen uptake.\n",
    "  * Identify the reaction name for the oxygen exchange reaction.\n",
    "  * Use as 'objective' the default biomass reaction and as 'reactions' the oxygen exchange reaction.\n",
    "  * For plotting, examine the column header names in 'prod_env'.\n",
    "  * Is the resulting graph visually appealing? Try using np.abs(prod_env['?...?']) to improve the figure."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Z1suWfKNaUqK"
   },
   "source": [
    "# Further Literature\n",
    "\n",
    "## Details to Jupyter education\n",
    "The following sites provide guides to using Jupyter notebooks for educational means:\n",
    " * https://jupyter4edu.github.io/jupyter-edu-book/index.html\n",
    " * https://github.com/jperkel/example_notebook\n",
    " * https://github.com/jupyter/jupyter/wiki/A-gallery-of-interesting-Jupyter-Notebooks#mathematics-physics-chemistry-biology\n",
    " * https://github.com/binder-examples/\n",
    " * https://nbviewer.jupyter.org/\n",
    " * https://jupyter.readthedocs.io/en/latest/index.html\n",
    " * https://jakevdp.github.io/blog/2017/12/05/installing-python-packages-from-jupyter/\n",
    " * https://matplotlib.org/index.html\n",
    "\n",
    "## more on cobrapy:\n",
    " * https://opencobra.github.io/cobrapy/\n",
    " * https://cobrapy.readthedocs.io/en/latest/getting_started.html\n",
    " * https://github.com/DD-DeCaF/tutorials\n",
    " * https://biosustain.github.io/cell-factory-design-course/\n",
    "\n",
    "## Escher Documentation:\n",
    " * https://escher.readthedocs.io/en/v1.2.0/index.html\n",
    " * https://github.com/zakandrewking/escher/blob/master/docs/notebooks/COBRApy%20and%20Escher.ipynb\n",
    " * https://github.com/DD-DeCaF/tutorials/blob/master/escher-01.ipynb\n",
    "\n",
    "## further material with cameo:\n",
    " * https://github.com/DD-DeCaF/tutorials\n",
    " * https://biosustain.github.io/cell-factory-design-course/\n",
    " * https://try.cameo.bio/user/M6JFMnvW35Vz/tree\n",
    " * !pip install cameo"
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "2001_GSMM-cobrapy_QuantMiBi.ipynb",
   "provenance": [],
   "toc_visible": true
  },
  "kernelspec": {
   "display_name": "Python 3",
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}