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

eodag/api/core.py

@@ -66,10 +66,10 @@ from eodag.utils import (
     MockResponse,
     _deprecated,
     copy_deepcopy,
-    deepcopy,
     get_geometry_from_various,
     makedirs,
     obj_md5sum,
+    sort_dict,
     string_to_jsonpath,
     uri_to_path,
 )
@@ -106,9 +106,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__(
@@ -312,7 +310,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 +325,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)
@@ -343,7 +339,6 @@ class EODataAccessGateway:
         an existing one.
 
         :param yaml_conf: YAML formated provider configuration
-        :type yaml_conf: str
         """
         conf_update = yaml.safe_load(yaml_conf)
 
@@ -358,39 +353,6 @@ 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()
@@ -400,6 +362,75 @@ class EODataAccessGateway:
         # 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"):
+            conf_dict[name].pop("search", None)
+            conf_dict[name].pop("download", None)
+            conf_dict[name].pop("auth", None)
+
+        override_config_from_mapping(self.providers_config, conf_dict)
+        provider_config_init(self.providers_config[name], load_stac_provider_config())
+        setattr(self.providers_config[name], "product_types_fetched", False)
+        self._plugins_manager.build_product_type_to_provider_config_map()
+
+        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
@@ -502,7 +533,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 +555,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:
@@ -574,7 +601,6 @@ class EODataAccessGateway:
 
         :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
         """
         if provider is not None and provider not in self.providers_config:
             return
@@ -711,9 +737,7 @@ class EODataAccessGateway:
 
         :param provider: (optional) The name of a provider to fetch. Defaults to all
                          providers (None value).
-        :type provider: str
         :returns: external product types configuration
-        :rtype: dict
         """
         if provider and provider not in self.providers_config:
             raise UnsupportedProvider(
@@ -742,6 +766,11 @@ class EODataAccessGateway:
                 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(
@@ -769,7 +798,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 +806,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:
@@ -870,12 +898,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 +934,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 +962,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 +993,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"):
@@ -1083,21 +1091,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 +1110,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
@@ -1188,15 +1189,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 +1204,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 +1247,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 +1380,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 +1395,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.
@@ -1509,15 +1492,11 @@ class EODataAccessGateway:
         perform the search, if this information is available
 
         :param uid: The uid of the EO product
-        :type uid: str
         :param provider: (optional) The provider on which to search the product.
                          This may be useful for performance reasons when the user
                          knows this product is available on the given provider
-        :type provider: str
         :param kwargs: Search criteria to help finding the right product
-        :type kwargs: Any
         :returns: A search result with one EO product or None at all
-        :rtype: :class:`~eodag.api.search_result.SearchResult`
         """
         product_type = kwargs.get("productType", None)
         if product_type is not None:
@@ -1597,6 +1576,10 @@ 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
@@ -1641,25 +1624,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 +1701,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]
@@ -1814,16 +1787,11 @@ 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)
         """
         max_items_per_page = getattr(search_plugin.config, "pagination", {}).get(
             "max_items_per_page", DEFAULT_MAX_ITEMS_PER_PAGE
@@ -1881,6 +1849,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 +1863,7 @@ class EODataAccessGateway:
                                     "keywords",
                                 ]
                                 and v is not None
-                            }
+                            },
                         )
                     except NoMatchingProductType:
                         pass
@@ -1965,9 +1934,7 @@ class EODataAccessGateway:
         """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 +1950,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 +1980,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
                                     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 +2034,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 +2046,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,9 +2056,7 @@ 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):
@@ -2131,22 +2089,14 @@ class EODataAccessGateway:
         the response content to an API request.
 
         :param filename: A filename containing features encoded as a geojson
-        :type filename: str
         :param recursive: (optional) Browse recursively in child nodes if True
-        :type recursive: bool
         :param max_connections: (optional) Maximum number of connections for HTTP requests
-        :type max_connections: int
         :param provider: (optional) Data provider
-        :type provider: str
         :param productType: (optional) Data product type
-        :type productType: str
         :param timeout: (optional) Timeout in seconds for each internal HTTP request
-        :type timeout: float
         :param kwargs: Parameters that will be stored in the result as
                        search criteria
-        :type kwargs: Any
         :returns: The search results encoded in `filename`
-        :rtype: :class:`~eodag.api.search_result.SearchResult`
 
         .. deprecated:: 2.2.1
            Use the :class:`~eodag.plugins.search.static_stac_search.StaticStacSearch` search plugin instead.
@@ -2211,26 +2161,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`
         """
@@ -2257,11 +2208,8 @@ class EODataAccessGateway:
         """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 +2221,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"]
@@ -2341,7 +2286,6 @@ class EODataAccessGateway:
 
         :returns: A dictionnary with providers as keys and dictionnary 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]] = {}