fix(queryables): adapt parameters' value before passing them to EODAG (#93)

Ensure the queryable parameter values match the expected type before
passing them to the call to `dag.list_queryables(...)`. E.g.
`ecmwf:data_format` must be passed as string; `ecmwf:variable` must be
passes as list.

A call to `dag.list_queryables(...)` with only provider and collection
(if they are available) is used to assess the expected type of the
parameters. The parameters given by the user are searched in the
queryables by both field name and alias, e.g. `ecmwf_variable`,
`ecmwf:variable` and `variable` are all searched.

Author: dalpasso

stac_fastapi/eodag/extensions/filter.py

@@ -18,11 +18,11 @@
 """Get Queryables."""
 
 import asyncio
-from typing import Any, Optional, cast
+from typing import Any, Literal, Optional, cast, get_args, get_origin
 
 import attr
 from fastapi import Request
-from pydantic import BaseModel, ConfigDict, create_model
+from pydantic import AliasChoices, AliasPath, BaseModel, ConfigDict, create_model
 from stac_fastapi.extensions.core.filter.client import AsyncBaseFiltersClient
 from stac_fastapi.types.errors import NotFoundError
 from stac_fastapi.types.requests import get_base_url
@@ -174,23 +174,8 @@ async def get_queryables(
         under OGC CQL but it is allowed by the STAC API Filter Extension
         https://github.com/radiantearth/stac-api-spec/tree/master/fragments/filter#queryables
         """
-        params: dict[str, list[Any]] = {}
-        for k, v in request.query_params.multi_items():
-            params.setdefault(k, []).append(v)
-
-        # parameter provider is deprecated
-        providers = params.pop("provider", [None])
-        federation_backends = params.pop("federation:backends", [None])
+        eodag_params = await self._get_eodag_params(request, collection_id)
 
-        # validate params and transform to eodag params
-        validated_params_model = QueryablesGetParams.model_validate(
-            {
-                **{"provider": federation_backends[0] or providers[0], "collection": collection_id},
-                **params,
-            }
-        )
-        validated_params = validated_params_model.model_dump(exclude_none=True, by_alias=True)
-        eodag_params = {self.stac_metadata_model.to_eodag(param): validated_params[param] for param in validated_params}
         # get queryables from eodag
         try:
             eodag_queryables = await asyncio.to_thread(request.app.state.dag.list_queryables, **eodag_params)
@@ -252,3 +237,95 @@ async def get_queryables(
                 properties[pk] = pv
 
         return queryables
+
+    async def _get_eodag_params(
+        self,
+        request: Request,
+        collection_id: Optional[str] = None,
+    ) -> dict[str, Any]:
+        """Return the EODAG parameters from the given HTTP Request.
+
+        :param request: The request object.
+        :param collection_id: The collection ID.
+        :return: The EODAG parameters.
+        """
+        params: dict[str, list[Any]] = {}
+        for k, v in request.query_params.multi_items():
+            params.setdefault(k, []).append(v)
+
+        # parameter provider is deprecated
+        providers = params.pop("provider", [None])
+        federation_backends = params.pop("federation:backends", [None])
+
+        # validate params and transform to eodag params
+        validated_params_model = QueryablesGetParams.model_validate(
+            {
+                **{"provider": federation_backends[0] or providers[0], "collection": collection_id},
+                **params,
+            }
+        )
+        validated_params = validated_params_model.model_dump(exclude_none=True, by_alias=True)
+        eodag_params = {self.stac_metadata_model.to_eodag(param): validated_params[param] for param in validated_params}
+
+        # the parameters in eodag_params are all lists:
+        # adapt them to use list or primitive type according to the collection queryables
+        eodag_params_pc = {k: eodag_params[k] for k in ["provider", "collection"] if k in eodag_params}
+        try:
+            eodag_queryables = await asyncio.to_thread(request.app.state.dag.list_queryables, **eodag_params_pc)
+        except UnsupportedCollection as err:
+            raise NotFoundError(err) from err
+
+        for queryables_key, annotation in eodag_queryables.items():
+            if queryables_key in ("provider", "collection"):
+                continue
+            param_args = get_args(annotation)
+            base_type = get_origin(param_args[0])
+            if base_type is None:
+                base_type = param_args[0]
+            field_info = param_args[1]
+
+            # get the aliases of queryable_key
+            validation_alias = field_info.validation_alias
+            aliases: list[str]
+            if isinstance(validation_alias, str):
+                aliases = [queryables_key, validation_alias]
+            elif isinstance(validation_alias, AliasChoices):
+                # e.g. aliases == ['ecmwf_data_format', 'ecmwf:data_format', 'data_format']
+                if any(not isinstance(c, str) for c in validation_alias.choices):
+                    # currently only choices of type string are used by EODAG
+                    raise NotImplementedError(
+                        f"Error for stac name {queryables_key}: "
+                        "only AliasChoices of type string are handled to get field aliases"
+                    )
+                choices: list[str] = [str(c) for c in validation_alias.choices]
+                aliases = [queryables_key, *choices]
+            elif isinstance(validation_alias, AliasPath):
+                # currently AliasPath is not used by EODAG
+                raise NotImplementedError(
+                    f"Error for stac name {queryables_key}: AliasPath is not currently handled to get field aliases"
+                )
+            elif validation_alias is None:
+                aliases = [queryables_key]
+            else:
+                raise NotImplementedError(
+                    f"Error for stac name {queryables_key}: validation alias no supported: {validation_alias}"
+                )
+
+            # check if any of the aliases is in eodag_params
+            eodag_key = next((n for n in aliases if n in eodag_params.keys()), None)
+            if not eodag_key:
+                # queryable_key is not in eodag_params: skip
+                continue
+
+            # adapt the value
+            if base_type in (Literal, str):
+                if isinstance(eodag_params[eodag_key], list):
+                    # convert list to single value
+                    eodag_params[eodag_key] = eodag_params[eodag_key][-1]
+            elif base_type in (tuple, list):
+                if not isinstance(eodag_params[eodag_key], list):
+                    # convert single value to list
+                    eodag_params[eodag_key] = [eodag_params[eodag_key]]
+            else:
+                raise NotImplementedError(f"Error for stac name {queryables_key}: type not supported: {param_args[0]}")
+        return eodag_params

tests/conftest.py

@@ -18,12 +18,13 @@
 """main conftest"""
 
 import os
+import typing
 import unittest.mock
 from dataclasses import dataclass, field
 from pathlib import Path
 from string import ascii_uppercase
 from tempfile import TemporaryDirectory
-from typing import Any, Iterator, Optional, Union
+from typing import Annotated, Any, Iterator, Optional, Union
 from urllib.parse import urljoin
 
 import pytest
@@ -43,6 +44,7 @@
 from eodag.utils import StreamResponse
 from fastapi import FastAPI
 from httpx import ASGITransport, AsyncClient
+from pydantic import AliasChoices, Field
 
 from stac_fastapi.eodag.app import api, stac_metadata_model
 from stac_fastapi.eodag.config import get_settings
@@ -315,6 +317,174 @@ def mock_list_queryables(mocker, app):
     return mocker.patch.object(app.state.dag, "list_queryables")
 
 
+@pytest.fixture(scope="function")
+def mock_list_queryables_return_value(mock_list_queryables):
+    """
+    Mocks the return value of `list_queryables` method of the `app.state.dag` object.
+    """
+    return_value = {
+        "ecmwf_area": Annotated[
+            tuple[
+                Annotated[
+                    float,
+                    Field(
+                        default=None,
+                        description="West border of the bounding box",
+                        ge=-180,
+                        le=180,
+                    ),
+                ],
+                Annotated[
+                    float,
+                    Field(
+                        default=None,
+                        description="South border of the bounding box",
+                        ge=-90,
+                        le=90,
+                    ),
+                ],
+                Annotated[
+                    float,
+                    Field(
+                        default=None,
+                        description="East border of the bounding box",
+                        ge=-180,
+                        le=180,
+                    ),
+                ],
+                Annotated[
+                    float,
+                    Field(
+                        default=None,
+                        description="North border of the bounding box",
+                        ge=-90,
+                        le=90,
+                    ),
+                ],
+            ],
+            Field(
+                default=None,
+                title="Sub-region extraction",
+                description="Select a sub-region of the available area by"
+                " providing its limits on latitude and longitude",
+                validation_alias=AliasChoices("ecmwf:area", "area"),
+                serialization_alias="ecmwf:area",
+                alias_priority=2,
+            ),
+        ],
+        "ecmwf_data_format": typing.Annotated[
+            typing.Literal["grib", "netcdf_zip"],
+            Field(
+                ...,
+                title="Data format",
+                validation_alias=AliasChoices("ecmwf:data_format", "data_format"),
+                serialization_alias="ecmwf:data_format",
+                alias_priority=2,
+            ),
+            "json_schema_required",
+        ],
+        "ecmwf_date": typing.Annotated[
+            typing.Literal[
+                "2025-03-04",
+                "2025-03-05/2025-03-21",
+                "2025-03-22",
+                "2025-03-23/2025-04-20",
+                "2025-04-21",
+                "2025-04-22/2025-04-29",
+                "2025-04-30",
+                "2025-05-01/2025-06-01",
+                "2025-05-03",
+                "2025-05-04/2026-02-03",
+                "2025-06-02",
+                "2025-06-03/2025-08-09",
+                "2025-08-10",
+                "2025-08-11",
+                "2025-08-12/2025-12-06",
+                "2025-12-07",
+                "2025-12-08/2026-02-02",
+                "2026-02-03",
+                "2026-02-04",
+            ],
+            Field(
+                ...,
+                title="Date",
+                validation_alias=AliasChoices("ecmwf:date", "date"),
+                serialization_alias="ecmwf:date",
+                alias_priority=2,
+                description="date formatted like yyyy-mm-dd/yyyy-mm-dd",
+            ),
+            "json_schema_required",
+        ],
+        "ecmwf_variable": typing.Annotated[
+            list[
+                typing.Literal[
+                    "alder_pollen",
+                    "ammonia",
+                    "birch_pollen",
+                    "carbon_monoxide",
+                    "dust",
+                    "formaldehyde",
+                    "glyoxal",
+                    "grass_pollen",
+                    "mugwort_pollen",
+                ],
+            ],
+            Field(
+                ...,
+                title="Variable",
+                validation_alias=AliasChoices("ecmwf:variable", "variable"),
+                serialization_alias="ecmwf:variable",
+                alias_priority=2,
+            ),
+            "json_schema_required",
+        ],
+        "end": Annotated[
+            str,
+            Field(
+                default=None,
+                alias="end_datetime",
+                alias_priority=2,
+                description="Date/time as string in ISO 8601 format (e.g. '2024-06-10T12:00:00Z')",
+            ),
+        ],
+        "start": Annotated[
+            str,
+            Field(
+                default=None,
+                alias="start_datetime",
+                alias_priority=2,
+                description="Date/time as string in ISO 8601 format (e.g. '2024-06-10T12:00:00Z')",
+            ),
+        ],
+        "dolorem": Annotated[
+            str,
+            Field(
+                default=None,
+                alias="dol",
+                alias_priority=2,
+            ),
+        ],
+        "ipsum": Annotated[
+            str,
+            Field(
+                default=None,
+                alias="ips",
+                alias_priority=2,
+            ),
+        ],
+        "bar": Annotated[
+            str,
+            Field(
+                default=None,
+                alias_priority=2,
+            ),
+        ],
+    }
+
+    mock_list_queryables.return_value = return_value
+    return return_value
+
+
 @pytest.fixture(scope="function")
 def mock_stac_discover_queryables(mocker):
     """