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

eodag/plugins/apis/base.py

@@ -17,196 +17,39 @@
 # limitations under the License.
 from __future__ import annotations
 
-import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+from eodag.plugins.download.base import Download
+from eodag.plugins.search.base import Search
 
-from pydantic.fields import Field, FieldInfo
 
-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, ProgressCallback
-
-from eodag.plugins.base import PluginTopic
-from eodag.utils import (
-    DEFAULT_DOWNLOAD_TIMEOUT,
-    DEFAULT_DOWNLOAD_WAIT,
-    DEFAULT_ITEMS_PER_PAGE,
-    DEFAULT_PAGE,
-    Annotated,
-    deepcopy,
-)
-
-logger = logging.getLogger("eodag.apis.base")
-
-
-class Api(PluginTopic):
+class Api(Search, Download):
     """Plugins API Base plugin
 
-    An Api plugin has three download methods that it must implement:
+    An Api plugin inherit the methods from Search and Download plugins.
 
+    There are three methods that it must implement:
     - ``query``: search for products
     - ``download``: download a single :class:`~eodag.api.product._product.EOProduct`
     - ``download_all``: download multiple products from a :class:`~eodag.api.search_result.SearchResult`
 
     The download methods 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
       product's file/directory. If the *record* file only is found, it must be deleted
       (it certainly indicates that the download didn't complete)
     """
-
-    def clear(self) -> None:
-        """Method used to clear a search context between two searches."""
-        pass
-
-    def query(
-        self,
-        product_type: Optional[str] = None,
-        items_per_page: int = DEFAULT_ITEMS_PER_PAGE,
-        page: int = DEFAULT_PAGE,
-        count: bool = True,
-        **kwargs: Any,
-    ) -> Tuple[List[EOProduct], Optional[int]]:
-        """Implementation of how the products must be searched goes here.
-
-        This method must return a tuple with (1) a list of EOProduct instances (see eodag.api.product module)
-        which will be processed by a Download plugin (2) and the total number of products matching
-        the search criteria. If ``count`` is False, the second element returned must be ``None``.
-        """
-        raise NotImplementedError("A Api plugin must implement a method named query")
-
-    def discover_product_types(self) -> Optional[Dict[str, Any]]:
-        """Fetch product types list from provider using `discover_product_types` conf"""
-        return None
-
-    def discover_queryables(
-        self, **kwargs: Any
-    ) -> Optional[Dict[str, Annotated[Any, FieldInfo]]]:
-        """Fetch queryables list from provider using `discover_queryables` conf
-
-        :param kwargs: additional filters for queryables (`productType` and other search
-                       arguments)
-        :type kwargs: Any
-        :returns: fetched queryable parameters dict
-        :rtype: Optional[Dict[str, Annotated[Any, FieldInfo]]]
-        """
-        return None
-
-    def get_defaults_as_queryables(
-        self, product_type: str
-    ) -> Dict[str, Annotated[Any, FieldInfo]]:
-        """
-        Return given product type defaut settings as queryables
-
-        :param product_type: given product type
-        :type product_type: str
-        :returns: queryable parameters dict
-        :rtype: Dict[str, Annotated[Any, FieldInfo]]
-        """
-        defaults = deepcopy(self.config.products.get(product_type, {}))
-        defaults.pop("metadata_mapping", None)
-
-        queryables = {}
-        for parameter, value in defaults.items():
-            queryables[parameter] = Annotated[type(value), Field(default=value)]
-        return queryables
-
-    def download(
-        self,
-        product: EOProduct,
-        auth: Optional[PluginConfig] = None,
-        progress_callback: Optional[ProgressCallback] = None,
-        wait: int = DEFAULT_DOWNLOAD_WAIT,
-        timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
-        **kwargs: Any,
-    ) -> Optional[str]:
-        """
-        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 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)
-                        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(
-            "An Api plugin must implement a method named download"
-        )
-
-    def download_all(
-        self,
-        products: SearchResult,
-        auth: Optional[PluginConfig] = None,
-        downloaded_callback: Optional[DownloadedCallback] = None,
-        progress_callback: Optional[ProgressCallback] = None,
-        wait: int = DEFAULT_DOWNLOAD_WAIT,
-        timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
-        **kwargs: Any,
-    ) -> List[str]:
-        """
-        Base download_all method.
-
-        :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 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)
-                        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
-        """
-        raise NotImplementedError(
-            "A Api plugin must implement a method named download_all"
-        )

eodag/plugins/apis/ecmwf.py

@@ -18,42 +18,47 @@
 from __future__ import annotations
 
 import logging
-from datetime import datetime
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+import os
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING
 
 import geojson
 from ecmwfapi import ECMWFDataServer, ECMWFService
 from ecmwfapi.api import APIException, Connection, get_apikey_values
 
 from eodag.plugins.apis.base import Api
-from eodag.plugins.download.base import Download
+from eodag.plugins.search import PreparedSearch
 from eodag.plugins.search.base import Search
 from eodag.plugins.search.build_search_result import BuildPostSearchResult
-from eodag.rest.stac import DEFAULT_MISSION_START_DATE
 from eodag.utils import (
     DEFAULT_DOWNLOAD_TIMEOUT,
     DEFAULT_DOWNLOAD_WAIT,
-    DEFAULT_ITEMS_PER_PAGE,
-    DEFAULT_PAGE,
+    DEFAULT_MISSION_START_DATE,
     get_geometry_from_various,
     path_to_uri,
+    sanitize,
     urlsplit,
 )
 from eodag.utils.exceptions import AuthenticationError, DownloadError
 from eodag.utils.logging import get_logging_verbose
 
 if TYPE_CHECKING:
+    from typing import Any, Dict, List, Optional, Tuple, Union
+
+    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, ProgressCallback
+    from eodag.types.download_args import DownloadConf
+    from eodag.utils import DownloadedCallback, ProgressCallback, Unpack
 
 logger = logging.getLogger("eodag.apis.ecmwf")
 
 ECMWF_MARS_KNOWN_FORMATS = {"grib": "grib", "netcdf": "nc"}
 
 
-class EcmwfApi(Download, Api, BuildPostSearchResult):
+class EcmwfApi(Api, BuildPostSearchResult):
     """A plugin that enables to build download-request and download data on ECMWF MARS.
 
     Builds a single ready-to-download :class:`~eodag.api.product._product.EOProduct`
@@ -84,10 +89,7 @@ class EcmwfApi(Download, Api, BuildPostSearchResult):
 
     def query(
         self,
-        product_type: Optional[str] = None,
-        items_per_page: int = DEFAULT_ITEMS_PER_PAGE,
-        page: int = DEFAULT_PAGE,
-        count: bool = True,
+        prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
     ) -> Tuple[List[EOProduct], Optional[int]]:
         """Build ready-to-download SearchResult"""
@@ -112,7 +114,7 @@ class EcmwfApi(Download, Api, BuildPostSearchResult):
         if "completionTimeFromAscendingNode" not in kwargs:
             kwargs["completionTimeFromAscendingNode"] = getattr(
                 self.config, "product_type_config", {}
-            ).get("missionEndDate", None) or datetime.utcnow().isoformat(
+            ).get("missionEndDate", None) or datetime.now(timezone.utc).isoformat(
                 timespec="seconds"
             )
 
@@ -120,15 +122,12 @@ class EcmwfApi(Download, Api, BuildPostSearchResult):
         if "geometry" in kwargs:
             kwargs["geometry"] = get_geometry_from_various(geometry=kwargs["geometry"])
 
-        return BuildPostSearchResult.query(
-            self, items_per_page=items_per_page, page=page, count=count, **kwargs
-        )
+        return BuildPostSearchResult.query(self, prep, **kwargs)
 
     def authenticate(self) -> Dict[str, Optional[str]]:
         """Check credentials and returns information needed for auth
 
         :returns: {key, url, email} dictionary
-        :rtype: dict
         :raises: :class:`~eodag.utils.exceptions.AuthenticationError`
         """
         # Get credentials from eodag or using ecmwf conf
@@ -156,21 +155,23 @@ class EcmwfApi(Download, Api, BuildPostSearchResult):
     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: Any,
+        **kwargs: Unpack[DownloadConf],
     ) -> Optional[str]:
         """Download data from ECMWF MARS"""
         product_format = product.properties.get("format", "grib")
         product_extension = ECMWF_MARS_KNOWN_FORMATS.get(product_format, product_format)
+        kwargs["output_extension"] = kwargs.get(
+            "output_extension", f".{product_extension}"
+        )
 
         # Prepare download
         fs_path, record_filename = self._prepare_download(
             product,
             progress_callback=progress_callback,
-            outputs_extension=f".{product_extension}",
             **kwargs,
         )
 
@@ -179,6 +180,13 @@ class EcmwfApi(Download, Api, BuildPostSearchResult):
                 product.location = path_to_uri(fs_path)
             return fs_path
 
+        new_fs_path = os.path.join(
+            os.path.dirname(fs_path), sanitize(product.properties["title"])
+        )
+        if not os.path.isdir(new_fs_path):
+            os.makedirs(new_fs_path)
+        fs_path = os.path.join(new_fs_path, os.path.basename(fs_path))
+
         # get download request dict from product.location/downloadLink url query string
         # separate url & parameters
         download_request = geojson.loads(urlsplit(product.location).query)
@@ -222,13 +230,12 @@ class EcmwfApi(Download, Api, BuildPostSearchResult):
             fh.write(product.properties["downloadLink"])
         logger.debug("Download recorded in %s", record_filename)
 
-        # do not try to extract or delete grib/netcdf
+        # do not try to extract a directory
         kwargs["extract"] = False
 
         product_path = self._finalize(
-            fs_path,
+            new_fs_path,
             progress_callback=progress_callback,
-            outputs_extension=f".{product_extension}",
             **kwargs,
         )
         product.location = path_to_uri(product_path)
@@ -237,12 +244,12 @@ class EcmwfApi(Download, Api, BuildPostSearchResult):
     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: Any,
+        **kwargs: Unpack[DownloadConf],
     ) -> List[str]:
         """
         Download all using parent (base plugin) method
@@ -256,3 +263,7 @@ class EcmwfApi(Download, Api, BuildPostSearchResult):
             timeout=timeout,
             **kwargs,
         )
+
+    def clear(self) -> None:
+        """Clear search context"""
+        pass

eodag/plugins/apis/usgs.py

@@ -18,10 +18,11 @@
 from __future__ import annotations
 
 import logging
+import os
 import shutil
 import tarfile
 import zipfile
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, cast
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union, cast
 
 import requests
 from jsonpath_ng.ext import parse
@@ -35,7 +36,7 @@ from eodag.api.product.metadata_mapping import (
     properties_from_json,
 )
 from eodag.plugins.apis.base import Api
-from eodag.plugins.download.base import Download
+from eodag.plugins.search import PreparedSearch
 from eodag.utils import (
     DEFAULT_DOWNLOAD_TIMEOUT,
     DEFAULT_DOWNLOAD_WAIT,
@@ -52,17 +53,21 @@ from eodag.utils.exceptions import (
     NoMatchingProductType,
     NotAvailableError,
     RequestError,
+    ValidationError,
 )
 
 if TYPE_CHECKING:
+    from requests.auth import AuthBase
+
     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.apis.usgs")
 
 
-class UsgsApi(Download, Api):
+class UsgsApi(Api):
     """A plugin that enables to query and download data on the USGS catalogues"""
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
@@ -71,7 +76,7 @@ class UsgsApi(Download, Api):
         # Same method as in base.py, Search.__init__()
         # Prepare the metadata mapping
         # Do a shallow copy, the structure is flat enough for this to be sufficient
-        metas = DEFAULT_METADATA_MAPPING.copy()
+        metas: Dict[str, Any] = DEFAULT_METADATA_MAPPING.copy()
         # Update the defaults with the mapping value. This will add any new key
         # added by the provider mapping that is not in the default metadata.
         metas.update(self.config.metadata_mapping)
@@ -98,30 +103,39 @@ class UsgsApi(Download, Api):
             except USGSAuthExpiredError:
                 api.logout()
                 continue
-            except USGSError:
-                raise AuthenticationError(
-                    "Please check your USGS credentials."
-                ) from None
+            except USGSError as e:
+                if i == 0:
+                    # `.usgs` API file key might be obsolete
+                    # Remove it and try again
+                    os.remove(api.TMPFILE)
+                    continue
+                raise AuthenticationError("Please check your USGS credentials.") from e
 
     def query(
         self,
-        product_type: Optional[str] = None,
-        items_per_page: int = DEFAULT_ITEMS_PER_PAGE,
-        page: int = DEFAULT_PAGE,
-        count: bool = True,
+        prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
     ) -> Tuple[List[EOProduct], Optional[int]]:
         """Search for data on USGS catalogues"""
+        page = prep.page if prep.page is not None else DEFAULT_PAGE
+        items_per_page = (
+            prep.items_per_page
+            if prep.items_per_page is not None
+            else DEFAULT_ITEMS_PER_PAGE
+        )
         product_type = kwargs.get("productType")
         if product_type is None:
             raise NoMatchingProductType(
                 "Cannot search on USGS without productType specified"
             )
+        if kwargs.get("sort_by"):
+            raise ValidationError("USGS does not support sorting feature")
 
         self.authenticate()
 
         product_type_def_params = self.config.products.get(  # type: ignore
-            product_type, self.config.products[GENERIC_PRODUCT_TYPE]  # type: ignore
+            product_type,
+            self.config.products[GENERIC_PRODUCT_TYPE],  # type: ignore
         )
         usgs_dataset = format_dict_items(product_type_def_params, **kwargs)["dataset"]
         start_date = kwargs.pop("startTimeFromAscendingNode", None)
@@ -159,11 +173,39 @@ class UsgsApi(Download, Api):
                 max_results=items_per_page,
                 starting_number=(1 + (page - 1) * items_per_page),
             )
-            logger.info(
-                f"Sending search request for {usgs_dataset} with {api_search_kwargs}"
-            )
 
-            results = api.scene_search(usgs_dataset, **api_search_kwargs)
+            # search by id
+            if searched_id := kwargs.get("id"):
+                dataset_filters = api.dataset_filters(usgs_dataset)
+                # ip pattern set as parameter queryable (first element of param conf list)
+                id_pattern = self.config.metadata_mapping["id"][0]
+                # loop on matching dataset_filters until one returns expected results
+                for dataset_filter in dataset_filters["data"]:
+                    if id_pattern in dataset_filter["searchSql"]:
+                        logger.debug(
+                            f"Try using {dataset_filter['searchSql']} dataset filter to search by id on {usgs_dataset}"
+                        )
+                        full_api_search_kwargs = {
+                            "where": {
+                                "filter_id": dataset_filter["id"],
+                                "value": searched_id,
+                            },
+                            **api_search_kwargs,
+                        }
+                        logger.info(
+                            f"Sending search request for {usgs_dataset} with {full_api_search_kwargs}"
+                        )
+                        results = api.scene_search(
+                            usgs_dataset, **full_api_search_kwargs
+                        )
+                        if len(results["data"]["results"]) == 1:
+                            # search by id using this dataset_filter succeeded
+                            break
+            else:
+                logger.info(
+                    f"Sending search request for {usgs_dataset} with {api_search_kwargs}"
+                )
+                results = api.scene_search(usgs_dataset, **api_search_kwargs)
 
             # update results with storage info from download_options()
             results_by_entity_id = {
@@ -214,7 +256,7 @@ class UsgsApi(Download, Api):
                 f"Product type {usgs_dataset} may not exist on USGS EE catalog"
             )
             api.logout()
-            raise RequestError(e)
+            raise RequestError.from_error(e) from e
 
         api.logout()
 
@@ -230,11 +272,11 @@ class UsgsApi(Download, Api):
     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: Any,
+        **kwargs: Unpack[DownloadConf],
     ) -> Optional[str]:
         """Download data from USGS catalogues"""
 
@@ -244,17 +286,17 @@ class UsgsApi(Download, Api):
             )
             progress_callback = ProgressCallback(disable=True)
 
-        outputs_extension = cast(
+        output_extension = cast(
             str,
             self.config.products.get(  # type: ignore
                 product.product_type, self.config.products[GENERIC_PRODUCT_TYPE]  # type: ignore
-            ).get("outputs_extension", ".tar.gz"),
+            ).get("output_extension", ".tar.gz"),
         )
+        kwargs["output_extension"] = kwargs.get("output_extension", output_extension)
 
         fs_path, record_filename = self._prepare_download(
             product,
             progress_callback=progress_callback,
-            outputs_extension=outputs_extension,
             **kwargs,
         )
         if not fs_path or not record_filename:
@@ -308,13 +350,14 @@ class UsgsApi(Download, Api):
         req_url = req_urls[0]
         progress_callback.reset()
         logger.debug(f"Downloading {req_url}")
+        ssl_verify = getattr(self.config, "ssl_verify", True)
 
         @self._download_retry(product, wait, timeout)
         def download_request(
             product: EOProduct,
             fs_path: str,
             progress_callback: ProgressCallback,
-            **kwargs: Any,
+            **kwargs: Unpack[DownloadConf],
         ) -> None:
             try:
                 with requests.get(
@@ -322,6 +365,7 @@ class UsgsApi(Download, Api):
                     stream=True,
                     headers=USER_AGENT,
                     timeout=wait * 60,
+                    verify=ssl_verify,
                 ) as stream:
                     try:
                         stream.raise_for_status()
@@ -334,7 +378,9 @@ class UsgsApi(Download, Api):
                             error_message = str(e)
                         raise NotAvailableError(error_message)
                     else:
-                        stream_size = int(stream.headers.get("content-length", 0))
+                        stream_size = (
+                            int(stream.headers.get("content-length", 0)) or None
+                        )
                         progress_callback.reset(total=stream_size)
                         with open(fs_path, "wb") as fhandle:
                             for chunk in stream.iter_content(chunk_size=64 * 1024):
@@ -357,13 +403,12 @@ class UsgsApi(Download, Api):
         api.logout()
 
         # Check downloaded file format
-        if (outputs_extension == ".tar.gz" and tarfile.is_tarfile(fs_path)) or (
-            outputs_extension == ".zip" and zipfile.is_zipfile(fs_path)
-        ):
+        if (
+            kwargs["output_extension"] == ".tar.gz" and tarfile.is_tarfile(fs_path)
+        ) or (kwargs["output_extension"] == ".zip" and zipfile.is_zipfile(fs_path)):
             product_path = self._finalize(
                 fs_path,
                 progress_callback=progress_callback,
-                outputs_extension=outputs_extension,
                 **kwargs,
             )
             product.location = path_to_uri(product_path)
@@ -372,7 +417,7 @@ class UsgsApi(Download, Api):
             logger.info(
                 "Downloaded product detected as a tar File, but was was expected to be a zip file"
             )
-            new_fs_path = fs_path[: fs_path.index(outputs_extension)] + ".tar.gz"
+            new_fs_path = fs_path[: fs_path.index(output_extension)] + ".tar.gz"
             shutil.move(fs_path, new_fs_path)
             product.location = path_to_uri(new_fs_path)
             return new_fs_path
@@ -380,7 +425,7 @@ class UsgsApi(Download, Api):
             logger.info(
                 "Downloaded product detected as a zip File, but was was expected to be a tar file"
             )
-            new_fs_path = fs_path[: fs_path.index(outputs_extension)] + ".zip"
+            new_fs_path = fs_path[: fs_path.index(output_extension)] + ".zip"
             shutil.move(fs_path, new_fs_path)
             product.location = path_to_uri(new_fs_path)
             return new_fs_path
@@ -388,7 +433,7 @@ class UsgsApi(Download, Api):
             logger.warning(
                 "Downloaded product is not a tar or a zip File. Please check its file type before using it"
             )
-            new_fs_path = fs_path[: fs_path.index(outputs_extension)]
+            new_fs_path = fs_path[: fs_path.index(output_extension)]
             shutil.move(fs_path, new_fs_path)
             product.location = path_to_uri(new_fs_path)
             return new_fs_path
@@ -396,12 +441,12 @@ class UsgsApi(Download, Api):
     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: Any,
+        **kwargs: Unpack[DownloadConf],
     ) -> List[str]:
         """
         Download all using parent (base plugin) method