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

eodag/api/core.py

@@ -17,13 +17,25 @@
 # 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, Any, Dict, Iterator, List, Optional, Set, Tuple, Union
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    Dict,
+    Iterator,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+)
 
 import geojson
 import pkg_resources
@@ -35,11 +47,16 @@ from whoosh.fields import Schema
 from whoosh.index import create_in, exists_in, open_dir
 from whoosh.qparser import QueryParser
 
-from eodag.api.product.metadata_mapping import mtd_cfg_as_conversion_and_querypath
+from eodag.api.product.metadata_mapping import (
+    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,
@@ -48,10 +65,12 @@ 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
 from eodag.types.whoosh import EODAGQueryParser
@@ -66,17 +85,15 @@ from eodag.utils import (
     MockResponse,
     _deprecated,
     copy_deepcopy,
-    deepcopy,
     get_geometry_from_various,
     makedirs,
     obj_md5sum,
+    sort_dict,
     string_to_jsonpath,
     uri_to_path,
 )
 from eodag.utils.exceptions import (
-    AuthenticationError,
     EodagError,
-    MisconfiguredError,
     NoMatchingProductType,
     PluginImplementationError,
     RequestError,
@@ -96,7 +113,7 @@ if TYPE_CHECKING:
     from eodag.plugins.search.base import Search
     from eodag.types import ProviderSortables
     from eodag.types.download_args import DownloadConf
-    from eodag.utils import Annotated, DownloadedCallback, ProgressCallback, Unpack
+    from eodag.utils import DownloadedCallback, ProgressCallback, Unpack
 
 logger = logging.getLogger("eodag.core")
 
@@ -106,9 +123,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__(
@@ -168,10 +183,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)
@@ -217,7 +237,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"""
@@ -312,7 +331,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(
@@ -328,7 +346,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)
@@ -337,15 +354,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()):
@@ -358,48 +384,86 @@ 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
@@ -421,12 +485,7 @@ class EODataAccessGateway:
 
             # check authentication
             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()
-                    ]
-                )
+                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(
@@ -438,7 +497,7 @@ class EODataAccessGateway:
                         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
@@ -449,11 +508,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
@@ -502,7 +563,6 @@ 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)
@@ -525,12 +585,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:
@@ -572,22 +629,32 @@ class EODataAccessGateway:
     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
@@ -709,13 +776,20 @@ class EODataAccessGateway:
     ) -> 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
         """
-        if provider and provider not in self.providers_config:
+        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}"
             )
@@ -724,7 +798,9 @@ class EODataAccessGateway:
             p
             for p in (
                 [
-                    provider,
+                    p
+                    for p in self.providers_config
+                    if p in grouped_providers + [provider]
                 ]
                 if provider
                 else self.available_providers()
@@ -738,29 +814,28 @@ 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 auth_plugin and callable(
-                        getattr(auth_plugin, "authenticate", None)
+                    if auth := self._plugins_manager.get_auth(
+                        search_plugin.provider,
+                        getattr(search_plugin.config, "api_endpoint", None),
+                        search_plugin.config,
                     ):
-                        try:
-                            kwargs["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
+                        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
@@ -769,7 +844,7 @@ class EODataAccessGateway:
                     **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]]]]
@@ -777,7 +852,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:
@@ -787,7 +861,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 = (
@@ -846,7 +922,7 @@ class EODataAccessGateway:
                             new_product_types.append(new_product_type)
                 if new_product_types:
                     logger.debug(
-                        f"Added product types {str(new_product_types)} for {provider}"
+                        f"Added {len(new_product_types)} product types for {provider}"
                     )
 
             elif provider not in self.providers_config:
@@ -870,12 +946,9 @@ class EODataAccessGateway:
         priority level.
 
         :param product_type: (optional) Only list providers configured for this product_type
-        :type product_type: Optional[str]
         :param by_group: (optional) If set to True, list groups when available instead
                          of providers, mixed with other providers
-        :type by_group: bool
         :returns: the sorted list of the available providers or groups
-        :rtype: List[str]
         """
 
         if product_type:
@@ -909,9 +982,7 @@ class EODataAccessGateway:
 
         :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
@@ -939,9 +1010,7 @@ 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)
@@ -972,31 +1041,18 @@ class EODataAccessGateway:
 
         :param free_text: Whoosh-compatible free text search filter used to search
                         accross all the following parameters
-        :type free_text: Optional[str]
         :param intersect: Join results for each parameter using INTERSECT instead of UNION.
-        :type intersect: bool
         :param instrument: Instrument parameter.
-        :type instrument: Optional[str]
         :param platform: Platform parameter.
-        :type platform: Optional[str]
         :param platformSerialIdentifier: Platform serial identifier parameter.
-        :type platformSerialIdentifier: Optional[str]
         :param processingLevel: Processing level parameter.
-        :type processingLevel: Optional[str]
         :param sensorType: Sensor type parameter.
-        :type sensorType: Optional[str]
         :param keywords: Keywords parameter.
-        :type keywords: Optional[str]
         :param abstract: Abstract parameter.
-        :type abstract: Optional[str]
         :param title: Title parameter.
-        :type title: Optional[str]
         :param missionStartDate: start date for datetime filtering. Not used by free_text
-        :type missionStartDate: Optional[str]
         :param missionEndDate: end date for datetime filtering. Not used by free_text
-        :type missionEndDate: Optional[str]
         :returns: The best match for the given parameters.
-        :rtype: List[str]
         :raises: :class:`~eodag.utils.exceptions.NoMatchingProductType`
         """
         if productType := kwargs.get("productType"):
@@ -1038,20 +1094,28 @@ class EODataAccessGateway:
 
         # 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 (
-                    not missionEndDate
-                    or g.get("missionStartDate")
-                    and rfc3339_str_to_datetime(g["missionStartDate"])
-                    <= rfc3339_str_to_datetime(missionEndDate)
-                )
-                and (
-                    not missionStartDate
-                    or g.get("missionEndDate")
-                    and rfc3339_str_to_datetime(g["missionEndDate"])
-                    >= rfc3339_str_to_datetime(missionStartDate)
+                    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,
+                    )
                 )
             ]
 
@@ -1083,21 +1147,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:
@@ -1107,24 +1166,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 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
         :param count: (optional) Whether to run a query with a count request or not
-        :type count: bool
         :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: A collection of EO products matching the criteria
-        :rtype: :class:`~eodag.api.search_result.SearchResult`
+
+        .. 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
@@ -1154,7 +1211,7 @@ 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()
@@ -1164,17 +1221,19 @@ class EODataAccessGateway:
                 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:
+                search_results.errors = errors
                 return search_results
 
         if i > 1:
             logger.error("No result could be obtained from any available provider")
-        return SearchResult([], 0) if count else SearchResult([])
+        return SearchResult([], 0, errors) if count else SearchResult([], errors=errors)
 
     def search_iter_page(
         self,
@@ -1188,15 +1247,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:
@@ -1206,19 +1262,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
@@ -1253,15 +1305,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
@@ -1390,15 +1438,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:
@@ -1408,19 +1453,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 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.
@@ -1452,7 +1493,7 @@ class EODataAccessGateway:
                 )
                 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,
@@ -1509,22 +1550,18 @@ 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
-        :rtype: :class:`~eodag.api.search_result.SearchResult`
         """
         product_type = kwargs.get("productType", None)
         if product_type is not None:
             try:
                 product_type = self.get_product_type_from_alias(product_type)
             except NoMatchingProductType:
-                logger.warning("product type %s not found", product_type)
+                logger.debug("product type %s not found", product_type)
         get_search_plugins_kwargs = dict(provider=provider, product_type=product_type)
         search_plugins = self._plugins_manager.get_search_plugins(
             **get_search_plugins_kwargs
@@ -1547,7 +1584,7 @@ class EODataAccessGateway:
                 "max_items_per_page", DEFAULT_MAX_ITEMS_PER_PAGE
             )
             kwargs.update(items_per_page=items_per_page)
-            if isinstance(plugin, BuildPostSearchResult):
+            if isinstance(plugin, PostJsonSearch):
                 kwargs.update(
                     items_per_page=items_per_page,
                     _dc_qs=_dc_qs,
@@ -1565,9 +1602,10 @@ class EODataAccessGateway:
                     **kwargs,
                 ):
                     results.data.extend(page_results.data)
-            except Exception:
+            except Exception as e:
                 if kwargs.get("raise_errors"):
                     raise
+                logger.warning(e)
                 continue
 
             # try using crunch to get unique result
@@ -1597,20 +1635,20 @@ class EODataAccessGateway:
         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):
-            auth_plugin = self._plugins_manager.get_auth_plugin(plugin.provider)
-            if auth_plugin and callable(getattr(auth_plugin, "authenticate", None)):
-                try:
-                    kwargs["auth"] = auth_plugin.authenticate()
-                except (AuthenticationError, MisconfiguredError) as e:
-                    logger.warning(f"Could not authenticate on {provider}: {str(e)}")
-            else:
-                logger.warning(
-                    f"Could not authenticate on {provider} using {auth_plugin} plugin"
-                )
+            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})
@@ -1641,25 +1679,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:
@@ -1725,18 +1756,15 @@ 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"
-            )
             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
-                or product_type
-                not in self._plugins_manager.product_type_to_provider_config_map.keys()
-            ):
+            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]
@@ -1759,12 +1787,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(
@@ -1772,11 +1798,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:
@@ -1814,17 +1835,13 @@ class EODataAccessGateway:
         """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
-        :rtype: tuple(:class:`~eodag.api.search_result.SearchResult`, int or None)
         """
+        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
         )
@@ -1842,19 +1859,23 @@ 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: Optional[int] = 0 if count else None
 
+        errors: List[Tuple[str, Exception]] = []
+
         try:
             prep = PreparedSearch(count=count)
-            if need_auth and auth_plugin and can_authenticate:
-                prep.auth = auth_plugin.authenticate()
 
-            prep.auth_plugin = auth_plugin
+            # 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)
 
@@ -1881,6 +1902,7 @@ class EODataAccessGateway:
                     pattern = re.compile(r"[^\w,]+")
                     try:
                         guesses = self.guess_product_type(
+                            intersect=False,
                             **{
                                 k: pattern.sub("", str(v).upper())
                                 for k, v in eo_product.properties.items()
@@ -1894,7 +1916,7 @@ class EODataAccessGateway:
                                     "keywords",
                                 ]
                                 and v is not None
-                            }
+                            },
                         )
                     except NoMatchingProductType:
                         pass
@@ -1907,12 +1929,31 @@ class EODataAccessGateway:
                             eo_product.product_type
                         )
                 except NoMatchingProductType:
-                    logger.warning("product type %s not found", eo_product.product_type)
+                    logger.debug("product type %s not found", eo_product.product_type)
 
                 if eo_product.search_intersection is not None:
                     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)
@@ -1942,13 +1983,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)
-            # keep only the message from exception args
-            if len(e.args) > 1:
-                e.args = (e.args[0],)
             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
@@ -1958,16 +1992,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():
@@ -1983,7 +2015,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
@@ -2014,33 +2045,32 @@ class EODataAccessGateway:
         """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
+                                    :class:`~eodag.utils.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:
@@ -2069,11 +2099,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)
@@ -2084,9 +2111,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))
@@ -2096,19 +2121,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(
@@ -2131,22 +2154,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 max_connections: (optional) Maximum number of connections for concurrent HTTP requests
         :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.
@@ -2211,26 +2226,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`
         """
@@ -2246,22 +2262,18 @@ 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()})
@@ -2273,17 +2285,14 @@ class EODataAccessGateway:
         """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]]
         """
         available_product_types = [
             pt["ID"]
@@ -2309,7 +2318,7 @@ class EODataAccessGateway:
 
         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.provider)
+                auth := self._plugins_manager.get_auth_plugin(plugin)
             ):
                 plugin.auth = auth.authenticate()
             providers_queryables[plugin.provider] = plugin.list_queryables(
@@ -2339,9 +2348,8 @@ class EODataAccessGateway:
         """For each provider, gives its available sortable parameter(s) and its maximum
         number of them if it supports the sorting feature, otherwise gives None.
 
-        :returns: A dictionnary with providers as keys and dictionnary of sortable parameter(s) and
+        :returns: A dictionary with providers as keys and dictionary of sortable parameter(s) and
                   its (their) maximum number as value(s).
-        :rtype: dict
         :raises: :class:`~eodag.utils.exceptions.UnsupportedProvider`
         """
         sortables: Dict[str, Optional[ProviderSortables]] = {}