├── titiler
    └── cmr
    │   ├── py.typed
    │   ├── templates
    │       ├── debug.html
    │       ├── footer.html
    │       ├── tilesets.html
    │       ├── conformance.html
    │       ├── tilematrixsets.html
    │       ├── landing.html
    │       ├── tilematrixset.html
    │       ├── wmts.xml
    │       ├── tileset.html
    │       └── header.html
    │   ├── __init__.py
    │   ├── errors.py
    │   ├── enums.py
    │   ├── settings.py
    │   ├── reader.py
    │   ├── utils.py
    │   ├── main.py
    │   ├── logger.py
    │   ├── dependencies.py
    │   └── compatibility.py
├── .python-version
├── docs
    ├── index.md
    ├── contributing.md
    ├── release-notes.md
    ├── titiler-cmr.png
    ├── assets
    │   └── logo_no_text.png
    ├── compatibility
    │   ├── tiling_results-11-24-2025.parquet
    │   ├── plotting.py
    │   └── generate_table.py
    └── overrides
    │   └── stylesheets
    │       └── extra.css
├── infrastructure
    └── aws
    │   ├── cdk
    │       ├── __init__.py
    │       ├── config.py
    │       ├── permissions_boundary
    │       │   └── construct.py
    │       └── app.py
    │   ├── cdk.json
    │   ├── package.json
    │   ├── lambda
    │       ├── collector-config.yaml
    │       ├── handler.py
    │       └── Dockerfile
    │   └── package-lock.json
├── titiler-cmr.png
├── .dockerignore
├── tests
    ├── data
    │   ├── lp-prod-protected
    │   │   └── HLSL30.020
    │   │   │   ├── HLS.L30.T15UWP.2024283T165135.v2.0
    │   │   │       └── HLS.L30.T15UWP.2024283T165135.v2.0.Fmask.tif
    │   │   │   └── HLS.L30.T15UXP.2024283T165135.v2.0
    │   │   │       └── HLS.L30.T15UXP.2024283T165135.v2.0.Fmask.tif
    │   └── podaac-ops-cumulus-protected
    │   │   └── GAMSSA_28km-ABOM-L4-GLOB-v01
    │   │       ├── 20241011120000-ABOM-L4_GHRSST-SSTfnd-GAMSSA_28km-GLOB-v02.0-fv01.0.nc
    │   │       └── 20241012120000-ABOM-L4_GHRSST-SSTfnd-GAMSSA_28km-GLOB-v02.0-fv01.0.nc
    ├── test_timeseries_extension.py
    ├── test_backend.py
    ├── test_utils.py
    ├── test_tms.py
    ├── test_app.py
    ├── test_rasterio_backend.py
    ├── test_factory.py
    ├── conftest.py
    ├── cassettes
    │   └── test_backend
    │   │   └── test_get_assets[external-https].yaml
    ├── test_dependencies.py
    ├── test_hls_benchmark.py
    └── test_timeseries.py
├── .pre-commit-config.yaml
├── .github
    ├── workflows
    │   ├── benchmark.yml
    │   ├── ci.yml
    │   ├── deploy-dev.yml
    │   └── docs.yml
    ├── ISSUE_TEMPLATE
    │   └── release-checklist.md
    └── actions
    │   └── cdk-deploy
    │       └── action.yml
├── Dockerfile
├── LICENSE
├── CONTRIBUTING.md
├── docker-compose.yml
├── .gitignore
├── data
    └── mursst-cmr.json
├── mkdocs.yml
├── CHANGELOG.md
├── pyproject.toml
└── README.md


/titiler/cmr/py.typed:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.python-version:
--------------------------------------------------------------------------------
1 | 3.12
2 | 


--------------------------------------------------------------------------------
/docs/index.md:
--------------------------------------------------------------------------------
1 | ../README.md


--------------------------------------------------------------------------------
/titiler/cmr/templates/debug.html:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/docs/contributing.md:
--------------------------------------------------------------------------------
1 | ../CONTRIBUTING.md


--------------------------------------------------------------------------------
/docs/release-notes.md:
--------------------------------------------------------------------------------
1 | ../CHANGELOG.md


--------------------------------------------------------------------------------
/docs/titiler-cmr.png:
--------------------------------------------------------------------------------
1 | ../titiler-cmr.png


--------------------------------------------------------------------------------
/infrastructure/aws/cdk/__init__.py:
--------------------------------------------------------------------------------
1 | """AWS App."""
2 | 


--------------------------------------------------------------------------------
/infrastructure/aws/cdk.json:
--------------------------------------------------------------------------------
1 | {
2 |     "app": "python3 cdk/app.py"
3 | }
4 | 


--------------------------------------------------------------------------------
/titiler-cmr.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/developmentseed/titiler-cmr/HEAD/titiler-cmr.png


--------------------------------------------------------------------------------
/.dockerignore:
--------------------------------------------------------------------------------
1 | .git
2 | infrastructure/aws/cdk.out
3 | .venv
4 | .mypy_cache
5 | .pytest_cache
6 | .ruff_cache
7 | 
8 | 


--------------------------------------------------------------------------------
/docs/assets/logo_no_text.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/developmentseed/titiler-cmr/HEAD/docs/assets/logo_no_text.png


--------------------------------------------------------------------------------
/titiler/cmr/templates/footer.html:
--------------------------------------------------------------------------------
1 |         {% include "debug.html" %}
2 |       </div>
3 |     </main>
4 |   </body>
5 | </html>
6 | 


--------------------------------------------------------------------------------
/docs/compatibility/tiling_results-11-24-2025.parquet:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/developmentseed/titiler-cmr/HEAD/docs/compatibility/tiling_results-11-24-2025.parquet


--------------------------------------------------------------------------------
/tests/data/lp-prod-protected/HLSL30.020/HLS.L30.T15UWP.2024283T165135.v2.0/HLS.L30.T15UWP.2024283T165135.v2.0.Fmask.tif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/developmentseed/titiler-cmr/HEAD/tests/data/lp-prod-protected/HLSL30.020/HLS.L30.T15UWP.2024283T165135.v2.0/HLS.L30.T15UWP.2024283T165135.v2.0.Fmask.tif


--------------------------------------------------------------------------------
/tests/data/lp-prod-protected/HLSL30.020/HLS.L30.T15UXP.2024283T165135.v2.0/HLS.L30.T15UXP.2024283T165135.v2.0.Fmask.tif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/developmentseed/titiler-cmr/HEAD/tests/data/lp-prod-protected/HLSL30.020/HLS.L30.T15UXP.2024283T165135.v2.0/HLS.L30.T15UXP.2024283T165135.v2.0.Fmask.tif


--------------------------------------------------------------------------------
/infrastructure/aws/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "cdk-deploy",
 3 |   "version": "0.1.0",
 4 |   "description": "Dependencies for CDK deployment",
 5 |   "license": "MIT",
 6 |   "private": true,
 7 |   "dependencies": {
 8 |     "cdk": "^2.177.0"
 9 |   },
10 |   "scripts": {
11 |     "cdk": "cdk"
12 |   }
13 | }
14 | 


--------------------------------------------------------------------------------
/tests/data/podaac-ops-cumulus-protected/GAMSSA_28km-ABOM-L4-GLOB-v01/20241011120000-ABOM-L4_GHRSST-SSTfnd-GAMSSA_28km-GLOB-v02.0-fv01.0.nc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/developmentseed/titiler-cmr/HEAD/tests/data/podaac-ops-cumulus-protected/GAMSSA_28km-ABOM-L4-GLOB-v01/20241011120000-ABOM-L4_GHRSST-SSTfnd-GAMSSA_28km-GLOB-v02.0-fv01.0.nc


--------------------------------------------------------------------------------
/tests/data/podaac-ops-cumulus-protected/GAMSSA_28km-ABOM-L4-GLOB-v01/20241012120000-ABOM-L4_GHRSST-SSTfnd-GAMSSA_28km-GLOB-v02.0-fv01.0.nc:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/developmentseed/titiler-cmr/HEAD/tests/data/podaac-ops-cumulus-protected/GAMSSA_28km-ABOM-L4-GLOB-v01/20241012120000-ABOM-L4_GHRSST-SSTfnd-GAMSSA_28km-GLOB-v02.0-fv01.0.nc


--------------------------------------------------------------------------------
/titiler/cmr/__init__.py:
--------------------------------------------------------------------------------
 1 | """titiler.cmr"""
 2 | 
 3 | from importlib.metadata import PackageNotFoundError as _PackageNotFoundError
 4 | from importlib.metadata import version as _version
 5 | 
 6 | try:
 7 |     __version__ = _version(__name__)
 8 | except _PackageNotFoundError:
 9 |     # package is not installed
10 |     __version__ = "unknown"
11 | 


--------------------------------------------------------------------------------
/.pre-commit-config.yaml:
--------------------------------------------------------------------------------
 1 | repos:
 2 |   - repo: https://github.com/abravalheri/validate-pyproject
 3 |     rev: v0.23
 4 |     hooks:
 5 |       - id: validate-pyproject
 6 | 
 7 |   - repo: https://github.com/astral-sh/ruff-pre-commit
 8 |     rev: v0.9.4
 9 |     hooks:
10 |       - id: ruff
11 |         args: ["--fix"]
12 |       - id: ruff-format
13 | 
14 |   - repo: https://github.com/pre-commit/mirrors-mypy
15 |     rev: v1.5.1
16 |     hooks:
17 |       - id: mypy
18 |         language_version: python
19 |         exclude: tests/.*
20 |         additional_dependencies:
21 |         - types-cachetools
22 |         - types-attrs
23 |         - types-python-dateutil
24 |         - pydantic>=2.4
25 | 


--------------------------------------------------------------------------------
/titiler/cmr/errors.py:
--------------------------------------------------------------------------------
 1 | """titiler.cmr.errors: Error classes."""
 2 | 
 3 | import logging
 4 | 
 5 | from starlette import status
 6 | 
 7 | from titiler.core.errors import TilerError
 8 | 
 9 | logger = logging.getLogger(__name__)
10 | 
11 | 
12 | class InvalidBBox(TilerError):
13 |     """Invalid bounding box coordinates."""
14 | 
15 | 
16 | class InvalidDatetime(TilerError):
17 |     """Invalid datetime."""
18 | 
19 | 
20 | class MissingCollectionCatalog(TilerError):
21 |     """`collection_catalog` not registered in the application state."""
22 | 
23 | 
24 | DEFAULT_STATUS_CODES = {
25 |     InvalidBBox: status.HTTP_422_UNPROCESSABLE_ENTITY,
26 |     InvalidDatetime: status.HTTP_422_UNPROCESSABLE_ENTITY,
27 |     MissingCollectionCatalog: status.HTTP_500_INTERNAL_SERVER_ERROR,
28 | }
29 | 


--------------------------------------------------------------------------------
/tests/test_timeseries_extension.py:
--------------------------------------------------------------------------------
 1 | """Tests for the timeseries extension"""
 2 | 
 3 | from fastapi import FastAPI
 4 | 
 5 | from titiler.cmr.factory import Endpoints
 6 | from titiler.cmr.timeseries import TimeseriesExtension
 7 | 
 8 | 
 9 | def test_timeseries_extension() -> None:
10 |     """Test timeseries extension endpoints"""
11 |     tiler = Endpoints()
12 |     tiler_plus_timeseries = Endpoints(extensions=[TimeseriesExtension()])
13 |     # Check that we added two routes
14 |     assert len(tiler_plus_timeseries.router.routes) > len(tiler.router.routes)
15 | 
16 |     timeseries_app = FastAPI()
17 |     timeseries_app.include_router(tiler_plus_timeseries.router)
18 | 
19 |     assert any(
20 |         "/timeseries/statistics" in str(route) for route in timeseries_app.router.routes
21 |     )
22 | 


--------------------------------------------------------------------------------
/titiler/cmr/templates/tilesets.html:
--------------------------------------------------------------------------------
 1 | {% include "header.html" %}
 2 | 
 3 | <nav aria-label="breadcrumb">
 4 |   <ol class="breadcrumb bg-light">
 5 |     {% for crumb in crumbs %}
 6 |       {% if not loop.last %}
 7 |     <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
 8 |       {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
 9 |       {% endif %}
10 |     {% endfor %}
11 | 
12 |     <li class="ml-auto json-link"><a target="_blank" href="{{ url }}?f=json">JSON</a></li>
13 |   </ol>
14 | </nav>
15 | 
16 | <h1>{{ template.title }} TileSet list</h1>
17 | 
18 | <h2>Links</h2>
19 | <ul>
20 | {% for tileset in response.tilesets %}
21 |   <li> <a href="{{ tileset.links[0].href }}">{{ tileset.title }}</a></li>
22 | {% endfor %}
23 | </ul>
24 | 
25 | 
26 | {% include "footer.html" %}
27 | 


--------------------------------------------------------------------------------
/titiler/cmr/templates/conformance.html:
--------------------------------------------------------------------------------
 1 | {% include "header.html" %}
 2 | 
 3 | <nav aria-label="breadcrumb">
 4 |   <ol class="breadcrumb bg-light">
 5 |     {% for crumb in crumbs %}
 6 |       {% if not loop.last %}
 7 |     <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
 8 |       {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
 9 |       {% endif %}
10 |     {% endfor %}
11 | 
12 |     <li class="ml-auto json-link"><a target="_blank" href="{{ url }}?f=json">JSON</a></li>
13 |   </ol>
14 | </nav>
15 | 
16 | <h1>{{ template.title }}Conformance</h1>
17 | 
18 | <p>This API implements the conformance classes from standards and community specifications that are listed below.</p>
19 | 
20 | <h2>Links</h2>
21 | <ul>
22 | {% for url in response.conformsTo %}
23 |   <li> <a target="_blank" href="{{ url }}">{{ url }}</a></li>
24 | {% endfor %}
25 | </ul>
26 | 
27 | {% include "footer.html" %}
28 | 


--------------------------------------------------------------------------------
/titiler/cmr/templates/tilematrixsets.html:
--------------------------------------------------------------------------------
 1 | {% include "header.html" %}
 2 | 
 3 | <nav aria-label="breadcrumb">
 4 |   <ol class="breadcrumb bg-light">
 5 |     {% for crumb in crumbs %}
 6 |       {% if not loop.last %}
 7 |     <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
 8 |       {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
 9 |       {% endif %}
10 |     {% endfor %}
11 | 
12 |     <li class="ml-auto json-link"><a target="_blank" href="{{ url }}?f=json">JSON</a></li>
13 |   </ol>
14 | </nav>
15 | 
16 | <h1>{{ template.title }}TileMatrixSets</h1>
17 | 
18 | <p>This API implements <a target="_blank" href="https://www.ogc.org/standard/tms/">TileMatrixSets</a> that are listed below.</p>
19 | 
20 | <h2>Links</h2>
21 | <ul>
22 | {% for tms in response.tileMatrixSets %}
23 |   <li> <a href="{{ tms.links[0].href }}">{{ tms.id }}</a></li>
24 | {% endfor %}
25 | </ul>
26 | 
27 | {% include "footer.html" %}
28 | 


--------------------------------------------------------------------------------
/tests/test_backend.py:
--------------------------------------------------------------------------------
 1 | """Test backend functions"""
 2 | 
 3 | import pytest
 4 | 
 5 | from titiler.cmr.backend import Access, CMRBackend
 6 | 
 7 | 
 8 | @pytest.mark.vcr
 9 | @pytest.mark.parametrize(
10 |     "access,expectation", [("direct", "s3"), ("external", "https")]
11 | )
12 | def test_get_assets(access: Access, expectation: str) -> None:
13 |     """Test fetching asset metadata from CMR"""
14 |     bbox = (-91.663, 47.862, -91.537, 47.928)
15 |     band = "B01"
16 |     with CMRBackend() as backend:
17 |         assets = backend.get_assets(
18 |             *bbox,
19 |             access=access,
20 |             bands_regex=band,
21 |             concept_id="C2021957657-LPCLOUD",
22 |             temporal=("2024-02-11", "2024-02-13"),
23 |         )
24 | 
25 |     asset = assets.pop(0)
26 |     assert asset
27 |     asset_url = asset.get("url")
28 |     assert asset_url
29 |     assert isinstance(asset_url, dict)
30 |     assert asset_url[band].startswith(expectation)
31 | 


--------------------------------------------------------------------------------
/.github/workflows/benchmark.yml:
--------------------------------------------------------------------------------
 1 | name: Benchmark
 2 | 
 3 | on:
 4 |   workflow_dispatch:
 5 | 
 6 | permissions:
 7 |   id-token: write
 8 |   contents: write
 9 | 
10 | env:
11 |   UV_FROZEN: 'true'
12 |   UV_NO_PROGRESS: 'true'
13 | 
14 | jobs:
15 |   benchmark:
16 |     runs-on: ubuntu-latest
17 |     steps:
18 |       - uses: actions/checkout@v4
19 | 
20 |       - name: Install uv
21 |         uses: astral-sh/setup-uv@v3
22 |         with:
23 |           version: "0.5.*"
24 |           enable-cache: true
25 | 
26 |       - name: Install dependencies
27 |         run: |
28 |           uv sync
29 | 
30 |       - name: Run benchmark
31 |         run: |
32 |           uv run pytest --benchmark-only --benchmark-json benchmark.json
33 | 
34 |       - name: Commit benchmark results
35 |         run: |
36 |           git config --local user.email "github-actions[bot]@users.noreply.github.com"
37 |           git config --local user.name "github-actions[bot]"
38 |           git add benchmark.json
39 |           git commit -m "Update benchmark results" || echo "No changes to commit"
40 |           git push
41 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM ghcr.io/astral-sh/uv:python3.12-bookworm-slim
 2 | 
 3 | WORKDIR /app
 4 | 
 5 | COPY pyproject.toml pyproject.toml
 6 | COPY uv.lock uv.lock
 7 | 
 8 | COPY titiler/ titiler/
 9 | COPY README.md README.md
10 | COPY LICENSE LICENSE
11 | 
12 | RUN apt-get update && apt-get -y --no-install-recommends install libexpat1 && uv sync --no-dev --frozen --extra uvicorn
13 | 
14 | ARG EARTHDATA_USERNAME
15 | ARG EARTHDATA_PASSWORD
16 | 
17 | # Check if EARTHDATA_USERNAME and EARTHDATA_PASSWORD are provided
18 | RUN if [ -z "$EARTHDATA_USERNAME" ] || [ -z "$EARTHDATA_PASSWORD" ]; then \
19 |   echo "Error: EARTHDATA_USERNAME and EARTHDATA_PASSWORD build args must be provided"; \
20 |   exit 1; \
21 |   fi && \
22 |   echo "machine urs.earthdata.nasa.gov\nlogin ${EARTHDATA_USERNAME}\npassword ${EARTHDATA_PASSWORD}" > ~/.netrc && \
23 |   unset EARTHDATA_USERNAME && \
24 |   unset EARTHDATA_PASSWORD
25 | 
26 | # http://www.uvicorn.org/settings/
27 | ENV HOST 0.0.0.0
28 | ENV PORT 80
29 | CMD uv run --no-dev uvicorn titiler.cmr.main:app --host ${HOST} --port ${PORT} --log-level debug --reload
30 | 
31 | 


--------------------------------------------------------------------------------
/titiler/cmr/templates/landing.html:
--------------------------------------------------------------------------------
 1 | {% include "header.html" %}
 2 | 
 3 | <nav aria-label="breadcrumb">
 4 |   <ol class="breadcrumb bg-light">
 5 |     {% for crumb in crumbs %}
 6 |       {% if not loop.last %}
 7 |     <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
 8 |       {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
 9 |       {% endif %}
10 |     {% endfor %}
11 | 
12 |     <li class="ml-auto json-link"><a target="_blank" href="{{ url }}?f=json">JSON</a></li>
13 |   </ol>
14 | </nav>
15 | 
16 | <h1>{{ response.title }}</h1>
17 | <pre style=" font-size:10px; text-align: center;" >
18 |   _____ _ _____ _ _              ___ __  __ ___
19 |  |_   _(_)_   _(_) |___ _ _ ___ / __|  \/  | _ \
20 |    | | | | | | | | / -_) '_|___| (__| |\/| |   /
21 |    |_| |_| |_| |_|_\___|_|      \___|_|  |_|_|_\
22 | 
23 | </pre>
24 | <p>
25 |   {{ response.description }}
26 | </p>
27 | 
28 | <h2>Links</h2>
29 | <ul>
30 | {% for link in response.links %}
31 |   <li> <a href="{{ link.href }}">{{ link.title }}</a></li>
32 | {% endfor %}
33 | </ul>
34 | 
35 | {% include "footer.html" %}
36 | 


--------------------------------------------------------------------------------
/infrastructure/aws/lambda/collector-config.yaml:
--------------------------------------------------------------------------------
 1 | extensions:
 2 |   # AWS Proxy extension - forwards X-Ray segments to local X-Ray daemon via UDP
 3 |   # This avoids the awsxray exporter making HTTPS API calls
 4 |   awsproxy:
 5 |     endpoint: 127.0.0.1:2000
 6 | 
 7 | receivers:
 8 |   otlp:
 9 |     protocols:
10 |       grpc:
11 |         endpoint: localhost:4317
12 |       http:
13 |         endpoint: localhost:4318
14 | 
15 | processors:
16 |   batch:
17 |     timeout: 1s
18 |     send_batch_size: 50
19 | 
20 | exporters:
21 |   # Export to AWS X-Ray via local X-Ray daemon (UDP, no internet required)
22 |   # The awsproxy extension bridges the collector to the daemon at 127.0.0.1:2000
23 |   awsxray:
24 |     endpoint: http://127.0.0.1:2000
25 |     local_mode: true  # Use local X-Ray daemon instead of direct API calls
26 |     index_all_attributes: true
27 | 
28 |   # Debug exporter to see traces in CloudWatch logs
29 |   debug:
30 |     verbosity: detailed
31 | 
32 | service:
33 |   extensions: [awsproxy]
34 |   pipelines:
35 |     traces:
36 |       receivers: [otlp]
37 |       processors: [batch]
38 |       exporters: [debug, awsxray]
39 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2024 Development Seed
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/tests/test_utils.py:
--------------------------------------------------------------------------------
 1 | """Tests for utils.py"""
 2 | 
 3 | import pytest
 4 | 
 5 | from titiler.cmr.utils import calculate_time_series_request_size
 6 | 
 7 | 
 8 | @pytest.mark.vcr
 9 | def test_calculate_request_size_no_resolution() -> None:
10 |     """If a concept_id does not include the horizontal resolution in the UMM metadata
11 |     it should return 0"""
12 |     request_size = calculate_time_series_request_size(
13 |         concept_id="C2723754864-GES_DISC",
14 |         n_time_steps=2,
15 |         minx=-180,
16 |         miny=-90,
17 |         maxx=180,
18 |         maxy=90,
19 |         coord_crs="epsg:4326",
20 |     )
21 | 
22 |     assert request_size == 0
23 | 
24 | 
25 | @pytest.mark.vcr
26 | def test_calculate_request_size() -> None:
27 |     """A concept_id that DOES include the horizontal resolution will return a positive value"""
28 |     request_size = calculate_time_series_request_size(
29 |         concept_id="C2036881735-POCLOUD",
30 |         n_time_steps=2,
31 |         minx=-180,
32 |         miny=-90,
33 |         maxx=180,
34 |         maxy=90,
35 |         coord_crs="epsg:4326",
36 |     )
37 | 
38 |     assert 0 < request_size < 1e10
39 | 


--------------------------------------------------------------------------------
/infrastructure/aws/lambda/handler.py:
--------------------------------------------------------------------------------
 1 | """AWS Lambda handler optimized for container runtime with OTEL instrumentation."""
 2 | 
 3 | import asyncio
 4 | import logging
 5 | import os
 6 | import warnings
 7 | from typing import Any
 8 | 
 9 | from mangum import Mangum
10 | from mangum.types import LambdaContext, LambdaEvent
11 | 
12 | from titiler.cmr.logger import configure_logging
13 | from titiler.cmr.main import app
14 | 
15 | configure_logging()
16 | 
17 | warnings.filterwarnings("ignore", category=UserWarning)
18 | warnings.filterwarnings("ignore", category=FutureWarning)
19 | logging.getLogger("numexpr").setLevel(logging.WARNING)
20 | 
21 | 
22 | handler = Mangum(
23 |     app,
24 |     lifespan="off",
25 |     text_mime_types=[
26 |         "application/json",
27 |         "application/javascript",
28 |         "application/xml",
29 |         "application/vnd.api+json",
30 |     ],
31 | )
32 | 
33 | if "AWS_EXECUTION_ENV" in os.environ:
34 |     loop = asyncio.get_event_loop()
35 |     loop.run_until_complete(app.router.startup())
36 | 
37 | 
38 | def lambda_handler(event: LambdaEvent, context: LambdaContext) -> dict[str, Any]:
39 |     """Lambda handler with container-specific optimizations and OTEL tracing."""
40 |     return handler(event, context)
41 | 


--------------------------------------------------------------------------------
/tests/test_tms.py:
--------------------------------------------------------------------------------
 1 | """test TileMatrixSets endpoints."""
 2 | 
 3 | from morecantile import tms
 4 | 
 5 | 
 6 | def test_tilematrix(app):
 7 |     """test /tileMatrixSet endpoint."""
 8 |     response = app.get("/tileMatrixSets")
 9 |     assert response.status_code == 200
10 |     body = response.json()
11 | 
12 |     assert len(body["tileMatrixSets"]) == len(tms.list())
13 |     tileMatrixSets = list(
14 |         filter(lambda m: m["id"] == "WebMercatorQuad", body["tileMatrixSets"])
15 |     )[0]
16 |     assert (
17 |         tileMatrixSets["links"][0]["href"]
18 |         == "http://testserver/tileMatrixSets/WebMercatorQuad"
19 |     )
20 | 
21 |     response = app.get("/tileMatrixSets?f=html")
22 |     assert response.status_code == 200
23 |     assert "text/html" in response.headers["content-type"]
24 | 
25 | 
26 | def test_tilematrixInfo(app):
27 |     """test /tileMatrixSet endpoint."""
28 |     response = app.get("/tileMatrixSets/WebMercatorQuad")
29 |     assert response.headers["content-type"] == "application/json"
30 |     assert response.status_code == 200
31 |     body = response.json()
32 |     assert body["id"] == "WebMercatorQuad"
33 |     assert body["crs"]
34 |     assert body["tileMatrices"]
35 | 
36 |     response = app.get("/tileMatrixSets/WebMercatorQuad?f=html")
37 |     assert response.status_code == 200
38 |     assert "text/html" in response.headers["content-type"]
39 | 


--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/release-checklist.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | name: Release + deploy vX.X.X to staging
 3 | about: Steps to release and test titiler-cmr
 4 | title: Release + deploy vX.X.X to staging
 5 | labels: ''
 6 | assignees: ''
 7 | 
 8 | ---
 9 | 
10 | - [ ] Deploy the `develop` branch to the test deployment API endpoint by dispatching [CDK Deploy Dev Workflow](https://github.com/developmentseed/titiler-cmr/actions/workflows/deploy-dev.yml) using the develop branch.
11 | - [ ] Test https://github.com/developmentseed/titiler-cmr/issues/57 with both the test endpoint and https://staging.openveda.cloud/api/titiler-cmr
12 | - [ ] Assuming all is working, add a new header to the CHANGELOG and make a release with tag vX.X.X (note: make sure header link is working by adding a new entry at the bottom of CHANGELOG.md)
13 | - [ ] Email the mailing list (use bcc)
14 | - [ ] Update the `TITILER_CMR_GIT_REF` github environment variable for the [smce-staging environment](https://github.com/NASA-IMPACT/veda-deploy/settings/environments/4556936903/edit)
15 | - [ ] Once deploy completes, retest the endpoints in https://github.com/developmentseed/titiler-cmr/issues/57
16 | 
17 | Note: At this point, if there is an issue at this point that can be resolved quickly, go ahead and do so. If there is an issue that requires more investigation and remedy, email at least a brief update that there is a known issue that is being worked on.
18 | 
19 | - [ ] Email an update to the mailing list
20 | 


--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | name: Test
 2 | 
 3 | # Triggers on pushes to main, dev and tags.
 4 | on:
 5 |   workflow_dispatch:
 6 |   push:
 7 |     branches:
 8 |       - main
 9 |       - develop
10 |     tags:
11 |       - 'v*'
12 |     paths:
13 |       # Only run test and docker publish if some code have changed
14 |       - 'pyproject.toml'
15 |       - 'infrastructure/aws/**'
16 |       - 'titiler/**'
17 |       - '.pre-commit-config.yaml'
18 |       - '.github/workflows/ci.yml'
19 | 
20 |   # Run tests on pull requests.
21 |   pull_request:
22 | env:
23 |   LATEST_PY_VERSION: '3.10'
24 |   UV_FROZEN: 'true'
25 |   UV_NO_PROGRESS: 'true'
26 | 
27 | permissions:
28 |   id-token: write   # This is required for requesting the JWT
29 |   contents: read    # This is required for actions/checkout
30 | 
31 | jobs:
32 |   tests:
33 |     runs-on: ubuntu-latest
34 |     strategy:
35 |       matrix:
36 |         python-version: ['3.10', '3.11', '3.12']
37 | 
38 |     steps:
39 |       - uses: actions/checkout@v4
40 | 
41 |       - name: Install uv
42 |         uses: astral-sh/setup-uv@v3
43 |         with:
44 |           version: "0.5.*"
45 |           enable-cache: true
46 | 
47 |       - name: Set up Python ${{ matrix.python-version }}
48 |         run: uv python install ${{ matrix.python-version }}
49 | 
50 |       - name: Install dependencies
51 |         run: |
52 |           uv sync --all-extras
53 | 
54 |       - name: run pre-commit
55 |         if: ${{ matrix.python-version == env.LATEST_PY_VERSION }}
56 |         run: |
57 |           uv run pre-commit run --all-files
58 | 
59 |       - name: Run tests
60 |         run: uv run pytest
61 | 


--------------------------------------------------------------------------------
/titiler/cmr/enums.py:
--------------------------------------------------------------------------------
 1 | """ogcapi-pydantic enums."""
 2 | 
 3 | from enum import Enum
 4 | 
 5 | 
 6 | class MediaType(str, Enum):
 7 |     """Responses Media types formerly known as MIME types."""
 8 | 
 9 |     xml = "application/xml"
10 |     json = "application/json"
11 |     ndjson = "application/ndjson"
12 |     geojson = "application/geo+json"
13 |     geojsonseq = "application/geo+json-seq"
14 |     schemajson = "application/schema+json"
15 |     html = "text/html"
16 |     text = "text/plain"
17 |     csv = "text/csv"
18 |     openapi30_json = "application/vnd.oai.openapi+json;version=3.0"
19 |     openapi30_yaml = "application/vnd.oai.openapi;version=3.0"
20 |     pbf = "application/x-protobuf"
21 |     mvt = "application/vnd.mapbox-vector-tile"
22 |     tif = "image/tiff; application=geotiff"
23 |     jp2 = "image/jp2"
24 |     png = "image/png"
25 |     pngraw = "image/png"
26 |     jpeg = "image/jpeg"
27 |     jpg = "image/jpg"
28 |     webp = "image/webp"
29 |     npy = "application/x-binary"
30 | 
31 | 
32 | class GeoJSONSchema(str, Enum):
33 |     """GeoJSON Schemas url."""
34 | 
35 |     GEOMETRY = ("https://geojson.org/schema/Geometry.json",)
36 |     POINT = ("https://geojson.org/schema/Point.json",)
37 |     MULTIPOINT = ("https://geojson.org/schema/MultiPoint.json",)
38 |     LINESTRING = ("https://geojson.org/schema/LineString.json",)
39 |     MULTILINESTRING = ("https://geojson.org/schema/MultiLineString.json",)
40 |     POLYGON = ("https://geojson.org/schema/Polygon.json",)
41 |     MULTIPOLYGON = ("https://geojson.org/schema/MultiPolygon.json",)
42 |     GEOMETRYCOLLECTION = ("https://geojson.org/schema/GeometryCollection.json",)
43 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
 1 | # Development - Contributing
 2 | 
 3 | Issues and pull requests are more than welcome: <https://github.com/developmentseed/titiler-cmr/issues>
 4 | 
 5 | **dev install**
 6 | 
 7 | This project uses [`uv`](https://docs.astral.sh/uv/) to manage the python environment and dependencies.
 8 | To install the package for development you can follow these steps:
 9 | 
10 | ```bash
11 | # install uv
12 | 
13 | # unix
14 | curl -LsSf https://astral.sh/uv/install.sh | sh
15 | 
16 | # or windows
17 | # powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
18 | 
19 | git clone https://github.com/developmentseed/titiler-cmr.git
20 | cd titiler-cmr
21 | uv sync --all-extras
22 | ```
23 | 
24 | ## Linting
25 | 
26 | This repo is set to use `pre-commit` to run *isort*, *flake8*, *pydocstring*, *black* ("uncompromising Python code formatter") and mypy when committing new code.
27 | 
28 | ```bash
29 | uv run pre-commit install
30 | ```
31 | 
32 | ## Testing
33 | 
34 | You can then run the tests with the following command:
35 | 
36 | ```bash
37 | uv run pytest
38 | ```
39 | 
40 | The tests use `vcrpy <https://vcrpy.readthedocs.io/en/latest/>`_ to mock API calls
41 | with "pre-recorded" API responses. When adding new tests that incur actual network traffic,
42 | use the ``@pytest.mark.vcr`` decorator function to indicate ``vcrpy`` should be used.
43 | Record the new responses and commit them to the repository.
44 | 
45 | ```bash
46 | uv run pytest -v -s --record-mode new_episodes
47 | ```
48 | 
49 | ## Documentation
50 | 
51 | The documentation is generated using `mkdocs` and gets built and deployed to Github Pages when new tags are released and on pushes to the `develop` branch.
52 | 
53 | To preview the documentation in your browser you can run:
54 | 
55 | ```bash
56 | uv run mkdocs serve -o
57 | ```
58 | 


--------------------------------------------------------------------------------
/docs/compatibility/plotting.py:
--------------------------------------------------------------------------------
 1 | """
 2 | Utilities for plotting
 3 | """
 4 | 
 5 | import matplotlib.pyplot as plt
 6 | import matplotlib.cm as cm
 7 | import numpy as np
 8 | 
 9 | 
10 | def create_pie_chart(labels, sizes, title="Pie Chart", legend=False, top_n=-1):
11 |     """
12 |     Create a pie chart with automatic color generation
13 | 
14 |     Parameters:
15 |     labels: list of category names
16 |     sizes: list of values/counts
17 |     title: chart title (optional)
18 |     legend: whether to show legend
19 |     top_n: number of top categories to show percentages on (-1 for all)
20 |     """
21 |     # Generate colors based on number of items
22 |     n = len(labels)
23 |     colors = cm.Set3(np.linspace(0, 1, n))
24 | 
25 |     # Find the top N values - handle the case when top_n=-1
26 |     if top_n == -1 or top_n >= n:
27 |         top_indices = set(range(n))  # All indices
28 |     else:
29 |         top_indices = set(np.argsort(sizes)[::-1][:top_n])
30 | 
31 |     # Create the pie chart
32 |     plt.figure(figsize=(8, 6))
33 | 
34 |     common_args = {
35 |         "x": sizes,
36 |         "colors": colors,
37 |         "autopct": "%1.1f%%",
38 |         "startangle": 90,
39 |         "textprops": {"fontsize": 11},
40 |         "labels": labels,
41 |     }
42 | 
43 |     _, texts, autotexts = plt.pie(**common_args)
44 | 
45 |     if legend:
46 |         # Add legend with labels and counts
47 |         legend_labels = [f"{label}: {size}" for label, size in zip(labels, sizes)]
48 |         plt.legend(
49 |             legend_labels,
50 |             loc="center left",
51 |             bbox_to_anchor=(1, 0.5),
52 |             fontsize=10,
53 |             title="Counts",
54 |         )
55 | 
56 |     # Hide percentages for non-top N categories
57 |     for i, (text, autotext) in enumerate(zip(texts, autotexts)):
58 |         if i not in top_indices:
59 |             text.set_text("")
60 |             autotext.set_text("")
61 | 
62 |     plt.title(title, fontsize=14, fontweight="bold")
63 |     plt.axis("equal")
64 |     plt.tight_layout()
65 |     plt.show()
66 | 


--------------------------------------------------------------------------------
/.github/workflows/deploy-dev.yml:
--------------------------------------------------------------------------------
 1 | name: CDK Deploy Dev Workflow 🚀
 2 | 
 3 | permissions:
 4 |   id-token: write
 5 |   contents: read
 6 | 
 7 | on:
 8 |   workflow_dispatch:
 9 |     inputs:
10 |       branch:
11 |         description: 'Branch to deploy'
12 |         required: true
13 |         default: 'develop'
14 |   pull_request:
15 |     types: [labeled, synchronize]
16 | 
17 | jobs:
18 |   deploy:
19 |     name: Deploy to dev 🚀
20 |     runs-on: ubuntu-latest
21 |     if: >
22 |       github.event_name != 'pull_request' ||
23 |       (github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'deploy-dev'))    
24 | 
25 |     steps:
26 |       - name: Determine branch to deploy
27 |         id: set_branch
28 |         run: |
29 |           if [ "${{ github.event_name }}" == "workflow_dispatch" ]; then
30 |             echo "branch=${{ github.event.inputs.branch }}" >> $GITHUB_OUTPUT
31 |           elif [ "${{ github.event_name }}" == "pull_request" ]; then
32 |             echo "branch=${{ github.event.pull_request.head.ref }}" >> $GITHUB_OUTPUT
33 |           else
34 |             echo "branch=${{ github.ref_name }}" >> $GITHUB_OUTPUT
35 |           fi
36 | 
37 |       - name: Checkout
38 |         uses: actions/checkout@v4
39 |         with:
40 |           ref: ${{ steps.set_branch.outputs.branch }}
41 | 
42 |       - name: Configure AWS credentials
43 |         uses: aws-actions/configure-aws-credentials@v2
44 |         with:
45 |           role-to-assume: ${{ secrets.deploy_role_arn }}
46 |           role-session-name: test-deploy
47 |           aws-region: us-west-2
48 | 
49 |       - name: Run titiler-cmr deployment
50 |         uses: "./.github/actions/cdk-deploy"
51 |         with:
52 |           dir: "./infrastructure/aws"
53 |           env_aws_secret_name: ""
54 |         env:
55 |           # I'm not sure this is in use anymore, should we remove it?
56 |           TITILER_CMR_ROLE_ARN: ${{ secrets.titiler_cmr_role_arn }}
57 |           TITILER_CMR_ROOT_PATH: ''
58 |           STAGE: dev
59 |           TITILER_CMR_AWS_REQUEST_PAYER: requester
60 |           TITILER_CMR_S3_AUTH_STRATEGY: iam
61 | 


--------------------------------------------------------------------------------
/infrastructure/aws/cdk/config.py:
--------------------------------------------------------------------------------
 1 | """STACK Configs."""
 2 | 
 3 | from typing import List, Optional
 4 | 
 5 | from pydantic import Field
 6 | from pydantic_settings import BaseSettings, SettingsConfigDict
 7 | 
 8 | 
 9 | class StackSettings(BaseSettings):
10 |     """Stack settings"""
11 | 
12 |     veda_custom_host: Optional[str] = None
13 |     stage: str = "production"
14 | 
15 |     model_config = SettingsConfigDict(env_file=".env", extra="ignore")
16 | 
17 |     bootstrap_qualifier: Optional[str] = Field(
18 |         None,
19 |         description="Custom bootstrap qualifier override if not using a default installation of AWS CDK Toolkit to synthesize app.",
20 |     )
21 | 
22 |     permissions_boundary_policy_name: Optional[str] = Field(
23 |         None,
24 |         description="Name of IAM policy to define stack permissions boundary",
25 |     )
26 | 
27 | 
28 | class AppSettings(BaseSettings):
29 |     """Application settings"""
30 | 
31 |     name: str = "titiler-cmr"
32 | 
33 |     owner: Optional[str] = None
34 |     client: Optional[str] = None
35 |     project: Optional[str] = None
36 | 
37 |     # S3 bucket names where TiTiler could do HEAD and GET Requests
38 |     # specific private and public buckets MUST be added if you want to use s3:// urls
39 |     # You can whitelist all bucket by setting `*`.
40 |     # ref: https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-arn-format.html
41 |     buckets: List = []
42 | 
43 |     # S3 key pattern to limit the access to specific items (e.g: "my_data/*.tif")
44 |     key: str = "*"
45 | 
46 |     timeout: int = 30
47 |     memory: int = 10240
48 | 
49 |     role_arn: Optional[str] = None
50 | 
51 |     # The maximum of concurrent executions you want to reserve for the function.
52 |     # Default: - No specific limit - account limit.
53 |     max_concurrent: Optional[int] = None
54 |     alarm_email: Optional[str] = None
55 |     root_path: Optional[str] = None
56 |     s3_auth_strategy: Optional[str] = "environment"
57 |     aws_request_payer: Optional[str] = None
58 | 
59 |     model_config = SettingsConfigDict(
60 |         env_prefix="TITILER_CMR_", env_file=".env", extra="ignore"
61 |     )
62 | 


--------------------------------------------------------------------------------
/titiler/cmr/settings.py:
--------------------------------------------------------------------------------
 1 | """API settings."""
 2 | 
 3 | from typing import Literal
 4 | 
 5 | from pydantic import Field, field_validator, model_validator
 6 | from pydantic_settings import BaseSettings
 7 | from typing_extensions import Annotated
 8 | 
 9 | 
10 | class ApiSettings(BaseSettings):
11 |     """API settings"""
12 | 
13 |     name: str = "titiler-cmr"
14 |     cors_origins: str = "*"
15 |     cachecontrol: str = "public, max-age=3600"
16 |     root_path: str = ""
17 |     time_series_max_requests: int = 995
18 |     time_series_max_image_size: float = 5.625e7
19 |     time_series_statistics_max_total_size: float = 1.5e10
20 |     time_series_image_max_total_size: float = 1e8
21 |     telemetry_enabled: bool = False
22 |     debug: bool = False
23 | 
24 |     model_config = {
25 |         "env_prefix": "TITILER_CMR_",
26 |         "env_file": ".env",
27 |         "extra": "ignore",
28 |     }
29 | 
30 |     @field_validator("cors_origins")
31 |     def parse_cors_origin(cls, v):
32 |         """Parse CORS origins."""
33 |         return [origin.strip() for origin in v.split(",")]
34 | 
35 | 
36 | class CacheSettings(BaseSettings):
37 |     """Cache settings"""
38 | 
39 |     # TTL of the cache in seconds
40 |     ttl: int = 300
41 | 
42 |     # Maximum size of the cache in Number of element
43 |     maxsize: int = 512
44 | 
45 |     # Whether or not caching is enabled
46 |     disable: bool = False
47 | 
48 |     model_config = {"env_prefix": "TITILER_CMR_CACHE_", "env_file": ".env"}
49 | 
50 |     @model_validator(mode="after")
51 |     def check_enable(self):
52 |         """Check if cache is disabled."""
53 |         if self.disable:
54 |             self.ttl = 0
55 |             self.maxsize = 0
56 | 
57 |         return self
58 | 
59 | 
60 | class RetrySettings(BaseSettings):
61 |     """Retry settings"""
62 | 
63 |     retry: Annotated[int, Field(ge=0)] = 3
64 |     delay: Annotated[float, Field(ge=0.0)] = 0.0
65 | 
66 |     model_config = {
67 |         "env_prefix": "TITILER_CMR_",
68 |         "env_file": ".env",
69 |         "extra": "ignore",
70 |     }
71 | 
72 | 
73 | class AuthSettings(BaseSettings):
74 |     """AWS credential settings."""
75 | 
76 |     strategy: Literal["environment", "iam", "netrc"] = "environment"
77 |     access: Literal["direct", "external"] = "direct"
78 | 
79 |     model_config = {
80 |         "env_prefix": "TITILER_CMR_S3_AUTH_",
81 |         "env_file": ".env",
82 |     }
83 | 


--------------------------------------------------------------------------------
/infrastructure/aws/cdk/permissions_boundary/construct.py:
--------------------------------------------------------------------------------
 1 | """Class that applies permissions boundary to all the roles created within a Stack"""
 2 | 
 3 | from typing import Union
 4 | 
 5 | import jsii
 6 | from aws_cdk import IAspect, aws_iam
 7 | from constructs import IConstruct
 8 | from jsii._reference_map import _refs
 9 | from jsii._utils import Singleton
10 | 
11 | 
12 | @jsii.implements(IAspect)
13 | class PermissionsBoundaryAspect:
14 |     """
15 |     This aspect finds all aws_iam.Role objects in a node (ie. CDK stack) and sets permissions boundary to the given ARN.
16 |     """
17 | 
18 |     def __init__(self, permissions_boundary: Union[aws_iam.ManagedPolicy, str]) -> None:
19 |         """
20 |         :param permissions_boundary: Either aws_iam.ManagedPolicy object or managed policy's ARN string
21 |         """
22 |         self.permissions_boundary = permissions_boundary
23 | 
24 |     def visit(self, construct_ref: IConstruct) -> None:
25 |         """
26 |         construct_ref only contains a string reference to an object. To get the actual object, we need to resolve it using JSII mapping.
27 |         :param construct_ref: ObjRef object with string reference to the actual object.
28 |         :return: None
29 |         """
30 |         if isinstance(construct_ref, jsii._kernel.ObjRef) and hasattr(
31 |             construct_ref, "ref"
32 |         ):
33 |             kernel = Singleton._instances[
34 |                 jsii._kernel.Kernel
35 |             ]  # The same object is available as: jsii.kernel
36 |             resolve = _refs.resolve(kernel, construct_ref)
37 |         else:
38 |             resolve = construct_ref
39 | 
40 |         def _walk(obj):
41 |             if isinstance(obj, aws_iam.Role):
42 |                 cfn_role = obj.node.find_child("Resource")
43 |                 policy_arn = (
44 |                     self.permissions_boundary
45 |                     if isinstance(self.permissions_boundary, str)
46 |                     else self.permissions_boundary.managed_policy_arn
47 |                 )
48 |                 cfn_role.add_property_override("PermissionsBoundary", policy_arn)
49 |             else:
50 |                 if hasattr(obj, "permissions_node"):
51 |                     for c in obj.permissions_node.children:
52 |                         _walk(c)
53 |                 if hasattr(obj, "node") and obj.node.children:
54 |                     for c in obj.node.children:
55 |                         _walk(c)
56 | 
57 |         _walk(resolve)
58 | 


--------------------------------------------------------------------------------
/docker-compose.yml:
--------------------------------------------------------------------------------
 1 | services:
 2 |   tiler:
 3 |     container_name: tiler-cmr
 4 |     platform: linux/amd64
 5 |     build:
 6 |       context: .
 7 |       dockerfile: Dockerfile
 8 |       args:
 9 |         EARTHDATA_USERNAME: ${EARTHDATA_USERNAME}
10 |         EARTHDATA_PASSWORD: ${EARTHDATA_PASSWORD}
11 |     ports:
12 |       - "8081:8081"
13 |     volumes:
14 |       - ./titiler:/app/titiler
15 |     environment:
16 |       # Application
17 |       - HOST=0.0.0.0
18 |       - PORT=8081
19 |       - WEB_CONCURRENCY=1
20 |       - TITILER_CMR_DEBUG=TRUE
21 |       - TITILER_CMR_S3_AUTH_STRATEGY=iam
22 |       - TITILER_CMR_S3_AUTH_ACCESS=external
23 |       # earthdata authentication
24 |       - EARTHDATA_USERNAME=${EARTHDATA_USERNAME}
25 |       - EARTHDATA_PASSWORD=${EARTHDATA_PASSWORD}
26 |       # GDAL Config
27 |       # This option controls the default GDAL raster block cache size.
28 |       # If its value is small (less than 100000), it is assumed to be measured in megabytes, otherwise in bytes.
29 |       - GDAL_CACHEMAX=200
30 |       - GDAL_DISABLE_READDIR_ON_OPEN=EMPTY_DIR
31 |       - GDAL_INGESTED_BYTES_AT_OPEN=32768
32 |       - GDAL_HTTP_MERGE_CONSECUTIVE_RANGES=YES
33 |       - GDAL_HTTP_COOKIEJAR=/tmp/cookies.txt
34 |       - GDAL_HTTP_MULTIPLEX=YES
35 |       - GDAL_HTTP_VERSION=2
36 |       # The file can be cached in RAM by setting the configuration option VSI_CACHE to TRUE.
37 |       # The cache size defaults to 25 MB, but can be modified by setting the configuration option VSI_CACHE_SIZE (in bytes).
38 |       # Content in that cache is discarded when the file handle is closed.
39 |       - VSI_CACHE=TRUE
40 |       - VSI_CACHE_SIZE=536870912
41 |       # In addition, a global least-recently-used cache of 16 MB shared among all downloaded content is enabled by default,
42 |       # and content in it may be reused after a file handle has been closed and reopen,
43 |       # during the life-time of the process or until VSICurlClearCache() is called.
44 |       # Starting with GDAL 2.3, the size of this global LRU cache can be modified by
45 |       # setting the configuration option CPL_VSIL_CURL_CACHE_SIZE (in bytes).
46 |       - CPL_VSIL_CURL_CACHE_SIZE=200000000
47 |       # TiTiler Config
48 |       - MOSAIC_CONCURRENCY=5
49 |       # AWS S3 endpoint config
50 |       # - AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID}
51 |       # - AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY}
52 |     develop:
53 |       watch:
54 |         - action: rebuild
55 |           path: ./pyproject.toml
56 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | 
  9 | # Distribution / packaging
 10 | .Python
 11 | env/
 12 | build/
 13 | develop-eggs/
 14 | dist/
 15 | downloads/
 16 | eggs/
 17 | .eggs/
 18 | lib/
 19 | lib64/
 20 | parts/
 21 | sdist/
 22 | var/
 23 | wheels/
 24 | *.egg-info/
 25 | .installed.cfg
 26 | *.egg
 27 | 
 28 | # PyInstaller
 29 | #  Usually these files are written by a python script from a template
 30 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 31 | *.manifest
 32 | *.spec
 33 | 
 34 | # Installer logs
 35 | pip-log.txt
 36 | pip-delete-this-directory.txt
 37 | 
 38 | # Unit test / coverage reports
 39 | htmlcov/
 40 | .tox/
 41 | .coverage
 42 | .coverage.*
 43 | .cache
 44 | nosetests.xml
 45 | coverage.xml
 46 | *.cover
 47 | .hypothesis/
 48 | 
 49 | # Translations
 50 | *.mo
 51 | *.pot
 52 | 
 53 | # Django stuff:
 54 | *.log
 55 | local_settings.py
 56 | 
 57 | # Flask stuff:
 58 | instance/
 59 | .webassets-cache
 60 | 
 61 | # Scrapy stuff:
 62 | .scrapy
 63 | 
 64 | # Sphinx documentation
 65 | docs/_build/
 66 | 
 67 | # PyBuilder
 68 | target/
 69 | 
 70 | # Jupyter Notebook
 71 | .ipynb_checkpoints
 72 | 
 73 | # celery beat schedule file
 74 | celerybeat-schedule
 75 | 
 76 | # SageMath parsed files
 77 | *.sage.py
 78 | 
 79 | # dotenv
 80 | .env
 81 | .env.*
 82 | 
 83 | # virtualenv
 84 | .venv
 85 | venv/
 86 | ENV/
 87 | 
 88 | # Spyder project settings
 89 | .spyderproject
 90 | .spyproject
 91 | 
 92 | # Rope project settings
 93 | .ropeproject
 94 | 
 95 | # mkdocs documentation
 96 | /site
 97 | 
 98 | # mypy
 99 | .mypy_cache/
100 | 
101 | # AWS CDK
102 | cdk.out/
103 | node_modules
104 | cdk.context.json
105 | 
106 | notebooks/
107 | .envrc
108 | 
109 | # Created by https://www.toptal.com/developers/gitignore/api/visualstudiocode
110 | # Edit at https://www.toptal.com/developers/gitignore?templates=visualstudiocode
111 | 
112 | ### VisualStudioCode ###
113 | .vscode/*
114 | #!.vscode/settings.json
115 | #!.vscode/tasks.json
116 | #!.vscode/launch.json
117 | #!.vscode/extensions.json
118 | #!.vscode/*.code-snippets
119 | 
120 | # Local History for Visual Studio Code
121 | .history/
122 | 
123 | # Built Visual Studio Code Extensions
124 | *.vsix
125 | 
126 | ### VisualStudioCode Patch ###
127 | # Ignore all local history of files
128 | .history
129 | .ionide
130 | 
131 | # End of https://www.toptal.com/developers/gitignore/api/visualstudiocode
132 | 


--------------------------------------------------------------------------------
/.github/actions/cdk-deploy/action.yml:
--------------------------------------------------------------------------------
 1 | name: Deploy
 2 | 
 3 | inputs:
 4 |   env_aws_secret_name:
 5 |     required: false
 6 |     type: string
 7 |     default: ''
 8 |   dir:
 9 |     required: false
10 |     type: string
11 |     default: "."
12 |   script_path:
13 |     required: true
14 |     type: string
15 |     default: ''
16 |   skip_deploy:
17 |     required: false
18 |     type: string
19 |     default: 'false'
20 | 
21 | runs:
22 |   using: "composite"
23 |   steps:
24 |     - name: Install node and related deps
25 |       uses: actions/setup-node@v4
26 |       with:
27 |         node-version: 20
28 | 
29 |     - uses: actions/cache@v3
30 |       with:
31 |         path: ~/.npm
32 |         key: ${{ runner.os }}-build-${{ env.cache-name }}-${{ hashFiles('**/package-lock.json') }}
33 | 
34 |     - name: Install AWS CDK
35 |       shell: bash
36 |       run: npm install -g aws-cdk@2
37 | 
38 |     - name: Install uv
39 |       uses: astral-sh/setup-uv@v7
40 |       with:
41 |         version: "0.5.*" 
42 | 
43 |     - name: Install dependencies
44 |       shell: bash
45 |       working-directory: ${{ inputs.dir }}
46 |       run: |
47 |         uv sync --only-group deployment
48 |         uv run npm install
49 | 
50 |     - name: Get relevant environment configuration from aws secrets
51 |       if: inputs.env_aws_secret_name != ''
52 |       shell: bash
53 |       working-directory: ${{ inputs.dir }}
54 |       env:
55 |         AWS_DEFAULT_REGION: us-west-2
56 |       run: uv run --only-group deployment ${{ inputs.script_path }} --secret-id ${{ inputs.env_aws_secret_name }}
57 | 
58 |     - name: CDK Synth
59 |       shell: bash
60 |       working-directory: ${{ inputs.dir }}
61 |       run: uv run --only-group deployment npm run cdk -- synth
62 | 
63 |     - name: Check Asset Sizes
64 |       shell: bash
65 |       working-directory: ${{ inputs.dir }}
66 |       run: |
67 |         MAX_SIZE_BYTES=262144000  # 262 MB in bytes
68 |         for dir in cdk.out/asset.*; do
69 |           if [ -d "$dir" ]; then
70 |             size=$(du -sb "$dir" | cut -f1)
71 |             if [ "$size" -gt $MAX_SIZE_BYTES ]; then
72 |               echo "Directory $dir exceeds 262 MB with size $size bytes (max: $MAX_SIZE_BYTES bytes)."
73 |               exit 1
74 |             fi
75 |             echo "Asset directory $dir size: $size bytes"
76 |           fi
77 |         done
78 |         echo "All asset directories are within size limits."
79 | 
80 |     - name: Deploy Test
81 |       if: ${{ inputs.skip_deploy == 'false' }}
82 |       id: deploy_titiler_cmr_stack
83 |       working-directory: ${{ inputs.dir }}
84 |       run: uv run cdk deploy --all --require-approval never --outputs-file ${HOME}/cdk-outputs.json
85 |       shell: bash
86 | 


--------------------------------------------------------------------------------
/infrastructure/aws/package-lock.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "cdk-deploy",
 3 |   "version": "0.1.0",
 4 |   "lockfileVersion": 2,
 5 |   "requires": true,
 6 |   "packages": {
 7 |     "": {
 8 |       "name": "cdk-deploy",
 9 |       "version": "0.1.0",
10 |       "license": "MIT",
11 |       "dependencies": {
12 |         "cdk": "2.94.0"
13 |       }
14 |     },
15 |     "node_modules/aws-cdk": {
16 |       "version": "2.94.0",
17 |       "resolved": "https://registry.npmjs.org/aws-cdk/-/aws-cdk-2.94.0.tgz",
18 |       "integrity": "sha512-9bJkzxFDYZDwPDfZi/DSUODn4HFRzuXWPhpFgIIgRykfT18P+iAIJ1AEhaaCmlqrrog5yQgN+2iYd9BwDsiBeg==",
19 |       "bin": {
20 |         "cdk": "bin/cdk"
21 |       },
22 |       "engines": {
23 |         "node": ">= 14.15.0"
24 |       },
25 |       "optionalDependencies": {
26 |         "fsevents": "2.3.2"
27 |       }
28 |     },
29 |     "node_modules/cdk": {
30 |       "version": "2.94.0",
31 |       "resolved": "https://registry.npmjs.org/cdk/-/cdk-2.94.0.tgz",
32 |       "integrity": "sha512-dMgSTaMtfpPxY2biMSHlNrwrJcq0iJkihvkVuSSQyhlHyLmH0s9fSBzO8zrGFAoEp/cDofg6iDfGzmwrHQ55LA==",
33 |       "dependencies": {
34 |         "aws-cdk": "2.94.0"
35 |       },
36 |       "bin": {
37 |         "cdk": "bin/cdk"
38 |       },
39 |       "engines": {
40 |         "node": ">= 14.15.0"
41 |       }
42 |     },
43 |     "node_modules/fsevents": {
44 |       "version": "2.3.2",
45 |       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
46 |       "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
47 |       "hasInstallScript": true,
48 |       "optional": true,
49 |       "os": [
50 |         "darwin"
51 |       ],
52 |       "engines": {
53 |         "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
54 |       }
55 |     }
56 |   },
57 |   "dependencies": {
58 |     "aws-cdk": {
59 |       "version": "2.94.0",
60 |       "resolved": "https://registry.npmjs.org/aws-cdk/-/aws-cdk-2.94.0.tgz",
61 |       "integrity": "sha512-9bJkzxFDYZDwPDfZi/DSUODn4HFRzuXWPhpFgIIgRykfT18P+iAIJ1AEhaaCmlqrrog5yQgN+2iYd9BwDsiBeg==",
62 |       "requires": {
63 |         "fsevents": "2.3.2"
64 |       }
65 |     },
66 |     "cdk": {
67 |       "version": "2.94.0",
68 |       "resolved": "https://registry.npmjs.org/cdk/-/cdk-2.94.0.tgz",
69 |       "integrity": "sha512-dMgSTaMtfpPxY2biMSHlNrwrJcq0iJkihvkVuSSQyhlHyLmH0s9fSBzO8zrGFAoEp/cDofg6iDfGzmwrHQ55LA==",
70 |       "requires": {
71 |         "aws-cdk": "2.94.0"
72 |       }
73 |     },
74 |     "fsevents": {
75 |       "version": "2.3.2",
76 |       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
77 |       "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
78 |       "optional": true
79 |     }
80 |   }
81 | }
82 | 


--------------------------------------------------------------------------------
/titiler/cmr/templates/tilematrixset.html:
--------------------------------------------------------------------------------
 1 | {% include "header.html" %}
 2 | 
 3 | <nav aria-label="breadcrumb">
 4 |   <ol class="breadcrumb bg-light">
 5 |     {% for crumb in crumbs %}
 6 |       {% if not loop.last %}
 7 |     <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
 8 |       {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
 9 |       {% endif %}
10 |     {% endfor %}
11 | 
12 |     <li class="ml-auto json-link"><a target="_blank" href="{{ url }}?f=json">JSON</a></li>
13 |   </ol>
14 | </nav>
15 | 
16 | <h1>{{ response.title or response.id }}</h1>
17 | 
18 | <div class="row">
19 |   <div class="col-sm">
20 |     <ul>
21 |       {% for key in ['title', 'description', 'id', 'uri', 'crs', 'wellKnownScaleSet', 'orderedAxes'] %}
22 |         {% if response[key]  %}
23 |           <li><strong>{{ key }}:</strong> {{ response[key] }}</li>
24 |         {% endif %}
25 |       {% endfor %}
26 | 
27 |       <li><strong>Nb TileMatrices:</strong> {{ response.tileMatrices|count }}</li>
28 |       <li><strong>Min level:</strong> {{ response.tileMatrices[0].id }}</li>
29 |       <li><strong>Max level:</strong> {{ response.tileMatrices[-1].id }}</li>
30 |       <li><strong>Origin:</strong> {{ response.tileMatrices[0].pointOfOrigin }}</li>
31 |       <li><strong>Tile size:</strong> {{ [response.tileMatrices[0].tileWidth, response.tileMatrices[0].tileHeight] }}</li>
32 | 
33 |     </ul>
34 |   </div>
35 |   <div class="col-sm">
36 |     <div id="map" class="rounded" style="width: 100%; height: 400px">
37 |       Loading...
38 |     </div>
39 |   </div>
40 | </div>
41 | 
42 | <script>
43 |   $(function() {
44 |     var map = L.map('map').setView([0, 0], 1);
45 |     map.addLayer(new L.TileLayer(
46 |       'https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
47 |         maxZoom: 18,
48 |         attribution: 'Map data &copy; <a href="https://openstreetmap.org/copyright">OpenStreetMap contributors</a>'
49 |       }
50 |     ));
51 | 
52 |     var bbox = {{ response.bbox or [-180,-90,180,90] }};
53 | 
54 |     const bboxPolygon = (bounds) => {
55 |       return {
56 |         'type': 'Feature',
57 |         'geometry': {
58 |             'type': 'Polygon',
59 |             'coordinates': [[
60 |                 [bounds[0], bounds[1]],
61 |                 [bounds[2], bounds[1]],
62 |                 [bounds[2], bounds[3]],
63 |                 [bounds[0], bounds[3]],
64 |                 [bounds[0], bounds[1]]
65 |             ]]
66 |         },
67 |         'properties': {}
68 |       }
69 |     }
70 | 
71 |     if (bbox[0] > bbox[2]) {
72 |       geo = {
73 |         "type": "FeatureCollection",
74 |         "features": [
75 |           bboxPolygon([-180, bbox[1], bbox[2], bbox[3]]),
76 |           bboxPolygon([bbox[0], bbox[1], 180, bbox[3]]),
77 |         ]
78 |       }
79 |     } else {
80 |       geo = {
81 |         "type": "FeatureCollection",
82 |         "features": [bboxPolygon(bbox)]
83 |       }
84 |     }
85 | 
86 |     var aoi = L.geoJSON(geo).addTo(map);
87 |     map.fitBounds(aoi.getBounds());
88 |   });
89 | </script>
90 | {% include "footer.html" %}
91 | 


--------------------------------------------------------------------------------
/docs/overrides/stylesheets/extra.css:
--------------------------------------------------------------------------------
  1 | :root,
  2 | [data-md-color-scheme="default"] {
  3 |   /* --md-heading-font: "Oswald"; */
  4 |   --md-primary-fg-color: #cf3f02;
  5 |   --md-default-fg-color: #443f3f;
  6 |   --boxShadowD: 0px 12px 24px 0px rgba(68, 63, 63, 0.08),
  7 |   /* xarray display settings */
  8 |   --xr-background-color: #ffffff;
  9 |   --xr-font-color: #24292e;
 10 |   --xr-border-color: #e1e4e8;
 11 |   --xr-background-color-row-even: #f6f8fa;
 12 |   --xr-background-color-row-odd: #ffffff;
 13 |     0px 0px 4px 0px rgba(68, 63, 63, 0.08);
 14 | }
 15 | [data-md-color-scheme="slate"] {
 16 |   /* xarray display settings */
 17 |   --xr-background-color: #1e1e1e;
 18 |   --xr-font-color: #d4d4d4;
 19 |   --xr-font-color0: #ffffff;
 20 |   --xr-font-color1: #d4d4d4;
 21 |   --xr-font-color2: #a0a0a0;
 22 |   --xr-font-color3: #a0a0a0;
 23 |   --xr-border-color: #404040;
 24 |   --xr-background-color-row-even: #252525;
 25 |   --xr-background-color-row-odd: #1e1e1e;
 26 | }
 27 | body {
 28 |   margin: 0;
 29 |   padding: 0;
 30 |   /* font-size: 16px; */
 31 | }
 32 | h1,
 33 | h2,
 34 | h3,
 35 | h4,
 36 | h5,
 37 | h6 {
 38 |   font-family: var(--md-heading-font);
 39 |   font-weight: bold;
 40 | }
 41 | .md-typeset h1,
 42 | .md-typeset h2,
 43 | .md-typeset h3,
 44 | .md-typeset h4 {
 45 |   font-weight: normal;
 46 |   color: var(--md-default-fg-color);
 47 | }
 48 | .md-button,
 49 | .md-typeset .md-button {
 50 |   font-family: var(--md-heading-font);
 51 | }
 52 | .md-content .supheading {
 53 |   font-family: var(--md-heading-font);
 54 |   text-transform: uppercase;
 55 |   color: var(--md-primary-fg-color);
 56 |   font-size: 0.75rem;
 57 |   font-weight: bold;
 58 | }
 59 | 
 60 | /* Fix xarray dataset HTML representation in jupyter notebook renderings. */
 61 | /* See https://github.com/danielfrg/mkdocs-jupyter/issues/164 for conversation */
 62 | 
 63 | /* Reinstate the display off-switch for xarray dataset views. */
 64 | /* See https://github.com/damianavila/RISE/issues/594 for inspiration. */
 65 | .md-typeset pre.xr-text-repr-fallback {
 66 |   display: none;
 67 | }
 68 | 
 69 | .md-typeset ul.xr-sections,
 70 | .jupyter-wrapper .jp-OutputArea-output dl.xr-attrs {
 71 |   display: grid;
 72 | }
 73 | 
 74 | .md-typeset li.xr-var-item,
 75 | .md-typeset ul.xr-var-list {
 76 |   display: contents;
 77 | }
 78 | 
 79 | .md-typeset .xr-section-details {
 80 |   display: none;
 81 | }
 82 | 
 83 | .md-typeset ul.xr-dim-list li {
 84 |   margin-bottom: 0;
 85 |   margin-left: 0;
 86 | }
 87 | 
 88 | .md-typeset ul.xr-dim-list {
 89 |   margin-bottom: 0;
 90 |   margin-top: 0;
 91 | }
 92 | 
 93 | .jupyter-wrapper .jp-OutputArea-output .xr-attrs dt {
 94 |   padding: 0;
 95 |   margin: 0;
 96 |   float: left;
 97 |   padding-right: 10px;
 98 |   width: auto;
 99 |   font-weight: normal;
100 |   grid-column: 1;
101 | }
102 | 
103 | .jupyter-wrapper .jp-OutputArea-output .xr-attrs dd {
104 |   white-space: nowrap;
105 |   overflow: hidden;
106 |   text-overflow: ellipsis;
107 |   padding-right: 10px;
108 | }
109 | 
110 | .jupyter-wrapper .jp-OutputArea-output .xr-attrs dd:hover {
111 |   overflow: auto;
112 |   width: auto;
113 |   z-index: 1;
114 | }
115 | 


--------------------------------------------------------------------------------
/.github/workflows/docs.yml:
--------------------------------------------------------------------------------
 1 | name: Documentation
 2 | on:
 3 |   push:
 4 |     branches:
 5 |       - develop
 6 |     tags:
 7 |       - 'v*'
 8 |   workflow_dispatch:
 9 |     inputs:
10 |       version:
11 |         description: 'Version to deploy (e.g., 0.1.4, or "dev" for develop branch)'
12 |         required: true
13 |         type: string
14 | 
15 | permissions:
16 |   contents: write
17 | 
18 | concurrency:
19 |   group: docs-deployment
20 |   cancel-in-progress: false
21 | 
22 | jobs:
23 |   deploy-versions:
24 |     if: github.event_name == 'push' || github.event_name == 'workflow_dispatch'
25 |     runs-on: ubuntu-latest
26 |     steps:
27 |       - uses: actions/checkout@v4
28 |         with:
29 |           fetch-depth: 0  # Important for mike to work with tags
30 |           ref: ${{ github.event_name == 'workflow_dispatch' && inputs.version != 'dev' && format('v{0}', inputs.version) || github.ref }}
31 | 
32 |       - uses: astral-sh/setup-uv@v7
33 |         with:
34 |           version: "0.9.*"
35 |           enable-cache: true
36 |       - name: Sync
37 |         run: |
38 |           uv sync
39 |           git restore uv.lock
40 | 
41 |       - name: Configure Git
42 |         run: |
43 |           git config --local user.name "GitHub Actions"
44 |           git config --local user.email "actions@github.com"
45 | 
46 |       - name: Fetch gh-pages branch
47 |         run: |
48 |           git fetch origin gh-pages --depth=1 || true
49 |       
50 |       - name: Deploy docs
51 |         env:
52 |           EARTHDATA_USERNAME: ${{ secrets.earthdata_username }}
53 |           EARTHDATA_PASSWORD: ${{ secrets.earthdata_password }}
54 |         run: |
55 |           echo "machine urs.earthdata.nasa.gov\nlogin ${EARTHDATA_USERNAME}\npassword ${EARTHDATA_PASSWORD}" > ~/.netrc
56 | 
57 |           # Handle manual workflow dispatch
58 |           if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
59 |             VERSION="${{ inputs.version }}"
60 |             if [[ "$VERSION" == "dev" ]]; then
61 |               uv run mike deploy --push --update-aliases dev
62 |               uv run mike set-default --push dev
63 |             else
64 |               uv run mike deploy --push $VERSION
65 | 
66 |               # Check if this should be the latest version
67 |               LATEST_TAG=$(git tag --sort=-creatordate | head -n 1)
68 |               if [[ "v$VERSION" == "$LATEST_TAG" ]]; then
69 |                 uv run mike alias --push --update-aliases $VERSION latest
70 |               fi
71 |             fi
72 |           elif [[ $GITHUB_REF == refs/tags/* ]]; then
73 |             # For tags, deploy the tagged version
74 |             VERSION=${GITHUB_REF#refs/tags/v}
75 |             uv run mike deploy --push $VERSION
76 | 
77 |             # If this is the latest version, update the 'latest' alias
78 |             LATEST_TAG=$(git tag --sort=-creatordate | head -n 1)
79 |           if [[ "v$VERSION" == "$LATEST_TAG" ]]; then
80 |             uv run mike alias --push --update-aliases $VERSION latest
81 |           fi
82 |           else
83 |             # For develop branch, deploy to 'dev'
84 |             uv run mike deploy --push --update-aliases dev
85 |             uv run mike set-default --push dev
86 |           fi
87 | 


--------------------------------------------------------------------------------
/titiler/cmr/templates/wmts.xml:
--------------------------------------------------------------------------------
 1 | <Capabilities xmlns="http://www.opengis.net/wmts/1.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:gml="http://www.opengis.net/gml" xsi:schemaLocation="http://www.opengis.net/wmts/1.0 http://schemas.opengis.net/wmts/1.0/wmtsGetCapabilities_response.xsd" version="1.0.0">
 2 |     <ows:ServiceIdentification>
 3 |         <ows:Title>"{{ title }}"</ows:Title>
 4 |         <ows:ServiceType>OGC WMTS</ows:ServiceType>
 5 |         <ows:ServiceTypeVersion>1.0.0</ows:ServiceTypeVersion>
 6 |     </ows:ServiceIdentification>
 7 |     <ows:OperationsMetadata>
 8 |         <ows:Operation name="GetCapabilities">
 9 |             <ows:DCP>
10 |                 <ows:HTTP>
11 |                     <ows:Get xlink:href="{{ request.url }}">
12 |                         <ows:Constraint name="GetEncoding">
13 |                             <ows:AllowedValues>
14 |                                 <ows:Value>RESTful</ows:Value>
15 |                             </ows:AllowedValues>
16 |                         </ows:Constraint>
17 |                     </ows:Get>
18 |                 </ows:HTTP>
19 |             </ows:DCP>
20 |         </ows:Operation>
21 |         <ows:Operation name="GetTile">
22 |             <ows:DCP>
23 |                 <ows:HTTP>
24 |                     <ows:Get xlink:href="{{ request.url }}">
25 |                         <ows:Constraint name="GetEncoding">
26 |                             <ows:AllowedValues>
27 |                                 <ows:Value>RESTful</ows:Value>
28 |                             </ows:AllowedValues>
29 |                         </ows:Constraint>
30 |                     </ows:Get>
31 |                 </ows:HTTP>
32 |             </ows:DCP>
33 |         </ows:Operation>
34 |     </ows:OperationsMetadata>
35 |     <Contents>
36 |         {% for layer in layers %}
37 |             <Layer>
38 |                 <ows:Title>{{ title }}</ows:Title>
39 |                 <ows:Identifier>{{ layer.name }}</ows:Identifier>
40 |                 <ows:Abstract>{{ layer.name }}</ows:Abstract>
41 |                 <ows:WGS84BoundingBox crs="urn:ogc:def:crs:OGC:2:84">
42 |                     <ows:LowerCorner>{{ bounds[0] }} {{ bounds[1] }}</ows:LowerCorner>
43 |                     <ows:UpperCorner>{{ bounds[2] }} {{ bounds[3] }}</ows:UpperCorner>
44 |                 </ows:WGS84BoundingBox>
45 |                 <Style isDefault="true">
46 |                     <ows:Identifier>default</ows:Identifier>
47 |                 </Style>
48 |                 <Format>{{ media_type }}</Format>
49 |                 <TileMatrixSetLink>
50 |                     <TileMatrixSet>{{ tms.id }}</TileMatrixSet>
51 |                 </TileMatrixSetLink>
52 |                 <ResourceURL format="{{ media_type }}" resourceType="tile" template="{{ layer.endpoint }}" />
53 |             </Layer>
54 |         {% endfor %}
55 |         <TileMatrixSet>
56 |             <ows:Identifier>{{ tms.id }}</ows:Identifier>
57 |             <ows:SupportedCRS>{{ tms.crs.srs }}</ows:SupportedCRS>
58 |             {% for item in tileMatrix %}
59 |             {{ item | safe }}
60 |             {% endfor %}
61 |         </TileMatrixSet>
62 |     </Contents>
63 |     <ServiceMetadataURL xlink:href="{{ request.url }}" />
64 | </Capabilities>
65 | 


--------------------------------------------------------------------------------
/tests/test_app.py:
--------------------------------------------------------------------------------
 1 | """test titiler-cmr app."""
 2 | 
 3 | 
 4 | def test_landing(app):
 5 |     """Test / endpoint."""
 6 |     response = app.get("/")
 7 |     assert response.status_code == 200
 8 |     assert response.headers["content-type"] == "application/json"
 9 |     body = response.json()
10 |     assert body["title"] == "titiler-cmr"
11 |     assert body["links"]
12 | 
13 |     response = app.get("/?f=html")
14 |     assert response.status_code == 200
15 |     assert "text/html" in response.headers["content-type"]
16 |     assert "titiler-cmr" in response.text
17 | 
18 |     # Check accept headers
19 |     response = app.get("/", headers={"accept": "text/html"})
20 |     assert response.status_code == 200
21 |     assert "text/html" in response.headers["content-type"]
22 |     assert "titiler-cmr" in response.text
23 | 
24 |     # accept quality
25 |     response = app.get(
26 |         "/", headers={"accept": "application/json;q=0.9, text/html;q=1.0"}
27 |     )
28 |     assert response.status_code == 200
29 |     assert "text/html" in response.headers["content-type"]
30 |     assert "titiler-cmr" in response.text
31 | 
32 |     # accept quality but only json is available
33 |     response = app.get("/", headers={"accept": "text/csv;q=1.0, application/json"})
34 |     assert response.status_code == 200
35 |     assert response.headers["content-type"] == "application/json"
36 |     body = response.json()
37 |     assert body["title"] == "titiler-cmr"
38 | 
39 |     # accept quality but only json is available
40 |     response = app.get("/", headers={"accept": "text/csv;q=1.0, */*"})
41 |     assert response.status_code == 200
42 |     assert response.headers["content-type"] == "application/json"
43 |     body = response.json()
44 |     assert body["title"] == "titiler-cmr"
45 | 
46 |     # Invalid accept, return default
47 |     response = app.get("/", headers={"accept": "text/htm"})
48 |     assert response.status_code == 200
49 |     assert response.headers["content-type"] == "application/json"
50 |     body = response.json()
51 |     assert body["title"] == "titiler-cmr"
52 |     assert body["links"]
53 | 
54 |     # make sure `?f=` has priority over headers
55 |     response = app.get("/?f=json", headers={"accept": "text/html"})
56 |     assert response.status_code == 200
57 |     assert response.headers["content-type"] == "application/json"
58 |     body = response.json()
59 |     assert body["title"] == "titiler-cmr"
60 | 
61 | 
62 | def test_docs(app):
63 |     """Test /api endpoint."""
64 |     response = app.get("/api")
65 |     assert response.status_code == 200
66 |     assert response.headers["content-type"] == "application/json"
67 |     body = response.json()
68 |     assert body["openapi"]
69 | 
70 |     response = app.get("/api.html")
71 |     assert response.status_code == 200
72 |     assert "text/html" in response.headers["content-type"]
73 | 
74 | 
75 | def test_conformance(app):
76 |     """Test /conformance endpoint."""
77 |     response = app.get("/conformance")
78 |     assert response.status_code == 200
79 |     assert response.headers["content-type"] == "application/json"
80 |     body = response.json()
81 |     assert body["conformsTo"]
82 | 
83 |     response = app.get("/conformance?f=html")
84 |     assert response.status_code == 200
85 |     assert "text/html" in response.headers["content-type"]
86 |     assert "Conformance" in response.text
87 | 


--------------------------------------------------------------------------------
/infrastructure/aws/lambda/Dockerfile:
--------------------------------------------------------------------------------
 1 | ARG PYTHON_VERSION=3.12
 2 | 
 3 | # Stage 1: OTEL
 4 | # Download the OpenTelemetry layer
 5 | # ref: https://github.com/athewsey/opentelemetry-lambda-container/blob/98069d5eb6d812ccd28d5c80e2f9d6c8a8c76fb9/python-example/lambda-function/Dockerfile
 6 | FROM public.ecr.aws/lambda/python:${PYTHON_VERSION} as otel-builder
 7 | RUN <<EOF
 8 | dnf install -y unzip wget
 9 | wget https://github.com/aws-observability/aws-otel-python-instrumentation/releases/download/v0.12.1/layer.zip -O /tmp/layer.zip
10 | mkdir -p /opt-builder
11 | unzip /tmp/layer.zip -d /opt-builder/
12 | EOF
13 | 
14 | # Stage 2: titiler-cmr application and dependencies
15 | FROM public.ecr.aws/lambda/python:${PYTHON_VERSION} AS builder
16 | COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
17 | 
18 | RUN dnf install -y gcc-c++ && dnf clean all
19 | 
20 | WORKDIR /build
21 | 
22 | COPY README.md uv.lock .python-version pyproject.toml ./
23 | COPY titiler/ ./titiler/
24 | 
25 | RUN <<EOF
26 | uv export --locked --no-editable --no-dev --extra lambda --format requirements.txt -o requirements.txt
27 | uv pip install \
28 |   --compile-bytecode \
29 |   --no-binary pydantic \
30 |   --target /deps \
31 |   --no-cache-dir \
32 |   --disable-pip-version-check \
33 |   -r requirements.txt
34 | EOF
35 | 
36 | # Aggressive cleanup to minimize size and optimize for Lambda container
37 | # Clean up app dependencies in /deps
38 | WORKDIR /deps
39 | SHELL ["/bin/bash", "-o", "pipefail", "-c"]
40 | RUN <<EOF
41 | # Convert .pyc files and remove source .py files for faster cold starts
42 | find . -type f -name '*.pyc' | while read -r f; do n="$(echo "$f" | sed 's/__pycache__\///' | sed 's/.cpython-[0-9]*//')"; cp "$f" "$n"; done
43 | find . -type d -a -name '__pycache__' -print0 | xargs -0 rm -rf
44 | find . -type f -a -name '*.py' -print0 | xargs -0 rm -f
45 | # Remove unnecessary files for Lambda runtime
46 | find . -type d -a -name 'tests' -print0 | xargs -0 rm -rf
47 | find . -type d -a -name 'test' -print0 | xargs -0 rm -rf
48 | rm -rf numpy/doc/ bin/ geos_license Misc/
49 | # Remove unnecessary locale and documentation files
50 | find . -name '*.mo' -delete
51 | find . -name '*.po' -delete
52 | find . -name 'LICENSE*' -delete
53 | find . -name 'README*' -delete
54 | find . -name '*.md' -delete
55 | # Strip debug symbols from shared libraries (preserve numpy.libs)
56 | find . -type f -name '*.so*' -not -path "*/numpy.libs/*" -exec strip --strip-unneeded {} \; 2>/dev/null || true
57 | EOF
58 | 
59 | # Stage 3: Final runtime stage - minimal Lambda image optimized for container runtime
60 | FROM public.ecr.aws/lambda/python:${PYTHON_VERSION}
61 | 
62 | ENV PYTHONUNBUFFERED=1 \
63 |   PYTHONDONTWRITEBYTECODE=1
64 | 
65 | COPY --from=otel-builder /opt-builder/ /opt/
66 | COPY infrastructure/aws/lambda/collector-config.yaml /opt/collector-config/config.yaml
67 | COPY --from=builder /deps ${LAMBDA_RUNTIME_DIR}/
68 | COPY --from=builder /usr/lib64/libexpat.so.1 ${LAMBDA_RUNTIME_DIR}/
69 | COPY infrastructure/aws/lambda/handler.py ${LAMBDA_RUNTIME_DIR}/
70 | 
71 | RUN <<EOF
72 | chmod 644 "${LAMBDA_RUNTIME_DIR}"/handler.py
73 | chmod -R 755 /opt/
74 | # Pre-compile the handler for faster cold starts
75 | python -c "import py_compile; py_compile.compile('${LAMBDA_RUNTIME_DIR}/handler.py', doraise=True)"
76 | # Create cache directories with proper permissions
77 | mkdir -p /tmp/.cache && chmod 777 /tmp/.cache
78 | EOF
79 | 
80 | CMD ["handler.lambda_handler"]
81 | 


--------------------------------------------------------------------------------
/data/mursst-cmr.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "id": "MUR-JPL-L4-GLOB",
 3 |     "stac_version": "1.0.0",
 4 |     "license": "not-provided",
 5 |     "title": "GHRSST Level 4 MUR Global Foundation Sea Surface Temperature Analysis (v4.1)",
 6 |     "type": "Collection",
 7 |     "description": "A Group for High Resolution Sea Surface Temperature (GHRSST) Level 4 sea surface temperature analysis produced as a retrospective dataset (four day latency) and near-real-time dataset (one day latency) at the JPL Physical Oceanography DAAC using wavelets as basis functions in an optimal interpolation approach on a global 0.01 degree grid. The version 4 Multiscale Ultrahigh Resolution (MUR) L4 analysis is based upon nighttime GHRSST L2P skin and subskin SST observations from several instruments including the NASA Advanced Microwave Scanning Radiometer-EOS (AMSR-E), the JAXA Advanced Microwave Scanning Radiometer 2 on GCOM-W1, the Moderate Resolution Imaging Spectroradiometers (MODIS) on the NASA Aqua and Terra platforms, the US Navy microwave WindSat radiometer, the Advanced Very High Resolution Radiometer (AVHRR) on several NOAA satellites, and in situ SST observations from the NOAA iQuam project. The ice concentration data are from the archives at the EUMETSAT Ocean and Sea Ice Satellite Application Facility (OSI SAF) High Latitude Processing Center and are also used for an improved SST parameterization for the high-latitudes.  The dataset also contains additional variables for some granules including a SST anomaly derived from a MUR climatology and the temporal distance to the nearest IR measurement for each pixel.This dataset is funded by the NASA MEaSUREs program ( http://earthdata.nasa.gov/our-community/community-data-system-programs/measures-projects ), and created by a team led by Dr. Toshio M. Chin from JPL. It adheres to the GHRSST Data Processing Specification (GDS) version 2 format specifications. Use the file global metadata \"history:\" attribute to determine if a granule is near-realtime or retrospective.",
 8 |     "collection_concept_id": "C1996881146-POCLOUD",
 9 |     "cube:dimensions": {},
10 |     "cube:variables": {
11 |       "analysed_sst": {
12 |           "dimensions": [
13 |             "time",
14 |             "lat",
15 |             "lon"
16 |           ],
17 |           "type": "data"
18 |         },
19 |         "analysis_error": {
20 |           "dimensions": [
21 |             "time",
22 |             "lat",
23 |             "lon"
24 |           ],
25 |           "type": "data"
26 |         }
27 |     },
28 |     "renders": {
29 |       "analysed_sst": {
30 |         "title": "Analysed Sea Surface Temperature",
31 |         "assets": [
32 |           "analysed_sst"
33 |         ],
34 |         "resampling": "average",
35 |         "colormap_name": "ocean"
36 |       }
37 |     },
38 |     "links": [
39 |       {
40 |         "rel": "self",
41 |         "href": "/collections/mursst-cmr.json",
42 |         "title": "Info about this collection",
43 |         "type": "application/json"
44 |       },
45 |       {
46 |         "rel": "root",
47 |         "href": "/",
48 |         "title": "Root catalog",
49 |         "type": "application/json"
50 |       }
51 |     ],
52 |     "extent": {
53 |       "spatial": {
54 |         "bbox": [
55 |           [
56 |             -180,
57 |             -90,
58 |             180,
59 |             90
60 |           ]
61 |         ]
62 |       },
63 |       "temporal": {
64 |         "interval": [
65 |           [
66 |             "2002-05-31T21:00:00.000Z",
67 |             null
68 |           ]
69 |         ]
70 |       }
71 |     }
72 |   }
73 | 


--------------------------------------------------------------------------------
/tests/test_rasterio_backend.py:
--------------------------------------------------------------------------------
  1 | """Test titiler-cmr rasterio backend."""
  2 | 
  3 | import warnings
  4 | from typing import Tuple
  5 | 
  6 | import pytest
  7 | from rasterio.errors import NotGeoreferencedWarning
  8 | 
  9 | 
 10 | @pytest.mark.vcr
 11 | def test_rasterio_tilejson(app, rasterio_query_params):
 12 |     """Test /tilejson.json endpoint for rasterio backend"""
 13 | 
 14 |     response = app.get(
 15 |         "/WebMercatorQuad/tilejson.json",
 16 |         params={
 17 |             **rasterio_query_params,
 18 |             "datetime": "2024-10-11T00:00:00Z/2024-10-12T23:59:59Z",
 19 |         },
 20 |     )
 21 |     assert response.status_code == 200
 22 |     assert response.headers["content-type"] == "application/json"
 23 | 
 24 |     tilejson = response.json()
 25 |     assert tilejson["bounds"] == [-180.0, -90.0, 180.0, 90.0]
 26 | 
 27 | 
 28 | @pytest.mark.vcr
 29 | def test_rasterio_statistics(app, mock_cmr_get_assets, mn_geojson):
 30 |     """Test /statistics endpoint for a polygon that straddles the boundary between two HLS granules"""
 31 | 
 32 |     concept_id = "C2021957657-LPCLOUD"
 33 |     band = "Fmask"
 34 |     datetime_range = "2024-10-09T00:00:01Z/2024-10-09T23:59:59Z"
 35 | 
 36 |     with warnings.catch_warnings(record=True):
 37 |         warnings.simplefilter("ignore", NotGeoreferencedWarning)
 38 | 
 39 |         response = app.post(
 40 |             "/statistics",
 41 |             params={
 42 |                 "concept_id": concept_id,
 43 |                 "datetime": datetime_range,
 44 |                 "backend": "rasterio",
 45 |                 "bands_regex": band,
 46 |                 "bands": band,
 47 |                 "dst_crs": "epsg:32615",
 48 |             },
 49 |             json=mn_geojson,
 50 |         )
 51 | 
 52 |     assert response.status_code == 200
 53 |     assert response.headers["content-type"] == "application/geo+json"
 54 |     resp = response.json()
 55 |     stats = resp["properties"]["statistics"]
 56 |     assert len(stats) == 1
 57 | 
 58 |     # numbers corroborated by QGIS zonal stats for these files and polygon
 59 |     assert stats[band]["majority"] == 64.0
 60 |     assert stats[band]["minority"] == 96.0
 61 |     assert stats[band]["sum"] == 19888616.0
 62 |     assert round(stats[band]["count"]) == 273132
 63 | 
 64 | 
 65 | @pytest.mark.vcr
 66 | def test_rasterio_feature(
 67 |     app, mock_cmr_get_assets, rasterio_query_params, mn_geojson
 68 | ) -> None:
 69 |     """Test /feature endpoint for rasterio backend"""
 70 |     with warnings.catch_warnings(record=True):
 71 |         warnings.simplefilter("ignore", NotGeoreferencedWarning)
 72 | 
 73 |         response = app.post(
 74 |             "/feature",
 75 |             params={
 76 |                 **rasterio_query_params,
 77 |                 "format": "tif",
 78 |                 "width": 100,
 79 |                 "height": 100,
 80 |             },
 81 |             json=mn_geojson,
 82 |         )
 83 |     assert response.status_code == 200
 84 |     assert response.headers["content-type"] == "image/tiff; application=geotiff"
 85 | 
 86 | 
 87 | @pytest.mark.vcr
 88 | def test_rasterio_part(
 89 |     app,
 90 |     mock_cmr_get_assets,
 91 |     rasterio_query_params,
 92 |     mn_bounds: Tuple[float, float, float, float],
 93 | ) -> None:
 94 |     """Test /part endpoint for rasterio backend"""
 95 | 
 96 |     with warnings.catch_warnings(record=True):
 97 |         warnings.simplefilter("ignore", NotGeoreferencedWarning)
 98 |         response = app.get(
 99 |             f"/bbox/{','.join(str(coord) for coord in mn_bounds)}/100x100.tif",
100 |             params={
101 |                 **rasterio_query_params,
102 |                 "format": "tif",
103 |             },
104 |         )
105 |     assert response.status_code == 200
106 |     assert response.headers["content-type"] == "image/tiff; application=geotiff"
107 | 


--------------------------------------------------------------------------------
/mkdocs.yml:
--------------------------------------------------------------------------------
  1 | site_name: TiTiler.CMR
  2 | site_description: Connect Common Metadata Repository (CMR) and TiTiler.
  3 | 
  4 | docs_dir: 'docs'
  5 | site_dir: 'build'
  6 | 
  7 | repo_name: developmentseed/titiler-cmr
  8 | repo_url: https://github.com/developmentseed/titiler-cmr
  9 | site_url: https://developmentseed.org/titiler-cmr/
 10 | site_author: Development Seed
 11 | site_description: An API for creating image tiles from CMR queries
 12 | 
 13 | extra:
 14 |   social:
 15 |     - icon: "fontawesome/brands/github"
 16 |       link: "https://github.com/developmentseed"
 17 |     - icon: "fontawesome/brands/bluesky"
 18 |       link: "https://bsky.app/profile/developmentseed.org"
 19 |     - icon: "fontawesome/brands/twitter"
 20 |       link: "https://twitter.com/developmentseed"
 21 |     - icon: "fontawesome/brands/linkedin"
 22 |       link: "https://www.linkedin.com/company/development-seed"
 23 |   version:
 24 |     provider: mike
 25 | 
 26 | nav:
 27 |   - Home: index.md
 28 |   - Examples:
 29 |     - examples/xarray_backend_example.ipynb
 30 |     - examples/rasterio_backend_example.ipynb
 31 |     - examples/time_series_example.ipynb
 32 |   - Dataset configuration:
 33 |     - datasets/hls_tiling.ipynb
 34 |   - Deployment:
 35 |     - deployment/time_series_api_limits.ipynb 
 36 |   - Development - Contributing: contributing.md
 37 |   - Release notes: release-notes.md
 38 |   - Compatibility: compatibility/index.ipynb
 39 | 
 40 | watch:
 41 |   - titiler/cmr
 42 |   - docs
 43 | 
 44 | plugins:
 45 |   - search
 46 |   - mkdocs-jupyter:
 47 |       include_source: True
 48 |       include_requirejs: True
 49 |       execute: True
 50 |       execute_ignore: ["*.py"]  # Don't execute these
 51 |       remove_tag_config:
 52 |         remove_input_tags:
 53 |           - hide_code
 54 | 
 55 | theme:
 56 |   name: material
 57 |   logo: assets/logo_no_text.png
 58 |   palette:
 59 |     # Palette toggle for automatic mode
 60 |     - media: "(prefers-color-scheme)"
 61 |       toggle:
 62 |         icon: material/brightness-auto
 63 |         name: Switch to light mode
 64 | 
 65 |     # Palette toggle for light mode
 66 |     - media: "(prefers-color-scheme: light)"
 67 |       primary: default
 68 |       accent: deep orange
 69 |       toggle:
 70 |         icon: material/brightness-7
 71 |         name: Switch to dark mode
 72 | 
 73 |     # Palette toggle for dark mode
 74 |     - media: "(prefers-color-scheme: dark)"
 75 |       scheme: slate
 76 |       primary: default
 77 |       accent: deep orange
 78 |       toggle:
 79 |         icon: material/brightness-4
 80 |         name: Switch to system preference
 81 | 
 82 |   font:
 83 |     text: Roboto
 84 |     code: Roboto Mono
 85 | 
 86 |   features:
 87 |     - content.code.annotate
 88 |     - content.code.copy
 89 |     - navigation.indexes
 90 |     - navigation.instant
 91 |     - navigation.tracking
 92 |     - search.suggest
 93 |     - search.share
 94 | 
 95 | 
 96 | extra_css:
 97 |   - overrides/stylesheets/extra.css
 98 | 
 99 | # https://github.com/developmentseed/titiler/blob/50934c929cca2fa8d3c408d239015f8da429c6a8/docs/mkdocs.yml#L115-L140
100 | markdown_extensions:
101 |   - admonition
102 |   - attr_list
103 |   - codehilite:
104 |       guess_lang: false
105 |   - def_list
106 |   - footnotes
107 |   - github-callouts
108 |   - md_in_html
109 |   - pymdownx.arithmatex
110 |   - pymdownx.betterem
111 |   - pymdownx.caret:
112 |       insert: false
113 |   - pymdownx.details
114 |   - pymdownx.emoji:
115 |       emoji_index: !!python/name:material.extensions.emoji.twemoji
116 |       emoji_generator: !!python/name:material.extensions.emoji.to_svg
117 |   - pymdownx.escapeall:
118 |       hardbreak: true
119 |       nbsp: true
120 |   - pymdownx.magiclink:
121 |       hide_protocol: true
122 |       repo_url_shortener: true
123 |   - pymdownx.smartsymbols
124 |   - pymdownx.superfences
125 |   - pymdownx.tasklist:
126 |       custom_checkbox: true
127 |   - pymdownx.tilde
128 |   - toc:
129 |       permalink: true
130 | 


--------------------------------------------------------------------------------
/titiler/cmr/templates/tileset.html:
--------------------------------------------------------------------------------
  1 | {% include "header.html" %}
  2 | 
  3 | <nav aria-label="breadcrumb">
  4 |   <ol class="breadcrumb bg-light">
  5 |     {% for crumb in crumbs %}
  6 |       {% if not loop.last %}
  7 |     <li class="breadcrumb-item"><a href="{{ crumb.url }}/">{{ crumb.part }}</a></li>
  8 |       {% else %}<li class="breadcrumb-item active" aria-current="page">{{ crumb.part }}</li>
  9 |       {% endif %}
 10 |     {% endfor %}
 11 | 
 12 |     <li class="ml-auto json-link"><a target="_blank" href="{{ url }}?f=json">JSON</a></li>
 13 |   </ol>
 14 | </nav>
 15 | 
 16 | <h1>{{ response.title}}</h1>
 17 | 
 18 | <div class="row" style="margin-top: 30px;">
 19 |   <div class="col-sm">
 20 | 
 21 |     <h2>Properties</h2>
 22 |     <li><strong>DataType:</strong> {{ response.dataType }}</li>
 23 |     <li><strong>CRS:</strong> {{ response.crs }}</li>
 24 | 
 25 |     <h2 style="margin-top: 10px;">TileMatrixSet Limits</h2>
 26 | 
 27 |     <table>
 28 |       <tr>
 29 |         <th style="padding: 5px;">Level</th>
 30 |         <th style="padding: 5px;">minTileRow</th>
 31 |         <th style="padding: 5px;">maxTileRow</th>
 32 |         <th style="padding: 5px;">minTileCol</th>
 33 |         <th style="padding: 5px;">maxTileCol</th>
 34 |      </tr>
 35 |       {% for tms in response.tileMatrixSetLimits %}
 36 |       <tr>
 37 |          <td style="text-align: right;">{{ tms.tileMatrix }}</td>
 38 |          <td style="text-align: right;">{{ tms.minTileRow }}</td>
 39 |          <td style="text-align: right;">{{ tms.maxTileRow }}</td>
 40 |          <td style="text-align: right;">{{ tms.minTileCol }}</td>
 41 |          <td style="text-align: right;">{{ tms.maxTileCol }}</td>
 42 |       </tr>
 43 |       {% endfor %}
 44 |     </table>
 45 | 
 46 |     <h2 style="margin-top: 10px;">Links</h2>
 47 |     <ul>
 48 |     {% for link in response.links %}
 49 |       {% if link.rel != 'self' %}
 50 |         <li> <a href="{{ link.href }}">{{ link.title }}</a></li>
 51 |       {% endif %}
 52 |     {% endfor %}
 53 |     </ul>
 54 | 
 55 |   </div>
 56 |   <div class="col-sm">
 57 |     <div id="map" class="rounded" style="width: 100%; height: 400px">
 58 |       Loading...
 59 |     </div>
 60 |   </div>
 61 | </div>
 62 | 
 63 | <script>
 64 |   $(function() {
 65 |     var map = L.map('map').setView([0, 0], 1);
 66 |     map.addLayer(new L.TileLayer(
 67 |       'https://tile.openstreetmap.org/{z}/{x}/{y}.png', {
 68 |         maxZoom: 18,
 69 |         attribution: 'Map data &copy; <a href="https://openstreetmap.org/copyright">OpenStreetMap contributors</a>'
 70 |       }
 71 |     ));
 72 | 
 73 |     var bbox;
 74 |     {% if response.boundingBox %}
 75 |     bbox = [
 76 |         {{ response.boundingBox.lowerLeft[0] }},
 77 |         {{ response.boundingBox.lowerLeft[1] }},
 78 |         {{ response.boundingBox.upperRight[0] }},
 79 |         {{ response.boundingBox.upperRight[1] }},
 80 |       ]
 81 |     {% else %}
 82 |       bbox = [-180,-90,180,90]
 83 |     {% endif %};
 84 | 
 85 |     const bboxPolygon = (bounds) => {
 86 |       return {
 87 |         'type': 'Feature',
 88 |         'geometry': {
 89 |             'type': 'Polygon',
 90 |             'coordinates': [[
 91 |                 [bounds[0], bounds[1]],
 92 |                 [bounds[2], bounds[1]],
 93 |                 [bounds[2], bounds[3]],
 94 |                 [bounds[0], bounds[3]],
 95 |                 [bounds[0], bounds[1]]
 96 |             ]]
 97 |         },
 98 |         'properties': {}
 99 |       }
100 |     }
101 | 
102 |     if (bbox[0] > bbox[2]) {
103 |       geo = {
104 |         "type": "FeatureCollection",
105 |         "features": [
106 |           bboxPolygon([-180, bbox[1], bbox[2], bbox[3]]),
107 |           bboxPolygon([bbox[0], bbox[1], 180, bbox[3]]),
108 |         ]
109 |       }
110 |     } else {
111 |       geo = {
112 |         "type": "FeatureCollection",
113 |         "features": [bboxPolygon(bbox)]
114 |       }
115 |     }
116 | 
117 |     var aoi = L.geoJSON(geo).addTo(map);
118 |     map.fitBounds(aoi.getBounds());
119 |   });
120 | </script>
121 | {% include "footer.html" %}
122 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | # Changelog
  2 | 
  3 | All notable changes to this project will be documented in this file.
  4 | 
  5 | The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
  6 | 
  7 | ## [Unreleased]
  8 | 
  9 | ### Fixed
 10 | 
 11 | - Fixed the missing parameter error message "`indexes` must be provided if not providing `bands_regex` and `bands`". The [alias](https://fastapi.tiangolo.com/tutorial/query-params-str-validations/#alias-parameters) for the `indexes` parameter is `bidx`, so the `bidx` parameter is what is missing from the parameter string. ([#101](https://github.com/developmentseed/titiler-cmr/pull/101))
 12 | 
 13 | ## [v0.3.0]
 14 | 
 15 | ### Added
 16 | 
 17 | - interpolate {datetime} in if sel includes {dim}={datetime} ([#78](https://github.com/developmentseed/titiler-cmr/pull/78))
 18 | - /compatibility and /concept_metadata endpoints ([#80](https://github.com/developmentseed/titiler-cmr/pull/80))
 19 | - add dataset statistics to /compatibility endpoint output for xarray datasets ([#80](https://github.com/developmentseed/titiler-cmr/pull/82))
 20 | 
 21 | - export traces to X-Ray from AWS Lambda ([#81](https://github.com/developmentseed/titiler-cmr/pull/81))
 22 | 
 23 | ### Fixed
 24 | 
 25 | - Fix bands + indexes + bands_regex logic ([#89](https://github.com/developmentseed/titiler-cmr/pull/89))
 26 | - DRY out the AWS credential logic in backend.py ([#93](https://github.com/developmentseed/titiler-cmr/pull/93))
 27 | 
 28 | ### Changed
 29 | 
 30 | - Switch from a zip package to a containerized Lambda function ([#81](https://github.com/developmentseed/titiler-cmr/pull/81))
 31 | 
 32 | ## [v0.2.0]
 33 | 
 34 | ### Fixed
 35 | 
 36 | - Upgrade to Python 3.12 runtime to avoid dependency build errors
 37 | 
 38 | ### Added
 39 | 
 40 | - Add OTEL traces
 41 | - Upgrade to titiler v0.23. and add more logging statements to help track performance ([#71](https://github.com/developmentseed/titiler-cmr/pull/71))
 42 | 
 43 | ## [v0.1.5]
 44 | 
 45 | ### Fixed
 46 | 
 47 | - Allow POST requests from cross-origin clients ([#60](https://github.com/developmentseed/titiler-cmr/pull/60))
 48 | 
 49 | - Handle case where `ResolutionAndCoordinateSystem` is not available for calculating time series request size ([#62](https://github.com/developmentseed/titiler-cmr/pull/62))
 50 | 
 51 | - Pin geojson-pydantic to >=2.0.0,<3.0 (previously was >=1.1.1) and fixed iteration of `FeatureCollection` ([#68](https://github.com/developmentseed/titiler-cmr/pull/68))
 52 | 
 53 | ### Changed
 54 | 
 55 | - Add `s3_auth_strategy` and `aws_request_payer` to `AppSettings`: <https://github.com/developmentseed/titiler-cmr/pull/58>
 56 | 
 57 | ## [v0.1.4]
 58 | 
 59 | ### Added
 60 | 
 61 | - Added support for `sel` and `sel_method` parameters: <https://github.com/developmentseed/titiler-cmr/pull/52>
 62 | - Add HLS tile configuration documentation: <https://github.com/developmentseed/titiler-cmr/pull/45>
 63 | 
 64 | ### Fixed
 65 | 
 66 | ### Changed
 67 | 
 68 | - Added github workflow for deploying to a dev stack: <https://github.com/developmentseed/titiler-cmr/pull/51>
 69 | - Modifications to github workflow to support deployment via [github.com/NASA-IMPACT/veda-deploy](https://github.com/NASA-IMPACT/veda-deploy): <https://github.com/developmentseed/titiler-cmr/pull/47>, <https://github.com/developmentseed/titiler-cmr/pull/48>
 70 | - Modifications to deployment environment variables `STAGE` and `AWS_REQUEST_PAYER` via `additional_env` in `StackSettings`: <https://github.com/developmentseed/titiler-cmr/pull/55>
 71 | 
 72 | ## [v0.1.3]
 73 | 
 74 | ### Added
 75 | 
 76 | - Time series API limits
 77 | 
 78 | ## [0.1.2]
 79 | 
 80 | ### Added
 81 | 
 82 | - Support for `/timeseries` endpoints ([#33](https://github.com/developmentseed/titiler-cmr/pull/33))
 83 | 
 84 | ## [0.1.1]
 85 | 
 86 | ### Added
 87 | 
 88 | - Add `/bbox`, `/feature`, and `/statistics` endpoints ([#30](https://github.com/developmentseed/titiler-cmr/pull/30))
 89 | 
 90 | ## [0.1.1]
 91 | 
 92 | ### Added
 93 | 
 94 | - Ability to run locally with Earthdata authentication ([#28](https://github.com/developmentseed/titiler-cmr/pull/28))
 95 | 
 96 | [Unreleased]: <https://github.com/developmentseed/titiler-cmr/compare/v0.2.0..develop>
 97 | [v0.2.0]: <https://github.com/developmentseed/titiler-cmr/compare/v0.1.5..v0.2.0>
 98 | [v0.1.5]: <https://github.com/developmentseed/titiler-cmr/compare/v0.1.4..v0.1.5>
 99 | [v0.1.4]: <https://github.com/developmentseed/titiler-cmr/compare/v0.1.3..v0.1.4>
100 | [v0.1.3]: <https://github.com/developmentseed/titiler-cmr/compare/v0.1.2..0.1.3>
101 | [0.1.2]: <https://github.com/developmentseed/titiler-cmr/compare/0.1.1..0.1.2>
102 | [0.1.1]: <https://github.com/developmentseed/titiler-cmr/compare/0.1.0..0.1.1>
103 | 


--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
  1 | [project]
  2 | name = "titiler.cmr"
  3 | description = "Connect Common Metadata Repository (CMR) and TiTiler."
  4 | readme = "README.md"
  5 | requires-python = ">=3.12"
  6 | license = {file = "LICENSE"}
  7 | authors = [
  8 |     {name = "Aimee Barciauskas", email = "aimee@developmentseed.com"},
  9 |     {name = "Vincent Sarago", email = "vincent@developmentseed.com"},
 10 | ]
 11 | keywords = [
 12 |     "TiTiler",
 13 |     "NASA CMR",
 14 | ]
 15 | classifiers = [
 16 |     "Intended Audience :: Information Technology",
 17 |     "Intended Audience :: Science/Research",
 18 |     "License :: OSI Approved :: MIT License",
 19 |     "Programming Language :: Python :: 3.12",
 20 |     "Programming Language :: Python :: 3.13",
 21 |     "Topic :: Scientific/Engineering :: GIS",
 22 | ]
 23 | dependencies = [
 24 |     "titiler.core>=0.23.1,<0.24",
 25 |     "titiler.mosaic>=0.23.1,<0.24",
 26 |     "titiler.xarray>=0.23.1,<0.24",
 27 |     "aiobotocore>=2.24.0",
 28 |     "boto3>=1.39.0",
 29 |     "cftime~=1.6.4",
 30 |     "earthaccess~=0.11.0",
 31 |     "geojson-pydantic>=2.0.0,<3.0",
 32 |     "h5netcdf~=1.1.0",
 33 |     "httpx>=0.27.2",
 34 |     "isodate>=0.7.2",
 35 |     "orjson~=3.10.7",
 36 |     "pillow>=11.0.0",
 37 |     "psutil>=6.0.0",
 38 |     "pydantic-settings~=2.0",
 39 |     "pydantic>=2.4,<3.0",
 40 |     "python-dateutil>=2.9.0.post0",
 41 |     "rio_tiler[s3]>=7.2.0,<8.0",
 42 |     "rioxarray~=0.13.4",
 43 |     "s3fs~=2025.9.0",
 44 |     "xarray~=2024.9.0",
 45 | ]
 46 | dynamic = ["version"]
 47 | 
 48 | [project.optional-dependencies]
 49 | uvicorn = [
 50 |     "uvicorn",
 51 | ]
 52 | 
 53 | lambda = [
 54 |     "mangum==0.19.0",
 55 |     "aiobotocore>=2.24.0,<2.24.2"
 56 | ]
 57 | 
 58 | [dependency-groups]
 59 | dev = [
 60 |     "folium>=0.17.0",
 61 |     "freezegun>=1.5.1",
 62 |     "jupyterlab>=4.2.5",
 63 |     "jupyterlab-code-formatter>=3.0.2",
 64 |     "matplotlib>=3.9.2",
 65 |     "mkdocs-jupyter>=0.25.1",
 66 |     "mkdocs>=1.6.1",
 67 |     "pre-commit>=4.0.1",
 68 |     "pytest>=8.3.3",
 69 |     "pytest-asyncio>=0.24.0",
 70 |     "pytest-cov>=5.0.0",
 71 |     "pytest-mock>=3.14.0",
 72 |     "pytest-recording>=0.13.2",
 73 |     "ruff>=0.8.0",
 74 |     "mkdocs-material>=9.5.47",
 75 |     "mike>=2.1.3",
 76 |     "ipython==8.28.0",
 77 |     "markdown-callouts>=0.4.0",
 78 |     "plotly>=5.24.1",
 79 |     "ipywidgets>=8.1.5",
 80 |     "pytest-benchmark>=5.1.0",
 81 |     "seaborn>=0.13.2",
 82 |     "uvicorn>=0.32.1",
 83 |     "pyarrow>=22.0.0",
 84 | ]
 85 | deployment = [
 86 |     "aws-cdk-lib~=2.177.0",
 87 |     "boto3>=1.34.145",
 88 |     "constructs>=10.4.2",
 89 |     "pydantic-settings~=2.0",
 90 |     "python-dotenv>=1.0.1",
 91 | ]
 92 | 
 93 | [project.urls]
 94 | Homepage = 'https://developmentseed.org/titiler-cmr/'
 95 | Documentation = "https://developmentseed.org/titiler-cmr/"
 96 | Issues = "https://github.com/developmentseed/titiler-cmr/issues"
 97 | Source = "https://github.com/developmentseed/titiler-cmr"
 98 | Changelog = "https://developmentseed.org/titiler-cmr/release-notes/"
 99 | 
100 | [build-system]
101 | requires = ["pdm-pep517"]
102 | build-backend = "pdm.pep517.api"
103 | 
104 | [tool.pdm.version]
105 | source = "scm"
106 | 
107 | [tool.pdm.build]
108 | includes = ["titiler/cmr"]
109 | excludes = ["tests/", "**/.mypy_cache", "**/.DS_Store"]
110 | 
111 | [tool.coverage.run]
112 | branch = true
113 | parallel = true
114 | 
115 | [tool.coverage.report]
116 | exclude_lines = [
117 |   "no cov",
118 |   "if __name__ == .__main__.:",
119 |   "if TYPE_CHECKING:",
120 | ]
121 | 
122 | [tool.isort]
123 | profile = "black"
124 | known_first_party = ["titiler"]
125 | known_third_party = [
126 |     "rasterio",
127 |     "morecantile",
128 |     "rio_tiler",
129 |     "cogeo_mosaic",
130 |     "geojson_pydantic",
131 | ]
132 | default_section = "THIRDPARTY"
133 | 
134 | [tool.ruff]
135 | select = [
136 |     "D1",  # pydocstyle errors
137 |     "E",  # pycodestyle errors
138 |     "W",  # pycodestyle warnings
139 |     "F",  # flake8
140 |     "C",  # flake8-comprehensions
141 |     "B",  # flake8-bugbear
142 | ]
143 | ignore = [
144 |     "E501",  # line too long, handled by black
145 |     "B008",  # do not perform function calls in argument defaults
146 |     "B905",  # ignore zip() without an explicit strict= parameter, only support with python >3.10
147 | ]
148 | 
149 | [tool.mypy]
150 | no_implicit_optional = true
151 | strict_optional = true
152 | namespace_packages = true
153 | explicit_package_bases = true
154 | 
155 | [tool.pytest.ini_options]
156 | # Address PytestDeprecationWarning: The configuration option "asyncio_default_fixture_loop_scope" is unset.
157 | asyncio_default_fixture_loop_scope = "function"
158 | filterwarnings = [
159 |     "ignore::rasterio.errors.NotGeoreferencedWarning",
160 | ]
161 | markers = "vcr: records network activity"
162 | addopts = "-Werror --cov=titiler.cmr --cov-report=term-missing --cov-report=xml -vv --benchmark-skip"
163 | 


--------------------------------------------------------------------------------
/tests/test_factory.py:
--------------------------------------------------------------------------------
  1 | """Test factory functions"""
  2 | 
  3 | import pytest
  4 | from titiler.cmr.dependencies import (
  5 |     RasterioParams,
  6 |     InterpolatedXarrayParams,
  7 |     ReaderParams,
  8 | )
  9 | from titiler.cmr.factory import parse_reader_options
 10 | from titiler.cmr.reader import MultiFilesBandsReader
 11 | from rio_tiler.io import rasterio
 12 | 
 13 | 
 14 | class TestParseReaderOptions:
 15 |     """Test parse_reader_options function assertions about bands and indexes"""
 16 | 
 17 |     def test_bands_regex_without_bands_fails(self):
 18 |         """Test that providing bands_regex without bands raises an assertion error"""
 19 |         rasterio_params = RasterioParams(
 20 |             bands_regex="B0[1-3]", bands=None, indexes=None
 21 |         )
 22 |         xarray_io_params = InterpolatedXarrayParams()
 23 |         xarray_ds_params = InterpolatedXarrayParams()
 24 |         reader_params = ReaderParams(backend="rasterio")
 25 | 
 26 |         with pytest.raises(
 27 |             AssertionError,
 28 |             match="`bands=` option must be provided when using multi-band data",
 29 |         ):
 30 |             parse_reader_options(
 31 |                 rasterio_params=rasterio_params,
 32 |                 xarray_io_params=xarray_io_params,
 33 |                 xarray_ds_params=xarray_ds_params,
 34 |                 reader_params=reader_params,
 35 |             )
 36 | 
 37 |     def test_no_bands_regex_no_bands_no_indexes_fails(self):
 38 |         """Test that providing neither bands_regex, bands, nor indexes raises an assertion error"""
 39 |         rasterio_params = RasterioParams(
 40 |             bands_regex=None,
 41 |             bands=None,
 42 |             indexes=None,  # This should cause the assertion to fail
 43 |         )
 44 |         xarray_io_params = InterpolatedXarrayParams()
 45 |         xarray_ds_params = InterpolatedXarrayParams()
 46 |         reader_params = ReaderParams(backend="rasterio")
 47 | 
 48 |         with pytest.raises(
 49 |             AssertionError,
 50 |             match="`bidx` must be provided if not providing `bands_regex` and `bands`",
 51 |         ):
 52 |             parse_reader_options(
 53 |                 rasterio_params=rasterio_params,
 54 |                 xarray_io_params=xarray_io_params,
 55 |                 xarray_ds_params=xarray_ds_params,
 56 |                 reader_params=reader_params,
 57 |             )
 58 | 
 59 |     def test_bands_regex_with_bands_succeeds(self):
 60 |         """Test that providing bands_regex with bands succeeds and returns MultiFilesBandsReader"""
 61 |         rasterio_params = RasterioParams(
 62 |             bands_regex="B0[1-3]", bands=["B01", "B02", "B03"], indexes=None
 63 |         )
 64 |         xarray_io_params = InterpolatedXarrayParams()
 65 |         xarray_ds_params = InterpolatedXarrayParams()
 66 |         reader_params = ReaderParams(backend="rasterio")
 67 | 
 68 |         reader, read_options, reader_options = parse_reader_options(
 69 |             rasterio_params=rasterio_params,
 70 |             xarray_io_params=xarray_io_params,
 71 |             xarray_ds_params=xarray_ds_params,
 72 |             reader_params=reader_params,
 73 |         )
 74 | 
 75 |         assert reader == MultiFilesBandsReader
 76 |         assert read_options["bands"] == ["B01", "B02", "B03"]
 77 |         assert read_options["bands_regex"] == "B0[1-3]"
 78 |         assert reader_options == {}
 79 | 
 80 |     def test_indexes_without_bands_regex_succeeds(self):
 81 |         """Test that providing indexes without bands_regex succeeds and returns rasterio.Reader"""
 82 |         rasterio_params = RasterioParams(
 83 |             bands_regex=None, bands=None, indexes=[1, 2, 3]
 84 |         )
 85 |         xarray_io_params = InterpolatedXarrayParams()
 86 |         xarray_ds_params = InterpolatedXarrayParams()
 87 |         reader_params = ReaderParams(backend="rasterio")
 88 | 
 89 |         reader, read_options, reader_options = parse_reader_options(
 90 |             rasterio_params=rasterio_params,
 91 |             xarray_io_params=xarray_io_params,
 92 |             xarray_ds_params=xarray_ds_params,
 93 |             reader_params=reader_params,
 94 |         )
 95 | 
 96 |         assert reader == rasterio.Reader
 97 |         assert read_options["indexes"] == [1, 2, 3]
 98 |         assert reader_options == {}
 99 | 
100 |     def test_xarray_backend_ignores_rasterio_params(self):
101 |         """Test that xarray backend ignores rasterio_params and doesn't trigger assertions"""
102 |         rasterio_params = RasterioParams(bands_regex=None, bands=None, indexes=None)
103 |         xarray_io_params = InterpolatedXarrayParams()
104 |         xarray_ds_params = InterpolatedXarrayParams()
105 |         reader_params = ReaderParams(backend="xarray")
106 | 
107 |         reader, read_options, reader_options = parse_reader_options(
108 |             rasterio_params=rasterio_params,
109 |             xarray_io_params=xarray_io_params,
110 |             xarray_ds_params=xarray_ds_params,
111 |             reader_params=reader_params,
112 |         )
113 | 
114 |         from titiler.xarray.io import Reader as XarrayReader
115 | 
116 |         assert reader == XarrayReader
117 | 


--------------------------------------------------------------------------------
/titiler/cmr/reader.py:
--------------------------------------------------------------------------------
  1 | """ZarrReader.
  2 | 
  3 | Originaly from titiler-xarray
  4 | """
  5 | 
  6 | import os
  7 | import pickle
  8 | from typing import Any, Dict, Optional, Type
  9 | from urllib.parse import urlparse
 10 | 
 11 | import attr
 12 | import earthaccess
 13 | import fsspec
 14 | import s3fs
 15 | import xarray
 16 | from cachetools import TTLCache
 17 | from morecantile import TileMatrixSet
 18 | from rio_tiler.constants import WEB_MERCATOR_TMS, WGS84_CRS
 19 | from rio_tiler.errors import InvalidBandName
 20 | from rio_tiler.io import BaseReader, MultiBandReader, Reader
 21 | 
 22 | from titiler.cmr.settings import CacheSettings
 23 | 
 24 | # Use simple in-memory cache for now (we can switch to redis later)
 25 | cache_config = CacheSettings()
 26 | cache_client: Any = TTLCache(maxsize=cache_config.maxsize, ttl=cache_config.ttl)
 27 | 
 28 | 
 29 | def get_filesystem(
 30 |     src_path: str,
 31 |     protocol: str,
 32 |     xr_engine: str,
 33 |     anon: bool = True,
 34 |     s3_credentials: Optional[Dict] = None,
 35 | ):
 36 |     """
 37 |     Get the filesystem for the given source path.
 38 |     """
 39 |     if protocol == "s3":
 40 |         s3_credentials = s3_credentials or {}
 41 |         if os.environ.get("AWS_REQUEST_PAYER") == "requester":
 42 |             s3_credentials["requester_pays"] = True
 43 |         s3_filesystem = s3fs.S3FileSystem(**s3_credentials)
 44 |         return (
 45 |             s3_filesystem.open(src_path)
 46 |             if xr_engine == "h5netcdf"
 47 |             else s3fs.S3Map(root=src_path, s3=s3_filesystem)
 48 |         )
 49 | 
 50 |     elif protocol == "reference":
 51 |         reference_args = {"fo": src_path, "remote_options": {"anon": anon}}
 52 |         return fsspec.filesystem("reference", **reference_args).get_mapper("")
 53 | 
 54 |     elif protocol in ["https", "http", "file"]:
 55 |         if protocol in ["https", "http"]:
 56 |             filesystem = earthaccess.get_fsspec_https_session()
 57 |         else:
 58 |             filesystem = fsspec.filesystem(protocol)  # type: ignore
 59 |         return (
 60 |             filesystem.open(src_path)
 61 |             if xr_engine == "h5netcdf"
 62 |             else filesystem.get_mapper(src_path)
 63 |         )
 64 | 
 65 |     else:
 66 |         raise ValueError(f"Unsupported protocol: {protocol}")
 67 | 
 68 | 
 69 | def xarray_open_dataset(
 70 |     src_path: str,
 71 |     group: Optional[Any] = None,
 72 |     decode_times: Optional[bool] = True,
 73 |     s3_credentials: Optional[Dict] = None,
 74 | ) -> xarray.Dataset:
 75 |     # TODO: can we import the internals of titiler.xarray.io.xarray_open_dataset?
 76 |     """Modified version of titiler.xarray.io.xarray_open_dataset with
 77 |     custom handler for earthaccess authentication over https
 78 |     """
 79 |     # Generate cache key and attempt to fetch the dataset from cache
 80 |     cache_key = f"{src_path}_{group}" if group is not None else src_path
 81 |     data_bytes = cache_client.get(cache_key, None)
 82 |     if data_bytes:
 83 |         return pickle.loads(data_bytes)
 84 | 
 85 |     parsed = urlparse(src_path)
 86 |     protocol = parsed.scheme or "file"
 87 | 
 88 |     if any(src_path.lower().endswith(ext) for ext in [".nc", ".nc4"]):
 89 |         xr_engine = "h5netcdf"
 90 |     else:
 91 |         xr_engine = "zarr"
 92 | 
 93 |     file_handler = get_filesystem(
 94 |         src_path, protocol, xr_engine, s3_credentials=s3_credentials
 95 |     )
 96 | 
 97 |     # Arguments for xarray.open_dataset
 98 |     # Default args
 99 |     xr_open_args: Dict[str, Any] = {
100 |         "decode_coords": "all",
101 |         "decode_times": decode_times,
102 |     }
103 | 
104 |     # Argument if we're opening a datatree
105 |     if group is not None:
106 |         xr_open_args["group"] = group
107 | 
108 |     # NetCDF arguments
109 |     if xr_engine == "h5netcdf":
110 |         xr_open_args.update(
111 |             {
112 |                 "engine": "h5netcdf",
113 |                 "lock": False,
114 |             }
115 |         )
116 | 
117 |         ds = xarray.open_dataset(file_handler, **xr_open_args)
118 | 
119 |     # Fallback to Zarr
120 |     else:
121 |         ds = xarray.open_zarr(file_handler, **xr_open_args)
122 | 
123 |     # Serialize the dataset to bytes using pickle
124 |     cache_client[cache_key] = pickle.dumps(ds)
125 | 
126 |     return ds
127 | 
128 | 
129 | @attr.s
130 | class MultiFilesBandsReader(MultiBandReader):
131 |     """Multiple Files as Bands."""
132 | 
133 |     input: Dict[str, str] = attr.ib()
134 |     tms: TileMatrixSet = attr.ib(default=WEB_MERCATOR_TMS)
135 | 
136 |     reader_options: Dict = attr.ib(factory=dict)
137 |     reader: Type[BaseReader] = attr.ib(default=Reader)
138 | 
139 |     minzoom: int = attr.ib()
140 |     maxzoom: int = attr.ib()
141 | 
142 |     @minzoom.default
143 |     def _minzoom(self):
144 |         return self.tms.minzoom
145 | 
146 |     @maxzoom.default
147 |     def _maxzoom(self):
148 |         return self.tms.maxzoom
149 | 
150 |     def __attrs_post_init__(self):
151 |         """Fetch Reference band to get the bounds."""
152 |         self.bands = list(self.input)
153 |         self.bounds = (-180.0, -90, 180.0, 90)
154 |         self.crs = WGS84_CRS
155 |         # with self.reader(
156 |         #     self.input[0],
157 |         #     tms=self.tms,
158 |         #     **self.reader_options,
159 |         # ) as cog:
160 |         #     self.bounds = cog.bounds
161 |         #     self.crs = cog.crs
162 |         #     self.minzoom = cog.minzoom
163 |         #     self.maxzoom = cog.maxzoom
164 | 
165 |     def _get_band_url(self, band: str) -> str:
166 |         """Validate band's name and return band's url."""
167 |         if band not in self.bands:
168 |             raise InvalidBandName(f"{band} is not valid")
169 | 
170 |         return self.input[band]
171 | 


--------------------------------------------------------------------------------
/titiler/cmr/utils.py:
--------------------------------------------------------------------------------
  1 | """titiler.cmr utilities.
  2 | 
  3 | Code from titiler.pgstac, MIT License.
  4 | 
  5 | """
  6 | 
  7 | import logging
  8 | import time
  9 | from datetime import datetime
 10 | from typing import Any, Dict, List, Optional, Sequence, Tuple, Type, Union
 11 | 
 12 | import earthaccess
 13 | from geojson_pydantic import Feature, FeatureCollection
 14 | from isodate import parse_datetime as _parse_datetime
 15 | from rasterio.crs import CRS
 16 | from rasterio.features import bounds
 17 | from rasterio.warp import transform_bounds
 18 | from rio_tiler.constants import WGS84_CRS
 19 | from urllib3.response import HTTPException
 20 | 
 21 | from titiler.cmr.errors import InvalidDatetime
 22 | 
 23 | logger = logging.getLogger(__name__)
 24 | 
 25 | 
 26 | def retry(
 27 |     tries: int,
 28 |     exceptions: Union[Type[Exception], Sequence[Type[Exception]]] = Exception,
 29 |     delay: float = 0.0,
 30 | ):
 31 |     """Retry Decorator"""
 32 | 
 33 |     def _decorator(func: Any):
 34 |         def _newfn(*args: Any, **kwargs: Any):
 35 |             attempt = 0
 36 |             while attempt < tries:
 37 |                 try:
 38 |                     return func(*args, **kwargs)
 39 | 
 40 |                 except exceptions:  # type: ignore
 41 |                     attempt += 1
 42 |                     time.sleep(delay)
 43 | 
 44 |             return func(*args, **kwargs)
 45 | 
 46 |         return _newfn
 47 | 
 48 |     return _decorator
 49 | 
 50 | 
 51 | def _parse_date(date: str) -> datetime:
 52 |     try:
 53 |         return _parse_datetime(date)
 54 |     except Exception as e:
 55 |         raise InvalidDatetime(f"Invalid datetime {date}") from e
 56 | 
 57 | 
 58 | def parse_datetime(
 59 |     datetime_str: str,
 60 | ) -> Tuple[Optional[datetime], Optional[datetime], Optional[datetime]]:
 61 |     """Parse datetime string input into datetime objects"""
 62 |     datetime_, start, end = None, None, None
 63 |     dt = datetime_str.split("/")
 64 |     if len(dt) == 1:
 65 |         datetime_ = _parse_date(dt[0])
 66 | 
 67 |     elif len(dt) == 2:
 68 |         dates: List[Optional[str]] = [None, None]
 69 |         dates[0] = dt[0] if dt[0] not in ["..", ""] else None
 70 |         dates[1] = dt[1] if dt[1] not in ["..", ""] else None
 71 | 
 72 |         if dates[0]:
 73 |             start = _parse_date(dates[0])
 74 | 
 75 |         if dates[1]:
 76 |             end = _parse_date(dates[1])
 77 | 
 78 |     else:
 79 |         raise InvalidDatetime("Invalid datetime: {datetime}")
 80 | 
 81 |     return datetime_, start, end
 82 | 
 83 | 
 84 | def get_concept_id_umm(concept_id: str) -> Dict[str, Any]:
 85 |     """Query CMR for the metadata for a concept_id"""
 86 |     results = earthaccess.collection_query().concept_id(concept_id).get(1)
 87 | 
 88 |     if not results:
 89 |         raise HTTPException(400, f"concept_id {concept_id} not found")
 90 | 
 91 |     return results[0]
 92 | 
 93 | 
 94 | def get_resolution_degrees(concept_id: str) -> Tuple[Optional[float], Optional[float]]:
 95 |     """Query CMR to get the resolution of a dataset using its concept_id. If the units are in meters
 96 |     convert to degrees using the rough conversion factor of 0.00001 degrees per meter"""
 97 |     ds = get_concept_id_umm(concept_id)
 98 | 
 99 |     try:
100 |         resolution_info = ds["umm"]["SpatialExtent"]["HorizontalSpatialDomain"][
101 |             "ResolutionAndCoordinateSystem"
102 |         ]["HorizontalDataResolution"]["GenericResolutions"][0]
103 |     except KeyError:
104 |         logger.warning(
105 |             f"could not find HorizontalDataResolution for concept_id {concept_id}"
106 |         )
107 |         return (None, None)
108 | 
109 |     units = resolution_info["Unit"].lower()
110 |     if units not in ["meters", "decimal degrees"]:
111 |         raise ValueError(
112 |             f"cannot convert the coordinate units for concept_id {concept_id}: {units}"
113 |         )
114 | 
115 |     conversion_factor = 0.00001 if units == "meters" else 1
116 | 
117 |     return (
118 |         resolution_info["XDimension"] * conversion_factor,
119 |         resolution_info["YDimension"] * conversion_factor,
120 |     )
121 | 
122 | 
123 | def get_bbox_degrees(
124 |     minx: float, miny: float, maxx: float, maxy: float, coord_crs: CRS
125 | ) -> Tuple[float, float, float, float]:
126 |     """Get bounding box coordinates in WGS84 decimal degrees"""
127 |     coord_crs = coord_crs or WGS84_CRS
128 |     if coord_crs != WGS84_CRS:
129 |         minx, miny, miny, maxy = transform_bounds(
130 |             coord_crs, WGS84_CRS, minx, miny, maxx, maxy
131 |         )
132 | 
133 |     return minx, miny, maxx, maxy
134 | 
135 | 
136 | def calculate_time_series_request_size(
137 |     concept_id: str,
138 |     n_time_steps: int,
139 |     minx: float,
140 |     miny: float,
141 |     maxx: float,
142 |     maxy: float,
143 |     coord_crs: CRS,
144 | ) -> float:
145 |     """Calculate the approximate magnitude of a time series request expressed
146 |     as a total number of pixels read across the entire time series
147 |     """
148 |     xres, yres = get_resolution_degrees(concept_id)
149 |     if not (xres and yres):
150 |         return 0
151 | 
152 |     minx, miny, maxx, maxy = get_bbox_degrees(minx, miny, maxx, maxy, coord_crs)
153 | 
154 |     n_pixels_per_request = (maxx - minx) / xres * (maxy - miny) / yres
155 | 
156 |     return n_pixels_per_request * n_time_steps
157 | 
158 | 
159 | def get_geojson_bounds(
160 |     geojson: Union[Feature, FeatureCollection],
161 | ) -> Tuple[float, float, float, float]:
162 |     """Get the global bounding box for a geojson Feature or FeatureCollection"""
163 |     fc = geojson
164 |     if isinstance(fc, Feature):
165 |         fc = FeatureCollection(type="FeatureCollection", features=[geojson])
166 | 
167 |     all_bounds = [
168 |         bounds(feature.model_dump(exclude_none=True)) for feature in fc.features
169 |     ]
170 | 
171 |     minx = min(bound[0] for bound in all_bounds)
172 |     miny = min(bound[1] for bound in all_bounds)
173 |     maxx = max(bound[2] for bound in all_bounds)
174 |     maxy = max(bound[3] for bound in all_bounds)
175 | 
176 |     return (minx, miny, maxx, maxy)
177 | 


--------------------------------------------------------------------------------
/titiler/cmr/main.py:
--------------------------------------------------------------------------------
  1 | """TiTiler+cmr FastAPI application."""
  2 | 
  3 | from contextlib import asynccontextmanager
  4 | 
  5 | import earthaccess
  6 | import jinja2
  7 | from fastapi import FastAPI
  8 | from starlette.middleware.cors import CORSMiddleware
  9 | from starlette.templating import Jinja2Templates
 10 | 
 11 | from titiler.cmr import __version__ as titiler_cmr_version
 12 | from titiler.cmr.errors import DEFAULT_STATUS_CODES as CMR_STATUS_CODES
 13 | from titiler.cmr.factory import Endpoints
 14 | from titiler.cmr.logger import configure_logging
 15 | from titiler.cmr.settings import ApiSettings, AuthSettings
 16 | from titiler.cmr.timeseries import TimeseriesExtension
 17 | from titiler.core.errors import DEFAULT_STATUS_CODES, add_exception_handlers
 18 | from titiler.core.middleware import CacheControlMiddleware, LoggerMiddleware
 19 | from titiler.mosaic.errors import MOSAIC_STATUS_CODES
 20 | 
 21 | # Configure logging at application startup
 22 | configure_logging()
 23 | 
 24 | jinja2_env = jinja2.Environment(
 25 |     loader=jinja2.ChoiceLoader(
 26 |         [
 27 |             jinja2.PackageLoader(__package__, "templates"),
 28 |             jinja2.PackageLoader("titiler.core"),
 29 |         ]
 30 |     ),
 31 | )
 32 | templates = Jinja2Templates(env=jinja2_env)
 33 | 
 34 | settings = ApiSettings()
 35 | auth_config = AuthSettings()
 36 | 
 37 | 
 38 | @asynccontextmanager
 39 | async def lifespan(app: FastAPI):
 40 |     """FastAPI Lifespan."""
 41 |     if auth_config.strategy == "environment" and auth_config.access == "direct":
 42 |         app.state.cmr_auth = earthaccess.login(strategy="environment")
 43 |     else:
 44 |         app.state.cmr_auth = None
 45 | 
 46 |     yield
 47 | 
 48 | 
 49 | description = """A TiTiler-based dynamic tiling application for the Common Metadata Repository (CMR).
 50 | 
 51 | ---
 52 | 
 53 | **Documentation**: <a href="https://developmentseed.org/titiler-cmr/" target="_blank">https://developmentseed.org/titiler-cmr/</a>
 54 | 
 55 | **Source Code**: <a href="https://github.com/developmentseed/titiler-cmr" target="_blank">https://github.com/developmentseed/titiler-cmr</a>
 56 | 
 57 | ---
 58 | 
 59 | This API allows you to interact with data in CMR using many of the familiar TiTiler functions.
 60 | Users can specify a CMR query for a specific concept id (e.g. C123456-LPDAAC_ECS) and datetime
 61 | and get a TileJSON, XYZ tile image, statistics report (for a GeoJSON) and more.
 62 | 
 63 | ## Timeseries
 64 | The Timeseries Extension provides endpoints for requesting results for all points or intervals
 65 | along a timeseries. The [/timeseries family of endpoints](#/Timeseries) works by converting
 66 | the provided timeseries parameters (`datetime`, `step`, and `temporal_mode`) into a set of
 67 | `datetime` query parameters for the corresponding lower-level endpoint, running asynchronous
 68 | requests to the lower-level endpoint, then collecting the results and formatting them in a
 69 | coherent format for the user.
 70 | 
 71 | The timeseries structure is defined by the `datetime`, `step`, and `temporal_mode` parameters.
 72 | 
 73 | The `temporal_mode` mode parameter controls whether or not CMR is queried for a particular
 74 | point-in-time (`temporal_mode=point`) or over an entire interval (`temporal_mode=interval`).
 75 | In general, it is best to use `temporal_mode=point` for datasets where granules overlap completely
 76 | in space (e.g. daily sea surface temperature predictions) because the /timeseries endpoints will
 77 | create a mosaic of all assets returned by the query and the first asset to cover a pixel will
 78 | be used. For datasets where it requires granules from multiple timestamps to fully cover an AOI,
 79 | `temporal_mode=interval` is appropriate. For example, you can get weekly composites of satellite
 80 | imagery for visualization purposes with `step=P1W & temporal_mode=interval`.
 81 | 
 82 | To get a timeseries for all granules between two datetimes, you can simply specify
 83 | `datetime={start}/{end}` and a query will be sent to CMR to identify all of the granule timestamps
 84 | between the provided `start` and `end` datetimes.
 85 | 
 86 | To get a weekly sample of granules you can specify `datetime={start}/{end}`, `step=P1W`, and
 87 | `temporal_mode=point`.
 88 | """
 89 | 
 90 | 
 91 | tags_metadata = [
 92 |     {
 93 |         "name": "Raster Tiles",
 94 |     },
 95 |     {
 96 |         "name": "TileJSON",
 97 |     },
 98 |     {
 99 |         "name": "Map",
100 |     },
101 |     {
102 |         "name": "Statistics",
103 |     },
104 |     {
105 |         "name": "Images",
106 |     },
107 |     {
108 |         "name": "Timeseries",
109 |         "description": "A family of endpoints for timeseries analysis and visualization.",
110 |     },
111 |     {
112 |         "name": "Tiling Schemes",
113 |     },
114 |     {
115 |         "name": "Landing Page",
116 |     },
117 |     {
118 |         "name": "Conformance",
119 |     },
120 | ]
121 | 
122 | app = FastAPI(
123 |     title=settings.name,
124 |     openapi_url="/api",
125 |     docs_url="/api.html",
126 |     description=description,
127 |     version=titiler_cmr_version,
128 |     root_path=settings.root_path,
129 |     lifespan=lifespan,
130 |     openapi_tags=tags_metadata,
131 | )
132 | 
133 | add_exception_handlers(app, DEFAULT_STATUS_CODES)
134 | add_exception_handlers(app, MOSAIC_STATUS_CODES)
135 | add_exception_handlers(app, CMR_STATUS_CODES)
136 | 
137 | # Set all CORS enabled origins
138 | if settings.cors_origins:
139 |     app.add_middleware(
140 |         CORSMiddleware,
141 |         allow_origins=settings.cors_origins,
142 |         allow_credentials=True,
143 |         allow_methods=["GET", "POST"],
144 |         allow_headers=["*"],
145 |     )
146 | 
147 | app.add_middleware(CacheControlMiddleware, cachecontrol=settings.cachecontrol)
148 | 
149 | app.add_middleware(LoggerMiddleware)
150 | 
151 | ###############################################################################
152 | # application endpoints
153 | endpoints = Endpoints(
154 |     title=settings.name,
155 |     templates=templates,
156 |     extensions=[TimeseriesExtension()],
157 |     enable_telemetry=settings.telemetry_enabled,
158 | )
159 | app.include_router(endpoints.router)
160 | 


--------------------------------------------------------------------------------
/titiler/cmr/logger.py:
--------------------------------------------------------------------------------
  1 | """titiler-cmr logger."""
  2 | 
  3 | import json
  4 | import logging
  5 | import os
  6 | from datetime import datetime, timezone
  7 | 
  8 | 
  9 | class JSONFormatter(logging.Formatter):
 10 |     """JSON log formatter for local development."""
 11 | 
 12 |     def format(self, record):
 13 |         """Format log record as JSON."""
 14 |         log_entry = {
 15 |             "timestamp": self.formatTime(record, "%Y-%m-%dT%H:%M:%S.%fZ"),
 16 |             "level": record.levelname,
 17 |             "logger": record.name,
 18 |             "message": record.getMessage(),
 19 |             "filename": record.filename,
 20 |             "lineno": record.lineno,
 21 |         }
 22 | 
 23 |         # Add any extra fields passed via the extra parameter
 24 |         if hasattr(record, "__dict__"):
 25 |             for key, value in record.__dict__.items():
 26 |                 if key not in log_entry and not key.startswith("_"):
 27 |                     # Only add if it's not a standard logging attribute
 28 |                     if not hasattr(logging.LogRecord("", 0, "", 0, "", (), None), key):
 29 |                         log_entry[key] = value
 30 | 
 31 |         if record.exc_info:
 32 |             log_entry["exception"] = self.formatException(record.exc_info)
 33 | 
 34 |         return json.dumps(log_entry)
 35 | 
 36 | 
 37 | def otel_trace_id_to_xray_format(otel_trace_id: str) -> str:
 38 |     """
 39 |     Convert OpenTelemetry trace ID to X-Ray format.
 40 | 
 41 |     OTEL format: 32 hex chars (e.g., "68eeb2ec45b07caf760899f308d34ab6")
 42 |     X-Ray format: "1-{first 8 chars}-{remaining 24 chars}" (e.g., "1-68eeb2ec-45b07caf760899f308d34ab6")
 43 | 
 44 |     The first 8 hex chars represent the Unix timestamp, which is how X-Ray generates compatible IDs.
 45 |     """
 46 |     if len(otel_trace_id) == 32:
 47 |         return f"1-{otel_trace_id[:8]}-{otel_trace_id[8:]}"
 48 |     return otel_trace_id
 49 | 
 50 | 
 51 | class XRayJsonFormatter(logging.Formatter):
 52 |     """
 53 |     Custom JSON formatter that includes X-Ray trace ID for log correlation.
 54 | 
 55 |     This formatter outputs logs as JSON and includes:
 56 |     - Standard log fields (timestamp, level, message, logger)
 57 |     - X-Ray trace ID (converted from OTEL format)
 58 |     - OTEL trace context fields (if present)
 59 |     - Any extra fields passed via logger.info("msg", extra={...})
 60 |     """
 61 | 
 62 |     RESERVED_ATTRS = {
 63 |         "name",
 64 |         "msg",
 65 |         "args",
 66 |         "created",
 67 |         "filename",
 68 |         "funcName",
 69 |         "levelname",
 70 |         "levelno",
 71 |         "lineno",
 72 |         "module",
 73 |         "msecs",
 74 |         "message",
 75 |         "pathname",
 76 |         "process",
 77 |         "processName",
 78 |         "relativeCreated",
 79 |         "thread",
 80 |         "threadName",
 81 |         "exc_info",
 82 |         "exc_text",
 83 |         "stack_info",
 84 |         "taskName",
 85 |     }
 86 | 
 87 |     def format(self, record: logging.LogRecord) -> str:  # noqa: C901
 88 |         """Format log record as JSON with X-Ray trace ID."""
 89 |         log_object = {
 90 |             "timestamp": datetime.fromtimestamp(record.created, tz=timezone.utc)
 91 |             .isoformat()
 92 |             .replace("+00:00", "Z"),
 93 |             "level": record.levelname,
 94 |             "message": record.getMessage(),
 95 |             "logger": record.name,
 96 |         }
 97 | 
 98 |         xray_trace_id = None
 99 | 
100 |         trace_header = os.environ.get("_X_AMZN_TRACE_ID", "")
101 |         if trace_header:
102 |             for part in trace_header.split(";"):
103 |                 if part.startswith("Root="):
104 |                     xray_trace_id = part.split("=", 1)[1]
105 |                     break
106 | 
107 |         if not xray_trace_id and hasattr(record, "otelTraceID"):
108 |             xray_trace_id = otel_trace_id_to_xray_format(record.otelTraceID)
109 | 
110 |         if xray_trace_id:
111 |             log_object["xray_trace_id"] = xray_trace_id
112 | 
113 |         if record.exc_info:
114 |             log_object["exception"] = self.formatException(record.exc_info)
115 | 
116 |         for attr in [
117 |             "otelSpanID",
118 |             "otelTraceID",
119 |             "otelTraceSampled",
120 |             "otelServiceName",
121 |         ]:
122 |             if hasattr(record, attr):
123 |                 log_object[attr] = getattr(record, attr)
124 | 
125 |         if hasattr(record, "aws_request_id"):
126 |             log_object["requestId"] = record.aws_request_id
127 | 
128 |         for key, value in record.__dict__.items():
129 |             if key not in self.RESERVED_ATTRS and key not in log_object:
130 |                 log_object[key] = value
131 | 
132 |         return json.dumps(log_object)
133 | 
134 | 
135 | def configure_logging():
136 |     """
137 |     Configure logging for the application.
138 | 
139 |     This should be called once at application startup.
140 |     Automatically detects the environment and configures appropriately:
141 |     - AWS Lambda: Uses XRayJsonFormatter with X-Ray trace correlation
142 |     - Local dev: Uses JSONFormatter for simple JSON logs
143 | 
144 |     All log levels for application and third-party libraries are configured here.
145 |     """
146 | 
147 |     logging.getLogger("titiler").setLevel(logging.INFO)
148 |     logging.getLogger("titiler-cmr").setLevel(logging.INFO)
149 | 
150 |     logging.getLogger("botocore").setLevel(logging.WARNING)
151 |     logging.getLogger("aiobotocore").setLevel(logging.WARNING)
152 |     logging.getLogger("earthaccess").setLevel(logging.WARNING)
153 |     logging.getLogger("urllib3").setLevel(logging.WARNING)
154 |     logging.getLogger("numexpr").setLevel(logging.WARNING)
155 | 
156 |     is_lambda = "AWS_EXECUTION_ENV" in os.environ
157 | 
158 |     if is_lambda:
159 |         root_logger = logging.getLogger()
160 |         root_logger.setLevel(logging.WARN)
161 | 
162 |         for log_handler in root_logger.handlers[:]:
163 |             root_logger.removeHandler(log_handler)
164 | 
165 |         json_handler = logging.StreamHandler()
166 |         json_handler.setFormatter(XRayJsonFormatter())
167 |         root_logger.addHandler(json_handler)
168 | 
169 |         logging.getLogger("mangum.lifespan").setLevel(logging.ERROR)
170 |         logging.getLogger("mangum.http").setLevel(logging.ERROR)
171 |     else:
172 |         formatter = JSONFormatter()
173 |         handler = logging.StreamHandler()
174 |         handler.setFormatter(formatter)
175 |         logging.root.addHandler(handler)
176 | 
177 | 
178 | logger = logging.getLogger("titiler-cmr")
179 | 


--------------------------------------------------------------------------------
/tests/conftest.py:
--------------------------------------------------------------------------------
  1 | """titiler.cmr tests configuration."""
  2 | 
  3 | import os
  4 | from collections.abc import Callable
  5 | from typing import Any
  6 | 
  7 | import pytest
  8 | from fastapi.testclient import TestClient
  9 | from geojson_pydantic import Feature, FeatureCollection, Polygon
 10 | from vcr.request import Request
 11 | 
 12 | from titiler.cmr.backend import CMRBackend
 13 | from titiler.cmr.settings import AuthSettings
 14 | 
 15 | # Create a custom AuthSettings instance
 16 | custom_auth_settings = AuthSettings(
 17 |     strategy="iam",
 18 |     access="external",
 19 | )
 20 | 
 21 | 
 22 | def before_record_cb(request: Request):
 23 |     """Do not cache requests to the test client"""
 24 |     # testserver is the default host for TestClient
 25 |     # find_or_create_token is an EDL API call, but we do NOT want to record tokens
 26 |     if request.host == "testserver" or request.path.endswith("find_or_create_token"):
 27 |         return None
 28 |     return request
 29 | 
 30 | 
 31 | @pytest.fixture(scope="session")
 32 | def vcr_config():
 33 |     """Do not cache requests to the test client"""
 34 |     return {
 35 |         "filter_headers": [("authorization", "DUMMY")],
 36 |         "before_record_request": before_record_cb,
 37 |     }
 38 | 
 39 | 
 40 | @pytest.fixture(scope="session", autouse=True)
 41 | def override_auth_settings(session_mocker):
 42 |     """Override AuthSettings for all tests."""
 43 |     session_mocker.patch(
 44 |         "titiler.cmr.settings.AuthSettings", return_value=custom_auth_settings
 45 |     )
 46 |     session_mocker.patch("titiler.cmr.backend.s3_auth_config", custom_auth_settings)
 47 | 
 48 | 
 49 | @pytest.fixture(scope="session")
 50 | def app():
 51 |     """Create a TestClient instance for the app."""
 52 |     from titiler.cmr.main import app
 53 | 
 54 |     with TestClient(app) as client:
 55 |         yield client
 56 | 
 57 | 
 58 | @pytest.fixture
 59 | def mock_cmr_get_assets(monkeypatch):
 60 |     """Replace remote urls with local file paths"""
 61 |     original_get_assets = CMRBackend.get_assets
 62 | 
 63 |     def mocked_get_assets(*args, **kwargs):
 64 |         assets = original_get_assets(*args, **kwargs)
 65 | 
 66 |         prefixes = (
 67 |             "https://data.lpdaac.earthdatacloud.nasa.gov/",
 68 |             "https://archive.podaac.earthdata.nasa.gov/",
 69 |         )
 70 |         data_dir = os.path.join(os.path.dirname(__file__), "data")
 71 |         for asset in assets:
 72 |             if isinstance(asset["url"], dict):
 73 |                 for band, url in asset["url"].items():
 74 |                     for prefix in prefixes:
 75 |                         if url.startswith(prefix):
 76 |                             asset["url"][band] = url.replace(
 77 |                                 prefix, f"file://{data_dir}/"
 78 |                             )
 79 |             elif isinstance(asset["url"], str):
 80 |                 for prefix in prefixes:
 81 |                     if asset["url"].startswith(prefix):
 82 |                         asset["url"] = asset["url"].replace(
 83 |                             prefix, f"file://{data_dir}/"
 84 |                         )
 85 | 
 86 |         return assets
 87 | 
 88 |     monkeypatch.setattr(CMRBackend, "get_assets", mocked_get_assets)
 89 | 
 90 | 
 91 | @pytest.fixture(scope="function")
 92 | def arctic_bounds() -> tuple[float, float, float, float]:
 93 |     """bbox coordinates for an area in the arctic"""
 94 |     return -20.799, 75.011, 14.483, 83.559
 95 | 
 96 | 
 97 | @pytest.fixture(scope="function")
 98 | def arctic_geojson(arctic_bounds: tuple[float, float, float, float]) -> dict[str, Any]:
 99 |     """geojson representation of an area in the arctic"""
100 |     return Feature(
101 |         type="Feature",
102 |         properties={},
103 |         geometry=Polygon.from_bounds(*arctic_bounds),
104 |     ).model_dump(exclude_none=True)
105 | 
106 | 
107 | @pytest.fixture(scope="function")
108 | def global_bounds() -> tuple[float, float, float, float]:
109 |     """bbox coordinates for the globe"""
110 |     return -180, -90, 180, 90
111 | 
112 | 
113 | @pytest.fixture(scope="function")
114 | def global_geojson(global_bounds: tuple[float, float, float, float]) -> dict[str, Any]:
115 |     """geojson representation of the whole globe"""
116 |     return Feature(
117 |         type="Feature",
118 |         properties={},
119 |         geometry=Polygon.from_bounds(*global_bounds),
120 |     ).model_dump(exclude_none=True)
121 | 
122 | 
123 | @pytest.fixture(scope="function")
124 | def mn_bounds() -> tuple[float, float, float, float]:
125 |     """bbox coordinates for an area in northern minnesota"""
126 |     return -91.705, 48.179, -91.459, 48.3
127 | 
128 | 
129 | @pytest.fixture(scope="function")
130 | def mn_geojson(mn_bounds: tuple[float, float, float, float]) -> dict[str, Any]:
131 |     """geojson representation of an area in northern minnesota"""
132 |     return Feature(
133 |         type="Feature",
134 |         properties={},
135 |         geometry=Polygon.from_bounds(*mn_bounds),
136 |     ).model_dump(exclude_none=True)
137 | 
138 | 
139 | @pytest.fixture(scope="function")
140 | def great_lakes_geojson() -> dict[str, Any]:
141 |     """geojson FeatureCollection representation of Lake Michigan and Lake Huron"""
142 |     # Lake Michigan bounds (approximate)
143 |     lake_michigan_bounds = (-87.5, 41.5, -85.0, 46.0)
144 |     # Lake Huron bounds (approximate)
145 |     lake_huron_bounds = (-84.0, 43.0, -79.0, 46.0)
146 | 
147 |     lake_michigan = Feature(
148 |         type="Feature",
149 |         properties={"name": "Lake Michigan"},
150 |         geometry=Polygon.from_bounds(*lake_michigan_bounds),
151 |     )
152 | 
153 |     lake_huron = Feature(
154 |         type="Feature",
155 |         properties={"name": "Lake Huron"},
156 |         geometry=Polygon.from_bounds(*lake_huron_bounds),
157 |     )
158 | 
159 |     return FeatureCollection(
160 |         type="FeatureCollection",
161 |         features=[lake_michigan, lake_huron],
162 |     ).model_dump(exclude_none=True)
163 | 
164 | 
165 | @pytest.fixture(scope="session")
166 | def xarray_query_params() -> Callable[..., dict[str, str]]:
167 |     """reusable set of query parameters for xarray backend requests"""
168 | 
169 |     def _xarray_query_params(
170 |         concept_id: str = "C2036881735-POCLOUD",
171 |         variable: str = "sea_ice_fraction",
172 |         datetime: str = "2024-10-11T00:00:01Z/2024-10-11T23:59:59Z",
173 |         sel: str | None = None,
174 |         sel_method: str | None = None,
175 |     ):
176 |         return {
177 |             "backend": "xarray",
178 |             "concept_id": concept_id,
179 |             "variable": variable,
180 |             "datetime": datetime,
181 |             **({"sel": sel} if sel else {}),
182 |             **({"sel_method": sel_method} if sel_method else {}),
183 |         }
184 | 
185 |     return _xarray_query_params
186 | 
187 | 
188 | @pytest.fixture(scope="session")
189 | def rasterio_query_params() -> dict[str, str]:
190 |     """reusable set of query parameters for rasterio backend requests"""
191 |     return {
192 |         "concept_id": "C2021957657-LPCLOUD",
193 |         "datetime": "2024-10-09T00:00:01Z/2024-10-09T23:59:59Z",
194 |         "backend": "rasterio",
195 |         "bands_regex": "Fmask",
196 |         "bands": "Fmask",
197 |     }
198 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | <p align="center">
  2 |   <img width="500" src="./titiler-cmr.png"/>
  3 |   <p align="center">A modern dynamic tile server with a NASA CMR backend built on top of FastAPI and Rasterio/GDAL.</p>
  4 | </p>
  5 | 
  6 | <p align="center">
  7 |   <a href="https://github.com/developmentseed/titiler/actions?query=workflow%3ACI" target="_blank">
  8 |       <img src="https://github.com/developmentseed/titiler/workflows/CI/badge.svg" alt="Test">
  9 |   </a>
 10 |   <a href="https://github.com/developmentseed/titiler-cmr/blob/main/LICENSE" target="_blank">
 11 |       <img src="https://img.shields.io/github/license/developmentseed/titiler-cmr.svg" alt="Downloads">
 12 |   </a>
 13 | </p>
 14 | 
 15 | # titiler-cmr
 16 | 
 17 | An API for creating image tiles from CMR queries.
 18 | 
 19 | ## Features
 20 | 
 21 | - Render tiles from assets discovered via queries to [NASA's CMR](https://cmr.earthdata.nasa.gov/search)
 22 | - Uses the [`earthaccess` python package](https://github.com/nsidc/earthaccess) to query the CMR
 23 | - Built on top of [titiler](https://github.com/developmentseed/titiler)
 24 | - Multiple projections support (see [TileMatrixSets](https://www.ogc.org/standards/tms)) via [`morecantile`](https://github.com/developmentseed/morecantile).
 25 | - JPEG / JP2 / PNG / WEBP / GTIFF / NumpyTile output format support
 26 | - Automatic OpenAPI documentation (FastAPI builtin)
 27 | - Example of AWS Lambda / ECS deployment (via CDK)
 28 | 
 29 | ## Installation
 30 | 
 31 | To install from sources and run for development, [install `uv`](https://docs.astral.sh/uv/getting-started/installation/) then:
 32 | 
 33 | ```bash
 34 | git clone https://github.com/developmentseed/titiler-cmr.git
 35 | cd titiler-cmr
 36 | 
 37 | uv sync --all-extras
 38 | ```
 39 | 
 40 | ## Authentication for data read access
 41 | 
 42 | `titiler-cmr` can read data either over `HTTP` (external) or directly from `AWS S3` (direct) depending on the app configuration.
 43 | The behavior of the application is controlled by the S3 authentication settings in `settings.py`, which you can set either with environment variables (`TITILER_CMR_S3_AUTH_ACCESS`, `TITILER_CMR_S3_AUTH_STRATEGY`) or in an environment file (`.env`).
 44 | 
 45 | ### Direct from S3
 46 | 
 47 | When running in an AWS context (e.g. Lambda), you should configure the application to access the data directly from `S3`.
 48 | You can do this in two ways:
 49 | 
 50 | - Configure an AWS IAM role for your runtime environment that has read access to the NASA buckets so that `rasterio/GDAL` can find the AWS credentials when reading data
 51 | - Set the `EARTHDATA_USERNAME` and `EARTHDATA_PASSWORD` environment variables so that the `earthaccess` package can issue temporary AWS credentials
 52 | 
 53 | > [!NOTE]
 54 | > Direct S3 access configuration will only work if the application is running in the same AWS region as the data are stored!
 55 | 
 56 | ### External access
 57 | 
 58 | When running outside of the AWS context (e.g. locally) you will need to configure the application to access data over `HTTP`.
 59 | You can do this by creating an Earthdata account, configuring your `.netrc` file with your Earthdata login credentials (which GDAL will find when trying to access data over the network), and setting a few environment variables:
 60 | 
 61 | ```bash
 62 | # environment variables for GDAL to read data from NASA over HTTP
 63 | export GDAL_DISABLE_READDIR_ON_OPEN=YES
 64 | export CPL_VSIL_CURL_USE_HEAD=FALSE
 65 | export GDAL_HTTP_COOKIEFILE=/tmp/cookies.txt
 66 | export GDAL_HTTP_COOKIEJAR=/tmp/cookies.txt
 67 | export EARTHDATA_USERNAME={your earthdata username}
 68 | export EARTHDATA_PASSWORD={your earthdata password}
 69 | 
 70 | # write your .netrc file to the home directory
 71 | echo "machine urs.earthdata.nasa.gov login ${EARTHDATA_USERNAME} password ${EARTHDATA_PASSWORD}" > ~/.netrc
 72 | ```
 73 | 
 74 | > [!NOTE]
 75 | > See [NASA's docs](https://uat.urs.earthdata.nasa.gov/documentation/for_users/data_access/curl_and_wget) for details
 76 | 
 77 | ## Docker deployment
 78 | 
 79 | You can run the application in a docker container using the docker-compose.yml file.
 80 | The docker container is configured to read the `EARTHDATA_USERNAME` and `EARTHDATA_PASSWORD` environment variables so make sure set those before starting the docker network.
 81 | 
 82 | ```bash
 83 | docker compose up --build 
 84 | ```
 85 | 
 86 | The application will be available at this address: [http://localhost:8081/api.html](http://localhost:8081/api.html)
 87 | 
 88 | ## Local deployment
 89 | 
 90 | To run the application directly in your local environment, configure the application to access data over `HTTP` then run it using `uvicorn`:
 91 | 
 92 | ```bash
 93 | TITILER_CMR_S3_AUTH_ACCESS=external uv run uvicorn titiler.cmr.main:app --reload --log-level info
 94 | ```
 95 | 
 96 | The application will be available at this address: [http://localhost:8000/api.html](http://localhost:8000/api.html)
 97 | 
 98 | ## Deployment to AWS via `veda-deploy`
 99 | 
100 | Deployment to AWS is currently triggered using [veda-deploy](https://github.com/NASA-IMPACT/veda-deploy). veda-deploy checks out this repo as a submodule and then executes [.github/actions/cdk-deploy/action.yml](.github/actions/cdk-deploy/action.yml) (see also: [veda-deploy/.github/workflows/deploy.yml](https://github.com/NASA-IMPACT/veda-deploy/blob/dev/.github/workflows/deploy.yml)). For more details, please review the [veda-deploy README section on adding new components](https://github.com/NASA-IMPACT/veda-deploy/tree/dev?tab=readme-ov-file#add-new-components).
101 | 
102 | ### Environment Variables
103 | 
104 | Environment variables for the `veda-deploy` deployment should be configured in the `veda-deploy` environment-specific AWS Secret. See also [these instructions](https://github.com/NASA-IMPACT/veda-deploy/tree/dev?tab=readme-ov-file#store-env-configuration-in-aws-secrets-manager). The variables in the AWS Secret will be written to an `.env` file and used by the CDK deployment as instantiated by the `AppSettings` and `StackSettings` defined [infrastructure/aws/cdk/config.py](infrastructure/aws/cdk/config.py). `StackSettings` are those specific to the specific stage being deployed, may only be used during deployment, and are more likely to be shared across VEDA services. `AppSettings` are settings specific to titiler-cmr and are used to set the lambda runtime environment variables.
105 | 
106 | The application-specific (`AppSettings`) environment variables which should be set in the `veda-deploy` AWS secret are:
107 | 
108 | - `TITILER_CMR_S3_AUTH_STRATEGY=iam`
109 | - `TITILER_CMR_ROOT_PATH=/api/titiler-cmr`
110 | - `TITILER_CMR_AWS_REQUEST_PAYER=requester`
111 | 
112 | ### Deployment to a development/test instance
113 | 
114 | You can trigger a deploy to a "dev" stack (cloudformation stack name should be `titiler-cmr-dev`) in the VEDA SMCE account by labeling a PR with the "deploy-dev" tag. This stack is intended for testing new features.
115 | 
116 | ## Contribution & Development
117 | 
118 | See [CONTRIBUTING.md](https://github.com/developmentseed/titiler-cmr/blob/develop/CONTRIBUTING.md)
119 | 
120 | ## License
121 | 
122 | See [LICENSE](https://github.com/developmentseed/titiler-cmr/blob/develop/LICENSE)
123 | 
124 | ## Authors
125 | 
126 | Created by [Development Seed](<http://developmentseed.org>)
127 | 
128 | See [contributors](https://github.com/developmentseed/titiler-cmr/graphs/contributors) for a listing of individual contributors.
129 | 
130 | ## Changes
131 | 
132 | See [CHANGES.md](https://github.com/developmentseed/titiler-cmr/blob/main/CHANGES.md).
133 | 


--------------------------------------------------------------------------------
/infrastructure/aws/cdk/app.py:
--------------------------------------------------------------------------------
  1 | """Construct App."""
  2 | 
  3 | import os
  4 | from typing import Any, List, Optional
  5 | 
  6 | from aws_cdk import App, CfnOutput, Duration, Stack, Tags, aws_lambda, Aspects
  7 | from aws_cdk import aws_apigatewayv2 as apigw
  8 | from aws_cdk import aws_cloudwatch as cloudwatch
  9 | from aws_cdk import aws_cloudwatch_actions as cloudwatch_actions
 10 | from aws_cdk import aws_iam as iam
 11 | from aws_cdk import aws_logs as logs
 12 | from aws_cdk import aws_sns as sns
 13 | from aws_cdk import aws_sns_subscriptions as subscriptions
 14 | from aws_cdk.aws_apigatewayv2_integrations import HttpLambdaIntegration
 15 | from aws_cdk.aws_ecr_assets import Platform
 16 | from config import AppSettings, StackSettings
 17 | from constructs import Construct
 18 | from permissions_boundary.construct import PermissionsBoundaryAspect
 19 | 
 20 | stack_settings, app_settings = StackSettings(), AppSettings()
 21 | 
 22 | DEFAULT_ENV = {
 23 |     "AWS_LAMBDA_LOG_FORMAT": "JSON",
 24 |     "AWS_LAMBDA_LOG_LEVEL": "INFO",
 25 |     "GDAL_CACHEMAX": "200",  # 200 mb
 26 |     "GDAL_DISABLE_READDIR_ON_OPEN": "EMPTY_DIR",
 27 |     "GDAL_INGESTED_BYTES_AT_OPEN": "32768",  # get more bytes when opening the files.
 28 |     "GDAL_HTTP_MERGE_CONSECUTIVE_RANGES": "YES",
 29 |     "GDAL_HTTP_MULTIPLEX": "YES",
 30 |     "GDAL_HTTP_VERSION": "2",
 31 |     "PYTHONWARNINGS": "ignore",
 32 |     "VSI_CACHE": "TRUE",
 33 |     "VSI_CACHE_SIZE": "5000000",  # 5 MB (per file-handle)
 34 | }
 35 | 
 36 | 
 37 | class LambdaStack(Stack):
 38 |     """Lambda Stack"""
 39 | 
 40 |     def __init__(
 41 |         self,
 42 |         scope: Construct,
 43 |         id: str,
 44 |         memory: int = 1024,
 45 |         timeout: int = 30,
 46 |         concurrent: Optional[int] = None,
 47 |         permissions: Optional[List[iam.PolicyStatement]] = None,
 48 |         role_arn: Optional[str] = None,
 49 |         context_dir: str = "../../",
 50 |         **kwargs: Any,
 51 |     ) -> None:
 52 |         """Define stack."""
 53 |         super().__init__(scope, id, *kwargs)
 54 | 
 55 |         if stack_settings.permissions_boundary_policy_name:
 56 |             permissions_boundary_policy = iam.ManagedPolicy.from_managed_policy_name(
 57 |                 self,
 58 |                 "permissions-boundary",
 59 |                 stack_settings.permissions_boundary_policy_name,
 60 |             )
 61 |             iam.PermissionsBoundary.of(self).apply(permissions_boundary_policy)
 62 |             Aspects.of(self).add(PermissionsBoundaryAspect(permissions_boundary_policy))
 63 | 
 64 |         permissions = permissions or []
 65 | 
 66 |         iam_reader_role = None
 67 |         if role_arn:
 68 |             iam_reader_role = iam.Role.from_role_arn(
 69 |                 self,
 70 |                 "veda-reader-dev-role",
 71 |                 role_arn=role_arn,
 72 |             )
 73 | 
 74 |         lambda_env = {
 75 |             **DEFAULT_ENV,
 76 |             "TITILER_CMR_ROOT_PATH": app_settings.root_path,
 77 |             "TITILER_CMR_S3_AUTH_STRATEGY": app_settings.s3_auth_strategy,
 78 |             "TITILER_CMR_TELEMETRY_ENABLED": "TRUE",
 79 |             "OTEL_PYTHON_DISABLED_INSTRUMENTATIONS": "aws-lambda,requests,urllib3,aiohttp-client",  # Disable aws-lambda auto-instrumentation (handled by otel_wrapper.py)
 80 |             "OTEL_PROPAGATORS": "tracecontext,baggage,xray",
 81 |             "OPENTELEMETRY_COLLECTOR_CONFIG_URI": "/opt/collector-config/config.yaml",
 82 |             # AWS_LAMBDA_LOG_FORMAT not set - using custom JSON formatter in handler.py
 83 |             "AWS_LAMBDA_EXEC_WRAPPER": "/opt/otel-instrument",  # Enable OTEL wrapper to avoid circular import
 84 |         }
 85 | 
 86 |         if app_settings.aws_request_payer:
 87 |             lambda_env["AWS_REQUEST_PAYER"] = app_settings.aws_request_payer
 88 | 
 89 |         lambda_function = aws_lambda.DockerImageFunction(
 90 |             self,
 91 |             f"{id}-lambda",
 92 |             code=aws_lambda.DockerImageCode.from_image_asset(
 93 |                 directory=os.path.abspath(context_dir),
 94 |                 file="infrastructure/aws/lambda/Dockerfile",
 95 |                 platform=Platform.LINUX_AMD64,
 96 |             ),
 97 |             memory_size=memory,
 98 |             reserved_concurrent_executions=concurrent,
 99 |             timeout=Duration.seconds(timeout),
100 |             environment=lambda_env,
101 |             log_retention=logs.RetentionDays.ONE_WEEK,
102 |             role=iam_reader_role,
103 |             tracing=aws_lambda.Tracing.ACTIVE,
104 |         )
105 | 
106 |         for perm in permissions:
107 |             lambda_function.add_to_role_policy(perm)
108 | 
109 |         api = apigw.HttpApi(
110 |             self,
111 |             f"{id}-endpoint",
112 |             default_integration=HttpLambdaIntegration(
113 |                 f"{id}-integration",
114 |                 lambda_function,
115 |                 parameter_mapping=apigw.ParameterMapping().overwrite_header(
116 |                     "host",
117 |                     apigw.MappingValue(stack_settings.veda_custom_host),
118 |                 )
119 |                 if stack_settings.veda_custom_host
120 |                 else None,
121 |             ),
122 |         )
123 | 
124 |         # Create an SNS Topic
125 |         if app_settings.alarm_email:
126 |             topic = sns.Topic(
127 |                 self,
128 |                 f"{id}-500-Errors",
129 |                 display_name=f"{id} Gateway 500 Errors",
130 |                 topic_name=f"{id}-Gateway-500-Errors",
131 |             )
132 |             # Subscribe email to the topic
133 |             topic.add_subscription(
134 |                 subscriptions.EmailSubscription(app_settings.alarm_email),
135 |             )
136 | 
137 |             # Create CloudWatch Alarm
138 |             alarm = cloudwatch.Alarm(
139 |                 self,
140 |                 "MyAlarm",
141 |                 metric=cloudwatch.Metric(
142 |                     namespace="AWS/ApiGateway",
143 |                     metric_name="5XXError",
144 |                     dimensions_map={"ApiName": f"{id}-endpoint"},
145 |                     period=Duration.minutes(1),
146 |                 ),
147 |                 evaluation_periods=1,
148 |                 threshold=1,
149 |                 alarm_description="Alarm if 500 errors are detected",
150 |                 alarm_name=f"{id}-ApiGateway500Alarm",
151 |                 actions_enabled=True,
152 |             )
153 |             alarm.add_alarm_action(cloudwatch_actions.SnsAction(topic))
154 | 
155 |         CfnOutput(self, "Endpoint", value=api.url)
156 | 
157 | 
158 | app = App()
159 | if stack_settings.bootstrap_qualifier:
160 |     app.node.set_context(
161 |         "@aws-cdk/core:bootstrapQualifier", stack_settings.bootstrap_qualifier
162 |     )
163 | 
164 | perms = []
165 | if app_settings.buckets:
166 |     perms.append(
167 |         iam.PolicyStatement(
168 |             actions=["s3:GetObject"],
169 |             resources=[f"arn:aws:s3:::{bucket}*" for bucket in app_settings.buckets],
170 |         )
171 |     )
172 | 
173 | lambda_stack = LambdaStack(
174 |     app,
175 |     f"{app_settings.name}-{stack_settings.stage}",
176 |     memory=app_settings.memory,
177 |     timeout=app_settings.timeout,
178 |     concurrent=app_settings.max_concurrent,
179 |     role_arn=app_settings.role_arn,
180 |     permissions=perms,
181 | )
182 | # Tag infrastructure
183 | for key, value in {
184 |     "Project": app_settings.name,
185 |     "Stack": stack_settings.stage,
186 |     "Owner": app_settings.owner,
187 |     "Client": app_settings.client,
188 | }.items():
189 |     if value:
190 |         Tags.of(lambda_stack).add(key, value)
191 | 
192 | 
193 | app.synth()
194 | 


--------------------------------------------------------------------------------
/docs/compatibility/generate_table.py:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python3
  2 | """Generate HTML table from parquet file for mkdocs site."""
  3 | 
  4 | import json
  5 | import pandas as pd
  6 | from pathlib import Path
  7 | 
  8 | 
  9 | def generate_searchable_table():
 10 |     """Convert parquet to JSON and generate HTML with DataTables."""
 11 | 
 12 |     # Read the parquet file
 13 |     df = pd.read_parquet("tiling_results-11-24-2025.parquet")
 14 | 
 15 |     # Filter out rows with n/a collection short name and version
 16 |     df = df[df["collection_short_name_and_version"].notna()]
 17 | 
 18 |     # Select key columns for display
 19 |     display_columns = [
 20 |         "collection_short_name_and_version",
 21 |         "data_center",
 22 |         "format",
 23 |         "extension",
 24 |         "tiling_compatible",
 25 |         "incompatible_reason",
 26 |         "processing_level",
 27 |         "num_granules",
 28 |     ]
 29 | 
 30 |     # Filter to only include columns that exist
 31 |     available_columns = [col for col in display_columns if col in df.columns]
 32 |     display_df = df[available_columns]
 33 | 
 34 |     # Convert to records for JSON serialization
 35 |     records = display_df.to_dict("records")
 36 | 
 37 |     # Create column definitions for DataTables
 38 |     columns = [
 39 |         {"data": col, "title": col.replace("_", " ").title()}
 40 |         for col in available_columns
 41 |     ]
 42 | 
 43 |     # Generate HTML
 44 |     html_content = f"""<!DOCTYPE html>
 45 | <html lang="en">
 46 | <head>
 47 |     <meta charset="UTF-8">
 48 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 49 |     <title>TiTiler-CMR Dataset Compatibility Results</title>
 50 |     <link rel="stylesheet" href="https://cdn.datatables.net/1.13.7/css/jquery.dataTables.min.css">
 51 |     <style>
 52 |         body {{
 53 |             font-family: 'Roboto', Arial, sans-serif;
 54 |             margin: 20px;
 55 |             background-color: #f5f5f5;
 56 |         }}
 57 |         .container {{
 58 |             max-width: 1400px;
 59 |             margin: 0 auto;
 60 |             background-color: white;
 61 |             padding: 30px;
 62 |             border-radius: 8px;
 63 |             box-shadow: 0 2px 4px rgba(0,0,0,0.1);
 64 |         }}
 65 |         h1 {{
 66 |             color: #333;
 67 |             border-bottom: 3px solid #ff5722;
 68 |             padding-bottom: 10px;
 69 |         }}
 70 |         .info-box {{
 71 |             background-color: #e3f2fd;
 72 |             border-left: 4px solid #2196f3;
 73 |             padding: 15px;
 74 |             margin: 20px 0;
 75 |             border-radius: 4px;
 76 |         }}
 77 |         table.dataTable {{
 78 |             width: 100% !important;
 79 |             font-size: 14px;
 80 |         }}
 81 |         .dataTables_wrapper {{
 82 |             margin-top: 20px;
 83 |         }}
 84 |         .compatible-true {{
 85 |             color: #4caf50;
 86 |             font-weight: bold;
 87 |         }}
 88 |         .compatible-false {{
 89 |             color: #f44336;
 90 |             font-weight: bold;
 91 |         }}
 92 |         .back-link {{
 93 |             display: inline-block;
 94 |             margin-bottom: 20px;
 95 |             color: #2196f3;
 96 |             text-decoration: none;
 97 |             font-weight: 500;
 98 |         }}
 99 |         .back-link:hover {{
100 |             text-decoration: underline;
101 |         }}
102 |     </style>
103 | </head>
104 | <body>
105 |     <div class="container">
106 |         <a href="index.html" class="back-link">&larr; Back to Compatibility Report</a>
107 | 
108 |         <h1>TiTiler-CMR Dataset Compatibility Results</h1>
109 | 
110 |         <div class="info-box">
111 |             <strong>Total datasets:</strong> {len(df)}<br>
112 |             <strong>Compatible datasets:</strong> {len(df[df.tiling_compatible])}<br>
113 |             <strong>Compatibility rate:</strong> {len(df[df.tiling_compatible]) / len(df) * 100:.2f}%
114 |         </div>
115 | 
116 |         <p>Use the search box and column filters below to explore the dataset compatibility results.
117 |         Click on column headers to sort.</p>
118 | 
119 |         <table id="resultsTable" class="display" style="width:100%">
120 |         </table>
121 |     </div>
122 | 
123 |     <script src="https://code.jquery.com/jquery-3.7.1.min.js"></script>
124 |     <script src="https://cdn.datatables.net/1.13.7/js/jquery.dataTables.min.js"></script>
125 |     <script>
126 |         const data = {json.dumps(records, default=str)};
127 |         const columns = {json.dumps(columns)};
128 | 
129 |         $(document).ready(function() {{
130 |             $('#resultsTable').DataTable({{
131 |                 data: data,
132 |                 columns: columns,
133 |                 pageLength: 25,
134 |                 order: [[0, 'asc']],
135 |                 deferRender: true,
136 |                 columnDefs: [
137 |                     {{
138 |                         targets: columns.findIndex(col => col.data === 'tiling_compatible'),
139 |                         render: function(data, type, row) {{
140 |                             if (type === 'display') {{
141 |                                 const className = data ? 'compatible-true' : 'compatible-false';
142 |                                 return '<span class="' + className + '">' + data + '</span>';
143 |                             }}
144 |                             return data;
145 |                         }}
146 |                     }},
147 |                     {{
148 |                         // Handle null values for all columns
149 |                         targets: '_all',
150 |                         render: function(data, type, row) {{
151 |                             if (data === null || data === undefined) {{
152 |                                 return type === 'display' ? '<em style="color: #999;">N/A</em>' : '';
153 |                             }}
154 |                             return data;
155 |                         }}
156 |                     }}
157 |                 ],
158 |                 initComplete: function() {{
159 |                     // Add column filters
160 |                     this.api().columns().every(function() {{
161 |                         const column = this;
162 |                         const header = $(column.header());
163 | 
164 |                         // Add filter for specific columns
165 |                         const filterColumns = ['data_center', 'format', 'tiling_compatible', 'incompatible_reason'];
166 |                         if (filterColumns.includes(column.dataSrc())) {{
167 |                             const select = $('<select><option value="">All</option></select>')
168 |                                 .appendTo($(column.header()))
169 |                                 .on('change', function() {{
170 |                                     const val = $.fn.dataTable.util.escapeRegex($(this).val());
171 |                                     column.search(val ? '^' + val + '$' : '', true, false).draw();
172 |                                 }});
173 | 
174 |                             column.data().unique().sort().each(function(d) {{
175 |                                 if (d !== null && d !== undefined && d !== '') {{
176 |                                     select.append('<option value="' + d + '">' + d + '</option>');
177 |                                 }}
178 |                             }});
179 |                         }}
180 |                     }});
181 |                 }}
182 |             }});
183 |         }});
184 |     </script>
185 | </body>
186 | </html>"""
187 | 
188 |     # Write the HTML file
189 |     output_path = Path("results_table.html")
190 |     output_path.write_text(html_content)
191 |     print(f"Generated {output_path}")
192 | 
193 | 
194 | if __name__ == "__main__":
195 |     generate_searchable_table()
196 | 


--------------------------------------------------------------------------------
/tests/cassettes/test_backend/test_get_assets[external-https].yaml:
--------------------------------------------------------------------------------
  1 | interactions:
  2 | - request:
  3 |     body: null
  4 |     headers:
  5 |       Accept:
  6 |       - '*/*'
  7 |       Accept-Encoding:
  8 |       - gzip, deflate
  9 |       Connection:
 10 |       - keep-alive
 11 |       User-Agent:
 12 |       - earthaccess v0.11.0
 13 |       authorization:
 14 |       - DUMMY
 15 |     method: GET
 16 |     uri: https://cmr.earthdata.nasa.gov/search/granules.umm_json?bounding_box=-91.663,47.862,-91.537,47.928&concept_id%5B%5D=C2021957657-LPCLOUD&temporal%5B%5D=2024-02-11T00:00:00Z,2024-02-13T23:59:59Z&page_size=0
 17 |   response:
 18 |     body:
 19 |       string: !!binary |
 20 |         H4sIAAAAAAAAAKtWysgsKVayMtJRKsnPz1ayMrS0tNRRyixJzQWKRsfWAgBR6EaoIQAAAA==
 21 |     headers:
 22 |       Access-Control-Allow-Origin:
 23 |       - '*'
 24 |       Access-Control-Expose-Headers:
 25 |       - CMR-Hits, CMR-Request-Id, X-Request-Id, CMR-Scroll-Id, CMR-Search-After, CMR-Timed-Out,
 26 |         CMR-Shapefile-Original-Point-Count, CMR-Shapefile-Simplified-Point-Count
 27 |       CMR-Hits:
 28 |       - '2'
 29 |       CMR-Request-Id:
 30 |       - fd879c97-e4fa-4f33-8a19-22751459f8ac
 31 |       CMR-Took:
 32 |       - '2000'
 33 |       Connection:
 34 |       - keep-alive
 35 |       Content-Encoding:
 36 |       - gzip
 37 |       Content-MD5:
 38 |       - 16ce72fa70303ce40e358743f2191f89
 39 |       Content-SHA1:
 40 |       - 44c45c20ce19be17683930897348e42602776939
 41 |       Content-Type:
 42 |       - application/vnd.nasa.cmr.umm_results+json;version=1.6.6; charset=utf-8
 43 |       Date:
 44 |       - Sat, 21 Dec 2024 12:45:42 GMT
 45 |       Server:
 46 |       - ServerTokens ProductOnly
 47 |       Strict-Transport-Security:
 48 |       - max-age=31536000; includeSubDomains; preload
 49 |       Transfer-Encoding:
 50 |       - chunked
 51 |       Vary:
 52 |       - Accept-Encoding, User-Agent
 53 |       Via:
 54 |       - 1.1 077041ddf56b8eb9505a28cba1464114.cloudfront.net (CloudFront)
 55 |       X-Amz-Cf-Id:
 56 |       - DlAzEptktR0J89c-oGlsSEHNgleQl2Mj3KvrYPRyc6Y7Cb5DIOl6ZQ==
 57 |       X-Amz-Cf-Pop:
 58 |       - MSP50-P2
 59 |       X-Cache:
 60 |       - Miss from cloudfront
 61 |       X-Content-Type-Options:
 62 |       - nosniff
 63 |       X-Frame-Options:
 64 |       - SAMEORIGIN
 65 |       X-Request-Id:
 66 |       - DlAzEptktR0J89c-oGlsSEHNgleQl2Mj3KvrYPRyc6Y7Cb5DIOl6ZQ==
 67 |       X-XSS-Protection:
 68 |       - 1; mode=block
 69 |     status:
 70 |       code: 200
 71 |       message: OK
 72 | - request:
 73 |     body: null
 74 |     headers:
 75 |       Accept:
 76 |       - '*/*'
 77 |       Accept-Encoding:
 78 |       - gzip, deflate
 79 |       Connection:
 80 |       - keep-alive
 81 |       User-Agent:
 82 |       - earthaccess v0.11.0
 83 |       authorization:
 84 |       - DUMMY
 85 |     method: GET
 86 |     uri: https://cmr.earthdata.nasa.gov/search/granules.umm_json?bounding_box=-91.663,47.862,-91.537,47.928&concept_id%5B%5D=C2021957657-LPCLOUD&temporal%5B%5D=2024-02-11T00:00:00Z,2024-02-13T23:59:59Z&page_size=100
 87 |   response:
 88 |     body:
 89 |       string: !!binary |
 90 |         H4sIAAAAAAAAAO1cbXOiShr9K5RfV0k3r+I3omioRXEBk7vZSlE90jHcQbAQvTd3Kv99u8XEYDQk
 91 |         EkKiY2VSTvu89HlOd/NED/6q3fnJvNbi6rUkin6SJ7Cp1Gt+gqdk9H+/alOcoFrrV20chWM8SxrJ
 92 |         /QzXWrVJjMJFgGv1pxd8jwz3uKYkyoAXeaVhDNuGOeoQkxgv/bkfhSsbWK+FKPGXOPW4MGzW4AHr
 93 |         QHH0x5DlACcAgXOgJDZ5yC45FqxyBAEeJzREJl2bmENFlEnOZ+lmcbT0PRynNpvx2yieooQModks
 94 |         8MeIxjvD47sIgn/9PQ2eT9RDCUVJZ9MAXAOKDgAtjmuJgOVl6br2UK8tplNaFwdPZ1GMAu3vBIcJ
 95 |         HbFQOMEdEsDxp5gOnOOJH4Z+ONkMbiJDArUlNlsELBTBNZmEFnpvtH0g0+ilRIyst9ZS9TyfIkeB
 96 |         miSx/2OR4JTpAVplM9RBx1Ydd2iZnVHbcXVauksULFZmNaMNFNeAztAFnEx+3FUWDsLNE8C5Dqzd
 97 |         PNSfYq4YcNvmpWapPS0TDwKQMe33LNt1dEPbTrzClDG1h6qjq8aeuPJOW0uzTWPk6OYgY02KBvbZ
 98 |         q/2hoQ96rmr0Mj7txQ9/zLSjcBkFC1rRTADCBS1hW7Nt6uzo/ez8tpYWbAF4nZ2BNsjxzC4HQQYg
 99 |         G+HCtPRrc+DQEtnuQN2KM3L6deaqZzeFOkOeM8RUY6CYCTEy/sj4SIA+tmo1Mv6bMRKFXVZqp+Oa
100 |         3a6tORnjrJGldV27rRL2u2rbMa2sKUuiZheWc6FZ/Vc9svYqKejbrbu6YVyqxihbt4ZCHhm7/6ju
101 |         blNOzJZz0DYNO7vwJClbgYFlXuWY9DV14Nqjgate6/2Rc+ESVMbW6hebLGgqAg8VYbfvtTbQd7pK
102 |         AivKiiwI4kvHS127eiUr1+RYRVZEReJ3ZF0570/LQgVCgWtmSzs4Vy2XbFnyO3V9MVe+Sarc5LI0
103 |         t9tmJxvfQLbVZpY8C9gsMEcnB45t990+cTGyO2Tw74F5NdhtPjRtnZ4jru2ozsjOdRzZPeJodp0r
104 |         1dqa2pC8AiWWZ7PLT+9oA0fv6pr1dBh3TH3r9GRFIMln5LSh/+jhDwD3hiiuSigk54OT3bp3STKb
105 |         t87OvMhno3hCAt3Ua/aMXCqfX+Euotj/JwoTFKxf6kRT5If0pR6OSMcQ36+eD6PgfhKF6eXlPFqE
106 |         HkpfGUZ+mKTDRhRO/GThkak2FHKQ0YfCy3VCWLIeF2RWFhSJA02e4sp4ALLgBJ7nxWbGg6x+WQIy
107 |         gOILD8hKogBlBShbHhyAPACKsMtDEiWJdDbbsxJlAZD8OzzycNw80B9y/R6umxV6vU8r0tnZe8AW
108 |         z7EyXHUITtqD6eEcx0mNZn+zz2i2am0ore2npsrCtzjGpK+i3Gghoc/xk2B9FWMMFHpzlDDmDMco
109 |         7RxWY4w+RRMcM/YivkVjzJAoNB4icRj6smOqzHnsT+6SEM/nTAf5wT3TC6IfxJ8HU2bVj5AKWDgg
110 |         U/JGcZDiH1kGyfy0ElGC2IDMGo1ZjOLkjg6Mg2jhsSGaI3YSLc+CWYP0fB79lZAZYO9pL3DgLL8p
111 |         eoMJew54NvFvN4XsaQ7TUR2VjHTwfBz7s1UL0Kp1or/CIEIe846olMIU9pwnmKvEw1zqKtPRLa3t
112 |         MOQYJe3LC4TOnT9nAj/8yaw77Tnj+TGZKOM9YkfjMeV86SPG5pkkYpI7zDz+zbBB++VIFkshWayM
113 |         5D14TptkpRSSlcpI3oPnpEkmjVEJJK+jVkDyPjynTLKtqiWQ/Bj180nei+eUSe5O0fxnCTRv4n4+
114 |         0a9gOmWqz4FcypVZruzKvAfPKZN8WcqhfVnZob0XzymTfA64UnYyV9lO3oPnpEmGsJQeG1bWY+/B
115 |         c9IkA6mUnSxVtpP34DltkoVSSBYqI3kPntMmuZTjGlR2XO/Dc8okX16X0l1fV9Zd78NzyiTbpZBs
116 |         V0byXjxfn+TFj8Aff3hF3DnJyP45JwifakLVE4ylGaqjdRh90DWtvrqWMR3M+bM8+1j/ggCPdl+P
117 |         pzGb6hBL5Pwpy+fv88PxVUP5nB/H2MMhVbjMD5g1mvkMDr0ZFbvQGcU4iX28xEySakbje+ZZAmaJ
118 |         At9jbqOYmaMpbsR4QsI84pzza4Rf88Ri/5xNsuf3Y4EudXukGvp18YVLU3zuMXUoqsLL9aZOFT1o
119 |         re2lqpwOuh9QKU03QBNaN3RPsuqrtXPr4zhVzmz+X8sRA2ec1/iGpJKLMY7XWXVvNY90lALbpUje
120 |         iFepNpPqjNR4fOcvsRp6HX+e6ouJrx6m4utVfTZa40GUPJbII762/w/Ww/P7lRKKl4EiQaikw6PQ
121 |         p8rt/jmZFFVNBSihEVPc9l0UJ1n5ckOhEEMyg8UUP2rNntuZhk5DEYR9nCC6Y+wZHpN6jNez3N5l
122 |         Yy/c7K7NxlpMp2dr3s6WkJVYiSR+lPz1+42VZpgQlK6M1IAKvw5V1kucdICy/urrK+sFVvkeyvq9
123 |         tfzGyvqrdyjrtzTNX1xZD5WW0PwGynpBUZTmb2X9N1DWyyzkgKIIAv9+Zb0CICfIcvPd0nrY5Fge
124 |         AAkozR1pX5fWc6wo04sHB98prRchJ5FD+be0/rGx/NbSepEXOchD/oWIXWxCsjx2iNhFjud4GXJb
125 |         Qnkoy6IEwEvZO0+PEXLtErYcBF5sKiJQ9jhIkrI9J0mEElmxu+aUg+LdwnrQEiVW4aT3COt3+Jy2
126 |         sH53T/QGk6IfMOZEPfRNjhLwfP03M8ssSqEPGHOiVkHy0X7AeHhRCis1c+N+PtFHrdQ8vCwFRXw5
127 |         UT+f5iMW8RUoSrGPGXOiVkDy9/2YscwrWSFVSE7UKq7MR6sKKVKUQre85UStguSjveWtSFEK3bya
128 |         E7UKko/25tUiRSl0i0xO1CpIPtpbZIoUpdDdEzlRqyD5aO+eKFCUYnco50StgOTjvUO5SFFK6a4L
129 |         3iJTAp6TJrnYV8PkRK3iuD7ar4Y5vCgFNdc5UT+f5G+suS6xKKW8rVn0CyVKwPP1SX5V0HlwRT5e
130 |         WJ+b5yDFajUAj3Zff7CwPifL5+/z38L6ry6sP5zbjxTWv5Lic4+poxHWv4D3ocL6lXb1w4X1ECqS
131 |         LPISPE5l/c3D/wHcdYz41F4AAA==
132 |     headers:
133 |       Access-Control-Allow-Origin:
134 |       - '*'
135 |       Access-Control-Expose-Headers:
136 |       - CMR-Hits, CMR-Request-Id, X-Request-Id, CMR-Scroll-Id, CMR-Search-After, CMR-Timed-Out,
137 |         CMR-Shapefile-Original-Point-Count, CMR-Shapefile-Simplified-Point-Count
138 |       CMR-Hits:
139 |       - '2'
140 |       CMR-Request-Id:
141 |       - 65fa3162-2198-4200-b828-1b507b593f1f
142 |       CMR-Search-After:
143 |       - '["lpcloud",1707670711150,2865703626]'
144 |       CMR-Took:
145 |       - '2190'
146 |       Connection:
147 |       - keep-alive
148 |       Content-Encoding:
149 |       - gzip
150 |       Content-MD5:
151 |       - 2cbf0601aef31a9432aed772fc28f059
152 |       Content-SHA1:
153 |       - 64518c5c182727de97b0b2226183b28f40babc2d
154 |       Content-Type:
155 |       - application/vnd.nasa.cmr.umm_results+json;version=1.6.6; charset=utf-8
156 |       Date:
157 |       - Sat, 21 Dec 2024 12:45:44 GMT
158 |       Server:
159 |       - ServerTokens ProductOnly
160 |       Strict-Transport-Security:
161 |       - max-age=31536000; includeSubDomains; preload
162 |       Transfer-Encoding:
163 |       - chunked
164 |       Vary:
165 |       - Accept-Encoding, User-Agent
166 |       Via:
167 |       - 1.1 077041ddf56b8eb9505a28cba1464114.cloudfront.net (CloudFront)
168 |       X-Amz-Cf-Id:
169 |       - nWNsc3avcYw63R0YJPVOsgvOpPFIkPjE4BBGxuG1cNkeSkeYs6Lvug==
170 |       X-Amz-Cf-Pop:
171 |       - MSP50-P2
172 |       X-Cache:
173 |       - Miss from cloudfront
174 |       X-Content-Type-Options:
175 |       - nosniff
176 |       X-Frame-Options:
177 |       - SAMEORIGIN
178 |       X-Request-Id:
179 |       - nWNsc3avcYw63R0YJPVOsgvOpPFIkPjE4BBGxuG1cNkeSkeYs6Lvug==
180 |       X-XSS-Protection:
181 |       - 1; mode=block
182 |     status:
183 |       code: 200
184 |       message: OK
185 | version: 1
186 | 


--------------------------------------------------------------------------------
/tests/test_dependencies.py:
--------------------------------------------------------------------------------
  1 | """test titiler-pgstac dependencies."""
  2 | 
  3 | from datetime import datetime, timezone
  4 | 
  5 | import pytest
  6 | from starlette.requests import Request
  7 | 
  8 | from titiler.cmr import dependencies
  9 | from titiler.cmr.enums import MediaType
 10 | from titiler.cmr.errors import InvalidDatetime
 11 | from titiler.xarray.dependencies import CompatXarrayParams
 12 | 
 13 | 
 14 | def test_media_type():
 15 |     """test accept_media_type dependency."""
 16 |     assert (
 17 |         dependencies.accept_media_type(
 18 |             "application/json;q=0.9, text/html;q=1.0",
 19 |             [MediaType.json, MediaType.html],
 20 |         )
 21 |         == MediaType.html
 22 |     )
 23 | 
 24 |     assert (
 25 |         dependencies.accept_media_type(
 26 |             "application/json;q=0.9, text/html;q=0.8",
 27 |             [MediaType.json, MediaType.html],
 28 |         )
 29 |         == MediaType.json
 30 |     )
 31 | 
 32 |     # if no quality then default to 1.0
 33 |     assert (
 34 |         dependencies.accept_media_type(
 35 |             "application/json;q=0.9, text/html",
 36 |             [MediaType.json, MediaType.html],
 37 |         )
 38 |         == MediaType.html
 39 |     )
 40 | 
 41 |     # Invalid Quality
 42 |     assert (
 43 |         dependencies.accept_media_type(
 44 |             "application/json;q=w, , text/html;q=0.1",
 45 |             [MediaType.json, MediaType.html],
 46 |         )
 47 |         == MediaType.html
 48 |     )
 49 | 
 50 |     assert (
 51 |         dependencies.accept_media_type(
 52 |             "*",
 53 |             [MediaType.json, MediaType.html],
 54 |         )
 55 |         == MediaType.json
 56 |     )
 57 | 
 58 | 
 59 | def test_output_type():
 60 |     """test OutputType dependency."""
 61 |     req = Request(
 62 |         {
 63 |             "type": "http",
 64 |             "client": None,
 65 |             "query_string": "",
 66 |             "headers": ((b"accept", b"application/json"),),
 67 |         },
 68 |         None,
 69 |     )
 70 |     assert (
 71 |         dependencies.OutputType(
 72 |             req,
 73 |         )
 74 |         == MediaType.json
 75 |     )
 76 | 
 77 |     req = Request(
 78 |         {
 79 |             "type": "http",
 80 |             "client": None,
 81 |             "query_string": "",
 82 |             "headers": ((b"accept", b"text/html"),),
 83 |         },
 84 |         None,
 85 |     )
 86 |     assert (
 87 |         dependencies.OutputType(
 88 |             req,
 89 |         )
 90 |         == MediaType.html
 91 |     )
 92 | 
 93 |     req = Request(
 94 |         {"type": "http", "client": None, "query_string": "", "headers": ()}, None
 95 |     )
 96 |     assert not dependencies.OutputType(req)
 97 | 
 98 |     # FastAPI will parse the request first and inject `f=json` in the dependency
 99 |     req = Request(
100 |         {
101 |             "type": "http",
102 |             "client": None,
103 |             "query_string": "f=json",
104 |             "headers": ((b"accept", b"text/html"),),
105 |         },
106 |         None,
107 |     )
108 |     assert dependencies.OutputType(req, f="json") == MediaType.json
109 | 
110 | 
111 | test_datetime = datetime(year=2018, month=2, day=12, hour=9, tzinfo=timezone.utc)
112 | 
113 | 
114 | @pytest.mark.parametrize(
115 |     "temporal,res",
116 |     [
117 |         (
118 |             "2018-02-12T09:00:00Z",
119 |             test_datetime,
120 |         ),
121 |         (
122 |             "2018-02-12T09:00:00Z/",
123 |             (test_datetime, None),
124 |         ),
125 |         (
126 |             "2018-02-12T09:00:00Z/..",
127 |             (test_datetime, None),
128 |         ),
129 |         ("/2018-02-12T09:00:00Z", (None, test_datetime)),
130 |         ("../2018-02-12T09:00:00Z", (None, test_datetime)),
131 |         (
132 |             "2018-02-12T09:00:00Z/2019-02-12T09:00:00Z",
133 |             (
134 |                 test_datetime,
135 |                 datetime(year=2019, month=2, day=12, hour=9, tzinfo=timezone.utc),
136 |             ),
137 |         ),
138 |     ],
139 | )
140 | def test_cmr_query(temporal, res):
141 |     """test cmr query dependency."""
142 |     assert (
143 |         dependencies.cmr_query(concept_id="something", datetime=temporal)["temporal"]
144 |         == res
145 |     )
146 | 
147 | 
148 | def test_cmr_query_more():
149 |     """test cmr query dependency."""
150 |     assert dependencies.cmr_query(
151 |         concept_id="something",
152 |     ) == {"concept_id": "something"}
153 | 
154 |     with pytest.raises(InvalidDatetime):
155 |         dependencies.cmr_query(
156 |             concept_id="something",
157 |             datetime="yo/yo/yo",
158 |         )
159 | 
160 |     with pytest.raises(InvalidDatetime):
161 |         dependencies.cmr_query(
162 |             concept_id="something",
163 |             datetime="2019-02-12",
164 |         )
165 | 
166 |     with pytest.raises(InvalidDatetime):
167 |         dependencies.cmr_query(
168 |             concept_id="something",
169 |             datetime="2019-02-12T09:00:00Z/2019-02-12",
170 |         )
171 | 
172 | 
173 | def test_interpolated_xarray_params_single_datetime():
174 |     """Test InterpolatedXarrayParams with single datetime interpolation."""
175 |     xarray_params = CompatXarrayParams(
176 |         variable="temperature", sel=["time={datetime}", "lev=1000"], method="nearest"
177 |     )
178 | 
179 |     single_datetime = datetime(2025, 9, 23, 0, 0, 0, tzinfo=timezone.utc)
180 |     cmr_query_params = {"concept_id": "test_concept", "temporal": single_datetime}
181 | 
182 |     result = dependencies.interpolated_xarray_ds_params(xarray_params, cmr_query_params)
183 | 
184 |     assert result.sel == [f"time={single_datetime.isoformat()}", "lev=1000"]
185 |     assert result.variable == "temperature"
186 |     assert result.method == "nearest"
187 | 
188 | 
189 | def test_interpolated_xarray_params_datetime_range():
190 |     """Test InterpolatedXarrayParams with datetime range (uses start datetime)."""
191 |     xarray_params = CompatXarrayParams(
192 |         variable="temperature", sel=["time={datetime}"], method="nearest"
193 |     )
194 | 
195 |     start_datetime = datetime(2025, 9, 23, 0, 0, 0, tzinfo=timezone.utc)
196 |     end_datetime = datetime(2025, 9, 24, 0, 0, 0, tzinfo=timezone.utc)
197 |     cmr_query_params = {
198 |         "concept_id": "test_concept",
199 |         "temporal": (start_datetime, end_datetime),
200 |     }
201 | 
202 |     result = dependencies.interpolated_xarray_ds_params(xarray_params, cmr_query_params)
203 | 
204 |     assert result.sel == [f"time={start_datetime.isoformat()}"]
205 | 
206 | 
207 | def test_interpolated_xarray_params_no_datetime_template():
208 |     """Test InterpolatedXarrayParams when sel doesn't contain datetime template."""
209 |     xarray_params = CompatXarrayParams(
210 |         variable="temperature",
211 |         sel=["time=2025-01-01T00:00:00Z", "lev=1000"],
212 |         method="nearest",
213 |     )
214 | 
215 |     single_datetime = datetime(2025, 9, 23, 0, 0, 0, tzinfo=timezone.utc)
216 |     cmr_query_params = {"concept_id": "test_concept", "temporal": single_datetime}
217 | 
218 |     result = dependencies.interpolated_xarray_ds_params(xarray_params, cmr_query_params)
219 | 
220 |     assert result.sel == ["time=2025-01-01T00:00:00Z", "lev=1000"]
221 | 
222 | 
223 | def test_interpolated_xarray_params_no_sel():
224 |     """Test InterpolatedXarrayParams when sel is None or empty."""
225 |     xarray_params = CompatXarrayParams(
226 |         variable="temperature", sel=None, method="nearest"
227 |     )
228 | 
229 |     single_datetime = datetime(2025, 9, 23, 0, 0, 0, tzinfo=timezone.utc)
230 |     cmr_query_params = {"concept_id": "test_concept", "temporal": single_datetime}
231 | 
232 |     result = dependencies.interpolated_xarray_ds_params(xarray_params, cmr_query_params)
233 | 
234 |     assert result.sel is None
235 |     assert result.variable == "temperature"
236 | 
237 | 
238 | def test_interpolated_xarray_params_multiple_templates():
239 |     """Test InterpolatedXarrayParams with multiple datetime templates."""
240 |     xarray_params = CompatXarrayParams(
241 |         variable="temperature",
242 |         sel=["time={datetime}", "start_time={datetime}", "lev=1000"],
243 |         method="nearest",
244 |     )
245 | 
246 |     single_datetime = datetime(2025, 9, 23, 12, 30, 45, tzinfo=timezone.utc)
247 |     cmr_query_params = {"concept_id": "test_concept", "temporal": single_datetime}
248 | 
249 |     result = dependencies.interpolated_xarray_ds_params(xarray_params, cmr_query_params)
250 | 
251 |     expected = [
252 |         f"time={single_datetime.isoformat()}",
253 |         f"start_time={single_datetime.isoformat()}",
254 |         "lev=1000",
255 |     ]
256 |     assert result.sel == expected
257 | 


--------------------------------------------------------------------------------
/titiler/cmr/dependencies.py:
--------------------------------------------------------------------------------
  1 | """titiler-cmr dependencies."""
  2 | 
  3 | from dataclasses import dataclass
  4 | from datetime import datetime
  5 | from typing import Any, Dict, List, Literal, Optional, Union, get_args
  6 | 
  7 | from fastapi import Depends, Query
  8 | from rio_tiler.types import RIOResampling, WarpResampling
  9 | from starlette.requests import Request
 10 | from typing_extensions import Annotated
 11 | 
 12 | from titiler.cmr.enums import MediaType
 13 | from titiler.cmr.utils import parse_datetime
 14 | from titiler.core.dependencies import DefaultDependency
 15 | from titiler.xarray.dependencies import CompatXarrayParams, SelDimStr
 16 | 
 17 | ResponseType = Literal["json", "html"]
 18 | 
 19 | 
 20 | def accept_media_type(accept: str, mediatypes: List[MediaType]) -> Optional[MediaType]:
 21 |     """Return MediaType based on accept header and available mediatype.
 22 | 
 23 |     Links:
 24 |     - https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
 25 |     - https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept
 26 | 
 27 |     """
 28 |     accept_values = {}
 29 |     for m in accept.replace(" ", "").split(","):
 30 |         values = m.split(";")
 31 |         if len(values) == 1:
 32 |             name = values[0]
 33 |             quality = 1.0
 34 |         else:
 35 |             name = values[0]
 36 |             groups = dict([param.split("=") for param in values[1:]])  # type: ignore
 37 |             try:
 38 |                 q = groups.get("q")
 39 |                 quality = float(q) if q else 1.0
 40 |             except ValueError:
 41 |                 quality = 0
 42 | 
 43 |         # if quality is 0 we ignore encoding
 44 |         if quality:
 45 |             accept_values[name] = quality
 46 | 
 47 |     # Create Preference matrix
 48 |     media_preference = {
 49 |         v: [n for (n, q) in accept_values.items() if q == v]
 50 |         for v in sorted(set(accept_values.values()), reverse=True)
 51 |     }
 52 | 
 53 |     # Loop through available compression and encoding preference
 54 |     for _, pref in media_preference.items():
 55 |         for media in mediatypes:
 56 |             if media.value in pref:
 57 |                 return media
 58 | 
 59 |     # If no specified encoding is supported but "*" is accepted,
 60 |     # take one of the available compressions.
 61 |     if "*" in accept_values and mediatypes:
 62 |         return mediatypes[0]
 63 | 
 64 |     return None
 65 | 
 66 | 
 67 | def OutputType(
 68 |     request: Request,
 69 |     f: Annotated[
 70 |         Optional[ResponseType],
 71 |         Query(
 72 |             description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header."
 73 |         ),
 74 |     ] = None,
 75 | ) -> Optional[MediaType]:
 76 |     """Output MediaType: json or html."""
 77 |     if f:
 78 |         return MediaType[f]
 79 | 
 80 |     accepted_media = [MediaType[v] for v in get_args(ResponseType)]
 81 |     return accept_media_type(request.headers.get("accept", ""), accepted_media)
 82 | 
 83 | 
 84 | ConceptID = Annotated[
 85 |     str,
 86 |     Query(
 87 |         description="""A CMR concept id, in the format <concept-type-prefix> <unique-number> '-' <provider-id>
 88 | - concept-type-prefix is a single capital letter prefix indicating the concept type. "C" is used for collections
 89 | - unique-number is a single number assigned by the CMR during ingest.
 90 | - provider-id is the short name for the provider. i.e. "LPDAAC_ECS"
 91 |         """
 92 |     ),
 93 | ]
 94 | 
 95 | 
 96 | def cmr_query(
 97 |     concept_id: ConceptID,
 98 |     datetime: Annotated[
 99 |         Optional[str],
100 |         Query(
101 |             description="Either a date-time or an interval. Date and time expressions adhere to rfc3339 ('2020-06-01T09:00:00Z') format. Intervals may be bounded or half-bounded (double-dots at start or end).",
102 |             openapi_examples={
103 |                 "A date-time": {"value": "2018-02-12T09:00:00Z"},
104 |                 "A bounded interval": {
105 |                     "value": "2018-02-12T09:00:00Z/2018-03-18T09:00:00Z"
106 |                 },
107 |                 "Half-bounded intervals (start)": {"value": "2018-02-12T09:00:00Z/.."},
108 |                 "Half-bounded intervals (end)": {"value": "../2018-03-18T09:00:00Z"},
109 |             },
110 |         ),
111 |     ] = None,
112 | ) -> Dict:
113 |     """CMR Query options."""
114 |     query: Dict[str, Any] = {"concept_id": concept_id}
115 | 
116 |     if datetime:
117 |         datetime_, start, end = parse_datetime(datetime)
118 |         query["temporal"] = datetime_ if datetime_ else (start, end)
119 | 
120 |     return query
121 | 
122 | 
123 | @dataclass
124 | class RasterioParams(DefaultDependency):
125 |     """Rasterio backend parameters"""
126 | 
127 |     indexes: Annotated[
128 |         Optional[List[int]],
129 |         Query(
130 |             title="Band indexes",
131 |             alias="bidx",
132 |             description="Dataset band indexes",
133 |         ),
134 |     ] = None
135 |     expression: Annotated[
136 |         Optional[str],
137 |         Query(
138 |             title="Band Math expression",
139 |             description="rio-tiler's band math expression",
140 |         ),
141 |     ] = None
142 |     bands: Annotated[
143 |         Optional[List[str]],
144 |         Query(
145 |             title="Band names",
146 |             description="Band names.",
147 |         ),
148 |     ] = None
149 |     bands_regex: Annotated[
150 |         Optional[str],
151 |         Query(
152 |             title="Regex expression to parse dataset links",
153 |             description="Regex expression to parse dataset links.",
154 |         ),
155 |     ] = None
156 |     unscale: Annotated[
157 |         Optional[bool],
158 |         Query(
159 |             title="Apply internal Scale/Offset",
160 |             description="Apply internal Scale/Offset. Defaults to `False`.",
161 |         ),
162 |     ] = None
163 |     resampling_method: Annotated[
164 |         Optional[RIOResampling],
165 |         Query(
166 |             alias="resampling",
167 |             description="RasterIO resampling algorithm. Defaults to `nearest`.",
168 |         ),
169 |     ] = None
170 | 
171 | 
172 | # TODO:can we replace this with titiler.xarray.dependencies.DatasetParams?
173 | @dataclass
174 | class ReaderParams(DefaultDependency):
175 |     """Reader parameters"""
176 | 
177 |     backend: Annotated[
178 |         Literal["rasterio", "xarray"],
179 |         Query(description="Backend to read the CMR dataset"),
180 |     ] = "rasterio"
181 |     nodata: Annotated[
182 |         Optional[Union[str, int, float]],
183 |         Query(
184 |             title="Nodata value",
185 |             description="Overwrite internal Nodata value",
186 |         ),
187 |     ] = None
188 |     reproject_method: Annotated[
189 |         Optional[WarpResampling],
190 |         Query(
191 |             alias="reproject",
192 |             description="WarpKernel resampling algorithm (only used when doing re-projection). Defaults to `nearest`.",
193 |         ),
194 |     ] = None
195 | 
196 | 
197 | @dataclass
198 | class InterpolatedXarrayParams(CompatXarrayParams):
199 |     """Modified version of CompatXarrayParms that describes {datetime} interpolation."""
200 | 
201 |     sel: Annotated[
202 |         Optional[List[SelDimStr]],
203 |         Query(
204 |             description="Xarray Indexing using dimension names `{dimension}={value}`."
205 |             " If value is {datetime}, it will be interpolated from the datetime query parameter.",
206 |         ),
207 |     ] = None
208 | 
209 | 
210 | def interpolated_xarray_ds_params(
211 |     xarray_params: InterpolatedXarrayParams = Depends(InterpolatedXarrayParams),
212 |     cmr_query_params: Dict = Depends(cmr_query),
213 | ) -> InterpolatedXarrayParams:
214 |     """
215 |     Xarray parameters with string interpolation support for the sel parameter.
216 | 
217 |     Interpolates {datetime} templates in sel parameter values with the actual
218 |     datetime value from the request in ISO format (e.g., 2025-09-23T00:00:00Z).
219 | 
220 |     Example:
221 |         datetime=2025-09-23&sel=time={datetime} → sel=time=2025-09-23T00:00:00Z
222 |     """
223 |     if not xarray_params.sel:
224 |         return xarray_params
225 | 
226 |     temporal = cmr_query_params["temporal"]
227 |     dt = temporal if isinstance(temporal, datetime) else temporal[0]
228 | 
229 |     interpolated_sel = []
230 |     for sel_item in xarray_params.sel:
231 |         if isinstance(sel_item, str) and "{datetime}" in sel_item:
232 |             interpolated_sel.append(sel_item.format(datetime=dt.isoformat()))
233 |         else:
234 |             interpolated_sel.append(sel_item)
235 | 
236 |     # Create a new instance with interpolated sel values
237 |     return InterpolatedXarrayParams(
238 |         variable=xarray_params.variable,
239 |         group=xarray_params.group,
240 |         sel=interpolated_sel,
241 |         method=xarray_params.method,
242 |         decode_times=xarray_params.decode_times,
243 |     )
244 | 


--------------------------------------------------------------------------------
/tests/test_hls_benchmark.py:
--------------------------------------------------------------------------------
  1 | """Benchmarks for HLS tile requests"""
  2 | 
  3 | import asyncio
  4 | from datetime import datetime, timedelta
  5 | from typing import Any, Dict, List, NamedTuple, Tuple
  6 | 
  7 | import httpx
  8 | import morecantile
  9 | import pytest
 10 | 
 11 | ENDPOINT = "https://staging.openveda.cloud/api/titiler-cmr"
 12 | TMS = morecantile.tms.get("WebMercatorQuad")
 13 | TEST_LNG, TEST_LAT = -92.1, 46.8
 14 | TILES_HEIGHT = 5
 15 | TILES_WIDTH = 5
 16 | 
 17 | 
 18 | class CollectionConfig(NamedTuple):
 19 |     """Configuration for a collection"""
 20 | 
 21 |     collection_id: str
 22 |     concept_id: str
 23 |     base_date: datetime
 24 | 
 25 |     # band configurations
 26 |     rgb_bands: List[str]
 27 |     ndvi_bands: Tuple[str, str]  # (red_band, nir_band)
 28 |     single_band: str
 29 | 
 30 | 
 31 | LANDSAT = CollectionConfig(
 32 |     collection_id="HLSL30",
 33 |     concept_id="C2021957657-LPCLOUD",
 34 |     base_date=datetime(2023, 2, 24, 0, 0, 1),
 35 |     rgb_bands=["B04", "B03", "B02"],
 36 |     ndvi_bands=("B04", "B05"),
 37 |     single_band="B04",
 38 | )
 39 | 
 40 | SENTINEL = CollectionConfig(
 41 |     collection_id="HLSS30",
 42 |     concept_id="C2021957295-LPCLOUD",
 43 |     base_date=datetime(2023, 2, 13, 0, 0, 1),
 44 |     rgb_bands=["B04", "B03", "B02"],
 45 |     ndvi_bands=("B04", "B8A"),
 46 |     single_band="B04",
 47 | )
 48 | 
 49 | COLLECTIONS = {
 50 |     "HLSL30": LANDSAT,
 51 |     "HLSS30": SENTINEL,
 52 | }
 53 | 
 54 | # test parameters
 55 | ZOOM_LEVELS = [6, 7, 8, 9, 10]
 56 | INTERVAL_DAYS = [1, 7]
 57 | N_BANDS = [1, 2, 3]
 58 | 
 59 | 
 60 | def get_surrounding_tiles(
 61 |     x: int, y: int, zoom: int, width: int = TILES_WIDTH, height: int = TILES_HEIGHT
 62 | ) -> List[Tuple[int, int]]:
 63 |     """Get a list of surrounding tiles for a viewport"""
 64 |     tiles = []
 65 |     offset_x = width // 2
 66 |     offset_y = height // 2
 67 | 
 68 |     for y_pos in range(y - offset_y, y + offset_y + 1):
 69 |         for x_pos in range(x - offset_x, x + offset_x + 1):
 70 |             # Ensure x, y are valid for the zoom level
 71 |             max_tile = 2**zoom - 1
 72 |             x_valid = max(0, min(x_pos, max_tile))
 73 |             y_valid = max(0, min(y_pos, max_tile))
 74 |             tiles.append((x_valid, y_valid))
 75 | 
 76 |     return tiles
 77 | 
 78 | 
 79 | def get_band_params(
 80 |     collection_config: CollectionConfig, n_bands: int
 81 | ) -> Dict[str, Any]:
 82 |     """Get band-specific parameters based on collection and band count"""
 83 |     params: Dict[str, Any] = {
 84 |         "backend": "rasterio",
 85 |         "bands_regex": "B[0-9][0-9]",
 86 |     }
 87 | 
 88 |     if n_bands == 3:
 89 |         # RGB visualization
 90 |         params["color_formula"] = "Gamma RGB 3.5 Saturation 1.7 Sigmoidal RGB 15 0.35"
 91 |         params["bands"] = collection_config.rgb_bands
 92 |     elif n_bands == 2:
 93 |         # NDVI visualization
 94 |         red_band, nir_band = collection_config.ndvi_bands
 95 |         params["bands"] = [red_band, nir_band]
 96 |         params["expression"] = f"({nir_band}-{red_band})/({nir_band}+{red_band})"
 97 |         params["colormap_name"] = "greens"
 98 |         params["rescale"] = "-1,1"
 99 |     elif n_bands == 1:
100 |         # Single band visualization
101 |         params["bands"] = [collection_config.single_band]
102 |         params["colormap_name"] = "viridis"
103 |         params["rescale"] = "0,5000"
104 | 
105 |     return params
106 | 
107 | 
108 | async def fetch_tile(
109 |     client: httpx.AsyncClient,
110 |     endpoint: str,
111 |     z: int,
112 |     x: int,
113 |     y: int,
114 |     collection_config: CollectionConfig,
115 |     interval_days: int,
116 |     n_bands: int,
117 | ) -> httpx.Response:
118 |     """Fetch a single HLS tile"""
119 |     url = f"{endpoint}/tiles/WebMercatorQuad/{z}/{x}/{y}.png"
120 | 
121 |     start_date = collection_config.base_date
122 |     end_date = start_date + timedelta(days=interval_days)
123 |     datetime_range = f"{start_date.isoformat()}/{end_date.isoformat()}"
124 | 
125 |     params: Dict[str, Any] = {
126 |         "concept_id": collection_config.concept_id,
127 |         "datetime": datetime_range,
128 |     }
129 | 
130 |     params.update(get_band_params(collection_config, n_bands))
131 | 
132 |     start_time = datetime.now()
133 |     try:
134 |         response = await client.get(url, params=params, timeout=30.0)
135 |         response.raise_for_status()
136 |         elapsed = (datetime.now() - start_time).total_seconds()
137 | 
138 |         response.elapsed = timedelta(seconds=elapsed)
139 |         return response
140 |     except Exception:
141 |         # Create a mock response for exceptions
142 |         mock_response = httpx.Response(500, request=httpx.Request("GET", url))
143 |         mock_response.elapsed = datetime.now() - start_time
144 |         return mock_response
145 | 
146 | 
147 | async def fetch_viewport_tiles(
148 |     endpoint: str,
149 |     collection_config: CollectionConfig,
150 |     zoom: int,
151 |     lng: float,
152 |     lat: float,
153 |     interval_days: int,
154 |     n_bands: int,
155 | ) -> List[Dict]:
156 |     """Fetch all tiles for a viewport and return detailed metrics"""
157 |     tile = TMS.tile(lng=lng, lat=lat, zoom=zoom)
158 |     tiles = get_surrounding_tiles(tile.x, tile.y, zoom)
159 | 
160 |     results = []
161 | 
162 |     async with httpx.AsyncClient() as client:
163 |         tasks = [
164 |             fetch_tile(
165 |                 client,
166 |                 endpoint,
167 |                 zoom,
168 |                 x,
169 |                 y,
170 |                 collection_config,
171 |                 interval_days,
172 |                 n_bands,
173 |             )
174 |             for x, y in tiles
175 |         ]
176 |         responses = await asyncio.gather(*tasks)
177 | 
178 |         for (x, y), response in zip(tiles, responses):
179 |             # Capture detailed metrics for each tile
180 |             results.append(
181 |                 {
182 |                     "x": x,
183 |                     "y": y,
184 |                     "status_code": response.status_code,
185 |                     "response_time": response.elapsed.total_seconds(),
186 |                     "response_size": len(response.content)
187 |                     if hasattr(response, "content")
188 |                     else 0,
189 |                     "has_data": response.status_code == 200,  # 204 means no data
190 |                     "is_error": response.status_code >= 400,
191 |                 }
192 |             )
193 | 
194 |     return results
195 | 
196 | 
197 | @pytest.fixture(scope="session", autouse=True)
198 | def warm_up_api():
199 |     """Perform a single warmup request to the API before all tests."""
200 |     asyncio.run(
201 |         fetch_viewport_tiles(
202 |             endpoint=ENDPOINT,
203 |             collection_config=LANDSAT,
204 |             zoom=8,
205 |             lng=TEST_LNG,
206 |             lat=TEST_LAT,
207 |             interval_days=1,
208 |             n_bands=3,
209 |         )
210 |     )
211 | 
212 | 
213 | @pytest.mark.benchmark(
214 |     group="hls-tiles",
215 |     min_rounds=2,
216 |     warmup=False,
217 | )
218 | @pytest.mark.parametrize("collection_id", list(COLLECTIONS.keys()))
219 | @pytest.mark.parametrize("zoom", ZOOM_LEVELS)
220 | @pytest.mark.parametrize("interval_days", INTERVAL_DAYS)
221 | @pytest.mark.parametrize("n_bands", N_BANDS)
222 | def test_hls_tiles(
223 |     benchmark,
224 |     collection_id: str,
225 |     zoom: int,
226 |     interval_days: int,
227 |     n_bands: int,
228 | ):
229 |     """Test HLS tile performance with various parameters"""
230 |     collection_config = COLLECTIONS[collection_id]
231 | 
232 |     def tile_benchmark():
233 |         # Run the async function in a synchronous context
234 |         results = asyncio.run(
235 |             fetch_viewport_tiles(
236 |                 endpoint=ENDPOINT,
237 |                 collection_config=collection_config,
238 |                 zoom=zoom,
239 |                 lng=TEST_LNG,
240 |                 lat=TEST_LAT,
241 |                 interval_days=interval_days,
242 |                 n_bands=n_bands,
243 |             )
244 |         )
245 |         return results
246 | 
247 |     # Run the benchmark
248 |     results = benchmark(tile_benchmark)
249 | 
250 |     # Calculate summary statistics
251 |     total_tiles = len(results)
252 |     success_count = sum(1 for r in results if r["has_data"])
253 |     no_data_count = sum(1 for r in results if r["status_code"] == 204)
254 |     error_count = sum(1 for r in results if r["is_error"])
255 | 
256 |     avg_response_time = (
257 |         sum(r["response_time"] for r in results) / total_tiles if total_tiles else 0
258 |     )
259 |     avg_response_size = (
260 |         sum(r["response_size"] for r in results if r["has_data"]) / success_count
261 |         if success_count
262 |         else 0
263 |     )
264 | 
265 |     # Add detailed metrics to the benchmark results
266 |     benchmark.extra_info.update(
267 |         {
268 |             "collection": collection_id,
269 |             "zoom": zoom,
270 |             "interval_days": interval_days,
271 |             "band_count": n_bands,
272 |             "total_tiles": total_tiles,
273 |             "success_count": success_count,
274 |             "no_data_count": no_data_count,
275 |             "error_count": error_count,
276 |             "success_rate": success_count / total_tiles if total_tiles else 0,
277 |             "avg_response_time": avg_response_time,
278 |             "avg_response_size": avg_response_size,
279 |         }
280 |     )
281 | 


--------------------------------------------------------------------------------
/tests/test_timeseries.py:
--------------------------------------------------------------------------------
  1 | """Test timeseries module"""
  2 | 
  3 | from collections.abc import Callable
  4 | from datetime import datetime
  5 | 
  6 | import pytest
  7 | from fastapi import HTTPException
  8 | from freezegun import freeze_time
  9 | 
 10 | from titiler.cmr.timeseries import (
 11 |     TemporalMode,
 12 |     TimeseriesParams,
 13 |     generate_datetime_ranges,
 14 |     timeseries_cmr_query,
 15 | )
 16 | 
 17 | 
 18 | def test_generate_datetime_ranges():
 19 |     """Test datetime ranges"""
 20 |     start = datetime(2023, 1, 1)
 21 |     end = datetime(2023, 12, 31, 23, 59, 59)
 22 | 
 23 |     # Test yearly ranges
 24 |     yearly_ranges = generate_datetime_ranges(start, end, "P1Y")
 25 |     assert len(yearly_ranges) == 1
 26 |     assert yearly_ranges[0] == (
 27 |         datetime(2023, 1, 1),
 28 |         datetime(2023, 12, 31, 23, 59, 59),
 29 |     )
 30 | 
 31 |     # Test monthly ranges
 32 |     monthly_ranges = generate_datetime_ranges(start, end, "P1M")
 33 |     assert len(monthly_ranges) == 12
 34 |     assert monthly_ranges[0] == (
 35 |         datetime(2023, 1, 1),
 36 |         datetime(2023, 1, 31, 23, 59, 59),
 37 |     )
 38 |     assert monthly_ranges[-1] == (
 39 |         datetime(2023, 12, 1),
 40 |         datetime(2023, 12, 31, 23, 59, 59),
 41 |     )
 42 | 
 43 |     # Test daily ranges
 44 |     daily_ranges = generate_datetime_ranges(
 45 |         start, datetime(2023, 1, 5, 23, 59, 59), "P1D"
 46 |     )
 47 |     assert len(daily_ranges) == 5
 48 |     assert daily_ranges[0] == (datetime(2023, 1, 1), datetime(2023, 1, 1, 23, 59, 59))
 49 |     assert daily_ranges[-1] == (datetime(2023, 1, 5), datetime(2023, 1, 5, 23, 59, 59))
 50 | 
 51 |     # Test hourly ranges
 52 |     hourly_ranges = generate_datetime_ranges(start, datetime(2023, 1, 1, 5), "PT1H")
 53 |     assert len(hourly_ranges) == 5
 54 |     assert hourly_ranges[0] == (
 55 |         datetime(2023, 1, 1, 0),
 56 |         datetime(2023, 1, 1, 0, 59, 59),
 57 |     )
 58 |     assert hourly_ranges[-1] == (datetime(2023, 1, 1, 4), datetime(2023, 1, 1, 5))
 59 | 
 60 |     # Test when start and end are the same
 61 |     same_time_ranges = generate_datetime_ranges(start, start, "P1D")
 62 |     assert len(same_time_ranges) == 1
 63 |     assert same_time_ranges[0] == (start, start)
 64 | 
 65 |     # Test when step is larger than the range
 66 |     large_step_ranges = generate_datetime_ranges(start, datetime(2023, 1, 2), "P1Y")
 67 |     assert len(large_step_ranges) == 1
 68 |     assert large_step_ranges[0] == (start, datetime(2023, 1, 2))
 69 | 
 70 |     # Test point-in-time mode
 71 |     exact_end_datetime = datetime(2023, 5, 1)
 72 |     exact_ranges = generate_datetime_ranges(
 73 |         start, exact_end_datetime, "P1M", temporal_mode=TemporalMode.point
 74 |     )
 75 |     assert len(exact_ranges) == 5
 76 |     assert exact_ranges[-1] == (exact_end_datetime,)
 77 | 
 78 |     exact_end_datetime = datetime(2023, 10, 25)
 79 |     exact_ranges = generate_datetime_ranges(
 80 |         start, exact_end_datetime, "P1W", temporal_mode=TemporalMode.point
 81 |     )
 82 |     assert len(exact_ranges) == 43
 83 | 
 84 | 
 85 | def test_generate_datetime_ranges_edge_cases():
 86 |     """Test datetime edge cases"""
 87 |     start = datetime(2023, 1, 1)
 88 |     end = datetime(2023, 12, 31, 23, 59, 59)
 89 | 
 90 |     # Test with a very small step
 91 |     small_step_ranges = generate_datetime_ranges(
 92 |         start, datetime(2023, 1, 1, 0, 0, 1, 999999), "PT1S"
 93 |     )
 94 |     assert len(small_step_ranges) == 2
 95 |     assert small_step_ranges[0] == (
 96 |         datetime(2023, 1, 1, 0, 0, 0),
 97 |         datetime(2023, 1, 1, 0, 0, 0, 999999),
 98 |     )
 99 |     assert small_step_ranges[1] == (
100 |         datetime(2023, 1, 1, 0, 0, 1),
101 |         datetime(2023, 1, 1, 0, 0, 1, 999999),
102 |     )
103 | 
104 |     # Test with a step that doesn't divide evenly into the range
105 |     uneven_ranges = generate_datetime_ranges(start, datetime(2023, 1, 11), "P3D")
106 |     assert len(uneven_ranges) == 4
107 |     assert uneven_ranges[-1] == (
108 |         datetime(2023, 1, 10),
109 |         datetime(2023, 1, 11),
110 |     )
111 | 
112 |     # Test with a very large step
113 |     large_step_ranges = generate_datetime_ranges(start, end, "P10Y")
114 |     assert len(large_step_ranges) == 1
115 |     assert large_step_ranges[0] == (start, end)
116 | 
117 | 
118 | def test_generate_datetime_ranges_small_timesteps():
119 |     """Test small datetime steps"""
120 |     start = datetime(2023, 1, 1, 0, 0, 0)
121 | 
122 |     # Test with 1-second step
123 |     one_second_ranges = generate_datetime_ranges(
124 |         start, datetime(2023, 1, 1, 0, 0, 1, 999999), "PT1S"
125 |     )
126 |     assert len(one_second_ranges) == 2
127 |     assert one_second_ranges[0] == (
128 |         datetime(2023, 1, 1, 0, 0, 0),
129 |         datetime(2023, 1, 1, 0, 0, 0, 999999),  # 999000 microseconds = 999 milliseconds
130 |     )
131 |     assert one_second_ranges[1] == (
132 |         datetime(2023, 1, 1, 0, 0, 1),
133 |         datetime(2023, 1, 1, 0, 0, 1, 999999),
134 |     )
135 | 
136 |     # Test with 500-millisecond step
137 |     half_second_ranges = generate_datetime_ranges(
138 |         start, datetime(2023, 1, 1, 0, 0, 1), "PT0.5S"
139 |     )
140 |     assert len(half_second_ranges) == 2
141 |     assert half_second_ranges[0] == (
142 |         datetime(2023, 1, 1, 0, 0, 0),
143 |         datetime(2023, 1, 1, 0, 0, 0, 499999),  # 499000 microseconds = 499 milliseconds
144 |     )
145 |     assert half_second_ranges[1] == (
146 |         datetime(2023, 1, 1, 0, 0, 0, 500000),  # 500000 microseconds = 500 milliseconds
147 |         datetime(2023, 1, 1, 0, 0, 1),
148 |     )
149 | 
150 |     # Test with larger step to ensure it still subtracts 1 second
151 |     larger_step_ranges = generate_datetime_ranges(
152 |         start, datetime(2023, 1, 1, 0, 1, 0), "PT30S"
153 |     )
154 |     assert len(larger_step_ranges) == 2
155 |     assert larger_step_ranges[0] == (
156 |         datetime(2023, 1, 1, 0, 0, 0),
157 |         datetime(2023, 1, 1, 0, 0, 29),  # Still subtracting 1 second
158 |     )
159 | 
160 | 
161 | @pytest.mark.vcr
162 | def test_timeseries_query(
163 |     xarray_query_params: Callable[..., dict[str, str]],
164 |     arctic_bounds: tuple[float, float, float, float],
165 | ) -> None:
166 |     """Test timeseries_query"""
167 |     start_datetime, end_datetime = xarray_query_params()["datetime"].split("/")
168 |     query = timeseries_cmr_query(
169 |         concept_id=xarray_query_params()["concept_id"],
170 |         timeseries_params=TimeseriesParams(
171 |             datetime=xarray_query_params()["datetime"],
172 |             step="P1D",
173 |         ),
174 |     )
175 |     assert len(query) == 1
176 | 
177 |     query = timeseries_cmr_query(
178 |         concept_id=xarray_query_params()["concept_id"],
179 |         timeseries_params=TimeseriesParams(
180 |             datetime=xarray_query_params()["datetime"],
181 |             step="PT1H",
182 |         ),
183 |     )
184 |     assert len(query) == 24
185 | 
186 |     query = timeseries_cmr_query(
187 |         concept_id=xarray_query_params()["concept_id"],
188 |         timeseries_params=TimeseriesParams(
189 |             datetime=f"{start_datetime}/2024-10-31T23:59:59Z",
190 |             step="P1W",
191 |         ),
192 |     )
193 |     assert len(query) == 3
194 | 
195 |     # no step parameter will force a CMR query to get unique
196 |     # datetimes from available granules
197 |     query = timeseries_cmr_query(
198 |         concept_id=xarray_query_params()["concept_id"],
199 |         timeseries_params=TimeseriesParams(
200 |             datetime=xarray_query_params()["datetime"],
201 |         ),
202 |     )
203 |     assert len(query) == 1
204 | 
205 |     # query CMR to get the actual timesteps from a collection
206 |     geographically_limited_concept_id = "C2623694361-GES_DISC"
207 |     query = timeseries_cmr_query(
208 |         concept_id=geographically_limited_concept_id,
209 |         timeseries_params=TimeseriesParams(
210 |             datetime=xarray_query_params()["datetime"],
211 |         ),
212 |         minx=-100,
213 |         miny=30,
214 |         maxx=-90,
215 |         maxy=40,
216 |     )
217 |     assert len(query) == 8
218 | 
219 |     # run a bbox query that returns no granules
220 |     query = timeseries_cmr_query(
221 |         concept_id=geographically_limited_concept_id,
222 |         timeseries_params=TimeseriesParams(
223 |             datetime=xarray_query_params()["datetime"],
224 |         ),
225 |         minx=1,
226 |         miny=1,
227 |         maxx=1,
228 |         maxy=1,
229 |     )
230 |     assert len(query) == 0
231 | 
232 | 
233 | @freeze_time("2024-10-01T00:00:00Z")
234 | def test_timeseries_query_unbounded_intervals(
235 |     xarray_query_params: Callable[..., dict[str, str]],
236 |     arctic_bounds: tuple[float, float, float, float],
237 | ) -> None:
238 |     """Test unbounded intervals"""
239 |     # expect an error if an interval is provided with an unbounded start datetime
240 |     with pytest.raises(HTTPException):
241 |         timeseries_cmr_query(
242 |             concept_id=xarray_query_params()["concept_id"],
243 |             timeseries_params=TimeseriesParams(
244 |                 datetime="../2024-01-01T00:00:00Z",
245 |                 step="P1W",
246 |             ),
247 |         )
248 | 
249 |     unbounded_query = timeseries_cmr_query(
250 |         concept_id=xarray_query_params()["concept_id"],
251 |         timeseries_params=TimeseriesParams(
252 |             datetime="2024-01-01T00:00:00Z/..",
253 |             step="P1W",
254 |         ),
255 |     )
256 | 
257 |     assert len(unbounded_query) == 40
258 | 
259 | 
260 | def test_timeseries_mixed_datetime(
261 |     xarray_query_params: Callable[..., dict[str, str]],
262 |     arctic_bounds: tuple[float, float, float, float],
263 | ) -> None:
264 |     """Test comma-separated mixed points and intervals"""
265 |     mixed_query = timeseries_cmr_query(
266 |         concept_id=xarray_query_params()["concept_id"],
267 |         timeseries_params=TimeseriesParams(
268 |             datetime="2023-01-01T00:00:00Z,2024-01-01T00:00:00Z/2024-01-05T00:00:00Z",
269 |             step="P1D",
270 |             temporal_mode=TemporalMode.point,
271 |         ),
272 |     )
273 |     assert len(mixed_query) == 6
274 | 


--------------------------------------------------------------------------------
/titiler/cmr/compatibility.py:
--------------------------------------------------------------------------------
  1 | """titiler.cmr.compatibility: Compatibility testing utilities."""
  2 | 
  3 | from typing import Any, Dict, List, Literal, Optional
  4 | 
  5 | import numpy as np
  6 | from fastapi import HTTPException
  7 | from pydantic import BaseModel
  8 | from rio_tiler.constants import WEB_MERCATOR_TMS
  9 | from rio_tiler.io.rasterio import Reader
 10 | from rio_tiler.models import Info
 11 | from starlette.requests import Request
 12 | 
 13 | from titiler.cmr.backend import CMRBackend
 14 | from titiler.cmr.dependencies import ConceptID
 15 | from titiler.cmr.logger import logger
 16 | from titiler.cmr.reader import xarray_open_dataset
 17 | from titiler.cmr.settings import AuthSettings
 18 | from titiler.cmr.utils import get_concept_id_umm
 19 | from titiler.xarray.io import Reader as XarrayReader
 20 | 
 21 | 
 22 | class VariableInfo(BaseModel):
 23 |     """Metadata for a single xarray variable"""
 24 | 
 25 |     shape: List[int]
 26 |     dtype: str
 27 |     min: Optional[float] = None
 28 |     max: Optional[float] = None
 29 |     mean: Optional[float] = None
 30 |     p01: Optional[float] = None
 31 |     p05: Optional[float] = None
 32 |     p95: Optional[float] = None
 33 |     p99: Optional[float] = None
 34 | 
 35 | 
 36 | class CoordinateInfo(BaseModel):
 37 |     """Metadata for a single xarray coordinate"""
 38 | 
 39 |     size: int
 40 |     dtype: str
 41 |     min: Optional[float] = None
 42 |     max: Optional[float] = None
 43 | 
 44 | 
 45 | class CompatibilityResponse(BaseModel):
 46 |     """Compatibility endpoint response model"""
 47 | 
 48 |     concept_id: ConceptID
 49 |     backend: Literal["rasterio", "xarray"]
 50 |     datetime: List[Dict[str, Any]]
 51 |     variables: Optional[Dict[str, VariableInfo]] = None
 52 |     dimensions: Optional[Dict[str, int]] = None
 53 |     coordinates: Optional[Dict[str, CoordinateInfo]] = None
 54 |     example_assets: Optional[Dict[str, str] | str] = None
 55 |     sample_asset_raster_info: Optional[Info] = None
 56 | 
 57 | 
 58 | def extract_xarray_metadata(
 59 |     ds: Any, max_sample_size: float = 100_000.0
 60 | ) -> Dict[str, Any]:
 61 |     """Extract comprehensive metadata from an xarray Dataset.
 62 | 
 63 |     For large arrays, uses sampling along each dimension to avoid memory issues.
 64 | 
 65 |     Args:
 66 |         ds: xarray Dataset instance
 67 |         max_sample_size: Maximum number of elements to sample for statistics.
 68 |             Arrays larger than this will be sampled. Default: 1,000,000
 69 | 
 70 |     Returns:
 71 |         Dictionary containing variables, dimensions, and coordinates metadata
 72 |     """
 73 |     variables = {}
 74 |     for var in ds.data_vars:
 75 |         var_info: Dict[str, Any] = {
 76 |             "shape": list(ds[var].shape),
 77 |             "dtype": str(ds[var].dtype),
 78 |         }
 79 | 
 80 |         if ds[var].dtype.kind in ["i", "f", "u"]:
 81 |             try:
 82 |                 var_data = ds[var]
 83 |                 total_size = var_data.size
 84 | 
 85 |                 # Use sampling for large arrays to avoid memory issues
 86 |                 if total_size > max_sample_size:
 87 |                     # Calculate exact sample size per dimension to stay within budget
 88 |                     indexers = {}
 89 |                     actual_sample_size = 1
 90 |                     remaining_budget = max_sample_size
 91 | 
 92 |                     for i, dim in enumerate(var_data.dims):
 93 |                         dim_size = var_data.sizes[dim]
 94 |                         # Distribute budget across remaining dimensions
 95 |                         dims_remaining = len(var_data.dims) - i
 96 |                         samples_per_dim = int(
 97 |                             remaining_budget ** (1.0 / dims_remaining)
 98 |                         )
 99 |                         sample_size = min(dim_size, max(1, samples_per_dim))
100 | 
101 |                         # Random sample of indices along this dimension
102 |                         indices = np.sort(
103 |                             np.random.choice(dim_size, size=sample_size, replace=False)
104 |                         )
105 |                         indexers[dim] = indices
106 |                         actual_sample_size *= sample_size
107 |                         remaining_budget = max_sample_size / actual_sample_size
108 | 
109 |                     # Sample using integer indexing (efficient with chunked data)
110 |                     sampled = var_data.isel(indexers)
111 |                     values = sampled.values
112 | 
113 |                     logger.info(
114 |                         f"Sampled {actual_sample_size:,} of {total_size:,} elements "
115 |                         f"from variable '{var}' for statistics"
116 |                     )
117 |                 else:
118 |                     # Load entire array for smaller datasets
119 |                     values = var_data.values
120 | 
121 |                 var_info["min"] = float(np.nanmin(values))
122 |                 var_info["max"] = float(np.nanmax(values))
123 |                 var_info["mean"] = float(np.nanmean(values))
124 | 
125 |                 # Calculate multiple percentiles in a single pass, filtering out NaNs
126 |                 p01, p05, p95, p99 = np.nanpercentile(values, [1, 5, 95, 99])
127 |                 var_info["p01"] = float(p01)
128 |                 var_info["p05"] = float(p05)
129 |                 var_info["p95"] = float(p95)
130 |                 var_info["p99"] = float(p99)
131 |             except Exception:
132 |                 # Skip statistics if computation fails (e.g., too large, all NaN values)
133 |                 pass
134 | 
135 |         variables[var] = var_info
136 | 
137 |     coordinates = {}
138 |     for coord, coord_data in ds.coords.items():
139 |         coord_info = {
140 |             "size": int(coord_data.size),
141 |             "dtype": str(coord_data.dtype),
142 |         }
143 | 
144 |         if coord_data.dtype.kind in ["i", "f", "u"]:
145 |             try:
146 |                 coord_info["min"] = float(coord_data.min())
147 |                 coord_info["max"] = float(coord_data.max())
148 |             except Exception:
149 |                 pass
150 |         coordinates[coord] = coord_info
151 | 
152 |     return {
153 |         "variables": variables,
154 |         "dimensions": dict(ds.dims),
155 |         "coordinates": coordinates,
156 |         "backend": "xarray",
157 |     }
158 | 
159 | 
160 | def evaluate_xarray_compatibility(
161 |     concept_id: ConceptID,
162 |     request: Request,
163 |     s3_auth_config: AuthSettings,
164 | ) -> Dict[str, Any]:
165 |     """Test XarrayReader compatibility with a concept.
166 | 
167 |     Args:
168 |         concept_id: CMR concept ID to test
169 |         request: FastAPI request object
170 |         s3_auth_config: S3 authentication configuration
171 | 
172 |     Returns:
173 |         Dictionary with xarray compatibility information
174 | 
175 |     Raises:
176 |         ValueError: If no assets found or reader incompatible
177 |         HTTPException: If CMR query fails
178 |         OSError: If file access fails
179 |         KeyError: If expected data structure is missing
180 |     """
181 |     logger.info("Testing XarrayReader")
182 | 
183 |     with CMRBackend(
184 |         tms=WEB_MERCATOR_TMS,
185 |         reader=XarrayReader,
186 |         reader_options={},
187 |         auth=request.app.state.cmr_auth,
188 |     ) as src_dst:
189 |         assets = src_dst.assets_for_tile(
190 |             0,
191 |             0,
192 |             0,
193 |             limit=1,
194 |             concept_id=concept_id,
195 |             access=s3_auth_config.access,
196 |         )
197 | 
198 |         if not assets:
199 |             raise ValueError("No assets found for XarrayReader")
200 | 
201 |         with xarray_open_dataset(assets[0]["url"]) as ds:
202 |             result = extract_xarray_metadata(ds)
203 |             result["example_assets"] = assets[0]["url"]
204 |             return result
205 | 
206 | 
207 | def evaluate_rasterio_compatibility(
208 |     concept_id: ConceptID,
209 |     request: Request,
210 |     s3_auth_config: AuthSettings,
211 | ) -> Dict[str, Any]:
212 |     """Test MultiFilesBandsReader compatibility with a concept.
213 | 
214 |     Args:
215 |         concept_id: CMR concept ID to test
216 |         request: FastAPI request object
217 |         s3_auth_config: S3 authentication configuration
218 | 
219 |     Returns:
220 |         Dictionary with rasterio compatibility information
221 | 
222 |     Raises:
223 |         ValueError: If no assets found or reader incompatible
224 |         HTTPException: If CMR query fails
225 |         OSError: If file access fails
226 |         KeyError: If expected data structure is missing
227 |     """
228 |     logger.info("Testing MultiFilesBandsReader")
229 | 
230 |     with CMRBackend(
231 |         tms=WEB_MERCATOR_TMS,
232 |         reader=Reader,
233 |         reader_options={"bands": [1]},
234 |         auth=request.app.state.cmr_auth,
235 |     ) as src_dst:
236 |         assets = src_dst.assets_for_tile(
237 |             0,
238 |             0,
239 |             0,
240 |             limit=1,
241 |             concept_id=concept_id,
242 |             access=s3_auth_config.access,
243 |             bands_regex=".*",
244 |         )
245 | 
246 |         if not assets:
247 |             raise ValueError("No assets found for MultiFilesBandsReader")
248 | 
249 |         example_assets: Dict[str, str] = assets[0]["url"]
250 | 
251 |         with src_dst.reader(
252 |             input=list(example_assets.values())[0], tms=src_dst.tms
253 |         ) as _src_dst:
254 |             info = _src_dst.info()
255 | 
256 |         return {
257 |             "example_assets": example_assets,
258 |             "sample_asset_raster_info": info,
259 |             "backend": "rasterio",
260 |         }
261 | 
262 | 
263 | def evaluate_concept_compatibility(
264 |     concept_id: ConceptID,
265 |     request: Request,
266 |     s3_auth_config: AuthSettings,
267 | ) -> CompatibilityResponse:
268 |     """Test which reader backend is compatible with a CMR concept.
269 | 
270 |     Tries XarrayReader first, falls back to MultiFilesBandsReader.
271 |     Also fetches and includes CMR metadata in the response.
272 | 
273 |     Args:
274 |         concept_id: CMR concept ID to test
275 |         request: FastAPI request object
276 |         s3_auth_config: S3 authentication configuration
277 | 
278 |     Returns:
279 |         CompatibilityResponse with backend info, temporal extent, and metadata
280 | 
281 |     Raises:
282 |         HTTPException: If neither reader is compatible or metadata cannot be fetched
283 |     """
284 | 
285 |     metadata = get_concept_id_umm(concept_id)
286 |     temporal_extent = metadata["umm"]["TemporalExtents"]
287 | 
288 |     # Try xarray first
289 |     try:
290 |         result = evaluate_xarray_compatibility(concept_id, request, s3_auth_config)
291 |         return CompatibilityResponse(
292 |             concept_id=concept_id,
293 |             datetime=temporal_extent,
294 |             **result,
295 |         )
296 |     except (ValueError, HTTPException, OSError, KeyError) as e:
297 |         logger.warning(f"XarrayReader failed: {e}")
298 | 
299 |     # Fall back to rasterio
300 |     try:
301 |         result = evaluate_rasterio_compatibility(concept_id, request, s3_auth_config)
302 |         return CompatibilityResponse(
303 |             concept_id=concept_id,
304 |             datetime=temporal_extent,
305 |             **result,
306 |         )
307 |     except (ValueError, HTTPException, OSError, KeyError) as e:
308 |         logger.warning(f"MultiFilesBandsReader failed: {e}")
309 | 
310 |     # Both failed
311 |     raise HTTPException(400, f"cannot parse concept_id {concept_id}")
312 | 


--------------------------------------------------------------------------------
/titiler/cmr/templates/header.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <title>{{ template.title }}</title>
 5 |     <meta charset="utf-8" />
 6 |     <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no" />
 7 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.5.3/css/bootstrap.min.css" />
 8 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.7.1/leaflet.css" />
 9 |     <style>
10 |       html { position: relative; min-height: 100%; }
11 |       body { padding-top: 5rem; margin-bottom: 40px; }
12 |       #page { padding: 1.5rem 1.5rem; }
13 |       .navbar { border-bottom: 8px solid #3333A4; }
14 |       .navbar-brand { font-size: 2rem; color: #3333A4 !important; text-shadow: 2px 2px 4px #ccc; }
15 |       .json-link { font-weight: normal; }
16 |     </style>
17 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.min.js"></script>
18 |     <script src="https://files.dnr.state.mn.us/lib/bootstrap4/javascripts/bootstrap.min.js"></script>
19 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.7.1/leaflet.js"></script>
20 |   </head>
21 |   <body>
22 |     <nav class="navbar navbar-expand-md navbar-light fixed-top bg-light">
23 |       <a href="{{ template.api_root }}/">
24 |         <!-- <img style="max-width: 60px;height: auto;" src="data:image/png;base64,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" alt="Development Seed"> -->
25 |       </a>
26 |       <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbar" aria-controls="navbar" aria-expanded="false" aria-label="Toggle navigation">
27 |         <span class="navbar-toggler-icon"></span>
28 |       </button>
29 |       <div class="collapse navbar-collapse" id="navbar">
30 |         <ul class="navbar-nav mr-auto">
31 |           <li class="nav-item dropdown">
32 |             <a class="nav-link dropdown-toggle" href="{{ template.api_root }}" id="links" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false">Links</a>
33 |             <div class="dropdown-menu" aria-labelledby="account">
34 |               <a class="dropdown-item" href="{{ template.api_root }}/">Home</a>
35 |               <a class="dropdown-item" href="{{ template.api_root }}/conformance">Conformance</a>
36 |             </div>
37 |           </li>
38 |         </ul>
39 |       </div>
40 |     </nav>
41 | 
42 |     <main role="main" class="container-fluid">
43 |       <div id="page">
44 | 


--------------------------------------------------------------------------------