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..e99dd8cb --- /dev/null +++ b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb @@ -0,0 +1,551 @@ +{ + "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 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": 2, + "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](../ESA_CCI/images/esa_maap.jpg)\n", + "- **NASA EDL authorization screen**: \n", + " ![NASA EDL](../ESA_CCI/images/page2.jpg)\n", + "- **Token page after authorization**: \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." + ] + }, + { + "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 home directory of user.\n", + "\n", + "**Steps**\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", + "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": 19, + "id": "9b295d53-3d99-435e-8f08-7d53303643e6", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# --- Path to credentials.txt --- \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", + " 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": 6, + "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)\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": 7, + "id": "f77c789c-0bd5-4733-9902-452d26784b84", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "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 \"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}\")" + ] + }, + { + "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 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. 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": 14, + "id": "7616b771-aec4-4ef1-8598-4e301b443259", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total items: 717\n" + ] + } + ], + "source": [ + "time_day = \"2025-12-12/2025-12-12\"\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))" + ] + }, + { + "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": 15, + "id": "72860f18-a844-4224-aceb-8d71b92ca76c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "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_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", + "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": 16, + "id": "1bd2b20b-a76f-496c-b91d-b7077559f273", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "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.012598428875207901 1.8292609453201294\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": 17, + "id": "bd8079d2-0d69-46d7-bfc8-358556da3480", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "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.012598428875207901 1.8292609453201294\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": 18, + "id": "8cfa5fcd-ea6d-4775-bb26-afaedbdad477", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "'bio_s2_dgm__1s_20251212t011542_20251212t011603_t_g01_m01_c01_t001_f222_i_abs.tiff'" + ] + }, + "execution_count": 18, + "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 Level1b 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_Simulated_Data_Access.ipynb b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Simulated_Data_Access.ipynb new file mode 100644 index 00000000..4eb9afc2 --- /dev/null +++ b/docs/source/science/ESA_BIOMASS/ESA_BIOMASS_Simulated_Data_Access.ipynb @@ -0,0 +1,534 @@ +{ + "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 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 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", + "## 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": 2, + "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](../ESA_CCI/images/esa_maap.jpg)\n", + "- **NASA EDL authorization screen**: \n", + " ![NASA EDL](../ESA_CCI/images/page2.jpg)\n", + "- **Token page after authorization**: \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." + ] + }, + { + "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 home directory of user.\n", + "\n", + "**Steps**\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", + "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": 3, + "id": "9b295d53-3d99-435e-8f08-7d53303643e6", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# --- Path to credentials.txt --- \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", + " 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": 4, + "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": 5, + "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": 6, + "id": "7616b771-aec4-4ef1-8598-4e301b443259", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total items: 5\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:\", 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": 7, + "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_DGM__ (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", + "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": 8, + "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": "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": null, + "id": "225c1ab7-8728-4318-a4a1-4c98f4910ed8", + "metadata": { + "tags": [] + }, + "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", + "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": null, + "id": "8cfa5fcd-ea6d-4775-bb26-afaedbdad477", + "metadata": { + "tags": [] + }, + "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", + " 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 simulated data 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_examples.rst b/docs/source/science_examples.rst index 6b51e99c..92cc4a6a 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_Simulated_Data_Access.ipynb + science/ESA_BIOMASS/ESA_BIOMASS_Data_Access.ipynb