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

eodag/plugins/search/build_search_result.py

@@ -17,120 +17,979 @@
 # 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
 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 pydantic import create_model
+from dateutil.utils import today
+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,
-    mtd_cfg_as_conversion_and_querypath,
+    OFFLINE_STATUS,
+    format_metadata,
     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")
 
+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 = {
+    "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",
+}
+
+ALLOWED_KEYWORDS = ECMWF_KEYWORDS | COP_DS_KEYWORDS
+
+END = "completionTimeFromAscendingNode"
+
+START = "startTimeFromAscendingNode"
+
+
+def ecmwf_mtd() -> dict[str, Any]:
+    """
+    Make metadata mapping dict from a list of defined ECMWF Keywords
+
+    We automatically add the #to_geojson convert to prevent modification of entries by eval() in the metadata mapping.
 
-class BuildPostSearchResult(PostJsonSearch):
-    """BuildPostSearchResult search plugin.
+    keyword:
+        - keyword
+        - $."keyword"#to_geojson
 
-    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.
+    :return: metadata mapping dict
+    """
+    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]
+) -> 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",
+                    },
+                ],
+            }
+        )
 
-    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:
+    # DateRangeWidget is a calendar date picker
+    if element["type"] == "DateRangeWidget":
+        prop["description"] = "date formatted like yyyy-mm-dd/yyyy-mm-dd"
 
-    :param provider: provider name
+    if description := element.get("help"):
+        prop["description"] = description
+
+
+def ecmwf_format(v: str) -> str:
+    """Add ECMWF prefix to value v if v is a ECMWF keyword."""
+    return ECMWF_PREFIX + v if v in ALLOWED_KEYWORDS else v
+
+
+class ECMWFSearch(PostJsonSearch):
+    """ECMWF search plugin.
+
+    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, with some particular parameters
+    for this plugin.
+
+    :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
+        * :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 count_hits(
-        self, count_url: Optional[str] = None, result_type: Optional[str] = None
-    ) -> int:
-        """Count method that will always return 1."""
-        return 1
+    def __init__(self, provider: str, config: PluginConfig) -> None:
+        config.metadata_mapping = {
+            **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,
+        }
 
-    def collect_search_urls(
+        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", "")
+        self.config.pagination.setdefault("next_page_query_obj", "{{}}")
+
+    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[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
+    ) -> tuple[list[EOProduct], Optional[int]]:
+        """Build ready-to-download SearchResult
 
-    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"
+        :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)
+        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
+
+        return result, num_items
+
+    def clear(self) -> None:
+        """Clear search context"""
+        super().clear()
+
+    def build_query_string(
+        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 query_dict: keyword arguments to be used in the query string
+        :return: formatted query params and encode query string
+        """
+        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)
+
+        return super().build_query_string(
+            product_type=product_type, query_dict=ordered_kwargs
         )
-        response = self._request(prep)
 
-        return [response.json()]
+    def _preprocess_search_params(
+        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
+        to ensure that required parameters like 'productType', 'startTimeFromAscendingNode',
+        'completionTimeFromAscendingNode', and 'geometry' are properly set. If not specified
+        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:
+            # 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[START], params[END] = _dc_qp["date"].split("/to/")
+            elif "/" in _dc_qp.get("date", ""):
+                (params[START], params[END],) = _dc_qp[
+                    "date"
+                ].split("/")
+            elif _dc_qp.get("date", None):
+                params[START] = params[END] = _dc_qp["date"]
+
+            if "/" in _dc_qp.get("area", ""):
+                params["geometry"] = _dc_qp["area"].split("/")
+
+        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
+        if getattr(self.config, "dates_required", False):
+            self._check_date_params(params, product_type)
+
+        # adapt end date if it is midnight
+        if END in params:
+            end_date_excluded = getattr(self.config, "end_date_excluded", True)
+            is_datetime = True
+            try:
+                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[END],
+                        "%Y-%m-%dT%H:%M:%S.%fZ",
+                    )
+                    end_date = end_date.replace(tzinfo=tzutc())
+                except ValueError:
+                    end_date = isoparse(params[END])
+                    is_datetime = False
+            start_date = isoparse(params[START])
+            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[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]]]:
+        """Fetch queryables list from provider using its constraints file
+
+        :param kwargs: additional filters for queryables (`productType` and other search
+                       arguments)
+        :returns: fetched queryable parameters dict
+        """
+        product_type = kwargs.pop("productType")
+
+        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_filters = self._preprocess_search_params(
+            deepcopy(filters), product_type
+        )
+
+        constraints_url = format_metadata(
+            getattr(self.config, "discover_queryables", {}).get("constraints_url", ""),
+            **filters,
+        )
+        constraints: list[dict[str, Any]] = self._fetch_data(constraints_url)
+
+        form_url = format_metadata(
+            getattr(self.config, "discover_queryables", {}).get("form_url", ""),
+            **filters,
+        )
+        form: list[dict[str, Any]] = self._fetch_data(form_url)
+
+        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 k, v in {**default_values, **kwargs}.items():
+            key = k.removeprefix(ECMWF_PREFIX)
+
+            if key not in ALLOWED_KEYWORDS | {
+                START,
+                END,
+                "geom",
+                "geometry",
+            }:
+                raise ValidationError(
+                    f"{key} is not a queryable parameter for {self.provider}"
+                )
+
+            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] = {
+            k: v
+            for k, v in formated_filters.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.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(**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 filters:
+            if (
+                keyword
+                not in available_values.keys()
+                | pt_config.keys()
+                | {
+                    START,
+                    END,
+                    "geom",
+                }
+                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")
+
+        # 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_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(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", processed_filters.get(START)
+                    ),
+                    "end": Queryables.get_with_default(
+                        "end",
+                        processed_filters.get(END),
+                    ),
+                }
+            )
+
+        # 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.",
+                ),
+            ]
+
+        return queryables
+
+    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}"
+                )
+
+            # 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(str(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]:
+                    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 = [
+                        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 = ECMWF_PREFIX + keyword
+
+                all_keywords_str = ""
+                if len(parsed_keywords) > 1:
+                    keywords = [
+                        f"{ECMWF_PREFIX + 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":
+                # 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
+            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")
+            )
+
+            # 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())
+
+            # sometimes form returns default as array instead of string
+            if default and prop.get("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,
+                    )
+                )
+            ]
+
+        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)
+
+            queryables[key] = Annotated[
+                get_args(
+                    json_field_definition_to_python(
+                        {"type": "string", "title": name, "enum": values},
+                        default_value=defaults.get(name),
+                        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
+        """
+        properties["productType"] = product_type
+
+        # provider product type specific conf
+        product_type_def_params = self.get_product_type_def_params(
+            product_type, format_variables=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:
+        """
+        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]:
+    ) -> 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")
 
         result = results[0]
@@ -151,13 +1010,12 @@ class BuildPostSearchResult(PostJsonSearch):
                     self.config.pagination["next_page_query_obj"].format()
                 )
                 unpaginated_query_params = {
-                    k: v[0] if (isinstance(v, list) and len(v) == 1) else v
+                    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
@@ -190,353 +1048,182 @@ class BuildPostSearchResult(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()
-        product_id = "%s_%s_%s_%s" % (
-            id_prefix,
-            parsed_properties["startTimeFromAscendingNode"]
-            .split("T")[0]
-            .replace("-", ""),
-            parsed_properties["completionTimeFromAscendingNode"]
-            .split("T")[0]
-            .replace("-", ""),
-            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 [
             product,
         ]
 
+    def count_hits(
+        self, count_url: Optional[str] = None, result_type: Optional[str] = None
+    ) -> int:
+        """Count method that will always return 1.
 
-class BuildSearchResult(BuildPostSearchResult):
-    """BuildSearchResult search plugin.
-
-    This plugin builds a single :class:`~eodag.api.search_result.SearchResult` object
-    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:
-
-    :param provider: provider name
-    :param config: Search plugin configuration:
+        :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
 
-        * :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``
 
-    """
+class MeteoblueSearch(ECMWFSearch):
+    """MeteoblueSearch search plugin.
 
-    def __init__(self, provider: str, config: PluginConfig) -> None:
-        # init self.config.metadata_mapping using Search Base plugin
-        Search.__init__(self, provider, config)
+    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.
 
-        self.config.__dict__.setdefault("api_endpoint", "")
+    The available configuration parameters are inherited from parent classes, with some a particularity
+    for pagination for this plugin.
 
-        # 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": "{{}}"})
-
-        # 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"]
-                )
+    :param provider: An eodag providers configuration dictionary
+    :param config: Search plugin configuration:
 
-                self.config.products[product_type][
-                    "metadata_mapping"
-                ] = product_type_metadata_mapping
+        * :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:
 
-    def do_search(self, *args: Any, **kwargs: Any) -> List[Dict[str, Any]]:
-        """Should perform the actual search request."""
-        return [{}]
+          * :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 query(
+    def collect_search_urls(
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> Tuple[List[EOProduct], Optional[int]]:
-        """Build ready-to-download SearchResult"""
-
-        self._preprocess_search_params(kwargs)
+    ) -> tuple[list[str], int]:
+        """Wraps PostJsonSearch.collect_search_urls to force product count to 1
 
-        return BuildPostSearchResult.query(self, prep, **kwargs)
+        :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 clear(self) -> None:
-        """Clear search context"""
-        pass
+    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.
 
-    def build_query_string(
-        self, product_type: str, **kwargs: Any
-    ) -> Tuple[Dict[str, Any], str]:
-        """Build The query string using the search parameters"""
-        # 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
-            for k, v in parsed_properties.items()
-            if v not in [NOT_AVAILABLE, NOT_MAPPED]
-        }
+        :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
+        """
 
-        # build and return the query
-        return BuildPostSearchResult.build_query_string(
-            self, product_type=product_type, **available_properties
+        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)
 
-    def _preprocess_search_params(self, params: Dict[str, Any]) -> None:
-        """Preprocess search parameters before making a request to the CDS API.
+        return [response.json()]
 
-        This method is responsible for checking and updating the provided search parameters
-        to ensure that required parameters like 'productType', 'startTimeFromAscendingNode',
-        'completionTimeFromAscendingNode', and 'geometry' are properly set. If not specified
-        in the input parameters, default values or values from the configuration are used.
+    def build_query_string(
+        self, product_type: str, query_dict: dict[str, Any]
+    ) -> tuple[dict[str, Any], str]:
+        """Build The query string using the search parameters
 
-        :param params: Search parameters to be preprocessed.
+        :param product_type: product type id
+        :param query_dict: keyword arguments to be used in the query string
+        :return: formatted query params and encode query string
         """
-        _dc_qs = params.get("_dc_qs", None)
-        if _dc_qs is not None:
-            # 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/")
-            elif "/" in _dc_qp.get("date", ""):
-                (
-                    params["startTimeFromAscendingNode"],
-                    params["completionTimeFromAscendingNode"],
-                ) = _dc_qp["date"].split("/")
-            elif _dc_qp.get("date", None):
-                params["startTimeFromAscendingNode"] = params[
-                    "completionTimeFromAscendingNode"
-                ] = _dc_qp["date"]
+        return QueryStringSearch.build_query_string(self, product_type, query_dict)
 
-            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("dataset", None)
-        params["productType"] = non_none_params.get("productType", dataset)
+class WekeoECMWFSearch(ECMWFSearch):
+    """
+    WekeoECMWFSearch search plugin.
 
-        # dates
-        mission_start_dt = datetime.fromisoformat(
-            self.get_product_type_cfg_value(
-                "missionStartDate", DEFAULT_MISSION_START_DATE
-            ).replace(
-                "Z", "+00:00"
-            )  # before 3.11
-        )
+    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.
 
-        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()
-        )
+    The available configuration parameters are inherited from parent classes, with some a particularity
+    for pagination for this plugin.
 
-        params["startTimeFromAscendingNode"] = non_none_params.get(
-            "startTimeFromAscendingNode", mission_start_dt.isoformat()
-        )
-        params["completionTimeFromAscendingNode"] = non_none_params.get(
-            "completionTimeFromAscendingNode", default_end_str
-        )
+    :param provider: An eodag providers configuration dictionary
+    :param config: Search plugin configuration:
 
-        # 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:
-            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()
+        * :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:
 
-        # geometry
-        if "geometry" in params:
-            params["geometry"] = get_geometry_from_various(geometry=params["geometry"])
+          * :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 discover_queryables(
-        self, **kwargs: Any
-    ) -> Optional[Dict[str, Annotated[Any, FieldInfo]]]:
-        """Fetch queryables list from provider using its constraints file
+    def normalize_results(
+        self, results: RawSearchResult, **kwargs: Any
+    ) -> list[EOProduct]:
+        """Build :class:`~eodag.api.product._product.EOProduct` from provider result
 
-        :param kwargs: additional filters for queryables (`productType` and other search
-                       arguments)
-        :returns: fetched queryable parameters dict
+        :param results: Raw provider result as single dict in list
+        :param kwargs: Search arguments
+        :returns: list of single :class:`~eodag.api.product._product.EOProduct`
         """
-        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 {}
 
-        provider_product_type = self.config.products.get(product_type, {}).get(
-            "dataset", None
-        )
-        user_provider_product_type = kwargs.pop("dataset", None)
-        if (
-            user_provider_product_type
-            and user_provider_product_type != provider_product_type
-        ):
-            raise ValidationError(
-                f"Cannot change dataset from {provider_product_type} to {user_provider_product_type}"
-            )
+        # formating of orderLink requires access to the productType value.
+        results.data = [
+            {**result, **results.product_type_def_params} for result in results
+        ]
 
-        # defaults
-        default_queryables = self._get_defaults_as_queryables(product_type)
-        # remove dataset from queryables
-        default_queryables.pop("dataset", None)
+        normalized = QueryStringSearch.normalize_results(self, results, **kwargs)
 
-        non_empty_kwargs = {k: v for k, v in kwargs.items() if v}
+        if not normalized:
+            return normalized
 
-        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
-            )
-            # 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"
-                    )
-                else:
-                    # get constraints again without common queryables
-                    constraint_params = (
-                        get_constraint_queryables_with_additional_params(
-                            constraints, non_empty_kwargs, self, product_type
-                        )
-                    )
+        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()}
 
-        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)
-                )
-                or json_param
-            )
-            default = kwargs.get(param, None) or self.config.products.get(
-                product_type, {}
-            ).get(param, None)
-            annotated_def = json_field_definition_to_python(
-                json_mtd, default_value=default, required=True
-            )
-            field_definitions[param] = get_args(annotated_def)
+        return normalized
 
-        python_queryables = create_model("m", **field_definitions).model_fields
-        return {**default_queryables, **model_fields_to_annotated(python_queryables)}
+    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)