From c6948ef0ed0f8cd7ace6f3b27b4f8979b90af1d6 Mon Sep 17 00:00:00 2001 From: omshinde23 Date: Tue, 16 Dec 2025 11:13:08 -0800 Subject: [PATCH 1/7] ESA BIOMASS Simulated data access notebook --- .../ESA_BIOMASS_Token_Access.ipynb | 524 ++++++++++++++++++ 1 file changed, 524 insertions(+) create mode 100644 docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Token_Access.ipynb diff --git a/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Token_Access.ipynb b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Token_Access.ipynb new file mode 100644 index 00000000..95a89b31 --- /dev/null +++ b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Token_Access.ipynb @@ -0,0 +1,524 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ba2af799-7655-4b5b-af0d-9b66f97f6fe7", + "metadata": { + "tags": [] + }, + "source": [ + "# ESA BIOMASS Data Access and Visualization (Token-secured)\n", + "\n", + "Authors: Rajat Shinde (UAH), Alex Mandel (Development Seed), Sheyenne Kirkland (UAH), Harshini Girish (UAH), Jamison French (Development Seed), Henry Rodman (Development Seed), Chuck Daniels (Development Seed), Zac Deziel (Development Seed), Brian Freitag (NASA), Ferrante, Francesco (SERCO), Cristiano Lopes (ESA)\n", + "\n", + "Date: December 16, 2025\n", + "\n", + "Description: This notebook documents how to access and visualize the ESA BIOMASS simulated data hosted on the ESA MAAP server. It is an example illustrating data access from ESA server based on ESA MAAP Token using the NASA MAAP Authorization. \n", + "\n", + "---\n", + "\n", + "## What you will do\n", + "1. Understand the product and file organization. \n", + "2. Obtain an ESA data access offline token. \n", + "3. Convert offline tooken to a short-lived data access token\n", + "4. Access a simulated raster using the token. \n", + "5. Visualize in Python. \n", + "\n", + "---\n", + "\n", + "## Run this notebook\n", + "You can run this notebook in your MAAP environment:\n", + "- Click on the **Launch Notebook** button from the documentation page, or \n", + "- Clone this notebook to your workspace and run all cells in order. \n", + "\n", + "**Prerequisites** \n", + "- An active ESA MAAP portal account with access initialized. \n", + "- OAuth2 client credentials for your ESA realm. \n", + "- Python packages: `requests`, `rasterio`, `numpy`, `matplotlib` (optional: `pystac-client`, `stackstac`). \n" + ] + }, + { + "cell_type": "markdown", + "id": "2896f0e7-65aa-49eb-81fe-b05b05cf66f8", + "metadata": {}, + "source": [ + "## Importing and Installing Packages" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "4a74381b-05cb-478c-b358-5ef4ea778d9f", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Install if needed. Comment out if already available.\n", + "# !pip install pystac-client rasterio requests matplotlib\n", + "\n", + "import os\n", + "import numpy as np\n", + "import requests\n", + "import matplotlib.pyplot as plt\n", + "import rasterio\n", + "from rasterio.io import MemoryFile\n", + "from pystac_client import Client\n", + "from pathlib import Path" + ] + }, + { + "cell_type": "markdown", + "id": "cd721b48-2b13-4357-8716-baa4d67c6c57", + "metadata": {}, + "source": [ + "## Getting the ESA MAAP Long Lasting Token\n", + "\n", + "This explains how to retrieve a long lasting token (hereafter, `offline token`) from the ESA MAAP portal using your browser and NASA EDL login. The offline token is valid for a 90-day period. \n", + "\n", + "Open the token page in your browser:\n", + "**https://portal.maap.eo.esa.int/ini/services/auth/token/**\n", + "\n", + "**Steps**\n", + "1. Navigate to the URL above. \n", + "2. Choose **NASA Earthdata Login (EDL)** when prompted and authorize access. \n", + "3. After successful authorization you will see a **token page** showing your short‑lived access token string.\n", + "\n", + "**The below screenshots illustrate the process for each steps.**\n", + "- **Portal entry page**: \n", + " ![Portal](./images/esa_maap.jpg)\n", + "- **NASA EDL authorization screen**: \n", + " ![NASA EDL](./images/page2.jpg)\n", + "- **Token page after authorization**: \n", + " ![Token Page](./images/page3.jpg)\n", + "\n", + "**Copy the offline token value** from the token page for use in the next cell." + ] + }, + { + "cell_type": "markdown", + "id": "2fdc9de3-3dd5-4908-83aa-07c441641108", + "metadata": {}, + "source": [ + "## Converting ESA MAAP Offline Token to get Short-lived Data Access Token\n", + "\n", + "The steps to get short-lived data access token are described [here](https://eartharxiv.org/repository/view/11083/), and also illustrated below. \n", + "\n", + "All API keys and tokens are stored in a `credentials.txt` file located in the same directory as the script/notebook.\n", + "\n", + "**Steps**\n", + "1. Create a `credentials.txt` file in the same location as script/notebook. \n", + "2. Edit and copy the following snippet to the `credentials.txt`.\n", + "\n", + "```\n", + "CLIENT_ID=offline-token\n", + "CLIENT_SECRET=p1eL7uonXs6MDxtGbgKdPVRAmnGxHpVE\n", + "OFFLINE_TOKEN=your_esamaap_offline_token_here\n", + "```\n", + "\n", + "3. Run the below cells to get a short-lived data access token in `token`." + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "9b295d53-3d99-435e-8f08-7d53303643e6", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "p1eL7uonXs6MDxtGbgKdPVRAmnGxHpVE\n" + ] + } + ], + "source": [ + "# --- Path to credentials.txt --- \n", + "CREDENTIALS_FILE = Path('./credentials.txt').resolve().parent / \"credentials.txt\" # Insert the .txt path\n", + "\n", + "def load_credentials(file_path=CREDENTIALS_FILE):\n", + " \"\"\"Read key-value pairs from a credentials file into a dictionary.\"\"\"\n", + " creds = {}\n", + " if not file_path.exists():\n", + " raise FileNotFoundError(f\"Credentials file not found: {file_path}\")\n", + " with open(file_path, \"r\") as f:\n", + " for line in f:\n", + " line = line.strip()\n", + " if not line or line.startswith(\"#\"):\n", + " continue\n", + " if \"=\" not in line:\n", + " continue\n", + " key, value = line.split(\"=\", 1)\n", + " creds[key.strip()] = value.strip()\n", + " return creds\n", + "\n", + "\n", + "# --- ESA MAAP API ---\n", + "\n", + "def get_token():\n", + " \"\"\"Use OFFLINE_TOKEN to fetch a short-lived access token.\"\"\"\n", + " creds = load_credentials()\n", + "\n", + " OFFLINE_TOKEN = creds.get(\"OFFLINE_TOKEN\")\n", + " CLIENT_ID = creds.get(\"CLIENT_ID\")\n", + " CLIENT_SECRET = creds.get(\"CLIENT_SECRET\")\n", + " print(CLIENT_SECRET)\n", + "\n", + " if not all([OFFLINE_TOKEN, CLIENT_ID, CLIENT_SECRET]):\n", + " raise ValueError(\"Missing OFFLINE_TOKEN, CLIENT_ID, or CLIENT_SECRET in credentials file\")\n", + "\n", + " url = \"https://iam.maap.eo.esa.int/realms/esa-maap/protocol/openid-connect/token\"\n", + " data = {\n", + " \"client_id\": CLIENT_ID,\n", + " \"client_secret\": CLIENT_SECRET,\n", + " \"grant_type\": \"refresh_token\",\n", + " \"refresh_token\": OFFLINE_TOKEN,\n", + " \"scope\": \"offline_access openid\"\n", + " }\n", + "\n", + " response = requests.post(url, data=data)\n", + " response.raise_for_status()\n", + "\n", + " response_json = response.json()\n", + " access_token = response_json.get('access_token')\n", + "\n", + " if not access_token:\n", + " raise RuntimeError(\"Failed to retrieve access token from IAM response\")\n", + "\n", + " return access_token\n", + "\n", + "token = get_token()" + ] + }, + { + "cell_type": "markdown", + "id": "a01a2fe2-9182-4dba-8d07-82eb1d7d0ddd", + "metadata": {}, + "source": [ + "**Note**\n", + "- Treat tokens as secrets. Do not commit them to version control or share publicly.\n", + "\n", + "Now we pass the data access `token` as `header` in our subsequent requests." + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "b00c8c0d-9669-46fb-b514-1bf5ea615004", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Connected to STAC: https://catalog.maap.eo.esa.int/catalogue/\n", + "Collections found: 290\n", + "['series', 'datasets', 'EOP:ESA:Sentinel-2', 'EOP:ESA:CopDem', 'EarthCAREL2Products_MAAP', 'Landsat8.Collection2.European.Coverage_', 'JAXAL2InstChecked_MAAP', 'JAXAL2Products_MAAP', 'BiomassLevel2a', 'BiomassLevel1bIOC']\n" + ] + } + ], + "source": [ + "headers = {\"Authorization\": f\"Bearer {token}\"}\n", + "\n", + "# STAC API that backs the MAAP/ESA STAC Browser\n", + "STAC_API_URL = \"https://catalog.maap.eo.esa.int/catalogue/\" # <-- note the /catalogue/ suffix\n", + "\n", + "# Connect to the STAC API landing page (NOT the browser link)\n", + "stac = Client.open(STAC_API_URL, headers=headers)\n", + "print(\"Connected to STAC:\", STAC_API_URL)\n", + "\n", + "# Quick sanity check: list a few collections (should include BiomassSimulated variants)\n", + "cols = list(stac.get_collections())\n", + "print(\"Collections found:\", len(cols))\n", + "print([c.id for c in cols[:10]])" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "f77c789c-0bd5-4733-9902-452d26784b84", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 1 collections containing 'Simulated':\n", + " - BiomassSimulated :: Biomass Simulated data\n", + "\n", + "Selected BiomassSimulated collection: BiomassSimulated\n", + "Description: Biomass Simulated data products\n" + ] + } + ], + "source": [ + "# List only collections that contain the word \"Simulated\"\n", + "simulated_cols = [c for c in cols if \"Simulated\" in (c.id or \"\") or \"Simulated\" in (c.title or \"\")]\n", + "print(f\"Found {len(simulated_cols)} collections containing 'Simulated':\")\n", + "for c in simulated_cols:\n", + " print(f\" - {c.id} :: {c.title}\")\n", + "\n", + "# If you want to inspect one of them (e.g., BiomassSimulated)\n", + "sim_col = [c for c in simulated_cols if \"BiomassSimulated\" in c.id]\n", + "if sim_col:\n", + " print(\"\\nSelected BiomassSimulated collection:\", sim_col[0].id)\n", + " print(\"Description:\", sim_col[0].description)" + ] + }, + { + "cell_type": "markdown", + "id": "d401b08a-5808-4e00-9442-e677e5b45ca0", + "metadata": {}, + "source": [ + "## Testing Data Access\n", + "\n", + "The below cell defines the URL of a specific tile in the ESA BIOMASS Simulated data collection that we want to test access on." + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "7616b771-aec4-4ef1-8598-4e301b443259", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total items: [, , , , ]\n" + ] + } + ], + "source": [ + "time_day = \"2017-02-25/2017-02-25\"\n", + "search = stac.search(collections=[\"BiomassSimulated\"], datetime=time_day, limit=1000)\n", + "items = list(search.get_items())\n", + "print(\"Total items:\", items)" + ] + }, + { + "cell_type": "markdown", + "id": "1f732733-c4b2-4cd1-bf66-afb893ee34df", + "metadata": {}, + "source": [ + "Here we make a request to the example tile using the token to check that authentication is working." + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "72860f18-a844-4224-aceb-8d71b92ca76c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Picked item: BIO_S3_DGM__1S_20170225T094537_20170225T094558_I_G01_M02_C01_T017_F001_01_DCJ9SK from collection: BiomassSimulated\n", + "Asset: enclosure_tiff → https://catalog.maap.eo.esa.int/data/biomass-pdgs-01/BiomassSimulated/2017/02/25/BIO_S3_DGM__1S_20170225T094537_20170225T094558_I_G01_M02_C01_T017_F001_01_DCJ9SK/BIO_S3_DGM__1S_20170225T094537_20170225T094558_I_G01_M02_C01_T017_F001_01_DCJ9SK/measurement/bio_s3_dgm__1s_20170225t094537_20170225t094558_i_g01_m02_c01_t017_f001_i_abs.tiff\n", + "HTTP status: 200\n" + ] + } + ], + "source": [ + "# Pick the first item whose ID contains S3_SCS__ (matches ...__1S or ...__1M)\n", + "s3_item = None\n", + "for it in items:\n", + " if \"S3_DGM__1S\" in it.id:\n", + " s3_item = it\n", + " break\n", + "\n", + "if s3_item is None:\n", + " raise RuntimeError(\"No item with 'S3_DGM__1S' in ID found in the current item list.\")\n", + "\n", + "print(\"Picked item:\", s3_item.id, \"from collection:\", s3_item.collection_id)\n", + "\n", + "# Select the first GeoTIFF/COG asset and visualize\n", + "import os, numpy as np, requests, matplotlib.pyplot as plt, rasterio\n", + "from rasterio.io import MemoryFile\n", + "\n", + "asset_key, asset_href = None, None\n", + "for k, a in s3_item.assets.items():\n", + " mt = (a.media_type or \"\").lower()\n", + " href = a.get_absolute_href() or a.href\n", + " if (\"tiff\" in mt) or href.lower().endswith((\".tif\", \".tiff\")):\n", + " asset_key, asset_href = k, href\n", + " break\n", + "\n", + "if asset_href is None:\n", + " raise RuntimeError(f\"No TIFF/COG assets on {s3_item.id}\")\n", + "\n", + "print(\"Asset:\", asset_key, \"→\", asset_href)\n", + "\n", + "r = requests.get(asset_href, headers=headers, stream=True, timeout=180)\n", + "print(\"HTTP status:\", r.status_code)\n", + "\n", + "if r.status_code != 200:\n", + " # Print a bit of the error text to see what the server says\n", + " print(\"Response text (first 500 chars):\")\n", + " print(r.text[:500])\n", + " raise RuntimeError(f\"Fetch failed: HTTP {r.status_code}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "9a7b853a-8e59-4c85-8322-c059aed40a81", + "metadata": {}, + "source": [ + "## Load the raster into memory and visualize\n", + "\n", + "If access is successful, this cell reads the raster data in memory and plots a quicklook visualization." + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "1bd2b20b-a76f-496c-b91d-b7077559f273", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape: (6321, 2251)\n", + "CRS: None\n", + "Transform: | 1.00, 0.00, 0.00|\n", + "| 0.00, 1.00, 0.00|\n", + "| 0.00, 0.00, 1.00|\n", + "Min/Max: 32.63134765625 2673.335205078125\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if r.status_code != 200:\n", + " raise RuntimeError(f\"Fetch failed: HTTP {r.status_code}\")\n", + "\n", + "with MemoryFile(r.content) as mem:\n", + " with mem.open() as ds:\n", + " arr = ds.read(1)\n", + " prof = ds.profile\n", + "\n", + "valid = arr[np.isfinite(arr)]\n", + "if valid.size == 0:\n", + " raise RuntimeError(\"No valid pixels found.\")\n", + "\n", + "print(\"Shape:\", arr.shape)\n", + "print(\"CRS:\", prof.get(\"crs\"))\n", + "print(\"Transform:\", prof.get(\"transform\"))\n", + "print(\"Min/Max:\", float(np.nanmin(valid)), float(np.nanmax(valid)))\n", + "\n", + "h, w = arr.shape\n", + "fig_w = 2\n", + "fig_h = max(3, min(10, fig_w * (h / w))) # keep the tall aspect but readable\n", + "\n", + "eps = 1e-6\n", + "arr_db = 20*np.log10(np.maximum(arr, eps)) # magnitude -> dB (use 10*log10 if arr is power)\n", + "\n", + "valid = arr_db[np.isfinite(arr_db)]\n", + "vmin, vmax = np.nanpercentile(valid, (2, 98))\n", + "\n", + "plt.figure(figsize=(fig_w, fig_h), dpi=160)\n", + "im = plt.imshow(arr_db, cmap=\"gray\", vmin=vmin, vmax=vmax, interpolation=\"nearest\")\n", + "plt.colorbar(im, label=\"Backscatter (dB)\", shrink=0.6)\n", + "plt.axis(\"off\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "cfb1da6e-6c88-4e4c-9070-3a473109c6ab", + "metadata": {}, + "source": [ + "## Downloading File Locally\n", + "\n", + "Here we define a helper function to save authenticated downloads to disk for later use." + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "8cfa5fcd-ea6d-4775-bb26-afaedbdad477", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'bio_s3_dgm__1s_20170225t094537_20170225t094558_i_g01_m02_c01_t017_f001_i_abs.tiff'" + ] + }, + "execution_count": 76, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def save_auth_file(url: str, token: str, out_path: str, chunk: int = 1 << 20) -> str:\n", + " headers = {\"Authorization\": f\"Bearer {token}\"}\n", + " with requests.get(url, headers=headers, stream=True) as resp:\n", + " resp.raise_for_status()\n", + " with open(out_path, \"wb\") as f:\n", + " for part in resp.iter_content(chunk_size=chunk):\n", + " if part:\n", + " f.write(part)\n", + " return out_path\n", + "\n", + "# Example:\n", + "save_auth_file(asset_href, token, asset_href.split('/')[-1])\n" + ] + }, + { + "cell_type": "markdown", + "id": "b78208a4-08d0-44fe-84b1-e7f57f02708b", + "metadata": {}, + "source": [ + "The example BIOMASS tile is succesfully downloaded locally. " + ] + } + ], + "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.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 61e2301543ffb3daa4bd8bba09b3189c22068a42 Mon Sep 17 00:00:00 2001 From: omshinde23 Date: Tue, 23 Dec 2025 13:01:45 -0800 Subject: [PATCH 2/7] Adding ESA BIOMASS Level1A and simulated data access notebook --- .../ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb | 556 ++++++++++++++++++ ...> ESA_BIOMASS_Simulated_Data_Access.ipynb} | 88 ++- docs/source/science_examples.rst | 2 + 3 files changed, 623 insertions(+), 23 deletions(-) create mode 100644 docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb rename docs/source/science/ESA_BIOMASS/{ESA_BIOMASS_Token_Access.ipynb => ESA_BIOMASS_Simulated_Data_Access.ipynb} (99%) diff --git a/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb new file mode 100644 index 00000000..f7b59366 --- /dev/null +++ b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb @@ -0,0 +1,556 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ba2af799-7655-4b5b-af0d-9b66f97f6fe7", + "metadata": { + "tags": [] + }, + "source": [ + "# ESA BIOMASS Data Access and Visualization (Token-secured)\n", + "\n", + "Authors: Rajat Shinde (UAH), Alex Mandel (Development Seed), Sheyenne Kirkland (UAH), Harshini Girish (UAH), Jamison French (Development Seed), Henry Rodman (Development Seed), Chuck Daniels (Development Seed), Zac Deziel (Development Seed), Brian Freitag (NASA), Francesco Ferrante (SERCO), Cristiano Lopes (ESA)\n", + "\n", + "Date: December 23, 2025\n", + "\n", + "Description: This notebook documents how to access and visualize the ESA BIOMASS simulated data hosted on the ESA MAAP server. It is an example illustrating data access from ESA server based on ESA MAAP Token using the NASA MAAP Authorization. \n", + "\n", + "---\n", + "\n", + "## What you will do\n", + "1. Understand the product and file organization. \n", + "2. Obtain an ESA data access offline token. \n", + "3. Convert offline token to a short-lived data access token\n", + "4. Access the ESA BIOMASS Level 1a raster using the data access token. \n", + "5. Visualize in Python. \n", + "\n", + "---\n", + "\n", + "## Run this notebook\n", + "To access and run this tutorial within MAAP's Algorithm Development Environment (ADE), please refer to the [Getting started with the MAAP](https://docs.maap-project.org/en/latest/getting_started/getting_started.html) section of our documentation.\n", + "\n", + "Disclaimer: it is highly recommended to run a tutorial within MAAP's ADE, which already includes packages specific to MAAP, such as maap-py. Running the tutorial outside of the MAAP ADE may lead to errors. \n", + "\n", + "**Prerequisites** \n", + "- An active ESA MAAP portal account with access initialized. \n", + "- OAuth2 client credentials for your ESA realm. \n", + "- Python packages: `requests`, `rasterio`, `numpy`, `matplotlib` (optional: `pystac-client`, `stackstac`). \n" + ] + }, + { + "cell_type": "markdown", + "id": "2896f0e7-65aa-49eb-81fe-b05b05cf66f8", + "metadata": {}, + "source": [ + "## Importing and Installing Packages" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4a74381b-05cb-478c-b358-5ef4ea778d9f", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Install if needed. Comment out if already available.\n", + "# !pip install pystac-client rasterio requests matplotlib\n", + "\n", + "import os\n", + "import numpy as np\n", + "import requests\n", + "import matplotlib.pyplot as plt\n", + "import rasterio\n", + "from rasterio.io import MemoryFile\n", + "from pystac_client import Client\n", + "from pathlib import Path" + ] + }, + { + "cell_type": "markdown", + "id": "cd721b48-2b13-4357-8716-baa4d67c6c57", + "metadata": {}, + "source": [ + "## Getting the ESA MAAP Long Lasting Token\n", + "\n", + "This explains how to retrieve a long lasting token (hereafter, `offline token`) from the ESA MAAP portal using your browser and NASA EDL login. The offline token is valid for a 90-day period. \n", + "\n", + "Open the token page in your browser:\n", + "**https://portal.maap.eo.esa.int/ini/services/auth/token/**\n", + "\n", + "**Steps**\n", + "1. Navigate to the URL above. \n", + "2. Choose **NASA Earthdata Login (EDL)** when prompted and authorize access. \n", + "3. After successful authorization you will see a **token page** showing your short‑lived access token string.\n", + "\n", + "**The below screenshots illustrate the process for each steps.**\n", + "- **Portal entry page**: \n", + " ![Portal](./images/esa_maap.jpg)\n", + "- **NASA EDL authorization screen**: \n", + " ![NASA EDL](./images/page2.jpg)\n", + "- **Token page after authorization**: \n", + " ![Token Page](./images/page3.jpg)\n", + "\n", + "**Copy the offline token value** from the token page for use in the next cell." + ] + }, + { + "cell_type": "markdown", + "id": "2fdc9de3-3dd5-4908-83aa-07c441641108", + "metadata": {}, + "source": [ + "## Converting ESA MAAP Offline Token to get Short-lived Data Access Token\n", + "\n", + "The steps to get short-lived data access token are described [here](https://eartharxiv.org/repository/view/11083/), and also illustrated below. \n", + "\n", + "All API keys and tokens are stored in a `credentials.txt` file located in the same directory as the script/notebook.\n", + "\n", + "**Steps**\n", + "1. Create a `credentials.txt` file in the same location as script/notebook. \n", + "2. Edit and copy the following snippet to the `credentials.txt`.\n", + "\n", + "```\n", + "CLIENT_ID=offline-token\n", + "CLIENT_SECRET=p1eL7uonXs6MDxtGbgKdPVRAmnGxHpVE\n", + "OFFLINE_TOKEN=your_esamaap_offline_token_here\n", + "```\n", + "\n", + "The `CLIENT_ID` and `CLIENT_SECRET` should be as defined above.\n", + "\n", + "3. Run the below cells to get a short-lived data access token in `token`." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "9b295d53-3d99-435e-8f08-7d53303643e6", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# --- Path to credentials.txt --- \n", + "CREDENTIALS_FILE = Path('./credentials.txt').resolve().parent / \"credentials.txt\" # Insert the .txt path\n", + "\n", + "def load_credentials(file_path=CREDENTIALS_FILE):\n", + " \"\"\"Read key-value pairs from a credentials file into a dictionary.\"\"\"\n", + " creds = {}\n", + " if not file_path.exists():\n", + " raise FileNotFoundError(f\"Credentials file not found: {file_path}\")\n", + " with open(file_path, \"r\") as f:\n", + " for line in f:\n", + " line = line.strip()\n", + " if not line or line.startswith(\"#\"):\n", + " continue\n", + " if \"=\" not in line:\n", + " continue\n", + " key, value = line.split(\"=\", 1)\n", + " creds[key.strip()] = value.strip()\n", + " return creds\n", + "\n", + "\n", + "# --- ESA MAAP API ---\n", + "\n", + "def get_token():\n", + " \"\"\"Use OFFLINE_TOKEN to fetch a short-lived access token.\"\"\"\n", + " creds = load_credentials()\n", + "\n", + " OFFLINE_TOKEN = creds.get(\"OFFLINE_TOKEN\")\n", + " CLIENT_ID = creds.get(\"CLIENT_ID\")\n", + " CLIENT_SECRET = creds.get(\"CLIENT_SECRET\")\n", + "\n", + " if not all([OFFLINE_TOKEN, CLIENT_ID, CLIENT_SECRET]):\n", + " raise ValueError(\"Missing OFFLINE_TOKEN, CLIENT_ID, or CLIENT_SECRET in credentials file\")\n", + "\n", + " url = \"https://iam.maap.eo.esa.int/realms/esa-maap/protocol/openid-connect/token\"\n", + " data = {\n", + " \"client_id\": CLIENT_ID,\n", + " \"client_secret\": CLIENT_SECRET,\n", + " \"grant_type\": \"refresh_token\",\n", + " \"refresh_token\": OFFLINE_TOKEN,\n", + " \"scope\": \"offline_access openid\"\n", + " }\n", + "\n", + " response = requests.post(url, data=data)\n", + " response.raise_for_status()\n", + "\n", + " response_json = response.json()\n", + " access_token = response_json.get('access_token')\n", + "\n", + " if not access_token:\n", + " raise RuntimeError(\"Failed to retrieve access token from IAM response\")\n", + "\n", + " return access_token\n", + "\n", + "token = get_token()" + ] + }, + { + "cell_type": "markdown", + "id": "a01a2fe2-9182-4dba-8d07-82eb1d7d0ddd", + "metadata": {}, + "source": [ + "**Note**\n", + "- Treat tokens as secrets. Do not commit them to version control or share publicly.\n", + "\n", + "Now we pass the data access `token` as `header` in our subsequent requests." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "b00c8c0d-9669-46fb-b514-1bf5ea615004", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Connected to STAC: https://catalog.maap.eo.esa.int/catalogue/\n", + "Collections found: 290\n", + "['series', 'datasets', 'EOP:ESA:Sentinel-2', 'EOP:ESA:CopDem', 'EarthCAREL2Products_MAAP', 'Landsat8.Collection2.European.Coverage_', 'JAXAL2InstChecked_MAAP', 'JAXAL2Products_MAAP', 'BiomassLevel2a', 'BiomassLevel1bIOC']\n" + ] + } + ], + "source": [ + "headers = {\"Authorization\": f\"Bearer {token}\"}\n", + "\n", + "# STAC API that backs the MAAP/ESA STAC Browser\n", + "STAC_API_URL = \"https://catalog.maap.eo.esa.int/catalogue/\" # <-- note the /catalogue/ suffix\n", + "\n", + "# Connect to the STAC API landing page (NOT the browser link)\n", + "stac = Client.open(STAC_API_URL, headers=headers)\n", + "print(\"Connected to STAC:\", STAC_API_URL)\n", + "\n", + "# Quick sanity check: list a few collections (should include BiomassSimulated variants)\n", + "cols = list(stac.get_collections())\n", + "print(\"Collections found:\", len(cols))\n", + "print([c.id for c in cols[:10]])" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "f77c789c-0bd5-4733-9902-452d26784b84", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 2 collections containing 'BiomassLevel1a':\n", + " - BiomassLevel1aIOC :: Biomass Level 1A (IOC)\n", + " - BiomassLevel1a :: Biomass Level 1A\n" + ] + } + ], + "source": [ + "_cols = [c for c in cols if \"BiomassLevel1a\" in (c.id or \"\") or \"BiomassLevel1a\" in (c.title or \"\")]\n", + "print(f\"Found {len(_cols)} collections containing 'BiomassLevel1a':\")\n", + "for c in _cols:\n", + " print(f\" - {c.id} :: {c.title}\")" + ] + }, + { + "cell_type": "markdown", + "id": "d401b08a-5808-4e00-9442-e677e5b45ca0", + "metadata": {}, + "source": [ + "## Testing Data Access\n", + "\n", + "The below cells shows how to access items from the ESA BIOMASS Level 1 collection (Id=`BiomassLevel1a`). Based on this, items can be accessed from other collections such as -\n", + "\n", + "1. BiomassLevel1b - a Detected Ground Multi-look (DGM) data, Analysis-ready Data (ARD) product\n", + "2. BiomassLevel1c - co-registered SLC\n", + "3. BiomassLevel2a - Forest retrieval products, generated from L1C, etc.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "7616b771-aec4-4ef1-8598-4e301b443259", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total items: 1434\n" + ] + } + ], + "source": [ + "time_day = \"2025-12-12/2025-12-12\"\n", + "search = stac.search(collections=[\"BiomassLevel1a\"], datetime=time_day, limit=1000)\n", + "items = list(search.get_items())\n", + "print(\"Total items:\", len(items))" + ] + }, + { + "cell_type": "markdown", + "id": "1f732733-c4b2-4cd1-bf66-afb893ee34df", + "metadata": {}, + "source": [ + "Here we make a request to the example tile using the token to check that authentication is working." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "72860f18-a844-4224-aceb-8d71b92ca76c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Picked item: BIO_S2_SCS__1S_20251212T025450_20251212T025512_T_G01_M01_C01_T002_F225_01_DJJECC from collection: BiomassLevel1a\n", + "Asset: enclosure_i_abs_tiff → https://catalog.maap.eo.esa.int/data/biomass-pdgs-01/BiomassLevel1a/2025/12/12/BIO_S2_SCS__1S_20251212T025450_20251212T025512_T_G01_M01_C01_T002_F225_01_DJJECC/BIO_S2_SCS__1S_20251212T025450_20251212T025512_T_G01_M01_C01_T002_F225_01_DJJECC/measurement/bio_s2_scs__1s_20251212t025450_20251212t025512_t_g01_m01_c01_t002_f225_i_abs.tiff\n", + "HTTP status: 200\n" + ] + } + ], + "source": [ + "# Pick the first item whose ID contains S2_SCS__1S\n", + "_item = None\n", + "for it in items:\n", + " if \"S2_SCS__1S\" in it.id:\n", + " _item = it\n", + " break\n", + "\n", + "if _item is None:\n", + " raise RuntimeError(\"No item with 'S2_SCS__1S' in ID found in the current item list.\")\n", + "\n", + "print(\"Picked item:\", s3_item.id, \"from collection:\", s3_item.collection_id)\n", + "\n", + "# Select the first GeoTIFF/COG asset and visualize\n", + "import os, numpy as np, requests, matplotlib.pyplot as plt, rasterio\n", + "from rasterio.io import MemoryFile\n", + "\n", + "asset_key, asset_href = None, None\n", + "for k, a in s3_item.assets.items():\n", + " mt = (a.media_type or \"\").lower()\n", + " href = a.get_absolute_href() or a.href\n", + " if (\"tiff\" in mt) or href.lower().endswith((\".tif\", \".tiff\")):\n", + " asset_key, asset_href = k, href\n", + " break\n", + "\n", + "if asset_href is None:\n", + " raise RuntimeError(f\"No TIFF/COG assets on {s3_item.id}\")\n", + "\n", + "print(\"Asset:\", asset_key, \"→\", asset_href)\n", + "\n", + "r = requests.get(asset_href, headers=headers, stream=True, timeout=180)\n", + "print(\"HTTP status:\", r.status_code)\n", + "\n", + "if r.status_code != 200:\n", + " # Print a bit of the error text to see what the server says\n", + " print(\"Response text (first 500 chars):\")\n", + " print(r.text[:500])\n", + " raise RuntimeError(f\"Fetch failed: HTTP {r.status_code}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "9a7b853a-8e59-4c85-8322-c059aed40a81", + "metadata": {}, + "source": [ + "## Load the raster into memory and visualize\n", + "\n", + "If access is successful, this cell reads the raster data in memory and plots a quicklook visualization." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "1bd2b20b-a76f-496c-b91d-b7077559f273", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape: (22723, 1332)\n", + "CRS: None\n", + "Transform: | 1.00, 0.00, 0.00|\n", + "| 0.00, 1.00, 0.00|\n", + "| 0.00, 0.00, 1.00|\n", + "Min/Max: 0.0 4.040882587432861\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if r.status_code != 200:\n", + " raise RuntimeError(f\"Fetch failed: HTTP {r.status_code}\")\n", + "\n", + "with MemoryFile(r.content) as mem:\n", + " with mem.open() as ds:\n", + " arr = ds.read(1)\n", + " prof = ds.profile\n", + "\n", + "valid = arr[np.isfinite(arr)]\n", + "if valid.size == 0:\n", + " raise RuntimeError(\"No valid pixels found.\")\n", + "\n", + "print(\"Shape:\", arr.shape)\n", + "print(\"CRS:\", prof.get(\"crs\"))\n", + "print(\"Transform:\", prof.get(\"transform\"))\n", + "print(\"Min/Max:\", float(np.nanmin(valid)), float(np.nanmax(valid)))\n", + "\n", + "h, w = arr.shape\n", + "fig_w = 2\n", + "fig_h = max(3, min(10, fig_w * (h / w))) # keep the tall aspect but readable\n", + "\n", + "eps = 1e-6\n", + "arr_db = 20*np.log10(np.maximum(arr, eps)) # magnitude -> dB (use 10*log10 if arr is power)\n", + "\n", + "valid = arr_db[np.isfinite(arr_db)]\n", + "vmin, vmax = np.nanpercentile(valid, (2, 98))\n", + "\n", + "plt.figure(figsize=(fig_w, fig_h), dpi=160)\n", + "im = plt.imshow(arr_db, cmap=\"gray\", vmin=vmin, vmax=vmax, interpolation=\"nearest\")\n", + "plt.colorbar(im, label=\"Backscatter (dB)\", shrink=0.6)\n", + "plt.axis(\"off\")\n", + "plt.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "637c605f-c160-4b33-839f-852a023252dd", + "metadata": {}, + "source": [ + "## Using Rasterio for Data Access\n", + "\n", + "The below cell shows another method to load the data directly with Rasterio by passing the token in GDAL HTTP headers." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "bd8079d2-0d69-46d7-bfc8-358556da3480", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape: (22723, 1332)\n", + "CRS: None\n", + "Transform: | 1.00, 0.00, 0.00|\n", + "| 0.00, 1.00, 0.00|\n", + "| 0.00, 0.00, 1.00|\n", + "Min/Max: 0.0 4.040882587432861\n" + ] + } + ], + "source": [ + "# Works if your GDAL/Rasterio build supports HTTP headers with /vsicurl/.\n", + "rio_env = rasterio.Env(GDAL_HTTP_HEADERS=f\"Authorization: Bearer {token}\")\n", + "with rio_env:\n", + " with rasterio.open(asset_href) as ds:\n", + " arr = ds.read(1)\n", + " valid = arr[np.isfinite(arr)]\n", + " print(\"Shape:\", arr.shape)\n", + " print(\"CRS:\", ds.crs)\n", + " print(\"Transform:\", ds.transform)\n", + " print(\"Min/Max:\", float(valid.min()), float(valid.max()))" + ] + }, + { + "cell_type": "markdown", + "id": "cfb1da6e-6c88-4e4c-9070-3a473109c6ab", + "metadata": {}, + "source": [ + "## Downloading File Locally\n", + "\n", + "Here we define a helper function to save authenticated downloads to disk for later use." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "8cfa5fcd-ea6d-4775-bb26-afaedbdad477", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'bio_s2_scs__1s_20251212t025450_20251212t025512_t_g01_m01_c01_t002_f225_i_abs.tiff'" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def save_auth_file(url: str, token: str, out_path: str, chunk: int = 1 << 20) -> str:\n", + " headers = {\"Authorization\": f\"Bearer {token}\"}\n", + " with requests.get(url, headers=headers, stream=True) as resp:\n", + " resp.raise_for_status()\n", + " with open(out_path, \"wb\") as f:\n", + " for part in resp.iter_content(chunk_size=chunk):\n", + " if part:\n", + " f.write(part)\n", + " return out_path\n", + "\n", + "# Example:\n", + "save_auth_file(asset_href, token, asset_href.split('/')[-1])\n" + ] + }, + { + "cell_type": "markdown", + "id": "b78208a4-08d0-44fe-84b1-e7f57f02708b", + "metadata": {}, + "source": [ + "The example ESA BIOMASS Level1a tile is successfully downloaded locally. " + ] + } + ], + "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.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Token_Access.ipynb b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Simulated_Data_Access.ipynb similarity index 99% rename from docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Token_Access.ipynb rename to docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Simulated_Data_Access.ipynb index 95a89b31..23b064ec 100644 --- a/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Token_Access.ipynb +++ b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Simulated_Data_Access.ipynb @@ -9,7 +9,7 @@ "source": [ "# ESA BIOMASS Data Access and Visualization (Token-secured)\n", "\n", - "Authors: Rajat Shinde (UAH), Alex Mandel (Development Seed), Sheyenne Kirkland (UAH), Harshini Girish (UAH), Jamison French (Development Seed), Henry Rodman (Development Seed), Chuck Daniels (Development Seed), Zac Deziel (Development Seed), Brian Freitag (NASA), Ferrante, Francesco (SERCO), Cristiano Lopes (ESA)\n", + "Authors: Rajat Shinde (UAH), Alex Mandel (Development Seed), Sheyenne Kirkland (UAH), Harshini Girish (UAH), Jamison French (Development Seed), Henry Rodman (Development Seed), Chuck Daniels (Development Seed), Zac Deziel (Development Seed), Brian Freitag (NASA), Francesco Ferrante (SERCO), Cristiano Lopes (ESA)\n", "\n", "Date: December 16, 2025\n", "\n", @@ -20,16 +20,17 @@ "## What you will do\n", "1. Understand the product and file organization. \n", "2. Obtain an ESA data access offline token. \n", - "3. Convert offline tooken to a short-lived data access token\n", + "3. Convert offline token to a short-lived data access token\n", "4. Access a simulated raster using the token. \n", "5. Visualize in Python. \n", "\n", "---\n", "\n", "## Run this notebook\n", - "You can run this notebook in your MAAP environment:\n", - "- Click on the **Launch Notebook** button from the documentation page, or \n", - "- Clone this notebook to your workspace and run all cells in order. \n", + "## Run this notebook\n", + "To access and run this tutorial within MAAP's Algorithm Development Environment (ADE), please refer to the [Getting started with the MAAP](https://docs.maap-project.org/en/latest/getting_started/getting_started.html) section of our documentation.\n", + "\n", + "Disclaimer: it is highly recommended to run a tutorial within MAAP's ADE, which already includes packages specific to MAAP, such as maap-py. Running the tutorial outside of the MAAP ADE may lead to errors. \n", "\n", "**Prerequisites** \n", "- An active ESA MAAP portal account with access initialized. \n", @@ -47,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 1, "id": "4a74381b-05cb-478c-b358-5ef4ea778d9f", "metadata": { "tags": [] @@ -116,12 +117,14 @@ "OFFLINE_TOKEN=your_esamaap_offline_token_here\n", "```\n", "\n", + "The `CLIENT_ID` and `CLIENT_SECRET` should be as defined above.\n", + "\n", "3. Run the below cells to get a short-lived data access token in `token`." ] }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 3, "id": "9b295d53-3d99-435e-8f08-7d53303643e6", "metadata": { "tags": [] @@ -165,7 +168,6 @@ " OFFLINE_TOKEN = creds.get(\"OFFLINE_TOKEN\")\n", " CLIENT_ID = creds.get(\"CLIENT_ID\")\n", " CLIENT_SECRET = creds.get(\"CLIENT_SECRET\")\n", - " print(CLIENT_SECRET)\n", "\n", " if not all([OFFLINE_TOKEN, CLIENT_ID, CLIENT_SECRET]):\n", " raise ValueError(\"Missing OFFLINE_TOKEN, CLIENT_ID, or CLIENT_SECRET in credentials file\")\n", @@ -206,7 +208,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 4, "id": "b00c8c0d-9669-46fb-b514-1bf5ea615004", "metadata": { "tags": [] @@ -240,7 +242,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 5, "id": "f77c789c-0bd5-4733-9902-452d26784b84", "metadata": { "tags": [] @@ -284,7 +286,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 11, "id": "7616b771-aec4-4ef1-8598-4e301b443259", "metadata": { "tags": [] @@ -294,7 +296,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Total items: [, , , , ]\n" + "Total items: 5\n" ] } ], @@ -302,7 +304,7 @@ "time_day = \"2017-02-25/2017-02-25\"\n", "search = stac.search(collections=[\"BiomassSimulated\"], datetime=time_day, limit=1000)\n", "items = list(search.get_items())\n", - "print(\"Total items:\", items)" + "print(\"Total items:\", len(items))" ] }, { @@ -315,7 +317,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 7, "id": "72860f18-a844-4224-aceb-8d71b92ca76c", "metadata": { "tags": [] @@ -332,7 +334,7 @@ } ], "source": [ - "# Pick the first item whose ID contains S3_SCS__ (matches ...__1S or ...__1M)\n", + "# Pick the first item whose ID contains S3_DGM__ (matches ...__1S or ...__1M)\n", "s3_item = None\n", "for it in items:\n", " if \"S3_DGM__1S\" in it.id:\n", @@ -344,10 +346,6 @@ "\n", "print(\"Picked item:\", s3_item.id, \"from collection:\", s3_item.collection_id)\n", "\n", - "# Select the first GeoTIFF/COG asset and visualize\n", - "import os, numpy as np, requests, matplotlib.pyplot as plt, rasterio\n", - "from rasterio.io import MemoryFile\n", - "\n", "asset_key, asset_href = None, None\n", "for k, a in s3_item.assets.items():\n", " mt = (a.media_type or \"\").lower()\n", @@ -383,7 +381,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 8, "id": "1bd2b20b-a76f-496c-b91d-b7077559f273", "metadata": { "tags": [] @@ -447,6 +445,50 @@ "plt.tight_layout()" ] }, + { + "cell_type": "markdown", + "id": "af15599a-c4e9-4647-a858-c0a479d8fc5f", + "metadata": {}, + "source": [ + "## Using Rasterio for Data Access\n", + "\n", + "The below cell shows another method to load the data directly with Rasterio by passing the token in GDAL HTTP headers." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "225c1ab7-8728-4318-a4a1-4c98f4910ed8", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape: (6321, 2251)\n", + "CRS: None\n", + "Transform: | 1.00, 0.00, 0.00|\n", + "| 0.00, 1.00, 0.00|\n", + "| 0.00, 0.00, 1.00|\n", + "Min/Max: 32.63134765625 2673.335205078125\n" + ] + } + ], + "source": [ + "# Works if your GDAL/Rasterio build supports HTTP headers with /vsicurl/.\n", + "rio_env = rasterio.Env(GDAL_HTTP_HEADERS=f\"Authorization: Bearer {token}\")\n", + "with rio_env:\n", + " with rasterio.open(asset_href) as ds:\n", + " arr = ds.read(1)\n", + " valid = arr[np.isfinite(arr)]\n", + " print(\"Shape:\", arr.shape)\n", + " print(\"CRS:\", ds.crs)\n", + " print(\"Transform:\", ds.transform)\n", + " print(\"Min/Max:\", float(valid.min()), float(valid.max()))" + ] + }, { "cell_type": "markdown", "id": "cfb1da6e-6c88-4e4c-9070-3a473109c6ab", @@ -459,7 +501,7 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 10, "id": "8cfa5fcd-ea6d-4775-bb26-afaedbdad477", "metadata": { "tags": [] @@ -471,7 +513,7 @@ "'bio_s3_dgm__1s_20170225t094537_20170225t094558_i_g01_m02_c01_t017_f001_i_abs.tiff'" ] }, - "execution_count": 76, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -496,7 +538,7 @@ "id": "b78208a4-08d0-44fe-84b1-e7f57f02708b", "metadata": {}, "source": [ - "The example BIOMASS tile is succesfully downloaded locally. " + "The example BIOMASS simulated data tile is successfully downloaded locally. " ] } ], diff --git a/docs/source/science_examples.rst b/docs/source/science_examples.rst index 6b51e99c..43953d2c 100644 --- a/docs/source/science_examples.rst +++ b/docs/source/science_examples.rst @@ -27,3 +27,5 @@ You can also find links to Open Source Science guidelines for the MAAP platform. science/oss_documentation.rst science/EarthCARE/EarthCARE_access_and_visualize.ipynb science/GEE/gee.ipynb + science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb + science/ESA_BIOMASS/ESA_BIOMASS_Simulated_Data_Access.ipynb \ No newline at end of file From 53d1160250386dfd8629e8463b19ebb69d261b38 Mon Sep 17 00:00:00 2001 From: omshinde23 Date: Thu, 8 Jan 2026 08:33:14 -0800 Subject: [PATCH 3/7] Update notebook to access L1B product --- .../ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb | 91 +++++++++---------- 1 file changed, 43 insertions(+), 48 deletions(-) diff --git a/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb index f7b59366..f6916343 100644 --- a/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb +++ b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb @@ -47,7 +47,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "4a74381b-05cb-478c-b358-5ef4ea778d9f", "metadata": { "tags": [] @@ -86,11 +86,11 @@ "\n", "**The below screenshots illustrate the process for each steps.**\n", "- **Portal entry page**: \n", - " ![Portal](./images/esa_maap.jpg)\n", + " ![Portal](../ESA_CCI/images/esa_maap.jpg)\n", "- **NASA EDL authorization screen**: \n", - " ![NASA EDL](./images/page2.jpg)\n", + " ![NASA EDL](../ESA_CCI/images/page2.jpg)\n", "- **Token page after authorization**: \n", - " ![Token Page](./images/page3.jpg)\n", + " ![Token Page](../ESA_CCI/images/page3.jpg)\n", "\n", "**Copy the offline token value** from the token page for use in the next cell." ] @@ -123,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 4, "id": "9b295d53-3d99-435e-8f08-7d53303643e6", "metadata": { "tags": [] @@ -199,7 +199,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 6, "id": "b00c8c0d-9669-46fb-b514-1bf5ea615004", "metadata": { "tags": [] @@ -222,7 +222,7 @@ "STAC_API_URL = \"https://catalog.maap.eo.esa.int/catalogue/\" # <-- note the /catalogue/ suffix\n", "\n", "# Connect to the STAC API landing page (NOT the browser link)\n", - "stac = Client.open(STAC_API_URL, headers=headers)\n", + "stac = Client.open(STAC_API_URL)\n", "print(\"Connected to STAC:\", STAC_API_URL)\n", "\n", "# Quick sanity check: list a few collections (should include BiomassSimulated variants)\n", @@ -233,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 7, "id": "f77c789c-0bd5-4733-9902-452d26784b84", "metadata": { "tags": [] @@ -243,15 +243,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "Found 2 collections containing 'BiomassLevel1a':\n", - " - BiomassLevel1aIOC :: Biomass Level 1A (IOC)\n", - " - BiomassLevel1a :: Biomass Level 1A\n" + "Found 2 collections containing 'BiomassLevel1b':\n", + " - BiomassLevel1bIOC :: Biomass Level 1B (IOC)\n", + " - BiomassLevel1b :: Biomass Level 1B\n" ] } ], "source": [ - "_cols = [c for c in cols if \"BiomassLevel1a\" in (c.id or \"\") or \"BiomassLevel1a\" in (c.title or \"\")]\n", - "print(f\"Found {len(_cols)} collections containing 'BiomassLevel1a':\")\n", + "_cols = [c for c in cols if \"BiomassLevel1b\" in (c.id or \"\") or \"BiomassLevel1b\" in (c.title or \"\")]\n", + "print(f\"Found {len(_cols)} collections containing 'BiomassLevel1b':\")\n", "for c in _cols:\n", " print(f\" - {c.id} :: {c.title}\")" ] @@ -263,16 +263,18 @@ "source": [ "## Testing Data Access\n", "\n", - "The below cells shows how to access items from the ESA BIOMASS Level 1 collection (Id=`BiomassLevel1a`). Based on this, items can be accessed from other collections such as -\n", + "The below cells shows how to access items from the ESA BIOMASS Level 1b collection (Id=`BiomassLevel1b`), which is a Detected Ground Multi-look (DGM) data, Analysis-ready Data (ARD) product. Based on this, items can be accessed from other collections such as -\n", "\n", - "1. BiomassLevel1b - a Detected Ground Multi-look (DGM) data, Analysis-ready Data (ARD) product\n", - "2. BiomassLevel1c - co-registered SLC\n", - "3. BiomassLevel2a - Forest retrieval products, generated from L1C, etc.\n" + "1. BiomassLevel1a - Single-look Complex Slant (SCS) data\n", + "2. BiomassLevel1c - co-registered Single-look Complex (SLC) data\n", + "3. BiomassLevel2a - Forest retrieval products, generated from L1C, etc.\n", + "\n", + "The ESA STAC API has the \"filter\" extension which can be used to filter products from the collection.\n" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 14, "id": "7616b771-aec4-4ef1-8598-4e301b443259", "metadata": { "tags": [] @@ -282,13 +284,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "Total items: 1434\n" + "Total items: 717\n" ] } ], "source": [ "time_day = \"2025-12-12/2025-12-12\"\n", - "search = stac.search(collections=[\"BiomassLevel1a\"], datetime=time_day, limit=1000)\n", + "search = stac.search(collections=[\"BiomassLevel1b\"], datetime=time_day, limit=1000, \n", + " filter=\"productType='S2_DGM__1S'\",\n", + " method=\"GET\")\n", "items = list(search.get_items())\n", "print(\"Total items:\", len(items))" ] @@ -303,7 +307,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 15, "id": "72860f18-a844-4224-aceb-8d71b92ca76c", "metadata": { "tags": [] @@ -313,29 +317,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "Picked item: BIO_S2_SCS__1S_20251212T025450_20251212T025512_T_G01_M01_C01_T002_F225_01_DJJECC from collection: BiomassLevel1a\n", - "Asset: enclosure_i_abs_tiff → https://catalog.maap.eo.esa.int/data/biomass-pdgs-01/BiomassLevel1a/2025/12/12/BIO_S2_SCS__1S_20251212T025450_20251212T025512_T_G01_M01_C01_T002_F225_01_DJJECC/BIO_S2_SCS__1S_20251212T025450_20251212T025512_T_G01_M01_C01_T002_F225_01_DJJECC/measurement/bio_s2_scs__1s_20251212t025450_20251212t025512_t_g01_m01_c01_t002_f225_i_abs.tiff\n", + "Picked item: BIO_S2_DGM__1S_20251212T011542_20251212T011603_T_G01_M01_C01_T001_F222_01_DJJDIM from collection: BiomassLevel1b\n", + "Asset: enclosure_tiff → https://catalog.maap.eo.esa.int/data/biomass-pdgs-01/BiomassLevel1b/2025/12/12/BIO_S2_DGM__1S_20251212T011542_20251212T011603_T_G01_M01_C01_T001_F222_01_DJJDIM/BIO_S2_DGM__1S_20251212T011542_20251212T011603_T_G01_M01_C01_T001_F222_01_DJJDIM/measurement/bio_s2_dgm__1s_20251212t011542_20251212t011603_t_g01_m01_c01_t001_f222_i_abs.tiff\n", "HTTP status: 200\n" ] } ], "source": [ - "# Pick the first item whose ID contains S2_SCS__1S\n", - "_item = None\n", - "for it in items:\n", - " if \"S2_SCS__1S\" in it.id:\n", - " _item = it\n", - " break\n", - "\n", - "if _item is None:\n", - " raise RuntimeError(\"No item with 'S2_SCS__1S' in ID found in the current item list.\")\n", + "# Pick the first item whose ID contains S2_DGM__1S\n", + "s3_item = items[0]\n", + "if s3_item is None:\n", + " raise RuntimeError(\"No item with 'S2_DGM__1S' in ID found in the current item list.\")\n", "\n", "print(\"Picked item:\", s3_item.id, \"from collection:\", s3_item.collection_id)\n", "\n", - "# Select the first GeoTIFF/COG asset and visualize\n", - "import os, numpy as np, requests, matplotlib.pyplot as plt, rasterio\n", - "from rasterio.io import MemoryFile\n", - "\n", "asset_key, asset_href = None, None\n", "for k, a in s3_item.assets.items():\n", " mt = (a.media_type or \"\").lower()\n", @@ -371,7 +366,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 16, "id": "1bd2b20b-a76f-496c-b91d-b7077559f273", "metadata": { "tags": [] @@ -381,19 +376,19 @@ "name": "stdout", "output_type": "stream", "text": [ - "Shape: (22723, 1332)\n", + "Shape: (6336, 2566)\n", "CRS: None\n", "Transform: | 1.00, 0.00, 0.00|\n", "| 0.00, 1.00, 0.00|\n", "| 0.00, 0.00, 1.00|\n", - "Min/Max: 0.0 4.040882587432861\n" + "Min/Max: 0.012598428875207901 1.8292609453201294\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -447,7 +442,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 17, "id": "bd8079d2-0d69-46d7-bfc8-358556da3480", "metadata": { "tags": [] @@ -457,12 +452,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Shape: (22723, 1332)\n", + "Shape: (6336, 2566)\n", "CRS: None\n", "Transform: | 1.00, 0.00, 0.00|\n", "| 0.00, 1.00, 0.00|\n", "| 0.00, 0.00, 1.00|\n", - "Min/Max: 0.0 4.040882587432861\n" + "Min/Max: 0.012598428875207901 1.8292609453201294\n" ] } ], @@ -491,7 +486,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 18, "id": "8cfa5fcd-ea6d-4775-bb26-afaedbdad477", "metadata": { "tags": [] @@ -500,10 +495,10 @@ { "data": { "text/plain": [ - "'bio_s2_scs__1s_20251212t025450_20251212t025512_t_g01_m01_c01_t002_f225_i_abs.tiff'" + "'bio_s2_dgm__1s_20251212t011542_20251212t011603_t_g01_m01_c01_t001_f222_i_abs.tiff'" ] }, - "execution_count": 31, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -528,7 +523,7 @@ "id": "b78208a4-08d0-44fe-84b1-e7f57f02708b", "metadata": {}, "source": [ - "The example ESA BIOMASS Level1a tile is successfully downloaded locally. " + "The example ESA BIOMASS Level1b tile is successfully downloaded locally. " ] } ], From 09905430c1bcb311d789b3b7b5e3fe9d256bf2e7 Mon Sep 17 00:00:00 2001 From: omshinde23 Date: Thu, 8 Jan 2026 09:18:47 -0800 Subject: [PATCH 4/7] Fix minor typo --- docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb index f6916343..303c6872 100644 --- a/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb +++ b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb @@ -13,7 +13,7 @@ "\n", "Date: December 23, 2025\n", "\n", - "Description: This notebook documents how to access and visualize the ESA BIOMASS simulated data hosted on the ESA MAAP server. It is an example illustrating data access from ESA server based on ESA MAAP Token using the NASA MAAP Authorization. \n", + "Description: This notebook documents how to access and visualize the ESA BIOMASS data hosted on the ESA MAAP server. It is an example illustrating data access from ESA server based on ESA MAAP Token using the NASA MAAP Authorization. \n", "\n", "---\n", "\n", From 1ce0d75b2b2dfc8491af48b646def20afe7996f2 Mon Sep 17 00:00:00 2001 From: omshinde23 Date: Thu, 8 Jan 2026 09:36:47 -0800 Subject: [PATCH 5/7] Add indexing details --- docs/source/science_examples.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/science_examples.rst b/docs/source/science_examples.rst index 43953d2c..92cc4a6a 100644 --- a/docs/source/science_examples.rst +++ b/docs/source/science_examples.rst @@ -27,5 +27,5 @@ You can also find links to Open Source Science guidelines for the MAAP platform. science/oss_documentation.rst science/EarthCARE/EarthCARE_access_and_visualize.ipynb science/GEE/gee.ipynb + science/ESA_BIOMASS/ESA_BIOMASS_Simulated_Data_Access.ipynb science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb - science/ESA_BIOMASS/ESA_BIOMASS_Simulated_Data_Access.ipynb \ No newline at end of file From bfb5ca88450afe151889d249f7f2eaf82adfec2c Mon Sep 17 00:00:00 2001 From: omshinde23 Date: Fri, 9 Jan 2026 09:25:58 -0800 Subject: [PATCH 6/7] Fix credentials.txt path --- .../science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb index 303c6872..3920311c 100644 --- a/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb +++ b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb @@ -107,7 +107,7 @@ "All API keys and tokens are stored in a `credentials.txt` file located in the same directory as the script/notebook.\n", "\n", "**Steps**\n", - "1. Create a `credentials.txt` file in the same location as script/notebook. \n", + "1. Create a `credentials.txt` file in the home directory of the user. \n", "2. Edit and copy the following snippet to the `credentials.txt`.\n", "\n", "```\n", @@ -123,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 19, "id": "9b295d53-3d99-435e-8f08-7d53303643e6", "metadata": { "tags": [] @@ -131,7 +131,7 @@ "outputs": [], "source": [ "# --- Path to credentials.txt --- \n", - "CREDENTIALS_FILE = Path('./credentials.txt').resolve().parent / \"credentials.txt\" # Insert the .txt path\n", + "CREDENTIALS_FILE = (Path.home() / \"credentials.txt\").resolve()\n", "\n", "def load_credentials(file_path=CREDENTIALS_FILE):\n", " \"\"\"Read key-value pairs from a credentials file into a dictionary.\"\"\"\n", From 06fda271079e70aa55e97041294e03285adbb92b Mon Sep 17 00:00:00 2001 From: omshinde23 Date: Fri, 9 Jan 2026 09:31:51 -0800 Subject: [PATCH 7/7] minor fix --- .../ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb | 2 +- .../ESA_BIOMASS_Simulated_Data_Access.ipynb | 58 +++++-------------- 2 files changed, 14 insertions(+), 46 deletions(-) diff --git a/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb index 3920311c..e99dd8cb 100644 --- a/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb +++ b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb @@ -104,7 +104,7 @@ "\n", "The steps to get short-lived data access token are described [here](https://eartharxiv.org/repository/view/11083/), and also illustrated below. \n", "\n", - "All API keys and tokens are stored in a `credentials.txt` file located in the same directory as the script/notebook.\n", + "All API keys and tokens are stored in a `credentials.txt` file located in the home directory of user.\n", "\n", "**Steps**\n", "1. Create a `credentials.txt` file in the home directory of the user. \n", diff --git a/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Simulated_Data_Access.ipynb b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Simulated_Data_Access.ipynb index 23b064ec..4eb9afc2 100644 --- a/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Simulated_Data_Access.ipynb +++ b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Simulated_Data_Access.ipynb @@ -48,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "4a74381b-05cb-478c-b358-5ef4ea778d9f", "metadata": { "tags": [] @@ -87,11 +87,11 @@ "\n", "**The below screenshots illustrate the process for each steps.**\n", "- **Portal entry page**: \n", - " ![Portal](./images/esa_maap.jpg)\n", + " ![Portal](../ESA_CCI/images/esa_maap.jpg)\n", "- **NASA EDL authorization screen**: \n", - " ![NASA EDL](./images/page2.jpg)\n", + " ![NASA EDL](../ESA_CCI/images/page2.jpg)\n", "- **Token page after authorization**: \n", - " ![Token Page](./images/page3.jpg)\n", + " ![Token Page](../ESA_CCI/images/page3.jpg)\n", "\n", "**Copy the offline token value** from the token page for use in the next cell." ] @@ -105,10 +105,10 @@ "\n", "The steps to get short-lived data access token are described [here](https://eartharxiv.org/repository/view/11083/), and also illustrated below. \n", "\n", - "All API keys and tokens are stored in a `credentials.txt` file located in the same directory as the script/notebook.\n", + "All API keys and tokens are stored in a `credentials.txt` file located in the home directory of user.\n", "\n", "**Steps**\n", - "1. Create a `credentials.txt` file in the same location as script/notebook. \n", + "1. Create a `credentials.txt` file in the home directory of the user. \n", "2. Edit and copy the following snippet to the `credentials.txt`.\n", "\n", "```\n", @@ -129,18 +129,10 @@ "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "p1eL7uonXs6MDxtGbgKdPVRAmnGxHpVE\n" - ] - } - ], + "outputs": [], "source": [ "# --- Path to credentials.txt --- \n", - "CREDENTIALS_FILE = Path('./credentials.txt').resolve().parent / \"credentials.txt\" # Insert the .txt path\n", + "CREDENTIALS_FILE = (Path.home() / \"credentials.txt\").resolve()\n", "\n", "def load_credentials(file_path=CREDENTIALS_FILE):\n", " \"\"\"Read key-value pairs from a credentials file into a dictionary.\"\"\"\n", @@ -286,7 +278,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 6, "id": "7616b771-aec4-4ef1-8598-4e301b443259", "metadata": { "tags": [] @@ -457,25 +449,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "225c1ab7-8728-4318-a4a1-4c98f4910ed8", "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Shape: (6321, 2251)\n", - "CRS: None\n", - "Transform: | 1.00, 0.00, 0.00|\n", - "| 0.00, 1.00, 0.00|\n", - "| 0.00, 0.00, 1.00|\n", - "Min/Max: 32.63134765625 2673.335205078125\n" - ] - } - ], + "outputs": [], "source": [ "# Works if your GDAL/Rasterio build supports HTTP headers with /vsicurl/.\n", "rio_env = rasterio.Env(GDAL_HTTP_HEADERS=f\"Authorization: Bearer {token}\")\n", @@ -501,23 +480,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "8cfa5fcd-ea6d-4775-bb26-afaedbdad477", "metadata": { "tags": [] }, - "outputs": [ - { - "data": { - "text/plain": [ - "'bio_s3_dgm__1s_20170225t094537_20170225t094558_i_g01_m02_c01_t017_f001_i_abs.tiff'" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "def save_auth_file(url: str, token: str, out_path: str, chunk: int = 1 << 20) -> str:\n", " headers = {\"Authorization\": f\"Bearer {token}\"}\n",