ioos_ckan_catalog/ioos_catalog_data_coverage_map.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "conscious-cornell",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import re\n",
    "\n",
    "import ckanapi\n",
    "import time\n",
    "import pandas as pd\n",
    "import geopandas\n",
    "\n",
    "import panel as pn\n",
    "import param\n",
    "pn.extension()\n",
    "\n",
    "import geojson\n",
    "from shapely.geometry import shape, Point\n",
    "\n",
    "import folium\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import os\n",
    "import sys\n",
    "module_path = os.path.abspath(os.path.join('..'))\n",
    "if module_path not in sys.path:\n",
    "    sys.path.append(module_path)\n",
    "\n",
    "#from .ioos_ckanapi.util import test_func\n",
    "from ioos_ckan_catalog.ioos_ckanapi.util import query_ckan, create_geodataframe, plot\n",
    "#from ioos_ckan_catalog.ioos_ckanapi.util import create_geodataframe, plot\n",
    "\n",
    "#from ioos_ckan_catalog import ioos_ckanapi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "welcome-subscriber",
   "metadata": {},
   "source": [
    "### Set up a ckanapi client to query IOOS Catalog"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "authorized-intermediate",
   "metadata": {},
   "outputs": [],
   "source": [
    "from ckanapi import RemoteCKAN\n",
    "ua = 'ckanapiioos/1.0 (+https://ioos.us/)'\n",
    "ioos_catalog = RemoteCKAN('https://data.ioos.us', user_agent=ua)\n",
    "ioos_catalog"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "opposite-settle",
   "metadata": {},
   "source": [
    "### Query examples using ckanapi:\n",
    "\n",
    "More information about ckanapi is available at: https://github.com/ckan/ckanapi.\n",
    "\n",
    "**Example command line execution of ckanapi:**\n",
    "```\n",
    "ckanapi action package_search -r https://data.ioos.us q=res_format:ERDDAP-TableDAP fq=cf_standard_names:mass_concentration_of_oxygen_in_sea_water rows=1\n",
    "```\n",
    "\n",
    "**Example queries using the Python package**\n",
    "\n",
    "First, filter only for `cf_standard_names:mass_concentration_of_oxygen_in_sea_water` (should produce ~ 574 results)::\n",
    "```\n",
    "datasets = ioos_catalog.action.package_search(fq='+cf_standard_names:mass_concentration_of_oxygen_in_sea_water', rows=50)\n",
    "datasets['count']\n",
    "```\n",
    "\n",
    "Add a filter for `res_format:ERDDAP-TableDAP` (~ 507 results)::\n",
    "```\n",
    "datasets = ioos_catalog.action.package_search(q='+res_format:ERDDAP-TableDAP', fq='+cf_standard_names:mass_concentration_of_oxygen_in_sea_water', rows=50)\n",
    "datasets['count']\n",
    "```\n",
    "\n",
    "Adding an organization filter for `+organization:gcoos` (~ 143 results):\n",
    "```\n",
    "datasets = ioos_catalog.action.package_search(q='+res_format:ERDDAP-TableDAP +organization:gcoos', fq='+cf_standard_names:mass_concentration_of_oxygen_in_sea_water', rows=50)\n",
    "datasets['count']\n",
    "```\n",
    "\n",
    "Next, we'll create some controls to automate the parameter selection and generate these queries dynamically."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "expressed-highway",
   "metadata": {},
   "source": [
    "### Query IOOS Catalog to Populate Parameter Pulldowns\n",
    "\n",
    "We can query CKAN API endpoints to populate pulldown menus for filter criteria for dataset queries.  Endpoints available to populate information from CKAN database include:\n",
    "- [tag_list](https://docs.ckan.org/en/latest/api/index.html#ckan.logic.action.get.tag_list)\n",
    "- [organization_list](https://docs.ckan.org/en/latest/api/index.html#ckan.logic.action.get.organization_list)\n",
    "\n",
    "Use ckanapi to query these IOOS Catalog endpoints for values. Some filtering is necessary for things like tag_list to restrict to CF Standard Names (approximately)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "confident-party",
   "metadata": {},
   "outputs": [],
   "source": [
    "tags = ioos_catalog.action.tag_list()\n",
    "organizations = ioos_catalog.action.organization_list()\n",
    "organizations.insert(0,None)\n",
    "\n",
    "for i, org in enumerate(organizations):\n",
    "    print(f\"i: {i}, org: {org}\")\n",
    "    if i >= 10: break"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "level-blond",
   "metadata": {},
   "source": [
    "Next, filter this list using regex to only include tags that match the CF Standard Name patterns (underscore ('_') between text phrases).\n",
    "\n",
    "We need to use one of the acceptable approaches to removing elements from a list in Python like `filter` or list comprehension (ie not iterating usina a for in loop becuase the indexes get messed up ):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "divided-burton",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"tags length: {len(tags)}\")\n",
    "\n",
    "# any will work:\n",
    "#p = re.compile(\"\\S*_\\S*\")\n",
    "#p = re.compile(\".*_.*\")\n",
    "p = re.compile(\"_+?\")\n",
    "#p = re.compile(\"_+\")\n",
    "#p = re.compile(\"_{1}\")\n",
    "\n",
    "# doesn't work (matches anything):\n",
    "#p = re.compile(\"_*\")\n",
    "\n",
    "tags_filtered = list(filter(lambda tag: p.search(tag), tags))\n",
    "#tags_filtered = [tag for tag in tags if p.search(tag)]\n",
    "\n",
    "# filter whitespace and bracket characters:\n",
    "whitespace = re.compile(\"\\s+?\")\n",
    "bracket = re.compile(\"[<>]\")\n",
    "tags_filtered = list(filter(lambda tag: not whitespace.search(tag) and not bracket.search(tag), tags_filtered))\n",
    "tags_filtered.insert(0,None)\n",
    "\n",
    "# print out the first 10 tags in tags_filtered:\n",
    "print(f\"tags_filtered length: {len(tags_filtered)}\")\n",
    "for i, tag in enumerate(tags_filtered):\n",
    "    print(f\"i: {i}, tag: {tag}\")\n",
    "    if i >= 10: break"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "short-utility",
   "metadata": {},
   "source": [
    "For CKAN Resource Formats, according to the [CKAN API docs](https://docs.ckan.org/en/latest/api/index.html) there doesn't appear to be an API function to obtain a list, so instead we just create it manually."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "preliminary-regular",
   "metadata": {},
   "outputs": [],
   "source": [
    "formats = ['OPeNDAP','ERDDAP-TableDAP','ERDDAP-GridDAP','ERDDAP-WMS','SOS','HTML','WCS','WMS','WFS','XML','PDF','TXT']\n",
    "formats.insert(0,None)\n",
    "for i, tag in enumerate(formats):\n",
    "    print(f\"i: {i}, tag: {tag}\")\n",
    "    if i >= 10: break"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sound-metadata",
   "metadata": {},
   "source": [
    "Create a Param selector to choose a CF Standard Name for query:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "wicked-housing",
   "metadata": {},
   "outputs": [],
   "source": [
    "class CatalogParams(param.Parameterized):\n",
    "    #sel_cf_std_name = param.ObjectSelector(objects=tags_filtered, default=tags_filtered[0], allow_None=True, label=\"Select a CF Standard Name:\")\n",
    "    #sel_cf_std_name = param.ObjectSelector(objects=tags_filtered, default='mass_concentration_of_oxygen_in_sea_water', allow_None=True, label=\"Select a CF Standard Name:\")\n",
    "    sel_cf_std_name = param.ObjectSelector(objects=tags_filtered, default='sea_water_turbidity', allow_None=True, label=\"Select a CF Standard Name:\")\n",
    "    sel_organization = param.ObjectSelector(objects=organizations, default=None, allow_None=True, label=\"Select an Organization:\")\n",
    "    sel_format = param.ObjectSelector(objects=formats, default=None, allow_None=True, label=\"Select a Format:\")\n",
    "    sel_plot_type = param.ObjectSelector(objects=['Static Map','Heat Map'], default='Heat Map', allow_None=False, label=\"Select a Plot Type:\")\n",
    "chart_params = CatalogParams()\n",
    "chart_params\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "received-corruption",
   "metadata": {},
   "source": [
    "Create some Panel widgets to provide the interactive controls and outputs for the query/plot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "present-vinyl",
   "metadata": {},
   "outputs": [],
   "source": [
    "generate_plot_button = pn.widgets.Button(name='Generate Plot', button_type='primary')\n",
    "status = pn.widgets.TextInput(value='')\n",
    "\n",
    "def generate_plot(event):\n",
    "    status.value = \"Querying IOOS Catalog for datasets...\"\n",
    "    list_of_datasets = query_ckan(ioos_catalog, sel_cf_std_name=chart_params.sel_cf_std_name, sel_organization=chart_params.sel_organization, sel_format=chart_params.sel_format)\n",
    "    gdf = create_geodataframe(list_of_datasets)\n",
    "    ioos_plot = plot(gdf, sel_cf_std_name=chart_params.sel_cf_std_name, sel_organization=chart_params.sel_organization, sel_format=chart_params.sel_format, sel_plot_type=chart_params.sel_plot_type)\n",
    "    #gspec[1:,1:4] = None\n",
    "    gspec[1:,1:4] = pn.panel(ioos_plot)\n",
    "    status.value = \"Completed query.\"\n",
    "    \n",
    "generate_plot_button.on_click(generate_plot)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "destroyed-pressure",
   "metadata": {},
   "source": [
    "Define a Panel layout to hold our parameter selection pulldowns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "positive-recognition",
   "metadata": {},
   "outputs": [],
   "source": [
    "#gspec = pn.GridSpec(sizing_mode='stretch_height', height_policy='fit')\n",
    "\n",
    "# define a Panel GridSpec object with 4 columns and 10 rows:\n",
    "gspec = pn.GridSpec(mode='override', sizing_mode='stretch_both', max_height=800)\n",
    "gspec[0, 0:] = chart_params\n",
    "#gspec[1,0] = pn.Row(generate_plot_button, status)\n",
    "gspec[1,0] = generate_plot_button\n",
    "gspec[2:10,0] = status\n",
    "gspec[1:,1:4] = pn.widgets.TextInput(value='Placeholder')\n",
    "gspec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "contemporary-cedar",
   "metadata": {},
   "outputs": [],
   "source": [
    "ioos_plot"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "powerful-casting",
   "metadata": {},
   "source": [
    "#### Submit a query to the CKAN API with parameters of interest\n",
    "\n",
    "See the util.query_ckan() function for details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "graduate-empire",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "result_rows = 50\n",
    "result_count = 0\n",
    "max_results = 5000\n",
    "list_of_datasets = []\n",
    "datasets_dict = {}\n",
    "\n",
    "q = \"\"\n",
    "q = q + f\" +organization:{chart_params.sel_organization}\" if chart_params.sel_organization is not None else q\n",
    "q = q + f\" +res_format:{chart_params.sel_format}\" if chart_params.sel_format is not None else q\n",
    "print(f\"q: {q}\")\n",
    "    \n",
    "fq = \"\"\n",
    "fq = fq + f\" +cf_standard_names:{chart_params.sel_cf_std_name}\" if chart_params.sel_cf_std_name is not None else fq\n",
    "print(f\"fq: {fq}\")\n",
    "\n",
    "while True:\n",
    "    #datasets = ioos_catalog.action.package_search(q='+res_format:ERDDAP-TableDAP +organization:cencoos', fq='+cf_standard_names:mass_concentration_of_oxygen_in_sea_water', rows=10, start=result_count)\n",
    "    #datasets = ioos_catalog.action.package_search(q='+res_format:ERDDAP-TableDAP +res_format:OPeNDAP', fq='+cf_standard_names:mass_concentration_of_oxygen_in_sea_water', rows=50, start=result_count)\n",
    "    datasets = ioos_catalog.action.package_search(q=q, fq=fq, rows=result_rows, start=result_count)\n",
    "    num_results = datasets['count']\n",
    "    print(f\"num_results: {num_results}, result_count: {result_count}\")\n",
    "    \n",
    "    # let's add a check to avoid processing too many results:\n",
    "    if num_results > max_results: \n",
    "        print(f\"Your query returned > {max_results} results.  Try adjusting the parameters to be more selective - the IOOS Catalog server will thank you.\")\n",
    "        break\n",
    "        \n",
    "    # if we return a large number of results (max_results/2), adjust the result_rows value higher to reduce roundtrips:\n",
    "    if num_results > max_results / 2:\n",
    "        result_rows = max_results / 10\n",
    "    elif num_results > max_results / 5:\n",
    "        result_rows = max_results / 25\n",
    "    \n",
    "    for dataset in datasets['results']:\n",
    "        datasets_dict = parse_result(dataset)\n",
    "        list_of_datasets.append(datasets_dict)\n",
    "        result_count = result_count + 1\n",
    "    time.sleep(1)\n",
    "    if(result_count >= num_results):\n",
    "        print(f\"num_results: {num_results}, result_count: {result_count}\")\n",
    "        break\n",
    "\n",
    "# output datasets_dict.keys() and an example dataset:\n",
    "print(f\"datasets_dict_keys: {datasets_dict.keys()}\")\n",
    "if len(list_of_datasets) > 0: [print(key,':',value) for key, value in list_of_datasets[0].items()]\n",
    "#if len(list_of_datasets) > 0: print(json.dumps(list_of_datasets[0], indent=4))\n",
    "'''\n",
    "list_of_datasets = query_ckan(ioos_catalog, sel_cf_std_name=chart_params.sel_cf_std_name, sel_organization=chart_params.sel_organization, sel_format=chart_params.sel_format)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "binary-swift",
   "metadata": {},
   "source": [
    "#### Convert the GeoJSON 'spatial' column to Shapely geometry object to use with GeoPandas\n",
    "\n",
    "Resulting fields/columns:\n",
    "- 'spatial': Shapely Polygon\n",
    "- 'spatial_point': Shapely Polygon and Point (depending on the size of the original polygon bounding box)\n",
    "- 'spatial_geojson': GeoJSON text field, the original 'spatial' field value from CKAN API\n",
    "\n",
    "WKT is supposed to work according to the [docs](https://geopandas.org/gallery/create_geopandas_from_pandas.html), but seems to fail."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eligible-justice",
   "metadata": {},
   "outputs": [],
   "source": [
    "#df = pd.DataFrame(list_of_datasets).dropna(subset=[df.spatial])\n",
    "df = pd.DataFrame(list_of_datasets)\n",
    "df.dropna(subset=['spatial'], inplace=True)\n",
    "\n",
    "\n",
    "# create a new column to store the original 'spatial' column (which is GeoJSON format):\n",
    "df['spatial_geojson'] = df.spatial\n",
    "\n",
    "# convert the 'spatial' column from GeoJSON to Shapely geometry for GeoPandas compatibility:\n",
    "df.spatial = df.spatial.apply(lambda x: shape(geojson.loads(x)))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "entire-massachusetts",
   "metadata": {},
   "source": [
    "Create a new 'spatial_point' column of Shapely geometry objects that converts any geometries where the difference between lat/lon min and max is < .0001 degree to Point, and retains all the others as Polygon:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fewer-anniversary",
   "metadata": {},
   "outputs": [],
   "source": [
    "# the approach below uses abs() account for postive/negative lat/lon coordinates to perform the calculation correctly for all quadrants on the globe (or for features crossing meridian/equator)\n",
    "df['spatial_point'] = df.apply(lambda row: row.spatial if abs(abs(float(row['bbox-west-long'])) - abs(float(row['bbox-east-long']))) > 0.0001 and abs(abs(float(row['bbox-north-lat'])) - abs(float(row['bbox-south-lat']))) > 0.0001 else Point(float(row['bbox-east-long']), float(row['bbox-south-lat'])), axis=1)\n",
    "\n",
    "# same as above but without using abs():\n",
    "#df['spatial_point'] = df.apply(lambda row: row.spatial if float(row['bbox-east-long']) - float(row['bbox-west-long']) > 0.0001 and float(row['bbox-north-lat']) - float(row['bbox-south-lat']) > 0.0001 else Point(float(row['bbox-east-long']), float(row['bbox-south-lat'])), axis=1)\n",
    "\n",
    "# this just converts every tow to a Point object:\n",
    "#df['#spatial_point'] = df.apply(lambda row: Point(float(row['bbox-east-long']), float(row['bbox-south-lat'])), axis=1)\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "variable-harvest",
   "metadata": {},
   "source": [
    "**Debug/Testing:** \n",
    "\n",
    "The code in the first for loop just outputs the df.spatial_geojson in WKT and the second for loop lists the converted WKT geometries in df.spatial_point for all rows in the DataFrame.\n",
    "\n",
    "Commented out as it's not necessary to run in order for the notebook to execute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sensitive-munich",
   "metadata": {},
   "outputs": [],
   "source": [
    "#for shape_geojson in (df.spatial_geojson):\n",
    "#    geom = shape(geojson.loads(shape_geojson))\n",
    "#    print(f\"wkt: {geom.wkt}\")\n",
    "#    print(f\"wkb: {geom.wkb}\")\n",
    " \n",
    "#for spatial_val in df.spatial: print(spatial_val)\n",
    "#for spatial_val in df.spatial_geojson: print(spatial_val)\n",
    "\n",
    "print(type(df.spatial_point[0]))\n",
    "print(type(df.spatial[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fatty-central",
   "metadata": {},
   "source": [
    "### GeoPandas GeoDataFrame\n",
    "\n",
    "Create a GeoPandas GeoDataFrame from the regular Pandas DataFrame.  Assign geometry column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "altered-examination",
   "metadata": {},
   "outputs": [],
   "source": [
    "gdf = geopandas.GeoDataFrame(df)\n",
    "#gdf.set_geometry(\"spatial\", inplace=True, crs=\"EPSG:4326\")\n",
    "gdf.set_geometry(\"spatial_point\", inplace=True, crs=\"EPSG:4326\")\n",
    "\n",
    "# print the name of the GeoPandas geometry column name:\n",
    "gdf.geometry.name\n",
    "#gdf\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "charitable-cloud",
   "metadata": {},
   "source": [
    "### Plotting\n",
    "\n",
    "Examples taken from: https://geopandas.readthedocs.io/en/latest/gallery/plotting_with_folium.html\n",
    "\n",
    "#### Make a simple plot color-coded by the `creator_sector` field"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bizarre-savings",
   "metadata": {},
   "outputs": [],
   "source": [
    "gdf.plot(column='creator_sector', figsize=(18, 18), legend=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "finite-fraud",
   "metadata": {},
   "source": [
    "#### Create a more complicated plot with world continents background.\n",
    "\n",
    "**To Do:** \n",
    "- retrieve a bounding box from the GeoDataFrame and set plot extent to match (defaults to extent of largest dataset, in this case the natural earth background)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "emotional-british",
   "metadata": {},
   "outputs": [],
   "source": [
    "world = geopandas.read_file(geopandas.datasets.get_path('naturalearth_lowres'))\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(24,18))\n",
    "world.plot(ax=ax, alpha=0.4, color='grey')\n",
    "#gdf.plot(column='spatial', ax=ax, legend=True)\n",
    "gdf.plot(ax=ax, column='creator_sector', legend=True)\n",
    "plt.title(f\"IOOS Catalog Dataset Coverage.  Filters - CF Std Name: {chart_params.sel_cf_std_name}, Org: {chart_params.sel_organization}, Format: {chart_params.sel_format}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "attempted-blackberry",
   "metadata": {},
   "outputs": [],
   "source": [
    "from folium import plugins\n",
    "\n",
    "map = folium.Map(location = [15,30], tiles='Cartodb dark_matter', zoom_start = 2)\n",
    "\n",
    "heat_data = [[geom.xy[1][0], geom.xy[0][0]] if geom.geom_type == \"Point\" else [geom.centroid.xy[1][0], geom.centroid.xy[0][0]] for geom in gdf.geometry ]\n",
    "\n",
    "heat_data\n",
    "plugins.HeatMap(heat_data).add_to(map)\n",
    "\n",
    "map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "complimentary-syndicate",
   "metadata": {},
   "outputs": [],
   "source": [
    "map = folium.Map(location = [13.406,80.110], tiles='OpenStreetMap' , zoom_start = 9)\n",
    "map"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cutting-kingston",
   "metadata": {},
   "source": [
    "### Demo CKAN Instance Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "moved-cologne",
   "metadata": {},
   "outputs": [],
   "source": [
    "#ioos_catalog = RemoteCKAN('https://data.ioos.us', user_agent=ua, get_only=True)\n",
    "demo = RemoteCKAN('https://demo.ckan.org', user_agent=ua)\n",
    "demo\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "heard-contrary",
   "metadata": {},
   "outputs": [],
   "source": [
    "demo_datasets = demo.action.group_list(id='Test%20Group')\n",
    "print(groups)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "selective-valuable",
   "metadata": {},
   "outputs": [],
   "source": [
    "demo_datasets = demo.action.package_search(q='+organization:sample-organization +res_format:GeoJSON +tags:geojson')\n",
    "demo_datasets['count']\n",
    "#print(demo_datasets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "clinical-conviction",
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}