eodag 3.4.3__py3-none-any.whl → 3.5.0__py3-none-any.whl

eodag/api/core.py

@@ -36,6 +36,7 @@ from whoosh.index import exists_in, open_dir
 from whoosh.qparser import QueryParser
 
 from eodag.api.product.metadata_mapping import (
+    NOT_AVAILABLE,
     ONLINE_STATUS,
     mtd_cfg_as_conversion_and_querypath,
 )
@@ -79,6 +80,7 @@ from eodag.utils import (
     string_to_jsonpath,
     uri_to_path,
 )
+from eodag.utils.env import is_env_var_true
 from eodag.utils.exceptions import (
     AuthenticationError,
     EodagError,
@@ -175,12 +177,19 @@ class EODataAccessGateway:
         share_credentials(self.providers_config)
 
         # init updated providers conf
+        strict_mode = is_env_var_true("EODAG_STRICT_PRODUCT_TYPES")
+        available_product_types = set(self.product_types_config.source.keys())
+
         for provider in self.providers_config.keys():
             provider_config_init(
                 self.providers_config[provider],
                 load_stac_provider_config(),
             )
 
+            self._sync_provider_product_types(
+                provider, available_product_types, strict_mode
+            )
+
         # re-build _plugins_manager using up-to-date providers_config
         self._plugins_manager.rebuild(self.providers_config)
 
@@ -226,6 +235,61 @@ class EODataAccessGateway:
                     )
         self.set_locations_conf(locations_conf_path)
 
+    def _sync_provider_product_types(
+        self,
+        provider: str,
+        available_product_types: set[str],
+        strict_mode: bool,
+    ) -> None:
+        """
+        Synchronize product types for a provider based on strict or permissive mode.
+
+        In strict mode, removes product types not in available_product_types.
+        In permissive mode, adds empty product type configs for missing types.
+
+        :param provider: The provider name whose product types should be synchronized.
+        :param available_product_types: The set of available product type IDs.
+        :param strict_mode: If True, remove unknown product types; if False, add empty configs for them.
+        :returns: None
+        """
+        provider_products = self.providers_config[provider].products
+        products_to_remove: list[str] = []
+        products_to_add: list[str] = []
+
+        for product_id in provider_products:
+            if product_id == GENERIC_PRODUCT_TYPE:
+                continue
+
+            if product_id not in available_product_types:
+                if strict_mode:
+                    products_to_remove.append(product_id)
+                    continue
+
+                empty_product = {
+                    "title": product_id,
+                    "abstract": NOT_AVAILABLE,
+                }
+                self.product_types_config.source[
+                    product_id
+                ] = empty_product  # will update available_product_types
+                products_to_add.append(product_id)
+
+        if products_to_add:
+            logger.debug(
+                "Product types permissive mode, %s added (provider %s)",
+                ", ".join(products_to_add),
+                provider,
+            )
+
+        if products_to_remove:
+            logger.debug(
+                "Product types strict mode, ignoring %s (provider %s)",
+                ", ".join(products_to_remove),
+                provider,
+            )
+            for id in products_to_remove:
+                del self.providers_config[provider].products[id]
+
     def get_version(self) -> str:
         """Get eodag package version"""
         return version("eodag")
@@ -608,11 +672,14 @@ class EODataAccessGateway:
             for product_type_id in p.products:  # type: ignore
                 if product_type_id == GENERIC_PRODUCT_TYPE:
                     continue
+
                 config = self.product_types_config[product_type_id]
                 config["_id"] = product_type_id
+
                 if "alias" in config:
                     product_type_id = config["alias"]
                 product_type = {"ID": product_type_id, **config}
+
                 if product_type not in product_types:
                     product_types.append(product_type)
 
@@ -620,11 +687,18 @@ class EODataAccessGateway:
         return sorted(product_types, key=itemgetter("ID"))
 
     def fetch_product_types_list(self, provider: Optional[str] = None) -> None:
-        """Fetch product types list and update if needed
+        """Fetch product types list and update if needed.
+
+        If strict mode is enabled (by setting the ``EODAG_STRICT_PRODUCT_TYPES`` environment variable
+        to a truthy value), this method will not fetch or update product types and will return immediately.
 
         :param provider: The name of a provider or provider-group for which product types
                          list should be updated. Defaults to all providers (None value).
         """
+        strict_mode = is_env_var_true("EODAG_STRICT_PRODUCT_TYPES")
+        if strict_mode:
+            return
+
         providers_to_fetch = list(self.providers_config.keys())
         # check if some providers are grouped under a group name which is not a provider name
         if provider is not None and provider not in self.providers_config:

eodag/api/product/metadata_mapping.py

@@ -54,6 +54,7 @@ from eodag.utils import (
     string_to_jsonpath,
     update_nested_dict,
 )
+from eodag.utils.exceptions import ValidationError
 
 if TYPE_CHECKING:
     from shapely.geometry.base import BaseGeometry
@@ -1286,7 +1287,10 @@ def mtd_cfg_as_conversion_and_querypath(
 
 
 def format_query_params(
-    product_type: str, config: PluginConfig, query_dict: dict[str, Any]
+    product_type: str,
+    config: PluginConfig,
+    query_dict: dict[str, Any],
+    error_context: str = "",
 ) -> dict[str, Any]:
     """format the search parameters to query parameters"""
     if "raise_errors" in query_dict.keys():
@@ -1299,10 +1303,26 @@ def format_query_params(
         **config.products.get(product_type, {}).get("metadata_mapping", {}),
     )
 
+    # Raise error if non-queryables parameters are used and raise_mtd_discovery_error configured
+    if (
+        raise_mtd_discovery_error := config.products.get(product_type, {})
+        .get("discover_metadata", {})
+        .get("raise_mtd_discovery_error")
+    ) is None:
+        raise_mtd_discovery_error = getattr(config, "discover_metadata", {}).get(
+            "raise_mtd_discovery_error", False
+        )
+
     query_params: dict[str, Any] = {}
     # Get all the search parameters that are recognised as queryables by the
     # provider (they appear in the queryables dictionary)
-    queryables = _get_queryables(query_dict, config, product_type_metadata_mapping)
+    queryables = _get_queryables(
+        query_dict,
+        config,
+        product_type_metadata_mapping,
+        raise_mtd_discovery_error,
+        error_context,
+    )
 
     for eodag_search_key, provider_search_key in queryables.items():
         user_input = query_dict[eodag_search_key]
@@ -1438,6 +1458,8 @@ def _get_queryables(
     search_params: dict[str, Any],
     config: PluginConfig,
     metadata_mapping: dict[str, Any],
+    raise_mtd_discovery_error: bool,
+    error_context: str,
 ) -> dict[str, Any]:
     """Retrieve the metadata mappings that are query-able"""
     logger.debug("Retrieving queryable metadata from metadata_mapping")
@@ -1445,6 +1467,13 @@ def _get_queryables(
     for eodag_search_key, user_input in search_params.items():
         if user_input is not None:
             md_mapping = metadata_mapping.get(eodag_search_key, (None, NOT_MAPPED))
+            # raise an error when a query param not allowed by the provider is found
+            if not isinstance(md_mapping, list) and raise_mtd_discovery_error:
+                raise ValidationError(
+                    "Search parameters which are not queryable are disallowed for this product type on this provider: "
+                    f"please remove '{eodag_search_key}' from your search parameters. {error_context}",
+                    {eodag_search_key},
+                )
             _, md_value = md_mapping
             # query param from defined metadata_mapping
             if md_mapping is not None and isinstance(md_mapping, list):

eodag/config.py

@@ -194,12 +194,24 @@ class ProviderConfig(yaml.YAMLObject):
             },
         )
         for key in PLUGINS_TOPICS_KEYS:
-            current_value: Optional[dict[str, Any]] = getattr(self, key, None)
+            current_value: Optional[PluginConfig] = getattr(self, key, None)
             mapping_value = mapping.get(key, {})
             if current_value is not None:
                 current_value.update(mapping_value)
             elif mapping_value:
-                setattr(self, key, PluginConfig.from_mapping(mapping_value))
+                try:
+                    setattr(self, key, PluginConfig.from_mapping(mapping_value))
+                except ValidationError as e:
+                    logger.warning(
+                        (
+                            "Could not add %s Plugin config to %s configuration: %s. "
+                            "Try updating existing %s Plugin configs instead."
+                        ),
+                        key,
+                        self.name,
+                        str(e),
+                        ", ".join([k for k in PLUGINS_TOPICS_KEYS if hasattr(self, k)]),
+                    )
 
 
 class PluginConfig(yaml.YAMLObject):
@@ -256,9 +268,11 @@ class PluginConfig(yaml.YAMLObject):
         #: Metadata regex pattern used for discovery in search result properties
         metadata_pattern: str
         #: Configuration/template that will be used to query for a discovered parameter
-        search_param: str
+        search_param: str | dict[str, Any]
         #: Path to the metadata in search result
         metadata_path: str
+        #: Whether an error must be raised when using a search parameter which is not queryable or not
+        raise_mtd_discovery_error: bool
 
     class DiscoverProductTypes(TypedDict, total=False):
         """Configuration for product types discovery"""
@@ -628,6 +642,10 @@ class PluginConfig(yaml.YAMLObject):
     #: :class:`~eodag.plugins.authentication.token_exchange.OIDCTokenExchangeAuth`
     #: Identifies the issuer of the `subject_token`
     subject_issuer: str
+    #: :class:`~eodag.plugins.authentication.token.TokenAuth`
+    #: :class:`~eodag.plugins.authentication.openid_connect.OIDCRefreshTokenBase`
+    #: Safety buffer to prevent token rejection from unexpected expiry between validity check and request.
+    token_expiration_margin: int
     #: :class:`~eodag.plugins.authentication.token_exchange.OIDCTokenExchangeAuth`
     #: Audience that the token ID is intended for. :attr:`~eodag.config.PluginConfig.client_id` of the Relying Party
     audience: str
@@ -648,6 +666,7 @@ class PluginConfig(yaml.YAMLObject):
     @classmethod
     def from_mapping(cls, mapping: dict[str, Any]) -> PluginConfig:
         """Build a :class:`~eodag.config.PluginConfig` from a mapping"""
+        cls.validate(tuple(mapping.keys()))
         c = cls()
         c.__dict__.update(mapping)
         return c
@@ -657,7 +676,7 @@ class PluginConfig(yaml.YAMLObject):
         """Validate a :class:`~eodag.config.PluginConfig`"""
         if "type" not in config_keys:
             raise ValidationError(
-                "A Plugin config must specify the Plugin it configures"
+                "A Plugin config must specify the type of Plugin it configures"
             )
 
     def update(self, mapping: Optional[dict[Any, Any]]) -> None:
@@ -689,6 +708,8 @@ def load_default_config() -> dict[str, ProviderConfig]:
 def load_config(config_path: str) -> dict[str, ProviderConfig]:
     """Load the providers configuration into a dictionary from a given file
 
+    If EODAG_PROVIDERS_WHITELIST is set, only load listed providers.
+
     :param config_path: The path to the provider config file
     :returns: The default provider's configuration
     """
@@ -701,10 +722,23 @@ def load_config(config_path: str) -> dict[str, ProviderConfig]:
     except yaml.parser.ParserError as e:
         logger.error("Unable to load configuration")
         raise e
+
     stac_provider_config = load_stac_provider_config()
+
+    whitelist_env = os.getenv("EODAG_PROVIDERS_WHITELIST")
+    whitelist = None
+    if whitelist_env:
+        whitelist = {provider for provider in whitelist_env.split(",")}
+        logger.info("Using providers whitelist: %s", ", ".join(whitelist))
+
     for provider_config in providers_configs:
+        if provider_config is None or (
+            whitelist and provider_config.name not in whitelist
+        ):
+            continue
         provider_config_init(provider_config, stac_provider_config)
         config[provider_config.name] = provider_config
+
     return config
 
 
@@ -803,7 +837,9 @@ def provider_config_init(
         pass
 
 
-def override_config_from_file(config: dict[str, Any], file_path: str) -> None:
+def override_config_from_file(
+    config: dict[str, ProviderConfig], file_path: str
+) -> None:
     """Override a configuration with the values in a file
 
     :param config: An eodag providers configuration dictionary
@@ -818,10 +854,11 @@ def override_config_from_file(config: dict[str, Any], file_path: str) -> None:
         except yaml.parser.ParserError as e:
             logger.error("Unable to load user configuration file")
             raise e
+
     override_config_from_mapping(config, config_in_file)
 
 
-def override_config_from_env(config: dict[str, Any]) -> None:
+def override_config_from_env(config: dict[str, ProviderConfig]) -> None:
     """Override a configuration with environment variables values
 
     :param config: An eodag providers configuration dictionary
@@ -892,16 +929,25 @@ def override_config_from_env(config: dict[str, Any]) -> None:
 
 
 def override_config_from_mapping(
-    config: dict[str, Any], mapping: dict[str, Any]
+    config: dict[str, ProviderConfig], mapping: dict[str, Any]
 ) -> None:
-    """Override a configuration with the values in a mapping
+    """Override a configuration with the values in a mapping.
+
+    If the environment variable ``EODAG_PROVIDERS_WHITELIST`` is set (as a comma-separated list of provider names),
+    only the listed providers will be used from the mapping. All other providers in the mapping will be ignored.
 
     :param config: An eodag providers configuration dictionary
     :param mapping: The mapping containing the values to be overriden
     """
+    whitelist_env = os.getenv("EODAG_PROVIDERS_WHITELIST")
+    whitelist = None
+    if whitelist_env:
+        whitelist = {provider for provider in whitelist_env.split(",")}
+
     for provider, new_conf in mapping.items():
         # check if metada-mapping as already been built as jsonpath in providers_config
-        if not isinstance(new_conf, dict):
+        # or provider not in whitelist
+        if not isinstance(new_conf, dict) or (whitelist and provider not in whitelist):
             continue
         new_conf_search = new_conf.get("search", {}) or {}
         new_conf_api = new_conf.get("api", {}) or {}
@@ -930,7 +976,7 @@ def override_config_from_mapping(
                 )
 
         # try overriding conf
-        old_conf: Optional[dict[str, Any]] = config.get(provider)
+        old_conf: Optional[ProviderConfig] = config.get(provider)
         if old_conf is not None:
             old_conf.update(new_conf)
         else:

eodag/plugins/authentication/keycloak.py

@@ -60,8 +60,10 @@ class KeycloakOIDCPasswordAuth(OIDCRefreshTokenBase):
           The allowed audiences that have to be present in the user token.
         * :attr:`~eodag.config.PluginConfig.auth_error_code` (``int``): which error code is
           returned in case of an authentication error
-        * :attr:`~eodag.config.PluginConfig.ssl_verify` (``bool``): if the ssl certificates
+        * :attr:`~eodag.config.PluginConfig.ssl_verify` (``bool``): If the SSL certificates
           should be verified in the token request; default: ``True``
+        * :attr:`~eodag.config.PluginConfig.token_expiration_margin` (``int``): The margin of time (in seconds)
+          before a token is considered expired. Default: 60 seconds
 
     Using :class:`~eodag.plugins.download.http.HTTPDownload` a download link
     ``http://example.com?foo=bar`` will become

eodag/plugins/authentication/openid_connect.py

@@ -30,7 +30,14 @@ from lxml import etree
 from requests.auth import AuthBase
 
 from eodag.plugins.authentication import Authentication
-from eodag.utils import HTTP_REQ_TIMEOUT, USER_AGENT, parse_qs, repeatfunc, urlparse
+from eodag.utils import (
+    DEFAULT_TOKEN_EXPIRATION_MARGIN,
+    HTTP_REQ_TIMEOUT,
+    USER_AGENT,
+    parse_qs,
+    repeatfunc,
+    urlparse,
+)
 from eodag.utils.exceptions import (
     AuthenticationError,
     MisconfiguredError,
@@ -117,13 +124,22 @@ class OIDCRefreshTokenBase(Authentication):
 
     def _get_access_token(self) -> str:
         now = datetime.now(timezone.utc)
-        if self.access_token and now < self.access_token_expiration:
+        expiration_margin = timedelta(
+            seconds=getattr(
+                self.config, "token_expiration_margin", DEFAULT_TOKEN_EXPIRATION_MARGIN
+            )
+        )
+
+        if self.access_token and self.access_token_expiration - now > expiration_margin:
             logger.debug(
                 f"Existing access_token is still valid until {self.access_token_expiration.isoformat()}."
             )
             return self.access_token
 
-        elif self.refresh_token and now < self.refresh_token_expiration:
+        elif (
+            self.refresh_token
+            and self.refresh_token_expiration - now > expiration_margin
+        ):
             response = self._get_token_with_refresh_token()
             logger.debug(
                 "access_token expired, fetching new access_token using refresh_token"
@@ -268,6 +284,8 @@ class OIDCAuthorizationCodeFlowAuth(OIDCRefreshTokenBase):
           Refers to the name of the query param to be used in the query request
         * :attr:`~eodag.config.PluginConfig.refresh_token_key` (``str``): The key pointing to
           the refresh_token in the json response to the POST request to the token server
+        * :attr:`~eodag.config.PluginConfig.token_expiration_margin` (``int``): The margin of time (in seconds)
+          before a token is considered expired. Default: 60 seconds.
 
     """
 

eodag/plugins/authentication/token.py

@@ -31,6 +31,7 @@ from urllib3 import Retry
 
 from eodag.plugins.authentication.base import Authentication
 from eodag.utils import (
+    DEFAULT_TOKEN_EXPIRATION_MARGIN,
     HTTP_REQ_TIMEOUT,
     REQ_RETRY_BACKOFF_FACTOR,
     REQ_RETRY_STATUS_FORCELIST,
@@ -90,6 +91,8 @@ class TokenAuth(Authentication):
         * :attr:`~eodag.config.PluginConfig.retry_status_forcelist` (``list[int]``): :class:`urllib3.util.Retry`
           ``status_forcelist`` parameter, list of integer HTTP status codes that we should force a retry on; default:
           ``[401, 429, 500, 502, 503, 504]``
+        * :attr:`~eodag.config.PluginConfig.token_expiration_margin` (``int``): The margin of time (in seconds) before
+          a token is considered expired. Default: 60 seconds.
     """
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
@@ -152,9 +155,18 @@ class TokenAuth(Authentication):
 
         # Use a thread lock to avoid several threads requesting the token at the same time
         with self.auth_lock:
-
+            expiration_margin = timedelta(
+                seconds=getattr(
+                    self.config,
+                    "token_expiration_margin",
+                    DEFAULT_TOKEN_EXPIRATION_MARGIN,
+                )
+            )
             self.validate_config_credentials()
-            if self.token and self.token_expiration > datetime.now():
+            if (
+                self.token
+                and self.token_expiration - datetime.now() > expiration_margin
+            ):
                 logger.debug("using existing access token")
                 return RequestsTokenAuth(
                     self.token, "header", headers=getattr(self.config, "headers", {})

eodag/plugins/authentication/token_exchange.py

@@ -79,6 +79,7 @@ class OIDCTokenExchangeAuth(Authentication):
             provider,
             PluginConfig.from_mapping(
                 {
+                    "type": "OIDCAuthorizationCodeFlowAuth",
                     "credentials": getattr(self.config, "credentials", {}),
                     **self.config.subject,
                 }

eodag/plugins/download/aws.py

@@ -207,7 +207,7 @@ class AwsDownload(Download):
     :param config: Download plugin configuration:
 
         * :attr:`~eodag.config.PluginConfig.type` (``str``) (**mandatory**): AwsDownload
-        * :attr:`~eodag.config.PluginConfig.base_uri` (``str``) (**mandatory**): s3 endpoint url
+        * :attr:`~eodag.config.PluginConfig.s3_endpoint` (``str``): s3 endpoint url
         * :attr:`~eodag.config.PluginConfig.requester_pays` (``bool``): whether download is done
           from a requester-pays bucket or not; default: ``False``
         * :attr:`~eodag.config.PluginConfig.flatten_top_dirs` (``bool``): if the directory structure

eodag/plugins/manager.py

@@ -190,7 +190,7 @@ class PluginManager:
                 plugin = cast(Api, self._build_plugin(config.name, api, Api))
             else:
                 raise MisconfiguredError(
-                    f"No search plugin configureed for {config.name}."
+                    f"No search plugin configured for {config.name}."
                 )
             return plugin
 

eodag/plugins/search/base.py

@@ -275,7 +275,8 @@ class Search(PluginTopic):
             if eodag_sort_order[:3] != "ASC" and eodag_sort_order[:3] != "DES":
                 raise ValidationError(
                     "Sorting order is invalid: it must be set to 'ASC' (ASCENDING) or "
-                    f"'DESC' (DESCENDING), got '{eodag_sort_order}' with '{eodag_sort_param}' instead"
+                    f"'DESC' (DESCENDING), got '{eodag_sort_order}' with '{eodag_sort_param}' instead",
+                    {eodag_sort_param},
                 )
             eodag_sort_order = eodag_sort_order[:3]
 
@@ -296,7 +297,7 @@ class Search(PluginTopic):
                     raise ValidationError(
                         f"'{eodag_sort_param}' parameter is called several times to sort results with different "
                         "sorting orders. Please set it to only one ('ASC' (ASCENDING) or 'DESC' (DESCENDING))",
-                        set([eodag_sort_param]),
+                        {eodag_sort_param},
                     )
             provider_sort_by_tuples_used.append(provider_sort_by_tuple)
 

eodag/plugins/search/build_search_result.py

@@ -722,7 +722,7 @@ class ECMWFSearch(PostJsonSearch):
                 "geometry",
             }:
                 raise ValidationError(
-                    f"{key} is not a queryable parameter for {self.provider}"
+                    f"'{key}' is not a queryable parameter for {self.provider}", {key}
                 )
 
             formated_filters[key] = v
@@ -781,7 +781,9 @@ class ECMWFSearch(PostJsonSearch):
                 and keyword.removeprefix(ECMWF_PREFIX)
                 not in set(list(available_values.keys()) + [f["name"] for f in form])
             ):
-                raise ValidationError(f"{keyword} is not a queryable parameter")
+                raise ValidationError(
+                    f"'{keyword}' is not a queryable parameter", {keyword}
+                )
 
         # generate queryables
         if form:
@@ -868,7 +870,8 @@ class ECMWFSearch(PostJsonSearch):
             # we only compare list of strings.
             if isinstance(values, dict):
                 raise ValidationError(
-                    f"Parameter value as object is not supported: {keyword}={values}"
+                    f"Parameter value as object is not supported: {keyword}={values}",
+                    {keyword},
                 )
 
             # We convert every single value to a list of string
@@ -934,7 +937,10 @@ class ECMWFSearch(PostJsonSearch):
                 raise ValidationError(
                     f"{keyword}={values} is not available"
                     f"{all_keywords_str}."
-                    f" Allowed values are {', '.join(allowed_values)}."
+                    f" Allowed values are {', '.join(allowed_values)}.",
+                    set(
+                        [keyword] + [k for k in parsed_keywords if k in input_keywords]
+                    ),
                 )
 
             parsed_keywords.append(keyword)

eodag/plugins/search/data_request_search.py

@@ -32,6 +32,7 @@ from eodag.api.product.metadata_mapping import (
 )
 from eodag.plugins.search import PreparedSearch
 from eodag.plugins.search.base import Search
+from eodag.types.queryables import Queryables
 from eodag.utils import (
     DEFAULT_ITEMS_PER_PAGE,
     DEFAULT_MISSION_START_DATE,
@@ -359,7 +360,19 @@ class DataRequestSearch(Search):
         ssl_verify = getattr(self.config.ssl_verify, "ssl_verify", True)
         try:
             url = self.config.data_request_url
-            request_body = format_query_params(eodag_product_type, self.config, kwargs)
+            try:
+                request_body = format_query_params(
+                    eodag_product_type, self.config, kwargs
+                )
+            except ValidationError as err:
+                not_queryable_search_param = Queryables.get_queryable_from_alias(
+                    str(err.message).split(":")[-1].strip()
+                )
+                raise ValidationError(
+                    f"Search parameters which are not queryable are disallowed for {product_type} on "
+                    f"{self.provider}: please remove '{not_queryable_search_param}' from your search parameters",
+                    {not_queryable_search_param},
+                ) from err
             logger.debug(
                 f"Sending search job request to {url} with {str(request_body)}"
             )

eodag/plugins/search/qssearch.py

@@ -811,7 +811,10 @@ class QueryStringSearch(Search):
     ) -> tuple[dict[str, Any], str]:
         """Build The query string using the search parameters"""
         logger.debug("Building the query string that will be used for search")
-        query_params = format_query_params(product_type, self.config, query_dict)
+        error_context = f"Product type: {product_type} / provider : {self.provider}"
+        query_params = format_query_params(
+            product_type, self.config, query_dict, error_context
+        )
 
         # Build the final query string, in one go without quoting it
         # (some providers do not operate well with urlencoded and quoted query strings)
@@ -1781,7 +1784,10 @@ class StacSearch(PostJsonSearch):
             query_dict.setdefault("startTimeFromAscendingNode", "..")
             query_dict.setdefault("completionTimeFromAscendingNode", "..")
 
-        query_params = format_query_params(product_type, self.config, query_dict)
+        error_context = f"Product type: {product_type} / provider : {self.provider}"
+        query_params = format_query_params(
+            product_type, self.config, query_dict, error_context
+        )
 
         # Build the final query string, in one go without quoting it
         # (some providers do not operate well with urlencoded and quoted query strings)