eodag 3.1.0b1__py3-none-any.whl → 3.2.0__py3-none-any.whl

eodag/plugins/search/build_search_result.py

@@ -23,25 +23,14 @@ import logging
 import re
 from collections import OrderedDict
 from datetime import datetime, timedelta
-from typing import (
-    TYPE_CHECKING,
-    Annotated,
-    Any,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    Union,
-    cast,
-)
+from typing import TYPE_CHECKING, Annotated, Any, Optional, Union
 from urllib.parse import quote_plus, unquote_plus
 
 import geojson
 import orjson
 from dateutil.parser import isoparse
 from dateutil.tz import tzutc
-from jsonpath_ng import Child, Fields, Root
+from dateutil.utils import today
 from pydantic import Field
 from pydantic.fields import FieldInfo
 from requests.auth import AuthBase
@@ -51,19 +40,18 @@ from typing_extensions import get_args
 from eodag.api.product import EOProduct
 from eodag.api.product.metadata_mapping import (
     NOT_AVAILABLE,
-    NOT_MAPPED,
+    OFFLINE_STATUS,
     format_metadata,
-    format_query_params,
-    mtd_cfg_as_conversion_and_querypath,
     properties_from_json,
 )
 from eodag.api.search_result import RawSearchResult
 from eodag.plugins.search import PreparedSearch
 from eodag.plugins.search.qssearch import PostJsonSearch, QueryStringSearch
 from eodag.types import json_field_definition_to_python
-from eodag.types.queryables import Queryables
+from eodag.types.queryables import Queryables, QueryablesDict
 from eodag.utils import (
-    HTTP_REQ_TIMEOUT,
+    DEFAULT_MISSION_START_DATE,
+    DEFAULT_SEARCH_TIMEOUT,
     deepcopy,
     dict_items_recursive_sort,
     get_geometry_from_various,
@@ -77,9 +65,11 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger("eodag.search.build_search_result")
 
+ECMWF_PREFIX = "ecmwf:"
+
 # keywords from ECMWF keyword database + "dataset" (not part of database but exists)
 # database: https://confluence.ecmwf.int/display/UDOC/Keywords+in+MARS+and+Dissemination+requests
-ECMWF_KEYWORDS = [
+ECMWF_KEYWORDS = {
     "dataset",
     "accuracy",
     "activity",
@@ -143,10 +133,10 @@ ECMWF_KEYWORDS = [
     "truncation",
     "type",
     "use",
-]
+}
 
 # additional keywords from copernicus services
-COP_DS_KEYWORDS = [
+COP_DS_KEYWORDS = {
     "aerosol_type",
     "altitude",
     "product_type",
@@ -201,57 +191,32 @@ COP_DS_KEYWORDS = [
     "variable_type",
     "version",
     "year",
-]
+}
 
+ALLOWED_KEYWORDS = ECMWF_KEYWORDS | COP_DS_KEYWORDS
 
-def keywords_to_mdt(
-    keywords: List[str], prefix: Optional[str] = None
-) -> Dict[str, Any]:
-    """
-    Make metadata mapping dict from a list of keywords
+END = "completionTimeFromAscendingNode"
 
-    prefix:keyword:
-        - keyword
-        - $."prefix:keyword"
+START = "startTimeFromAscendingNode"
 
-    >>> keywords_to_mdt(["month", "year"])
-    {'month': ['month', '$."month"'], 'year': ['year', '$."year"']}
-    >>> keywords_to_mdt(["month", "year"], "ecmwf")
-    {'ecmwf:month': ['month', '$."ecmwf:month"'], 'ecmwf:year': ['year', '$."ecmwf:year"']}
 
-    :param keywords: List of keywords to be converted
-    :param prefix: prefix to be added to the parameter in the mapping
-    :return: metadata mapping dict
+def ecmwf_mtd() -> dict[str, Any]:
     """
-    mdt: Dict[str, Any] = {}
-    for keyword in keywords:
-        key = f"{prefix}:{keyword}" if prefix else keyword
-        mdt[key] = [keyword, f'$."{key}"']
-    return mdt
-
+    Make metadata mapping dict from a list of defined ECMWF Keywords
 
-def strip_quotes(value: Any) -> Any:
-    """Strip superfluous quotes from elements (added by mapping converter to_geojson).
+    We automatically add the #to_geojson convert to prevent modification of entries by eval() in the metadata mapping.
 
-    >>> strip_quotes("'abc'")
-    'abc'
-    >>> strip_quotes(["'abc'", '"def'])
-    ['abc', 'def']
+    keyword:
+        - keyword
+        - $."keyword"#to_geojson
 
-    :param value: value from which quotes should be removed (should be either str or list)
-    :return: value without quotes
-    :raises: NotImplementedError
+    :return: metadata mapping dict
     """
-    if isinstance(value, (list, tuple)):
-        return [strip_quotes(v) for v in value]
-    elif isinstance(value, dict):
-        raise NotImplementedError("Dict value is not supported.")
-    else:
-        return str(value).strip("'\"")
+    return {k: [k, f'{{$."{k}"#to_geojson}}'] for k in ALLOWED_KEYWORDS}
 
 
 def _update_properties_from_element(
-    prop: Dict[str, Any], element: Dict[str, Any], values: List[str]
+    prop: dict[str, Any], element: dict[str, Any], values: list[str]
 ) -> None:
     """updates a property dict with the given values based on the information from the element dict
     e.g. the type is set based on the type of the element
@@ -318,7 +283,7 @@ def _update_properties_from_element(
 
 def ecmwf_format(v: str) -> str:
     """Add ECMWF prefix to value v if v is a ECMWF keyword."""
-    return "ecmwf:" + v if v in ECMWF_KEYWORDS + COP_DS_KEYWORDS else v
+    return ECMWF_PREFIX + v if v in ALLOWED_KEYWORDS else v
 
 
 class ECMWFSearch(PostJsonSearch):
@@ -333,7 +298,7 @@ class ECMWFSearch(PostJsonSearch):
     :param provider: An eodag providers configuration dictionary
     :param config: Search plugin configuration:
 
-        * :attr:`~eodag.config.PluginConfig.remove_from_query` (``List[str]``): List of parameters
+        * :attr:`~eodag.config.PluginConfig.remove_from_query` (``list[str]``): List of parameters
           used to parse metadata but that must not be included to the query
         * :attr:`~eodag.config.PluginConfig.end_date_excluded` (``bool``): Set to `False` if
           provider does not include end date to search
@@ -350,59 +315,27 @@ class ECMWFSearch(PostJsonSearch):
     """
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
-        # cache fetching method
-        self.fetch_data = functools.lru_cache()(self._fetch_data)
-
         config.metadata_mapping = {
-            **keywords_to_mdt(ECMWF_KEYWORDS + COP_DS_KEYWORDS, "ecmwf"),
+            **ecmwf_mtd(),
+            **{
+                "id": "$.id",
+                "title": "$.id",
+                "storageStatus": OFFLINE_STATUS,
+                "downloadLink": "$.null",
+                "geometry": ["feature", "$.geometry"],
+                "defaultGeometry": "POLYGON((180 -90, 180 90, -180 90, -180 -90, 180 -90))",
+            },
             **config.metadata_mapping,
         }
 
         super().__init__(provider, config)
 
+        # ECMWF providers do not feature any api_endpoint or next_page_query_obj.
+        # Searched is faked by EODAG.
         self.config.__dict__.setdefault("api_endpoint", "")
-
-        # needed by QueryStringSearch.build_query_string / format_free_text_search
-        self.config.__dict__.setdefault("free_text_search_operations", {})
-        # needed for compatibility
         self.config.pagination.setdefault("next_page_query_obj", "{{}}")
 
-        # parse jsonpath on init: product type specific metadata-mapping
-        for product_type in self.config.products.keys():
-            if "metadata_mapping" in self.config.products[product_type].keys():
-                self.config.products[product_type][
-                    "metadata_mapping"
-                ] = mtd_cfg_as_conversion_and_querypath(
-                    self.config.products[product_type]["metadata_mapping"]
-                )
-                # Complete and ready to use product type specific metadata-mapping
-                product_type_metadata_mapping = deepcopy(self.config.metadata_mapping)
-
-                # update config using provider product type definition metadata_mapping
-                # from another product
-                other_product_for_mapping = cast(
-                    str,
-                    self.config.products[product_type].get(
-                        "metadata_mapping_from_product", ""
-                    ),
-                )
-                if other_product_for_mapping:
-                    other_product_type_def_params = self.get_product_type_def_params(
-                        other_product_for_mapping,
-                    )
-                    product_type_metadata_mapping.update(
-                        other_product_type_def_params.get("metadata_mapping", {})
-                    )
-                # from current product
-                product_type_metadata_mapping.update(
-                    self.config.products[product_type]["metadata_mapping"]
-                )
-
-                self.config.products[product_type][
-                    "metadata_mapping"
-                ] = product_type_metadata_mapping
-
-    def do_search(self, *args: Any, **kwargs: Any) -> List[Dict[str, Any]]:
+    def do_search(self, *args: Any, **kwargs: Any) -> list[dict[str, Any]]:
         """Should perform the actual search request.
 
         :param args: arguments to be used in the search
@@ -416,7 +349,7 @@ class ECMWFSearch(PostJsonSearch):
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> Tuple[List[EOProduct], Optional[int]]:
+    ) -> tuple[list[EOProduct], Optional[int]]:
         """Build ready-to-download SearchResult
 
         :param prep: :class:`~eodag.plugins.search.PreparedSearch` object containing information needed for the search
@@ -426,7 +359,7 @@ class ECMWFSearch(PostJsonSearch):
         product_type = prep.product_type
         if not product_type:
             product_type = kwargs.get("productType", None)
-        self._preprocess_search_params(kwargs, product_type)
+        kwargs = self._preprocess_search_params(kwargs, product_type)
         result, num_items = super().query(prep, **kwargs)
         if prep.count and not num_items:
             num_items = 1
@@ -438,34 +371,31 @@ class ECMWFSearch(PostJsonSearch):
         super().clear()
 
     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
 
         :param product_type: product type id
-        :param kwargs: keyword arguments to be used in the query string
+        :param query_dict: keyword arguments to be used in the query string
         :return: formatted query params and encode query string
         """
-        # parse kwargs as properties as they might be needed to build the query
-        parsed_properties = properties_from_json(
-            kwargs,
-            self.config.metadata_mapping,
-        )
-        available_properties = {
-            # We strip values of superfluous quotes (added by mapping converter to_geojson).
-            k: strip_quotes(v)
-            for k, v in parsed_properties.items()
-            if v not in [NOT_AVAILABLE, NOT_MAPPED]
-        }
+        query_dict["_date"] = f"{query_dict.get(START)}/{query_dict.get(END)}"
+
+        # Reorder kwargs to make sure year/month/day/time if set overwrite default datetime.
+        priority_keys = [
+            START,
+            END,
+        ]
+        ordered_kwargs = {k: query_dict[k] for k in priority_keys if k in query_dict}
+        ordered_kwargs.update(query_dict)
 
-        # build and return the query
         return super().build_query_string(
-            product_type=product_type, **available_properties
+            product_type=product_type, query_dict=ordered_kwargs
         )
 
     def _preprocess_search_params(
-        self, params: Dict[str, Any], product_type: Optional[str]
-    ) -> None:
+        self, params: dict[str, Any], product_type: Optional[str]
+    ) -> dict[str, Any]:
         """Preprocess search parameters before making a request to the CDS API.
 
         This method is responsible for checking and updating the provided search parameters
@@ -481,28 +411,20 @@ class ECMWFSearch(PostJsonSearch):
             # if available, update search params using datacube query-string
             _dc_qp = geojson.loads(unquote_plus(unquote_plus(_dc_qs)))
             if "/to/" in _dc_qp.get("date", ""):
-                (
-                    params["startTimeFromAscendingNode"],
-                    params["completionTimeFromAscendingNode"],
-                ) = _dc_qp["date"].split("/to/")
+                params[START], params[END] = _dc_qp["date"].split("/to/")
             elif "/" in _dc_qp.get("date", ""):
-                (
-                    params["startTimeFromAscendingNode"],
-                    params["completionTimeFromAscendingNode"],
-                ) = _dc_qp["date"].split("/")
+                (params[START], params[END],) = _dc_qp[
+                    "date"
+                ].split("/")
             elif _dc_qp.get("date", None):
-                params["startTimeFromAscendingNode"] = params[
-                    "completionTimeFromAscendingNode"
-                ] = _dc_qp["date"]
+                params[START] = params[END] = _dc_qp["date"]
 
             if "/" in _dc_qp.get("area", ""):
                 params["geometry"] = _dc_qp["area"].split("/")
 
-        non_none_params = {k: v for k, v in params.items() if v}
-
-        # productType
-        dataset = params.get("ecmwf:dataset", None)
-        params["productType"] = non_none_params.get("productType", dataset)
+        params = {
+            k.removeprefix(ECMWF_PREFIX): v for k, v in params.items() if v is not None
+        }
 
         # dates
         # check if default dates have to be added
@@ -510,25 +432,23 @@ class ECMWFSearch(PostJsonSearch):
             self._check_date_params(params, product_type)
 
         # adapt end date if it is midnight
-        if "completionTimeFromAscendingNode" in params:
+        if END in params:
             end_date_excluded = getattr(self.config, "end_date_excluded", True)
             is_datetime = True
             try:
-                end_date = datetime.strptime(
-                    params["completionTimeFromAscendingNode"], "%Y-%m-%dT%H:%M:%SZ"
-                )
+                end_date = datetime.strptime(params[END], "%Y-%m-%dT%H:%M:%SZ")
                 end_date = end_date.replace(tzinfo=tzutc())
             except ValueError:
                 try:
                     end_date = datetime.strptime(
-                        params["completionTimeFromAscendingNode"],
+                        params[END],
                         "%Y-%m-%dT%H:%M:%S.%fZ",
                     )
                     end_date = end_date.replace(tzinfo=tzutc())
                 except ValueError:
-                    end_date = isoparse(params["completionTimeFromAscendingNode"])
+                    end_date = isoparse(params[END])
                     is_datetime = False
-            start_date = isoparse(params["startTimeFromAscendingNode"])
+            start_date = isoparse(params[START])
             if (
                 not end_date_excluded
                 and is_datetime
@@ -537,15 +457,90 @@ class ECMWFSearch(PostJsonSearch):
                 == end_date.replace(hour=0, minute=0, second=0, microsecond=0)
             ):
                 end_date += timedelta(days=-1)
-                params["completionTimeFromAscendingNode"] = end_date.isoformat()
+                params[END] = end_date.isoformat()
 
         # geometry
         if "geometry" in params:
             params["geometry"] = get_geometry_from_various(geometry=params["geometry"])
 
+        return params
+
+    def _check_date_params(
+        self, keywords: dict[str, Any], product_type: Optional[str]
+    ) -> None:
+        """checks if start and end date are present in the keywords and adds them if not"""
+
+        if START and END in keywords:
+            return
+
+        product_type_conf = getattr(self.config, "metadata_mapping", {})
+        if (
+            product_type
+            and product_type in self.config.products
+            and "metadata_mapping" in self.config.products[product_type]
+        ):
+            product_type_conf = self.config.products[product_type]["metadata_mapping"]
+
+        # start time given, end time missing
+        if START in keywords:
+            keywords[END] = (
+                keywords[START]
+                if END in product_type_conf
+                else self.get_product_type_cfg_value(
+                    "missionEndDate", today().isoformat()
+                )
+            )
+            return
+
+        if END in product_type_conf:
+            mapping = product_type_conf[START]
+            if not isinstance(mapping, list):
+                mapping = product_type_conf[END]
+            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
+                        break
+                if not in_keywords:
+                    keywords[START] = self.get_product_type_cfg_value(
+                        "missionStartDate", DEFAULT_MISSION_START_DATE
+                    )
+                    keywords[END] = (
+                        keywords[START]
+                        if END in product_type_conf
+                        else self.get_product_type_cfg_value(
+                            "missionEndDate", today().isoformat()
+                        )
+                    )
+
+    def _get_product_type_queryables(
+        self, product_type: Optional[str], alias: Optional[str], filters: dict[str, Any]
+    ) -> QueryablesDict:
+        """Override to set additional_properties to false."""
+        default_values: dict[str, Any] = deepcopy(
+            getattr(self.config, "products", {}).get(product_type, {})
+        )
+        default_values.pop("metadata_mapping", None)
+
+        filters["productType"] = product_type
+        queryables = self.discover_queryables(**{**default_values, **filters}) or {}
+
+        return QueryablesDict(additional_properties=False, **queryables)
+
     def discover_queryables(
         self, **kwargs: Any
-    ) -> Optional[Dict[str, Annotated[Any, FieldInfo]]]:
+    ) -> 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
@@ -553,65 +548,64 @@ class ECMWFSearch(PostJsonSearch):
         :returns: fetched queryable parameters dict
         """
         product_type = kwargs.pop("productType")
-        product_type_config = self.config.products.get(product_type, {})
-        provider_product_type = (
-            product_type_config.get("ecmwf:dataset", None)
-            or product_type_config["productType"]
-        )
-        if "start" in kwargs:
-            kwargs["startTimeFromAscendingNode"] = kwargs.pop("start")
-        if "end" in kwargs:
-            kwargs["completionTimeFromAscendingNode"] = kwargs.pop("end")
+
+        pt_config = self.get_product_type_def_params(product_type)
+
+        default_values = deepcopy(pt_config)
+        default_values.pop("metadata_mapping", None)
+        filters = {**default_values, **kwargs}
+
+        if "start" in filters:
+            filters[START] = filters.pop("start")
+        if "end" in filters:
+            filters[END] = filters.pop("end")
 
         # extract default datetime
-        processed_kwargs = deepcopy(kwargs)
-        self._preprocess_search_params(processed_kwargs, product_type)
+        processed_filters = self._preprocess_search_params(
+            deepcopy(filters), product_type
+        )
 
         constraints_url = format_metadata(
             getattr(self.config, "discover_queryables", {}).get("constraints_url", ""),
-            **kwargs,
+            **filters,
         )
-        constraints: List[Dict[str, Any]] = self.fetch_data(constraints_url)
+        constraints: list[dict[str, Any]] = self._fetch_data(constraints_url)
 
         form_url = format_metadata(
             getattr(self.config, "discover_queryables", {}).get("form_url", ""),
-            **kwargs,
+            **filters,
         )
-        form = self.fetch_data(form_url)
+        form: list[dict[str, Any]] = self._fetch_data(form_url)
 
-        formated_kwargs = self.format_as_provider_keyword(
-            product_type, processed_kwargs
+        formated_filters = self.format_as_provider_keyword(
+            product_type, processed_filters
         )
         # we re-apply kwargs input to consider override of year, month, day and time.
-        for key in kwargs:
-            if key.startswith("ecmwf:"):
-                formated_kwargs[key.replace("ecmwf:", "")] = kwargs[key]
-            elif key in (
-                "startTimeFromAscendingNode",
-                "completionTimeFromAscendingNode",
+        for k, v in {**default_values, **kwargs}.items():
+            key = k.removeprefix(ECMWF_PREFIX)
+
+            if key not in ALLOWED_KEYWORDS | {
+                START,
+                END,
                 "geom",
-            ):
-                formated_kwargs[key] = kwargs[key]
-            else:
+                "geometry",
+            }:
                 raise ValidationError(
                     f"{key} is not a queryable parameter for {self.provider}"
                 )
 
-        # we use non empty kwargs as default to integrate user inputs
+            formated_filters[key] = v
+
+        # we use non empty filters as default to integrate user inputs
         # it is needed because pydantic json schema does not represent "value"
         # but only "default"
-        non_empty_formated: Dict[str, Any] = {
+        non_empty_formated: dict[str, Any] = {
             k: v
-            for k, v in formated_kwargs.items()
-            if v and (not isinstance(v, list) or all(v))
-        }
-        non_empty_kwargs: Dict[str, Any] = {
-            k: v
-            for k, v in processed_kwargs.items()
+            for k, v in formated_filters.items()
             if v and (not isinstance(v, list) or all(v))
         }
 
-        required_keywords: Set[str] = set()
+        required_keywords: set[str] = set()
 
         # calculate available values
         if constraints:
@@ -625,33 +619,36 @@ class ECMWFSearch(PostJsonSearch):
             # Pre-compute the required keywords (present in all constraint dicts)
             # when form, required keywords are extracted directly from form
             if not form:
-                required_keywords = set(constraints[0].keys())
-                for constraint in constraints[1:]:
-                    required_keywords.intersection_update(constraint.keys())
+                required_keywords = set.intersection(
+                    *(map(lambda d: set(d.keys()), constraints))
+                )
+
         else:
             values_url = getattr(self.config, "available_values_url", "")
             if not values_url:
                 return self.queryables_from_metadata_mapping(product_type)
             if "{" in values_url:
-                values_url = values_url.format(productType=provider_product_type)
-            data = self.fetch_data(values_url)
+                values_url = values_url.format(**filters)
+            data = self._fetch_data(values_url)
             available_values = data["constraints"]
             required_keywords = data.get("required", [])
 
         # To check if all keywords are queryable parameters, we check if they are in the
         # available values or the product type config (available values calculated from the
         # constraints might not include all queryables)
-        for keyword in kwargs:
+        for keyword in filters:
             if (
                 keyword
                 not in available_values.keys()
-                | product_type_config.keys()
+                | pt_config.keys()
                 | {
-                    "startTimeFromAscendingNode",
-                    "completionTimeFromAscendingNode",
+                    START,
+                    END,
                     "geom",
                 }
-                and keyword.replace("ecmwf:", "") not in available_values
+                and keyword not in [f["name"] for f in form]
+                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")
 
@@ -664,24 +661,24 @@ class ECMWFSearch(PostJsonSearch):
             )
         else:
             queryables = self.queryables_by_values(
-                available_values, list(required_keywords), non_empty_kwargs
+                available_values, list(required_keywords), non_empty_formated
             )
 
         # ecmwf:date is replaced by start and end.
         # start and end filters are supported whenever combinations of "year", "month", "day" filters exist
         if (
-            queryables.pop("ecmwf:date", None)
-            or "ecmwf:year" in queryables
-            or "ecmwf:hyear" in queryables
+            queryables.pop(f"{ECMWF_PREFIX}date", None)
+            or f"{ECMWF_PREFIX}year" in queryables
+            or f"{ECMWF_PREFIX}hyear" in queryables
         ):
             queryables.update(
                 {
                     "start": Queryables.get_with_default(
-                        "start", non_empty_kwargs.get("startTimeFromAscendingNode")
+                        "start", processed_filters.get(START)
                     ),
                     "end": Queryables.get_with_default(
                         "end",
-                        non_empty_kwargs.get("completionTimeFromAscendingNode"),
+                        processed_filters.get(END),
                     ),
                 }
             )
@@ -689,7 +686,7 @@ class ECMWFSearch(PostJsonSearch):
         # area is geom in EODAG.
         if queryables.pop("area", None):
             queryables["geom"] = Annotated[
-                Union[str, Dict[str, float], BaseGeometry],
+                Union[str, dict[str, float], BaseGeometry],
                 Field(
                     None,
                     description="Read EODAG documentation for all supported geometry format.",
@@ -700,10 +697,10 @@ class ECMWFSearch(PostJsonSearch):
 
     def available_values_from_constraints(
         self,
-        constraints: list[Dict[str, Any]],
-        input_keywords: Dict[str, Any],
-        form_keywords: List[str],
-    ) -> Dict[str, List[str]]:
+        constraints: list[dict[str, Any]],
+        input_keywords: dict[str, Any],
+        form_keywords: list[str],
+    ) -> dict[str, list[str]]:
         """
         Filter constraints using input_keywords. Return list of available queryables.
         All constraint entries must have the same parameters.
@@ -727,9 +724,9 @@ class ECMWFSearch(PostJsonSearch):
         )
 
         # filter constraint entries matching input keyword values
-        filtered_constraints: List[Dict[str, Any]]
+        filtered_constraints: list[dict[str, Any]]
 
-        parsed_keywords: List[str] = []
+        parsed_keywords: list[str] = []
         for keyword in ordered_keywords:
             values = input_keywords.get(keyword)
 
@@ -742,14 +739,15 @@ class ECMWFSearch(PostJsonSearch):
                 raise ValidationError(
                     f"Parameter value as object is not supported: {keyword}={values}"
                 )
-            filter_v = values if isinstance(values, (list, tuple)) else [values]
 
             # We convert every single value to a list of string
+            filter_v = values if isinstance(values, (list, tuple)) else [values]
+
             # We strip values of superfluous quotes (added by mapping converter to_geojson).
             # ECMWF accept values with /to/. We need to split it to an array
             # ECMWF accept values in format val1/val2. We need to split it to an array
             sep = re.compile(r"/to/|/")
-            filter_v = [i for v in filter_v for i in sep.split(strip_quotes(v))]
+            filter_v = [i for v in filter_v for i in sep.split(str(v))]
 
             # special handling for time 0000 converted to 0 by pre-formating with metadata_mapping
             if keyword.split(":")[-1] == "time":
@@ -768,7 +766,10 @@ class ECMWFSearch(PostJsonSearch):
                 # we assume that if the first value is an interval, all values are intervals
                 present_values = []
                 if keyword == "date" and "/" in entry[keyword][0]:
-                    if any(is_range_in_range(x, values[0]) for x in entry[keyword]):
+                    input_range = values
+                    if isinstance(values, list):
+                        input_range = values[0]
+                    if any(is_range_in_range(x, input_range) for x in entry[keyword]):
                         present_values = filter_v
                 else:
                     present_values = [
@@ -788,12 +789,12 @@ class ECMWFSearch(PostJsonSearch):
                     {value for c in constraints for value in c.get(keyword, [])}
                 )
                 # restore ecmwf: prefix before raising error
-                keyword = f"ecmwf:{keyword}"
+                keyword = ECMWF_PREFIX + keyword
 
                 all_keywords_str = ""
                 if len(parsed_keywords) > 1:
                     keywords = [
-                        f"ecmwf:{k}={pk}"
+                        f"{ECMWF_PREFIX + k}={pk}"
                         for k in parsed_keywords
                         if (pk := input_keywords.get(k))
                     ]
@@ -808,7 +809,7 @@ class ECMWFSearch(PostJsonSearch):
             parsed_keywords.append(keyword)
             constraints = filtered_constraints
 
-        available_values: Dict[str, Any] = {k: set() for k in ordered_keywords}
+        available_values: dict[str, Any] = {k: set() for k in ordered_keywords}
 
         # we aggregate the constraint entries left
         for entry in constraints:
@@ -819,10 +820,10 @@ class ECMWFSearch(PostJsonSearch):
 
     def queryables_by_form(
         self,
-        form: List[Dict[str, Any]],
-        available_values: Dict[str, List[str]],
-        defaults: Dict[str, Any],
-    ) -> Dict[str, Annotated[Any, FieldInfo]]:
+        form: list[dict[str, Any]],
+        available_values: dict[str, list[str]],
+        defaults: dict[str, Any],
+    ) -> dict[str, Annotated[Any, FieldInfo]]:
         """
         Generate Annotated field definitions from form entries and available values
         Used by Copernicus services like cop_cds, cop_ads, cop_ewds.
@@ -832,9 +833,9 @@ class ECMWFSearch(PostJsonSearch):
         :param defaults: default values for the parameters
         :return: dict of annotated queryables
         """
-        queryables: Dict[str, Annotated[Any, FieldInfo]] = {}
+        queryables: dict[str, Annotated[Any, FieldInfo]] = {}
 
-        required_list: List[str] = []
+        required_list: list[str] = []
         for element in form:
             name: str = element["name"]
 
@@ -842,6 +843,8 @@ class ECMWFSearch(PostJsonSearch):
             if name in ("area_group", "global", "warning", "licences"):
                 continue
             if "type" not in element or element["type"] == "FreeEditionWidget":
+                # FreeEditionWidget used to select the whole available region
+                # and to provide comments for the dataset
                 continue
 
             # ordering done by id -> set id to high value if not present -> element will be last
@@ -869,18 +872,11 @@ class ECMWFSearch(PostJsonSearch):
                 if fields and (comment := fields[0].get("comment")):
                     prop["description"] = comment
 
-                if d := details.get("default"):
-                    default = default or (d[0] if fields else d)
-
             if name == "area" and isinstance(default, dict):
                 default = list(default.values())
 
-            if default:
-                # We strip values of superfluous quotes (addded by mapping converter to_geojson).
-                default = strip_quotes(default)
-
             # sometimes form returns default as array instead of string
-            if default and prop["type"] == "string" and isinstance(default, list):
+            if default and prop.get("type") == "string" and isinstance(default, list):
                 default = ",".join(default)
 
             is_required = bool(element.get("required"))
@@ -901,10 +897,10 @@ class ECMWFSearch(PostJsonSearch):
 
     def queryables_by_values(
         self,
-        available_values: Dict[str, List[str]],
-        required_keywords: List[str],
-        defaults: Dict[str, Any],
-    ) -> Dict[str, Annotated[Any, FieldInfo]]:
+        available_values: dict[str, list[str]],
+        required_keywords: list[str],
+        defaults: dict[str, Any],
+    ) -> dict[str, Annotated[Any, FieldInfo]]:
         """
         Generate Annotated field definitions from available values.
         Used by ECMWF data providers like dedt_lumi.
@@ -918,19 +914,17 @@ class ECMWFSearch(PostJsonSearch):
         # Needed to map constraints like "xxxx" to eodag parameter "ecmwf:xxxx"
         required = [ecmwf_format(k) for k in required_keywords]
 
-        queryables: Dict[str, Annotated[Any, FieldInfo]] = {}
+        queryables: dict[str, Annotated[Any, FieldInfo]] = {}
         for name, values in available_values.items():
             # Rename keywords from form with metadata mapping.
             # Needed to map constraints like "xxxx" to eodag parameter "ecmwf:xxxx"
             key = ecmwf_format(name)
 
-            default = defaults.get(key)
-
             queryables[key] = Annotated[
                 get_args(
                     json_field_definition_to_python(
                         {"type": "string", "title": name, "enum": values},
-                        default_value=strip_quotes(default) if default else None,
+                        default_value=defaults.get(name),
                         required=bool(key in required),
                     )
                 )
@@ -939,24 +933,34 @@ class ECMWFSearch(PostJsonSearch):
         return queryables
 
     def format_as_provider_keyword(
-        self, product_type: str, properties: Dict[str, Any]
-    ) -> Dict[str, Any]:
+        self, product_type: str, properties: dict[str, Any]
+    ) -> dict[str, Any]:
         """Return provider equivalent keyword names from EODAG keywords.
 
         :param product_type: product type id
         :param properties: dict of properties to be formatted
         :return: dict of formatted properties
         """
-        parsed_properties = properties_from_json(
-            properties,
-            self.config.metadata_mapping,
+        properties["productType"] = product_type
+
+        # provider product type specific conf
+        product_type_def_params = self.get_product_type_def_params(
+            product_type, format_variables=properties
         )
-        available_properties = {
-            k: v
-            for k, v in parsed_properties.items()
-            if v not in [NOT_AVAILABLE, NOT_MAPPED]
-        }
-        return format_query_params(product_type, self.config, available_properties)
+
+        # Add to the query, the queryable parameters set in the provider product type definition
+        properties.update(
+            {
+                k: v
+                for k, v in product_type_def_params.items()
+                if k not in properties.keys()
+                and k in self.config.metadata_mapping.keys()
+                and isinstance(self.config.metadata_mapping[k], list)
+            }
+        )
+        qp, _ = self.build_query_string(product_type, properties)
+
+        return qp
 
     def _fetch_data(self, url: str) -> Any:
         """
@@ -973,12 +977,12 @@ class ECMWFSearch(PostJsonSearch):
             if hasattr(self, "auth") and isinstance(self.auth, AuthBase)
             else None
         )
-        timeout = getattr(self.config, "timeout", HTTP_REQ_TIMEOUT)
-        return fetch_json(url, auth=auth, timeout=timeout)
+        timeout = getattr(self.config, "timeout", DEFAULT_SEARCH_TIMEOUT)
+        return functools.lru_cache()(fetch_json)(url, auth=auth, timeout=timeout)
 
     def normalize_results(
         self, results: RawSearchResult, **kwargs: Any
-    ) -> List[EOProduct]:
+    ) -> list[EOProduct]:
         """Build :class:`~eodag.api.product._product.EOProduct` from provider result
 
         :param results: Raw provider result as single dict in list
@@ -1044,67 +1048,37 @@ class ECMWFSearch(PostJsonSearch):
             discovery_config=getattr(self.config, "discover_metadata", {}),
         )
 
-        if not product_type:
-            product_type = parsed_properties.get("productType", None)
+        properties = {
+            # use product_type_config as default properties
+            **getattr(self.config, "product_type_config", {}),
+            **{ecmwf_format(k): v for k, v in parsed_properties.items()},
+        }
+
+        def slugify(date_str: str) -> str:
+            return date_str.split("T")[0].replace("-", "")
 
         # build product id
-        id_prefix = (product_type or self.provider).upper()
-        if (
-            "startTimeFromAscendingNode" in parsed_properties
-            and parsed_properties["startTimeFromAscendingNode"] != "Not Available"
-            and "completionTimeFromAscendingNode" in parsed_properties
-            and parsed_properties["completionTimeFromAscendingNode"] != "Not Available"
-        ):
-            product_id = "%s_%s_%s_%s" % (
-                id_prefix,
-                parsed_properties["startTimeFromAscendingNode"]
-                .split("T")[0]
-                .replace("-", ""),
-                parsed_properties["completionTimeFromAscendingNode"]
-                .split("T")[0]
-                .replace("-", ""),
-                query_hash,
-            )
-        elif (
-            "startTimeFromAscendingNode" in parsed_properties
-            and parsed_properties["startTimeFromAscendingNode"] != "Not Available"
-        ):
-            product_id = "%s_%s_%s" % (
-                id_prefix,
-                parsed_properties["startTimeFromAscendingNode"]
-                .split("T")[0]
-                .replace("-", ""),
-                query_hash,
-            )
-        else:
-            product_id = f"{id_prefix}_{query_hash}"
-
-        parsed_properties["id"] = parsed_properties["title"] = product_id
-
-        # update downloadLink and orderLink
-        parsed_properties["_dc_qs"] = quote_plus(qs)
-        if parsed_properties["downloadLink"] != "Not Available":
-            parsed_properties["downloadLink"] += f"?{qs}"
-
-        # parse metadata needing downloadLink
-        dl_path = Fields("downloadLink")
-        dl_path_from_root = Child(Root(), dl_path)
-        for param, mapping in self.config.metadata_mapping.items():
-            if dl_path in mapping or dl_path_from_root in mapping:
-                parsed_properties.update(
-                    properties_from_json(parsed_properties, {param: mapping})
-                )
+        product_id = (product_type or kwargs.get("dataset") or self.provider).upper()
 
-        # use product_type_config as default properties
-        parsed_properties = dict(
-            getattr(self.config, "product_type_config", {}),
-            **parsed_properties,
-        )
+        start = properties.get(START, NOT_AVAILABLE)
+        end = properties.get(END, NOT_AVAILABLE)
+
+        if start != NOT_AVAILABLE:
+            product_id += f"_{slugify(start)}"
+            if end != NOT_AVAILABLE:
+                product_id += f"_{slugify(end)}"
+
+        product_id += f"_{query_hash}"
+
+        properties["id"] = properties["title"] = product_id
+
+        # used by server mode to generate downloadlink href
+        properties["_dc_qs"] = quote_plus(qs)
 
         product = EOProduct(
             provider=self.provider,
             productType=product_type,
-            properties=parsed_properties,
+            properties=properties,
         )
 
         return [
@@ -1150,7 +1124,7 @@ class MeteoblueSearch(ECMWFSearch):
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> Tuple[List[str], int]:
+    ) -> tuple[list[str], int]:
         """Wraps PostJsonSearch.collect_search_urls to force product count to 1
 
         :param prep: :class:`~eodag.plugins.search.PreparedSearch` object containing information for the search
@@ -1162,7 +1136,7 @@ class MeteoblueSearch(ECMWFSearch):
 
     def do_search(
         self, prep: PreparedSearch = PreparedSearch(items_per_page=None), **kwargs: Any
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Perform the actual search request, and return result in a single element.
 
         :param prep: :class:`~eodag.plugins.search.PreparedSearch` object containing information for the search
@@ -1181,17 +1155,15 @@ class MeteoblueSearch(ECMWFSearch):
         return [response.json()]
 
     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
 
         :param product_type: product type id
-        :param kwargs: keyword arguments to be used in the query string
+        :param query_dict: keyword arguments to be used in the query string
         :return: formatted query params and encode query string
         """
-        return QueryStringSearch.build_query_string(
-            self, product_type=product_type, **kwargs
-        )
+        return QueryStringSearch.build_query_string(self, product_type, query_dict)
 
 
 class WekeoECMWFSearch(ECMWFSearch):
@@ -1221,7 +1193,7 @@ class WekeoECMWFSearch(ECMWFSearch):
 
     def normalize_results(
         self, results: RawSearchResult, **kwargs: Any
-    ) -> List[EOProduct]:
+    ) -> list[EOProduct]:
         """Build :class:`~eodag.api.product._product.EOProduct` from provider result
 
         :param results: Raw provider result as single dict in list
@@ -1247,7 +1219,7 @@ class WekeoECMWFSearch(ECMWFSearch):
 
         return normalized
 
-    def do_search(self, *args: Any, **kwargs: Any) -> List[Dict[str, Any]]:
+    def do_search(self, *args: Any, **kwargs: Any) -> list[dict[str, Any]]:
         """Should perform the actual search request.
 
         :param args: arguments to be used in the search
@@ -1255,25 +1227,3 @@ class WekeoECMWFSearch(ECMWFSearch):
         :return: list containing the results from the provider in json format
         """
         return QueryStringSearch.do_search(self, *args, **kwargs)
-
-    def build_query_string(
-        self, product_type: str, **kwargs: Any
-    ) -> Tuple[Dict[str, Any], str]:
-        """Build The query string using the search parameters
-
-        :param product_type: product type id
-        :param kwargs: keyword arguments to be used in the query string
-        :return: formatted query params and encode query string
-        """
-        # Reorder kwargs to make sure year/month/day/time if set overwrite default datetime.
-        # strip_quotes to remove duplicated quotes like "'1_1'" produced by convertors like to_geojson.
-        priority_keys = [
-            "startTimeFromAscendingNode",
-            "completionTimeFromAscendingNode",
-        ]
-        ordered_kwargs = {k: kwargs[k] for k in priority_keys if k in kwargs}
-        ordered_kwargs.update({k: strip_quotes(v) for k, v in kwargs.items()})
-
-        return QueryStringSearch.build_query_string(
-            self, product_type=product_type, **ordered_kwargs
-        )