demo/pydantic.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "               .\n",
      "              ..:\n",
      "            Hultnér\n",
      "          Technologies\n",
      "\n",
      "@ahultner | https://hultner.se/\n"
     ]
    }
   ],
   "source": [
    "def s(x): return \" \"*(10+x)\n",
    "print(s(5)+\".\\n\"+s(4)+\"..:\\n\"+s(2)+\"Hultnér\\n\"+s(0)+\"Technologies\\n\\n@ahultner | https://hultner.se/\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Give your dataclasses super powers with pydantic\n",
    "\n",
    "## Index\n",
    "- Quick refresher on python data classes\n",
    "- Pydantic introduction\n",
    "    - Prior art\n",
    "    - Minimal example from dataclass\n",
    "    - Runtime type-checking\n",
    "    - JSON (de)serialisation\n",
    "    - JSONSchema\n",
    "    - Validators\n",
    "        - [Custom model validators](https://pydantic-docs.helpmanual.io/usage/validators/)\n",
    "        - [Validation decorator for functions](https://pydantic-docs.helpmanual.io/usage/validation_decorator/), via `@validate_arguments`. Still in beta, API may change.\n",
    "    - FastAPI framework\n",
    "        - OpenAPI Specifications\n",
    "        - Autogenerated tests\n",
    "- Cool features worth mentioning\n",
    "- Future\n",
    "- Conclusion\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with a quick `@dataclass`-refresher.\n",
    "\n",
    "Well use pizza-based examples in the spirit of [python.pizza](https://remote.python.pizza) 🐍🍕"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "from typing import Tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class Pizza:\n",
    "    style: str\n",
    "    toppings: Tuple[str, ...]\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(style=1, toppings=('cheese', 'ham'))"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza(1, (\"cheese\", \"ham\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we may want to constrain the toppings to ones we actually offer.\n",
    "Our pizzeria doesn't offer pineapple 🚫🍍 as a valid topping, hate it 😡 or love it 💕"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from enum import Enum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Topping(str, Enum):\n",
    "    mozzarella = 'mozzarella'\n",
    "    tomato_sauce = 'tomato sauce'\n",
    "    prosciutto = 'prosciutto'\n",
    "    basil = 'basil'\n",
    "    rucola = 'rucola'\n",
    "    \n",
    "\n",
    "@dataclass\n",
    "class Pizza:\n",
    "    style: str\n",
    "    toppings: Tuple[Topping, ...]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's see what happens if we try to create a pizza with pineapple 🍍 topping."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(style=2, toppings=('pineapple', 24))"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza(2, (\"pineapple\", 24))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With dataclasses the types aren't enforced, this can ofcourse be implemented but in this case we'll lean on the shoulders of a giant, pydantic 🧹🐍🧐"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydantic.dataclasses import dataclass\n",
    "\n",
    "    \n",
    "@dataclass\n",
    "class Pizza:\n",
    "    style: str\n",
    "    toppings: Tuple[Topping, ...]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see the only thing changed in this example is that we import the dataclass decorator from pydantic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 validation errors for Pizza\n",
      "toppings -> 0\n",
      "  value is not a valid enumeration member; permitted: 'mozzarella', 'tomato sauce', 'prosciutto', 'basil', 'rucola' (type=type_error.enum; enum_values=[<Topping.mozzarella: 'mozzarella'>, <Topping.tomato_sauce: 'tomato sauce'>, <Topping.prosciutto: 'prosciutto'>, <Topping.basil: 'basil'>, <Topping.rucola: 'rucola'>])\n",
      "toppings -> 1\n",
      "  value is not a valid enumeration member; permitted: 'mozzarella', 'tomato sauce', 'prosciutto', 'basil', 'rucola' (type=type_error.enum; enum_values=[<Topping.mozzarella: 'mozzarella'>, <Topping.tomato_sauce: 'tomato sauce'>, <Topping.prosciutto: 'prosciutto'>, <Topping.basil: 'basil'>, <Topping.rucola: 'rucola'>])\n"
     ]
    }
   ],
   "source": [
    "from pydantic import ValidationError\n",
    "try:\n",
    "    Pizza(2, (\"pineapple\", 24))\n",
    "except ValidationError as err:\n",
    "    print(err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And with that simple chage we can see that our new instance of an invalid pizza actually raises errors 🚫🚨\n",
    "\n",
    "Additionally these errors are very readable!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So let's try to create a valid pizza 🍕✅"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(style='Napoli', toppings=(<Topping.tomato_sauce: 'tomato sauce'>, <Topping.prosciutto: 'prosciutto'>, <Topping.mozzarella: 'mozzarella'>, <Topping.basil: 'basil'>))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza(\"Napoli\", (Topping.tomato_sauce, Topping.prosciutto, Topping.mozzarella, Topping.basil))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So what about JSON? 🧑‍💻  \n",
    "The dataclass dropin replacement decorator from pydantic is great for compability but by using `pydantic.BaseModel` we can get even more out of pydantic. One of those things is (de)serialisation, pydantic have native support JSON encoding and decoding."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydantic import BaseModel\n",
    "\n",
    "\n",
    "\n",
    "class Pizza(BaseModel):\n",
    "    style: str\n",
    "    toppings: Tuple[Topping, ...]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Disclaimer: Pydantic is primarly a parsing library and does validation as a means to an end, so make sure it makes sense for you.*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using the BaseModel the default behaviour requires to specify the init arguments using their keywords like below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(style='Napoli', toppings=(<Topping.tomato_sauce: 'tomato sauce'>, <Topping.prosciutto: 'prosciutto'>, <Topping.mozzarella: 'mozzarella'>, <Topping.basil: 'basil'>))"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza(style=\"Napoli\", toppings=(Topping.tomato_sauce, Topping.prosciutto, Topping.mozzarella, Topping.basil))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now easily encode this object as `JSON`, there's also [built-in support](https://pydantic-docs.helpmanual.io/usage/exporting_models/) for dict, pickle, immutable `copy()`. Pydantic will also (de)serialise subclasses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{\"style\": \"Napoli\", \"toppings\": [\"tomato sauce\", \"prosciutto\", \"mozzarella\", \"basil\"]}'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_.json()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And we can also reconstruct our original object using the `parse_raw`-method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Pizza(style='Napoli', toppings=(<Topping.tomato_sauce: 'tomato sauce'>, <Topping.prosciutto: 'prosciutto'>, <Topping.mozzarella: 'mozzarella'>, <Topping.basil: 'basil'>))"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza.parse_raw('{\"style\": \"Napoli\", \"toppings\": [\"tomato sauce\", \"prosciutto\", \"mozzarella\", \"basil\"]}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Errors raises a validation error, these can also be represented as JSON."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\n",
      "  {\n",
      "    \"loc\": [\n",
      "      \"toppings\",\n",
      "      0\n",
      "    ],\n",
      "    \"msg\": \"value is not a valid enumeration member; permitted: 'mozzarella', 'tomato sauce', 'prosciutto', 'basil', 'rucola'\",\n",
      "    \"type\": \"type_error.enum\",\n",
      "    \"ctx\": {\n",
      "      \"enum_values\": [\n",
      "        \"mozzarella\",\n",
      "        \"tomato sauce\",\n",
      "        \"prosciutto\",\n",
      "        \"basil\",\n",
      "        \"rucola\"\n",
      "      ]\n",
      "    }\n",
      "  }\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    Pizza(style=\"Napoli\", toppings=(2,))\n",
    "except ValidationError as err:\n",
    "    print(err.json())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also export a JSONSchema directly from our model, this is very useful for instance if we want to use your model to feed a Swagger/OpenAPI-spec. 📜✅\n",
    "\n",
    "⚠ *Caution: Pydantic uses the latest draft 7 of JSONSchema, this will be used in the comming OpenAPI 3.1 spec but the current 3.0.x spec uses draft 4. I spoke with Samuel Colvin, the creator of pydantic about this and his recommendation is to write a `schema_extra`function to use the older JSONSchema version if you want strict compability. The FastAPI framework doesn't do this and is slightly incompatible with the current OpenAPI-spec*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'title': 'Pizza',\n",
       " 'type': 'object',\n",
       " 'properties': {'style': {'title': 'Style', 'type': 'string'},\n",
       "  'toppings': {'title': 'Toppings',\n",
       "   'type': 'array',\n",
       "   'items': {'enum': ['mozzarella',\n",
       "     'tomato sauce',\n",
       "     'prosciutto',\n",
       "     'basil',\n",
       "     'rucola'],\n",
       "    'type': 'string'}}},\n",
       " 'required': ['style', 'toppings']}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Pizza.schema()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That was the basics using the built-in validators, but what if you want to implement your own business rules in a custom validator, we're going to look at this next.\n",
    "\n",
    "We now want to add a new property for `oven_temperature`, but in our case we also want to ensure that we are close to the ideal of roughly 375°C for Neapolitan pizzas, which is our imaginary restaurants house style."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydantic import validator, root_validator\n",
    "class BakedPizza(Pizza):\n",
    "    # For simplicity in the example we use int for temperature\n",
    "    oven_temperature: int\n",
    "        \n",
    "    # A validator looking at a single property\n",
    "    @validator('style')\n",
    "    def check_style(cls, style):\n",
    "        house_styles = (\"Napoli\", \"Roman\", \"Italian\")\n",
    "        if style not in house_styles:\n",
    "            raise ValueError(f\"We only cook the following styles: {house_styles}, given: {style}\")\n",
    "        return style\n",
    "    \n",
    "    # Root validators check the entire model\n",
    "    @root_validator\n",
    "    def check_temp(cls, values):\n",
    "        style, temp = values.get(\"style\"), values.get(\"oven_temperature\")\n",
    "        \n",
    "        if style != \"Napoli\":\n",
    "            # We don't have any special rules yet for the other styles\n",
    "            return values\n",
    "\n",
    "        if 350 <= temp <= 400: \n",
    "            # Target temperature 350 - 400°C, ideally around 375°C\n",
    "            return values\n",
    "\n",
    "        raise ValueError(f\"Napoli pizzas require a oven_temperature in the range of 350 - 400°C, given: {temp}°C\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's see if we create some invalid pizzas ⚠️🚨"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 validation error for BakedPizza\n",
      "style\n",
      "  We only cook the following styles: ('Napoli', 'Roman', 'Italian'), given: Panpizza (type=value_error)\n"
     ]
    }
   ],
   "source": [
    "try: \n",
    "    BakedPizza(style=\"Panpizza\", toppings=[\"tomato sauce\"], oven_temperature=250 )\n",
    "except ValidationError as err:\n",
    "    print(err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 validation error for BakedPizza\n",
      "__root__\n",
      "  Napoli pizzas require a oven_temperature in the range of 350 - 400°C, given: 300°C (type=value_error)\n"
     ]
    }
   ],
   "source": [
    "try: \n",
    "    BakedPizza(style=\"Napoli\", toppings=[\"tomato sauce\"], oven_temperature=300 )\n",
    "except ValidationError as err:\n",
    "    print(err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's create a pizza 🍕 allowed by our rules! ✨"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BakedPizza(style='Napoli', toppings=(<Topping.tomato_sauce: 'tomato sauce'>,), oven_temperature=350)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "BakedPizza(style=\"Napoli\", toppings=[\"tomato sauce\"], oven_temperature=350)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Gosh these runtime type checkers are rather useful, but what about **functions**? \n",
    "\n",
    "Pydantic got you covered with `@validate_arguments`. *Still in beta, API may change, release 2020-04-18 in version 1.5*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydantic import validate_arguments\n",
    "\n",
    "# Validator on function\n",
    "# Ensure that we use a valid pizza when making orders\n",
    "@validate_arguments\n",
    "def make_order(pizza: Pizza):\n",
    "    ...\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 validation error for MakeOrder\n",
      "pizza -> toppings -> 3\n",
      "  value is not a valid enumeration member; permitted: 'mozzarella', 'tomato sauce', 'prosciutto', 'basil', 'rucola' (type=type_error.enum; enum_values=[<Topping.mozzarella: 'mozzarella'>, <Topping.tomato_sauce: 'tomato sauce'>, <Topping.prosciutto: 'prosciutto'>, <Topping.basil: 'basil'>, <Topping.rucola: 'rucola'>])\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    make_order({\n",
    "        \"style\":\"Napoli\",\n",
    "        \"toppings\":(\"tomato sauce\", \"mozzarella\", \"prosciutto\", \"pineapple\")\n",
    "    })\n",
    "except ValidationError as err:\n",
    "    print(err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FastAPI\n",
    "FastAPI is a lean microframework similar to Flask which utilizes pydantic models heavily, it will also automatically generate OpenAPI-specifications from your application based on your models.\n",
    "\n",
    "This gives you framework agnostic models while still being able to leverage tight integration with a modern and easy to use framework. If you're going to start a new API-project i highly recommend trying FastAPI."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fastapi import FastAPI\n",
    "from pydantic import BaseModel\n",
    "\n",
    "app = FastAPI()\n",
    "\n",
    "def make_order(pizza: Pizza):\n",
    "    # Business logic for making an order\n",
    "    pass\n",
    "\n",
    "def dispatch_order(pizza: BakedPizza):\n",
    "    # Hand over pizza to delivery company\n",
    "    pass\n",
    "\n",
    "# Deliver a baked pizza\n",
    "@app.post(\"/delivery/pizza\")\n",
    "async def deliver_pizza_order(pizza: BakedPizza):\n",
    "    dispatch = dispatch_order(pizza)\n",
    "    return dispatch\n",
    "\n",
    "@app.post(\"/order/pizza\")\n",
    "async def order_pizza(pizza: Pizza):\n",
    "    order = make_order(pizza)\n",
    "    return order\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is everything we need to create a small API around our models."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "That's it, a quick introduction to pydantic! \n",
    "\n",
    "But this is just the tip of the iceberg 🗻 and I want to give you a hint about what more can be done.  \n",
    "I'm not going to go into detail in any of this but feel free to ask me about it in the chat, on Twitter/LinkedIn or via email. 💬📨"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cool features worth mentioning\n",
    "\n",
    "- Post **1.0**, reached this milestone about a year ago\n",
    "- Support for [standard library types](https://pydantic-docs.helpmanual.io/usage/types/#pydantic-types)\n",
    "- Offer useful extra types for every day use\n",
    "    - Email\n",
    "    - HttpUrl (and more, stricturl for custom validation)\n",
    "    - PostgresDsn\n",
    "    - IPvAnyAddress (as well as IPv4Address and IPv6Address from ipaddress)\n",
    "    - PositiveInt\n",
    "    - PaymentCardNumber, PaymentCardBrand.[amex, mastercard, visa, other], checks luhn, str of digits and BIN-based lenght.\n",
    "    - [Constrained types](https://pydantic-docs.helpmanual.io/usage/types/#constrained-types) (e.g. conlist, conint, etc.)\n",
    "    - and more…\n",
    "- Supports [custom datatypes](https://pydantic-docs.helpmanual.io/usage/types/#custom-data-types)\n",
    "- [Settings management](https://pydantic-docs.helpmanual.io/usage/settings/)\n",
    "    - Typed configuration management\n",
    "    - Automatically reads from environment variables\n",
    "    - Dotenv (`.env`) support via defacto standard [python-dotenv](https://pypi.org/project/python-dotenv/).\n",
    "- ORM-mode\n",
    "- Recursive models\n",
    "- Works with mypy out of the box, [mypy plugin](https://pydantic-docs.helpmanual.io/mypy_plugin/) further improves experience.\n",
    "- [Postponed annotations, self-referencing models](https://pydantic-docs.helpmanual.io/usage/postponed_annotations/), [PEP-563](https://www.python.org/dev/peps/pep-0563/)-style.\n",
    "- python-devtools intergration\n",
    "- PyCharm plugin\n",
    "- [Fast](https://pydantic-docs.helpmanual.io/benchmarks/) compared to popular alternatives!  \n",
    "  But always make your own benchmarks for your own usecase if performance is important for you.\n",
    "\n",
    "## Future\n",
    "- A strict mode is being worked on, in the future this will enable us to choose between Strict and Coercion on a model level instead of relying on the Strict* types.\n",
    "- The project is very active and a lot of improvements are constantly being made to the library.\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "Pure python syntax\n",
    "Better validation\n",
    "Very useful JSON-tools for API's\n",
    "Easy to migrate from dataclasses\n",
    "Lots of useful features\n",
    "Try it out!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Want to hear more from me? \n",
    "I'm making a course on property based testing in python using Hypothesis.  \n",
    "[Sign up here](https://forms.gle/yRWapypPXdPFSLME7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}