{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Getting Started\n",
    "\n",
    "You can execute any notebooks via the execution API.\n",
    "\n",
    "Example:\n",
    "\n",
    "```sh\n",
    "$ curl -N -X POST \\\n",
    "    --data-urlencode \"token=<your_jupyter_token>\" \\\n",
    "    --data-urlencode \"notebook=<notebook.ipynb>\" \\\n",
    "    \"http://localhost:8888/api/executions\"\n",
    "```\n",
    "\n",
    "nbexec does not require any additional libraries for execution, but it requires a cell to define parameters if you set parameters at runtime."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basic Example\n",
    "\n",
    "Create a notebook with the following two cells and save it to `basic_example.ipynb`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': {'desc': 'Parameter a', 'examples': ['1', '0xf'], 'type': 'int'},\n",
       " 'b': {'desc': 'Parameter b', 'examples': ['1.5', '2e-2'], 'type': 'float'}}"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# nbexec: params\n",
    "a = 1\n",
    "b = 1.5\n",
    "{\n",
    "    'a': dict(type='int', desc='Parameter a', examples=['1', '0xf']),\n",
    "    'b': dict(type='float', desc='Parameter b', examples=['1.5', '2e-2'])\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first cell contains the parameter definition.\n",
    "It must starts with the `# nbexec: params`.\n",
    "The assignments `a = 1` and `b = 1.5` are the default values.\n",
    "They are also required to execute this notebook interactively.\n",
    "\n",
    "The next dict ``{...}`` is the parameter definition.\n",
    "The key name is the parameter name and the value is a dict which contains options for it.\n",
    "`type` is always required because parameters will be validated by the type.\n",
    "`desc` and `examples` are optional which are displayed in the document page.\n",
    "\n",
    "The second cell multiplies the variable `a` and `b`.\n",
    "\n",
    "nbexec displays a cog button at the end of the Jupyter toolbar:\n",
    "\n",
    "![](_static/doc_button.png)\n",
    "\n",
    "This is a link to the execution document which displays the API parameters and examples.\n",
    "\n",
    "You can execute the notebook from your console as below:\n",
    "\n",
    "```sh\n",
    "$ curl -N -X POST \\\n",
    "    --data-urlencode \"token=<your_jupyter_token>\" \\\n",
    "    --data-urlencode \"notebook=<notebook.ipynb>\" \\\n",
    "    \"http://localhost:8888/api/executions\"\n",
    "```\n",
    "\n",
    "It returns a JSON result immediately.\n",
    "\n",
    "```json\n",
    "{\n",
    "  \"event\": \"notebook_start\",\n",
    "  \"execution\": {\n",
    "    \"completed_at\": null,\n",
    "    \"exec_id\": \"50959a2f-d681-4a66-8c4c-0c2ef69d3be8\",\n",
    "    \"progress\": null,\n",
    "    \"output_path\": null,\n",
    "    \"params\": {},\n",
    "    \"jupyter_kernel\": null,\n",
    "    \"path\": \"basic_example.ipynb\",\n",
    "    \"status\": \"executing\",\n",
    "    \"last_cell_source\": null,\n",
    "    \"overwrite\": false,\n",
    "    \"started_at\": 1517209210.531868,\n",
    "    \"cell_timeout\": null\n",
    "  },\n",
    "  \"timestamp\": 1517209210.531868\n",
    "}\n",
    "```\n",
    "\n",
    "The execution is just started and is not finished yet.\n",
    "It takes at least a few seconds.\n",
    "You can get the status via the API with specifying `exec_id` which is included in the JSON above.\n",
    "\n",
    "```sh\n",
    "$ curl -N -G \\\n",
    "    --data-urlencode \"token=<your_jupyter_token>\" \\\n",
    "    \"http://localhost:8888/api/executions/50959a2f-d681-4a66-8c4c-0c2ef69d3be8\"\n",
    "```\n",
    "\n",
    "When the execution finishes, `status` becomes `completed`.\n",
    "\n",
    "Alternatively, you can execute the notebook with sending `X-Response-Encoding: chunked` header to receive real time progress.\n",
    "\n",
    "```sh\n",
    "$ curl -N -X POST \\\n",
    "    -H 'X-Response-Encoding: chunked' \\\n",
    "    --data-urlencode \"token=<your_jupyter_token>\" \\\n",
    "    --data-urlencode \"notebook=<notebook.ipynb>\" \\\n",
    "    \"http://localhost:8888/api/executions\"\n",
    "```\n",
    "\n",
    "It displays real time events until the execution finishes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Machine Learning Example\n",
    "\n",
    "We are going to create a pair of notebooks to do machine learning with [Iris Data Set](http://archive.ics.uci.edu/ml/datasets/Iris).\n",
    "\n",
    "1. iris-train.ipynb\n",
    "    * Create a model from data and save it as a file\n",
    "2. iris-predict.ipynb\n",
    "    * Load a model from a file and predict the target value with given data\n",
    "\n",
    "[pandas](https://pandas.pydata.org/), [scikit-learn](http://scikit-learn.org/) and [matplotlib](https://matplotlib.org/) are required to execute the following example.\n",
    "\n",
    "### Preparing Data Files\n",
    "\n",
    "Before creating notebooks, we need data files for training and prediction.\n",
    "Execute the following code in a notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import sklearn.datasets\n",
    "\n",
    "data = pd.read_csv(os.path.join(sklearn.datasets.__path__[0], 'data', 'iris.csv'),\n",
    "                   skiprows=1, header=None)\n",
    "train = data.sample(frac=0.8, random_state=1)\n",
    "test = data.drop(train.index)\n",
    "train.to_csv('training.csv', header=None, index=None)  # training dataset\n",
    "test.to_csv('test.csv', header=None, index=None)  # test dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can check the file contents as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.8,4.0,1.2,0.2,0\r\n",
      "5.1,2.5,3.0,1.1,1\r\n",
      "6.6,3.0,4.4,1.4,1\r\n",
      "5.4,3.9,1.3,0.4,0\r\n",
      "7.9,3.8,6.4,2.0,2\r\n"
     ]
    }
   ],
   "source": [
    "!head -5 training.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.1,3.5,1.4,0.2,0\r\n",
      "4.9,3.0,1.4,0.2,0\r\n",
      "5.0,3.4,1.5,0.2,0\r\n",
      "4.4,2.9,1.4,0.2,0\r\n",
      "4.3,3.0,1.1,0.1,0\r\n"
     ]
    }
   ],
   "source": [
    "!head -5 test.csv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training\n",
    "\n",
    "Create the following notebook and save it as `iris-train.ipynb`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "import pandas as pd\n",
    "from sklearn import svm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'C': {'desc': 'Penalty parameter C of the error term',\n",
       "  'examples': ['1.0'],\n",
       "  'type': float},\n",
       " 'data_file': {'desc': 'Data file', 'examples': ['example.csv'], 'type': str},\n",
       " 'degree': {'desc': \"Degree of the polynomial kernel function ('poly')Ignored by all other kernels.\",\n",
       "  'examples': ['3'],\n",
       "  'type': int},\n",
       " 'gamma': {'desc': \"Kernel coefficient for 'rbf', 'poly' and 'sigmoid'\",\n",
       "  'examples': ['0.2'],\n",
       "  'type': float},\n",
       " 'kernel': {'desc': 'Specifies the kernel type to be used in the algorithm',\n",
       "  'examples': ['linear', 'poly', 'rbf', 'sigmoid'],\n",
       "  'type': str}}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# nbexec: params\n",
    "data_file = 'training.csv'\n",
    "C = 1.0\n",
    "kernel = 'rbf'\n",
    "degree = 3\n",
    "gamma = 'auto'\n",
    "{\n",
    "    'data_file': dict(type=str, desc='Data file', examples=['example.csv']),\n",
    "    'C': dict(type=float, desc='Penalty parameter C of the error term', examples=['1.0']),\n",
    "    'kernel': dict(type=str, desc='Specifies the kernel type to be used in the algorithm',\n",
    "                   examples=['linear', 'poly', 'rbf', 'sigmoid']),\n",
    "    'degree': dict(type=int, desc=\"Degree of the polynomial kernel function ('poly')\"\n",
    "                                  \"Ignored by all other kernels.\", examples=['3']),\n",
    "    'gamma': dict(type=float, desc=\"Kernel coefficient for 'rbf', 'poly' and 'sigmoid'\", examples=['0.2'])\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv(data_file, names=['sepal length', 'sepal width',\n",
    "                                   'petal length', 'petal width', 'target'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal length</th>\n",
       "      <th>sepal width</th>\n",
       "      <th>petal length</th>\n",
       "      <th>petal width</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.8</td>\n",
       "      <td>4.0</td>\n",
       "      <td>1.2</td>\n",
       "      <td>0.2</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>5.1</td>\n",
       "      <td>2.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>6.6</td>\n",
       "      <td>3.0</td>\n",
       "      <td>4.4</td>\n",
       "      <td>1.4</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>5.4</td>\n",
       "      <td>3.9</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.4</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>7.9</td>\n",
       "      <td>3.8</td>\n",
       "      <td>6.4</td>\n",
       "      <td>2.0</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   sepal length  sepal width  petal length  petal width  target\n",
       "0           5.8          4.0           1.2          0.2       0\n",
       "1           5.1          2.5           3.0          1.1       1\n",
       "2           6.6          3.0           4.4          1.4       1\n",
       "3           5.4          3.9           1.3          0.4       0\n",
       "4           7.9          3.8           6.4          2.0       2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[<matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab33920b8>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab3311080>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab32d7128>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab32a27f0>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab3262fd0>],\n",
       "       [<matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab32344a8>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab326dba8>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab31c34e0>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab3110710>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab30d5320>],\n",
       "       [<matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab30a71d0>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab3060e10>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab3034160>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab2ff1b70>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab2fbeac8>],\n",
       "       [<matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab2f89550>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab2ed5898>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab2e98c18>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab2e6b160>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab2e2ca58>],\n",
       "       [<matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab2df7f28>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab2dbc898>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab2d89da0>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab2d1ed30>,\n",
       "        <matplotlib.axes._subplots.AxesSubplot object at 0x7f0ab2d0abe0>]], dtype=object)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f0ab3627f28>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pd.plotting.scatter_matrix(df, figsize=(10, 8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "X = df.drop(['target'], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "y = df['target']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "clf = svm.SVC(C=C, kernel=kernel, degree=degree, gamma=gamma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,\n",
       "  decision_function_shape=None, degree=3, gamma='auto', kernel='rbf',\n",
       "  max_iter=-1, probability=False, random_state=None, shrinking=True,\n",
       "  tol=0.001, verbose=False)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clf.fit(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open('iris.pickle', 'wb') as f:\n",
    "    pickle.dump(clf, f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can execute this notebook with several parameter combinations.\n",
    "\n",
    "Using 'linear' kernel:\n",
    "\n",
    "```sh\n",
    "$ curl -N -X POST \\\n",
    "    --data-urlencode \"token=<your_jupyter_token>\" \\\n",
    "    --data-urlencode \"notebook=iris-train.ipynb\" \\\n",
    "    --data-urlencode \"kernel=linear\" \\\n",
    "    --data-urlencode \"data_file=training.csv\" \\\n",
    "    \"http://localhost:8888/api/executions\"\n",
    "```\n",
    "\n",
    "Using 'rbf' kernel with `gamma = 0.7`:\n",
    "\n",
    "```sh\n",
    "$ curl -N -X POST \\\n",
    "    --data-urlencode \"token=<your_jupyter_token>\" \\\n",
    "    --data-urlencode \"notebook=iris-train.ipynb\" \\\n",
    "    --data-urlencode \"kernel=rbf\" \\\n",
    "    --data-urlencode \"gamma=0.7\" \\\n",
    "    --data-urlencode \"data_file=training.csv\" \\\n",
    "    \"http://localhost:8888/api/executions\"\n",
    "```\n",
    "\n",
    "Using 'poly' kernel with `degree = 3`:\n",
    "\n",
    "```sh\n",
    "$ curl -N -X POST \\\n",
    "    --data-urlencode \"token=<your_jupyter_token>\" \\\n",
    "    --data-urlencode \"notebook=iris-train.ipynb\" \\\n",
    "    --data-urlencode \"kernel=poly\" \\\n",
    "    --data-urlencode \"degree=3\" \\\n",
    "    --data-urlencode \"data_file=training.csv\" \\\n",
    "    \"http://localhost:8888/api/executions\"\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prediction\n",
    "\n",
    "Create the following notebook and save it as `iris-predict.ipynb`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pickle\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'data_file': {'desc': 'Data file', 'examples': ['example.csv'], 'type': str}}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# nbexec: params\n",
    "data_file = 'test.csv'\n",
    "{\n",
    "    'data_file': dict(type=str, desc='Data file', examples=['example.csv'])\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv(data_file, names=['sepal length', 'sepal width',\n",
    "                                   'petal length', 'petal width', 'target'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "with open('iris.pickle', 'rb') as f:\n",
    "    clf = pickle.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "X = df.drop(['target'], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "result = clf.predict(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "1\n",
      "1\n",
      "1\n",
      "1\n",
      "1\n",
      "1\n",
      "1\n",
      "1\n",
      "1\n",
      "1\n",
      "1\n",
      "1\n",
      "1\n",
      "2\n",
      "2\n",
      "2\n",
      "2\n",
      "2\n",
      "2\n",
      "2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(pd.DataFrame(result).to_csv(header=False, index=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook can be executed by the following execution API:\n",
    "\n",
    "```sh\n",
    "$ curl -N -X POST \\\n",
    "    --data-urlencode \"token=<your_jupyter_token>\" \\\n",
    "    --data-urlencode \"notebook=iris-predict.ipynb\" \\\n",
    "    --data-urlencode \"data_file=test.csv\" \\\n",
    "    \"http://localhost:8888/api/executions\"\n",
    "```\n",
    "\n",
    "The result is included in the cell above.\n",
    "You can get it from the output notebook `iris-predict-Executed1.ipynb`.\n",
    "\n",
    "You can also get the real time progress by specicying `X-Response-Encoding: chunked`.\n",
    "The progress payload includes the cell object and you can get the result from it.\n",
    "\n",
    "Example:\n",
    "\n",
    "```sh\n",
    "$ curl -N -X POST \\\n",
    "    -H 'X-Response-Encoding: chunked' \\\n",
    "    --data-urlencode \"token=<your_jupyter_token>\" \\\n",
    "    --data-urlencode \"notebook=iris-predict.ipynb\" \\\n",
    "    --data-urlencode \"data_file=test.csv\" \\\n",
    "    \"http://localhost:8888/api/executions\"\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "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.4.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
