{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MaBoSS Client-Server example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-08-02T11:18:34.502186Z",
     "iopub.status.busy": "2024-08-02T11:18:34.501873Z",
     "iopub.status.idle": "2024-08-02T11:18:35.628508Z",
     "shell.execute_reply": "2024-08-02T11:18:35.627939Z",
     "shell.execute_reply.started": "2024-08-02T11:18:34.502166Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<script type=\"text/javascript\" id=\"colomoto-setup-1542818\" class=\"to-be-removed\">\n",
       "        if (typeof Jupyter != 'undefined') {\n",
       "            \n",
       "function detect_import(cell, module) {\n",
       "    var code = cell.get_text();\n",
       "    code = code.replace(/\\\\\\n/g, \"\");\n",
       "    var lines = code.split(\"\\n\");\n",
       "    var r_simple = new RegExp(\"^(\"+module+\")$\");\n",
       "    var r_alias = new RegExp(\"^\"+module+\"\\\\s+as\\\\s+(\\\\w+)$\");\n",
       "    for (var i = 0; i < lines.length; ++i) {\n",
       "        if (/^import\\s/.test(lines[i])) {\n",
       "            code = lines[i].substr(7);\n",
       "            var parts = code.split(\",\")\n",
       "            for (var j = 0; j < parts.length; ++j) {\n",
       "                code = parts[j].trim();\n",
       "                var m = code.match(r_simple);\n",
       "                if (!m) {\n",
       "                    m = code.match(r_alias);\n",
       "                }\n",
       "                if (m) {\n",
       "                    return m[1];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "    return module;\n",
       "}\n",
       "\n",
       "function colomoto_replace_call(cell, orig, dest, args, comment=false) {\n",
       "    var call_regexp = new RegExp(\"\\\\.\"+orig.replace(\".\",\"\\\\.\")+\"\\\\(\");\n",
       "    var call_replacer = new RegExp(\"\\\\.\"+orig.replace(\".\",\"\\\\.\")\n",
       "                    + \"\\\\(\\\\s*([^\\\\)]*)?\\\\)\");\n",
       "    var code = cell.get_text();\n",
       "    var lines = code.split(\"\\n\");\n",
       "    if (args) {\n",
       "        var strargs = \", \"+args.join(\", \");\n",
       "    } else {\n",
       "        var strargs = \"\";\n",
       "    }\n",
       "    for (var i = 0; i < lines.length; ++i) {\n",
       "        if (call_regexp.test(lines[i])) {\n",
       "            var code = \"\"\n",
       "            if (comment) {\n",
       "                code += \"#\"+lines[i]+\"\\n\";\n",
       "            }\n",
       "            code += lines[i].replace(call_replacer, \".\"+dest+\"($1\"+strargs+\")\")\n",
       "            lines[i] = code;\n",
       "        }\n",
       "    }\n",
       "    cell.set_text(code)\n",
       "}\n",
       "\n",
       "function colomoto_upload(Jupyter, ssid, input, py_callback_name, orig, dest) {\n",
       "\n",
       "    function callback(out_data) {\n",
       "        var cell_element = $(\"#\"+ssid).parents('.cell');\n",
       "        var cell_idx = Jupyter.notebook.get_cell_elements().index(cell_element);\n",
       "        var cell = Jupyter.notebook.get_cell(cell_idx);\n",
       "\n",
       "        var filename = out_data.content.text;\n",
       "\n",
       "        var code = cell.get_text();\n",
       "        code = code.replace(new RegExp(\"\\\\b\" + orig.replace('.', '\\\\.')\n",
       "                    + \"\\\\(\\\\s*((\\\\w+)=[^\\\\)]*)?\\\\)\"),\n",
       "                dest+\"(\\\"\"+filename+\"\\\",$1)\");\n",
       "        code = code.replace('\",)', '\")')\n",
       "        cell.set_text(code);\n",
       "\n",
       "        Jupyter.notebook.select(cell_idx);\n",
       "        Jupyter.notebook.execute_cell_and_select_below();\n",
       "    }\n",
       "\n",
       "    if (! (window.File && window.FileReader && window.FileList && window.Blob)) {\n",
       "        alert(\"Interactive file upload is not supported by your browser.\");\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    input.disabled = true;\n",
       "    input.style.cursor = \"wait\";\n",
       "    input.parentElement.style.cursor = \"wait\";\n",
       "\n",
       "    var f = input.files[0];\n",
       "    var reader = new FileReader();\n",
       "    reader.onload = (function(f) {\n",
       "        return function (e) {\n",
       "            var obj = {\n",
       "                content: e.target.result,\n",
       "                name: f.name\n",
       "            };\n",
       "\n",
       "            //var pycb = py_callback_name+\"(\"+JSON.stringify(obj)+\")\"\n",
       "            // hack/workaround:\n",
       "            // it seems that Jupyter does not like very long lines\n",
       "            // so we split the data in chunks\n",
       "            var chunk_length = 100;\n",
       "            var pycb = \"__colomoto_upload_name = \" + JSON.stringify(obj.name) + \"\\n\";\n",
       "            pycb += \"__colomoto_upload_content = \\\\\\n\";\n",
       "            for (var i = 0; i < obj.content.length; i += chunk_length) {\n",
       "                pycb += \"\\\"\" + obj.content.substr(i, chunk_length)+\"\\\"\\\\\\n\"\n",
       "            }\n",
       "            pycb += \"\\n\"\n",
       "            pycb += py_callback_name+\"({'name':__colomoto_upload_name, 'content': __colomoto_upload_content})\\n\";\n",
       "            pycb += \"del __colomoto_upload_name, __colomoto_upload_content\"\n",
       "\n",
       "            IPython.notebook.kernel.execute(pycb, {iopub: {output: callback}});\n",
       "        };\n",
       "    })(f);\n",
       "    reader.readAsDataURL(f);\n",
       "}\n",
       "\n",
       "function resolve_function(tool_api, funcname) {\n",
       "    if (tool_api.hasOwnProperty(funcname)) {\n",
       "        return tool_api[funcname];\n",
       "    } else {\n",
       "        return window[funcname];\n",
       "    }\n",
       "}\n",
       "\n",
       "function colomoto_extension(Jupyter, ssid, name, menu, toolbar, tool_api) {\n",
       "\n",
       "    function insert_snippet_code(snippet) {\n",
       "        var cell = Jupyter.notebook.get_selected_cell();\n",
       "        Jupyter.notebook.edit_mode();\n",
       "        cell.code_mirror.replaceSelection(snippet, 'around');\n",
       "        //cell.focus_editor();\n",
       "    }\n",
       "\n",
       "    /**\n",
       "        from https://github.com/moble/jupyter_boilerplate/blob/master/main.js\n",
       "    */\n",
       "    function callback_insert_snippet (evt) {\n",
       "        // this (or event.currentTarget, see below) always refers to the DOM\n",
       "        // element the listener was attached to - see\n",
       "        // http://stackoverflow.com/questions/12077859\n",
       "        insert_snippet_code($(evt.currentTarget).data('snippet-code'));\n",
       "    }\n",
       "    function build_menu_element (menu_item_spec, direction) {\n",
       "        // Create the menu item html element\n",
       "        var element = $('<li/>');\n",
       "\n",
       "        if (typeof menu_item_spec == 'string') {\n",
       "            if (menu_item_spec != '---') {\n",
       "                return element.html(menu_item_spec)\n",
       "                        .addClass('ui-state-disabled')\n",
       "                        .attr({\"style\": \"padding:2px .4em\"})\n",
       "                       ;\n",
       "            }\n",
       "            return element.addClass('divider');\n",
       "        }\n",
       "\n",
       "        var a = $('<a/>')\n",
       "            .attr('href', '#')\n",
       "            .html(menu_item_spec.name)\n",
       "            .appendTo(element);\n",
       "        if (menu_item_spec.hasOwnProperty('snippet')) {\n",
       "            var snippet = menu_item_spec.snippet;\n",
       "            if (typeof snippet == 'string' || snippet instanceof String) {\n",
       "                snippet = [snippet];\n",
       "            }\n",
       "            a.attr({\n",
       "                'title' : \"\", // Do not remove this, even though it's empty!\n",
       "                'data-snippet-code' : snippet.join('\\n'),\n",
       "            })\n",
       "            .on('click', callback_insert_snippet)\n",
       "            .addClass('snippet');\n",
       "        }\n",
       "        else if (menu_item_spec.hasOwnProperty('internal-link')) {\n",
       "            a.attr('href', menu_item_spec['internal-link']);\n",
       "        }\n",
       "        else if (menu_item_spec.hasOwnProperty('external-link')) {\n",
       "            a.empty();\n",
       "            a.attr('href', menu_item_spec['external-link']);\n",
       "            a.attr({\n",
       "                'target' : '_blank',\n",
       "                'title' : 'Opens in a new window',\n",
       "            });\n",
       "            $('<i class=\"fa fa-external-link menu-icon pull-right\"/>').appendTo(a);\n",
       "            $('<span/>').html(menu_item_spec.name).appendTo(a);\n",
       "        }\n",
       "\n",
       "        if (menu_item_spec.hasOwnProperty('sub-menu')) {\n",
       "            element\n",
       "                .addClass('dropdown-submenu')\n",
       "                .toggleClass('dropdown-submenu-left', direction === 'left');\n",
       "            var sub_element = $('<ul class=\"dropdown-menu\"/>')\n",
       "                .toggleClass('dropdown-menu-compact', menu_item_spec.overlay === true) // For space-saving menus\n",
       "                .appendTo(element);\n",
       "\n",
       "            var new_direction = (menu_item_spec['sub-menu-direction'] === 'left') ? 'left' : 'right';\n",
       "            for (var j=0; j<menu_item_spec['sub-menu'].length; ++j) {\n",
       "                var sub_menu_item_spec = build_menu_element(menu_item_spec['sub-menu'][j], new_direction);\n",
       "                if(sub_menu_item_spec !== null) {\n",
       "                    sub_menu_item_spec.appendTo(sub_element);\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "\n",
       "        return element;\n",
       "    }\n",
       "\n",
       "    function menu_setup (menu_item_specs, sibling, insert_before_sibling) {\n",
       "        for (var i=0; i<menu_item_specs.length; ++i) {\n",
       "            var menu_item_spec;\n",
       "            if (insert_before_sibling) {\n",
       "                menu_item_spec = menu_item_specs[i];\n",
       "            } else {\n",
       "                menu_item_spec = menu_item_specs[menu_item_specs.length-1-i];\n",
       "            }\n",
       "            var direction = (menu_item_spec['menu-direction'] == 'left') ? 'left' : 'right';\n",
       "            var menu_element = build_menu_element(menu_item_spec, direction);\n",
       "            // We need special properties if this item is in the navbar\n",
       "            if ($(sibling).parent().is('ul.nav.navbar-nav')) {\n",
       "                menu_element\n",
       "                    .addClass('dropdown')\n",
       "                    .removeClass('dropdown-submenu dropdown-submenu-left');\n",
       "                menu_element.children('a')\n",
       "                    .addClass('dropdown-toggle')\n",
       "                    .attr({\n",
       "                        'id': name+'_menu',\n",
       "                        'data-toggle' : 'dropdown',\n",
       "                        'aria-expanded' : 'false'\n",
       "                    });\n",
       "            }\n",
       "\n",
       "            // Insert the menu element into DOM\n",
       "            menu_element[insert_before_sibling ? 'insertBefore': 'insertAfter'](sibling);\n",
       "        }\n",
       "    }\n",
       "    /** end from */\n",
       "\n",
       "\n",
       "    function self_cleanup() {\n",
       "        var cell_element = $(\"script[class='to-be-removed']\").parents('.cell');\n",
       "        var cell_idx = Jupyter.notebook.get_cell_elements().index(cell_element);\n",
       "        var cell = Jupyter.notebook.get_cell(cell_idx);\n",
       "        var to_remove = -1;\n",
       "        for (var i = 0; i < cell.output_area.outputs.length; ++i) {\n",
       "            var oa = cell.output_area.outputs[i];\n",
       "            if (oa.output_type == \"display_data\"\n",
       "                && typeof oa.data[\"text/html\"] != 'undefined'\n",
       "                && oa.data[\"text/html\"].indexOf(' class=\"to-be-removed\"') >= 0) {\n",
       "                to_remove = i;\n",
       "                break;\n",
       "            }\n",
       "        }\n",
       "        if (to_remove == -1) {\n",
       "            console.log(\"cannot find toberemoved\");\n",
       "        } else {\n",
       "            cell.output_area.outputs.splice(to_remove, 1);\n",
       "        }\n",
       "    }\n",
       "\n",
       "    function toolbar_setup(actions) {\n",
       "        var buttons = [];\n",
       "        for (var i = 0; i < actions.length; ++i) {\n",
       "            var setup = actions[i].setup;\n",
       "            if (typeof setup.handler == 'string') {\n",
       "                setup.handler = resolve_function(tool_api, setup.handler);\n",
       "            }\n",
       "            buttons.push(Jupyter.actions.register(actions[i].setup,\n",
       "                actions[i].name, name));\n",
       "        }\n",
       "        $(\"#\"+name+\"-toolbar\").remove();\n",
       "        Jupyter.toolbar.add_buttons_group(buttons, name+\"-toolbar\");\n",
       "    }\n",
       "\n",
       "    function replace_menu_snippets(menu_spec, orig, dest) {\n",
       "        if (menu_spec.hasOwnProperty(\"snippet\")) {\n",
       "            var snippet = menu_spec.snippet;\n",
       "            if (typeof snippet == \"string\" || snippet instanceof String) {\n",
       "                menu_spec[\"snippet\"] = snippet.replace(orig, dest);\n",
       "            } else {\n",
       "                for (var i = 0; i < snippet.length; ++i) {\n",
       "                    menu_spec[\"snippet\"][i] = snippet[i].replace(orig, dest);\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "        if (menu_spec.hasOwnProperty(\"sub-menu\")) {\n",
       "            for (var i = 0; i < menu_spec[\"sub-menu\"].length; ++i) {\n",
       "                replace_menu_snippets(menu_spec[\"sub-menu\"][i], orig, dest);\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "\n",
       "    function load_ipython_extension() {\n",
       "\n",
       "        var mycellelt = $(\"#\"+ssid).parents('.cell');\n",
       "        var myidx = Jupyter.notebook.get_cell_elements().index(mycellelt);\n",
       "        var import_cell = Jupyter.notebook.get_cell(myidx);\n",
       "\n",
       "        var alias = detect_import(import_cell, name);\n",
       "        tool_api.module_alias = alias;\n",
       "        if (alias && alias != name) {\n",
       "            var orig = new RegExp(\"\\\\b\"+name+\"\\\\b\", \"g\");\n",
       "            replace_menu_snippets(menu, orig, alias);\n",
       "        }\n",
       "\n",
       "        if (toolbar) {\n",
       "            toolbar_setup(toolbar);\n",
       "        }\n",
       "\n",
       "        $(\"#\"+name+\"_menu\").parent().remove();\n",
       "        if (menu) {\n",
       "            menu_setup([menu], $(\"#help_menu\").parent(), true);\n",
       "        }\n",
       "\n",
       "        if (tool_api.hasOwnProperty(\"post_install_callback\")) {\n",
       "            tool_api.post_install_callback();\n",
       "        }\n",
       "\n",
       "        setTimeout(self_cleanup, 5000);\n",
       "    };\n",
       "\n",
       "    load_ipython_extension();\n",
       "}\n",
       "\n",
       "function resolve_toolbar_handlers(tool_api, toolbar_spec) {\n",
       "    for (var i = 0; i < toolbar_spec.length; ++i) {\n",
       "        func = resolve_function(tool_api, toolbar_spec[i][\"setup\"][\"handler\"]);\n",
       "        toolbar_spec[i][\"setup\"][\"handler\"] = func;\n",
       "    }\n",
       "    return toolbar_spec\n",
       "}\n",
       "\n",
       "\n",
       "    var minibn_jsapi = {  };\n",
       "    colomoto_extension(Jupyter, \"colomoto-setup-1542818\", \"minibn\", null, null, minibn_jsapi);\n",
       "     }</script>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<script type=\"text/javascript\" id=\"colomoto-setup-158153\" class=\"to-be-removed\">\n",
       "        if (typeof Jupyter != 'undefined') {\n",
       "            \n",
       "    var mymodule_jsapi = {  };\n",
       "    colomoto_extension(Jupyter, \"colomoto-setup-158153\", \"mymodule\", {\"name\": \"MaBoSS\", \"sub-menu\": [{\"name\": \"Load MaBoSS file\", \"snippet\": [\"masim = maboss.load(\\\"filename.bnd\\\", \\\"filename.cfg\\\")\"]}, {\"name\": \"Network\", \"sub-menu\": [{\"name\": \"Set istate\", \"snippet\": [\"maboss.wg_set_istate(masim)\"]}, {\"name\": \"Get initial state\", \"snippet\": [\"masim.get_initial_state()\"]}]}, {\"name\": \"Simulation\", \"sub-menu\": [{\"name\": \"Create mutant\", \"snippet\": [\"maboss.wg_make_mutant(masim)\"]}, {\"name\": \"Run\", \"snippet\": [\"simres = masim.run()\"]}, {\"name\": \"Set initial states\", \"snippet\": [\"masim.network.set_istate([\\\"mygenelist\\\"],{})\"]}, {\"name\": \"Set output\", \"snippet\": [\"maboss.wg_set_output(masim)\"]}]}, {\"name\": \"Results\", \"sub-menu\": [{\"name\": \"Save results\", \"snippet\": [\"simres.save(\\\"filename\\\")\"]}, {\"name\": \"Plot piechart\", \"snippet\": [\"simres.plot_piechart()\"]}, {\"name\": \"Plot trajectory\", \"snippet\": [\"simres.plot_trajectory()\"]}]}, {\"name\": \"Conversion\", \"sub-menu\": [{\"name\": \"Convert to biolqm\", \"snippet\": [\"biolqm_model = maboss.to_biolqm(masim)\"]}, {\"name\": \"Convert to minibn\", \"snippet\": [\"minibn_model = maboss.to_minibn(masim)\"]}]}, \"---\", {\"name\": \"Documentation\", \"external-link\": \"http://pymaboss.readthedocs.io\"}]}, null, mymodule_jsapi);\n",
       "     }</script><style type=\"text/css\">\n",
       "    #mymodule_menu {\n",
       "        color: green;\n",
       "        background-color: white;\n",
       "    }\n",
       "    </style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import maboss"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading the simulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-08-02T11:18:35.630216Z",
     "iopub.status.busy": "2024-08-02T11:18:35.629720Z",
     "iopub.status.idle": "2024-08-02T11:18:35.743484Z",
     "shell.execute_reply": "2024-08-02T11:18:35.743037Z",
     "shell.execute_reply.started": "2024-08-02T11:18:35.630203Z"
    }
   },
   "outputs": [],
   "source": [
    "simulation = maboss.load(\"metastasis.bnd\", \"metastasis.cfg\")\n",
    "outputs = ['Metastasis', 'Migration', 'Invasion', 'EMT', 'Apoptosis', 'CellCycleArrest']\n",
    "simulation.network.set_output(outputs)\n",
    "simulation.network.set_istate('ECMicroenv', [0.5, 0.5])\n",
    "simulation.network.set_istate('DNAdamage', [0.5, 0.5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulating locally"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-08-02T11:18:35.743985Z",
     "iopub.status.busy": "2024-08-02T11:18:35.743883Z",
     "iopub.status.idle": "2024-08-02T11:18:36.730491Z",
     "shell.execute_reply": "2024-08-02T11:18:36.729898Z",
     "shell.execute_reply.started": "2024-08-02T11:18:35.743976Z"
    }
   },
   "outputs": [],
   "source": [
    "result = simulation.run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-08-02T11:18:36.730951Z",
     "iopub.status.busy": "2024-08-02T11:18:36.730850Z",
     "iopub.status.idle": "2024-08-02T11:18:36.800817Z",
     "shell.execute_reply": "2024-08-02T11:18:36.800341Z",
     "shell.execute_reply.started": "2024-08-02T11:18:36.730942Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "result.plot_piechart()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simulating on the server"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-08-02T11:18:36.801536Z",
     "iopub.status.busy": "2024-08-02T11:18:36.801333Z",
     "iopub.status.idle": "2024-08-02T11:18:36.804619Z",
     "shell.execute_reply": "2024-08-02T11:18:36.804119Z",
     "shell.execute_reply.started": "2024-08-02T11:18:36.801519Z"
    }
   },
   "outputs": [],
   "source": [
    "server_host = \"localhost\"\n",
    "server_port = 7777"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-08-02T11:18:36.805672Z",
     "iopub.status.busy": "2024-08-02T11:18:36.805286Z",
     "iopub.status.idle": "2024-08-02T11:18:37.796642Z",
     "shell.execute_reply": "2024-08-02T11:18:37.796197Z",
     "shell.execute_reply.started": "2024-08-02T11:18:36.805652Z"
    }
   },
   "outputs": [],
   "source": [
    "mbcli = maboss.MaBoSSClient(host=server_host, port=server_port)\n",
    "result_server = mbcli.run(simulation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-08-02T11:18:37.797892Z",
     "iopub.status.busy": "2024-08-02T11:18:37.797731Z",
     "iopub.status.idle": "2024-08-02T11:18:37.864998Z",
     "shell.execute_reply": "2024-08-02T11:18:37.864439Z",
     "shell.execute_reply.started": "2024-08-02T11:18:37.797878Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "result_server.plot_piechart()"
   ]
  }
 ],
 "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}