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

eodag/plugins/download/aws.py

@@ -34,6 +34,7 @@ from typing import (
     Optional,
     Set,
     Tuple,
+    TypedDict,
     Union,
     cast,
 )
@@ -43,6 +44,7 @@ import requests
 from botocore.exceptions import ClientError, ProfileNotFound
 from botocore.handlers import disable_signing
 from lxml import etree
+from requests.auth import AuthBase
 from stream_zip import ZIP_AUTO, stream_zip
 
 from eodag.api.product.metadata_mapping import (
@@ -57,6 +59,7 @@ from eodag.utils import (
     HTTP_REQ_TIMEOUT,
     USER_AGENT,
     ProgressCallback,
+    StreamResponse,
     flatten_top_directories,
     get_bucket_name_and_prefix,
     path_to_uri,
@@ -66,6 +69,8 @@ from eodag.utils import (
 from eodag.utils.exceptions import (
     AuthenticationError,
     DownloadError,
+    MisconfiguredError,
+    NoMatchingProductType,
     NotAvailableError,
     TimeOutError,
 )
@@ -76,7 +81,8 @@ if TYPE_CHECKING:
     from eodag.api.product import EOProduct
     from eodag.api.search_result import SearchResult
     from eodag.config import PluginConfig
-    from eodag.utils import DownloadedCallback
+    from eodag.types.download_args import DownloadConf
+    from eodag.utils import DownloadedCallback, Unpack
 
 
 logger = logging.getLogger("eodag.download.aws")
@@ -209,59 +215,56 @@ 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
+        * ``config.s3_endpoint`` (str) - s3 endpoint url
         * ``config.requester_pays`` (bool) - (optional) whether download is done from a
           requester-pays bucket or not
         * ``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,
         product: EOProduct,
-        auth: Optional[PluginConfig] = None,
+        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
         progress_callback: Optional[ProgressCallback] = None,
         wait: int = DEFAULT_DOWNLOAD_WAIT,
         timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
-        **kwargs: Union[str, bool, Dict[str, Any]],
-    ) -> str:
+        **kwargs: Unpack[DownloadConf],
+    ) -> Optional[str]:
         """Download method for AWS S3 API.
 
         The product can be downloaded as it is, or as SAFE-formatted product.
         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}/{updated_title}.SAFE`
+        `{output_dir}/{title}`
 
         :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: Union[AuthBase, Dict[str, str]]
+        :param auth: (optional) authenticated object
         :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 = {}
+        if isinstance(auth, AuthBase):
+            raise MisconfiguredError("Please use AwsAuth plugin with AwsDownload")
+
         if progress_callback is None:
             logger.info(
                 "Progress bar unavailable, please call product.download() instead of plugin.download()"
@@ -272,7 +275,7 @@ class AwsDownload(Download):
         product_local_path, record_filename = self._download_preparation(
             product, progress_callback=progress_callback, **kwargs
         )
-        if not record_filename:
+        if not record_filename or not product_local_path:
             return product_local_path
 
         product_conf = getattr(self.config, "products", {}).get(
@@ -290,7 +293,7 @@ class AwsDownload(Download):
 
         # product conf overrides provider conf for "flatten_top_dirs"
         flatten_top_dirs = product_conf.get(
-            "flatten_top_dirs", getattr(self.config, "flatten_top_dirs", False)
+            "flatten_top_dirs", getattr(self.config, "flatten_top_dirs", True)
         )
 
         # xtra metadata needed for SAFE product
@@ -328,7 +331,7 @@ class AwsDownload(Download):
             product,
         )
 
-        total_size = sum([p.size for p in unique_product_chunks])
+        total_size = sum([p.size for p in unique_product_chunks]) or None
 
         # download
         progress_callback.reset(total=total_size)
@@ -384,21 +387,20 @@ class AwsDownload(Download):
         return product_local_path
 
     def _download_preparation(
-        self, product: EOProduct, progress_callback: ProgressCallback, **kwargs: Any
-    ) -> Tuple[str, Optional[str]]:
+        self,
+        product: EOProduct,
+        progress_callback: ProgressCallback,
+        **kwargs: Unpack[DownloadConf],
+    ) -> Tuple[Optional[str], Optional[str]]:
         """
         preparation for the download:
         - check if file was already downloaded
         - 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
@@ -420,13 +422,14 @@ 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, {}
         )
+        ssl_verify = getattr(self.config, "ssl_verify", True)
+        timeout = getattr(self.config, "timeout", HTTP_REQ_TIMEOUT)
+
         if build_safe and "fetch_metadata" in product_conf.keys():
             fetch_format = product_conf["fetch_metadata"]["fetch_format"]
             update_metadata = product_conf["fetch_metadata"]["update_metadata"]
@@ -436,10 +439,13 @@ class AwsDownload(Download):
             logger.info("Fetching extra metadata from %s" % fetch_url)
             try:
                 resp = requests.get(
-                    fetch_url, headers=USER_AGENT, timeout=HTTP_REQ_TIMEOUT
+                    fetch_url,
+                    headers=USER_AGENT,
+                    timeout=timeout,
+                    verify=ssl_verify,
                 )
             except requests.exceptions.Timeout as exc:
-                raise TimeOutError(exc, timeout=HTTP_REQ_TIMEOUT) from exc
+                raise TimeOutError(exc, timeout=timeout) from exc
             update_metadata = mtd_cfg_as_conversion_and_querypath(update_metadata)
             if fetch_format == "json":
                 json_resp = resp.json()
@@ -454,18 +460,17 @@ class AwsDownload(Download):
                 )
 
     def _get_bucket_names_and_prefixes(
-        self, product: EOProduct, asset_filter: str, ignore_assets: bool
+        self,
+        product: EOProduct,
+        asset_filter: Optional[str] = None,
+        ignore_assets: Optional[bool] = False,
     ) -> List[Tuple[str, Optional[str]]]:
         """
         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:
@@ -483,7 +488,7 @@ class AwsDownload(Download):
                         rf"No asset key matching re.fullmatch(r'{asset_filter}') was found in {product}"
                     )
             else:
-                assets_values = getattr(product, "assets", {}).values()
+                assets_values = product.assets.values()
 
             bucket_names_and_prefixes = []
             for complementary_url in assets_values:
@@ -501,23 +506,28 @@ class AwsDownload(Download):
     def _do_authentication(
         self,
         bucket_names_and_prefixes: List[Tuple[str, Optional[str]]],
-        auth: Dict[str, str],
-    ) -> Tuple[Dict[str, Any], ResourceCollection[Any]]:
+        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+    ) -> Tuple[Dict[str, Any], ResourceCollection]:
         """
         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(
+                f"Incompatible authentication information, expected dict or None, got {type(auth)}"
+            )
+        if auth is None:
+            auth = {}
         authenticated_objects: Dict[str, Any] = {}
         auth_error_messages: Set[str] = set()
         for _, pack in enumerate(bucket_names_and_prefixes):
             try:
                 bucket_name, prefix = pack
+                if not prefix:
+                    continue
                 if bucket_name not in authenticated_objects:
                     # get Prefixes longest common base path
                     common_prefix = ""
@@ -532,7 +542,7 @@ class AwsDownload(Download):
                                 [
                                     p
                                     for b, p in bucket_names_and_prefixes
-                                    if b == bucket_name and common_prefix in p
+                                    if p and b == bucket_name and common_prefix in p
                                 ]
                             )
                             < prefixes_in_bucket
@@ -566,24 +576,18 @@ class AwsDownload(Download):
         self,
         bucket_names_and_prefixes: List[Tuple[str, Optional[str]]],
         authenticated_objects: Dict[str, Any],
-        asset_filter: str,
+        asset_filter: Optional[str],
         ignore_assets: bool,
         product: EOProduct,
     ) -> Set[Any]:
         """
         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:
@@ -608,52 +612,46 @@ class AwsDownload(Download):
                 raise NotAvailableError(
                     rf"No file basename matching re.fullmatch(r'{asset_filter}') was found in {product.remote_location}"
                 )
+
+        if not unique_product_chunks:
+            raise NoMatchingProductType("No product found to download.")
+
         return unique_product_chunks
 
     def _raise_if_auth_error(self, exception: ClientError) -> None:
         """Raises an error if given exception is an authentication error"""
-        err = exception.response["Error"]
+        err = cast(Dict[str, str], exception.response["Error"])
         if err["Code"] in AWS_AUTH_ERROR_MESSAGES and "key" in err["Message"].lower():
             raise AuthenticationError(
-                "HTTP error {} returned\n{}: {}\nPlease check your credentials for {}".format(
-                    exception.response["ResponseMetadata"]["HTTPStatusCode"],
-                    err["Code"],
-                    err["Message"],
-                    self.provider,
-                )
+                f"Please check your credentials for {self.provider}.",
+                f"HTTP Error {exception.response['ResponseMetadata']['HTTPStatusCode']} returned.",
+                err["Code"] + ": " + err["Message"],
             )
 
     def _stream_download_dict(
         self,
         product: EOProduct,
-        auth: Optional[PluginConfig] = None,
+        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
         progress_callback: Optional[ProgressCallback] = None,
         wait: int = DEFAULT_DOWNLOAD_WAIT,
         timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
-        **kwargs: Union[str, bool, Dict[str, Any]],
-    ) -> Dict[str, Any]:
+        **kwargs: Unpack[DownloadConf],
+    ) -> StreamResponse:
         r"""
-        Returns dictionnary of :class:`~fastapi.responses.StreamingResponse` keyword-arguments.
+        Returns dictionary of :class:`~fastapi.responses.StreamingResponse` keyword-arguments.
         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
+        :returns: Dictionary of :class:`~fastapi.responses.StreamingResponse` keyword-arguments
         """
         if progress_callback is None:
             logger.info(
@@ -725,11 +723,11 @@ class AwsDownload(Download):
             if assets_values[0].get("type", None):
                 headers["content-type"] = assets_values[0]["type"]
 
-            return dict(
+            return StreamResponse(
                 content=chain(iter([first_chunks_tuple]), chunks_tuples),
                 headers=headers,
             )
-        return dict(
+        return StreamResponse(
             content=stream_zip(chunks_tuples),
             media_type="application/zip",
             headers={
@@ -744,7 +742,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
@@ -755,7 +753,6 @@ class AwsDownload(Download):
             product_chunk: Any, progress_callback: ProgressCallback
         ) -> Any:
             try:
-
                 chunk_start = 0
                 chunk_end = chunk_start + chunk_size - 1
 
@@ -779,7 +776,7 @@ class AwsDownload(Download):
             product.product_type, {}
         )
         flatten_top_dirs = product_conf.get(
-            "flatten_top_dirs", getattr(self.config, "flatten_top_dirs", False)
+            "flatten_top_dirs", getattr(self.config, "flatten_top_dirs", True)
         )
         common_path = ""
         if flatten_top_dirs:
@@ -832,13 +829,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
+        :param auth_dict: Dictionary containing authentication keys
         :returns: The rasterio environement variables
-        :rtype: dict
         """
         if self.s3_session is not None:
             if self.requester_pays:
@@ -863,14 +856,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
+        :param auth_dict: Dictionary containing authentication keys
         :returns: The boto3 authenticated objects
-        :rtype: :class:`~boto3.resources.collection.s3.Bucket.objectsCollection`
         """
         auth_methods: List[
             Callable[[str, str, Dict[str, str]], Optional[ResourceCollection]]
@@ -912,15 +901,15 @@ class AwsDownload(Download):
     ) -> Optional[ResourceCollection]:
         """Auth strategy using no-sign-request"""
 
-        s3_resource = boto3.resource(  # type: ignore
-            service_name="s3", endpoint_url=getattr(self.config, "base_uri", None)
+        s3_resource = boto3.resource(
+            service_name="s3", endpoint_url=getattr(self.config, "s3_endpoint", 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]
@@ -928,20 +917,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),
+                endpoint_url=getattr(self.config, "s3_endpoint", 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
 
@@ -952,23 +941,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),
+                endpoint_url=getattr(self.config, "s3_endpoint", 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
 
@@ -977,19 +978,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
-            service_name="s3", endpoint_url=getattr(self.config, "base_uri", None)
+        s3_session = boto3.session.Session()
+        s3_resource = s3_session.resource(
+            service_name="s3", endpoint_url=getattr(self.config, "s3_endpoint", 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
@@ -997,11 +998,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
@@ -1154,8 +1152,7 @@ class AwsDownload(Download):
         # S2 L2A Tile files -----------------------------------------------
         if matched := S2L2A_TILE_IMG_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/GRANULE/%s/IMG_DATA/R%s/T%s%s%s_%s_%s_%s.jp2" % (
-                product.properties["title"],
+            product_path = "GRANULE/%s/IMG_DATA/R%s/T%s%s%s_%s_%s_%s.jp2" % (
                 found_dict["num"],
                 found_dict["res"],
                 found_dict["tile1"],
@@ -1167,16 +1164,14 @@ class AwsDownload(Download):
             )
         elif matched := S2L2A_TILE_AUX_DIR_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/GRANULE/%s/AUX_DATA/%s" % (
-                product.properties["title"],
+            product_path = "GRANULE/%s/AUX_DATA/%s" % (
                 found_dict["num"],
                 found_dict["file"],
             )
         # S2 L2A QI Masks
         elif matched := S2_TILE_QI_MSK_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/GRANULE/%s/QI_DATA/MSK_%sPRB_%s" % (
-                product.properties["title"],
+            product_path = "GRANULE/%s/QI_DATA/MSK_%sPRB_%s" % (
                 found_dict["num"],
                 found_dict["file_base"],
                 found_dict["file_suffix"],
@@ -1184,8 +1179,7 @@ class AwsDownload(Download):
         # S2 L2A QI PVI
         elif matched := S2_TILE_QI_PVI_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/GRANULE/%s/QI_DATA/%s_%s_PVI.jp2" % (
-                product.properties["title"],
+            product_path = "GRANULE/%s/QI_DATA/%s_%s_PVI.jp2" % (
                 found_dict["num"],
                 title_part3,
                 title_date1,
@@ -1193,15 +1187,13 @@ class AwsDownload(Download):
         # S2 Tile files ---------------------------------------------------
         elif matched := S2_TILE_PREVIEW_DIR_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/GRANULE/%s/preview/%s" % (
-                product.properties["title"],
+            product_path = "GRANULE/%s/preview/%s" % (
                 found_dict["num"],
                 found_dict["file"],
             )
         elif matched := S2_TILE_IMG_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/GRANULE/%s/IMG_DATA/T%s%s%s_%s_%s" % (
-                product.properties["title"],
+            product_path = "GRANULE/%s/IMG_DATA/T%s%s%s_%s_%s" % (
                 found_dict["num"],
                 found_dict["tile1"],
                 found_dict["tile2"],
@@ -1211,97 +1203,74 @@ class AwsDownload(Download):
             )
         elif matched := S2_TILE_THUMBNAIL_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/GRANULE/%s/%s" % (
-                product.properties["title"],
+            product_path = "GRANULE/%s/%s" % (
                 found_dict["num"],
                 found_dict["file"],
             )
         elif matched := S2_TILE_MTD_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/GRANULE/%s/MTD_TL.xml" % (
-                product.properties["title"],
-                found_dict["num"],
-            )
+            product_path = "GRANULE/%s/MTD_TL.xml" % found_dict["num"]
         elif matched := S2_TILE_AUX_DIR_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/GRANULE/%s/AUX_DATA/AUX_%s" % (
-                product.properties["title"],
+            product_path = "GRANULE/%s/AUX_DATA/AUX_%s" % (
                 found_dict["num"],
                 found_dict["file"],
             )
         elif matched := S2_TILE_QI_DIR_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/GRANULE/%s/QI_DATA/%s" % (
-                product.properties["title"],
+            product_path = "GRANULE/%s/QI_DATA/%s" % (
                 found_dict["num"],
                 found_dict["file"],
             )
         # S2 Tiles generic
         elif matched := S2_TILE_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/GRANULE/%s/%s" % (
-                product.properties["title"],
+            product_path = "GRANULE/%s/%s" % (
                 found_dict["num"],
                 found_dict["file"],
             )
         # S2 Product files
         elif matched := S2_PROD_DS_MTD_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/DATASTRIP/%s/MTD_DS.xml" % (
-                product.properties["title"],
-                ds_dir,
-            )
+            product_path = "DATASTRIP/%s/MTD_DS.xml" % ds_dir
         elif matched := S2_PROD_DS_QI_REPORT_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/DATASTRIP/%s/QI_DATA/%s.xml" % (
-                product.properties["title"],
+            product_path = "DATASTRIP/%s/QI_DATA/%s.xml" % (
                 ds_dir,
                 found_dict["filename"],
             )
         elif matched := S2_PROD_DS_QI_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/DATASTRIP/%s/QI_DATA/%s" % (
-                product.properties["title"],
+            product_path = "DATASTRIP/%s/QI_DATA/%s" % (
                 ds_dir,
                 found_dict["file"],
             )
         elif matched := S2_PROD_INSPIRE_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/INSPIRE.xml" % (product.properties["title"],)
+            product_path = "INSPIRE.xml"
         elif matched := S2_PROD_MTD_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/MTD_MSI%s.xml" % (
-                product.properties["title"],
-                s2_processing_level,
-            )
+            product_path = "MTD_MSI%s.xml" % s2_processing_level
         # S2 Product generic
         elif matched := S2_PROD_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/%s" % (
-                product.properties["title"],
-                found_dict["file"],
-            )
+            product_path = "%s" % found_dict["file"]
         # S1 --------------------------------------------------------------
         elif matched := S1_CALIB_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = (
-                "%s.SAFE/annotation/calibration/%s-%s-%s-grd-%s-%s-%03d.xml"
-                % (
-                    product.properties["title"],
-                    found_dict["file_prefix"],
-                    product.properties["platformSerialIdentifier"].lower(),
-                    found_dict["file_beam"],
-                    found_dict["file_pol"],
-                    s1_title_suffix,
-                    S1_IMG_NB_PER_POLAR.get(
-                        product.properties["polarizationMode"], {}
-                    ).get(found_dict["file_pol"].upper(), 1),
-                )
+            product_path = "annotation/calibration/%s-%s-%s-grd-%s-%s-%03d.xml" % (
+                found_dict["file_prefix"],
+                product.properties["platformSerialIdentifier"].lower(),
+                found_dict["file_beam"],
+                found_dict["file_pol"],
+                s1_title_suffix,
+                S1_IMG_NB_PER_POLAR.get(product.properties["polarizationMode"], {}).get(
+                    found_dict["file_pol"].upper(), 1
+                ),
             )
         elif matched := S1_ANNOT_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/annotation/%s-%s-grd-%s-%s-%03d.xml" % (
-                product.properties["title"],
+            product_path = "annotation/%s-%s-grd-%s-%s-%03d.xml" % (
                 product.properties["platformSerialIdentifier"].lower(),
                 found_dict["file_beam"],
                 found_dict["file_pol"],
@@ -1312,8 +1281,7 @@ class AwsDownload(Download):
             )
         elif matched := S1_MEAS_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/measurement/%s-%s-grd-%s-%s-%03d.%s" % (
-                product.properties["title"],
+            product_path = "measurement/%s-%s-grd-%s-%s-%03d.%s" % (
                 product.properties["platformSerialIdentifier"].lower(),
                 found_dict["file_beam"],
                 found_dict["file_pol"],
@@ -1325,18 +1293,14 @@ class AwsDownload(Download):
             )
         elif matched := S1_REPORT_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/%s.SAFE-%s" % (
-                product.properties["title"],
+            product_path = "%s.SAFE-%s" % (
                 product.properties["title"],
                 found_dict["file"],
             )
         # S1 generic
         elif matched := S1_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
-            product_path = "%s.SAFE/%s" % (
-                product.properties["title"],
-                found_dict["file"],
-            )
+            product_path = "%s" % found_dict["file"]
         # out of SAFE format
         else:
             raise NotAvailableError(f"Ignored {chunk.key} out of SAFE matching pattern")
@@ -1347,12 +1311,12 @@ class AwsDownload(Download):
     def download_all(
         self,
         products: SearchResult,
-        auth: Optional[PluginConfig] = None,
+        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
         downloaded_callback: Optional[DownloadedCallback] = None,
         progress_callback: Optional[ProgressCallback] = None,
         wait: int = DEFAULT_DOWNLOAD_WAIT,
         timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
-        **kwargs: Union[str, bool, Dict[str, Any]],
+        **kwargs: Unpack[DownloadConf],
     ) -> List[str]:
         """
         download_all using parent (base plugin) method