eodag 3.0.1__py3-none-any.whl → 3.1.0__py3-none-any.whl

eodag/plugins/search/qssearch.py

@@ -19,19 +19,15 @@ from __future__ import annotations
 
 import logging
 import re
+import socket
 from copy import copy as copy_copy
-from datetime import datetime
 from typing import (
     TYPE_CHECKING,
     Annotated,
     Any,
     Callable,
-    Dict,
-    List,
     Optional,
     Sequence,
-    Set,
-    Tuple,
     TypedDict,
     cast,
     get_args,
@@ -52,7 +48,6 @@ import geojson
 import orjson
 import requests
 import yaml
-from dateutil.utils import today
 from jsonpath_ng import JSONPath
 from lxml import etree
 from pydantic import create_model
@@ -75,9 +70,9 @@ from eodag.api.search_result import RawSearchResult
 from eodag.plugins.search import PreparedSearch
 from eodag.plugins.search.base import Search
 from eodag.types import json_field_definition_to_python, model_fields_to_annotated
-from eodag.types.queryables import CommonQueryables
 from eodag.types.search_args import SortByList
 from eodag.utils import (
+    DEFAULT_SEARCH_TIMEOUT,
     GENERIC_PRODUCT_TYPE,
     HTTP_REQ_TIMEOUT,
     REQ_RETRY_BACKOFF_FACTOR,
@@ -94,10 +89,6 @@ from eodag.utils import (
     update_nested_dict,
     urlencode,
 )
-from eodag.utils.constraints import (
-    fetch_constraints,
-    get_constraint_queryables_with_additional_params,
-)
 from eodag.utils.exceptions import (
     AuthenticationError,
     MisconfiguredError,
@@ -132,7 +123,7 @@ class QueryStringSearch(Search):
           authentication error; only used if ``need_auth=true``
         * :attr:`~eodag.config.PluginConfig.ssl_verify` (``bool``): if the ssl certificates should be verified in
           requests; default: ``True``
-        * :attr:`~eodag.config.PluginConfig.dont_quote` (``List[str]``): characters that should not be quoted in the
+        * :attr:`~eodag.config.PluginConfig.dont_quote` (``list[str]``): characters that should not be quoted in the
           url params
         * :attr:`~eodag.config.PluginConfig.timeout` (``int``): time to wait until request timeout in seconds;
           default: ``5``
@@ -140,10 +131,10 @@ class QueryStringSearch(Search):
           total number of retries to allow; default: ``3``
         * :attr:`~eodag.config.PluginConfig.retry_backoff_factor` (``int``): :class:`urllib3.util.Retry`
           ``backoff_factor`` parameter, backoff factor to apply between attempts after the second try; default: ``2``
-        * :attr:`~eodag.config.PluginConfig.retry_status_forcelist` (``List[int]``): :class:`urllib3.util.Retry`
+        * :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.literal_search_params` (``Dict[str, str]``): A mapping of (search_param =>
+        * :attr:`~eodag.config.PluginConfig.literal_search_params` (``dict[str, str]``): A mapping of (search_param =>
           search_value) pairs giving search parameters to be passed as is in the search url query string. This is useful
           for example in situations where the user wants to add a fixed search query parameter exactly
           as it is done on the provider interface.
@@ -187,10 +178,13 @@ class QueryStringSearch(Search):
           * :attr:`~eodag.config.PluginConfig.DiscoverProductTypes.generic_product_type_id` (``str``): mapping for the
             product type id
           * :attr:`~eodag.config.PluginConfig.DiscoverProductTypes.generic_product_type_parsable_metadata`
-            (``Dict[str, str]``): mapping for product type metadata (e.g. ``abstract``, ``licence``) which can be parsed
+            (``dict[str, str]``): mapping for product type metadata (e.g. ``abstract``, ``licence``) which can be parsed
             from the provider result
           * :attr:`~eodag.config.PluginConfig.DiscoverProductTypes.generic_product_type_parsable_properties`
-            (``Dict[str, str]``): mapping for product type properties which can be parsed from the result that are not
+            (``dict[str, str]``): mapping for product type properties which can be parsed from the result and are not
+            product type metadata
+          * :attr:`~eodag.config.PluginConfig.DiscoverProductTypes.generic_product_type_unparsable_properties`
+            (``dict[str, str]``): mapping for product type properties which cannot be parsed from the result and are not
             product type metadata
           * :attr:`~eodag.config.PluginConfig.DiscoverProductTypes.single_collection_fetch_url` (``str``): url to fetch
             data for a single collection; used if product type metadata is not available from the endpoint given in
@@ -199,13 +193,13 @@ class QueryStringSearch(Search):
             to be added to the :attr:`~eodag.config.PluginConfig.DiscoverProductTypes.fetch_url` to filter for a
             collection
           * :attr:`~eodag.config.PluginConfig.DiscoverProductTypes.single_product_type_parsable_metadata`
-            (``Dict[str, str]``): mapping for product type metadata returned by the endpoint given in
+            (``dict[str, str]``): mapping for product type metadata returned by the endpoint given in
             :attr:`~eodag.config.PluginConfig.DiscoverProductTypes.single_collection_fetch_url`.
 
         * :attr:`~eodag.config.PluginConfig.sort` (:class:`~eodag.config.PluginConfig.Sort`): configuration for sorting
           the results. It contains the keys:
 
-          * :attr:`~eodag.config.PluginConfig.Sort.sort_by_default` (``List[Tuple(str, Literal["ASC", "DESC"])]``):
+          * :attr:`~eodag.config.PluginConfig.Sort.sort_by_default` (``list[Tuple(str, Literal["ASC", "DESC"])]``):
             parameter and sort order by which the result will be sorted by default (if the user does not enter a
             ``sort_by`` parameter); if not given the result will use the default sorting of the provider; Attention:
             for some providers sorting might cause a timeout if no filters are used. In that case no default
@@ -221,12 +215,12 @@ class QueryStringSearch(Search):
           * :attr:`~eodag.config.PluginConfig.Sort.sort_param_mapping` (``Dict [str, str]``): mapping for the parameters
             available for sorting
           * :attr:`~eodag.config.PluginConfig.Sort.sort_order_mapping`
-            (``Dict[Literal["ascending", "descending"], str]``): mapping for the sort order
+            (``dict[Literal["ascending", "descending"], str]``): mapping for the sort order
           * :attr:`~eodag.config.PluginConfig.Sort.max_sort_params` (``int``): maximum number of sort parameters
             supported by the provider; used to validate the user input to avoid failed requests or unexpected behaviour
             (not all parameters are used in the request)
 
-        * :attr:`~eodag.config.PluginConfig.metadata_mapping` (``Dict[str, Any]``): The search plugins of this kind can
+        * :attr:`~eodag.config.PluginConfig.metadata_mapping` (``dict[str, Any]``): The search plugins of this kind can
           detect when a metadata mapping is "query-able", and get the semantics of how to format the query string
           parameter that enables to make a query on the corresponding metadata. To make a metadata query-able,
           just configure it in the metadata mapping to be a list of 2 items, the first one being the
@@ -259,7 +253,7 @@ class QueryStringSearch(Search):
             metadata is activated; default: ``False``; if false, the other parameters are not used;
           * :attr:`~eodag.config.PluginConfig.DiscoverMetadata.metadata_pattern` (``str``): regex string a parameter in
             the result should match so that is used
-          * :attr:`~eodag.config.PluginConfig.DiscoverMetadata.search_param` (``Union [str, Dict[str, Any]]``): format
+          * :attr:`~eodag.config.PluginConfig.DiscoverMetadata.search_param` (``Union [str, dict[str, Any]]``): format
             to add a query param given by the user and not in the metadata mapping to the requests, 'metadata' will be
             replaced by the search param; can be a string or a dict containing
             :attr:`~eodag.config.PluginConfig.free_text_search_operations`
@@ -282,16 +276,12 @@ class QueryStringSearch(Search):
 
         * :attr:`~eodag.config.PluginConfig.constraints_file_url` (``str``): url to fetch the constraints for a specific
           product type, can be an http url or a path to a file; the constraints are used to build queryables
-        * :attr:`~eodag.config.PluginConfig.constraints_file_dataset_key` (``str``): key which is used in the eodag
-          configuration to map the eodag product type to the provider product type; default: ``dataset``
         * :attr:`~eodag.config.PluginConfig.constraints_entry` (``str``): key in the json result where the constraints
           can be found; if not given, it is assumed that the constraints are on top level of the result, i.e.
           the result is an array of constraints
-        * :attr:`~eodag.config.PluginConfig.stop_without_constraints_entry_key` (``bool``): if true only a provider
-          result containing `constraints_entry` is accepted as valid and used to create constraints; default: ``False``
     """
 
-    extract_properties: Dict[str, Callable[..., Dict[str, Any]]] = {
+    extract_properties: dict[str, Callable[..., dict[str, Any]]] = {
         "xml": properties_from_xml,
         "json": properties_from_json,
     }
@@ -302,8 +292,8 @@ class QueryStringSearch(Search):
         self.config.__dict__.setdefault("results_entry", "features")
         self.config.__dict__.setdefault("pagination", {})
         self.config.__dict__.setdefault("free_text_search_operations", {})
-        self.search_urls: List[str] = []
-        self.query_params: Dict[str, str] = dict()
+        self.search_urls: list[str] = []
+        self.query_params: dict[str, str] = dict()
         self.query_string = ""
         self.next_page_url = None
         self.next_page_query_obj = None
@@ -448,7 +438,7 @@ class QueryStringSearch(Search):
         self.next_page_query_obj = None
         self.next_page_merge = None
 
-    def discover_product_types(self, **kwargs: Any) -> Optional[Dict[str, Any]]:
+    def discover_product_types(self, **kwargs: Any) -> Optional[dict[str, Any]]:
         """Fetch product types list from provider using `discover_product_types` conf
 
         :returns: configuration dict containing fetched product types information
@@ -465,7 +455,7 @@ class QueryStringSearch(Search):
             # no pagination
             return self.discover_product_types_per_page(**kwargs)
 
-        conf_update_dict: Dict[str, Any] = {
+        conf_update_dict: dict[str, Any] = {
             "providers_config": {},
             "product_types_config": {},
         }
@@ -498,7 +488,7 @@ class QueryStringSearch(Search):
 
     def discover_product_types_per_page(
         self, **kwargs: Any
-    ) -> Optional[Dict[str, Any]]:
+    ) -> Optional[dict[str, Any]]:
         """Fetch product types list from provider using `discover_product_types` conf
         using paginated ``kwargs["fetch_url"]``
 
@@ -541,7 +531,7 @@ class QueryStringSearch(Search):
 
             prep.info_message = "Fetching product types: {}".format(prep.url)
             prep.exception_message = (
-                "Skipping error while fetching product types for " "{} {} instance:"
+                "Skipping error while fetching product types for {} {} instance:"
             ).format(self.provider, self.__class__.__name__)
 
             # Query using appropriate method
@@ -556,7 +546,7 @@ class QueryStringSearch(Search):
             return None
         else:
             try:
-                conf_update_dict: Dict[str, Any] = {
+                conf_update_dict: dict[str, Any] = {
                     "providers_config": {},
                     "product_types_config": {},
                 }
@@ -575,7 +565,7 @@ class QueryStringSearch(Search):
                         result = result[0]
 
                     def conf_update_from_product_type_result(
-                        product_type_result: Dict[str, Any]
+                        product_type_result: dict[str, Any],
                     ) -> None:
                         """Update ``conf_update_dict`` using given product type json response"""
                         # providers_config extraction
@@ -641,7 +631,11 @@ class QueryStringSearch(Search):
                                     ][kf]
                                 )
                                 for kf in keywords_fields
-                                if conf_update_dict["product_types_config"][
+                                if kf
+                                in conf_update_dict["product_types_config"][
+                                    generic_product_type_id
+                                ]
+                                and conf_update_dict["product_types_config"][
                                     generic_product_type_id
                                 ][kf]
                                 != NOT_AVAILABLE
@@ -699,7 +693,7 @@ class QueryStringSearch(Search):
 
     def _get_product_type_metadata_from_single_collection_endpoint(
         self, product_type: str
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """
         retrieves additional product type information from an endpoint returning data for a single collection
         :param product_type: product type
@@ -723,107 +717,11 @@ class QueryStringSearch(Search):
             self.config.discover_product_types["single_product_type_parsable_metadata"],
         )
 
-    def discover_queryables(
-        self, **kwargs: Any
-    ) -> Optional[Dict[str, Annotated[Any, FieldInfo]]]:
-        """Fetch queryables list from provider using its constraints file
-
-        :param kwargs: additional filters for queryables (`productType` and other search
-                       arguments)
-        :returns: fetched queryable parameters dict
-        """
-        product_type = kwargs.pop("productType", None)
-        if not product_type:
-            return {}
-        constraints_file_url = getattr(self.config, "constraints_file_url", "")
-        if not constraints_file_url:
-            return {}
-
-        constraints_file_dataset_key = getattr(
-            self.config, "constraints_file_dataset_key", "dataset"
-        )
-        provider_product_type = self.config.products.get(product_type, {}).get(
-            constraints_file_dataset_key, None
-        )
-
-        # defaults
-        default_queryables = self._get_defaults_as_queryables(product_type)
-        # remove unwanted queryables
-        for param in getattr(self.config, "remove_from_queryables", []):
-            default_queryables.pop(param, None)
-
-        non_empty_kwargs = {k: v for k, v in kwargs.items() if v}
-
-        if "{" in constraints_file_url:
-            constraints_file_url = constraints_file_url.format(
-                dataset=provider_product_type
-            )
-        constraints = fetch_constraints(constraints_file_url, self)
-        if not constraints:
-            return default_queryables
-
-        constraint_params: Dict[str, Dict[str, Set[Any]]] = {}
-        if len(kwargs) == 0:
-            # get values from constraints without additional filters
-            for constraint in constraints:
-                for key in constraint.keys():
-                    if key in constraint_params:
-                        constraint_params[key]["enum"].update(constraint[key])
-                    else:
-                        constraint_params[key] = {"enum": set(constraint[key])}
-        else:
-            # get values from constraints with additional filters
-            constraints_input_params = {k: v for k, v in non_empty_kwargs.items()}
-            constraint_params = get_constraint_queryables_with_additional_params(
-                constraints, constraints_input_params, self, product_type
-            )
-            # query params that are not in constraints but might be default queryables
-            if len(constraint_params) == 1 and "not_available" in constraint_params:
-                not_queryables = set()
-                for constraint_param in constraint_params["not_available"]["enum"]:
-                    param = CommonQueryables.get_queryable_from_alias(constraint_param)
-                    if param in dict(
-                        CommonQueryables.model_fields, **default_queryables
-                    ):
-                        non_empty_kwargs.pop(constraint_param)
-                    else:
-                        not_queryables.add(constraint_param)
-                if not_queryables:
-                    raise ValidationError(
-                        f"parameter(s) {str(not_queryables)} not queryable"
-                    )
-                else:
-                    # get constraints again without common queryables
-                    constraint_params = (
-                        get_constraint_queryables_with_additional_params(
-                            constraints, non_empty_kwargs, self, product_type
-                        )
-                    )
-
-        field_definitions: Dict[str, Any] = dict()
-        for json_param, json_mtd in constraint_params.items():
-            param = (
-                get_queryable_from_provider(
-                    json_param, self.get_metadata_mapping(product_type)
-                )
-                or json_param
-            )
-            default = kwargs.get(param, None) or self.config.products.get(
-                product_type, {}
-            ).get(param, None)
-            annotated_def = json_field_definition_to_python(
-                json_mtd, default_value=default, required=True
-            )
-            field_definitions[param] = get_args(annotated_def)
-
-        python_queryables = create_model("m", **field_definitions).model_fields
-        return dict(default_queryables, **model_fields_to_annotated(python_queryables))
-
     def query(
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> Tuple[List[EOProduct], Optional[int]]:
+    ) -> tuple[list[EOProduct], Optional[int]]:
         """Perform a search on an OpenSearch-like interface
 
         :param prep: Object collecting needed information for search.
@@ -851,7 +749,7 @@ class QueryStringSearch(Search):
 
         # provider product type specific conf
         prep.product_type_def_params = (
-            self.get_product_type_def_params(product_type, **kwargs)
+            self.get_product_type_def_params(product_type, format_variables=kwargs)
             if product_type is not None
             else {}
         )
@@ -875,7 +773,7 @@ class QueryStringSearch(Search):
                 }
             )
 
-        qp, qs = self.build_query_string(product_type, **keywords)
+        qp, qs = self.build_query_string(product_type, keywords)
 
         prep.query_params = qp
         prep.query_string = qs
@@ -903,21 +801,21 @@ class QueryStringSearch(Search):
         reason="Simply run `self.config.metadata_mapping.update(metadata_mapping)` instead",
         version="2.10.0",
     )
-    def update_metadata_mapping(self, metadata_mapping: Dict[str, Any]) -> None:
+    def update_metadata_mapping(self, metadata_mapping: dict[str, Any]) -> None:
         """Update plugin metadata_mapping with input metadata_mapping configuration"""
         if self.config.metadata_mapping:
             self.config.metadata_mapping.update(metadata_mapping)
 
     def build_query_string(
-        self, product_type: str, **kwargs: Any
-    ) -> Tuple[Dict[str, Any], str]:
+        self, product_type: str, query_dict: dict[str, Any]
+    ) -> 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, kwargs)
+        query_params = format_query_params(product_type, self.config, query_dict)
 
         # Build the final query string, in one go without quoting it
         # (some providers do not operate well with urlencoded and quoted query strings)
-        def quote_via(x: Any, *_args, **_kwargs) -> str:
+        def quote_via(x: Any, *_args: Any, **_kwargs: Any) -> str:
             return x
 
         return (
@@ -929,7 +827,7 @@ class QueryStringSearch(Search):
         self,
         prep: PreparedSearch = PreparedSearch(page=None, items_per_page=None),
         **kwargs: Any,
-    ) -> Tuple[List[str], Optional[int]]:
+    ) -> tuple[list[str], Optional[int]]:
         """Build paginated urls"""
         page = prep.page
         items_per_page = prep.items_per_page
@@ -998,7 +896,7 @@ class QueryStringSearch(Search):
 
     def do_search(
         self, prep: PreparedSearch = PreparedSearch(items_per_page=None), **kwargs: Any
-    ) -> List[Any]:
+    ) -> list[Any]:
         """Perform the actual search request.
 
         If there is a specified number of items per page, return the results as soon
@@ -1015,7 +913,7 @@ class QueryStringSearch(Search):
                     "total_items_nb_key_path"
                 ]
 
-        results: List[Any] = []
+        results: list[Any] = []
         for search_url in prep.search_urls:
             single_search_prep = copy_copy(prep)
             single_search_prep.url = search_url
@@ -1138,9 +1036,13 @@ class QueryStringSearch(Search):
                         logger.debug(
                             "Could not extract total_items_nb from search results"
                         )
-            if getattr(self.config, "merge_responses", False):
+            if (
+                getattr(self.config, "merge_responses", False)
+                and self.config.result_type == "json"
+            ):
+                json_result = cast(list[dict[str, Any]], result)
                 results = (
-                    [dict(r, **result[i]) for i, r in enumerate(results)]
+                    [dict(r, **json_result[i]) for i, r in enumerate(results)]
                     if results
                     else result
                 )
@@ -1162,14 +1064,14 @@ class QueryStringSearch(Search):
 
     def normalize_results(
         self, results: RawSearchResult, **kwargs: Any
-    ) -> List[EOProduct]:
+    ) -> list[EOProduct]:
         """Build EOProducts from provider results"""
         normalize_remaining_count = len(results)
         logger.debug(
             "Adapting %s plugin results to eodag product representation"
             % normalize_remaining_count
         )
-        products: List[EOProduct] = []
+        products: list[EOProduct] = []
         for result in results:
             product = EOProduct(
                 self.provider,
@@ -1184,8 +1086,15 @@ class QueryStringSearch(Search):
             product.properties = dict(
                 getattr(self.config, "product_type_config", {}), **product.properties
             )
-            # move assets from properties to product's attr
-            product.assets.update(product.properties.pop("assets", {}))
+            # move assets from properties to product's attr, normalize keys & roles
+            for key, asset in product.properties.pop("assets", {}).items():
+                norm_key, asset["roles"] = product.driver.guess_asset_key_and_roles(
+                    asset.get("href", ""), product
+                )
+                if norm_key:
+                    product.assets[norm_key] = asset
+            # sort assets
+            product.assets.data = dict(sorted(product.assets.data.items()))
             products.append(product)
         return products
 
@@ -1227,7 +1136,7 @@ class QueryStringSearch(Search):
                 total_results = int(count_results)
         return total_results
 
-    def get_collections(self, prep: PreparedSearch, **kwargs: Any) -> Tuple[str, ...]:
+    def get_collections(self, prep: PreparedSearch, **kwargs: Any) -> tuple[str, ...]:
         """Get the collection to which the product belongs"""
         # See https://earth.esa.int/web/sentinel/missions/sentinel-2/news/-
         # /asset_publisher/Ac0d/content/change-of
@@ -1238,7 +1147,7 @@ class QueryStringSearch(Search):
             not hasattr(prep, "product_type_def_params")
             or not prep.product_type_def_params
         ):
-            collections: Set[str] = set()
+            collections: set[str] = set()
             collection = getattr(self.config, "collection", None)
             if collection is None:
                 try:
@@ -1280,7 +1189,7 @@ class QueryStringSearch(Search):
         info_message = prep.info_message
         exception_message = prep.exception_message
         try:
-            timeout = getattr(self.config, "timeout", HTTP_REQ_TIMEOUT)
+            timeout = getattr(self.config, "timeout", DEFAULT_SEARCH_TIMEOUT)
             ssl_verify = getattr(self.config, "ssl_verify", True)
 
             retry_total = getattr(self.config, "retry_total", REQ_RETRY_TOTAL)
@@ -1293,7 +1202,7 @@ class QueryStringSearch(Search):
 
             ssl_ctx = get_ssl_context(ssl_verify)
             # auth if needed
-            kwargs: Dict[str, Any] = {}
+            kwargs: dict[str, Any] = {}
             if (
                 getattr(self.config, "need_auth", False)
                 and hasattr(prep, "auth")
@@ -1348,6 +1257,9 @@ class QueryStringSearch(Search):
                 response.raise_for_status()
         except requests.exceptions.Timeout as exc:
             raise TimeOutError(exc, timeout=timeout) from exc
+        except socket.timeout:
+            err = requests.exceptions.Timeout(request=requests.Request(url=url))
+            raise TimeOutError(err, timeout=timeout)
         except (requests.RequestException, URLError) as err:
             err_msg = err.readlines() if hasattr(err, "readlines") else ""
             if exception_message:
@@ -1424,7 +1336,7 @@ class ODataV4Search(QueryStringSearch):
 
     def do_search(
         self, prep: PreparedSearch = PreparedSearch(), **kwargs: Any
-    ) -> List[Any]:
+    ) -> list[Any]:
         """A two step search can be performed if the metadata are not given into the search result"""
 
         if getattr(self.config, "per_product_metadata_query", False):
@@ -1459,7 +1371,7 @@ class ODataV4Search(QueryStringSearch):
         else:
             return super(ODataV4Search, self).do_search(prep, **kwargs)
 
-    def get_metadata_search_url(self, entity: Dict[str, Any]) -> str:
+    def get_metadata_search_url(self, entity: dict[str, Any]) -> str:
         """Build the metadata link for the given entity"""
         return "{}({})/Metadata".format(
             self.config.api_endpoint.rstrip("/"), entity["id"]
@@ -1467,7 +1379,7 @@ class ODataV4Search(QueryStringSearch):
 
     def normalize_results(
         self, results: RawSearchResult, **kwargs: Any
-    ) -> List[EOProduct]:
+    ) -> list[EOProduct]:
         """Build EOProducts from provider results
 
         If configured, a metadata pre-mapping can be applied to simplify further metadata extraction.
@@ -1523,89 +1435,13 @@ class PostJsonSearch(QueryStringSearch):
 
     """
 
-    def _get_default_end_date_from_start_date(
-        self, start_datetime: str, product_type: str
-    ) -> str:
-        default_end_date = self.config.products.get(product_type, {}).get(
-            "_default_end_date", None
-        )
-        if default_end_date:
-            return default_end_date
-        try:
-            start_date = datetime.fromisoformat(start_datetime)
-        except ValueError:
-            start_date = datetime.strptime(start_datetime, "%Y-%m-%dT%H:%M:%SZ")
-        product_type_conf = self.config.products[product_type]
-        if (
-            "metadata_mapping" in product_type_conf
-            and "startTimeFromAscendingNode" in product_type_conf["metadata_mapping"]
-        ):
-            mapping = product_type_conf["metadata_mapping"][
-                "startTimeFromAscendingNode"
-            ]
-            if isinstance(mapping, list) and "year" in mapping[0]:
-                # if date is mapped to year/month/(day), use end_date = start_date to avoid large requests
-                end_date = start_date
-                return end_date.isoformat()
-        return self.get_product_type_cfg_value("missionEndDate", today().isoformat())
-
-    def _check_date_params(self, keywords: Dict[str, Any], product_type: str) -> None:
-        """checks if start and end date are present in the keywords and adds them if not"""
-        if (
-            "startTimeFromAscendingNode"
-            and "completionTimeFromAscendingNode" in keywords
-        ):
-            return
-        # start time given, end time missing
-        if "startTimeFromAscendingNode" in keywords:
-            keywords[
-                "completionTimeFromAscendingNode"
-            ] = self._get_default_end_date_from_start_date(
-                keywords["startTimeFromAscendingNode"], product_type
-            )
-            return
-        product_type_conf = self.config.products[product_type]
-        if (
-            "metadata_mapping" in product_type_conf
-            and "startTimeFromAscendingNode" in product_type_conf["metadata_mapping"]
-        ):
-            mapping = product_type_conf["metadata_mapping"][
-                "startTimeFromAscendingNode"
-            ]
-            if isinstance(mapping, list):
-                # get time parameters (date, year, month, ...) from metadata mapping
-                input_mapping = mapping[0].replace("{{", "").replace("}}", "")
-                time_params = [
-                    values.split(":")[0].strip() for values in input_mapping.split(",")
-                ]
-                time_params = [
-                    tp.replace('"', "").replace("'", "") for tp in time_params
-                ]
-                # if startTime is not given but other time params (e.g. year/month/(day)) are given,
-                # no default date is required
-                in_keywords = True
-                for tp in time_params:
-                    if tp not in keywords:
-                        in_keywords = False
-                if not in_keywords:
-                    keywords[
-                        "startTimeFromAscendingNode"
-                    ] = self.get_product_type_cfg_value(
-                        "missionStartDate", today().isoformat()
-                    )
-                    keywords[
-                        "completionTimeFromAscendingNode"
-                    ] = self._get_default_end_date_from_start_date(
-                        keywords["startTimeFromAscendingNode"], product_type
-                    )
-
     def query(
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> Tuple[List[EOProduct], Optional[int]]:
+    ) -> tuple[list[EOProduct], Optional[int]]:
         """Perform a search on an OpenSearch-like interface"""
-        product_type = kwargs.get("productType", None)
+        product_type = kwargs.get("productType", "")
         count = prep.count
         # remove "product_type" from search args if exists for compatibility with QueryStringSearch methods
         kwargs.pop("product_type", None)
@@ -1621,7 +1457,7 @@ class PostJsonSearch(QueryStringSearch):
 
             # provider product type specific conf
             prep.product_type_def_params = self.get_product_type_def_params(
-                product_type, **kwargs
+                product_type, format_variables=kwargs
             )
         else:
             keywords = {
@@ -1635,7 +1471,7 @@ class PostJsonSearch(QueryStringSearch):
 
             # provider product type specific conf
             prep.product_type_def_params = self.get_product_type_def_params(
-                product_type, **kwargs
+                product_type, format_variables=kwargs
             )
 
             # Add to the query, the queryable parameters set in the provider product type definition
@@ -1648,10 +1484,8 @@ class PostJsonSearch(QueryStringSearch):
                     and isinstance(self.config.metadata_mapping[k], list)
                 }
             )
-            if getattr(self.config, "dates_required", False):
-                self._check_date_params(keywords, product_type)
 
-            qp, _ = self.build_query_string(product_type, **keywords)
+            qp, _ = self.build_query_string(product_type, keywords)
 
         for query_param, query_value in qp.items():
             if (
@@ -1720,6 +1554,7 @@ class PostJsonSearch(QueryStringSearch):
             # do not try to extract total_items from search results if count is False
             del prep.total_items_nb
             del prep.need_count
+
         provider_results = self.do_search(prep, **kwargs)
         if count and total_items is None and hasattr(prep, "total_items_nb"):
             total_items = prep.total_items_nb
@@ -1733,7 +1568,7 @@ class PostJsonSearch(QueryStringSearch):
 
     def normalize_results(
         self, results: RawSearchResult, **kwargs: Any
-    ) -> List[EOProduct]:
+    ) -> list[EOProduct]:
         """Build EOProducts from provider results"""
         normalized = super().normalize_results(results, **kwargs)
         for product in normalized:
@@ -1768,12 +1603,12 @@ class PostJsonSearch(QueryStringSearch):
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> Tuple[List[str], Optional[int]]:
+    ) -> tuple[list[str], Optional[int]]:
         """Adds pagination to query parameters, and auth to url"""
         page = prep.page
         items_per_page = prep.items_per_page
         count = prep.count
-        urls: List[str] = []
+        urls: list[str] = []
         total_results = 0 if count else None
 
         if "count_endpoint" not in self.config.pagination:
@@ -1842,7 +1677,7 @@ class PostJsonSearch(QueryStringSearch):
             raise ValidationError("Cannot request empty URL")
         info_message = prep.info_message
         exception_message = prep.exception_message
-        timeout = getattr(self.config, "timeout", HTTP_REQ_TIMEOUT)
+        timeout = getattr(self.config, "timeout", DEFAULT_SEARCH_TIMEOUT)
         ssl_verify = getattr(self.config, "ssl_verify", True)
         try:
             # auth if needed
@@ -1933,24 +1768,24 @@ class StacSearch(PostJsonSearch):
         self.config.results_entry = results_entry
 
     def build_query_string(
-        self, product_type: str, **kwargs: Any
-    ) -> Tuple[Dict[str, Any], str]:
+        self, product_type: str, query_dict: dict[str, Any]
+    ) -> 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")
 
         # handle opened time intervals
         if any(
-            k in kwargs
-            for k in ("startTimeFromAscendingNode", "completionTimeFromAscendingNode")
+            q in query_dict
+            for q in ("startTimeFromAscendingNode", "completionTimeFromAscendingNode")
         ):
-            kwargs.setdefault("startTimeFromAscendingNode", "..")
-            kwargs.setdefault("completionTimeFromAscendingNode", "..")
+            query_dict.setdefault("startTimeFromAscendingNode", "..")
+            query_dict.setdefault("completionTimeFromAscendingNode", "..")
 
-        query_params = format_query_params(product_type, self.config, kwargs)
+        query_params = format_query_params(product_type, self.config, query_dict)
 
         # Build the final query string, in one go without quoting it
         # (some providers do not operate well with urlencoded and quoted query strings)
-        def quote_via(x: Any, *_args, **_kwargs) -> str:
+        def quote_via(x: Any, *_args: Any, **_kwargs: Any) -> str:
             return x
 
         return (
@@ -1960,7 +1795,7 @@ class StacSearch(PostJsonSearch):
 
     def discover_queryables(
         self, **kwargs: Any
-    ) -> Optional[Dict[str, Annotated[Any, FieldInfo]]]:
+    ) -> Optional[dict[str, Annotated[Any, FieldInfo]]]:
         """Fetch queryables list from provider using `discover_queryables` conf
 
         :param kwargs: additional filters for queryables (`productType` and other search
@@ -2007,7 +1842,8 @@ class StacSearch(PostJsonSearch):
                 return None
 
             fetch_url = unparsed_fetch_url.format(
-                provider_product_type=provider_product_type, **self.config.__dict__
+                provider_product_type=provider_product_type,
+                **self.config.__dict__,
             )
             auth = (
                 self.auth
@@ -2024,7 +1860,8 @@ class StacSearch(PostJsonSearch):
                     "{} {} instance:".format(self.provider, self.__class__.__name__),
                 ),
             )
-        except (RequestError, KeyError, AttributeError):
+        except (RequestError, KeyError, AttributeError) as e:
+            logger.warning("failure in queryables discovery: %s", e)
             return None
         else:
             json_queryables = dict()
@@ -2056,7 +1893,7 @@ class StacSearch(PostJsonSearch):
                 return None
 
             # convert json results to pydantic model fields
-            field_definitions: Dict[str, Any] = dict()
+            field_definitions: dict[str, Any] = dict()
             for json_param, json_mtd in json_queryables.items():
                 param = (
                     get_queryable_from_provider(
@@ -2072,6 +1909,10 @@ class StacSearch(PostJsonSearch):
                 field_definitions[param] = get_args(annotated_def)
 
             python_queryables = create_model("m", **field_definitions).model_fields
+            # replace geometry by geom
+            geom_queryable = python_queryables.pop("geometry", None)
+            if geom_queryable:
+                python_queryables["geom"] = geom_queryable
 
         return model_fields_to_annotated(python_queryables)
 
@@ -2085,7 +1926,7 @@ class PostJsonSearchWithStacQueryables(StacSearch, PostJsonSearch):
         PostJsonSearch.__init__(self, provider, config)
 
     def build_query_string(
-        self, product_type: str, **kwargs: Any
-    ) -> Tuple[Dict[str, Any], str]:
+        self, product_type: str, query_dict: dict[str, Any]
+    ) -> tuple[dict[str, Any], str]:
         """Build The query string using the search parameters"""
-        return PostJsonSearch.build_query_string(self, product_type, **kwargs)
+        return PostJsonSearch.build_query_string(self, product_type, query_dict)