data-access-with-stac.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "963119e7-5b99-4bfd-9a24-ad3bcec89d67",
   "metadata": {},
   "source": [
    "# Data access with STAC\n",
    "\n",
    "This section introduces [STAC](https://stacspec.org/), the SpatioTemporal Asset Catalog. STAC provides a standardized way to structure metadata about spatialotemporal data. The STAC community are building APIs and tools on top of this structure to make working with spatiotemporal data easier.\n",
    "\n",
    "This notebook will give a brief introduction to the concepts defined by STAC, before moving on to using the STAC API easily find and load data."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89aa2b68-5483-4472-84e3-0a6bc51845e3",
   "metadata": {},
   "source": [
    "## Introduction to STAC\n",
    "\n",
    "Users of STAC will interact most often with **Collections** and **Items** (there's also **Catalogs**, which group together collections). A Collection is just a collection of items, plus some additional metadata like the license and summaries of what's available on each item. You can view the collections available on the Planetary Computer at https://planetarycomputer.microsoft.com/catalog. There's also [STAC Index](https://stacindex.org/), which maintains a list of public catalogs.\n",
    "\n",
    "Let's load up the collection for Sentinel 2 Level 2-A, and compare it to the [HTML version](https://planetarycomputer.microsoft.com/dataset/sentinel-2-l2a) on the Planetary Computer website (which is generated from the STAC metadata)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e427f285-804f-43ca-915d-955f152f64fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pystac\n",
    "\n",
    "sentinel2 = pystac.read_file(\n",
    "    \"https://planetarycomputer.microsoft.com/api/stac/v1/collections/sentinel-2-l2a/\"\n",
    ")\n",
    "sentinel2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c1b4a4b-0192-43b0-8aee-1cf71dfd3faf",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sentinel2.description)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66468189-b2bc-48f7-b3dd-b8103de63b22",
   "metadata": {},
   "outputs": [],
   "source": [
    "sentinel2.extent.spatial.to_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb5cf795-f881-4b77-86b6-bddc3b07ddc7",
   "metadata": {},
   "outputs": [],
   "source": [
    "sentinel2.extent.temporal.to_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6785840-d214-4064-8a5d-ef994d7e9c8a",
   "metadata": {},
   "source": [
    "Now let's take a look at a specific item. In this case, we'll load an item that covers the area just north of Buenos Aires: https://planetarycomputer.microsoft.com/api/stac/v1/collections/sentinel-2-l2a/items/S2A_MSIL2A_20210811T135121_R024_T21HUC_20210812T044104"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8f09512-d517-4421-8ce2-b74bcc89a0fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "item = pystac.read_file(\n",
    "    \"https://planetarycomputer.microsoft.com/api/stac/v1/collections\"\n",
    "    \"/sentinel-2-l2a/items/\"\n",
    "    \"S2A_MSIL2A_20210811T135121_R024_T21HUC_20210812T044104\"\n",
    ")\n",
    "item"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79cf0e6c-936d-487e-bf75-063114954ff4",
   "metadata": {},
   "source": [
    "The STAC item has a whole bunch of metadata about the Sentinel-2 scene."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "222d4649-738b-42fc-b979-9389dfd1f9f6",
   "metadata": {},
   "source": [
    "### Exercise: What time was the scene captured?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78372374-7e3e-4dec-94f2-79d1ee605685",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load solutions/stac-item-datetime.py\n",
    "# What time was the scene captured?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73d098ff-0708-4af6-a6f3-d291360b159b",
   "metadata": {},
   "source": [
    "### Exercise: What is the bounding box for the item?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bae13c60-6e2d-4d9a-9cd0-78106e61988a",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load solutions/stac-item-bbox.py\n",
    "# What is the bounding box for the item?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84e34480-f65a-4971-9255-c57b4307cbf6",
   "metadata": {},
   "source": [
    "The core STAC specification covers things that are common to pretty much any geospatial dataset. STAC is built to be extensible to facilate catologing metadata that's specific to certain datasets or certain kinds of datasets.\n",
    "\n",
    "For example, the `proj` extension allows you to get projection-related information, like the EPSG code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "062f8baa-daeb-4a00-810f-25cf1d2e6fe0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pystac.extensions.projection import ProjectionExtension\n",
    "\n",
    "ProjectionExtension.ext(item).epsg"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7eac9820-d982-4834-a8f5-22f03cbfd313",
   "metadata": {},
   "source": [
    "Or the [geo `transform`](https://github.com/stac-extensions/projection#projtransform)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edb2f826-9a20-43a7-b0e3-7a8b699f1d07",
   "metadata": {},
   "outputs": [],
   "source": [
    "ProjectionExtension.ext(item.assets[\"B03\"]).transform"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cf53480-4a52-4aed-be80-d03a32775930",
   "metadata": {},
   "source": [
    "## Exercise: How cloudy is the item?\n",
    "\n",
    "Use `pystac.extensions.eo.EOExtension` to get the cloud cover. See https://pystac.readthedocs.io/en/latest/api.html?highlight=EOExtension#eoextension for help."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0c559b9-eb19-41a7-b860-bf83e08c3e7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pystac.extensions.eo import EOExtension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "901e6b63-5142-458c-93ef-48c78470a3b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load solutions/stac-item-cloud-cover.py\n",
    "# How cloud is the item? Use pystac.extension.eo.EOExtension"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c783580-3ded-463c-82cf-beb27e8024c5",
   "metadata": {},
   "source": [
    "You can view the full list of STAC extensions at <https://stac-extensions.github.io/>\n",
    "\n",
    "### Assets\n",
    "\n",
    "STAC is a *metadata* standard. It doesn't really deal with data files directly. Instead, it links to the data files under the \"assets\" property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a4902f4-3004-47a4-b786-cd84ab5dc799",
   "metadata": {},
   "outputs": [],
   "source": [
    "item.assets"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e3b0093-31db-48cc-8858-43c5ab3a2883",
   "metadata": {},
   "source": [
    "Browsing through that list, most of the assets are link to Cloud Optimized GeoTIFF files in Azure Blob Storage. There are a few other metadata-related assets, and some \"preview\"-related assets.\n",
    "\n",
    "We can use the \"tilejson\" URL, combined with `ipyleaflet` and the Item's geometry to quickly visualize the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53622aaa-825b-45ef-8fac-fdc24a17f5d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from ipyleaflet import Map, TileLayer, GeoJSON, FullScreenControl\n",
    "import shapely.geometry\n",
    "import requests\n",
    "\n",
    "center = shapely.geometry.shape(item.geometry).centroid.bounds[:2][::-1]\n",
    "\n",
    "m = Map(center=center, zoom=12)\n",
    "layer = TileLayer(\n",
    "    url=requests.get(item.assets[\"tilejson\"].href).json()[\"tiles\"][0],\n",
    ")\n",
    "m.add_layer(layer)\n",
    "m.add_control(FullScreenControl())\n",
    "\n",
    "m.scroll_wheel_zoom = True\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5dccbba8-e0e8-43ef-8c8a-cf3c30d5d92b",
   "metadata": {},
   "source": [
    "### Signing for the Planetary Computer\n",
    "\n",
    "If you try to open any of the data assets (e.g. \"B02\" for the blue band) you'll get a 404 error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "590c92ae-7998-4077-ace3-b7a2d0244ccf",
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "\n",
    "r = requests.get(item.assets[\"B02\"].href)\n",
    "r.status_code"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b814739-9aaf-4ce0-9f88-ad05571c8aa8",
   "metadata": {},
   "source": [
    "So while the STAC *metadata* is all public, *data* from the Planetary Computer is typically in private Blob Storage containers. But, you can access it anonymously by *signing* the item / asset / href."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d6f5747-1aa1-4452-9c52-264c7e52f9ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "import rioxarray\n",
    "import planetary_computer\n",
    "\n",
    "ds = rioxarray.open_rasterio(planetary_computer.sign(item.assets[\"B02\"].href))\n",
    "ds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7cf39e6c-04a8-4572-87bb-2559852fe81b",
   "metadata": {},
   "source": [
    "You can sign ItemCollections, Items, Assets, or URLs. Once a URL has been signed, it can be opened with any of your favorite tools (rioxarray, rasterio / GDAL, QGIS, etc.)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7b4cda6-4adf-4818-bc9e-ef60c56576aa",
   "metadata": {},
   "source": [
    "## Querying the STAC API\n",
    "\n",
    "In the examples we've seen so far, we've just been given a STAC item. How do you find the items you want in the first place? That's where a STAC **API** comes in.\n",
    "\n",
    "A STAC API is some web service that accepts queries and returns STAC objects. The ability to handle queries is what differentiates a STAC API from a *static* STAC catalog, where items are just present on some file system.\n",
    "\n",
    "![image.png](ms-stac.png)\n",
    "\n",
    "Visit https://planetarycomputer.microsoft.com/api/stac/v1/docs for documentation on a STAC API with HTTP requests. We'll use [pystac-client](https://pystac-client.readthedocs.io/en/latest/)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59cdc9d2-afa3-4bbd-865d-1cdc2100f1da",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pystac_client\n",
    "\n",
    "bbox = [-58.92, -34.81, -58.26, -34.18]\n",
    "date_range = \"2020-01-01/2020-12-31\"\n",
    "\n",
    "catalog = pystac_client.Client.open(\n",
    "    \"https://planetarycomputer.microsoft.com/api/stac/v1\"\n",
    ")\n",
    "search = catalog.search(\n",
    "    collections=[\"sentinel-2-l2a\"],\n",
    "    bbox=bbox,\n",
    "    datetime=date_range,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "132f6a71-7b65-4122-bdff-2325cb071d3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "items = list(search.get_all_items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0c182fc-e42b-467d-806f-d407517a74be",
   "metadata": {},
   "outputs": [],
   "source": [
    "import shapely.geometry\n",
    "\n",
    "item = items[0]\n",
    "center = shapely.geometry.shape(item.geometry).centroid.bounds[:2][::-1]\n",
    "\n",
    "m = Map(center=center, zoom=8)\n",
    "layer = TileLayer(\n",
    "    url=requests.get(item.assets[\"tilejson\"].href).json()[\"tiles\"][0],\n",
    ")\n",
    "m.add_layer(layer)\n",
    "m.add_control(FullScreenControl())\n",
    "\n",
    "m.scroll_wheel_zoom = True\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0113c6cd-0d00-4f87-bf18-d850fcd52ea5",
   "metadata": {},
   "source": [
    "Oops, that image is pretty cloudy. Let's check its cloud cover."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33bac978-4aee-4521-942c-88cccfd9dead",
   "metadata": {},
   "outputs": [],
   "source": [
    "EOExtension.ext(item).cloud_cover"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "548ee615-f7b3-48af-bde5-e93354d278ac",
   "metadata": {},
   "source": [
    "Fortunately, with the STAC API, it's possible to filter out images that are cloudier than some threshold."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0bf2e9f-ff30-4ff5-82f8-99022366b271",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pystac_client\n",
    "\n",
    "bbox = [-58.92, -34.81, -58.26, -34.18]\n",
    "date_range = \"2020-01-01/2020-12-31\"\n",
    "\n",
    "catalog = pystac_client.Client.open(\n",
    "    \"https://planetarycomputer.microsoft.com/api/stac/v1\"\n",
    ")\n",
    "low_cloud_search = catalog.search(\n",
    "    collections=[\"sentinel-2-l2a\"],\n",
    "    bbox=bbox,\n",
    "    datetime=date_range,\n",
    "    query={\"eo:cloud_cover\": {\"lt\": 10}},  # Just return items with few clouds\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9ae7a50-6e17-48fc-9d3e-ba93999bf725",
   "metadata": {},
   "outputs": [],
   "source": [
    "%time items = list(low_cloud_search.get_all_items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95c22d30-b39e-4ee8-a191-e5f4c64687e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(items)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d53608c-db41-4a5c-8aa6-0f6ba21107f1",
   "metadata": {},
   "source": [
    "Let's visualize that item, along with our bounding box."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03336bca-2fec-46d1-a159-577bd6b501c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "item = items[0]\n",
    "center = shapely.geometry.shape(item.geometry).centroid.bounds[:2][::-1]\n",
    "\n",
    "m = Map(center=center, zoom=9)\n",
    "layer = TileLayer(\n",
    "    url=requests.get(item.assets[\"tilejson\"].href).json()[\"tiles\"][0],\n",
    ")\n",
    "m.add_layer(layer)\n",
    "m.add_control(FullScreenControl())\n",
    "m.add_layer(GeoJSON(data=shapely.geometry.mapping(shapely.geometry.box(*bbox))))\n",
    "m.scroll_wheel_zoom = True\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a93edfb-cd28-4dab-a7bf-f2390e573e33",
   "metadata": {},
   "source": [
    "Notice that there are still a few clouds near the top of the image, but overall there aren't too many.\n",
    "\n",
    "Also notice that our bounding box isn't completly covered by the one Sentinel 2 scene. It seems like we'll need to combine multiple scenes to cover it. We'll do that next.\n",
    "\n",
    "## Loading STAC Items into xarray\n",
    "\n",
    "Many remote sensing datasets are provided as collections of COGs. Each COG covers some area, and was taken at a specific time and a specific wavelength. It's very convienient to work with this as a 4-dimensional DataArray indexed by `(time, band, lon, lat)`. The `stackstac` library is a great way to build this type of DataArray."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "44f0fbd9-4f98-44ef-a5aa-946d48ea1cd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "signed_items = [planetary_computer.sign(item).to_dict() for item in items]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "56ef6bc5-be97-4d4c-8c2b-d0daa0c552e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "import stackstac\n",
    "\n",
    "ds = stackstac.stack(signed_items, assets=[\"B02\", \"B03\", \"B04\", \"B08\"])\n",
    "ds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c2df5de-03d7-42a5-b73a-4845f70f1033",
   "metadata": {},
   "source": [
    "With `stackstac` we can go from a collection of STAC items to a DataArray in a single function call.\n",
    "\n",
    "But look at the size of that DataArray! We aren't quite ready to tackle it yet, so let's narrow things down a bit. We will\n",
    "\n",
    "* Crop the data down to our bounding box\n",
    "* Upsample the data to 90m resolution (instead of the native 10m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2da32a8-0166-4ad9-9f4e-1a56e576ac90",
   "metadata": {},
   "outputs": [],
   "source": [
    "ds = stackstac.stack(\n",
    "    signed_items, assets=[\"B02\", \"B03\", \"B04\", \"B08\"], bounds_latlon=bbox, resolution=90\n",
    ").where(lambda x: x > 0)  # filter out nodata\n",
    "ds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c143e54-7c4f-44bb-b6d1-680d558ff251",
   "metadata": {},
   "source": [
    "Let's spin up a local \"cluster\" so that we can watch the computaiton progress."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67a621d4-8537-4d13-a7de-1387c097bdc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "from distributed import Client\n",
    "\n",
    "client = Client()\n",
    "client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9d780249-5471-48f0-ad78-9241e6cbbc11",
   "metadata": {},
   "outputs": [],
   "source": [
    "# AOI spans two scene boundaries\n",
    "ds = ds.compute().ffill(dim=\"time\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ef45d0c-4c32-42ad-8b27-6607c8ec4311",
   "metadata": {},
   "source": [
    "So we just\n",
    "\n",
    "1. Queried the millions of Sentinel-2 Level 2-A scenes for just ones matching our requirements (location, time, cloudiness) using the STAC API\n",
    "2. Assembled the matching scenes into a 4-d DataArray using stackstac\n",
    "3. Loaded those into memory in parallel using Dask\n",
    "\n",
    "Now we ready to do some analytics. Let's compute NDVI."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12f15de9-d0ba-498d-a8b8-d02b10724b70",
   "metadata": {},
   "outputs": [],
   "source": [
    "blue = ds.sel(band=\"B02\")\n",
    "green = ds.sel(band=\"B03\")\n",
    "red = ds.sel(band=\"B04\")\n",
    "nir = ds.sel(band=\"B08\")\n",
    "\n",
    "ndvi = (nir - red) / (nir + red)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb6a7926-a58b-4b9e-b95e-24e081c6e505",
   "metadata": {},
   "source": [
    "We can plot a single scene:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3636d8be-e989-429b-ac3c-6ae33ac7f5f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "ndvi[1].plot.imshow(figsize=(12, 9), cmap=\"YlGn\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd78d04c-d200-4653-89e5-1d1aebaeda88",
   "metadata": {},
   "source": [
    "Or the timeseries (averaged over latitude and longitude)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b817f7c-f708-47ca-83d2-2c318b7127af",
   "metadata": {},
   "outputs": [],
   "source": [
    "ts = ndvi.mean(dim=[\"y\", \"x\"])\n",
    "ts.plot()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9939b1e8-8b3b-47b5-b119-dc1ea6c4ff20",
   "metadata": {},
   "outputs": [],
   "source": [
    "low = ts.argmin().item()\n",
    "\n",
    "ndvi.isel(time=low).plot.imshow(figsize=(12, 9), cmap=\"YlGn\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9109bf2e-94d2-4708-84aa-92188e755881",
   "metadata": {},
   "outputs": [],
   "source": [
    "peak = ndvi.max(dim=\"time\")\n",
    "change = peak - ndvi.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b173f2f-69d0-4a99-8286-15a046115ca1",
   "metadata": {},
   "outputs": [],
   "source": [
    "change.plot.imshow(figsize=(12, 9), cmap=\"RdYlGn\", vmin=-0.65, vmax=0.65);"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0399c23-8304-4db2-923b-d29aa1e7b0b1",
   "metadata": {},
   "source": [
    "### Exercise: Plot the GNDVI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ad69cce-4c85-4be9-8e14-73eaa6e77a99",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load solutions/gndvi.py"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48397757-a750-4859-8f93-c86602e27eab",
   "metadata": {},
   "source": [
    "stackstac has a handy function for adding a DataArray to a map, which is nice for larger datasets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe2a0e6f-701d-498b-b22a-9122682e4356",
   "metadata": {},
   "outputs": [],
   "source": [
    "m = stackstac.show(change, cmap=\"RdYlGn\", range=(-0.65, 0.65))\n",
    "m.add_control(FullScreenControl())\n",
    "m.scroll_wheel_zoom = True\n",
    "m"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}