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

eodag/plugins/search/build_search_result.py

@@ -17,21 +17,13 @@
 # limitations under the License.
 from __future__ import annotations
 
+import functools
 import hashlib
 import logging
-from datetime import datetime, timedelta, timezone
-from typing import (
-    TYPE_CHECKING,
-    Annotated,
-    Any,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    cast,
-    get_args,
-)
+import re
+from collections import OrderedDict
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING, Annotated, Any, Optional, Union, cast
 from urllib.parse import quote_plus, unquote_plus
 
 import geojson
@@ -39,235 +31,329 @@ import orjson
 from dateutil.parser import isoparse
 from dateutil.tz import tzutc
 from jsonpath_ng import Child, Fields, Root
-from pydantic import create_model
+from pydantic import Field
 from pydantic.fields import FieldInfo
+from requests.auth import AuthBase
+from shapely.geometry.base import BaseGeometry
+from typing_extensions import get_args
 
 from eodag.api.product import EOProduct
 from eodag.api.product.metadata_mapping import (
     NOT_AVAILABLE,
     NOT_MAPPED,
-    get_queryable_from_provider,
+    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.base import Search
-from eodag.plugins.search.qssearch import PostJsonSearch
-from eodag.types import json_field_definition_to_python, model_fields_to_annotated
-from eodag.types.queryables import CommonQueryables
+from eodag.plugins.search.qssearch import PostJsonSearch, QueryStringSearch
+from eodag.types import json_field_definition_to_python
+from eodag.types.queryables import Queryables, QueryablesDict
 from eodag.utils import (
-    DEFAULT_MISSION_START_DATE,
+    DEFAULT_SEARCH_TIMEOUT,
     deepcopy,
     dict_items_recursive_sort,
     get_geometry_from_various,
-)
-from eodag.utils.constraints import (
-    fetch_constraints,
-    get_constraint_queryables_with_additional_params,
+    is_range_in_range,
 )
 from eodag.utils.exceptions import ValidationError
+from eodag.utils.requests import fetch_json
 
 if TYPE_CHECKING:
     from eodag.config import PluginConfig
 
 logger = logging.getLogger("eodag.search.build_search_result")
 
-
-class BuildPostSearchResult(PostJsonSearch):
-    """BuildPostSearchResult search plugin.
-
-    This plugin, which inherits from :class:`~eodag.plugins.search.qssearch.PostJsonSearch`,
-    performs a POST request and uses its result to build a single :class:`~eodag.api.search_result.SearchResult`
-    object.
-
-    The available configuration parameters are inherited from parent classes
-    (:class:`~eodag.plugins.search.qssearch.PostJsonSearch` and
-    :class:`~eodag.plugins.search.qssearch.QueryStringSearch`), with particularly for this plugin:
-
-    :param provider: provider name
-    :param config: Search plugin configuration:
-
-        * :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
-
+# 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 = [
+    "dataset",
+    "accuracy",
+    "activity",
+    "anoffset",
+    "bitmap",
+    "block",
+    "channel",
+    "class",
+    "database",
+    "date",
+    "diagnostic",
+    "direction",
+    "domain",
+    "duplicates",
+    "expect",
+    "expver",
+    "fcmonth",
+    "fcperiod",
+    "fieldset",
+    "filter",
+    "format",
+    "frame",
+    "frequency",
+    "generation",
+    "grid",
+    "hdate",
+    "ident",
+    "interpolation",
+    "intgrid",
+    "iteration",
+    "latitude",
+    "levelist",
+    "levtype",
+    "longitude",
+    "lsm",
+    "method",
+    "number",
+    "obsgroup",
+    "obstype",
+    "origin",
+    "packing",
+    "padding",
+    "param",
+    "priority",
+    "product",
+    "range",
+    "realization",
+    "refdate",
+    "reference",
+    "reportype",
+    "repres",
+    "resolution",
+    "rotation",
+    "section",
+    "source",
+    "step",
+    "stream",
+    "system",
+    "target",
+    "time",
+    "truncation",
+    "type",
+    "use",
+]
+
+# additional keywords from copernicus services
+COP_DS_KEYWORDS = [
+    "aerosol_type",
+    "altitude",
+    "product_type",
+    "band",
+    "cdr_type",
+    "data_format",
+    "dataset_type",
+    "day",
+    "download_format",
+    "ensemble_member",
+    "experiment",
+    "forcing_type",
+    "gcm",
+    "hday",
+    "hmonth",
+    "horizontal_resolution",
+    "hydrological_model",
+    "hydrological_year",
+    "hyear",
+    "input_observations",
+    "leadtime_hour",
+    "leadtime_month",
+    "level",
+    "location",
+    "model",
+    "model_level",
+    "model_levels",
+    "month",
+    "nominal_day",
+    "originating_centre",
+    "period",
+    "pressure_level",
+    "processing_level",
+    "processing_type",
+    "product_version",
+    "quantity",
+    "rcm",
+    "region",
+    "release_version",
+    "satellite",
+    "sensor",
+    "sensor_and_algorithm",
+    "soil_level",
+    "sky_type",
+    "statistic",
+    "system_version",
+    "temporal_aggregation",
+    "time_aggregation",
+    "time_reference",
+    "time_step",
+    "variable",
+    "variable_type",
+    "version",
+    "year",
+]
+
+
+def keywords_to_mdt(
+    keywords: list[str], prefix: Optional[str] = None
+) -> dict[str, Any]:
     """
+    Make metadata mapping dict from a list of keywords
 
-    def count_hits(
-        self, count_url: Optional[str] = None, result_type: Optional[str] = None
-    ) -> int:
-        """Count method that will always return 1."""
-        return 1
-
-    def collect_search_urls(
-        self,
-        prep: PreparedSearch = PreparedSearch(),
-        **kwargs: Any,
-    ) -> Tuple[List[str], int]:
-        """Wraps PostJsonSearch.collect_search_urls to force product count to 1"""
-        urls, _ = super(BuildPostSearchResult, self).collect_search_urls(prep, **kwargs)
-        return urls, 1
-
-    def do_search(
-        self, prep: PreparedSearch = PreparedSearch(items_per_page=None), **kwargs: Any
-    ) -> List[Dict[str, Any]]:
-        """Perform the actual search request, and return result in a single element."""
-        prep.url = prep.search_urls[0]
-        prep.info_message = f"Sending search request: {prep.url}"
-        prep.exception_message = (
-            f"Skipping error while searching for {self.provider}"
-            f" {self.__class__.__name__} instance"
-        )
-        response = self._request(prep)
-
-        return [response.json()]
-
-    def normalize_results(
-        self, results: RawSearchResult, **kwargs: Any
-    ) -> List[EOProduct]:
-        """Build :class:`~eodag.api.product._product.EOProduct` from provider result
-
-        :param results: Raw provider result as single dict in list
-        :param kwargs: Search arguments
-        :returns: list of single :class:`~eodag.api.product._product.EOProduct`
-        """
-        product_type = kwargs.get("productType")
+    prefix:keyword:
+        - keyword
+        - $."prefix:keyword"
 
-        result = results[0]
+    >>> 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"']}
 
-        # datacube query string got from previous search
-        _dc_qs = kwargs.pop("_dc_qs", None)
-        if _dc_qs is not None:
-            qs = unquote_plus(unquote_plus(_dc_qs))
-            sorted_unpaginated_query_params = geojson.loads(qs)
-        else:
-            # update result with query parameters without pagination (or search-only params)
-            if isinstance(
-                self.config.pagination["next_page_query_obj"], str
-            ) and hasattr(results, "query_params_unpaginated"):
-                unpaginated_query_params = results.query_params_unpaginated
-            elif isinstance(self.config.pagination["next_page_query_obj"], str):
-                next_page_query_obj = orjson.loads(
-                    self.config.pagination["next_page_query_obj"].format()
-                )
-                unpaginated_query_params = {
-                    k: v[0] if (isinstance(v, list) and len(v) == 1) else v
-                    for k, v in results.query_params.items()
-                    if (k, v) not in next_page_query_obj.items()
-                }
-            else:
-                unpaginated_query_params = self.query_params
-
-            # query hash, will be used to build a product id
-            sorted_unpaginated_query_params = dict_items_recursive_sort(
-                unpaginated_query_params
-            )
-
-        # use all available query_params to parse properties
-        result = dict(
-            result,
-            **sorted_unpaginated_query_params,
-            qs=sorted_unpaginated_query_params,
-        )
-
-        # remove unwanted query params
-        for param in getattr(self.config, "remove_from_query", []):
-            sorted_unpaginated_query_params.pop(param, None)
-
-        qs = geojson.dumps(sorted_unpaginated_query_params)
-
-        query_hash = hashlib.sha1(str(qs).encode("UTF-8")).hexdigest()
-
-        # update result with product_type_def_params and search args if not None (and not auth)
-        kwargs.pop("auth", None)
-        result.update(results.product_type_def_params)
-        result = dict(result, **{k: v for k, v in kwargs.items() if v is not None})
-
-        # parse properties
-        parsed_properties = properties_from_json(
-            result,
-            self.config.metadata_mapping,
-            discovery_config=getattr(self.config, "discover_metadata", {}),
-        )
-
-        if not product_type:
-            product_type = parsed_properties.get("productType", None)
-
-        # build product id
-        id_prefix = (product_type or self.provider).upper()
-        product_id = "%s_%s_%s_%s" % (
-            id_prefix,
-            parsed_properties["startTimeFromAscendingNode"]
-            .split("T")[0]
-            .replace("-", ""),
-            parsed_properties["completionTimeFromAscendingNode"]
-            .split("T")[0]
-            .replace("-", ""),
-            query_hash,
+    :param keywords: List of keywords to be converted
+    :param prefix: prefix to be added to the parameter in the mapping
+    :return: metadata mapping dict
+    """
+    mdt: dict[str, Any] = {}
+    for keyword in keywords:
+        key = f"{prefix}:{keyword}" if prefix else keyword
+        mdt[key] = [keyword, f'$."{key}"']
+    return mdt
+
+
+def strip_quotes(value: Any) -> Any:
+    """Strip superfluous quotes from elements (added by mapping converter to_geojson).
+
+    >>> strip_quotes("'abc'")
+    'abc'
+    >>> strip_quotes(["'abc'", '"def'])
+    ['abc', 'def']
+    >>> strip_quotes({"'abc'": 'def"'})
+    {'abc': 'def'}
+
+    :param value: value from which quotes should be removed (should be either str or list)
+    :return: value without quotes
+    :raises: NotImplementedError
+    """
+    if isinstance(value, (list, tuple)):
+        return [strip_quotes(v) for v in value]
+    elif isinstance(value, dict):
+        return {strip_quotes(k): strip_quotes(v) for k, v in value.items()}
+    else:
+        return str(value).strip("'\"")
+
+
+def _update_properties_from_element(
+    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
+    """
+    # multichoice elements are transformed into array
+    if element["type"] in ("StringListWidget", "StringListArrayWidget"):
+        prop["type"] = "array"
+        if values:
+            prop["items"] = {"type": "string", "enum": sorted(values)}
+
+    # single choice elements are transformed into string
+    elif element["type"] in (
+        "StringChoiceWidget",
+        "DateRangeWidget",
+        "FreeformInputWidget",
+    ):
+        prop["type"] = "string"
+        if values:
+            prop["enum"] = sorted(values)
+
+    # a bbox element
+    elif element["type"] in ["GeographicExtentWidget", "GeographicExtentMapWidget"]:
+        prop.update(
+            {
+                "type": "array",
+                "minItems": 4,
+                "additionalItems": False,
+                "items": [
+                    {
+                        "type": "number",
+                        "maximum": 180,
+                        "minimum": -180,
+                        "description": "West border of the bounding box",
+                    },
+                    {
+                        "type": "number",
+                        "maximum": 90,
+                        "minimum": -90,
+                        "description": "South border of the bounding box",
+                    },
+                    {
+                        "type": "number",
+                        "maximum": 180,
+                        "minimum": -180,
+                        "description": "East border of the bounding box",
+                    },
+                    {
+                        "type": "number",
+                        "maximum": 90,
+                        "minimum": -90,
+                        "description": "North border of the bounding box",
+                    },
+                ],
+            }
         )
-        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})
-                )
+    # DateRangeWidget is a calendar date picker
+    if element["type"] == "DateRangeWidget":
+        prop["description"] = "date formatted like yyyy-mm-dd/yyyy-mm-dd"
 
-        # use product_type_config as default properties
-        parsed_properties = dict(
-            getattr(self.config, "product_type_config", {}),
-            **parsed_properties,
-        )
+    if description := element.get("help"):
+        prop["description"] = description
 
-        product = EOProduct(
-            provider=self.provider,
-            productType=product_type,
-            properties=parsed_properties,
-        )
 
-        return [
-            product,
-        ]
+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
 
 
-class BuildSearchResult(BuildPostSearchResult):
-    """BuildSearchResult search plugin.
+class ECMWFSearch(PostJsonSearch):
+    """ECMWF search plugin.
 
-    This plugin builds a single :class:`~eodag.api.search_result.SearchResult` object
+    This plugin builds a :class:`~eodag.api.search_result.SearchResult` containing a single product
     using given query parameters as product properties.
 
-    The available configuration parameters inherits from parent classes
-    (:class:`~eodag.plugins.search.build_search_result.BuildPostSearchResult`,
-    :class:`~eodag.plugins.search.qssearch.PostJsonSearch` and
-    :class:`~eodag.plugins.search.qssearch.QueryStringSearch`), with particularly for this plugin:
+    The available configuration parameters inherits from parent classes, with some particular parameters
+    for this plugin.
 
-    :param provider: provider name
+    :param provider: An eodag providers configuration dictionary
     :param config: Search plugin configuration:
 
-        * :attr:`~eodag.config.PluginConfig.end_date_excluded` (``bool``): Set to ``False`` if provider
-          does not include end date in the search request; In this case, if the end date is at midnight,
-          the previous day will be used. default: ``True``
-
+        * :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
+        * :attr:`~eodag.config.PluginConfig.discover_queryables`
+          (:class:`~eodag.config.PluginConfig.DiscoverQueryables`): configuration to fetch the queryables from a
+          provider queryables endpoint; It has the following keys:
+
+          * :attr:`~eodag.config.PluginConfig.DiscoverQueryables.fetch_url` (``str``): url to fetch the queryables valid
+            for all product types
+          * :attr:`~eodag.config.PluginConfig.DiscoverQueryables.product_type_fetch_url` (``str``): url to fetch the
+            queryables for a specific product type
+          * :attr:`~eodag.config.PluginConfig.DiscoverQueryables.constraints_url` (``str``): url of the constraint file
+            used to build queryables
     """
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
-        # init self.config.metadata_mapping using Search Base plugin
-        Search.__init__(self, provider, config)
+        config.metadata_mapping = {
+            **keywords_to_mdt(ECMWF_KEYWORDS + COP_DS_KEYWORDS, "ecmwf"),
+            **config.metadata_mapping,
+        }
+
+        super().__init__(provider, config)
 
         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.__dict__.setdefault("pagination", {"next_page_query_obj": "{{}}"})
+        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():
@@ -304,46 +390,70 @@ class BuildSearchResult(BuildPostSearchResult):
                     "metadata_mapping"
                 ] = product_type_metadata_mapping
 
-    def do_search(self, *args: Any, **kwargs: Any) -> List[Dict[str, Any]]:
-        """Should perform the actual search request."""
+    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
+        :param kwargs: keyword arguments to be used in the search
+        :return: list containing the results from the provider in json format
+        """
+        # no real search. We fake it all
         return [{}]
 
     def query(
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> Tuple[List[EOProduct], Optional[int]]:
-        """Build ready-to-download SearchResult"""
+    ) -> tuple[list[EOProduct], Optional[int]]:
+        """Build ready-to-download SearchResult
 
-        self._preprocess_search_params(kwargs)
+        :param prep: :class:`~eodag.plugins.search.PreparedSearch` object containing information needed for the search
+        :param kwargs: keyword arguments to be used in the search
+        :returns: list of products and number of products (optional)
+        """
+        product_type = prep.product_type
+        if not product_type:
+            product_type = kwargs.get("productType", None)
+        self._preprocess_search_params(kwargs, product_type)
+        result, num_items = super().query(prep, **kwargs)
+        if prep.count and not num_items:
+            num_items = 1
 
-        return BuildPostSearchResult.query(self, prep, **kwargs)
+        return result, num_items
 
     def clear(self) -> None:
         """Clear search context"""
-        pass
+        super().clear()
 
     def build_query_string(
         self, product_type: str, **kwargs: Any
-    ) -> Tuple[Dict[str, Any], str]:
-        """Build The query string using the search parameters"""
+    ) -> 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
+        """
         # 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 = {
-            k: v
+            # 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]
         }
 
         # build and return the query
-        return BuildPostSearchResult.build_query_string(
-            self, product_type=product_type, **available_properties
+        return super().build_query_string(
+            product_type=product_type, **available_properties
         )
 
-    def _preprocess_search_params(self, params: Dict[str, Any]) -> None:
+    def _preprocess_search_params(
+        self, params: dict[str, Any], product_type: Optional[str]
+    ) -> None:
         """Preprocess search parameters before making a request to the CDS API.
 
         This method is responsible for checking and updating the provided search parameters
@@ -352,6 +462,7 @@ class BuildSearchResult(BuildPostSearchResult):
         in the input parameters, default values or values from the configuration are used.
 
         :param params: Search parameters to be preprocessed.
+        :param product_type: (optional) product type id
         """
         _dc_qs = params.get("_dc_qs", None)
         if _dc_qs is not None:
@@ -378,165 +489,792 @@ class BuildSearchResult(BuildPostSearchResult):
         non_none_params = {k: v for k, v in params.items() if v}
 
         # productType
-        dataset = params.get("dataset", None)
+        dataset = params.get("ecmwf:dataset", None)
         params["productType"] = non_none_params.get("productType", dataset)
 
         # dates
-        mission_start_dt = datetime.fromisoformat(
-            self.get_product_type_cfg_value(
-                "missionStartDate", DEFAULT_MISSION_START_DATE
-            ).replace(
-                "Z", "+00:00"
-            )  # before 3.11
-        )
-
-        default_end_from_cfg = self.config.products.get(params["productType"], {}).get(
-            "_default_end_date", None
-        )
-        default_end_str = (
-            default_end_from_cfg
-            or (
-                datetime.now(timezone.utc)
-                if params.get("startTimeFromAscendingNode")
-                else mission_start_dt + timedelta(days=1)
-            ).isoformat()
-        )
-
-        params["startTimeFromAscendingNode"] = non_none_params.get(
-            "startTimeFromAscendingNode", mission_start_dt.isoformat()
-        )
-        params["completionTimeFromAscendingNode"] = non_none_params.get(
-            "completionTimeFromAscendingNode", default_end_str
-        )
+        # check if default dates have to be added
+        if getattr(self.config, "dates_required", False):
+            self._check_date_params(params, product_type)
 
         # adapt end date if it is midnight
-        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 = end_date.replace(tzinfo=tzutc())
-        except ValueError:
+        if "completionTimeFromAscendingNode" 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:%S.%fZ"
+                    params["completionTimeFromAscendingNode"], "%Y-%m-%dT%H:%M:%SZ"
                 )
                 end_date = end_date.replace(tzinfo=tzutc())
             except ValueError:
-                end_date = isoparse(params["completionTimeFromAscendingNode"])
-                is_datetime = False
-        start_date = isoparse(params["startTimeFromAscendingNode"])
-        if (
-            not end_date_excluded
-            and is_datetime
-            and end_date > start_date
-            and end_date == end_date.replace(hour=0, minute=0, second=0, microsecond=0)
-        ):
-            end_date += timedelta(days=-1)
-            params["completionTimeFromAscendingNode"] = end_date.isoformat()
+                try:
+                    end_date = datetime.strptime(
+                        params["completionTimeFromAscendingNode"],
+                        "%Y-%m-%dT%H:%M:%S.%fZ",
+                    )
+                    end_date = end_date.replace(tzinfo=tzutc())
+                except ValueError:
+                    end_date = isoparse(params["completionTimeFromAscendingNode"])
+                    is_datetime = False
+            start_date = isoparse(params["startTimeFromAscendingNode"])
+            if (
+                not end_date_excluded
+                and is_datetime
+                and end_date > start_date
+                and end_date
+                == end_date.replace(hour=0, minute=0, second=0, microsecond=0)
+            ):
+                end_date += timedelta(days=-1)
+                params["completionTimeFromAscendingNode"] = end_date.isoformat()
 
         # geometry
         if "geometry" in params:
             params["geometry"] = get_geometry_from_various(geometry=params["geometry"])
 
+    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
                        arguments)
         :returns: fetched queryable parameters dict
         """
-        constraints_file_url = getattr(self.config, "constraints_file_url", "")
-        if not constraints_file_url:
-            return {}
-        product_type = kwargs.pop("productType", None)
-        if not product_type:
-            return {}
+        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")
+
+        # extract default datetime
+        processed_kwargs = deepcopy(kwargs)
+        self._preprocess_search_params(processed_kwargs, product_type)
+
+        constraints_url = format_metadata(
+            getattr(self.config, "discover_queryables", {}).get("constraints_url", ""),
+            **kwargs,
+        )
+        constraints: list[dict[str, Any]] = self._fetch_data(constraints_url)
 
-        provider_product_type = self.config.products.get(product_type, {}).get(
-            "dataset", None
+        form_url = format_metadata(
+            getattr(self.config, "discover_queryables", {}).get("form_url", ""),
+            **kwargs,
         )
-        user_provider_product_type = kwargs.pop("dataset", None)
+        form: list[dict[str, Any]] = self._fetch_data(form_url)
+
+        formated_kwargs = self.format_as_provider_keyword(
+            product_type, processed_kwargs
+        )
+        # 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",
+                "geom",
+            ):
+                formated_kwargs[key] = kwargs[key]
+            else:
+                raise ValidationError(
+                    f"{key} is not a queryable parameter for {self.provider}"
+                )
+
+        # we use non empty kwargs 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] = {
+            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()
+            if v and (not isinstance(v, list) or all(v))
+        }
+
+        required_keywords: set[str] = set()
+
+        # calculate available values
+        if constraints:
+            # Apply constraints filtering
+            available_values = self.available_values_from_constraints(
+                constraints,
+                non_empty_formated,
+                form_keywords=[f["name"] for f in form],
+            )
+
+            # 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())
+        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)
+            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:
+            if (
+                keyword
+                not in available_values.keys()
+                | product_type_config.keys()
+                | {
+                    "startTimeFromAscendingNode",
+                    "completionTimeFromAscendingNode",
+                    "geom",
+                }
+                and keyword not in [f["name"] for f in form]
+                and keyword.replace("ecmwf:", "")
+                not in set(list(available_values.keys()) + [f["name"] for f in form])
+            ):
+                raise ValidationError(f"{keyword} is not a queryable parameter")
+
+        # generate queryables
+        if form:
+            queryables = self.queryables_by_form(
+                form,
+                available_values,
+                non_empty_formated,
+            )
+        else:
+            queryables = self.queryables_by_values(
+                available_values, list(required_keywords), non_empty_kwargs
+            )
+
+        # ecmwf:date is replaced by start and end.
+        # start and end filters are supported whenever combinations of "year", "month", "day" filters exist
         if (
-            user_provider_product_type
-            and user_provider_product_type != provider_product_type
+            queryables.pop("ecmwf:date", None)
+            or "ecmwf:year" in queryables
+            or "ecmwf:hyear" in queryables
         ):
-            raise ValidationError(
-                f"Cannot change dataset from {provider_product_type} to {user_provider_product_type}"
+            queryables.update(
+                {
+                    "start": Queryables.get_with_default(
+                        "start", non_empty_kwargs.get("startTimeFromAscendingNode")
+                    ),
+                    "end": Queryables.get_with_default(
+                        "end",
+                        non_empty_kwargs.get("completionTimeFromAscendingNode"),
+                    ),
+                }
             )
 
-        # defaults
-        default_queryables = self._get_defaults_as_queryables(product_type)
-        # remove dataset from queryables
-        default_queryables.pop("dataset", None)
+        # area is geom in EODAG.
+        if queryables.pop("area", None):
+            queryables["geom"] = Annotated[
+                Union[str, dict[str, float], BaseGeometry],
+                Field(
+                    None,
+                    description="Read EODAG documentation for all supported geometry format.",
+                ),
+            ]
 
-        non_empty_kwargs = {k: v for k, v in kwargs.items() if v}
+        return queryables
 
-        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] = {}
-                        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
+    def available_values_from_constraints(
+        self,
+        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.
+
+        :param constraints: list of constraints received from the provider
+        :param input_keywords: dict of input parameters given by the user
+        :param form_keywords: list of keyword names from the provider form endpoint
+        :return: dict with available values for each parameter
+        """
+        # get ordered constraint keywords
+        constraints_keywords = list(
+            OrderedDict.fromkeys(k for c in constraints for k in c.keys())
+        )
+
+        # prepare ordered input keywords formatted as provider's keywords
+        # required to filter with constraints
+        ordered_keywords = (
+            [kw for kw in form_keywords if kw in constraints_keywords]
+            if form_keywords
+            else constraints_keywords
+        )
+
+        # filter constraint entries matching input keyword values
+        filtered_constraints: list[dict[str, Any]]
+
+        parsed_keywords: list[str] = []
+        for keyword in ordered_keywords:
+            values = input_keywords.get(keyword)
+
+            if values is None:
+                parsed_keywords.append(keyword)
+                continue
+
+            # we only compare list of strings.
+            if isinstance(values, dict):
+                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
+            # 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))]
+
+            # special handling for time 0000 converted to 0 by pre-formating with metadata_mapping
+            if keyword.split(":")[-1] == "time":
+                filter_v = ["0000" if str(v) == "0" else v for v in filter_v]
+
+            # Collect missing values to report errors
+            missing_values = set(filter_v)
+
+            # Filter constraints and check for missing values
+            filtered_constraints = []
+            for entry in constraints:
+                # Filter based on the presence of any value in filter_v
+                entry_values = entry.get(keyword, [])
+
+                # date constraint may be intervals. We identify intervals with a "/" in the value
+                # 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]):
+                        present_values = filter_v
+                else:
+                    present_values = [
+                        value for value in filter_v if value in entry_values
+                    ]
+
+                # Remove present values from the missing_values set
+                missing_values -= set(present_values)
+
+                if present_values:
+                    filtered_constraints.append(entry)
+
+            # raise an error as no constraint entry matched the input keywords
+            # raise an error if one value from input is not allowed
+            if not filtered_constraints or missing_values:
+                allowed_values = list(
+                    {value for c in constraints for value in c.get(keyword, [])}
+                )
+                # restore ecmwf: prefix before raising error
+                keyword = f"ecmwf:{keyword}"
+
+                all_keywords_str = ""
+                if len(parsed_keywords) > 1:
+                    keywords = [
+                        f"ecmwf:{k}={pk}"
+                        for k in parsed_keywords
+                        if (pk := input_keywords.get(k))
+                    ]
+                    all_keywords_str = f" with {', '.join(keywords)}"
+
+                raise ValidationError(
+                    f"{keyword}={values} is not available"
+                    f"{all_keywords_str}."
+                    f" Allowed values are {', '.join(allowed_values)}."
+                )
+
+            parsed_keywords.append(keyword)
+            constraints = filtered_constraints
+
+        available_values: dict[str, Any] = {k: set() for k in ordered_keywords}
+
+        # we aggregate the constraint entries left
+        for entry in constraints:
+            for key, value in entry.items():
+                available_values[key].update(value)
+
+        return {k: list(v) for k, v in available_values.items()}
+
+    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]]:
+        """
+        Generate Annotated field definitions from form entries and available values
+        Used by Copernicus services like cop_cds, cop_ads, cop_ewds.
+
+        :param form: data fetched from the form endpoint of the provider
+        :param available_values: available values for each parameter
+        :param defaults: default values for the parameters
+        :return: dict of annotated queryables
+        """
+        queryables: dict[str, Annotated[Any, FieldInfo]] = {}
+
+        required_list: list[str] = []
+        for element in form:
+            name: str = element["name"]
+
+            # those are not parameter elements.
+            if name in ("area_group", "global", "warning", "licences"):
+                continue
+            if "type" not in element or element["type"] == "FreeEditionWidget":
+                continue
+
+            # ordering done by id -> set id to high value if not present -> element will be last
+            if "id" not in element:
+                element["id"] = 100
+
+            prop = {"title": element.get("label", name)}
+
+            details = element.get("details", {})
+
+            # add values from form if keyword was not in constraints
+            values = (
+                available_values[name]
+                if name in available_values
+                else details.get("values")
             )
-            # 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[str] = 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) {not_queryables} not queryable"
+
+            # updates the properties with the values given based on the information from the element
+            _update_properties_from_element(prop, element, values)
+
+            default = defaults.get(name)
+
+            if details:
+                fields = details.get("fields")
+                if fields and (comment := fields[0].get("comment")):
+                    prop["description"] = comment
+
+            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):
+                default = ",".join(default)
+
+            is_required = bool(element.get("required"))
+            if is_required:
+                required_list.append(name)
+
+            queryables[ecmwf_format(name)] = Annotated[
+                get_args(
+                    json_field_definition_to_python(
+                        prop,
+                        default_value=default,
+                        required=is_required,
                     )
-                else:
-                    # get constraints again without common queryables
-                    constraint_params = (
-                        get_constraint_queryables_with_additional_params(
-                            constraints, non_empty_kwargs, self, product_type
-                        )
+                )
+            ]
+
+        return queryables
+
+    def queryables_by_values(
+        self,
+        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.
+
+        :param available_values: available values for each parameter
+        :param required_keywords: list of required parameters
+        :param defaults: default values for the parameters
+        :return: dict of annotated queryables
+        """
+        # Rename keywords from form with metadata mapping.
+        # 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]] = {}
+        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,
+                        required=bool(key in required),
                     )
+                )
+            ]
+
+        return queryables
+
+    def format_as_provider_keyword(
+        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,
+        )
+        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)
+
+    def _fetch_data(self, url: str) -> Any:
+        """
+        fetches from a provider elements like constraints or forms.
+
+        :param url: url from which the constraints can be fetched
+        :returns: json file content fetched from the provider
+        """
+        if not url:
+            return []
+
+        auth = (
+            self.auth
+            if hasattr(self, "auth") and isinstance(self.auth, AuthBase)
+            else None
+        )
+        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]:
+        """Build :class:`~eodag.api.product._product.EOProduct` from provider result
+
+        :param results: Raw provider result as single dict in list
+        :param kwargs: Search arguments
+        :returns: list of single :class:`~eodag.api.product._product.EOProduct`
+        """
 
-        field_definitions: Dict[str, Any] = {}
-        for json_param, json_mtd in constraint_params.items():
-            param = (
-                get_queryable_from_provider(
-                    json_param, self.get_metadata_mapping(product_type)
+        product_type = kwargs.get("productType")
+
+        result = results[0]
+
+        # datacube query string got from previous search
+        _dc_qs = kwargs.pop("_dc_qs", None)
+        if _dc_qs is not None:
+            qs = unquote_plus(unquote_plus(_dc_qs))
+            sorted_unpaginated_query_params = geojson.loads(qs)
+        else:
+            # update result with query parameters without pagination (or search-only params)
+            if isinstance(
+                self.config.pagination["next_page_query_obj"], str
+            ) and hasattr(results, "query_params_unpaginated"):
+                unpaginated_query_params = results.query_params_unpaginated
+            elif isinstance(self.config.pagination["next_page_query_obj"], str):
+                next_page_query_obj = orjson.loads(
+                    self.config.pagination["next_page_query_obj"].format()
                 )
-                or json_param
+                unpaginated_query_params = {
+                    k: v
+                    for k, v in results.query_params.items()
+                    if (k, v) not in next_page_query_obj.items()
+                }
+            else:
+                unpaginated_query_params = self.query_params
+            # query hash, will be used to build a product id
+            sorted_unpaginated_query_params = dict_items_recursive_sort(
+                unpaginated_query_params
             )
-            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
+
+        # use all available query_params to parse properties
+        result = dict(
+            result,
+            **sorted_unpaginated_query_params,
+            qs=sorted_unpaginated_query_params,
+        )
+
+        # remove unwanted query params
+        for param in getattr(self.config, "remove_from_query", []):
+            sorted_unpaginated_query_params.pop(param, None)
+
+        qs = geojson.dumps(sorted_unpaginated_query_params)
+
+        query_hash = hashlib.sha1(str(qs).encode("UTF-8")).hexdigest()
+
+        # update result with product_type_def_params and search args if not None (and not auth)
+        kwargs.pop("auth", None)
+        result.update(results.product_type_def_params)
+        result = dict(result, **{k: v for k, v in kwargs.items() if v is not None})
+
+        # parse properties
+        parsed_properties = properties_from_json(
+            result,
+            self.config.metadata_mapping,
+            discovery_config=getattr(self.config, "discover_metadata", {}),
+        )
+
+        if not product_type:
+            product_type = parsed_properties.get("productType", None)
+
+        # 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,
             )
-            field_definitions[param] = get_args(annotated_def)
+        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})
+                )
+
+        # use product_type_config as default properties
+        parsed_properties = dict(
+            getattr(self.config, "product_type_config", {}),
+            **parsed_properties,
+        )
+
+        product = EOProduct(
+            provider=self.provider,
+            productType=product_type,
+            properties=parsed_properties,
+        )
+
+        return [
+            product,
+        ]
 
-        python_queryables = create_model("m", **field_definitions).model_fields
-        return {**default_queryables, **model_fields_to_annotated(python_queryables)}
+    def count_hits(
+        self, count_url: Optional[str] = None, result_type: Optional[str] = None
+    ) -> int:
+        """Count method that will always return 1.
+
+        :param count_url: not used, only here because this method overwrites count_hits from the parent class
+        :param result_type: not used, only here because this method overwrites count_hits from the parent class
+        :return: always 1
+        """
+        return 1
+
+
+class MeteoblueSearch(ECMWFSearch):
+    """MeteoblueSearch search plugin.
+
+    This plugin, which inherits from :class:`~eodag.plugins.search.build_search_result.ECMWFSearch`,
+    performs a POST request and uses its result to build a single :class:`~eodag.api.search_result.SearchResult`
+    object.
+
+    The available configuration parameters are inherited from parent classes, with some a particularity
+    for pagination for this plugin.
+
+    :param provider: An eodag providers configuration dictionary
+    :param config: Search plugin configuration:
+
+        * :attr:`~eodag.config.PluginConfig.pagination` (:class:`~eodag.config.PluginConfig.Pagination`)
+          (**mandatory**): The configuration of how the pagination is done on the provider. For
+          this plugin it has the node:
+
+          * :attr:`~eodag.config.PluginConfig.Pagination.next_page_query_obj` (``str``): The
+            additional parameters needed to perform search. These parameters won't be included in
+            the result. This must be a json dict formatted like ``{{"foo":"bar"}}`` because it
+            will be passed to a :meth:`str.format` method before being loaded as json.
+    """
+
+    def collect_search_urls(
+        self,
+        prep: PreparedSearch = PreparedSearch(),
+        **kwargs: Any,
+    ) -> 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
+        :param kwargs: keyword arguments used in the search
+        :return: list of search url and number of results
+        """
+        urls, _ = super().collect_search_urls(prep, **kwargs)
+        return urls, 1
+
+    def do_search(
+        self, prep: PreparedSearch = PreparedSearch(items_per_page=None), **kwargs: 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
+        :param kwargs: keyword arguments to be used in the search
+        :return: list containing the results from the provider in json format
+        """
+
+        prep.url = prep.search_urls[0]
+        prep.info_message = f"Sending search request: {prep.url}"
+        prep.exception_message = (
+            f"Skipping error while searching for {self.provider}"
+            f" {self.__class__.__name__} instance"
+        )
+        response = self._request(prep)
+
+        return [response.json()]
+
+    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
+        """
+        return QueryStringSearch.build_query_string(
+            self, product_type=product_type, **kwargs
+        )
+
+
+class WekeoECMWFSearch(ECMWFSearch):
+    """
+    WekeoECMWFSearch search plugin.
+
+    This plugin, which inherits from :class:`~eodag.plugins.search.build_search_result.ECMWFSearch`,
+    performs a POST request and uses its result to build a single :class:`~eodag.api.search_result.SearchResult`
+    object. In contrast to ECMWFSearch or MeteoblueSearch, the products are only build with information
+    returned by the provider.
+
+    The available configuration parameters are inherited from parent classes, with some a particularity
+    for pagination for this plugin.
+
+    :param provider: An eodag providers configuration dictionary
+    :param config: Search plugin configuration:
+
+        * :attr:`~eodag.config.PluginConfig.pagination` (:class:`~eodag.config.PluginConfig.Pagination`)
+          (**mandatory**): The configuration of how the pagination is done on the provider. For
+          this plugin it has the node:
+
+          * :attr:`~eodag.config.PluginConfig.Pagination.next_page_query_obj` (``str``): The
+            additional parameters needed to perform search. These parameters won't be included in
+            the result. This must be a json dict formatted like ``{{"foo":"bar"}}`` because it
+            will be passed to a :meth:`str.format` method before being loaded as json.
+    """
+
+    def normalize_results(
+        self, results: RawSearchResult, **kwargs: Any
+    ) -> list[EOProduct]:
+        """Build :class:`~eodag.api.product._product.EOProduct` from provider result
+
+        :param results: Raw provider result as single dict in list
+        :param kwargs: Search arguments
+        :returns: list of single :class:`~eodag.api.product._product.EOProduct`
+        """
+
+        # formating of orderLink requires access to the productType value.
+        results.data = [
+            {**result, **results.product_type_def_params} for result in results
+        ]
+
+        normalized = QueryStringSearch.normalize_results(self, results, **kwargs)
+
+        if not normalized:
+            return normalized
+
+        query_params_encoded = quote_plus(orjson.dumps(results.query_params))
+        for product in normalized:
+            properties = {**product.properties, **results.query_params}
+            properties["_dc_qs"] = query_params_encoded
+            product.properties = {ecmwf_format(k): v for k, v in properties.items()}
+
+        return normalized
+
+    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
+        :param kwargs: keyword arguments to be used in the search
+        :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
+        )