tutorials/fugue_sql/extensions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Extensions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extensions are Python functions that are wrapped in order to execute in the `%%fsql`. These are needed to implement custom logic in SQL workflows. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creator\n",
    "\n",
    "`Creators` are functions that generate a `DataFrame`. The example below contains all syntax variations. Schema needs to be specified in the Python code, or in the SQL query. **Pandas** `DataFrames` have schema defined, so it does not need to be passed. The default `LOAD` an example of a `Creator`.\n",
    "\n",
    "A common use case for `Creator` is reading from a different data source like MongoDB Atlas or AWS S3.\n",
    "\n",
    "[Read more about Creators](../extensions/creator.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": "\nrequire([\"codemirror/lib/codemirror\"]);\nfunction set(str) {\n    var obj = {}, words = str.split(\" \");\n    for (var i = 0; i < words.length; ++i) obj[words[i]] = true;\n    return obj;\n  }\nvar fugue_keywords = \"fill hash rand even presort persist broadcast params process output outtransform rowcount concurrency prepartition zip print title save append parquet csv json single checkpoint weak strong deterministic yield connect sample seed take sub callback dataframe file\";\nCodeMirror.defineMIME(\"text/x-fsql\", {\n    name: \"sql\",\n    keywords: set(fugue_keywords + \" add after all alter analyze and anti archive array as asc at between bucket buckets by cache cascade case cast change clear cluster clustered codegen collection column columns comment commit compact compactions compute concatenate cost create cross cube current current_date current_timestamp database databases data dbproperties defined delete delimited deny desc describe dfs directories distinct distribute drop else end escaped except exchange exists explain export extended external false fields fileformat first following for format formatted from full function functions global grant group grouping having if ignore import in index indexes inner inpath inputformat insert intersect interval into is items join keys last lateral lazy left like limit lines list load local location lock locks logical macro map minus msck natural no not null nulls of on optimize option options or order out outer outputformat over overwrite partition partitioned partitions percent preceding principals purge range recordreader recordwriter recover reduce refresh regexp rename repair replace reset restrict revoke right rlike role roles rollback rollup row rows schema schemas select semi separated serde serdeproperties set sets show skewed sort sorted start statistics stored stratify struct table tables tablesample tblproperties temp temporary terminated then to touch transaction transactions transform true truncate unarchive unbounded uncache union unlock unset use using values view when where window with\"),\n    builtin: set(\"date datetime tinyint smallint int bigint boolean float double string binary timestamp decimal array map struct uniontype delimited serde sequencefile textfile rcfile inputformat outputformat\"),\n    atoms: set(\"false true null\"),\n    operatorChars: /^[*\\/+\\-%<>!=~&|^]/,\n    dateSQL: set(\"time\"),\n    support: set(\"ODBCdotTable doubleQuote zerolessFloat\")\n  });\n\nCodeMirror.modeInfo.push( {\n            name: \"Fugue SQL\",\n            mime: \"text/x-fsql\",\n            mode: \"sql\"\n          } );\n\nrequire(['notebook/js/codecell'], function(codecell) {\n    codecell.CodeCell.options_default.highlight_modes['magic_text/x-fsql'] = {'reg':[/%%fsql/]} ;\n    Jupyter.notebook.events.on('kernel_ready.Kernel', function(){\n    Jupyter.notebook.get_cells().map(function(cell){\n        if (cell.cell_type == 'code'){ cell.auto_highlight(); } }) ;\n    });\n  });\n",
      "text/plain": "<IPython.core.display.Javascript object>"
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from fugue_notebook import setup\n",
    "setup()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List, Any\n",
    "import pandas as pd\n",
    "\n",
    "def create1(n=1) -> pd.DataFrame:\n",
    "    return pd.DataFrame([[n]],columns=[\"a\"])\n",
    "\n",
    "# schema: a:int\n",
    "def create2(n=1) -> List[List[Any]]:\n",
    "    return [[n]]\n",
    "\n",
    "def create3(n=1) -> List[List[Any]]:\n",
    "    return [[n]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>a</th>\n      <th>b</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0</td>\n      <td>hello</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1</td>\n      <td>world</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
      "text/plain": "   a      b\n0  0  hello\n1  1  world"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<small>schema: a:int,b:str</small>",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>a</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>1</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
      "text/plain": "   a\n0  1"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<small>schema: a:long</small>",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>a</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>3</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
      "text/plain": "   a\n0  3"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<small>schema: a:int</small>",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>a</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>4</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
      "text/plain": "   a\n0  4"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<small>schema: a:int</small>",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>a</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>4</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
      "text/plain": "   a\n0  4"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<small>schema: a:int</small>",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%fsql\n",
    "CREATE [[0,\"hello\"],[1,\"world\"]] SCHEMA a:int,b:str\n",
    "PRINT\n",
    "CREATE USING create1 \n",
    "PRINT\n",
    "CREATE USING create2(n=3) \n",
    "PRINT\n",
    "CREATE USING create3(n=4) SCHEMA a:int PRINT\n",
    "PRINT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Outputter\n",
    "\n",
    "`Outputters` are functions that either write out `DataFrames` or display them. The default `SAVE` and `PRINT` are examples of Outputters. They do not return anything. They are invoked in SQL using the `OUTPUT` keyword.\n",
    "\n",
    "`PREPARTITION` can be used along with `Outputters` to apply the logic on each partition. This is only possible if the `Outputter interface` is used to define the extension.\n",
    "\n",
    "[Read more about Outputters](../extensions/outputter.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def output(df:pd.DataFrame, n=1) -> None:\n",
    "    print(n)\n",
    "    print(df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "   a\n",
      "0  0\n",
      "1\n",
      "   a\n",
      "0  0\n"
     ]
    }
   ],
   "source": [
    "%%fsql\n",
    "a=CREATE [[0]] SCHEMA a:int\n",
    "OUTPUT a USING output(n=2)\n",
    "OUTPUT PREPARTITION BY a USING output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Processor\n",
    "\n",
    "`Processors` take in multiple `DataFrames` and output one `DataFrame`. Similar to the `Outputter`, the SQL `PROCESS` keyword can be used in conjunction with `PREPARTITION` but only if the `Processor class interface` was used to define the `Processor`.\n",
    "\n",
    "[Read more about Processors](../extensions/processor.ipynb)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def concat(df1:pd.DataFrame, df2:pd.DataFrame) -> pd.DataFrame:\n",
    "    return pd.concat([df1,df2]).reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>a</th>\n      <th>b</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>0</td>\n      <td>1</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>1</td>\n      <td>2</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
      "text/plain": "   a  b\n0  0  1\n1  1  2"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<small>schema: a:int,b:str</small>",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%fsql\n",
    "a = CREATE [[0,\"1\"]] SCHEMA a:int,b:str\n",
    "b = CREATE [[1,\"2\"]] SCHEMA a:int,b:str\n",
    "PROCESS a,b USING concat\n",
    "PRINT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Transformer\n",
    "\n",
    "`Transformers` are the most used extension. They take one `DataFrame` in and output one `DataFrame`. This has appeared in the previous tutorials. It can be used with `PREPARTITION` to apply the `Transformer` to each parition.\n",
    "\n",
    "[Read more about Transformers](../extensions/transformer.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [\n",
    "    [\"A\", \"2020-01-01\", 10],\n",
    "    [\"A\", \"2020-01-02\", None],\n",
    "    [\"A\", \"2020-01-03\", 30],\n",
    "    [\"B\", \"2020-01-01\", 20],\n",
    "    [\"B\", \"2020-01-02\", None],\n",
    "    [\"B\", \"2020-01-03\", 40]\n",
    "]\n",
    "df = pd.DataFrame(data, columns=[\"id\", \"date\", \"value\"])\n",
    "\n",
    "# schema: *, shift:double\n",
    "def shift(df: pd.DataFrame) -> pd.DataFrame:\n",
    "    df['shift'] = df['value'].shift()\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>id</th>\n      <th>date</th>\n      <th>value</th>\n      <th>shift</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>A</td>\n      <td>2020-01-03</td>\n      <td>30.0</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>A</td>\n      <td>2020-01-02</td>\n      <td>NaN</td>\n      <td>30.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>A</td>\n      <td>2020-01-01</td>\n      <td>10.0</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>B</td>\n      <td>2020-01-03</td>\n      <td>40.0</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>B</td>\n      <td>2020-01-02</td>\n      <td>NaN</td>\n      <td>40.0</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>B</td>\n      <td>2020-01-01</td>\n      <td>20.0</td>\n      <td>NaN</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
      "text/plain": "  id        date  value  shift\n0  A  2020-01-03   30.0    NaN\n1  A  2020-01-02    NaN   30.0\n2  A  2020-01-01   10.0    NaN\n3  B  2020-01-03   40.0    NaN\n4  B  2020-01-02    NaN   40.0\n5  B  2020-01-01   20.0    NaN"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<small>schema: id:str,date:str,value:double,shift:double</small>",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>id</th>\n      <th>date</th>\n      <th>value</th>\n      <th>shift</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>A</td>\n      <td>2020-01-01</td>\n      <td>10.0</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>A</td>\n      <td>2020-01-02</td>\n      <td>NaN</td>\n      <td>10.0</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>A</td>\n      <td>2020-01-03</td>\n      <td>30.0</td>\n      <td>NaN</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>B</td>\n      <td>2020-01-01</td>\n      <td>20.0</td>\n      <td>30.0</td>\n    </tr>\n    <tr>\n      <th>4</th>\n      <td>B</td>\n      <td>2020-01-02</td>\n      <td>NaN</td>\n      <td>20.0</td>\n    </tr>\n    <tr>\n      <th>5</th>\n      <td>B</td>\n      <td>2020-01-03</td>\n      <td>40.0</td>\n      <td>NaN</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
      "text/plain": "  id        date  value  shift\n0  A  2020-01-01   10.0    NaN\n1  A  2020-01-02    NaN   10.0\n2  A  2020-01-03   30.0    NaN\n3  B  2020-01-01   20.0   30.0\n4  B  2020-01-02    NaN   20.0\n5  B  2020-01-03   40.0    NaN"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<small>schema: id:str,date:str,value:double,shift:double</small>",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%fsql\n",
    "a = SELECT * FROM df\n",
    "TRANSFORM a PREPARTITION BY id PRESORT date DESC USING shift\n",
    "PRINT\n",
    "TRANSFORM a USING shift    # default partition\n",
    "PRINT"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Spark** may give inconsistent results when using `TRANSFORM` without using `PREPARITION` because the default partitions are used. Also note order is not guaranteed in a distributed environment unless explicitly specified. `PREPARTITION` can also be used without a `PRESORT`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CoTransformer\n",
    "\n",
    "`CoTransformers` are the used on multiple `DataFrames` parititioned in the same way. The data is then joined together with an `INNER JOIN` by default, but it can be specified which join to use. In `FugueSQL`, `TRANSFORM` and `ZIP` are used together to apply the `CoTransformer`.\n",
    "\n",
    "[Read more about CoTransformers](../extensions/cotransformer.ipynb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from fugue import DataFrames\n",
    "\n",
    "#schema: res:[str]\n",
    "def to_str_with_key(dfs:DataFrames) -> List[List[Any]]:\n",
    "    return [[[k+\" \"+x.as_array().__repr__() for k,x in dfs.items()]]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>res</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>[_0 [[0, 1]], _1 [[0, 4]], _2 [[0, 2]]]</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
      "text/plain": "                                       res\n0  [_0 [[0, 1]], _1 [[0, 4]], _2 [[0, 2]]]"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<small>schema: res:[str]</small>",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>res</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>[a [[0, 1]], b [[0, 4]], c [[0, 2]]]</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>[a [[1, 3]], b [], c [[1, 1], [1, 5]]]</td>\n    </tr>\n  </tbody>\n</table>\n</div>",
      "text/plain": "                                      res\n0    [a [[0, 1]], b [[0, 4]], c [[0, 2]]]\n1  [a [[1, 3]], b [], c [[1, 1], [1, 5]]]"
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": "<small>schema: res:[str]</small>",
      "text/plain": "<IPython.core.display.HTML object>"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%fsql\n",
    "df1 = CREATE [[0,1],[1,3]] SCHEMA a:int,b:int\n",
    "df2 = CREATE [[0,4],[2,2]] SCHEMA a:int,c:int\n",
    "df3 = CREATE [[0,2],[1,1],[1,5]] SCHEMA a:int,d:int\n",
    "\n",
    "TRANSFORM (ZIP df1,df2,df3) USING to_str_with_key\n",
    "PRINT\n",
    "\n",
    "TRANSFORM (ZIP a=df1,b=df2,c=df3 LEFT OUTER BY a PRESORT b DESC) USING to_str_with_key\n",
    "PRINT"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.9 64-bit ('fugue-tutorials': conda)",
   "metadata": {
    "interpreter": {
     "hash": "131b24c7e1bb8763ab2b04d5b6d98a68c7b3a823a2a57c5722935f7690890f70"
    }
   },
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.7.9"
  },
  "orig_nbformat": 2
 },
 "nbformat": 4,
 "nbformat_minor": 2
}