eodag 2.12.1__py3-none-any.whl → 3.0.0__py3-none-any.whl

eodag/api/core.py

@@ -17,24 +17,14 @@
 # limitations under the License.
 from __future__ import annotations
 
+import datetime
 import logging
 import os
 import re
 import shutil
 import tempfile
 from operator import itemgetter
-from typing import (
-    TYPE_CHECKING,
-    AbstractSet,
-    Any,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Optional, Set, Tuple, Union
 
 import geojson
 import pkg_resources
@@ -47,12 +37,15 @@ from whoosh.index import create_in, exists_in, open_dir
 from whoosh.qparser import QueryParser
 
 from eodag.api.product.metadata_mapping import (
-    NOT_MAPPED,
+    ONLINE_STATUS,
     mtd_cfg_as_conversion_and_querypath,
 )
 from eodag.api.search_result import SearchResult
 from eodag.config import (
+    PLUGINS_TOPICS_KEYS,
+    PluginConfig,
     SimpleYamlProxyConfig,
+    credentials_in_auth,
     get_ext_product_types_conf,
     load_default_config,
     load_stac_provider_config,
@@ -61,11 +54,15 @@ from eodag.config import (
     override_config_from_file,
     override_config_from_mapping,
     provider_config_init,
+    share_credentials,
 )
 from eodag.plugins.manager import PluginManager
+from eodag.plugins.search import PreparedSearch
 from eodag.plugins.search.build_search_result import BuildPostSearchResult
+from eodag.plugins.search.qssearch import PostJsonSearch
 from eodag.types import model_fields_to_annotated
-from eodag.types.queryables import CommonQueryables, Queryables
+from eodag.types.queryables import CommonQueryables
+from eodag.types.whoosh import EODAGQueryParser
 from eodag.utils import (
     DEFAULT_DOWNLOAD_TIMEOUT,
     DEFAULT_DOWNLOAD_WAIT,
@@ -77,23 +74,22 @@ from eodag.utils import (
     MockResponse,
     _deprecated,
     copy_deepcopy,
-    deepcopy,
-    get_args,
     get_geometry_from_various,
     makedirs,
     obj_md5sum,
+    sort_dict,
     string_to_jsonpath,
     uri_to_path,
 )
 from eodag.utils.exceptions import (
-    AuthenticationError,
-    MisconfiguredError,
+    EodagError,
     NoMatchingProductType,
     PluginImplementationError,
     RequestError,
     UnsupportedProductType,
     UnsupportedProvider,
 )
+from eodag.utils.rest import rfc3339_str_to_datetime
 from eodag.utils.stac_reader import fetch_stac_items
 
 if TYPE_CHECKING:
@@ -104,7 +100,9 @@ if TYPE_CHECKING:
     from eodag.plugins.apis.base import Api
     from eodag.plugins.crunch.base import Crunch
     from eodag.plugins.search.base import Search
-    from eodag.utils import Annotated, DownloadedCallback, ProgressCallback
+    from eodag.types import ProviderSortables
+    from eodag.types.download_args import DownloadConf
+    from eodag.utils import Annotated, DownloadedCallback, ProgressCallback, Unpack
 
 logger = logging.getLogger("eodag.core")
 
@@ -114,9 +112,7 @@ class EODataAccessGateway:
     from different types of providers.
 
     :param user_conf_file_path: (optional) Path to the user configuration file
-    :type user_conf_file_path: str
     :param locations_conf_path: (optional) Path to the locations configuration file
-    :type locations_conf_path: str
     """
 
     def __init__(
@@ -176,10 +172,15 @@ class EODataAccessGateway:
         # Second level override: From environment variables
         override_config_from_env(self.providers_config)
 
+        # share credentials between updated plugins confs
+        share_credentials(self.providers_config)
+
         # init updated providers conf
-        stac_provider_config = load_stac_provider_config()
         for provider in self.providers_config.keys():
-            provider_config_init(self.providers_config[provider], stac_provider_config)
+            provider_config_init(
+                self.providers_config[provider],
+                load_stac_provider_config(),
+            )
 
         # re-build _plugins_manager using up-to-date providers_config
         self._plugins_manager.rebuild(self.providers_config)
@@ -225,7 +226,6 @@ class EODataAccessGateway:
                         os.path.join(self.conf_dir, "shp"),
                     )
         self.set_locations_conf(locations_conf_path)
-        self.search_errors: Set = set()
 
     def get_version(self) -> str:
         """Get eodag package version"""
@@ -247,7 +247,6 @@ class EODataAccessGateway:
             if "unsupported pickle protocol" in str(ve):
                 logger.debug("Need to recreate whoosh .index: '%s'", ve)
                 create_index = True
-                shutil.rmtree(index_dir)
             # Unexpected error
             else:
                 logger.error(
@@ -261,13 +260,14 @@ class EODataAccessGateway:
             if self._product_types_index is None:
                 logger.debug("Opening product types index in %s", index_dir)
                 self._product_types_index = open_dir(index_dir)
-            try:
-                self.guess_product_type(md5=self.product_types_config_md5)
-            except NoMatchingProductType:
-                create_index = True
-            finally:
-                if create_index:
-                    shutil.rmtree(index_dir)
+
+            with self._product_types_index.searcher() as searcher:
+                p = QueryParser("md5", self._product_types_index.schema, plugins=[])
+                query = p.parse(self.product_types_config_md5)
+                results = searcher.search(query, limit=1)
+
+                if not results:
+                    create_index = True
                     logger.debug(
                         "Out-of-date product types index removed from %s", index_dir
                     )
@@ -284,9 +284,8 @@ class EODataAccessGateway:
             )
 
             product_types_schema = Schema(
-                ID=fields.STORED,
-                alias=fields.ID,
-                abstract=fields.STORED,
+                ID=fields.ID(stored=True),
+                abstract=fields.TEXT,
                 instrument=fields.IDLIST,
                 platform=fields.ID,
                 platformSerialIdentifier=fields.IDLIST,
@@ -294,10 +293,11 @@ class EODataAccessGateway:
                 sensorType=fields.ID,
                 md5=fields.ID,
                 license=fields.ID,
-                title=fields.ID,
-                missionStartDate=fields.ID,
-                missionEndDate=fields.ID,
+                title=fields.TEXT,
+                missionStartDate=fields.STORED,
+                missionEndDate=fields.STORED,
                 keywords=fields.KEYWORD(analyzer=kw_analyzer),
+                stacCollection=fields.STORED,
             )
             self._product_types_index = create_in(index_dir, product_types_schema)
             ix_writer = self._product_types_index.writer()
@@ -320,7 +320,6 @@ class EODataAccessGateway:
 
         :param provider: The name of the provider that should be considered as the
                          preferred provider to be used for this instance
-        :type provider: str
         """
         if provider not in self.available_providers():
             raise UnsupportedProvider(
@@ -336,7 +335,6 @@ class EODataAccessGateway:
         products, along with its priority.
 
         :returns: The provider with the maximum priority and its priority
-        :rtype: tuple(str, int)
         """
         providers_with_priority = [
             (provider, conf.priority)
@@ -345,15 +343,24 @@ class EODataAccessGateway:
         preferred, priority = max(providers_with_priority, key=itemgetter(1))
         return preferred, priority
 
-    def update_providers_config(self, yaml_conf: str) -> None:
+    def update_providers_config(
+        self,
+        yaml_conf: Optional[str] = None,
+        dict_conf: Optional[Dict[str, Any]] = None,
+    ) -> None:
         """Update providers configuration with given input.
         Can be used to add a provider to existing configuration or update
         an existing one.
 
         :param yaml_conf: YAML formated provider configuration
-        :type yaml_conf: str
+        :param dict_conf: provider configuration as dictionary in place of ``yaml_conf``
         """
-        conf_update = yaml.safe_load(yaml_conf)
+        if dict_conf is not None:
+            conf_update = dict_conf
+        elif yaml_conf is not None:
+            conf_update = yaml.safe_load(yaml_conf)
+        else:
+            return None
 
         # restore the pruned configuration
         for provider in list(self._pruned_providers_config.keys()):
@@ -366,60 +373,108 @@ class EODataAccessGateway:
                     provider
                 )
 
-        # check if metada-mapping as already been built as jsonpath in providers_config
-        for provider, provider_conf in conf_update.items():
-            if (
-                provider in self.providers_config
-                and "metadata_mapping" in provider_conf.get("search", {})
-            ):
-                search_plugin_key = "search"
-            elif (
-                provider in self.providers_config
-                and "metadata_mapping" in provider_conf.get("api", {})
-            ):
-                search_plugin_key = "api"
-            else:
-                continue
-            # get some already configured value
-            configured_metadata_mapping = getattr(
-                self.providers_config[provider], search_plugin_key
-            ).metadata_mapping
-            some_configured_value = next(iter(configured_metadata_mapping.values()))
-            # check if the configured value has already been built as jsonpath
-            if (
-                isinstance(some_configured_value, list)
-                and isinstance(some_configured_value[1], tuple)
-                or isinstance(some_configured_value, tuple)
-            ):
-                # also build as jsonpath the incoming conf
-                mtd_cfg_as_conversion_and_querypath(
-                    deepcopy(
-                        conf_update[provider][search_plugin_key]["metadata_mapping"]
-                    ),
-                    conf_update[provider][search_plugin_key]["metadata_mapping"],
-                )
-
         override_config_from_mapping(self.providers_config, conf_update)
 
-        stac_provider_config = load_stac_provider_config()
+        # share credentials between updated plugins confs
+        share_credentials(self.providers_config)
+
         for provider in conf_update.keys():
-            provider_config_init(self.providers_config[provider], stac_provider_config)
+            provider_config_init(
+                self.providers_config[provider],
+                load_stac_provider_config(),
+            )
+            setattr(self.providers_config[provider], "product_types_fetched", False)
         # re-create _plugins_manager using up-to-date providers_config
         self._plugins_manager.build_product_type_to_provider_config_map()
 
+    def add_provider(
+        self,
+        name: str,
+        url: Optional[str] = None,
+        priority: Optional[int] = None,
+        search: Dict[str, Any] = {"type": "StacSearch"},
+        products: Dict[str, Any] = {
+            GENERIC_PRODUCT_TYPE: {"productType": "{productType}"}
+        },
+        download: Dict[str, Any] = {"type": "HTTPDownload", "auth_error_code": 401},
+        **kwargs: Dict[str, Any],
+    ):
+        """Adds a new provider.
+
+        ``search``, ``products`` & ``download`` already have default values that will be
+        updated (not replaced), with user provided ones:
+
+            * ``search`` : ``{"type": "StacSearch"}``
+            * ``products`` : ``{"GENERIC_PRODUCT_TYPE": {"productType": "{productType}"}}``
+            * ``download`` : ``{"type": "HTTPDownload", "auth_error_code": 401}``
+
+        :param name: Name of provider
+        :param url: Provider url, also used as ``search["api_endpoint"]`` if not defined
+        :param priority: Provider priority. If None, provider will be set as preferred (highest priority)
+        :param search: Search :class:`~eodag.config.PluginConfig` mapping
+        :param products: Provider product types mapping
+        :param download: Download :class:`~eodag.config.PluginConfig` mapping
+        :param kwargs: Additional :class:`~eodag.config.ProviderConfig` mapping
+        """
+        conf_dict: Dict[str, Any] = {
+            name: {
+                "url": url,
+                "search": {"type": "StacSearch", **search},
+                "products": {
+                    GENERIC_PRODUCT_TYPE: {"productType": "{productType}"},
+                    **products,
+                },
+                "download": {
+                    "type": "HTTPDownload",
+                    "auth_error_code": 401,
+                    **download,
+                },
+                **kwargs,
+            }
+        }
+        if priority is not None:
+            conf_dict[name]["priority"] = priority
+        # if provided, use url as default search api_endpoint
+        if (
+            url
+            and conf_dict[name].get("search", {})
+            and not conf_dict[name]["search"].get("api_endpoint")
+        ):
+            conf_dict[name]["search"]["api_endpoint"] = url
+
+        # api plugin usage: remove unneeded search/download/auth plugin conf
+        if conf_dict[name].get("api"):
+            for k in PLUGINS_TOPICS_KEYS:
+                if k != "api":
+                    conf_dict[name].pop(k, None)
+
+        self.update_providers_config(dict_conf=conf_dict)
+
+        if priority is None:
+            self.set_preferred_provider(name)
+
     def _prune_providers_list(self) -> None:
         """Removes from config providers needing auth that have no credentials set."""
         update_needed = False
         for provider in list(self.providers_config.keys()):
             conf = self.providers_config[provider]
 
-            if hasattr(conf, "api") and getattr(conf.api, "need_auth", False):
-                credentials_exist = any(
-                    [
-                        cred is not None
-                        for cred in getattr(conf.api, "credentials", {}).values()
-                    ]
+            # remove providers using skipped plugins
+            if [
+                v
+                for v in conf.__dict__.values()
+                if isinstance(v, PluginConfig)
+                and getattr(v, "type", None) in self._plugins_manager.skipped_plugins
+            ]:
+                self.providers_config.pop(provider)
+                logger.debug(
+                    f"{provider}: provider needing unavailable plugin has been removed"
                 )
+                continue
+
+            # check authentication
+            if hasattr(conf, "api") and getattr(conf.api, "need_auth", False):
+                credentials_exist = credentials_in_auth(conf.api)
                 if not credentials_exist:
                     # credentials needed but not found
                     self._pruned_providers_config[provider] = self.providers_config.pop(
@@ -427,11 +482,11 @@ class EODataAccessGateway:
                     )
                     update_needed = True
                     logger.info(
-                        "%s: provider needing auth for search has been pruned because no crendentials could be found",
+                        "%s: provider needing auth for search has been pruned because no credentials could be found",
                         provider,
                     )
             elif hasattr(conf, "search") and getattr(conf.search, "need_auth", False):
-                if not hasattr(conf, "auth"):
+                if not hasattr(conf, "auth") and not hasattr(conf, "search_auth"):
                     # credentials needed but no auth plugin was found
                     self._pruned_providers_config[provider] = self.providers_config.pop(
                         provider
@@ -442,11 +497,13 @@ class EODataAccessGateway:
                         provider,
                     )
                     continue
-                credentials_exist = any(
-                    [
-                        cred is not None
-                        for cred in getattr(conf.auth, "credentials", {}).values()
-                    ]
+                credentials_exist = (
+                    hasattr(conf, "search_auth")
+                    and credentials_in_auth(conf.search_auth)
+                ) or (
+                    not hasattr(conf, "search_auth")
+                    and hasattr(conf, "auth")
+                    and credentials_in_auth(conf.auth)
                 )
                 if not credentials_exist:
                     # credentials needed but not found
@@ -455,7 +512,7 @@ class EODataAccessGateway:
                     )
                     update_needed = True
                     logger.info(
-                        "%s: provider needing auth for search has been pruned because no crendentials could be found",
+                        "%s: provider needing auth for search has been pruned because no credentials could be found",
                         provider,
                     )
             elif not hasattr(conf, "api") and not hasattr(conf, "search"):
@@ -495,16 +552,15 @@ class EODataAccessGateway:
                     attr: FRA
 
         :param locations_conf_path: Path to the locations configuration file
-        :type locations_conf_path: str
         """
         if os.path.isfile(locations_conf_path):
             locations_config = load_yml_config(locations_conf_path)
 
             main_key = next(iter(locations_config))
-            locations_config = locations_config[main_key]
+            main_locations_config = locations_config[main_key]
 
             logger.info("Locations configuration loaded from %s" % locations_conf_path)
-            self.locations_config: List[Dict[str, Any]] = locations_config
+            self.locations_config: List[Dict[str, Any]] = main_locations_config
         else:
             logger.info(
                 "Could not load locations configuration from %s" % locations_conf_path
@@ -518,12 +574,9 @@ class EODataAccessGateway:
 
         :param provider: (optional) The name of a provider that must support the product
                          types we are about to list
-        :type provider: str
         :param fetch_providers: (optional) Whether to fetch providers for new product
                                 types or not
-        :type fetch_providers: bool
         :returns: The list of the product types that can be accessed using eodag.
-        :rtype: list(dict)
         :raises: :class:`~eodag.utils.exceptions.UnsupportedProvider`
         """
         if fetch_providers:
@@ -531,57 +584,66 @@ class EODataAccessGateway:
             self.fetch_product_types_list(provider=provider)
 
         product_types: List[Dict[str, Any]] = []
-        if provider is not None:
-            if provider in self.providers_config:
-                provider_supported_products = self.providers_config[provider].products
-                for product_type_id in provider_supported_products:
-                    if product_type_id == GENERIC_PRODUCT_TYPE:
-                        continue
-                    config = self.product_types_config[product_type_id]
-                    if "alias" in config:
-                        config["_id"] = product_type_id
-                        product_type_id = config["alias"]
-                    product_type = dict(ID=product_type_id, **config)
-                    if product_type_id not in product_types:
-                        product_types.append(product_type)
-                return sorted(product_types, key=itemgetter("ID"))
+
+        providers_configs = (
+            list(self.providers_config.values())
+            if not provider
+            else [
+                p
+                for p in self.providers_config.values()
+                if provider in [p.name, getattr(p, "group", None)]
+            ]
+        )
+
+        if provider and not providers_configs:
             raise UnsupportedProvider(
                 f"The requested provider is not (yet) supported: {provider}"
             )
-        # Only get the product types supported by the available providers
-        for provider in self.available_providers():
-            current_product_type_ids = [pt["ID"] for pt in product_types]
-            product_types.extend(
-                [
-                    pt
-                    for pt in self.list_product_types(
-                        provider=provider, fetch_providers=False
-                    )
-                    if pt["ID"] not in current_product_type_ids
-                ]
-            )
+
+        for p in providers_configs:
+            for product_type_id in p.products:  # type: ignore
+                if product_type_id == GENERIC_PRODUCT_TYPE:
+                    continue
+                config = self.product_types_config[product_type_id]
+                config["_id"] = product_type_id
+                if "alias" in config:
+                    product_type_id = config["alias"]
+                product_type = {"ID": product_type_id, **config}
+                if product_type not in product_types:
+                    product_types.append(product_type)
+
         # Return the product_types sorted in lexicographic order of their ID
         return sorted(product_types, key=itemgetter("ID"))
 
     def fetch_product_types_list(self, provider: Optional[str] = None) -> None:
         """Fetch product types list and update if needed
 
-        :param provider: (optional) The name of a provider for which product types list
-                         should be updated. Defaults to all providers (None value).
-        :type provider: str
+        :param provider: The name of a provider or provider-group for which product types
+                         list should be updated. Defaults to all providers (None value).
         """
+        providers_to_fetch = list(self.providers_config.keys())
+        # check if some providers are grouped under a group name which is not a provider name
         if provider is not None and provider not in self.providers_config:
-            return
+            providers_to_fetch = [
+                p
+                for p, pconf in self.providers_config.items()
+                if provider == getattr(pconf, "group", None)
+            ]
+            if providers_to_fetch:
+                logger.info(
+                    f"Fetch product types for {provider} group: {', '.join(providers_to_fetch)}"
+                )
+            else:
+                return None
+        elif provider is not None:
+            providers_to_fetch = [provider]
 
         # providers discovery confs that are fetchable
         providers_discovery_configs_fetchable: Dict[str, Any] = {}
         # check if any provider has not already been fetched for product types
         already_fetched = True
-        for provider_to_fetch, provider_config in (
-            {provider: self.providers_config[provider]}.items()
-            if provider
-            else self.providers_config.items()
-        ):
+        for provider_to_fetch in providers_to_fetch:
+            provider_config = self.providers_config[provider_to_fetch]
             # get discovery conf
             if hasattr(provider_config, "search"):
                 provider_search_config = provider_config.search
@@ -611,9 +673,8 @@ class EODataAccessGateway:
 
                 if not ext_product_types_conf:
                     # empty ext_product_types conf
-                    discover_kwargs = dict(provider=provider) if provider else {}
-                    ext_product_types_conf = self.discover_product_types(
-                        **discover_kwargs
+                    ext_product_types_conf = (
+                        self.discover_product_types(provider=provider) or {}
                     )
 
             # update eodag product types list with new conf
@@ -691,36 +752,50 @@ class EODataAccessGateway:
                 # providers not skipped here should be user-modified
                 # or not in ext_product_types_conf (if eodag system conf != eodag conf used for ext_product_types_conf)
 
-            # discover product types for user configured provider
-            provider_ext_product_types_conf = self.discover_product_types(
-                provider=provider
-            )
-
-            # update eodag product types list with new conf
-            self.update_product_types_list(provider_ext_product_types_conf)
+            if not already_fetched:
+                # discover product types for user configured provider
+                provider_ext_product_types_conf = (
+                    self.discover_product_types(provider=provider) or {}
+                )
+                # update eodag product types list with new conf
+                self.update_product_types_list(provider_ext_product_types_conf)
 
     def discover_product_types(
         self, provider: Optional[str] = None
     ) -> Optional[Dict[str, Any]]:
         """Fetch providers for product types
 
-        :param provider: (optional) The name of a provider to fetch. Defaults to all
-                         providers (None value).
-        :type provider: str
+        :param provider: The name of a provider or provider-group to fetch. Defaults to
+                         all providers (None value).
         :returns: external product types configuration
-        :rtype: dict
         """
+        grouped_providers = [
+            p
+            for p, provider_config in self.providers_config.items()
+            if provider == getattr(provider_config, "group", None)
+        ]
+        if provider and provider not in self.providers_config and grouped_providers:
+            logger.info(
+                f"Discover product types for {provider} group: {', '.join(grouped_providers)}"
+            )
+        elif provider and provider not in self.providers_config:
+            raise UnsupportedProvider(
+                f"The requested provider is not (yet) supported: {provider}"
+            )
         ext_product_types_conf: Dict[str, Any] = {}
         providers_to_fetch = [
             p
             for p in (
                 [
-                    provider,
+                    p
+                    for p in self.providers_config
+                    if p in grouped_providers + [provider]
                 ]
                 if provider
                 else self.available_providers()
             )
         ]
+        kwargs: Dict[str, Any] = {}
         for provider in providers_to_fetch:
             if hasattr(self.providers_config[provider], "search"):
                 search_plugin_config = self.providers_config[provider].search
@@ -728,36 +803,37 @@ class EODataAccessGateway:
                 search_plugin_config = self.providers_config[provider].api
             else:
                 return None
-            if getattr(search_plugin_config, "discover_product_types", None):
+            if getattr(search_plugin_config, "discover_product_types", {}).get(
+                "fetch_url", None
+            ):
                 search_plugin: Union[Search, Api] = next(
                     self._plugins_manager.get_search_plugins(provider=provider)
                 )
+                # check after plugin init if still fetchable
+                if not getattr(search_plugin.config, "discover_product_types", {}).get(
+                    "fetch_url"
+                ):
+                    continue
                 # append auth to search plugin if needed
                 if getattr(search_plugin.config, "need_auth", False):
-                    auth_plugin = self._plugins_manager.get_auth_plugin(
-                        search_plugin.provider
-                    )
-                    if callable(getattr(auth_plugin, "authenticate", None)):
-                        try:
-                            search_plugin.auth = auth_plugin.authenticate()
-                        except (AuthenticationError, MisconfiguredError) as e:
-                            logger.warning(
-                                f"Could not authenticate on {provider}: {str(e)}"
-                            )
-                            ext_product_types_conf[provider] = None
-                            continue
+                    if auth := self._plugins_manager.get_auth(
+                        search_plugin.provider,
+                        getattr(search_plugin.config, "api_endpoint", None),
+                        search_plugin.config,
+                    ):
+                        kwargs["auth"] = auth
                     else:
-                        logger.warning(
-                            f"Could not authenticate on {provider} using {auth_plugin} plugin"
+                        logger.debug(
+                            f"Could not authenticate on {provider} for product types discovery"
                         )
                         ext_product_types_conf[provider] = None
                         continue
 
-                ext_product_types_conf[
-                    provider
-                ] = search_plugin.discover_product_types()
+                ext_product_types_conf[provider] = search_plugin.discover_product_types(
+                    **kwargs
+                )
 
-        return ext_product_types_conf
+        return sort_dict(ext_product_types_conf)
 
     def update_product_types_list(
         self, ext_product_types_conf: Dict[str, Optional[Dict[str, Dict[str, Any]]]]
@@ -765,7 +841,6 @@ class EODataAccessGateway:
         """Update eodag product types list
 
         :param ext_product_types_conf: external product types configuration
-        :type ext_product_types_conf: dict
         """
         for provider, new_product_types_conf in ext_product_types_conf.items():
             if new_product_types_conf and provider in self.providers_config:
@@ -775,7 +850,9 @@ class EODataAccessGateway:
                     ) or getattr(self.providers_config[provider], "api", None)
                     if search_plugin_config is None:
                         continue
-                    if not hasattr(search_plugin_config, "discover_product_types"):
+                    if not getattr(
+                        search_plugin_config, "discover_product_types", {}
+                    ).get("fetch_url", None):
                         # conf has been updated and provider product types are no more discoverable
                         continue
                     provider_products_config = (
@@ -848,32 +925,53 @@ class EODataAccessGateway:
         # rebuild index after product types list update
         self.build_index()
 
-    def available_providers(self, product_type: Optional[str] = None) -> List[str]:
-        """Gives the sorted list of the available providers
+    def available_providers(
+        self, product_type: Optional[str] = None, by_group: bool = False
+    ) -> List[str]:
+        """Gives the sorted list of the available providers or groups
+
+        The providers or groups are sorted first by their priority level in descending order,
+        and then alphabetically in ascending order for providers or groups with the same
+        priority level.
 
         :param product_type: (optional) Only list providers configured for this product_type
-        :type product_type: str
-        :returns: the sorted list of the available providers
-        :rtype: list
+        :param by_group: (optional) If set to True, list groups when available instead
+                         of providers, mixed with other providers
+        :returns: the sorted list of the available providers or groups
         """
 
         if product_type:
-            return sorted(
-                k
+            providers = [
+                (v.group if by_group and hasattr(v, "group") else k, v.priority)
                 for k, v in self.providers_config.items()
                 if product_type in getattr(v, "products", {}).keys()
-            )
+            ]
         else:
-            return sorted(tuple(self.providers_config.keys()))
+            providers = [
+                (v.group if by_group and hasattr(v, "group") else k, v.priority)
+                for k, v in self.providers_config.items()
+            ]
+
+        # If by_group is True, keep only the highest priority for each group
+        if by_group:
+            group_priority: Dict[str, int] = {}
+            for name, priority in providers:
+                if name not in group_priority or priority > group_priority[name]:
+                    group_priority[name] = priority
+            providers = list(group_priority.items())
+
+        # Sort by priority (descending) and then by name (ascending)
+        providers.sort(key=lambda x: (-x[1], x[0]))
+
+        # Return only the names of the providers or groups
+        return [name for name, _ in providers]
 
     def get_product_type_from_alias(self, alias_or_id: str) -> str:
         """Return the ID of a product type by either its ID or alias
 
         :param alias_or_id: Alias of the product type. If an existing ID is given, this
                             method will directly return the given value.
-        :type alias_or_id: str
         :returns: Internal name of the product type.
-        :rtype: str
         """
         product_types = [
             k
@@ -901,56 +999,118 @@ class EODataAccessGateway:
         given product type, its ID is returned instead.
 
         :param product_type: product type ID
-        :type product_type: str
         :returns: Alias of the product type or its ID if no alias has been defined for it.
-        :rtype: str
         """
         if product_type not in self.product_types_config:
             raise NoMatchingProductType(product_type)
 
         return self.product_types_config[product_type].get("alias", product_type)
 
-    def guess_product_type(self, **kwargs: Any) -> List[str]:
-        """Find eodag product types codes that best match a set of search params
-
-        :param kwargs: A set of search parameters as keywords arguments
-        :returns: The best match for the given parameters
-        :rtype: list[str]
+    def guess_product_type(
+        self,
+        free_text: Optional[str] = None,
+        intersect: bool = False,
+        instrument: Optional[str] = None,
+        platform: Optional[str] = None,
+        platformSerialIdentifier: Optional[str] = None,
+        processingLevel: Optional[str] = None,
+        sensorType: Optional[str] = None,
+        keywords: Optional[str] = None,
+        abstract: Optional[str] = None,
+        title: Optional[str] = None,
+        missionStartDate: Optional[str] = None,
+        missionEndDate: Optional[str] = None,
+        **kwargs: Any,
+    ) -> List[str]:
+        """
+        Find EODAG product type IDs that best match a set of search parameters.
+
+        See https://whoosh.readthedocs.io/en/latest/querylang.html#the-default-query-language
+          for syntax.
+
+        :param free_text: Whoosh-compatible free text search filter used to search
+                        accross all the following parameters
+        :param intersect: Join results for each parameter using INTERSECT instead of UNION.
+        :param instrument: Instrument parameter.
+        :param platform: Platform parameter.
+        :param platformSerialIdentifier: Platform serial identifier parameter.
+        :param processingLevel: Processing level parameter.
+        :param sensorType: Sensor type parameter.
+        :param keywords: Keywords parameter.
+        :param abstract: Abstract parameter.
+        :param title: Title parameter.
+        :param missionStartDate: start date for datetime filtering. Not used by free_text
+        :param missionEndDate: end date for datetime filtering. Not used by free_text
+        :returns: The best match for the given parameters.
         :raises: :class:`~eodag.utils.exceptions.NoMatchingProductType`
         """
-        if kwargs.get("productType", None):
-            return [kwargs["productType"]]
-        supported_params = {
-            param
-            for param in (
-                "instrument",
-                "platform",
-                "platformSerialIdentifier",
-                "processingLevel",
-                "sensorType",
-                "keywords",
-                "md5",
-            )
-            if kwargs.get(param, None) is not None
+        if productType := kwargs.get("productType"):
+            return [productType]
+
+        if not self._product_types_index:
+            raise EodagError("Missing product types index")
+
+        filters = {
+            "instrument": instrument,
+            "platform": platform,
+            "platformSerialIdentifier": platformSerialIdentifier,
+            "processingLevel": processingLevel,
+            "sensorType": sensorType,
+            "keywords": keywords,
+            "abstract": abstract,
+            "title": title,
         }
+        joint = " AND " if intersect else " OR "
+        filters_text = joint.join(
+            [f"{k}:({v})" for k, v in filters.items() if v is not None]
+        )
+
+        text = f"({free_text})" if free_text else ""
+        if free_text and filters_text:
+            text += joint
+        if filters_text:
+            text += f"({filters_text})"
+
+        if not text and (missionStartDate or missionEndDate):
+            text = "*"
+
         with self._product_types_index.searcher() as searcher:
-            results = None
-            # For each search key, do a guess and then upgrade the result (i.e. when
-            # merging results, if a hit appears in both results, its position is raised
-            # to the top. This way, the top most result will be the hit that best
-            # matches the given queries. Put another way, this best guess is the one
-            # that crosses the highest number of search params from the given queries
-            for search_key in supported_params:
-                query = QueryParser(search_key, self._product_types_index.schema).parse(
-                    kwargs[search_key]
+            p = EODAGQueryParser(list(filters.keys()), self._product_types_index.schema)
+            query = p.parse(text)
+            results = searcher.search(query, limit=None)
+
+            guesses: List[Dict[str, str]] = [dict(r) for r in results or []]
+
+        # datetime filtering
+        if missionStartDate or missionEndDate:
+            min_aware = datetime.datetime.min.replace(tzinfo=datetime.timezone.utc)
+            max_aware = datetime.datetime.max.replace(tzinfo=datetime.timezone.utc)
+            guesses = [
+                g
+                for g in guesses
+                if (
+                    max(
+                        rfc3339_str_to_datetime(missionStartDate)
+                        if missionStartDate
+                        else min_aware,
+                        rfc3339_str_to_datetime(g["missionStartDate"])
+                        if g.get("missionStartDate")
+                        else min_aware,
+                    )
+                    <= min(
+                        rfc3339_str_to_datetime(missionEndDate)
+                        if missionEndDate
+                        else max_aware,
+                        rfc3339_str_to_datetime(g["missionEndDate"])
+                        if g.get("missionEndDate")
+                        else max_aware,
+                    )
                 )
-                if results is None:
-                    results = searcher.search(query, limit=None)
-                else:
-                    results.upgrade_and_extend(searcher.search(query, limit=None))
-            guesses: List[str] = [r["ID"] for r in results or []]
+            ]
+
         if guesses:
-            return guesses
+            return [g["ID"] for g in guesses or []]
+
         raise NoMatchingProductType()
 
     def search(
@@ -963,8 +1123,9 @@ class EODataAccessGateway:
         geom: Optional[Union[str, Dict[str, float], BaseGeometry]] = None,
         locations: Optional[Dict[str, str]] = None,
         provider: Optional[str] = None,
+        count: bool = False,
         **kwargs: Any,
-    ) -> Tuple[SearchResult, int]:
+    ) -> SearchResult:
         """Look for products matching criteria on known providers.
 
         The default behaviour is to look for products on the provider with the
@@ -975,21 +1136,16 @@ class EODataAccessGateway:
         Only if the request fails for all available providers, an error will be thrown.
 
         :param page: (optional) The page number to return
-        :type page: int
         :param items_per_page: (optional) The number of results that must appear in one single
                                page
-        :type items_per_page: int
         :param raise_errors:  (optional) When an error occurs when searching, if this is set to
                               True, the error is raised
-        :type raise_errors: bool
         :param start: (optional) Start sensing time in ISO 8601 format (e.g. "1990-11-26",
                       "1990-11-26T14:30:10.153Z", "1990-11-26T14:30:10+02:00", ...).
                       If no time offset is given, the time is assumed to be given in UTC.
-        :type start: str
         :param end: (optional) End sensing time in ISO 8601 format (e.g. "1990-11-26",
                     "1990-11-26T14:30:10.153Z", "1990-11-26T14:30:10+02:00", ...).
                     If no time offset is given, the time is assumed to be given in UTC.
-        :type end: str
         :param geom: (optional) Search area that can be defined in different ways:
 
                      * with a Shapely geometry object:
@@ -999,23 +1155,22 @@ class EODataAccessGateway:
                      * with a bounding box as list of float:
                        ``[lonmin, latmin, lonmax, latmax]``
                      * with a WKT str
-        :type geom: Union[str, dict, shapely.geometry.base.BaseGeometry]
         :param locations: (optional) Location filtering by name using locations configuration
                           ``{"<location_name>"="<attr_regex>"}``. For example, ``{"country"="PA."}`` will use
                           the geometry of the features having the property ISO3 starting with
                           'PA' such as Panama and Pakistan in the shapefile configured with
                           name=country and attr=ISO3
-        :type locations: dict
-        :param kwargs: Some other criteria that will be used to do the search,
-                       using paramaters compatibles with the provider
         :param provider: (optional) the provider to be used. If set, search fallback will be disabled.
                          If not set, the configured preferred provider will be used at first
                          before trying others until finding results.
-        :type provider: str
-        :type kwargs: Union[int, str, bool, dict]
-        :returns: A collection of EO products matching the criteria and the total
-                  number of results found
-        :rtype: tuple(:class:`~eodag.api.search_result.SearchResult`, int)
+        :param count: (optional) Whether to run a query with a count request or not
+        :param kwargs: Some other criteria that will be used to do the search,
+                       using paramaters compatibles with the provider
+        :returns: A collection of EO products matching the criteria
+
+        .. versionchanged:: v3.0.0b1
+            ``search()`` method now returns only a single :class:`~eodag.api.search_result.SearchResult`
+            instead of a 2 values tuple.
 
         .. note::
             The search interfaces, which are implemented as plugins, are required to
@@ -1030,16 +1185,12 @@ class EODataAccessGateway:
             provider=provider,
             **kwargs,
         )
-
         if search_kwargs.get("id"):
-            # adds minimal pagination to be able to check only 1 product is returned
-            search_kwargs.update(
-                page=1,
-                items_per_page=2,
-                raise_errors=raise_errors,
-            )
             return self._search_by_id(
-                search_kwargs.pop("id"), provider=provider, **search_kwargs
+                search_kwargs.pop("id"),
+                provider=provider,
+                raise_errors=raise_errors,
+                **search_kwargs,
             )
         # remove datacube query string from kwargs which was only needed for search-by-id
         search_kwargs.pop("_dc_qs", None)
@@ -1049,26 +1200,29 @@ class EODataAccessGateway:
             items_per_page=items_per_page,
         )
 
-        self.search_errors = set()
+        errors: List[Tuple[str, Exception]] = []
         # Loop over available providers and return the first non-empty results
         for i, search_plugin in enumerate(search_plugins):
             search_plugin.clear()
-            search_results, total_results = self._do_search(
+            search_results = self._do_search(
                 search_plugin,
-                count=True,
+                count=count,
                 raise_errors=raise_errors,
                 **search_kwargs,
             )
+            errors.extend(search_results.errors)
             if len(search_results) == 0 and i < len(search_plugins) - 1:
                 logger.warning(
                     f"No result could be obtained from provider {search_plugin.provider}, "
                     "we will try to get the data from another provider",
                 )
             elif len(search_results) > 0:
-                return search_results, total_results
+                search_results.errors = errors
+                return search_results
 
-        logger.error("No result could be obtained from any available provider")
-        return SearchResult([]), 0
+        if i > 1:
+            logger.error("No result could be obtained from any available provider")
+        return SearchResult([], 0, errors) if count else SearchResult([], errors=errors)
 
     def search_iter_page(
         self,
@@ -1082,15 +1236,12 @@ class EODataAccessGateway:
         """Iterate over the pages of a products search.
 
         :param items_per_page: (optional) The number of results requested per page
-        :type items_per_page: int
         :param start: (optional) Start sensing time in ISO 8601 format (e.g. "1990-11-26",
                       "1990-11-26T14:30:10.153Z", "1990-11-26T14:30:10+02:00", ...).
                       If no time offset is given, the time is assumed to be given in UTC.
-        :type start: str
         :param end: (optional) End sensing time in ISO 8601 format (e.g. "1990-11-26",
                     "1990-11-26T14:30:10.153Z", "1990-11-26T14:30:10+02:00", ...).
                     If no time offset is given, the time is assumed to be given in UTC.
-        :type end: str
         :param geom: (optional) Search area that can be defined in different ways:
 
                      * with a Shapely geometry object:
@@ -1100,19 +1251,15 @@ class EODataAccessGateway:
                      * with a bounding box as list of float:
                        ``[lonmin, latmin, lonmax, latmax]``
                      * with a WKT str
-        :type geom: Union[str, dict, shapely.geometry.base.BaseGeometry]
         :param locations: (optional) Location filtering by name using locations configuration
                           ``{"<location_name>"="<attr_regex>"}``. For example, ``{"country"="PA."}`` will use
                           the geometry of the features having the property ISO3 starting with
                           'PA' such as Panama and Pakistan in the shapefile configured with
                           name=country and attr=ISO3
-        :type locations: dict
         :param kwargs: Some other criteria that will be used to do the search,
                        using paramaters compatibles with the provider
-        :type kwargs: Union[int, str, bool, dict]
         :returns: An iterator that yields page per page a collection of EO products
                   matching the criteria
-        :rtype: Iterator[:class:`~eodag.api.search_result.SearchResult`]
         """
         search_plugins, search_kwargs = self._prepare_search(
             start=start, end=end, geom=geom, locations=locations, **kwargs
@@ -1147,15 +1294,11 @@ class EODataAccessGateway:
         """Iterate over the pages of a products search using a given search plugin.
 
         :param items_per_page: (optional) The number of results requested per page
-        :type items_per_page: int
         :param kwargs: Some other criteria that will be used to do the search,
                        using parameters compatibles with the provider
-        :type kwargs: Union[int, str, bool, dict]
         :param search_plugin: search plugin to be used
-        :type search_plugin: eodag.plugins.search.base.Search
         :returns: An iterator that yields page per page a collection of EO products
                   matching the criteria
-        :rtype: Iterator[:class:`~eodag.api.search_result.SearchResult`]
         """
 
         iteration = 1
@@ -1181,9 +1324,10 @@ class EODataAccessGateway:
                 pagination_config["next_page_query_obj"] = next_page_query_obj
             logger.info("Iterate search over multiple pages: page #%s", iteration)
             try:
-                if "raise_errors" in kwargs:
-                    kwargs.pop("raise_errors")
-                products, _ = self._do_search(
+                # remove unwanted kwargs for _do_search
+                kwargs.pop("count", None)
+                kwargs.pop("raise_errors", None)
+                search_result = self._do_search(
                     search_plugin, count=False, raise_errors=True, **kwargs
                 )
             except Exception:
@@ -1222,12 +1366,12 @@ class EODataAccessGateway:
                     else:
                         search_plugin.next_page_query_obj = next_page_query_obj
 
-            if len(products) > 0:
+            if len(search_result) > 0:
                 # The first products between two iterations are compared. If they
                 # are actually the same product, it means the iteration failed at
                 # progressing for some reason. This is implemented as a workaround
                 # to some search plugins/providers not handling pagination.
-                product = products[0]
+                product = search_result[0]
                 if (
                     prev_product
                     and product.properties["id"] == prev_product.properties["id"]
@@ -1240,11 +1384,11 @@ class EODataAccessGateway:
                     )
                     last_page_with_products = iteration - 1
                     break
-                yield products
+                yield search_result
                 prev_product = product
                 # Prevent a last search if the current one returned less than the
                 # maximum number of items asked for.
-                if len(products) < items_per_page:
+                if len(search_result) < items_per_page:
                     last_page_with_products = iteration
                     break
             else:
@@ -1283,15 +1427,12 @@ class EODataAccessGateway:
                                matching the search criteria. If this number is not
                                available, a default value of 50 is used instead.
                                items_per_page can also be set to any arbitrary value.
-        :type items_per_page: int
         :param start: (optional) Start sensing time in ISO 8601 format (e.g. "1990-11-26",
                       "1990-11-26T14:30:10.153Z", "1990-11-26T14:30:10+02:00", ...).
                       If no time offset is given, the time is assumed to be given in UTC.
-        :type start: str
         :param end: (optional) End sensing time in ISO 8601 format (e.g. "1990-11-26",
                     "1990-11-26T14:30:10.153Z", "1990-11-26T14:30:10+02:00", ...).
                     If no time offset is given, the time is assumed to be given in UTC.
-        :type end: str
         :param geom: (optional) Search area that can be defined in different ways:
 
                      * with a Shapely geometry object:
@@ -1301,25 +1442,21 @@ class EODataAccessGateway:
                      * with a bounding box as list of float:
                        ``[lonmin, latmin, lonmax, latmax]``
                      * with a WKT str
-        :type geom: Union[str, dict, shapely.geometry.base.BaseGeometry]
         :param locations: (optional) Location filtering by name using locations configuration
                           ``{"<location_name>"="<attr_regex>"}``. For example, ``{"country"="PA."}`` will use
                           the geometry of the features having the property ISO3 starting with
                           'PA' such as Panama and Pakistan in the shapefile configured with
                           name=country and attr=ISO3
-        :type locations: dict
         :param kwargs: Some other criteria that will be used to do the search,
                        using parameters compatible with the provider
-        :type kwargs: Union[int, str, bool, dict]
         :returns: An iterator that yields page per page a collection of EO products
                   matching the criteria
-        :rtype: Iterator[:class:`~eodag.api.search_result.SearchResult`]
         """
         # Get the search plugin and the maximized value
         # of items_per_page if defined for the provider used.
         try:
             product_type = self.get_product_type_from_alias(
-                kwargs.get("productType", None) or self.guess_product_type(**kwargs)[0]
+                self.guess_product_type(**kwargs)[0]
             )
         except NoMatchingProductType:
             product_type = GENERIC_PRODUCT_TYPE
@@ -1338,10 +1475,14 @@ class EODataAccessGateway:
             start=start, end=end, geom=geom, locations=locations, **kwargs
         )
         for i, search_plugin in enumerate(search_plugins):
-            itp = items_per_page or search_plugin.config.pagination.get(
-                "max_items_per_page", DEFAULT_MAX_ITEMS_PER_PAGE
+            itp = (
+                items_per_page
+                or getattr(search_plugin.config, "pagination", {}).get(
+                    "max_items_per_page"
+                )
+                or DEFAULT_MAX_ITEMS_PER_PAGE
             )
-            logger.debug(
+            logger.info(
                 "Searching for all the products with provider %s and a maximum of %s "
                 "items per page.",
                 search_plugin.provider,
@@ -1385,7 +1526,7 @@ class EODataAccessGateway:
 
     def _search_by_id(
         self, uid: str, provider: Optional[str] = None, **kwargs: Any
-    ) -> Tuple[SearchResult, int]:
+    ) -> SearchResult:
         """Internal method that enables searching a product by its id.
 
         Keeps requesting providers until a result matching the id is supplied. The
@@ -1398,16 +1539,11 @@ class EODataAccessGateway:
         perform the search, if this information is available
 
         :param uid: The uid of the EO product
-        :type uid: str
         :param provider: (optional) The provider on which to search the product.
                          This may be useful for performance reasons when the user
                          knows this product is available on the given provider
-        :type provider: str
         :param kwargs: Search criteria to help finding the right product
-        :type kwargs: Any
-        :returns: A search result with one EO product or None at all, and the number
-                  of EO products retrieved (0 or 1)
-        :rtype: tuple(:class:`~eodag.api.search_result.SearchResult`, int)
+        :returns: A search result with one EO product or None at all
         """
         product_type = kwargs.get("productType", None)
         if product_type is not None:
@@ -1422,16 +1558,52 @@ class EODataAccessGateway:
         # datacube query string
         _dc_qs = kwargs.pop("_dc_qs", None)
 
+        results = SearchResult([])
+
         for plugin in search_plugins:
             logger.info(
                 "Searching product with id '%s' on provider: %s", uid, plugin.provider
             )
             logger.debug("Using plugin class for search: %s", plugin.__class__.__name__)
             plugin.clear()
-            if isinstance(plugin, BuildPostSearchResult):
-                results, _ = self._do_search(plugin, id=uid, _dc_qs=_dc_qs, **kwargs)
+
+            # adds maximal pagination to be able to do a search-all + crunch if more
+            # than one result are returned
+            items_per_page = plugin.config.pagination.get(
+                "max_items_per_page", DEFAULT_MAX_ITEMS_PER_PAGE
+            )
+            kwargs.update(items_per_page=items_per_page)
+            if isinstance(plugin, PostJsonSearch):
+                kwargs.update(
+                    items_per_page=items_per_page,
+                    _dc_qs=_dc_qs,
+                )
             else:
-                results, _ = self._do_search(plugin, id=uid, **kwargs)
+                kwargs.update(
+                    items_per_page=items_per_page,
+                )
+
+            try:
+                # if more than one results are found, try getting them all and then filter using crunch
+                for page_results in self.search_iter_page_plugin(
+                    search_plugin=plugin,
+                    id=uid,
+                    **kwargs,
+                ):
+                    results.data.extend(page_results.data)
+            except Exception as e:
+                if kwargs.get("raise_errors"):
+                    raise
+                logger.warning(e)
+                continue
+
+            # try using crunch to get unique result
+            if (
+                len(results) > 1
+                and len(filtered := results.filter_property(id=uid)) == 1
+            ):
+                results = filtered
+
             if len(results) == 1:
                 if not results[0].product_type:
                     # guess product type from properties
@@ -1439,20 +1611,36 @@ class EODataAccessGateway:
                     results[0].product_type = guesses[0]
                     # reset driver
                     results[0].driver = results[0].get_driver()
-                return results, 1
+                results.number_matched = 1
+                return results
             elif len(results) > 1:
-                if getattr(plugin.config, "two_passes_id_search", False):
-                    # check if id of one product exactly matches id that was searched for
-                    # required if provider does not offer search by id and therefore other
-                    # parameters which might not given an exact result are used
-                    for result in results:
-                        if result.properties["id"] == uid.split(".")[0]:
-                            return [results[0]], 1
                 logger.info(
                     "Several products found for this id (%s). You may try searching using more selective criteria.",
                     results,
                 )
-        return SearchResult([]), 0
+        return SearchResult([], 0)
+
+    def _fetch_external_product_type(self, provider: str, product_type: str):
+        plugins = self._plugins_manager.get_search_plugins(provider=provider)
+        plugin = next(plugins)
+
+        # check after plugin init if still fetchable
+        if not getattr(plugin.config, "discover_product_types", {}).get("fetch_url"):
+            return None
+
+        kwargs: Dict[str, Any] = {"productType": product_type}
+
+        # append auth if needed
+        if getattr(plugin.config, "need_auth", False):
+            if auth := self._plugins_manager.get_auth(
+                plugin.provider,
+                getattr(plugin.config, "api_endpoint", None),
+                plugin.config,
+            ):
+                kwargs["auth"] = auth
+
+        product_type_config = plugin.discover_product_types(**kwargs)
+        self.update_product_types_list({provider: product_type_config})
 
     def _prepare_search(
         self,
@@ -1480,25 +1668,18 @@ class EODataAccessGateway:
         :param start: (optional) Start sensing time in ISO 8601 format (e.g. "1990-11-26",
                       "1990-11-26T14:30:10.153Z", "1990-11-26T14:30:10+02:00", ...).
                       If no time offset is given, the time is assumed to be given in UTC.
-        :type start: str
         :param end: (optional) End sensing time in ISO 8601 format (e.g. "1990-11-26",
                     "1990-11-26T14:30:10.153Z", "1990-11-26T14:30:10+02:00", ...).
                     If no time offset is given, the time is assumed to be given in UTC.
-        :type end: str
         :param geom: (optional) Search area that can be defined in different ways (see search)
-        :type geom: Union[str, dict, shapely.geometry.base.BaseGeometry]
         :param locations: (optional) Location filtering by name using locations configuration
-        :type locations: dict
         :param provider: provider to be used, if no provider is given or the product type
                         is not available for the provider, the preferred provider is used
-        :type provider: str
         :param kwargs: Some other criteria
                        * id and/or a provider for a search by
                        * search criteria to guess the product type
                        * other criteria compatible with the provider
-        :type kwargs: Any
         :returns: Search plugins list and the prepared kwargs to make a query.
-        :rtype: tuple(list, dict)
         """
         product_type = kwargs.get("productType", None)
         if product_type is None:
@@ -1532,7 +1713,7 @@ class EODataAccessGateway:
             try:
                 product_type = self.get_product_type_from_alias(product_type)
             except NoMatchingProductType:
-                logger.warning("unknown product type " + product_type)
+                logger.info("unknown product type " + product_type)
         kwargs["productType"] = product_type
 
         if start is not None:
@@ -1564,10 +1745,16 @@ class EODataAccessGateway:
             product_type
             not in self._plugins_manager.product_type_to_provider_config_map.keys()
         ):
-            logger.debug(
-                f"Fetching external product types sources to find {product_type} product type"
-            )
-            self.fetch_product_types_list()
+            if provider:
+                # Try to get specific product type from external provider
+                logger.debug(f"Fetching {provider} to find {product_type} product type")
+                self._fetch_external_product_type(provider, product_type)
+            if not provider:
+                # no provider or still not found -> fetch all external product types
+                logger.debug(
+                    f"Fetching external product types sources to find {product_type} product type"
+                )
+                self.fetch_product_types_list()
 
         preferred_provider = self.get_preferred_provider()[0]
 
@@ -1589,12 +1776,10 @@ class EODataAccessGateway:
             provider = preferred_provider
         providers = [plugin.provider for plugin in search_plugins]
         if provider not in providers:
-            logger.warning(
-                "Product type '%s' is not available with provider '%s'. "
-                "Searching it on provider '%s' instead.",
+            logger.debug(
+                "Product type '%s' is not available with preferred provider '%s'.",
                 product_type,
                 provider,
-                search_plugins[0].provider,
             )
         else:
             provider_plugin = list(
@@ -1602,11 +1787,6 @@ class EODataAccessGateway:
             )[0]
             search_plugins.remove(provider_plugin)
             search_plugins.insert(0, provider_plugin)
-            logger.info(
-                "Searching product type '%s' on provider: %s",
-                product_type,
-                search_plugins[0].provider,
-            )
         # Add product_types_config to plugin config. This dict contains product
         # type metadata that will also be stored in each product's properties.
         for search_plugin in search_plugins:
@@ -1617,8 +1797,7 @@ class EODataAccessGateway:
                         for p in self.list_product_types(
                             search_plugin.provider, fetch_providers=False
                         )
-                        if p["ID"] == product_type
-                        or ("_id" in p and p["_id"] == product_type)
+                        if p["_id"] == product_type
                     ][0],
                     **{"productType": product_type},
                 )
@@ -1638,29 +1817,27 @@ class EODataAccessGateway:
     def _do_search(
         self,
         search_plugin: Union[Search, Api],
-        count: bool = True,
+        count: bool = False,
         raise_errors: bool = False,
         **kwargs: Any,
-    ) -> Tuple[SearchResult, Optional[int]]:
+    ) -> SearchResult:
         """Internal method that performs a search on a given provider.
 
         :param search_plugin: A search plugin
-        :type search_plugin: eodag.plugins.base.Search
         :param count: (optional) Whether to run a query with a count request or not
-        :type count: bool
         :param raise_errors: (optional) When an error occurs when searching, if this is set to
                              True, the error is raised
-        :type raise_errors: bool
         :param kwargs: Some other criteria that will be used to do the search
-        :type kwargs: Any
-        :returns: A collection of EO products matching the criteria and the total
-                  number of results found if count is True else None
-        :rtype: tuple(:class:`~eodag.api.search_result.SearchResult`, int or None)
+        :returns: A collection of EO products matching the criteria
         """
+        logger.info("Searching on provider %s", search_plugin.provider)
         max_items_per_page = getattr(search_plugin.config, "pagination", {}).get(
             "max_items_per_page", DEFAULT_MAX_ITEMS_PER_PAGE
         )
-        if kwargs.get("items_per_page", DEFAULT_ITEMS_PER_PAGE) > max_items_per_page:
+        if (
+            kwargs.get("items_per_page", DEFAULT_ITEMS_PER_PAGE) > max_items_per_page
+            and max_items_per_page > 0
+        ):
             logger.warning(
                 "EODAG believes that you might have asked for more products/items "
                 "than the maximum allowed by '%s': %s > %s. Try to lower "
@@ -1671,56 +1848,27 @@ class EODataAccessGateway:
                 max_items_per_page,
             )
 
-        need_auth = getattr(search_plugin.config, "need_auth", False)
-        auth_plugin = self._plugins_manager.get_auth_plugin(search_plugin.provider)
-        can_authenticate = callable(getattr(auth_plugin, "authenticate", None))
-
         results: List[EOProduct] = []
-        total_results = 0
+        total_results: Optional[int] = 0 if count else None
+
+        errors: List[Tuple[str, Exception]] = []
 
         try:
-            if need_auth and auth_plugin and can_authenticate:
-                search_plugin.auth = auth_plugin.authenticate()
-
-            res, nb_res = search_plugin.query(count=count, auth=auth_plugin, **kwargs)
-
-            # Only do the pagination computations when it makes sense. For example,
-            # for a search by id, we can reasonably guess that the provider will return
-            # At most 1 product, so we don't need such a thing as pagination
-            page = kwargs.get("page")
-            items_per_page = kwargs.get("items_per_page")
-            if page and items_per_page and count:
-                # Take into account the fact that a provider may not return the count of
-                # products (in that case, fallback to using the length of the results it
-                # returned and the page requested. As an example, check the result of
-                # the following request (look for the value of properties.totalResults)
-                # https://theia-landsat.cnes.fr/resto/api/collections/Landsat/search.json?
-                # maxRecords=1&page=1
-                if not nb_res:
-                    nb_res = len(res) * page
-
-                # Attempt to ensure a little bit more coherence. Some providers return
-                # a fuzzy number of total results, meaning that you have to keep
-                # requesting it until it has returned everything it has to know exactly
-                # how many EO products they have in their stock. In that case, we need
-                # to replace the returned number of results with the sum of the number
-                # of items that were skipped so far and the length of the currently
-                # retrieved items. We know there is an incoherence when the number of
-                # skipped items is greater than the total number of items returned by
-                # the plugin
-                nb_skipped_items = items_per_page * (page - 1)
-                nb_current_items = len(res)
-                if nb_skipped_items > nb_res:
-                    if nb_res != 0:
-                        nb_res = nb_skipped_items + nb_current_items
-                    # This is for when the returned results is an empty list and the
-                    # number of results returned is incoherent with the observations.
-                    # In that case, we assume the total number of results is the number
-                    # of skipped results. By requesting a lower page than the current
-                    # one, a user can iteratively reach the last page of results for
-                    # these criteria on the provider.
-                    else:
-                        nb_res = nb_skipped_items
+            prep = PreparedSearch(count=count)
+
+            # append auth if needed
+            if getattr(search_plugin.config, "need_auth", False):
+                if auth := self._plugins_manager.get_auth(
+                    search_plugin.provider,
+                    getattr(search_plugin.config, "api_endpoint", None),
+                    search_plugin.config,
+                ):
+                    prep.auth = auth
+
+            prep.page = kwargs.pop("page", None)
+            prep.items_per_page = kwargs.pop("items_per_page", None)
+
+            res, nb_res = search_plugin.query(prep, **kwargs)
 
             if not isinstance(res, list):
                 raise PluginImplementationError(
@@ -1743,8 +1891,8 @@ class EODataAccessGateway:
                     pattern = re.compile(r"[^\w,]+")
                     try:
                         guesses = self.guess_product_type(
+                            intersect=False,
                             **{
-                                # k:str(v) for k,v in eo_product.properties.items()
                                 k: pattern.sub("", str(v).upper())
                                 for k, v in eo_product.properties.items()
                                 if k
@@ -1757,7 +1905,7 @@ class EODataAccessGateway:
                                     "keywords",
                                 ]
                                 and v is not None
-                            }
+                            },
                         )
                     except NoMatchingProductType:
                         pass
@@ -1776,11 +1924,34 @@ class EODataAccessGateway:
                     download_plugin = self._plugins_manager.get_download_plugin(
                         eo_product
                     )
+                    if len(eo_product.assets) > 0:
+                        matching_url = next(iter(eo_product.assets.values()))["href"]
+                    elif eo_product.properties.get("storageStatus") != ONLINE_STATUS:
+                        matching_url = eo_product.properties.get(
+                            "orderLink"
+                        ) or eo_product.properties.get("downloadLink")
+                    else:
+                        matching_url = eo_product.properties.get("downloadLink")
+
+                    try:
+                        auth_plugin = next(
+                            self._plugins_manager.get_auth_plugins(
+                                search_plugin.provider,
+                                matching_url=matching_url,
+                                matching_conf=download_plugin.config,
+                            )
+                        )
+                    except StopIteration:
+                        auth_plugin = None
                     eo_product.register_downloader(download_plugin, auth_plugin)
 
             results.extend(res)
-            total_results = None if nb_res is None else total_results + nb_res
-            if count:
+            total_results = (
+                None
+                if (nb_res is None or total_results is None)
+                else total_results + nb_res
+            )
+            if count and nb_res is not None:
                 logger.info(
                     "Found %s result(s) on provider '%s'",
                     nb_res,
@@ -1801,10 +1972,6 @@ class EODataAccessGateway:
                         "the total number of products matching the search criteria"
                     )
         except Exception as e:
-            log_msg = f"No result from provider '{search_plugin.provider}' due to an error during search."
-            if not raise_errors:
-                log_msg += " Raise verbosity of log messages for details"
-            logger.info(log_msg)
             if raise_errors:
                 # Raise the error, letting the application wrapping eodag know that
                 # something went bad. This way it will be able to decide what to do next
@@ -1814,16 +1981,14 @@ class EODataAccessGateway:
                     "Error while searching on provider %s (ignored):",
                     search_plugin.provider,
                 )
-                self.search_errors.add((search_plugin.provider, e))
-        return SearchResult(results), total_results
+                errors.append((search_plugin.provider, e))
+        return SearchResult(results, total_results, errors)
 
     def crunch(self, results: SearchResult, **kwargs: Any) -> SearchResult:
         """Apply the filters given through the keyword arguments to the results
 
         :param results: The results of a eodag search request
-        :type results: :class:`~eodag.api.search_result.SearchResult`
         :returns: The result of successively applying all the filters to the results
-        :rtype: :class:`~eodag.api.search_result.SearchResult`
         """
         search_criteria = kwargs.pop("search_criteria", {})
         for cruncher_name, cruncher_args in kwargs.items():
@@ -1839,7 +2004,6 @@ class EODataAccessGateway:
         by extent (i.e. bounding box).
 
         :param searches: List of eodag SearchResult
-        :type searches: list
         :returns: list of :class:`~eodag.api.search_result.SearchResult`
         """
         # Dict with extents as keys, each extent being defined by a str
@@ -1865,38 +2029,37 @@ class EODataAccessGateway:
         progress_callback: Optional[ProgressCallback] = None,
         wait: int = DEFAULT_DOWNLOAD_WAIT,
         timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
-        **kwargs: Any,
+        **kwargs: Unpack[DownloadConf],
     ) -> List[str]:
         """Download all products resulting from a search.
 
         :param search_result: A collection of EO products resulting from a search
-        :type search_result: :class:`~eodag.api.search_result.SearchResult`
         :param downloaded_callback: (optional) A method or a callable object which takes
                                     as parameter the ``product``. You can use the base class
                                     :class:`~eodag.api.product.DownloadedCallback` and override
                                     its ``__call__`` method. Will be called each time a product
                                     finishes downloading
-        :type downloaded_callback: Callable[[:class:`~eodag.api.product._product.EOProduct`], None]
-                                   or None
         :param progress_callback: (optional) A method or a callable object
                                   which takes a current size and a maximum
                                   size as inputs and handle progress bar
                                   creation and update to give the user a
                                   feedback on the download progress
-        :type progress_callback: :class:`~eodag.utils.ProgressCallback` or None
         :param wait: (optional) If download fails, wait time in minutes between
                      two download tries of the same product
-        :type wait: int
         :param timeout: (optional) If download fails, maximum time in minutes
                         before stop retrying to download
-        :type timeout: int
-        :param kwargs: `outputs_prefix` (str), `extract` (bool), `delete_archive` (bool)
-                        and `dl_url_params` (dict) can be provided as additional kwargs
-                        and will override any other values defined in a configuration
-                        file or with environment variables.
-        :type kwargs: Union[str, bool, dict]
+        :param kwargs: Additional keyword arguments from the download plugin configuration class that can
+                       be provided to override any other values defined in a configuration file
+                       or with environment variables:
+
+                       * ``output_dir`` - where to store downloaded products, as an absolute file path
+                         (Default: local temporary directory)
+                       * ``output_extension`` - downloaded file extension
+                       * ``extract`` - whether to extract the downloaded products, only applies to archived products
+                       * ``dl_url_params`` - additional parameters to pass over to the download url as an url parameter
+                       * ``delete_archive`` - whether to delete the downloaded archives
+                       * ``asset`` - regex filter to identify assets to download
         :returns: A collection of the absolute paths to the downloaded products
-        :rtype: list
         """
         paths = []
         if search_result:
@@ -1925,11 +2088,8 @@ class EODataAccessGateway:
         """Registers results of a search into a geojson file.
 
         :param search_result: A collection of EO products resulting from a search
-        :type search_result: :class:`~eodag.api.search_result.SearchResult`
         :param filename: (optional) The name of the file to generate
-        :type filename: str
         :returns: The name of the created file
-        :rtype: str
         """
         with open(filename, "w") as fh:
             geojson.dump(search_result, fh)
@@ -1940,9 +2100,7 @@ class EODataAccessGateway:
         """Loads results of a search from a geojson file.
 
         :param filename: A filename containing a search result encoded as a geojson
-        :type filename: str
         :returns: The search results encoded in `filename`
-        :rtype: :class:`~eodag.api.search_result.SearchResult`
         """
         with open(filename, "r") as fh:
             return SearchResult.from_geojson(geojson.load(fh))
@@ -1952,19 +2110,17 @@ class EODataAccessGateway:
         products with the information needed to download itself
 
         :param filename: A filename containing a search result encoded as a geojson
-        :type filename: str
         :returns: The search results encoded in `filename`
-        :rtype: :class:`~eodag.api.search_result.SearchResult`
         """
         products = self.deserialize(filename)
         for i, product in enumerate(products):
             if product.downloader is None:
+                downloader = self._plugins_manager.get_download_plugin(product)
                 auth = product.downloader_auth
                 if auth is None:
-                    auth = self._plugins_manager.get_auth_plugin(product.provider)
-                products[i].register_downloader(
-                    self._plugins_manager.get_download_plugin(product), auth
-                )
+                    auth = self._plugins_manager.get_auth_plugin(downloader, product)
+                products[i].register_downloader(downloader, auth)
+
         return products
 
     @_deprecated(
@@ -1978,6 +2134,7 @@ class EODataAccessGateway:
         provider: Optional[str] = None,
         productType: Optional[str] = None,
         timeout: int = HTTP_REQ_TIMEOUT,
+        ssl_verify: bool = True,
         **kwargs: Any,
     ) -> SearchResult:
         """Loads STAC items from a geojson file / STAC catalog or collection, and convert to SearchResult.
@@ -1986,22 +2143,14 @@ class EODataAccessGateway:
         the response content to an API request.
 
         :param filename: A filename containing features encoded as a geojson
-        :type filename: str
         :param recursive: (optional) Browse recursively in child nodes if True
-        :type recursive: bool
         :param max_connections: (optional) Maximum number of connections for HTTP requests
-        :type max_connections: int
         :param provider: (optional) Data provider
-        :type provider: str
         :param productType: (optional) Data product type
-        :type productType: str
         :param timeout: (optional) Timeout in seconds for each internal HTTP request
-        :type timeout: float
         :param kwargs: Parameters that will be stored in the result as
                        search criteria
-        :type kwargs: Any
         :returns: The search results encoded in `filename`
-        :rtype: :class:`~eodag.api.search_result.SearchResult`
 
         .. deprecated:: 2.2.1
            Use the :class:`~eodag.plugins.search.static_stac_search.StaticStacSearch` search plugin instead.
@@ -2011,6 +2160,7 @@ class EODataAccessGateway:
             recursive=recursive,
             max_connections=max_connections,
             timeout=timeout,
+            ssl_verify=ssl_verify,
         )
         feature_collection = geojson.FeatureCollection(features)
 
@@ -2027,12 +2177,14 @@ class EODataAccessGateway:
             )
         )
 
-        products, _ = self.search(productType=productType, provider=provider, **kwargs)
+        search_result = self.search(
+            productType=productType, provider=provider, **kwargs
+        )
 
         # restore plugin._request
         plugin._request = plugin_request
 
-        return products
+        return search_result
 
     def download(
         self,
@@ -2040,7 +2192,7 @@ class EODataAccessGateway:
         progress_callback: Optional[ProgressCallback] = None,
         wait: int = DEFAULT_DOWNLOAD_WAIT,
         timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
-        **kwargs: Any,
+        **kwargs: Unpack[DownloadConf],
     ) -> str:
         """Download a single product.
 
@@ -2063,26 +2215,27 @@ class EODataAccessGateway:
         trying to download the product.
 
         :param product: The EO product to download
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         :param progress_callback: (optional) A method or a callable object
                                   which takes a current size and a maximum
                                   size as inputs and handle progress bar
                                   creation and update to give the user a
                                   feedback on the download progress
-        :type progress_callback: :class:`~eodag.utils.ProgressCallback` or None
         :param wait: (optional) If download fails, wait time in minutes between
                     two download tries
-        :type wait: int
         :param timeout: (optional) If download fails, maximum time in minutes
                         before stop retrying to download
-        :type timeout: int
-        :param kwargs: `outputs_prefix` (str), `extract` (bool), `delete_archive` (bool)
-                        and `dl_url_params` (dict) can be provided as additional kwargs
-                        and will override any other values defined in a configuration
-                        file or with environment variables.
-        :type kwargs: Union[str, bool, dict]
+        :param kwargs: Additional keyword arguments from the download plugin configuration class that can
+                       be provided to override any other values defined in a configuration file
+                       or with environment variables:
+
+                       * ``output_dir`` - where to store downloaded products, as an absolute file path
+                         (Default: local temporary directory)
+                       * ``output_extension`` - downloaded file extension
+                       * ``extract`` - whether to extract the downloaded products, only applies to archived products
+                       * ``dl_url_params`` - additional parameters to pass over to the download url as an url parameter
+                       * ``delete_archive`` - whether to delete the downloaded archives
+                       * ``asset`` - regex filter to identify assets to download
         :returns: The absolute path to the downloaded product in the local filesystem
-        :rtype: str
         :raises: :class:`~eodag.utils.exceptions.PluginImplementationError`
         :raises: :class:`RuntimeError`
         """
@@ -2098,146 +2251,77 @@ class EODataAccessGateway:
 
     def _setup_downloader(self, product: EOProduct) -> None:
         if product.downloader is None:
+            downloader = self._plugins_manager.get_download_plugin(product)
             auth = product.downloader_auth
             if auth is None:
-                auth = self._plugins_manager.get_auth_plugin(product.provider)
-            product.register_downloader(
-                self._plugins_manager.get_download_plugin(product), auth
-            )
+                auth = self._plugins_manager.get_auth_plugin(downloader, product)
+            product.register_downloader(downloader, auth)
 
     def get_cruncher(self, name: str, **options: Any) -> Crunch:
         """Build a crunch plugin from a configuration
 
         :param name: The name of the cruncher to build
-        :type name: str
         :param options: The configuration options of the cruncher
-        :type options: dict
         :returns: The cruncher named ``name``
-        :rtype: :class:`~eodag.plugins.crunch.Crunch`
         """
         plugin_conf = {"name": name}
         plugin_conf.update({key.replace("-", "_"): val for key, val in options.items()})
         return self._plugins_manager.get_crunch_plugin(name, **plugin_conf)
 
     def list_queryables(
-        self,
-        provider: Optional[str] = None,
-        **kwargs: Any,
+        self, provider: Optional[str] = None, **kwargs: Any
     ) -> Dict[str, Annotated[Any, FieldInfo]]:
         """Fetch the queryable properties for a given product type and/or provider.
 
         :param provider: (optional) The provider.
-        :type provider: str
         :param kwargs: additional filters for queryables (`productType` or other search
                        arguments)
-        :type kwargs: Any
+
+        :raises UnsupportedProductType: If the specified product type is not available for the
+                                        provider.
+
         :returns: A dict containing the EODAG queryable properties, associating
                   parameters to their annotated type
-        :rtype: Dict[str, Annotated[Any, FieldInfo]]
         """
-        # unknown product type
         available_product_types = [
-            pt["ID"] for pt in self.list_product_types(fetch_providers=False)
+            pt["ID"]
+            for pt in self.list_product_types(provider=provider, fetch_providers=False)
         ]
-        product_type = kwargs.get("productType", None)
-        if product_type is not None and product_type not in available_product_types:
-            self.fetch_product_types_list()
-
-        # dictionary of the queryable properties of the providers supporting the given product type
-        providers_available_queryables: Dict[
-            str, Dict[str, Annotated[Any, FieldInfo]]
-        ] = dict()
-
-        if provider is None and product_type is None:
-            return model_fields_to_annotated(CommonQueryables.model_fields)
-        elif provider is None:
-            for plugin in self._plugins_manager.get_search_plugins(
-                product_type, provider
-            ):
-                providers_available_queryables[plugin.provider] = self.list_queryables(
-                    provider=plugin.provider, **kwargs
-                )
+        product_type = kwargs.get("productType")
 
-            # return providers queryables intersection
-            queryables_keys: AbstractSet[str] = set()
-            for queryables in providers_available_queryables.values():
-                queryables_keys = (
-                    queryables_keys & queryables.keys()
-                    if queryables_keys
-                    else queryables.keys()
+        if product_type:
+            try:
+                kwargs["productType"] = product_type = self.get_product_type_from_alias(
+                    product_type
                 )
-            return {
-                k: v
-                for k, v in providers_available_queryables.popitem()[1].items()
-                if k in queryables_keys
-            }
+            except NoMatchingProductType as e:
+                raise UnsupportedProductType(f"{product_type} is not available") from e
 
-        all_queryables = copy_deepcopy(
-            model_fields_to_annotated(Queryables.model_fields)
-        )
+        if product_type and product_type not in available_product_types:
+            self.fetch_product_types_list()
 
-        try:
-            plugin = next(
-                self._plugins_manager.get_search_plugins(product_type, provider)
-            )
-        except StopIteration:
-            # return default queryables if no plugin is found
+        if not provider and not product_type:
             return model_fields_to_annotated(CommonQueryables.model_fields)
 
-        providers_available_queryables[plugin.provider] = dict()
+        providers_queryables: Dict[str, Dict[str, Annotated[Any, FieldInfo]]] = {}
 
-        # unknown product type: try again after fetch_product_types_list()
-        if (
-            product_type
-            and product_type not in plugin.config.products.keys()
-            and provider is None
-        ):
-            raise UnsupportedProductType(product_type)
-        elif product_type and product_type not in plugin.config.products.keys():
-            raise UnsupportedProductType(
-                f"{product_type} is not available for provider {provider}"
+        for plugin in self._plugins_manager.get_search_plugins(product_type, provider):
+            if getattr(plugin.config, "need_auth", False) and (
+                auth := self._plugins_manager.get_auth_plugin(plugin)
+            ):
+                plugin.auth = auth.authenticate()
+            providers_queryables[plugin.provider] = plugin.list_queryables(
+                filters=kwargs, product_type=product_type
             )
 
-        metadata_mapping = deepcopy(getattr(plugin.config, "metadata_mapping", {}))
-
-        # product_type-specific metadata-mapping
-        metadata_mapping.update(
-            getattr(plugin.config, "products", {})
-            .get(product_type, {})
-            .get("metadata_mapping", {})
-        )
-
-        # default values
-        default_values = deepcopy(
-            getattr(plugin.config, "products", {}).get(product_type, {})
+        queryable_keys: Set[str] = set.intersection(  # type: ignore
+            *[set(q.keys()) for q in providers_queryables.values()]
         )
-        default_values.pop("metadata_mapping", None)
-        kwargs = dict(default_values, **kwargs)
-
-        # remove not mapped parameters or non-queryables
-        for param in list(metadata_mapping.keys()):
-            if NOT_MAPPED in metadata_mapping[param] or not isinstance(
-                metadata_mapping[param], list
-            ):
-                del metadata_mapping[param]
-
-        for key, value in all_queryables.items():
-            annotated_args = get_args(value)
-            if len(annotated_args) < 1:
-                continue
-            field_info = annotated_args[1]
-            if not isinstance(field_info, FieldInfo):
-                continue
-            if key in kwargs:
-                field_info.default = kwargs[key]
-            if field_info.is_required() or (
-                (field_info.alias or key) in metadata_mapping
-            ):
-                providers_available_queryables[plugin.provider][key] = value
-
-        provider_queryables = plugin.discover_queryables(**kwargs) or dict()
-        # use EODAG configured queryables by default
-        provider_queryables.update(providers_available_queryables[provider])
+        queryables = {
+            k: v
+            for k, v in list(providers_queryables.values())[0].items()
+            if k in queryable_keys
+        }
 
         # always keep at least CommonQueryables
         common_queryables = copy_deepcopy(CommonQueryables.model_fields)
@@ -2245,6 +2329,38 @@ class EODataAccessGateway:
             if key in kwargs:
                 queryable.default = kwargs[key]
 
-        provider_queryables.update(model_fields_to_annotated(common_queryables))
+        queryables.update(model_fields_to_annotated(common_queryables))
+
+        return queryables
+
+    def available_sortables(self) -> Dict[str, Optional[ProviderSortables]]:
+        """For each provider, gives its available sortable parameter(s) and its maximum
+        number of them if it supports the sorting feature, otherwise gives None.
 
-        return provider_queryables
+        :returns: A dictionary with providers as keys and dictionary of sortable parameter(s) and
+                  its (their) maximum number as value(s).
+        :raises: :class:`~eodag.utils.exceptions.UnsupportedProvider`
+        """
+        sortables: Dict[str, Optional[ProviderSortables]] = {}
+        provider_search_plugins = self._plugins_manager.get_search_plugins()
+        for provider_search_plugin in provider_search_plugins:
+            provider = provider_search_plugin.provider
+            if not hasattr(provider_search_plugin.config, "sort"):
+                sortables[provider] = None
+                continue
+            sortable_params = list(
+                provider_search_plugin.config.sort.get("sort_param_mapping", {}).keys()
+            )
+            if not provider_search_plugin.config.sort.get("max_sort_params"):
+                sortables[provider] = {
+                    "sortables": sortable_params,
+                    "max_sort_params": None,
+                }
+                continue
+            sortables[provider] = {
+                "sortables": sortable_params,
+                "max_sort_params": provider_search_plugin.config.sort[
+                    "max_sort_params"
+                ],
+            }
+        return sortables