jupyter-notebooks/against-sql.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8584a46a-d125-4583-85ba-d2319b05a245",
   "metadata": {},
   "source": [
    "Jamie Brandon has a super thoughtful [writeup](https://www.scattered-thoughts.net/writing/against-sql/) titled `Against SQL` about how working with SQL is difficult and ways to improve upon it. While the latter task is comparable to implementing a new programming language, writing SQL queries can be made easier using regular programming abstractions. \n",
    "\n",
    "We address the SQL query examples highlighted in the post using FunSQL, which is a Julia/Python library  to compose SQL queries. While not dissimilar to pipelined DSLs or ORMs in its objective, it stays close to SQL semantics and aims to feel just like writing SQL directly. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a86457b7-18f8-423c-82b4-db9369ffc2a5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-26T10:51:11.259671Z",
     "iopub.status.busy": "2022-07-26T10:51:11.259326Z",
     "iopub.status.idle": "2022-07-26T10:51:11.270242Z",
     "shell.execute_reply": "2022-07-26T10:51:11.270424Z"
    }
   },
   "outputs": [],
   "source": [
    "from funsql import *"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97c37590-8ce4-43bd-a12b-fde181f5f3d4",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Verbose to express - [link](https://www.scattered-thoughts.net/writing/against-sql/#verbose-to-express)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1aefbb6a-cade-4771-a7af-e63410c6106a",
   "metadata": {},
   "source": [
    "The example given shows how SQL is verbose since we can't abstract over common patterns. While the SQL spec allows for function definitions, the article points out the limits wrt the types of the input args and hence the reduced flexibility. \n",
    "\n",
    "```sql\n",
    "select foo.id, quux.value \n",
    "from foo, bar, quux \n",
    "where foo.bar_id = bar.id and bar.quux_id = quux.id\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc15cc3a-597b-47be-830a-5624d4a5b7f8",
   "metadata": {},
   "source": [
    "Regular languages like python don't share the restrictions of SQL functions, so creating higher level abstractions is convenient. Here, we create a function to join multiple tables through foreign key relationships. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "96876e08-3b00-4de1-9bbb-6995c2783700",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-26T10:51:11.274198Z",
     "iopub.status.busy": "2022-07-26T10:51:11.273833Z",
     "iopub.status.idle": "2022-07-26T10:51:11.274951Z",
     "shell.execute_reply": "2022-07-26T10:51:11.275139Z"
    }
   },
   "outputs": [],
   "source": [
    "foo = SQLTable(S.foo, [\"id\", \"bar_id\"])\n",
    "bar = SQLTable(S.bar, [\"id\", \"quux_id\"])\n",
    "quux = SQLTable(S.quux, [\"id\", \"value\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eec576c2-3a64-432c-9c7e-030b92db2a80",
   "metadata": {},
   "source": [
    "Since FunSQL constructs are regular functions and objects in the host language, we can use them to abstract over composite SQL clauses. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3aab39f7-1005-449e-b3e0-1a62c7204980",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-26T10:51:11.280829Z",
     "iopub.status.busy": "2022-07-26T10:51:11.280493Z",
     "iopub.status.idle": "2022-07-26T10:51:11.281923Z",
     "shell.execute_reply": "2022-07-26T10:51:11.282157Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "query: \n",
       "SELECT\n",
       "  \"foo_1\".\"bar_id\", \n",
       "  \"bar_1\".\"quux_id\", \n",
       "  \"quux_1\".\"value\"\n",
       "FROM \"foo\" AS \"foo_1\"\n",
       "INNER JOIN \"bar\" AS \"bar_1\" ON (\"foo_1\".\"bar_id\" = \"bar_1\".\"id\")\n",
       "INNER JOIN \"quux\" AS \"quux_1\" ON (\"bar_1\".\"quux_id\" = \"quux_1\".\"id\")"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fk_join(*args, id_column=\"id\"):\n",
    "    # args is an interleaved list of tables and foreign key names\n",
    "    table = From(args[0])\n",
    "    fk_name = None\n",
    "    for i, arg in enumerate(args[1:]):\n",
    "        if i % 2 == 0:\n",
    "            fk_name = S(arg)\n",
    "        else:\n",
    "            joinee = From(arg)\n",
    "            table = table >> Join(\n",
    "                joinee, on=Fun(\"=\", Get(fk_name), Get(id_column, over=joinee))\n",
    "            )\n",
    "    return table\n",
    "\n",
    "\n",
    "q = fk_join(foo, \"bar_id\", bar, \"quux_id\", quux)\n",
    "render(q)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9de563b4-e2fb-416a-a0d4-94f606b33031",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Fragile structure - [link](https://www.scattered-thoughts.net/writing/against-sql/#fragile-structure)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9ca3933-1f93-4b17-a3c1-fdb5989a73d6",
   "metadata": {},
   "source": [
    "The example shows how correlated subqueries in a `SELECT` clause can only return a single column, and must be swapped for lateral joins if we need flexibility in the output type. \n",
    "\n",
    "```sql\n",
    "-- inline for a single column\n",
    "select\n",
    "    manager.name,\n",
    "    (select employee.name\n",
    "    from employee\n",
    "    where employee.manager = manager.name\n",
    "    order by employee.salary desc\n",
    "    limit 1)\n",
    "from manager;\n",
    "\n",
    "-- lateral join for multiple columns\n",
    "select manager.name, employee.name, employee.salary\n",
    "from manager\n",
    "join lateral (\n",
    "   select employee.name, employee.salary\n",
    "   from employee\n",
    "   where employee.manager = manager.name\n",
    "   order by employee.salary desc\n",
    "   limit 1\n",
    ") as employee\n",
    "on true;\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ddcc9020-c56d-454c-84ab-40b568047457",
   "metadata": {},
   "source": [
    "I couldn't find the reason for why inline subqueries are allowed at places where a _scalar_ expression is required  - args for a `SELECT` clause, `WHERE` expressions, and more. Though this feels like an inconsistency coming from SQL's desire to be less verbose? The nested query is really more like a _table_ than a _column_, so lateral joins are the \"correct\" choice. However, inline subqueries are slightly easier to read/write (and also test?). "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41808b4b-e05f-4586-bec9-0cb4047e3ad1",
   "metadata": {},
   "source": [
    "To _hide_ this detail from the query writer, we could compile to an inline query when a single column is selected, and use a lateral join otherwise. Alternatively, we could just output a lateral join everytime. By creating an abstraction for the `correlated join`, we can still keep the query syntax concise. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4a71e747-d508-4d41-8231-6be1a71c6c88",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-26T10:51:11.285901Z",
     "iopub.status.busy": "2022-07-26T10:51:11.285539Z",
     "iopub.status.idle": "2022-07-26T10:51:11.287060Z",
     "shell.execute_reply": "2022-07-26T10:51:11.287366Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "query: \n",
       "SELECT\n",
       "  \"employee_1\".\"name\", \n",
       "  \"employee_1\".\"salary\"\n",
       "FROM \"employee\" AS \"employee_1\"\n",
       "WHERE (\"employee_1\".\"manager\" = 'ABC')\n",
       "ORDER BY \"employee_1\".\"salary\" DESC\n",
       "LIMIT 1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "manager = SQLTable(\"manager\", [\"id\", \"name\"])\n",
    "employee = SQLTable(\"employee\", [\"id\", \"name\", \"salary\", \"manager\"])\n",
    "\n",
    "# returns highest paid employee for a given manager\n",
    "def most_paid_employee(m_name):\n",
    "    return (\n",
    "        From(employee)\n",
    "        >> Where(Fun(\"=\", Get.manager, Var.MANAGER_NAME))\n",
    "        >> Order(Get.salary >> Desc())\n",
    "        >> Limit(1)\n",
    "        >> Bind(aka(m_name, S.MANAGER_NAME))\n",
    "    )\n",
    "\n",
    "\n",
    "q = most_paid_employee(\"ABC\") >> Select(Get.name, Get.salary)\n",
    "render(q)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ae4db4e-9575-4929-b32f-44f9530d77ae",
   "metadata": {},
   "source": [
    "Now, we can use this subquery to compute top salaried employee for all the managers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "515ecfb8-357c-46a9-80cf-46ef222d1469",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-26T10:51:11.290555Z",
     "iopub.status.busy": "2022-07-26T10:51:11.290176Z",
     "iopub.status.idle": "2022-07-26T10:51:11.291684Z",
     "shell.execute_reply": "2022-07-26T10:51:11.291935Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "query: \n",
       "SELECT\n",
       "  \"manager_1\".\"name\", \n",
       "  \"employee_2\".\"name\" AS \"emp_name\", \n",
       "  \"employee_2\".\"salary\" AS \"emp_salary\"\n",
       "FROM \"manager\" AS \"manager_1\"\n",
       "LEFT JOIN LATERAL (\n",
       "  SELECT\n",
       "    \"employee_1\".\"name\", \n",
       "    \"employee_1\".\"salary\"\n",
       "  FROM \"employee\" AS \"employee_1\"\n",
       "  WHERE (\"employee_1\".\"manager\" = \"manager_1\".\"name\")\n",
       "  ORDER BY \"employee_1\".\"salary\" DESC\n",
       "  LIMIT 1\n",
       ") AS \"employee_2\" ON TRUE"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q = (\n",
    "    From(manager)\n",
    "    >> Join(most_paid_employee(Get.name) >> As(\"employee\"), on=True, left=True)\n",
    "    >> Select(\n",
    "        Get.name,\n",
    "        aka(Get.employee >> Get.name, \"emp_name\"),\n",
    "        aka(Get.employee.salary, \"emp_salary\"),\n",
    "    )\n",
    ")\n",
    "render(q)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c27fa516-ac7a-424c-9a16-a952e166bc95",
   "metadata": {},
   "source": [
    "Since the columns selected are specified in the end, we don't have to go back and edit the correlated query whether we pick single, multiple or no columns from it!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3d6aa13-fda4-4090-bb69-b326a328eb49",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Incompressible code - [link](https://www.scattered-thoughts.net/writing/against-sql/#incompressible)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53e14c0a-942c-44ce-97e0-6812cb09f349",
   "metadata": {},
   "source": [
    "The post provides multiple examples where SQL makes you tear your hair out. I concur. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "006ee5b5-c02c-4819-aac5-17dd0e90dbee",
   "metadata": {},
   "source": [
    "#### Variables"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de582c85-f58e-429b-903b-9f63b041e6d5",
   "metadata": {},
   "source": [
    "Temporary scalar variables can't be created unless they are included in the output. So, this arithmetic op can't be abstracted over without creating a subquery. \n",
    "\n",
    "```sql\n",
    "-- repeated structure\n",
    "select a+((z*2)-1), b+((z*2)-1) from foo;\n",
    "\n",
    "-- compressed?\n",
    "select a2, b2 from (select a+tmp as a2, b+tmp as b2, (z*2)-1 as tmp from foo);\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e097e3e4-ff95-49b2-baf9-6cd981181c1e",
   "metadata": {},
   "source": [
    "Since FunSQL nodes are regular python variables, we can just reuse them and hope they will be compiled away. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ece933d3-3166-4693-8614-9e67134fb1b0",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-26T10:51:11.295315Z",
     "iopub.status.busy": "2022-07-26T10:51:11.294968Z",
     "iopub.status.idle": "2022-07-26T10:51:11.296520Z",
     "shell.execute_reply": "2022-07-26T10:51:11.296808Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "query: \n",
       "SELECT\n",
       "  (((\"foo_1\".\"z\" * 2) - 1) + \"foo_1\".\"a\") AS \"a\", \n",
       "  (((\"foo_1\".\"z\" * 2) - 1) + \"foo_1\".\"b\") AS \"b\"\n",
       "FROM \"foo\" AS \"foo_1\""
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo = SQLTable(\"foo\", [\"a\", \"b\", \"z\"])\n",
    "\n",
    "\n",
    "def add_z(col):\n",
    "    z_sq = Fun(\"-\", Fun(\"*\", Get.z, 2), 1)\n",
    "    return Fun(\"+\", z_sq, col)\n",
    "\n",
    "\n",
    "q = From(foo) >> Select(add_z(Get.a) >> As(S.a), add_z(Get.b) >> As(S.b))\n",
    "render(q)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dcd9e7a-5a48-4b42-904b-43bffc73028c",
   "metadata": {},
   "source": [
    "SQL doesn't allow naming args to a `GROUP BY` clause. \n",
    "\n",
    "```sql\n",
    "-- can't name this value\n",
    "> select x2 from foo group by x+1 as x2;\n",
    "ERROR:  syntax error at or near \"as\"\n",
    "LINE 1: select x2 from foo group by x+1 as x2;\n",
    "\n",
    "-- sprinkle some more select on it\n",
    "> select x2 from (select x+1 as x2 from foo) group by x2;\n",
    " ?column?\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9633fb5a-37fd-44c2-869c-508886aa1339",
   "metadata": {},
   "source": [
    "FunSQL adds the variables created by the Group node to the namespace for that subquery, and moves the alias to the corresponding `SELECT`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c0a806d7-2c5f-43a2-a089-09a426062d72",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-26T10:51:11.300008Z",
     "iopub.status.busy": "2022-07-26T10:51:11.299612Z",
     "iopub.status.idle": "2022-07-26T10:51:11.300969Z",
     "shell.execute_reply": "2022-07-26T10:51:11.301151Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "query: \n",
       "SELECT\n",
       "  (\"foo_1\".\"x\" + 1) AS \"x2\", \n",
       "  count(\"foo_1\".\"y\") AS \"count\"\n",
       "FROM \"foo\" AS \"foo_1\"\n",
       "GROUP BY (\"foo_1\".\"x\" + 1)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo = SQLTable(\"foo\", [\"x\", \"y\"])\n",
    "q = (\n",
    "    From(foo)\n",
    "    >> Group(aka(Fun(\"+\", Get.x, 1), S.x2))\n",
    "    >> Select(Get.x2, Agg.count(Get.y))\n",
    ")\n",
    "\n",
    "render(q)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1eaf0aca-c1be-4c00-a077-89d1882d5555",
   "metadata": {},
   "source": [
    "#### CTEs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af457003-25a8-4d75-9ddb-f5bbfc2ad5d2",
   "metadata": {},
   "source": [
    "SQL didn't have CTEs until SQL:99. \n",
    "\n",
    "```sql\n",
    "-- repeated structure\n",
    "select * \n",
    "from \n",
    "  (select x, x+1 as x2 from foo) as foo1 \n",
    "left join \n",
    "  (select x, x+1 as x2 from foo) as foo2 \n",
    "on \n",
    "  foo1.x2 = foo2.x;\n",
    "  \n",
    "-- compressed?\n",
    "with foo_plus as \n",
    "  (select x, x+1 as x2 from foo)\n",
    "select * \n",
    "from \n",
    "  foo_plus as foo1 \n",
    "left join \n",
    "  foo_plus as foo2 \n",
    "on \n",
    "  foo1.x2 = foo2.x;\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9738a601-0c0b-4548-b99c-4ae6e4c034ef",
   "metadata": {},
   "source": [
    "With FunSQL, inline subqueries can be written similarly to CTEs without duplication. We just reuse the variable representing the subquery. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e86628b6-9b22-4774-bd10-10ca40704898",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-26T10:51:11.303414Z",
     "iopub.status.busy": "2022-07-26T10:51:11.303070Z",
     "iopub.status.idle": "2022-07-26T10:51:11.304094Z",
     "shell.execute_reply": "2022-07-26T10:51:11.304364Z"
    }
   },
   "outputs": [],
   "source": [
    "foo = SQLTable(\"foo\", [\"x\", \"y\"])\n",
    "foo_plus = From(foo) >> Select(Get.x, aka(Fun(\"+\", Get.x, 1), S.x2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "defcd1c8-d527-4543-b6dc-1c803d982d8d",
   "metadata": {},
   "source": [
    "The inline version gets rendered as,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1c276248-815e-49b2-9d5c-12576c74a46f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-26T10:51:11.306986Z",
     "iopub.status.busy": "2022-07-26T10:51:11.306664Z",
     "iopub.status.idle": "2022-07-26T10:51:11.307987Z",
     "shell.execute_reply": "2022-07-26T10:51:11.308214Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "query: \n",
       "SELECT\n",
       "  \"foo_2\".\"x\", \n",
       "  \"foo_2\".\"x2\"\n",
       "FROM (\n",
       "  SELECT\n",
       "    \"foo_1\".\"x\", \n",
       "    (\"foo_1\".\"x\" + 1) AS \"x2\"\n",
       "  FROM \"foo\" AS \"foo_1\"\n",
       ") AS \"foo_2\"\n",
       "LEFT JOIN (\n",
       "  SELECT\n",
       "    \"foo_3\".\"x\", \n",
       "    (\"foo_3\".\"x\" + 1) AS \"x2\"\n",
       "  FROM \"foo\" AS \"foo_3\"\n",
       ") AS \"foo_2_1\" ON (\"foo_2\".\"x2\" = \"foo_2_1\".\"x\")"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q = foo_plus >> Join(\n",
    "    aka(foo_plus, \"foo_2\"), left=True, on=Fun(\"=\", Get.x2, Get.foo_2.x)\n",
    ")\n",
    "render(q)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06759312-1e61-40c6-9dca-d6b62e74fbf1",
   "metadata": {},
   "source": [
    "While with the base table defined as a CTE,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "be43b8d5-39a7-4757-9455-24b325eb3e37",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-07-26T10:51:11.311066Z",
     "iopub.status.busy": "2022-07-26T10:51:11.310768Z",
     "iopub.status.idle": "2022-07-26T10:51:11.312161Z",
     "shell.execute_reply": "2022-07-26T10:51:11.312339Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "query: \n",
       "WITH \"foo_plus_1\" (\"x\", \"x2\")  AS (\n",
       "  SELECT\n",
       "    \"foo_1\".\"x\", \n",
       "    (\"foo_1\".\"x\" + 1) AS \"x2\"\n",
       "  FROM \"foo\" AS \"foo_1\"\n",
       ")\n",
       "SELECT\n",
       "  \"foo_plus_2\".\"x\", \n",
       "  \"foo_plus_2\".\"x2\"\n",
       "FROM \"foo_plus_1\" AS \"foo_plus_2\"\n",
       "LEFT JOIN \"foo_plus_1\" AS \"foo_plus_3\" ON (\"foo_plus_2\".\"x2\" = \"foo_plus_3\".\"x\")"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q = (\n",
    "    From(S.foo_plus)\n",
    "    >> Join(\n",
    "        aka(From(S.foo_plus), \"foo_plus_2\"),\n",
    "        left=True,\n",
    "        on=Fun(\"=\", Get.x2, Get.foo_plus_2.x),\n",
    "    )\n",
    "    >> With(foo_plus >> As(S.foo_plus))\n",
    ")\n",
    "render(q)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45f28089-407c-4d4b-9bb3-4aa0efc5ff9e",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f56cfc6-7472-4535-9695-643d711e2fc4",
   "metadata": {},
   "source": [
    "While SQL definitely needs a redo for the big list of reasons specified in the `Against SQL` post, FunSQL lets us get around some of the lexical issues with SQL. It could be useful to query systems speaking SQL either directly, or implementing a more concise DSL on top of it. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.5 ('base')",
   "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.9.5"
  },
  "vscode": {
   "interpreter": {
    "hash": "bee13da5dfd8cc2ab21d09493523ce7a17f20d31f50093ee24dd9a0766090f17"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}