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

eodag/plugins/crunch/filter_property.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 
 import logging
 import operator
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Any, List
 
 from eodag.plugins.crunch.base import Crunch
 
@@ -38,23 +38,17 @@ class FilterProperty(Crunch):
 
                    - `property=value` : property key from product.properties, associated to its filter value
                    - `operator` : (optional) Operator used for filtering (one of `lt,le,eq,ne,ge,gt`). Default is `eq`
-
-    :type config: dict
     """
 
-    config: Dict[str, Union[str, Optional[str]]]
-
     def proceed(
         self, products: List[EOProduct], **search_params: Any
     ) -> List[EOProduct]:
         """Execute crunch: Filter products, retaining only those that match property filtering
 
         :param products: A list of products resulting from a search
-        :type products: list(:class:`~eodag.api.product._product.EOProduct`)
         :returns: The filtered products
-        :rtype: list(:class:`~eodag.api.product._product.EOProduct`)
         """
-        operator_name = self.config.pop("operator", "eq") or "eq"
+        operator_name = self.config.__dict__.pop("operator", "eq") or "eq"
         try:
             operator_method = getattr(operator, operator_name)
         except AttributeError:
@@ -64,12 +58,12 @@ class FilterProperty(Crunch):
             )
             return products
 
-        if len(self.config.keys()) != 1:
+        if len(self.config.__dict__.keys()) != 1:
             logger.warning("One property is needed for filtering, filtering disabled.")
             return products
 
-        property_key = next(iter(self.config))
-        property_value = self.config.get(property_key, None)
+        property_key = next(iter(self.config.__dict__))
+        property_value = self.config.__dict__.get(property_key, None)
 
         logger.debug(
             "Start filtering for products matching operator.%s(product.properties['%s'], %s)",

eodag/plugins/download/aws.py

@@ -34,6 +34,7 @@ from typing import (
     Optional,
     Set,
     Tuple,
+    TypedDict,
     Union,
     cast,
 )
@@ -213,7 +214,6 @@ class AwsDownload(Download):
     """Download on AWS using S3 protocol.
 
     :param provider: provider name
-    :type provider: str
     :param config: Download plugin configuration:
 
         * ``config.base_uri`` (str) - s3 endpoint url
@@ -222,14 +222,12 @@ class AwsDownload(Download):
         * ``config.flatten_top_dirs`` (bool) - (optional) flatten directory structure
         * ``config.products`` (dict) - (optional) product_type specific configuration
         * ``config.ignore_assets`` (bool) - (optional) ignore assets and download using downloadLink
-
-    :type config: :class:`~eodag.config.PluginConfig`
     """
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
         super(AwsDownload, self).__init__(provider, config)
         self.requester_pays = getattr(self.config, "requester_pays", False)
-        self.s3_session = None
+        self.s3_session: Optional[boto3.session.Session] = None
 
     def download(
         self,
@@ -246,25 +244,20 @@ class AwsDownload(Download):
         SAFE-build is configured for a given provider and product type.
         If the product title is configured to be updated during download and
         SAFE-formatted, its destination path will be:
-        `{outputs_prefix}/{title}`
+        `{output_dir}/{title}`
 
         :param product: The EO product to download
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         :param auth: (optional) authenticated object
-        :type auth: 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 None:
             auth = {}
@@ -404,13 +397,9 @@ class AwsDownload(Download):
         - get file path
         - create directories
         :param product: product to be downloaded
-        :type product: EOProduct
         :param progress_callback: progress callback to be used
-        :type progress_callback: ProgressCallback
         :param kwargs: additional arguments
-        :type kwargs: Any
         :return: local path and file name
-        :rtype: Tuple[str, Optional[str]]
         """
         product_local_path, record_filename = self._prepare_download(
             product, progress_callback=progress_callback, **kwargs
@@ -432,9 +421,7 @@ class AwsDownload(Download):
         """
         updates the product properties with fetch metadata if safe build is enabled
         :param build_safe: if safe build is enabled
-        :type build_safe: bool
         :param product: product to be updated
-        :type product: EOProduct
         """
         product_conf = getattr(self.config, "products", {}).get(
             product.product_type, {}
@@ -480,13 +467,9 @@ class AwsDownload(Download):
         """
         retrieves the bucket names and path prefixes for the assets
         :param product: product for which the assets shall be downloaded
-        :type product: EOProduct
         :param asset_filter: text for which the assets should be filtered
-        :type asset_filter: str
         :param ignore_assets: if product instead of individual assets should be used
-        :type ignore_assets: bool
         :return: tuples of bucket names and prefixes
-        :rtype: List[Tuple[str, Optional[str]]]
         """
         # if assets are defined, use them instead of scanning product.location
         if len(product.assets) > 0 and not ignore_assets:
@@ -528,11 +511,8 @@ class AwsDownload(Download):
         authenticates with s3 and retrieves the available objects
         raises an error when authentication is not possible
         :param bucket_names_and_prefixes: list of bucket names and corresponding path prefixes
-        :type bucket_names_and_prefixes: List[Tuple[str, Optional[str]]]
         :param auth: authentication information
-        :type auth: Dict[str, str]
         :return: authenticated objects per bucket, list of available objects
-        :rtype: Tuple[Dict[str, Any], ResourceCollection[Any]]
         """
         if not isinstance(auth, (dict, type(None))):
             raise AuthenticationError(
@@ -602,17 +582,11 @@ class AwsDownload(Download):
         """
         retrieve unique product chunks based on authenticated objects and asset filters
         :param bucket_names_and_prefixes: list of bucket names and corresponding path prefixes
-        :type bucket_names_and_prefixes: List[Tuple[str, Optional[str]]]
         :param authenticated_objects: available objects per bucket
-        :type authenticated_objects: Dict[str, Any]
         :param asset_filter: text for which assets should be filtered
-        :type asset_filter: str
         :param ignore_assets: if product instead of individual assets should be used
-        :type ignore_assets: bool
         :param product: product that shall be downloaded
-        :type product: EOProduct
         :return: set of product chunks that can be downloaded
-        :rtype: Set[Any]
         """
         product_chunks: List[Any] = []
         for bucket_name, prefix in bucket_names_and_prefixes:
@@ -666,23 +640,16 @@ class AwsDownload(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) The configuration of a plugin of type Authentication
-        :type auth: :class:`~eodag.config.PluginConfig`
         :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 progress_callback is None:
             logger.info(
@@ -773,7 +740,7 @@ class AwsDownload(Download):
         build_safe: bool,
         progress_callback: ProgressCallback,
         assets_values: List[Dict[str, Any]],
-    ) -> Iterator[Tuple[str, datetime, int, Any, Iterator[Any]]]:
+    ) -> Iterator[Any]:
         """Yield product data chunks"""
 
         chunk_size = 4096 * 1024
@@ -861,13 +828,9 @@ class AwsDownload(Download):
         """Get rasterio environment variables needed for data access authentication.
 
         :param bucket_name: Bucket containg objects
-        :type bucket_name: str
         :param prefix: Prefix used to try auth
-        :type prefix: str
         :param auth_dict: Dictionnary containing authentication keys
-        :type auth_dict: dict
         :returns: The rasterio environement variables
-        :rtype: dict
         """
         if self.s3_session is not None:
             if self.requester_pays:
@@ -892,14 +855,10 @@ class AwsDownload(Download):
         Also expose ``s3_session`` as class variable if available.
 
         :param bucket_name: Bucket containg objects
-        :type bucket_name: str
         :param prefix: Prefix used to filter objects on auth try
                        (not used to filter returned objects)
-        :type prefix: str
         :param auth_dict: Dictionnary containing authentication keys
-        :type auth_dict: dict
         :returns: The boto3 authenticated objects
-        :rtype: :class:`~boto3.resources.collection.s3.Bucket.objectsCollection`
         """
         auth_methods: List[
             Callable[[str, str, Dict[str, str]], Optional[ResourceCollection]]
@@ -941,15 +900,15 @@ class AwsDownload(Download):
     ) -> Optional[ResourceCollection]:
         """Auth strategy using no-sign-request"""
 
-        s3_resource = boto3.resource(  # type: ignore
+        s3_resource = boto3.resource(
             service_name="s3", endpoint_url=getattr(self.config, "base_uri", None)
         )
-        s3_resource.meta.client.meta.events.register(  # type: ignore
+        s3_resource.meta.client.meta.events.register(
             "choose-signer.s3.*", disable_signing
         )
-        objects = s3_resource.Bucket(bucket_name).objects  # type: ignore
-        list(objects.filter(Prefix=prefix).limit(1))  # type: ignore
-        return objects  # type: ignore
+        objects = s3_resource.Bucket(bucket_name).objects
+        list(objects.filter(Prefix=prefix).limit(1))
+        return objects
 
     def _get_authenticated_objects_from_auth_profile(
         self, bucket_name: str, prefix: str, auth_dict: Dict[str, str]
@@ -957,20 +916,20 @@ class AwsDownload(Download):
         """Auth strategy using RequestPayer=requester and ``aws_profile`` from provided credentials"""
 
         if "profile_name" in auth_dict.keys():
-            s3_session = boto3.session.Session(profile_name=auth_dict["profile_name"])  # type: ignore
-            s3_resource = s3_session.resource(  # type: ignore
+            s3_session = boto3.session.Session(profile_name=auth_dict["profile_name"])
+            s3_resource = s3_session.resource(
                 service_name="s3",
                 endpoint_url=getattr(self.config, "base_uri", None),
             )
             if self.requester_pays:
-                objects = s3_resource.Bucket(bucket_name).objects.filter(  # type: ignore
+                objects = s3_resource.Bucket(bucket_name).objects.filter(
                     RequestPayer="requester"
                 )
             else:
-                objects = s3_resource.Bucket(bucket_name).objects  # type: ignore
-            list(objects.filter(Prefix=prefix).limit(1))  # type: ignore
-            self.s3_session = s3_session  # type: ignore
-            return objects  # type: ignore
+                objects = s3_resource.Bucket(bucket_name).objects
+            list(objects.filter(Prefix=prefix).limit(1))
+            self.s3_session = s3_session
+            return objects
         else:
             return None
 
@@ -981,23 +940,35 @@ class AwsDownload(Download):
         from provided credentials"""
 
         if all(k in auth_dict for k in ("aws_access_key_id", "aws_secret_access_key")):
-            s3_session = boto3.session.Session(  # type: ignore
-                aws_access_key_id=auth_dict["aws_access_key_id"],
-                aws_secret_access_key=auth_dict["aws_secret_access_key"],
+            S3SessionKwargs = TypedDict(
+                "S3SessionKwargs",
+                {
+                    "aws_access_key_id": str,
+                    "aws_secret_access_key": str,
+                    "aws_session_token": str,
+                },
+                total=False,
             )
-            s3_resource = s3_session.resource(  # type: ignore
+            s3_session_kwargs: S3SessionKwargs = {
+                "aws_access_key_id": auth_dict["aws_access_key_id"],
+                "aws_secret_access_key": auth_dict["aws_secret_access_key"],
+            }
+            if auth_dict.get("aws_session_token"):
+                s3_session_kwargs["aws_session_token"] = auth_dict["aws_session_token"]
+            s3_session = boto3.session.Session(**s3_session_kwargs)
+            s3_resource = s3_session.resource(
                 service_name="s3",
                 endpoint_url=getattr(self.config, "base_uri", None),
             )
             if self.requester_pays:
-                objects = s3_resource.Bucket(bucket_name).objects.filter(  # type: ignore
+                objects = s3_resource.Bucket(bucket_name).objects.filter(
                     RequestPayer="requester"
                 )
             else:
-                objects = s3_resource.Bucket(bucket_name).objects  # type: ignore
-            list(objects.filter(Prefix=prefix).limit(1))  # type: ignore
-            self.s3_session = s3_session  # type: ignore
-            return objects  # type: ignore
+                objects = s3_resource.Bucket(bucket_name).objects
+            list(objects.filter(Prefix=prefix).limit(1))
+            self.s3_session = s3_session
+            return objects
         else:
             return None
 
@@ -1006,19 +977,19 @@ class AwsDownload(Download):
     ) -> Optional[ResourceCollection]:
         """Auth strategy using RequestPayer=requester and current environment"""
 
-        s3_session = boto3.session.Session()  # type: ignore
-        s3_resource = s3_session.resource(  # type: ignore
+        s3_session = boto3.session.Session()
+        s3_resource = s3_session.resource(
             service_name="s3", endpoint_url=getattr(self.config, "base_uri", None)
         )
         if self.requester_pays:
-            objects = s3_resource.Bucket(bucket_name).objects.filter(  # type: ignore
+            objects = s3_resource.Bucket(bucket_name).objects.filter(
                 RequestPayer="requester"
             )
         else:
-            objects = s3_resource.Bucket(bucket_name).objects  # type: ignore
-        list(objects.filter(Prefix=prefix).limit(1))  # type: ignore
-        self.s3_session = s3_session  # type: ignore
-        return objects  # type: ignore
+            objects = s3_resource.Bucket(bucket_name).objects
+        list(objects.filter(Prefix=prefix).limit(1))
+        self.s3_session = s3_session
+        return objects
 
     def get_product_bucket_name_and_prefix(
         self, product: EOProduct, url: Optional[str] = None
@@ -1026,11 +997,8 @@ class AwsDownload(Download):
         """Extract bucket name and prefix from product URL
 
         :param product: The EO product to download
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         :param url: (optional) URL to use as product.location
-        :type url: str
         :returns: bucket_name and prefix as str
-        :rtype: tuple
         """
         if url is None:
             url = product.location

eodag/plugins/download/base.py

@@ -79,17 +79,17 @@ class Download(PluginTopic):
 
     They must:
 
-    - download data in the ``outputs_prefix`` folder defined in the plugin's
+    - download data in the ``output_dir`` folder defined in the plugin's
       configuration or passed through kwargs
     - extract products from their archive (if relevant) if ``extract`` is set to True
       (True by default)
-    - save a product in an archive/directory (in ``outputs_prefix``) whose name must be
+    - save a product in an archive/directory (in ``output_dir``) whose name must be
       the product's ``title`` property
     - update the product's ``location`` attribute once its data is downloaded (and
       eventually after it's extracted) to the product's location given as a file URI
       (e.g. 'file:///tmp/product_folder' on Linux or
       'file:///C:/Users/username/AppData/LOcal/Temp' on Windows)
-    - save a *record* file in the directory ``outputs_prefix/.downloaded`` whose name
+    - save a *record* file in the directory ``output_dir/.downloaded`` whose name
       is built on the MD5 hash of the product's ``product_type`` and ``properties['id']``
       attributes (``hashlib.md5((product.product_type+"-"+product.properties['id']).encode("utf-8")).hexdigest()``)
       and whose content is the product's ``remote_location`` attribute itself.
@@ -100,9 +100,7 @@ class Download(PluginTopic):
       (it certainly indicates that the download didn't complete)
 
     :param provider: An eodag providers configuration dictionary
-    :type provider: dict
     :param config: Path to the user configuration file
-    :type config: str
     """
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
@@ -122,25 +120,18 @@ class Download(PluginTopic):
         Base download method. Not available, it must be defined for each plugin.
 
         :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: The absolute path to the downloaded product in the local filesystem
             (e.g. '/tmp/product.zip' on Linux or
             'C:\\Users\\username\\AppData\\Local\\Temp\\product.zip' on Windows)
-        :rtype: str
         """
         raise NotImplementedError(
             "A Download plugin must implement a method named download"
@@ -159,23 +150,16 @@ class Download(PluginTopic):
         Base _stream_download_dict method. Not available, it must be defined for each plugin.
 
         :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
         """
         raise NotImplementedError(
             "Download streaming must be implemented using a method named _stream_download_dict"
@@ -190,11 +174,8 @@ class Download(PluginTopic):
         """Check if file has already been downloaded, and prepare product download
 
         :param product: The EO product to download
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         :param progress_callback: (optional) A progress callback
-        :type progress_callback: :class:`~eodag.utils.ProgressCallback` or None
         :returns: fs_path, record_filename
-        :rtype: Tuple[Optional[str], Optional[str]]
         """
         if product.location != product.remote_location:
             fs_path = uri_to_path(product.location)
@@ -216,18 +197,18 @@ class Download(PluginTopic):
             f"Download url: {url}",
         )
 
-        outputs_prefix = (
-            kwargs.pop("outputs_prefix", None)
-            or getattr(self.config, "outputs_prefix", tempfile.gettempdir())
+        output_dir = (
+            kwargs.pop("output_dir", None)
+            or getattr(self.config, "output_dir", tempfile.gettempdir())
             or tempfile.gettempdir()
         )
-        outputs_extension = kwargs.get("outputs_extension", None) or getattr(
-            self.config, "outputs_extension", ".zip"
+        output_extension = kwargs.get("output_extension", None) or getattr(
+            self.config, "output_extension", ".zip"
         )
 
         # Strong asumption made here: all products downloaded will be zip files
         # If they are not, the '.zip' extension will be removed when they are downloaded and returned as is
-        prefix = os.path.abspath(outputs_prefix)
+        prefix = os.path.abspath(output_dir)
         sanitized_title = sanitize(product.properties["title"])
         if sanitized_title == product.properties["title"]:
             collision_avoidance_suffix = ""
@@ -235,10 +216,10 @@ class Download(PluginTopic):
             collision_avoidance_suffix = "-" + sanitize(product.properties["id"])
         fs_path = os.path.join(
             prefix,
-            f"{sanitize(product.properties['title'])}{collision_avoidance_suffix}{outputs_extension}",
+            f"{sanitize(product.properties['title'])}{collision_avoidance_suffix}{output_extension}",
         )
         fs_dir_path = (
-            fs_path.replace(outputs_extension, "") if outputs_extension else fs_path
+            fs_path.replace(output_extension, "") if output_extension else fs_path
         )
         download_records_dir = os.path.join(prefix, ".downloaded")
         try:
@@ -292,9 +273,7 @@ class Download(PluginTopic):
         (``hashlib.md5((product.product_type+"-"+product.properties['id']).encode("utf-8")).hexdigest()``)
 
         :param product: The product to calculate the record hash
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         :returns: The MD5 hash
-        :rtype: str
         """
         # In some unit tests, `product.product_type` is `None` and `product.properties["id"]` is `ìnt`
         product_hash = str(product.product_type) + "-" + str(product.properties["id"])
@@ -309,9 +288,7 @@ class Download(PluginTopic):
         WARNING: A strong assumption is made here: there is only one subdirectory per level
 
         :param product_path: The path to the extracted product
-        :type product_path: str
         :returns: The path to the extracted product with the right depth
-        :rtype: str
         """
         archive_depth = getattr(self.config, "archive_depth", 1)
         count = 1
@@ -329,11 +306,8 @@ class Download(PluginTopic):
         """Finalize the download process.
 
         :param fs_path: The path to the local zip archive downloaded or already present
-        :type fs_path: str
         :param progress_callback: (optional) A progress callback
-        :type progress_callback: :class:`~eodag.utils.ProgressCallback` or None
         :returns: The absolute path to the product
-        :rtype: str
         """
         # progress bar init
         if progress_callback is None:
@@ -365,11 +339,11 @@ class Download(PluginTopic):
             if delete_archive is not None
             else getattr(self.config, "delete_archive", True)
         )
-        outputs_extension = kwargs.pop("outputs_extension", ".zip")
+        output_extension = kwargs.pop("output_extension", ".zip")
 
         product_path = (
-            fs_path[: fs_path.index(outputs_extension)]
-            if outputs_extension in fs_path
+            fs_path[: fs_path.index(output_extension)]
+            if output_extension in fs_path
             else fs_path
         )
         product_path_exists = os.path.exists(product_path)
@@ -396,9 +370,7 @@ class Download(PluginTopic):
             )
             progress_callback(1, total=1)
             return product_path
-        outputs_prefix = (
-            kwargs.pop("outputs_prefix", None) or self.config.outputs_prefix
-        )
+        output_dir = kwargs.pop("output_dir", None) or self.config.output_dir
 
         if not os.path.exists(product_path):
             logger.info("Extraction activated")
@@ -407,9 +379,9 @@ class Download(PluginTopic):
             )
             progress_callback.refresh()
 
-            outputs_dir = os.path.join(outputs_prefix, product_path)
+            product_dir = os.path.join(output_dir, product_path)
             tmp_dir = tempfile.TemporaryDirectory()
-            extraction_dir = os.path.join(tmp_dir.name, os.path.basename(outputs_dir))
+            extraction_dir = os.path.join(tmp_dir.name, os.path.basename(product_dir))
 
             if fs_path.endswith(".zip"):
                 with zipfile.ZipFile(fs_path, "r") as zfile:
@@ -427,10 +399,10 @@ class Download(PluginTopic):
                 # then, we create a directory in which we place this file
                 product_extraction_path = self._resolve_archive_depth(extraction_dir)
                 if os.path.isfile(product_extraction_path) and not os.path.isdir(
-                    outputs_dir
+                    product_dir
                 ):
-                    os.makedirs(outputs_dir)
-                shutil.move(product_extraction_path, outputs_dir)
+                    os.makedirs(product_dir)
+                shutil.move(product_extraction_path, product_dir)
 
             elif fs_path.endswith(".tar") or fs_path.endswith(".tar.gz"):
                 with tarfile.open(fs_path, "r") as zfile:
@@ -441,10 +413,10 @@ class Download(PluginTopic):
                 # then, we create a directory in which we place this file
                 product_extraction_path = self._resolve_archive_depth(extraction_dir)
                 if os.path.isfile(product_extraction_path) and not os.path.isdir(
-                    outputs_dir
+                    product_dir
                 ):
-                    os.makedirs(outputs_dir)
-                shutil.move(product_extraction_path, outputs_dir)
+                    os.makedirs(product_dir)
+                shutil.move(product_extraction_path, product_dir)
             else:
                 progress_callback(1, total=1)
 
@@ -483,32 +455,23 @@ class Download(PluginTopic):
         implemented by the plugin to **sequentially** attempt to download products.
 
         :param products: Products to download
-        :type products: :class:`~eodag.api.search_result.SearchResult`
         :param auth: (optional) authenticated object
-        :type auth: Optional[Union[AuthBase, Dict[str, str]]]
         :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 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: List of absolute paths to the downloaded products in the local
             filesystem (e.g. ``['/tmp/product.zip']`` on Linux or
             ``['C:\\Users\\username\\AppData\\Local\\Temp\\product.zip']`` on Windows)
-        :rtype: list
         """
         # Products are going to be removed one by one from this sequence once
         # downloaded.
@@ -632,14 +595,10 @@ class Download(PluginTopic):
         exception is thrown until `timeout` minutes.
 
         :param product: The EO product to download
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         :param wait: If download fails, wait time in minutes between two download tries
-        :type wait: int
         :param timeout: If download fails, maximum time in minutes before stop retrying
                         to download
-        :type timeout: int
         :returns: decorator
-        :rtype: Callable[[Callable[..., T]], Callable[..., T]]
         """
 
         def decorator(download: Callable[..., T]) -> Callable[..., T]:
@@ -670,7 +629,7 @@ class Download(PluginTopic):
                             not_available_info = str(e)
 
                     if datetime_now >= product.next_try and datetime_now < stop_time:
-                        wait_seconds = (
+                        wait_seconds: Union[float, int] = (
                             datetime_now - product.next_try + timedelta(minutes=wait)
                         ).seconds
                         retry_count += 1