codestral code interpreter

Notebook content (JSON format):

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Codestral with code interpreting and analyzing dataset\n",
        "\n",
        "This AI assistant is powered by the open-source [Code Interpreter SDK](https://github.com/e2b-dev/code-interpreter) by [E2B](https://e2b.dev/docs). The SDK quickly creates a secure cloud sandbox powered by [Firecracker](https://github.com/firecracker-microvm/firecracker). Inside this sandbox is a running Jupyter server that the LLM can use.\n",
        "\n",
        "Read more about Mistral's new Codestral model [here](https://mistral.ai/news/codestral/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Step 1: Install dependencies\n",
        "\n",
        "We start with installing the [E2B code interpreter SDK](https://github.com/e2b-dev/code-interpreter) and [Mistral's Python SDK](https://console.mistral.ai/)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XsUPOWJl5pn9",
        "outputId": "e459be0c-d698-4b99-cde4-480b8a5e42d2"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: mistralai==0.4.2 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from -r requirements.txt (line 1)) (0.4.2)\n",
            "Requirement already satisfied: e2b_code_interpreter==0.0.10 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from -r requirements.txt (line 2)) (0.0.10)\n",
            "Requirement already satisfied: httpx<1,>=0.25 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from mistralai==0.4.2->-r requirements.txt (line 1)) (0.27.0)\n",
            "Requirement already satisfied: orjson<3.11,>=3.9.10 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from mistralai==0.4.2->-r requirements.txt (line 1)) (3.9.15)\n",
            "Requirement already satisfied: pydantic<3,>=2.5.2 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from mistralai==0.4.2->-r requirements.txt (line 1)) (2.7.1)\n",
            "Requirement already satisfied: e2b>=0.17.1 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (0.17.1)\n",
            "Requirement already satisfied: websocket-client<2.0.0,>=1.7.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (1.7.0)\n",
            "Requirement already satisfied: aenum>=3.1.11 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (3.1.15)\n",
            "Requirement already satisfied: aiohttp>=3.8.4 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (3.9.5)\n",
            "Requirement already satisfied: jsonrpcclient>=4.0.3 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (4.0.3)\n",
            "Requirement already satisfied: python-dateutil>=2.8.2 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (2.8.2)\n",
            "Requirement already satisfied: requests>=2.31.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (2.31.0)\n",
            "Requirement already satisfied: typing-extensions>=4.8.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (4.9.0)\n",
            "Requirement already satisfied: urllib3>=1.25.3 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (2.2.1)\n",
            "Requirement already satisfied: websockets>=11.0.3 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (11.0.3)\n",
            "Requirement already satisfied: anyio in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from httpx<1,>=0.25->mistralai==0.4.2->-r requirements.txt (line 1)) (3.7.1)\n",
            "Requirement already satisfied: certifi in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from httpx<1,>=0.25->mistralai==0.4.2->-r requirements.txt (line 1)) (2024.2.2)\n",
            "Requirement already satisfied: httpcore==1.* in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from httpx<1,>=0.25->mistralai==0.4.2->-r requirements.txt (line 1)) (1.0.2)\n",
            "Requirement already satisfied: idna in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from httpx<1,>=0.25->mistralai==0.4.2->-r requirements.txt (line 1)) (3.6)\n",
            "Requirement already satisfied: sniffio in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from httpx<1,>=0.25->mistralai==0.4.2->-r requirements.txt (line 1)) (1.3.0)\n",
            "Requirement already satisfied: h11<0.15,>=0.13 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from httpcore==1.*->httpx<1,>=0.25->mistralai==0.4.2->-r requirements.txt (line 1)) (0.14.0)\n",
            "Requirement already satisfied: annotated-types>=0.4.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from pydantic<3,>=2.5.2->mistralai==0.4.2->-r requirements.txt (line 1)) (0.5.0)\n",
            "Requirement already satisfied: pydantic-core==2.18.2 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from pydantic<3,>=2.5.2->mistralai==0.4.2->-r requirements.txt (line 1)) (2.18.2)\n",
            "Requirement already satisfied: aiosignal>=1.1.2 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from aiohttp>=3.8.4->e2b>=0.17.1->e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (1.3.1)\n",
            "Requirement already satisfied: attrs>=17.3.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from aiohttp>=3.8.4->e2b>=0.17.1->e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (23.1.0)\n",
            "Requirement already satisfied: frozenlist>=1.1.1 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from aiohttp>=3.8.4->e2b>=0.17.1->e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (1.4.0)\n",
            "Requirement already satisfied: multidict<7.0,>=4.5 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from aiohttp>=3.8.4->e2b>=0.17.1->e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (6.0.4)\n",
            "Requirement already satisfied: yarl<2.0,>=1.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from aiohttp>=3.8.4->e2b>=0.17.1->e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (1.9.2)\n",
            "Requirement already satisfied: six>=1.5 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from python-dateutil>=2.8.2->e2b>=0.17.1->e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (1.16.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from requests>=2.31.0->e2b>=0.17.1->e2b_code_interpreter==0.0.10->-r requirements.txt (line 2)) (3.3.2)\n",
            "Note: you may need to restart the kernel to use updated packages.\n"
          ]
        }
      ],
      "source": [
        "%pip install -r requirements.txt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Step 2: Define API keys and prompt\n",
        "\n",
        "Let's define our variables with API keys for Mistral and E2B together with the model ID and prompt.\n",
        "\n",
        "We won't be defining any tools, because this example is made to work universally, including Mistral's models that don't fully support tool usage (function calling) yet. To learn more about function calling with Mistral's LLMs, see [this docs page](https://docs.mistral.ai/capabilities/function_calling/)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {
        "id": "HnxngrHnWlV8"
      },
      "outputs": [],
      "source": [
        "# TODO: Get your Mistral API key from https://console.mistral.ai\n",
        "MISTRAL_API_KEY = \"\"\n",
        "\n",
        "# TODO: Get your E2B API key from https://e2b.dev/docs\n",
        "E2B_API_KEY = \"\"\n",
        "\n",
        "MODEL_NAME = \"codestral-latest\" #See the available models at https://docs.mistral.ai/getting-started/models/\n",
        "\n",
        "SYSTEM_PROMPT = \"\"\"You're a Python data scientist. You are given tasks to complete and you run Python code to solve them.\n",
        "\n",
        "Information about the csv dataset:\n",
        "- It's in the `/home/user/global_economy_indicators.csv` file\n",
        "- The CSV file is using , as the delimiter\n",
        "- It has the following columns (examples included):\n",
        "    - country: \"Argentina\", \"Australia\"\n",
        "    - Region: \"SouthAmerica\", \"Oceania\"\n",
        "    - Surface area (km2): for example, 2780400\n",
        "    - Population in thousands (2017): for example, 44271\n",
        "    - Population density (per km2, 2017): for example, 16.2\n",
        "    - Sex ratio (m per 100 f, 2017): for example, 95.9\n",
        "    - GDP: Gross domestic product (million current US$): for example, 632343\n",
        "    - GDP growth rate (annual %, const. 2005 prices): for example, 2.4\n",
        "    - GDP per capita (current US$): for example, 14564.5\n",
        "    - Economy: Agriculture (% of GVA): for example, 10.0\n",
        "    - Economy: Industry (% of GVA): for example, 28.1\n",
        "    - Economy: Services and other activity (% of GVA): for example, 61.9\n",
        "    - Employment: Agriculture (% of employed): for example, 4.8\n",
        "    - Employment: Industry (% of employed): for example, 20.6\n",
        "    - Employment: Services (% of employed): for example, 74.7\n",
        "    - Unemployment (% of labour force): for example, 8.5\n",
        "    - Employment: Female (% of employed): for example, 43.7\n",
        "    - Employment: Male (% of employed): for example, 56.3\n",
        "    - Labour force participation (female %): for example, 48.5\n",
        "    - Labour force participation (male %): for example, 71.1\n",
        "    - International trade: Imports (million US$): for example, 59253\n",
        "    - International trade: Exports (million US$): for example, 57802\n",
        "    - International trade: Balance (million US$): for example, -1451\n",
        "    - Education: Government expenditure (% of GDP): for example, 5.3\n",
        "    - Health: Total expenditure (% of GDP): for example, 8.1\n",
        "    - Health: Government expenditure (% of total health expenditure): for example, 69.2\n",
        "    - Health: Private expenditure (% of total health expenditure): for example, 30.8\n",
        "    - Health: Out-of-pocket expenditure (% of total health expenditure): for example, 20.2\n",
        "    - Health: External health expenditure (% of total health expenditure): for example, 0.2\n",
        "    - Education: Primary gross enrollment ratio (f/m per 100 pop): for example, 111.5/107.6\n",
        "    - Education: Secondary gross enrollment ratio (f/m per 100 pop): for example, 104.7/98.9\n",
        "    - Education: Tertiary gross enrollment ratio (f/m per 100 pop): for example, 90.5/72.3\n",
        "    - Education: Mean years of schooling (female): for example, 10.4\n",
        "    - Education: Mean years of schooling (male): for example, 9.7\n",
        "    - Urban population (% of total population): for example, 91.7\n",
        "    - Population growth rate (annual %): for example, 0.9\n",
        "    - Fertility rate (births per woman): for example, 2.3\n",
        "    - Infant mortality rate (per 1,000 live births): for example, 8.9\n",
        "    - Life expectancy at birth, female (years): for example, 79.7\n",
        "    - Life expectancy at birth, male (years): for example, 72.9\n",
        "    - Life expectancy at birth, total (years): for example, 76.4\n",
        "    - Military expenditure (% of GDP): for example, 0.9\n",
        "    - Population, female: for example, 22572521\n",
        "    - Population, male: for example, 21472290\n",
        "    - Tax revenue (% of GDP): for example, 11.0\n",
        "    - Taxes on income, profits and capital gains (% of revenue): for example, 12.9\n",
        "    - Urban population (% of total population): for example, 91.7\n",
        "\n",
        "Generally, you follow these rules:\n",
        "- ALWAYS FORMAT YOUR RESPONSE IN MARKDOWN\n",
        "- ALWAYS RESPOND ONLY WITH CODE IN CODE BLOCK LIKE THIS:\n",
        "```python\n",
        "{code}\n",
        "```\n",
        "- the Python code runs in jupyter notebook.\n",
        "- every time you generate Python, the code is executed in a separate cell. it's okay to make multiple calls to `execute_python`.\n",
        "- display visualizations using matplotlib or any other visualization library directly in the notebook. don't worry about saving the visualizations to a file.\n",
        "- you have access to the internet and can make api requests.\n",
        "- you also have access to the filesystem and can read/write files.\n",
        "- you can install any pip package (if it exists) if you need to be running `!pip install {package}`. The usual packages for data analysis are already preinstalled though.\n",
        "- you can run any Python code you want, everything is running in a secure sandbox environment\n",
        "\"\"\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a74aGJUdjonY"
      },
      "source": [
        "We instruct the model to return messages in Markdown and then parse and extract the Python code block."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {
        "id": "yVwSBPF1iHby"
      },
      "outputs": [],
      "source": [
        "import re\n",
        "pattern = re.compile(r'```python\\n(.*?)\\n```', re.DOTALL) # Match everything in between ```python and ```\n",
        "def match_code_block(llm_response):\n",
        "  match = pattern.search(llm_response)\n",
        "  if match:\n",
        "    code = match.group(1)\n",
        "    print(code)\n",
        "    return code\n",
        "  return \"\""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Step 3: Implement the method for code interpreting\n",
        "\n",
        "Here's the main function that uses the E2B code interpreter SDK. We'll be calling this function a little bit further in the code when we're parsing the Codestral's response with tool calls."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "id": "knZ-_2qtXkqM"
      },
      "outputs": [],
      "source": [
        "def code_interpret(e2b_code_interpreter, code):\n",
        "  print(\"Running code interpreter...\")\n",
        "  exec = e2b_code_interpreter.notebook.exec_cell(\n",
        "    code,\n",
        "    on_stderr=lambda stderr: print(\"[Code Interpreter]\", stderr),\n",
        "    on_stdout=lambda stdout: print(\"[Code Interpreter]\", stdout),\n",
        "    # You can also stream code execution results\n",
        "    # on_result=...\n",
        "  )\n",
        "\n",
        "  if exec.error:\n",
        "    print(\"[Code Interpreter ERROR]\", exec.error)\n",
        "  else:\n",
        "    return exec.results"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### Step 4: Implement the method for calling Codestral and parsing its response\n",
        "\n",
        "Now we're going to define and implement `chat` method. In this method, we'll call the Codestral LLM, parse the output to extract any Python code block, and call our `code_interpret` method we defined above."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {
        "id": "udfl9vKoXnBn"
      },
      "outputs": [],
      "source": [
        "from mistralai.client import MistralClient\n",
        "\n",
        "client = MistralClient(api_key=MISTRAL_API_KEY)\n",
        "\n",
        "def chat(e2b_code_interpreter, user_message):\n",
        "  print(f\"\\n{'='*50}\\nUser message: {user_message}\\n{'='*50}\")\n",
        "\n",
        "  messages = [\n",
        "      {\"role\": \"system\", \"content\": SYSTEM_PROMPT},\n",
        "      {\"role\": \"user\", \"content\": user_message}\n",
        "  ]\n",
        "  \n",
        "  response = client.chat(\n",
        "      model=MODEL_NAME,\n",
        "      messages=messages,\n",
        "  )\n",
        "  response_message = response.choices[0].message\n",
        "  python_code = match_code_block(response_message.content)\n",
        "  if python_code != \"\":\n",
        "    code_interpreter_results = code_interpret(e2b_code_interpreter, python_code)\n",
        "    return code_interpreter_results\n",
        "  else:\n",
        "    print(f\"Failed to match any Python code in model's response {response_message}\")\n",
        "    return[]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P4-9Vj3lkiB1"
      },
      "source": [
        "### Step 5: Implement the method for uploading dataset to code interpreter sandbox\n",
        "\n",
        "The file gets uploaded to the E2B sandbox where our code interpreter is running. We get the file's remote path in the `remote_path` variable."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "metadata": {
        "id": "29lU13cQkg36"
      },
      "outputs": [],
      "source": [
        "def upload_dataset(code_interpreter):\n",
        "  print(\"Uploading dataset to Code Interpreter sandbox...\")\n",
        "  with open(\"./global_economy_indicators.csv\", \"rb\") as f:\n",
        "    remote_path = code_interpreter.upload_file(f)\n",
        "  print(\"Uploaded at\", remote_path)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zX90GEiPkrOX"
      },
      "source": [
        "### Step 6: Put everything together\n",
        "\n",
        "In this last step, we put all the pieces together. We instantiate a new code interpreter instance using\n",
        "\n",
        "```py\n",
        "with CodeInterpreter(api_key=E2B_API_KEY) as code_interpreter:\n",
        "```\n",
        "\n",
        "and then call the `chat` method with our user message and the `code_interpreter` instance."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 51,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "LIs_hCRlYD-X",
        "outputId": "cad8a089-389e-4774-88d7-79f28ef39aa0"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Uploading dataset to Code Interpreter sandbox...\n",
            "Uploaded at /home/user/global_economy_indicators.csv\n",
            "\n",
            "==================================================\n",
            "User message: Make a chart showing linear regression of the relationship between GDP per capita and life expectancy from the global_economy_indicators. Filter out any missing values or values in wrong format.\n",
            "==================================================\n",
            "import pandas as pd\n",
            "import matplotlib.pyplot as plt\n",
            "from sklearn.linear_model import LinearRegression\n",
            "\n",
            "# Load the dataset\n",
            "df = pd.read_csv('/home/user/global_economy_indicators.csv')\n",
            "\n",
            "# Filter out missing values\n",
            "df = df.dropna(subset=['GDP per capita (current US$)', 'Life expectancy at birth, total (years)'])\n",
            "\n",
            "# Convert columns to numeric, errors='coerce' will turn the invalid parsing into NaN\n",
            "df['GDP per capita (current US$)'] = pd.to_numeric(df['GDP per capita (current US$)'], errors='coerce')\n",
            "df['Life expectancy at birth, total (years)'] = pd.to_numeric(df['Life expectancy at birth, total (years)'], errors='coerce')\n",
            "\n",
            "# Drop NaN values after conversion\n",
            "df = df.dropna(subset=['GDP per capita (current US$)', 'Life expectancy at birth, total (years)'])\n",
            "\n",
            "# Prepare the data for linear regression\n",
            "X = df[['GDP per capita (current US$)']]\n",
            "y = df['Life expectancy at birth, total (years)']\n",
            "\n",
            "# Fit the linear regression model\n",
            "model = LinearRegression()\n",
            "model.fit(X, y)\n",
            "\n",
            "# Predict life expectancy for all GDP per capita values\n",
            "y_pred = model.predict(X)\n",
            "\n",
            "# Plot the data and the regression line\n",
            "plt.scatter(X, y, color='blue')\n",
            "plt.plot(X, y_pred, color='red')\n",
            "plt.title('Relationship between GDP per capita and life expectancy')\n",
            "plt.xlabel('GDP per capita (current US$)')\n",
            "plt.ylabel('Life expectancy at birth, total (years)')\n",
            "plt.show()\n",
            "Running code interpreter...\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "Result(<Figure size 640x480 with 1 Axes>)"
            ]
          },
          "execution_count": 51,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from e2b_code_interpreter import CodeInterpreter\n",
        "\n",
        "with CodeInterpreter(api_key=E2B_API_KEY) as code_interpreter:\n",
        "  # Upload the dataset to the code interpreter sandbox\n",
        "  upload_dataset(code_interpreter)\n",
        "\n",
        "  code_results = chat(\n",
        "    code_interpreter,\n",
        "    \"Make a chart showing linear regression of the relationship between GDP per capita and life expectancy from the global_economy_indicators. Filter out any missing values or values in wrong format.\"\n",
        "  )\n",
        "  if code_results:\n",
        "    first_result = code_results[0]\n",
        "  else:\n",
        "    raise Exception(\"No code interpreter results\")\n",
        "\n",
        "\n",
        "# This will render the image\n",
        "# You can also access the data directly\n",
        "# first_result.png\n",
        "# first_result.jpg\n",
        "# first_result.pdf\n",
        "# ...\n",
        "first_result"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.11.4"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}