eodag 3.0.0b1__py3-none-any.whl → 3.0.0b3__py3-none-any.whl

eodag/plugins/download/http.py

@@ -25,6 +25,7 @@ import zipfile
 from datetime import datetime
 from email.message import Message
 from itertools import chain
+from json import JSONDecodeError
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -32,7 +33,6 @@ from typing import (
     Iterator,
     List,
     Optional,
-    Tuple,
     TypedDict,
     Union,
     cast,
@@ -44,6 +44,7 @@ import requests
 from lxml import etree
 from requests import RequestException
 from requests.auth import AuthBase
+from requests.structures import CaseInsensitiveDict
 from stream_zip import ZIP_AUTO, stream_zip
 
 from eodag.api.product.metadata_mapping import (
@@ -97,7 +98,6 @@ class HTTPDownload(Download):
     """HTTPDownload plugin. Handles product download over HTTP protocol
 
     :param provider: provider name
-    :type provider: str
     :param config: Download plugin configuration:
 
         * ``config.base_uri`` (str) - (optional) default endpoint url
@@ -113,15 +113,12 @@ class HTTPDownload(Download):
         * ``config.order_on_response`` (dict) - (optional) edit or add new product properties
         * ``config.order_status`` (:class:`~eodag.config.PluginConfig.OrderStatus`) - (optional) Order status handling
 
-
-    :type config: :class:`~eodag.config.PluginConfig`
-
     """
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
         super(HTTPDownload, self).__init__(provider, config)
 
-    def orderDownload(
+    def order_download(
         self,
         product: EOProduct,
         auth: Optional[AuthBase] = None,
@@ -147,13 +144,9 @@ class HTTPDownload(Download):
             - **orderLink**: order request URL
 
         :param product: The EO product to order
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         :param auth: (optional) authenticated object
-        :type auth: Optional[AuthBase]
         :param kwargs: download additional kwargs
-        :type kwargs: Union[str, bool, dict]
         :returns: the returned json status response
-        :rtype: dict
         """
         product.properties["storageStatus"] = STAGING_STATUS
 
@@ -167,10 +160,15 @@ class HTTPDownload(Download):
         if order_method == "POST":
             # separate url & parameters
             parts = urlparse(str(product.properties["orderLink"]))
-            query_dict = parse_qs(parts.query)
-            if not query_dict and parts.query:
+            query_dict = {}
+            # `parts.query` may be a JSON with query strings as one of values. If `parse_qs` is executed as first step,
+            # the resulting `query_dict` would be erroneous.
+            try:
                 query_dict = geojson.loads(parts.query)
-            order_url = parts._replace(query=None).geturl()
+            except JSONDecodeError:
+                if parts.query:
+                    query_dict = parse_qs(parts.query)
+            order_url = parts._replace(query="").geturl()
             if query_dict:
                 order_kwargs["json"] = query_dict
         else:
@@ -217,11 +215,8 @@ class HTTPDownload(Download):
         """Process order response
 
         :param response: The order response
-        :type response: :class:`~requests.Response`
         :param product: The orderd EO product
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         :returns: the returned json status response
-        :rtype: dict
         """
         on_response_mm = getattr(self.config, "order_on_response", {}).get(
             "metadata_mapping", {}
@@ -251,7 +246,7 @@ class HTTPDownload(Download):
 
         return json_response
 
-    def orderDownloadStatus(
+    def order_download_status(
         self,
         product: EOProduct,
         auth: Optional[AuthBase] = None,
@@ -268,11 +263,8 @@ class HTTPDownload(Download):
             - **orderStatusLink**: order status request URL
 
         :param product: The ordered EO product
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         :param auth: (optional) authenticated object
-        :type auth: Optional[AuthBase]
         :param kwargs: download additional kwargs
-        :type kwargs: Union[str, bool, dict]
         """
 
         status_config = getattr(self.config, "order_status", {})
@@ -325,7 +317,7 @@ class HTTPDownload(Download):
         if status_request_method == "POST":
             # separate url & parameters
             parts = urlparse(str(product.properties["orderStatusLink"]))
-            status_url = parts._replace(query=None).geturl()
+            status_url = parts._replace(query="").geturl()
             query_dict = parse_qs(parts.query)
             if not query_dict and parts.query:
                 query_dict = geojson.loads(parts.query)
@@ -568,12 +560,12 @@ class HTTPDownload(Download):
             )
             progress_callback = ProgressCallback(disable=True)
 
-        outputs_extension = getattr(self.config, "products", {}).get(
+        output_extension = getattr(self.config, "products", {}).get(
             product.product_type, {}
-        ).get("outputs_extension", None) or getattr(
-            self.config, "outputs_extension", ".zip"
+        ).get("output_extension", None) or getattr(
+            self.config, "output_extension", ".zip"
         )
-        kwargs["outputs_extension"] = kwargs.get("outputs_extension", outputs_extension)
+        kwargs["output_extension"] = kwargs.get("output_extension", output_extension)
 
         fs_path, record_filename = self._prepare_download(
             product,
@@ -637,7 +629,7 @@ class HTTPDownload(Download):
         logger.debug("Download recorded in %s", record_filename)
 
         # Check that the downloaded file is really a zip file
-        if not zipfile.is_zipfile(fs_path) and outputs_extension == ".zip":
+        if not zipfile.is_zipfile(fs_path) and output_extension == ".zip":
             logger.warning(
                 "Downloaded product is not a Zip File. Please check its file type before using it"
             )
@@ -658,7 +650,7 @@ class HTTPDownload(Download):
                 if not new_fs_path.endswith(".tar"):
                     new_fs_path += ".tar"
                 shutil.move(fs_path, new_fs_path)
-                kwargs["outputs_extension"] = ".tar"
+                kwargs["output_extension"] = ".tar"
                 product_path = self._finalize(
                     new_fs_path,
                     progress_callback=progress_callback,
@@ -727,13 +719,13 @@ class HTTPDownload(Download):
                     if ext:
                         filename += ext
                 else:
-                    outputs_extension: Optional[str] = (
+                    output_extension: Optional[str] = (
                         getattr(self.config, "products", {})
                         .get(product.product_type, {})
-                        .get("outputs_extension")
+                        .get("output_extension")
                     )
-                    if outputs_extension:
-                        filename += outputs_extension
+                    if output_extension:
+                        filename += output_extension
 
         return filename
 
@@ -751,23 +743,16 @@ class HTTPDownload(Download):
         It contains a generator to streamed download chunks and the response headers.
 
         :param product: The EO product to download
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         :param auth: (optional) authenticated object
-        :type auth: Optional[Union[AuthBase, Dict[str, str]]]
         :param progress_callback: (optional) A progress callback
-        :type progress_callback: :class:`~eodag.utils.ProgressCallback`
         :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)
+        :param kwargs: `output_dir` (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]
         :returns: Dictionnary of :class:`~fastapi.responses.StreamingResponse` keyword-arguments
-        :rtype: dict
         """
         if auth is not None and not isinstance(auth, AuthBase):
             raise MisconfiguredError(f"Incompatible auth plugin: {type(auth)}")
@@ -906,17 +891,13 @@ class HTTPDownload(Download):
         fetches a zip file containing the assets of a given product as a stream
         and returns a generator yielding the chunks of the file
         :param product: product for which the assets should be downloaded
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         :param auth: The configuration of a plugin of type Authentication
-        :type auth: Optional[Union[AuthBase, Dict[str, str]]]
         :param progress_callback: 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`
         :param kwargs: additional arguments
-        :type kwargs: dict
         """
         if progress_callback is None:
             logger.info("Progress bar unavailable, please call product.download()")
@@ -928,13 +909,13 @@ class HTTPDownload(Download):
             and product.properties.get("storageStatus") == OFFLINE_STATUS
             and not product.properties.get("orderStatus")
         ):
-            self.orderDownload(product=product, auth=auth)
+            self.order_download(product=product, auth=auth)
 
         if (
             product.properties.get("orderStatusLink", None)
             and product.properties.get("storageStatus") != ONLINE_STATUS
         ):
-            self.orderDownloadStatus(product=product, auth=auth)
+            self.order_download_status(product=product, auth=auth)
 
         params = kwargs.pop("dl_url_params", None) or getattr(
             self.config, "dl_url_params", {}
@@ -951,7 +932,7 @@ class HTTPDownload(Download):
             query_dict = parse_qs(parts.query)
             if not query_dict and parts.query:
                 query_dict = geojson.loads(parts.query)
-            req_url = parts._replace(query=None).geturl()
+            req_url = parts._replace(query="").geturl()
             req_kwargs: Dict[str, Any] = {"json": query_dict} if query_dict else {}
         else:
             req_url = url
@@ -1004,8 +985,11 @@ class HTTPDownload(Download):
                     "content-disposition"
                 ] = f"attachment; filename={filename}"
                 content_type = product.headers.get("Content-Type")
-                if filename and not content_type:
-                    product.headers["Content-Type"] = guess_file_type(filename)
+                guessed_content_type = (
+                    guess_file_type(filename) if filename and not content_type else None
+                )
+                if guessed_content_type is not None:
+                    product.headers["Content-Type"] = guessed_content_type
 
                 progress_callback.reset(total=stream_size)
                 for chunk in self.stream.iter_content(chunk_size=64 * 1024):
@@ -1020,7 +1004,7 @@ class HTTPDownload(Download):
         progress_callback: Optional[ProgressCallback] = None,
         assets_values: List[Asset] = [],
         **kwargs: Unpack[DownloadConf],
-    ) -> Iterator[Tuple[str, datetime, int, Any, Iterator[Any]]]:
+    ) -> Iterator[Any]:
         if progress_callback is None:
             logger.info("Progress bar unavailable, please call product.download()")
             progress_callback = ProgressCallback(disable=True)
@@ -1074,7 +1058,6 @@ class HTTPDownload(Download):
 
         # loop for assets download
         for asset in assets_values:
-
             if not asset["href"] or asset["href"].startswith("file:"):
                 logger.info(
                     f"Local asset detected. Download skipped for {asset['href']}"
@@ -1194,7 +1177,9 @@ class HTTPDownload(Download):
             # start reading chunks to set asset.rel_path
             first_chunks_tuple = next(chunks_tuples)
             chunks = chain(iter([first_chunks_tuple]), chunks_tuples)
-            chunks_tuples = [(assets_values[0].rel_path, None, None, None, chunks)]
+            chunks_tuples = iter(
+                [(assets_values[0].rel_path, None, None, None, chunks)]
+            )
 
         for chunk_tuple in chunks_tuples:
             asset_path = chunk_tuple[0]
@@ -1291,12 +1276,18 @@ class HTTPDownload(Download):
         for asset in assets_values:
             if asset["href"] and not asset["href"].startswith("file:"):
                 # HEAD request for size & filename
-                asset_headers = requests.head(
-                    asset["href"],
-                    auth=auth,
-                    headers=USER_AGENT,
-                    timeout=timeout,
-                ).headers
+                try:
+                    asset_headers = requests.head(
+                        asset["href"],
+                        auth=auth,
+                        params=params,
+                        headers=USER_AGENT,
+                        timeout=timeout,
+                        verify=ssl_verify,
+                    ).headers
+                except RequestException as e:
+                    logger.debug(f"HEAD request failed: {str(e)}")
+                    asset_headers = CaseInsensitiveDict()
 
                 if not getattr(asset, "size", 0):
                     # size from HEAD header / Content-length

eodag/plugins/download/s3rest.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 import logging
 import os
 import os.path
-from typing import TYPE_CHECKING, Dict, Optional, Union
+from typing import TYPE_CHECKING, Dict, List, Optional, Union
 from xml.dom import minidom
 from xml.parsers.expat import ExpatError
 
@@ -68,7 +68,6 @@ class S3RestDownload(Download):
     Re-use AwsDownload bucket some handling methods
 
     :param provider: provider name
-    :type provider: str
     :param config: Download plugin configuration:
 
         * ``config.base_uri`` (str) - default endpoint url
@@ -80,8 +79,6 @@ class S3RestDownload(Download):
         * ``config.order_headers`` (dict) - (optional) order request headers
         * ``config.order_on_response`` (dict) - (optional) edit or add new product properties
         * ``config.order_status`` (:class:`~eodag.config.PluginConfig.OrderStatus`) - Order status handling
-
-    :type config: :class:`~eodag.config.PluginConfig`
     """
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
@@ -100,22 +97,17 @@ class S3RestDownload(Download):
         """Download method for S3 REST API.
 
         :param product: The EO product to download
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         :param auth: (optional) authenticated object
-        :type auth: Optional[Union[AuthBase, Dict[str, str]]]
         :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 kwargs: `outputs_prefix` (str), `extract` (bool), `delete_archive` (bool)
+        :param kwargs: `output_dir` (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]
         :returns: The absolute path to the downloaded product in the local filesystem
-        :rtype: str
         """
         if auth is not None and not isinstance(auth, AuthBase):
             raise MisconfiguredError(f"Incompatible auth plugin: {type(auth)}")
@@ -133,7 +125,7 @@ class S3RestDownload(Download):
             and "storageStatus" in product.properties
             and product.properties["storageStatus"] != ONLINE_STATUS
         ):
-            self.http_download_plugin.orderDownload(product=product, auth=auth)
+            self.http_download_plugin.order_download(product=product, auth=auth)
 
         @self._download_retry(product, wait, timeout)
         def download_request(
@@ -145,7 +137,7 @@ class S3RestDownload(Download):
         ):
             # check order status
             if product.properties.get("orderStatusLink", None):
-                self.http_download_plugin.orderDownloadStatus(
+                self.http_download_plugin.order_download_status(
                     product=product, auth=auth
                 )
 
@@ -153,6 +145,8 @@ class S3RestDownload(Download):
             bucket_name, prefix = get_bucket_name_and_prefix(
                 url=product.location, bucket_path_level=self.config.bucket_path_level
             )
+            if prefix is None:
+                raise DownloadError(f"Could not extract prefix from {product.location}")
 
             if (
                 bucket_name is None
@@ -243,14 +237,12 @@ class S3RestDownload(Download):
                 logger.warning("Could not load any content from %s", nodes_list_url)
 
             # destination product path
-            outputs_prefix = (
-                kwargs.pop("outputs_prefix", None) or self.config.outputs_prefix
-            )
-            abs_outputs_prefix = os.path.abspath(outputs_prefix)
-            product_local_path = os.path.join(abs_outputs_prefix, prefix.split("/")[-1])
+            output_dir = kwargs.pop("output_dir", None) or self.config.output_dir
+            abs_output_dir = os.path.abspath(output_dir)
+            product_local_path = os.path.join(abs_output_dir, prefix.split("/")[-1])
 
             # .downloaded cache record directory
-            download_records_dir = os.path.join(abs_outputs_prefix, ".downloaded")
+            download_records_dir = os.path.join(abs_output_dir, ".downloaded")
             try:
                 os.makedirs(download_records_dir)
             except OSError as exc:
@@ -278,18 +270,18 @@ class S3RestDownload(Download):
                 os.remove(record_filename)
 
             # total size for progress_callback
-            total_size = sum(
-                [
-                    int(node.firstChild.nodeValue)
-                    for node in xmldoc.getElementsByTagName("Size")
-                ]
-            )
+            size_list: List[int] = [
+                int(node.firstChild.nodeValue)  # type: ignore[attr-defined]
+                for node in xmldoc.getElementsByTagName("Size")
+                if node.firstChild is not None
+            ]
+            total_size = sum(size_list)
             progress_callback.reset(total=total_size)
 
             # download each node key
             for node_xml in nodes_xml_list:
                 node_key = unquote(
-                    node_xml.getElementsByTagName("Key")[0].firstChild.nodeValue
+                    node_xml.getElementsByTagName("Key")[0].firstChild.nodeValue  # type: ignore[union-attr]
                 )
                 # As "Key", "Size" and "ETag" (md5 hash) can also be retrieved from node_xml
                 node_url = urljoin(bucket_url.strip("/") + "/", node_key.strip("/"))

eodag/plugins/manager.py

@@ -68,7 +68,6 @@ class PluginManager:
 
     :param providers_config: The configuration with all information about the providers
                              supported by ``eodag``
-    :type providers_config: dict[str, :class:`~eodag.config.ProviderConfig`]
     """
 
     supported_topics = {"search", "download", "crunch", "auth", "api"}
@@ -111,7 +110,11 @@ class PluginManager:
                         "Check that the plugin module (%s) is importable",
                         entry_point.module_name,
                     )
-                if entry_point.dist and entry_point.dist.key != "eodag":
+                if (
+                    entry_point.dist
+                    and entry_point.dist.key != "eodag"
+                    and entry_point.dist.location is not None
+                ):
                     # use plugin providers if any
                     plugin_providers_config_path = [
                         str(x)
@@ -172,13 +175,10 @@ class PluginManager:
 
         :param product_type: (optional) The product type that the constructed plugins
                              must support
-        :type product_type: str
         :param provider: (optional) The provider or the provider group on which to get
             the search plugins
-        :type provider: str
         :returns: All the plugins supporting the product type, one by one (a generator
                   object)
-        :rtype: types.GeneratorType(:class:`~eodag.plugins.search.Search`
             or :class:`~eodag.plugins.download.Api`)
         :raises: :class:`~eodag.utils.exceptions.UnsupportedProvider`
         """
@@ -230,9 +230,7 @@ class PluginManager:
         product.
 
         :param product: The product to get a download plugin for
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         :returns: The download plugin capable of downloading the product
-        :rtype: :class:`~eodag.plugins.download.Download` or :class:`~eodag.plugins.download.Api`
         """
         plugin_conf = self.providers_config[product.provider]
         if download := getattr(plugin_conf, "download", None):
@@ -242,6 +240,7 @@ class PluginManager:
                 self._build_plugin(product.provider, download, Download),
             )
         elif api := getattr(plugin_conf, "api", None):
+            plugin_conf.api.products = plugin_conf.products
             plugin_conf.api.priority = plugin_conf.priority
             plugin = cast(Api, self._build_plugin(product.provider, api, Api))
         else:
@@ -255,9 +254,7 @@ class PluginManager:
         provider
 
         :param provider: The provider for which to get the authentication plugin
-        :type provider: str
         :returns: The Authentication plugin for the provider
-        :rtype: :class:`~eodag.plugins.authentication.Authentication`
         """
         plugin_conf = self.providers_config[provider]
         auth: Optional[PluginConfig] = getattr(plugin_conf, "auth", None)
@@ -278,11 +275,8 @@ class PluginManager:
         it with the `options`
 
         :param name: The name of the Crunch plugin to instantiate
-        :type name: str
         :param options: The configuration parameters of the cruncher
-        :type options: dict
         :returns: The cruncher named `name`
-        :rtype: :class:`~eodag.plugins.crunch.Crunch`
         """
         klass = Crunch.get_plugin_by_class_name(name)
         return klass(options)
@@ -296,9 +290,7 @@ class PluginManager:
         """Set the priority of the given provider
 
         :param provider: The provider which is assigned the priority
-        :type provider: str
         :param priority: The priority to assign to the provider
-        :type priority: int
         """
         # Update the priority in the configurations so that it is taken into account
         # when a plugin of this provider is latterly built
@@ -326,13 +318,9 @@ class PluginManager:
         registered as the given provider
 
         :param provider: The provider for which to build the plugin
-        :type provider: str
         :param plugin_conf: The configuration of the plugin to be built
-        :type plugin_conf: :class:`~eodag.config.PluginConfig`
         :param topic_class: The type of plugin to build
-        :type topic_class: :class:`~eodag.plugin.base.PluginTopic`
         :returns: The built plugin
-        :rtype: :class:`~eodag.plugin.search.Search` or
                 :class:`~eodag.plugin.download.Download` or
                 :class:`~eodag.plugin.authentication.Authentication` or
                 :class:`~eodag.plugin.crunch.Crunch`

eodag/plugins/search/__init__.py

@@ -36,8 +36,8 @@ class PreparedSearch:
     """An object collecting needed information for search."""
 
     product_type: Optional[str] = None
-    page: int = DEFAULT_PAGE
-    items_per_page: int = DEFAULT_ITEMS_PER_PAGE
+    page: Optional[int] = DEFAULT_PAGE
+    items_per_page: Optional[int] = DEFAULT_ITEMS_PER_PAGE
     auth: Optional[Union[AuthBase, Dict[str, str]]] = None
     auth_plugin: Optional[Authentication] = None
     count: bool = True
@@ -45,10 +45,10 @@ class PreparedSearch:
     info_message: Optional[str] = None
     exception_message: Optional[str] = None
 
-    need_count: bool = field(init=False)
-    query_params: Dict[str, Any] = field(init=False)
-    query_string: str = field(init=False)
-    search_urls: List[str] = field(init=False)
-    product_type_def_params: Dict[str, Any] = field(init=False)
-    total_items_nb: int = field(init=False)
-    sort_by_qs: str = field(init=False)
+    need_count: bool = field(init=False, repr=False)
+    query_params: Dict[str, Any] = field(init=False, repr=False)
+    query_string: str = field(init=False, repr=False)
+    search_urls: List[str] = field(init=False, repr=False)
+    product_type_def_params: Dict[str, Any] = field(init=False, repr=False)
+    total_items_nb: int = field(init=False, repr=False)
+    sort_by_qs: str = field(init=False, repr=False)

eodag/plugins/search/base.py

@@ -59,9 +59,7 @@ class Search(PluginTopic):
     """Base Search Plugin.
 
     :param provider: An EODAG provider name
-    :type provider: str
     :param config: An EODAG plugin configuration
-    :type config: :class:`~eodag.config.PluginConfig`
     """
 
     auth: Union[AuthBase, Dict[str, str]]
@@ -114,9 +112,7 @@ class Search(PluginTopic):
 
         :param kwargs: additional filters for queryables (`productType` and other search
                        arguments)
-        :type kwargs: Any
         :returns: fetched queryable parameters dict
-        :rtype: Optional[Dict[str, Annotated[Any, FieldInfo]]]
         """
         raise NotImplementedError(
             f"discover_queryables is not implemeted for plugin {self.__class__.__name__}"
@@ -129,9 +125,7 @@ class Search(PluginTopic):
         Return given product type default settings as queryables
 
         :param product_type: given product type
-        :type product_type: str
         :returns: queryable parameters dict
-        :rtype: Dict[str, Annotated[Any, FieldInfo]]
         """
         defaults = deepcopy(self.config.products.get(product_type, {}))
         defaults.pop("metadata_mapping", None)
@@ -147,9 +141,7 @@ class Search(PluginTopic):
         """Get the provider product type from eodag product type
 
         :param product_type: eodag product type
-        :type product_type: str
         :returns: provider product type
-        :rtype: str
         """
         if product_type is None:
             return None
@@ -164,9 +156,7 @@ class Search(PluginTopic):
         """Get the provider product type definition parameters and specific settings
 
         :param product_type: the desired product type
-        :type product_type: str
         :returns: The product type definition parameters
-        :rtype: dict
         """
         if product_type in self.config.products.keys():
             logger.debug(
@@ -195,9 +185,7 @@ class Search(PluginTopic):
         """Get the plugin metadata mapping configuration (product type specific if exists)
 
         :param product_type: the desired product type
-        :type product_type: str
         :returns: The product type specific metadata-mapping
-        :rtype: dict
         """
         if product_type:
             return self.config.products.get(product_type, {}).get(
@@ -206,16 +194,14 @@ class Search(PluginTopic):
         return self.config.metadata_mapping
 
     def get_sort_by_arg(self, kwargs: Dict[str, Any]) -> Optional[SortByList]:
-        """Extract the "sortBy" argument from the kwargs or the provider default sort configuration
+        """Extract the "sort_by" argument from the kwargs or the provider default sort configuration
 
         :param kwargs: Search arguments
-        :type kwargs: Dict[str, Any]
-        :returns: The "sortBy" argument from the kwargs or the provider default sort configuration
-        :rtype: :class:`~eodag.types.search_args.SortByList`
+        :returns: The "sort_by" argument from the kwargs or the provider default sort configuration
         """
-        # remove "sortBy" from search args if exists because it is not part of metadata mapping,
+        # remove "sort_by" from search args if exists because it is not part of metadata mapping,
         # it will complete the query string or body once metadata mapping will be done
-        sort_by_arg_tmp = kwargs.pop("sortBy", None)
+        sort_by_arg_tmp = kwargs.pop("sort_by", None)
         sort_by_arg = sort_by_arg_tmp or getattr(self.config, "sort", {}).get(
             "sort_by_default", None
         )
@@ -230,12 +216,10 @@ class Search(PluginTopic):
         self, sort_by_arg: SortByList
     ) -> Tuple[str, Dict[str, List[Dict[str, str]]]]:
         """Build the sorting part of the query string or body by transforming
-        the "sortBy" argument into a provider-specific string or dictionnary
+        the "sort_by" argument into a provider-specific string or dictionnary
 
-        :param sort_by_arg: the "sortBy" argument in EODAG format
-        :type sort_by_arg: :class:`~eodag.types.search_args.SortByList`
-        :returns: The "sortBy" argument in provider-specific format
-        :rtype: Union[str, Dict[str, List[Dict[str, str]]]]
+        :param sort_by_arg: the "sort_by" argument in EODAG format
+        :returns: The "sort_by" argument in provider-specific format
         """
         if not hasattr(self.config, "sort"):
             raise ValidationError(f"{self.provider} does not support sorting feature")
@@ -331,13 +315,10 @@ class Search(PluginTopic):
         Get queryables
 
         :param filters: Additional filters for queryables.
-        :type filters: Dict[str, Any]
         :param product_type: (optional) The product type.
-        :type product_type: Optional[str]
 
         :return: A dictionary containing the queryable properties, associating parameters to their
                 annotated type.
-        :rtype: Dict[str, Annotated[Any, FieldInfo]]
         """
         default_values: Dict[str, Any] = deepcopy(
             getattr(self.config, "products", {}).get(product_type, {})