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

eodag/plugins/download/aws.py

@@ -23,21 +23,7 @@ import re
 from datetime import datetime
 from itertools import chain
 from pathlib import Path
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    Iterator,
-    List,
-    Match,
-    Optional,
-    Set,
-    Tuple,
-    TypedDict,
-    Union,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, Callable, Iterator, Optional, Union, cast
 
 import boto3
 import requests
@@ -81,6 +67,7 @@ if TYPE_CHECKING:
     from eodag.api.product import EOProduct
     from eodag.api.search_result import SearchResult
     from eodag.config import PluginConfig
+    from eodag.types import S3SessionKwargs
     from eodag.types.download_args import DownloadConf
     from eodag.utils import DownloadedCallback, Unpack
 
@@ -230,14 +217,14 @@ class AwsDownload(Download):
         * :attr:`~eodag.config.PluginConfig.bucket_path_level` (``int``): at which level of the
           path part of the url the bucket can be found; If no bucket_path_level is given, the bucket
           is taken from the first element of the netloc part.
-        * :attr:`~eodag.config.PluginConfig.products` (``Dict[str, Dict[str, Any]``): product type
+        * :attr:`~eodag.config.PluginConfig.products` (``dict[str, dict[str, Any]``): product type
           specific config; the keys are the product types, the values are dictionaries which can contain the keys:
 
           * **default_bucket** (``str``): bucket where the product type can be found
           * **complementary_url_key** (``str``): keys to add additional urls
           * **build_safe** (``bool``): if a SAFE (Standard Archive Format for Europe) product should
             be created; used for Sentinel products; default: False
-          * **fetch_metadata** (``Dict[str, Any]``): config for metadata to be fetched for the SAFE product
+          * **fetch_metadata** (``dict[str, Any]``): config for metadata to be fetched for the SAFE product
 
     """
 
@@ -249,10 +236,10 @@ class AwsDownload(Download):
     def download(
         self,
         product: EOProduct,
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
         progress_callback: Optional[ProgressCallback] = None,
-        wait: int = DEFAULT_DOWNLOAD_WAIT,
-        timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
+        wait: float = DEFAULT_DOWNLOAD_WAIT,
+        timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
         **kwargs: Unpack[DownloadConf],
     ) -> Optional[str]:
         """Download method for AWS S3 API.
@@ -407,7 +394,7 @@ class AwsDownload(Download):
         product: EOProduct,
         progress_callback: ProgressCallback,
         **kwargs: Unpack[DownloadConf],
-    ) -> Tuple[Optional[str], Optional[str]]:
+    ) -> tuple[Optional[str], Optional[str]]:
         """
         preparation for the download:
         - check if file was already downloaded
@@ -480,9 +467,10 @@ class AwsDownload(Download):
         product: EOProduct,
         asset_filter: Optional[str] = None,
         ignore_assets: Optional[bool] = False,
-    ) -> List[Tuple[str, Optional[str]]]:
+    ) -> list[tuple[str, Optional[str]]]:
         """
-        retrieves the bucket names and path prefixes for the assets
+        Retrieves the bucket names and path prefixes for the assets
+
         :param product: product for which the assets shall be downloaded
         :param asset_filter: text for which the assets should be filtered
         :param ignore_assets: if product instead of individual assets should be used
@@ -521,9 +509,9 @@ class AwsDownload(Download):
 
     def _do_authentication(
         self,
-        bucket_names_and_prefixes: List[Tuple[str, Optional[str]]],
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
-    ) -> Tuple[Dict[str, Any], ResourceCollection]:
+        bucket_names_and_prefixes: list[tuple[str, Optional[str]]],
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
+    ) -> tuple[dict[str, Any], ResourceCollection]:
         """
         authenticates with s3 and retrieves the available objects
         raises an error when authentication is not possible
@@ -537,8 +525,8 @@ class AwsDownload(Download):
             )
         if auth is None:
             auth = {}
-        authenticated_objects: Dict[str, Any] = {}
-        auth_error_messages: Set[str] = set()
+        authenticated_objects: dict[str, Any] = {}
+        auth_error_messages: set[str] = set()
         for _, pack in enumerate(bucket_names_and_prefixes):
             try:
                 bucket_name, prefix = pack
@@ -590,12 +578,12 @@ class AwsDownload(Download):
 
     def _get_unique_products(
         self,
-        bucket_names_and_prefixes: List[Tuple[str, Optional[str]]],
-        authenticated_objects: Dict[str, Any],
+        bucket_names_and_prefixes: list[tuple[str, Optional[str]]],
+        authenticated_objects: dict[str, Any],
         asset_filter: Optional[str],
         ignore_assets: bool,
         product: EOProduct,
-    ) -> Set[Any]:
+    ) -> 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
@@ -605,7 +593,7 @@ class AwsDownload(Download):
         :param product: product that shall be downloaded
         :return: set of product chunks that can be downloaded
         """
-        product_chunks: List[Any] = []
+        product_chunks: list[Any] = []
         for bucket_name, prefix in bucket_names_and_prefixes:
             # unauthenticated items filtered out
             if bucket_name in authenticated_objects.keys():
@@ -636,7 +624,7 @@ class AwsDownload(Download):
 
     def _raise_if_auth_error(self, exception: ClientError) -> None:
         """Raises an error if given exception is an authentication error"""
-        err = cast(Dict[str, str], 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(
                 f"Please check your credentials for {self.provider}.",
@@ -647,10 +635,10 @@ class AwsDownload(Download):
     def _stream_download_dict(
         self,
         product: EOProduct,
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
         progress_callback: Optional[ProgressCallback] = None,
-        wait: int = DEFAULT_DOWNLOAD_WAIT,
-        timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
+        wait: float = DEFAULT_DOWNLOAD_WAIT,
+        timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
         **kwargs: Unpack[DownloadConf],
     ) -> StreamResponse:
         r"""
@@ -731,12 +719,12 @@ class AwsDownload(Download):
             else sanitize(product.properties.get("id", "download"))
         )
 
-        if len(assets_values) == 1:
+        if len(assets_values) <= 1:
             first_chunks_tuple = next(chunks_tuples)
             # update headers
             filename = os.path.basename(list(unique_product_chunks)[0].key)
             headers = {"content-disposition": f"attachment; filename={filename}"}
-            if assets_values[0].get("type", None):
+            if assets_values and assets_values[0].get("type", None):
                 headers["content-type"] = assets_values[0]["type"]
 
             return StreamResponse(
@@ -753,11 +741,11 @@ class AwsDownload(Download):
 
     def _stream_download(
         self,
-        unique_product_chunks: Set[Any],
+        unique_product_chunks: set[Any],
         product: EOProduct,
         build_safe: bool,
         progress_callback: ProgressCallback,
-        assets_values: List[Dict[str, Any]],
+        assets_values: list[dict[str, Any]],
     ) -> Iterator[Any]:
         """Yield product data chunks"""
 
@@ -799,7 +787,6 @@ class AwsDownload(Download):
             common_path = self._get_commonpath(
                 product, unique_product_chunks, build_safe
             )
-
         for product_chunk in unique_product_chunks:
             try:
                 chunk_rel_path = self.get_chunk_dest_path(
@@ -817,8 +804,7 @@ class AwsDownload(Download):
                 # out of SAFE format chunk
                 logger.warning(e)
                 continue
-
-            if len(assets_values) == 1:
+            if len(assets_values) <= 1:
                 yield from get_chunk_parts(product_chunk, progress_callback)
             else:
                 yield (
@@ -830,7 +816,7 @@ class AwsDownload(Download):
                 )
 
     def _get_commonpath(
-        self, product: EOProduct, product_chunks: Set[Any], build_safe: bool
+        self, product: EOProduct, product_chunks: set[Any], build_safe: bool
     ) -> str:
         chunk_paths = []
         for product_chunk in product_chunks:
@@ -840,8 +826,8 @@ class AwsDownload(Download):
         return os.path.commonpath(chunk_paths)
 
     def get_rio_env(
-        self, bucket_name: str, prefix: str, auth_dict: Dict[str, str]
-    ) -> Dict[str, Any]:
+        self, bucket_name: str, prefix: str, auth_dict: S3SessionKwargs
+    ) -> dict[str, Any]:
         """Get rasterio environment variables needed for data access authentication.
 
         :param bucket_name: Bucket containg objects
@@ -849,23 +835,26 @@ class AwsDownload(Download):
         :param auth_dict: Dictionary containing authentication keys
         :returns: The rasterio environement variables
         """
-        if self.s3_session is not None:
-            if self.requester_pays:
-                return {"session": self.s3_session, "requester_pays": True}
-            else:
-                return {"session": self.s3_session}
+        rio_env_kwargs = {}
+        if endpoint_url := getattr(self.config, "s3_endpoint", None):
+            rio_env_kwargs["endpoint_url"] = endpoint_url.split("://")[-1]
+        rio_env_kwargs |= auth_dict
+
+        if self.s3_session is None:
+            _ = self.get_authenticated_objects(bucket_name, prefix, auth_dict)
 
-        _ = self.get_authenticated_objects(bucket_name, prefix, auth_dict)
         if self.s3_session is not None:
             if self.requester_pays:
-                return {"session": self.s3_session, "requester_pays": True}
-            else:
-                return {"session": self.s3_session}
+                rio_env_kwargs["requester_pays"] = True
+            return {
+                "session": self.s3_session,
+                **rio_env_kwargs,
+            }
         else:
-            return {"aws_unsigned": True}
+            return {"aws_unsigned": True, **rio_env_kwargs}
 
     def get_authenticated_objects(
-        self, bucket_name: str, prefix: str, auth_dict: Dict[str, str]
+        self, bucket_name: str, prefix: str, auth_dict: S3SessionKwargs
     ) -> ResourceCollection:
         """Get boto3 authenticated objects for the given bucket using
         the most adapted auth strategy.
@@ -877,8 +866,8 @@ class AwsDownload(Download):
         :param auth_dict: Dictionary containing authentication keys
         :returns: The boto3 authenticated objects
         """
-        auth_methods: List[
-            Callable[[str, str, Dict[str, str]], Optional[ResourceCollection]]
+        auth_methods: list[
+            Callable[[str, str, S3SessionKwargs], Optional[ResourceCollection]]
         ] = [
             self._get_authenticated_objects_unsigned,
             self._get_authenticated_objects_from_auth_profile,
@@ -913,7 +902,7 @@ class AwsDownload(Download):
         )
 
     def _get_authenticated_objects_unsigned(
-        self, bucket_name: str, prefix: str, auth_dict: Dict[str, str]
+        self, bucket_name: str, prefix: str, auth_dict: S3SessionKwargs
     ) -> Optional[ResourceCollection]:
         """Auth strategy using no-sign-request"""
 
@@ -928,7 +917,7 @@ class AwsDownload(Download):
         return objects
 
     def _get_authenticated_objects_from_auth_profile(
-        self, bucket_name: str, prefix: str, auth_dict: Dict[str, str]
+        self, bucket_name: str, prefix: str, auth_dict: S3SessionKwargs
     ) -> Optional[ResourceCollection]:
         """Auth strategy using RequestPayer=requester and ``aws_profile`` from provided credentials"""
 
@@ -951,21 +940,12 @@ class AwsDownload(Download):
             return None
 
     def _get_authenticated_objects_from_auth_keys(
-        self, bucket_name: str, prefix: str, auth_dict: Dict[str, str]
+        self, bucket_name: str, prefix: str, auth_dict: S3SessionKwargs
     ) -> Optional[ResourceCollection]:
         """Auth strategy using RequestPayer=requester and ``aws_access_key_id``/``aws_secret_access_key``
         from provided credentials"""
 
         if all(k in auth_dict for k in ("aws_access_key_id", "aws_secret_access_key")):
-            S3SessionKwargs = TypedDict(
-                "S3SessionKwargs",
-                {
-                    "aws_access_key_id": str,
-                    "aws_secret_access_key": str,
-                    "aws_session_token": str,
-                },
-                total=False,
-            )
             s3_session_kwargs: S3SessionKwargs = {
                 "aws_access_key_id": auth_dict["aws_access_key_id"],
                 "aws_secret_access_key": auth_dict["aws_secret_access_key"],
@@ -990,7 +970,7 @@ class AwsDownload(Download):
             return None
 
     def _get_authenticated_objects_from_env(
-        self, bucket_name: str, prefix: str, auth_dict: Dict[str, str]
+        self, bucket_name: str, prefix: str, auth_dict: S3SessionKwargs
     ) -> Optional[ResourceCollection]:
         """Auth strategy using RequestPayer=requester and current environment"""
 
@@ -1010,7 +990,7 @@ class AwsDownload(Download):
 
     def get_product_bucket_name_and_prefix(
         self, product: EOProduct, url: Optional[str] = None
-    ) -> Tuple[str, Optional[str]]:
+    ) -> tuple[str, Optional[str]]:
         """Extract bucket name and prefix from product URL
 
         :param product: The EO product to download
@@ -1141,7 +1121,7 @@ class AwsDownload(Download):
         s1_title_suffix: Optional[str] = None
         # S2 common
         if product.product_type and "S2_MSI" in product.product_type:
-            title_search: Optional[Match[str]] = re.search(
+            title_search: Optional[re.Match[str]] = re.search(
                 r"^\w+_\w+_(\w+)_(\w+)_(\w+)_(\w+)_(\w+)$",
                 product.properties["title"],
             )
@@ -1327,13 +1307,13 @@ class AwsDownload(Download):
     def download_all(
         self,
         products: SearchResult,
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
         downloaded_callback: Optional[DownloadedCallback] = None,
         progress_callback: Optional[ProgressCallback] = None,
-        wait: int = DEFAULT_DOWNLOAD_WAIT,
-        timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
+        wait: float = DEFAULT_DOWNLOAD_WAIT,
+        timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
         **kwargs: Unpack[DownloadConf],
-    ) -> List[str]:
+    ) -> list[str]:
         """
         download_all using parent (base plugin) method
         """

eodag/plugins/download/base.py

@@ -26,17 +26,7 @@ import tempfile
 import zipfile
 from datetime import datetime, timedelta
 from time import sleep
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    List,
-    Optional,
-    Tuple,
-    TypeVar,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union
 
 from eodag.plugins.base import PluginTopic
 from eodag.utils import (
@@ -60,6 +50,7 @@ if TYPE_CHECKING:
     from eodag.api.product import EOProduct
     from eodag.api.search_result import SearchResult
     from eodag.config import PluginConfig
+    from eodag.types import S3SessionKwargs
     from eodag.types.download_args import DownloadConf
     from eodag.utils import DownloadedCallback, Unpack
 
@@ -110,10 +101,10 @@ class Download(PluginTopic):
     def download(
         self,
         product: EOProduct,
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
         progress_callback: Optional[ProgressCallback] = None,
-        wait: int = DEFAULT_DOWNLOAD_WAIT,
-        timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
+        wait: float = DEFAULT_DOWNLOAD_WAIT,
+        timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
         **kwargs: Unpack[DownloadConf],
     ) -> Optional[str]:
         r"""
@@ -140,10 +131,10 @@ class Download(PluginTopic):
     def _stream_download_dict(
         self,
         product: EOProduct,
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
         progress_callback: Optional[ProgressCallback] = None,
-        wait: int = DEFAULT_DOWNLOAD_WAIT,
-        timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
+        wait: float = DEFAULT_DOWNLOAD_WAIT,
+        timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
         **kwargs: Unpack[DownloadConf],
     ) -> StreamResponse:
         r"""
@@ -170,7 +161,7 @@ class Download(PluginTopic):
         product: EOProduct,
         progress_callback: Optional[ProgressCallback] = None,
         **kwargs: Unpack[DownloadConf],
-    ) -> Tuple[Optional[str], Optional[str]]:
+    ) -> tuple[Optional[str], Optional[str]]:
         """Check if file has already been downloaded, and prepare product download
 
         :param product: The EO product to download
@@ -202,8 +193,8 @@ class Download(PluginTopic):
             or getattr(self.config, "output_dir", tempfile.gettempdir())
             or tempfile.gettempdir()
         )
-        output_extension = kwargs.get("output_extension", None) or getattr(
-            self.config, "output_extension", ".zip"
+        output_extension = kwargs.get("output_extension") or getattr(
+            self.config, "output_extension", ""
         )
 
         # Strong asumption made here: all products downloaded will be zip files
@@ -233,9 +224,13 @@ class Download(PluginTopic):
                 logger.warning(
                     f"Unable to create records directory. Got:\n{tb.format_exc()}",
                 )
+        url_hash = hashlib.md5(url.encode("utf-8")).hexdigest()
+        old_record_filename = os.path.join(download_records_dir, url_hash)
         record_filename = os.path.join(
             download_records_dir, self.generate_record_hash(product)
         )
+        if os.path.isfile(old_record_filename):
+            os.rename(old_record_filename, record_filename)
         if os.path.isfile(record_filename) and os.path.isfile(fs_path):
             logger.info(
                 f"Product already downloaded: {fs_path}",
@@ -339,13 +334,7 @@ class Download(PluginTopic):
             if delete_archive is not None
             else getattr(self.config, "delete_archive", True)
         )
-        output_extension = kwargs.pop("output_extension", ".zip")
-
-        product_path = (
-            fs_path[: fs_path.index(output_extension)]
-            if output_extension in fs_path
-            else fs_path
-        )
+        product_path, _ = os.path.splitext(fs_path)
         product_path_exists = os.path.exists(product_path)
         if product_path_exists and os.path.isfile(product_path):
             logger.info(
@@ -422,10 +411,10 @@ class Download(PluginTopic):
 
             tmp_dir.cleanup()
 
-            if delete_archive:
+            if delete_archive and os.path.isfile(fs_path):
                 logger.info(f"Deleting archive {os.path.basename(fs_path)}")
                 os.unlink(fs_path)
-            else:
+            elif os.path.isfile(fs_path):
                 logger.info(
                     f"Archive deletion is deactivated, keeping {os.path.basename(fs_path)}"
                 )
@@ -441,13 +430,13 @@ class Download(PluginTopic):
     def download_all(
         self,
         products: SearchResult,
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
         downloaded_callback: Optional[DownloadedCallback] = None,
         progress_callback: Optional[ProgressCallback] = None,
-        wait: int = DEFAULT_DOWNLOAD_WAIT,
-        timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
+        wait: float = DEFAULT_DOWNLOAD_WAIT,
+        timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
         **kwargs: Unpack[DownloadConf],
-    ) -> List[str]:
+    ) -> list[str]:
         """
         Base download_all method.
 
@@ -476,7 +465,7 @@ class Download(PluginTopic):
         # Products are going to be removed one by one from this sequence once
         # downloaded.
         products = products[:]
-        paths: List[str] = []
+        paths: list[str] = []
         # initiate retry loop
         start_time = datetime.now()
         stop_time = start_time + timedelta(minutes=timeout)
@@ -541,7 +530,7 @@ class Download(PluginTopic):
                             )
                             raise
 
-                        except RuntimeError:
+                        except (RuntimeError, Exception):
                             import traceback as tb
 
                             logger.error(
@@ -549,16 +538,9 @@ class Download(PluginTopic):
                                 "Skipping it"
                             )
                             logger.debug(f"\n{tb.format_exc()}")
-                            stop_time = datetime.now()
-
-                        except Exception:
-                            import traceback as tb
 
-                            logger.warning(
-                                f"A problem occurred during download of product: {product}. "
-                                "Skipping it",
-                            )
-                            logger.debug(f"\n{tb.format_exc()}")
+                            # product skipped, to not retry it
+                            products.remove(product)
 
                 if (
                     len(products) > 0
@@ -585,14 +567,14 @@ class Download(PluginTopic):
 
         return paths
 
-    def _download_retry(
-        self, product: EOProduct, wait: int, timeout: int
+    def _order_download_retry(
+        self, product: EOProduct, wait: float, timeout: float
     ) -> Callable[[Callable[..., T]], Callable[..., T]]:
         """
-        Download retry decorator.
+        Order download retry decorator.
 
-        Retries the wrapped  download method after `wait` minutes if a NotAvailableError
-        exception is thrown until `timeout` minutes.
+        Retries the wrapped order_download method after ``wait`` minutes if a
+        ``NotAvailableError`` exception is thrown until ``timeout`` minutes.
 
         :param product: The EO product to download
         :param wait: If download fails, wait time in minutes between two download tries
@@ -601,7 +583,7 @@ class Download(PluginTopic):
         :returns: decorator
         """
 
-        def decorator(download: Callable[..., T]) -> Callable[..., T]:
+        def decorator(order_download: Callable[..., T]) -> Callable[..., T]:
             def download_and_retry(*args: Any, **kwargs: Unpack[DownloadConf]) -> T:
                 # initiate retry loop
                 start_time = datetime.now()
@@ -618,7 +600,7 @@ class Download(PluginTopic):
                     if datetime_now >= product.next_try:
                         product.next_try += timedelta(minutes=wait)
                         try:
-                            return download(*args, **kwargs)
+                            return order_download(*args, **kwargs)
 
                         except NotAvailableError as e:
                             if not getattr(self.config, "order_enabled", False):
@@ -634,7 +616,7 @@ class Download(PluginTopic):
                         ).seconds
                         retry_count += 1
                         retry_info = (
-                            f"[Retry #{retry_count}] Waited {wait_seconds}s, trying again to download ordered product"
+                            f"[Retry #{retry_count}] Waited {wait_seconds}s, checking order status again"
                             f" (retry every {wait}' for {timeout}')"
                         )
                         logger.info(not_available_info)
@@ -656,8 +638,8 @@ class Download(PluginTopic):
                         ).microseconds / 1e6
                         retry_count += 1
                         retry_info = (
-                            f"[Retry #{retry_count}] Waiting {wait_seconds}s until next download try"
-                            f" for ordered product (retry every {wait}' for {timeout}')"
+                            f"[Retry #{retry_count}] Waiting {wait_seconds}s until next order status check"
+                            f" (retry every {wait}' for {timeout}')"
                         )
                         logger.info(not_available_info)
                         # Retry-After info from Response header
@@ -678,12 +660,12 @@ class Download(PluginTopic):
                         logger.info(not_available_info)
                         raise NotAvailableError(
                             f"{product.properties['title']} is not available ({product.properties['storageStatus']})"
-                            f" and could not be downloaded, timeout reached"
+                            f" and order was not successfull, timeout reached"
                         )
                     elif datetime_now >= stop_time:
                         raise NotAvailableError(not_available_info)
 
-                return download(*args, **kwargs)
+                return order_download(*args, **kwargs)
 
             return download_and_retry
 

eodag/plugins/download/creodias_s3.py

@@ -15,10 +15,12 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from typing import Optional
 
 import boto3
 from botocore.exceptions import ClientError
 
+from eodag import EOProduct
 from eodag.plugins.download.aws import AwsDownload
 from eodag.utils.exceptions import MisconfiguredError
 
@@ -65,3 +67,30 @@ class CreodiasS3Download(AwsDownload):
         list(objects.filter(Prefix=prefix).limit(1))
         self.s3_session = s3_session
         return objects
+
+    def _get_bucket_names_and_prefixes(
+        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
+        :param asset_filter: text for which the assets should be filtered
+        :param ignore_assets: if product instead of individual assets should be used
+        :return: tuples of bucket names and prefixes
+        """
+        # if assets are defined, use them instead of scanning product.location
+        if len(product.assets) > 0 and not ignore_assets:
+            bucket_names_and_prefixes = super()._get_bucket_names_and_prefixes(
+                product, asset_filter, ignore_assets
+            )
+        else:
+            # if no assets are given, use productIdentifier to get S3 path for download
+            s3_url = "s3:/" + product.properties["productIdentifier"]
+            bucket_names_and_prefixes = [
+                self.get_product_bucket_name_and_prefix(product, s3_url)
+            ]
+        return bucket_names_and_prefixes