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

eodag/plugins/download/base.py

@@ -43,6 +43,7 @@ from eodag.utils import (
     DEFAULT_DOWNLOAD_TIMEOUT,
     DEFAULT_DOWNLOAD_WAIT,
     ProgressCallback,
+    StreamResponse,
     sanitize,
     uri_to_path,
 )
@@ -54,10 +55,13 @@ from eodag.utils.exceptions import (
 from eodag.utils.notebook import NotebookWidgets
 
 if TYPE_CHECKING:
+    from requests.auth import AuthBase
+
     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.base")
@@ -75,20 +79,20 @@ 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
-      is built on the MD5 hash of the product's ``remote_location`` attribute
-      (``hashlib.md5(remote_location.encode("utf-8")).hexdigest()``) and whose content is
-      the product's ``remote_location`` attribute itself.
+    - 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.
     - not try to download a product whose ``location`` attribute already points to an
       existing file/directory
     - not try to download a product if its *record* file exists as long as the expected
@@ -96,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:
@@ -108,35 +110,28 @@ class Download(PluginTopic):
     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]],
+        **kwargs: Unpack[DownloadConf],
     ) -> Optional[str]:
         r"""
         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) The configuration of a plugin of type Authentication
-        :type auth: :class:`~eodag.config.PluginConfig`
+        :param auth: (optional) authenticated object
         :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"
@@ -145,33 +140,26 @@ class Download(PluginTopic):
     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"""
         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) The configuration of a plugin of type Authentication
-        :type auth: :class:`~eodag.config.PluginConfig`
+        :param auth: (optional) authenticated object
         :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
         """
         raise NotImplementedError(
             "Download streaming must be implemented using a method named _stream_download_dict"
@@ -181,16 +169,13 @@ class Download(PluginTopic):
         self,
         product: EOProduct,
         progress_callback: Optional[ProgressCallback] = None,
-        **kwargs: Union[str, bool, Dict[str, Any]],
+        **kwargs: Unpack[DownloadConf],
     ) -> Tuple[Optional[str], Optional[str]]:
         """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)
@@ -212,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 = ""
@@ -231,9 +216,11 @@ 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(output_extension, "") if output_extension else fs_path
         )
-        fs_dir_path = fs_path.replace(outputs_extension, "")
         download_records_dir = os.path.join(prefix, ".downloaded")
         try:
             os.makedirs(download_records_dir)
@@ -246,8 +233,9 @@ 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()
-        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(record_filename) and os.path.isfile(fs_path):
             logger.info(
                 f"Product already downloaded: {fs_path}",
@@ -278,6 +266,19 @@ class Download(PluginTopic):
 
         return fs_path, record_filename
 
+    def generate_record_hash(self, product: EOProduct) -> str:
+        """Generate the record hash of the given product.
+
+        The MD5 hash is built from the product's ``product_type`` and ``properties['id']`` attributes
+        (``hashlib.md5((product.product_type+"-"+product.properties['id']).encode("utf-8")).hexdigest()``)
+
+        :param product: The product to calculate the record hash
+        :returns: The MD5 hash
+        """
+        # 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"])
+        return hashlib.md5(product_hash.encode("utf-8")).hexdigest()
+
     def _resolve_archive_depth(self, product_path: str) -> str:
         """Update product_path using archive_depth from provider configuration.
 
@@ -287,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
@@ -302,16 +301,13 @@ class Download(PluginTopic):
         self,
         fs_path: str,
         progress_callback: Optional[ProgressCallback] = None,
-        **kwargs: Any,
+        **kwargs: Unpack[DownloadConf],
     ) -> str:
         """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:
@@ -332,22 +328,22 @@ class Download(PluginTopic):
         extract = (
             extract if extract is not None else getattr(self.config, "extract", True)
         )
+        if not extract:
+            logger.info("Extraction not activated. The product is available as is.")
+            progress_callback(1, total=1)
+            return fs_path
+
         delete_archive = kwargs.pop("delete_archive", None)
         delete_archive = (
             delete_archive
             if delete_archive is not None
             else getattr(self.config, "delete_archive", True)
         )
-        outputs_extension = kwargs.pop("outputs_extension", ".zip")
-
-        if not extract:
-            logger.info("Extraction not activated. The product is available as is.")
-            progress_callback(1, total=1)
-            return fs_path
+        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)
@@ -373,11 +369,8 @@ class Download(PluginTopic):
                 f"Extraction cancelled, destination directory already exists and is not empty: {product_path}"
             )
             progress_callback(1, total=1)
-            product_path = self._resolve_archive_depth(product_path)
             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")
@@ -386,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:
@@ -402,14 +395,28 @@ class Download(PluginTopic):
                             path=extraction_dir,
                         )
                         progress_callback(1)
-                shutil.move(extraction_dir, outputs_dir)
+                # in some cases, only a lone file is extracted without being in a directory
+                # 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(
+                    product_dir
+                ):
+                    os.makedirs(product_dir)
+                shutil.move(product_extraction_path, product_dir)
 
-            elif fs_path.endswith(".tar.gz"):
+            elif fs_path.endswith(".tar") or fs_path.endswith(".tar.gz"):
                 with tarfile.open(fs_path, "r") as zfile:
                     progress_callback.reset(total=1)
                     zfile.extractall(path=extraction_dir)
                     progress_callback(1)
-                shutil.move(extraction_dir, outputs_dir)
+                # in some cases, only a lone file is extracted without being in a directory
+                # 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(
+                    product_dir
+                ):
+                    os.makedirs(product_dir)
+                shutil.move(product_extraction_path, product_dir)
             else:
                 progress_callback(1, total=1)
 
@@ -429,19 +436,17 @@ class Download(PluginTopic):
         if close_progress_callback:
             progress_callback.close()
 
-        product_path = self._resolve_archive_depth(product_path)
-
         return product_path
 
     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]:
         """
         Base download_all method.
@@ -450,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) The configuration of a plugin of type Authentication
-        :type auth: :class:`~eodag.config.PluginConfig`
+        :param auth: (optional) authenticated object
         :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.
@@ -599,18 +595,14 @@ 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]:
-            def download_and_retry(*args: Any, **kwargs: Any) -> T:
+            def download_and_retry(*args: Any, **kwargs: Unpack[DownloadConf]) -> T:
                 # initiate retry loop
                 start_time = datetime.now()
                 stop_time = start_time + timedelta(minutes=timeout)
@@ -634,11 +626,10 @@ class Download(PluginTopic):
                                     f"Product is not available for download and order is not supported for"
                                     f" {self.provider}, {e}"
                                 )
-                            not_available_info = e
-                            pass
+                            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
@@ -646,7 +637,7 @@ class Download(PluginTopic):
                             f"[Retry #{retry_count}] Waited {wait_seconds}s, trying again to download ordered product"
                             f" (retry every {wait}' for {timeout}')"
                         )
-                        logger.debug(not_available_info)
+                        logger.info(not_available_info)
                         # Retry-After info from Response header
                         if hasattr(self, "stream"):
                             retry_server_info = self.stream.headers.get(
@@ -656,7 +647,7 @@ class Download(PluginTopic):
                                 logger.debug(
                                     f"[{self.provider} response] Retry-After: {retry_server_info}"
                                 )
-                        logger.info(retry_info)
+                        logger.debug(retry_info)
                         nb_info.display_html(retry_info)
                         product.next_try = datetime_now
                     elif datetime_now < product.next_try and datetime_now < stop_time:
@@ -668,7 +659,7 @@ class Download(PluginTopic):
                             f"[Retry #{retry_count}] Waiting {wait_seconds}s until next download try"
                             f" for ordered product (retry every {wait}' for {timeout}')"
                         )
-                        logger.debug(not_available_info)
+                        logger.info(not_available_info)
                         # Retry-After info from Response header
                         if hasattr(self, "stream"):
                             retry_server_info = self.stream.headers.get(
@@ -678,7 +669,7 @@ class Download(PluginTopic):
                                 logger.debug(
                                     f"[{self.provider} response] Retry-After: {retry_server_info}"
                                 )
-                        logger.info(retry_info)
+                        logger.debug(retry_info)
                         nb_info.display_html(retry_info)
                         sleep(wait_seconds)
                     elif datetime_now >= stop_time and timeout > 0:

eodag/plugins/download/creodias_s3.py

@@ -50,7 +50,7 @@ class CreodiasS3Download(AwsDownload):
 
         s3_session = boto3.session.Session(**auth_dict)
         s3_resource = s3_session.resource(
-            "s3", endpoint_url=getattr(self.config, "base_uri", None)
+            "s3", endpoint_url=getattr(self.config, "s3_endpoint", None)
         )
         objects = s3_resource.Bucket(bucket_name).objects.filter()
         list(objects.filter(Prefix=prefix).limit(1))