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

eodag/plugins/authentication/token.py

@@ -28,7 +28,13 @@ from requests.auth import AuthBase
 from urllib3 import Retry
 
 from eodag.plugins.authentication.base import Authentication
-from eodag.utils import HTTP_REQ_TIMEOUT, USER_AGENT
+from eodag.utils import (
+    HTTP_REQ_TIMEOUT,
+    REQ_RETRY_BACKOFF_FACTOR,
+    REQ_RETRY_STATUS_FORCELIST,
+    REQ_RETRY_TOTAL,
+    USER_AGENT,
+)
 from eodag.utils.exceptions import AuthenticationError, MisconfiguredError, TimeOutError
 
 if TYPE_CHECKING:
@@ -41,7 +47,45 @@ logger = logging.getLogger("eodag.authentication.token")
 
 
 class TokenAuth(Authentication):
-    """TokenAuth authentication plugin"""
+    """TokenAuth authentication plugin - fetches a token which is added to search/download requests.
+
+    When using headers, if only :attr:`~eodag.config.PluginConfig.headers` is given, it will be used for both token
+    retrieve and authentication. If :attr:`~eodag.config.PluginConfig.retrieve_headers` is given, it will be used for
+    token retrieve only. If both are given, :attr:`~eodag.config.PluginConfig.retrieve_headers` will be used for token
+    retrieve and :attr:`~eodag.config.PluginConfig.headers` for authentication.
+
+    :param provider: provider name
+    :param config: Authentication plugin configuration:
+
+        * :attr:`~eodag.config.PluginConfig.type` (``str``) (**mandatory**): TokenAuth
+        * :attr:`~eodag.config.PluginConfig.auth_uri` (``str``) (**mandatory**): url used to fetch
+          the access token with user/password
+        * :attr:`~eodag.config.PluginConfig.headers` (``Dict[str, str]``): Dictionary containing all
+          keys/value pairs that should be added to the headers
+        * :attr:`~eodag.config.PluginConfig.retrieve_headers` (``Dict[str, str]``): Dictionary containing all
+          keys/value pairs that should be added to the headers for token retrieve only
+        * :attr:`~eodag.config.PluginConfig.refresh_uri` (``str``) : url used to fetch the
+          access token with a refresh token
+        * :attr:`~eodag.config.PluginConfig.token_type` (``str``): type of the token (``json``
+          or ``text``); default: ``text``
+        * :attr:`~eodag.config.PluginConfig.token_key` (``str``): (mandatory if token_type=json)
+          key to get the access token in the response to the token request
+        * :attr:`~eodag.config.PluginConfig.refresh_token_key` (``str``): key to get the refresh
+          token in the response to the token request
+        * :attr:`~eodag.config.PluginConfig.ssl_verify` (``bool``): if the ssl certificates
+          should be verified in the requests; default: ``True``
+        * :attr:`~eodag.config.PluginConfig.auth_error_code` (``int``): which error code is
+          returned in case of an authentication error
+        * :attr:`~eodag.config.PluginConfig.req_data` (``Dict[str, Any]``): if the credentials
+          should be sent as data in the post request, the json structure can be given in this parameter
+        * :attr:`~eodag.config.PluginConfig.retry_total` (``int``): :class:`urllib3.util.Retry` ``total`` parameter,
+          total number of retries to allow; default: ``3``
+        * :attr:`~eodag.config.PluginConfig.retry_backoff_factor` (``int``): :class:`urllib3.util.Retry`
+          ``backoff_factor`` parameter, backoff factor to apply between attempts after the second try; default: ``2``
+        * :attr:`~eodag.config.PluginConfig.retry_status_forcelist` (``List[int]``): :class:`urllib3.util.Retry`
+          ``status_forcelist`` parameter, list of integer HTTP status codes that we should force a retry on; default:
+          ``[401, 429, 500, 502, 503, 504]``
+    """
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
         super(TokenAuth, self).__init__(provider, config)
@@ -56,11 +100,29 @@ class TokenAuth(Authentication):
             self.config.auth_uri = self.config.auth_uri.format(
                 **self.config.credentials
             )
-            # format headers if needed (and accepts {token} to be formatted later)
+
+            # Format headers if needed with values from the credentials. Note:
+            # if only 'headers' is given, it will be used for both token retrieve and authentication.
+            # if 'retrieve_headers' is given, it will be used for token retrieve only.
+            # if both are given, 'retrieve_headers' will be used for token retrieve and 'headers' for authentication.
+
+            # If the authentication headers are undefined or None: use an empty dict.
+            # And don't format '{token}' now, it will be done later.
+            raw_headers = getattr(self.config, "headers", None) or {}
             self.config.headers = {
                 header: value.format(**{"token": "{token}", **self.config.credentials})
-                for header, value in getattr(self.config, "headers", {}).items()
+                for header, value in raw_headers.items()
             }
+
+            # If the retrieve headers are undefined, their attribute must not be set in self.config.
+            # If they are defined but empty, use an empty dict instead of None.
+            if hasattr(self.config, "retrieve_headers"):
+                raw_retrieve_headers = self.config.retrieve_headers or {}
+                self.config.retrieve_headers = {
+                    header: value.format(**self.config.credentials)
+                    for header, value in raw_retrieve_headers.items()
+                }
+
         except KeyError as e:
             raise MisconfiguredError(
                 f"Missing credentials inputs for provider {self.provider}: {e}"
@@ -89,14 +151,15 @@ class TokenAuth(Authentication):
                 and e.response.status_code in auth_errors
             ):
                 raise AuthenticationError(
-                    f"HTTP Error {e.response.status_code} returned, {response_text}\n"
-                    f"Please check your credentials for {self.provider}"
-                )
+                    f"Please check your credentials for {self.provider}.",
+                    f"HTTP Error {e.response.status_code} returned.",
+                    response_text,
+                ) from e
             # other error
             else:
                 raise AuthenticationError(
-                    f"Could no get authentication token: {str(e)}, {response_text}"
-                )
+                    "Could no get authentication token", str(e), response_text
+                ) from e
         else:
             if getattr(self.config, "token_type", "text") == "json":
                 token = response.json()[self.config.token_key]
@@ -116,16 +179,29 @@ class TokenAuth(Authentication):
         self,
         session: requests.Session,
     ) -> requests.Response:
+        retry_total = getattr(self.config, "retry_total", REQ_RETRY_TOTAL)
+        retry_backoff_factor = getattr(
+            self.config, "retry_backoff_factor", REQ_RETRY_BACKOFF_FACTOR
+        )
+        retry_status_forcelist = getattr(
+            self.config, "retry_status_forcelist", REQ_RETRY_STATUS_FORCELIST
+        )
+
         retries = Retry(
-            total=3,
-            backoff_factor=2,
-            status_forcelist=[401, 429, 500, 502, 503, 504],
+            total=retry_total,
+            backoff_factor=retry_backoff_factor,
+            status_forcelist=retry_status_forcelist,
         )
 
+        # Use the headers for retrieval if defined, else the headers for authentication
+        try:
+            headers = self.config.retrieve_headers
+        except AttributeError:
+            headers = self.config.headers
+
         # append headers to req if some are specified in config
-        req_kwargs: Dict[str, Any] = {
-            "headers": dict(self.config.headers, **USER_AGENT)
-        }
+        req_kwargs: Dict[str, Any] = {"headers": dict(headers, **USER_AGENT)}
+        ssl_verify = getattr(self.config, "ssl_verify", True)
 
         if self.refresh_token:
             logger.debug("fetching access token with refresh token")
@@ -135,6 +211,7 @@ class TokenAuth(Authentication):
                     self.config.refresh_uri,
                     data={"refresh_token": self.refresh_token},
                     timeout=HTTP_REQ_TIMEOUT,
+                    verify=ssl_verify,
                     **req_kwargs,
                 )
                 response.raise_for_status()
@@ -170,6 +247,7 @@ class TokenAuth(Authentication):
             method=method,
             url=self.config.auth_uri,
             timeout=HTTP_REQ_TIMEOUT,
+            verify=ssl_verify,
             **req_kwargs,
         )
 

eodag/plugins/authentication/token_exchange.py

@@ -38,25 +38,23 @@ class OIDCTokenExchangeAuth(Authentication):
     """Token exchange implementation using
         :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth` token as subject.
 
-    The configuration keys of this plugin are as follows (they have no defaults)::
+    :param provider: provider name
+    :param config: Authentication plugin configuration:
+
+        * :attr:`~eodag.config.PluginConfig.subject` (``Dict[str, Any]``) (**mandatory**):
+          The full :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth` plugin
+          configuration used to retrieve subject token
+        * :attr:`~eodag.config.PluginConfig.subject_issuer` (``str``) (**mandatory**): Identifies
+          the issuer of the subject_token
+        * :attr:`~eodag.config.PluginConfig.token_uri` (``str``) (**mandatory**): The url to
+          query to get the authorized token
+        * :attr:`~eodag.config.PluginConfig.client_id` (``str``) (**mandatory**): The OIDC
+          provider's client ID of the eodag provider
+        * :attr:`~eodag.config.PluginConfig.audience` (``str``) (**mandatory**): This parameter
+          specifies the target client you want the new token minted for.
+        * :attr:`~eodag.config.PluginConfig.token_key` (``str``) (**mandatory**): The key
+          pointing to the token in the json response to the POST request to the token server
 
-        # (mandatory) The full OIDCAuthorizationCodeFlowAuth plugin configuration used to retrieve subject token
-        subject:
-
-        # (mandatory) Identifies the issuer of the subject_token
-        subject_issuer:
-
-        # (mandatory) The url to query to get the authorized token
-        token_uri:
-
-        # (mandatory) The OIDC provider's client ID of the eodag provider
-        client_id:
-
-        # (mandatory) This parameter specifies the target client you want the new token minted for.
-        audience:
-
-        # (mandatory) The key pointing to the token in the json response to the POST request to the token server
-        token_key:
     """
 
     GRANT_TYPE = "urn:ietf:params:oauth:grant-type:token-exchange"
@@ -71,7 +69,7 @@ class OIDCTokenExchangeAuth(Authentication):
     ]
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
-        super(OIDCTokenExchangeAuth, self).__init__(provider, config)
+        super().__init__(provider, config)
         for required_key in self.REQUIRED_KEYS:
             if getattr(self.config, required_key, None) is None:
                 raise MisconfiguredError(
@@ -100,12 +98,14 @@ class OIDCTokenExchangeAuth(Authentication):
             "audience": self.config.audience,
         }
         logger.debug("Getting target auth token")
+        ssl_verify = getattr(self.config, "ssl_verify", True)
         try:
             auth_response = self.subject.session.post(
                 self.config.token_uri,
                 data=auth_data,
                 headers=USER_AGENT,
                 timeout=HTTP_REQ_TIMEOUT,
+                verify=ssl_verify,
             )
             auth_response.raise_for_status()
         except requests.exceptions.Timeout as exc:

eodag/plugins/crunch/base.py

@@ -27,7 +27,10 @@ if TYPE_CHECKING:
 
 
 class Crunch(PluginTopic):
-    """Base cruncher"""
+    """Base cruncher
+
+    :param config: Crunch configuration
+    """
 
     def __init__(self, config: Optional[Dict[str, Any]]) -> None:
         self.config = PluginConfig()

eodag/plugins/crunch/filter_date.py

@@ -37,10 +37,13 @@ logger = logging.getLogger("eodag.crunch.date")
 class FilterDate(Crunch):
     """FilterDate cruncher: filter products by date
 
+    Allows to filter out products that are older than a start date (optional) or more recent than an end date
+    (optional).
+
     :param config: Crunch configuration, may contain :
 
-                   - `start`: (optional) start sensing time in iso format
-                   - `end`: (optional) end sensing time in iso format
+        * ``start`` (``str``): start sensing time in iso format
+        * ``end`` (``str``): end sensing time in iso format
     """
 
     @staticmethod

eodag/plugins/crunch/filter_latest_intersect.py

@@ -39,7 +39,8 @@ logger = logging.getLogger("eodag.crunch.latest_intersect")
 class FilterLatestIntersect(Crunch):
     """FilterLatestIntersect cruncher
 
-    Filter latest products (the ones with a the highest start date) that intersect search extent
+    Filter latest products (the ones with a the highest start date) that intersect search extent;
+    The configuration for this plugin is an empty dict
     """
 
     @staticmethod
@@ -53,14 +54,14 @@ class FilterLatestIntersect(Crunch):
         return dateutil.parser.parse(start_date)
 
     def proceed(
-        self, products: List[EOProduct], **search_params: Any
+        self, products: List[EOProduct], **search_params: Dict[str, Any]
     ) -> List[EOProduct]:
         """Execute crunch:
         Filter latest products (the ones with a the highest start date) that intersect search extent.
 
         :param products: A list of products resulting from a search
-        :param search_params: Search criteria that must contain `geometry` (dict)
-                              or search `geom` (:class:`shapely.geometry.base.BaseGeometry`) argument will be used
+        :param search_params: Search criteria that must contain ``geometry`` or ``geom`` parameters having value of
+                              type :class:`shapely.geometry.base.BaseGeometry` or ``Dict[str, Any]``
         :returns: The filtered products
         """
         logger.debug("Start filtering for latest products")

eodag/plugins/crunch/filter_latest_tpl_name.py

@@ -37,7 +37,7 @@ class FilterLatestByName(Crunch):
 
     :param config: Crunch configuration, must contain :
 
-                   - `name_pattern` : product name pattern
+        * ``name_pattern`` (``str``) (**mandatory**): product name pattern
     """
 
     NAME_PATTERN_CONSTRAINT = re.compile(r"\(\?P<tileid>\\d\{6\}\)")

eodag/plugins/crunch/filter_overlap.py

@@ -40,14 +40,12 @@ class FilterOverlap(Crunch):
 
     Filter products, retaining only those that are overlapping with the search_extent
 
-    :param config: Crunch configuration, may contain :
+    :param config: Crunch configuration may contain the following parameters which are mutually exclusive:
 
-                   - `minimum_overlap` : minimal overlap percentage
-                   - `contains` : True if product geometry contains the search area
-                   - `intersects` : True if product geometry intersects the search area
-                   - `within` : True if product geometry is within the search area
-
-                   These configuration parameters are mutually exclusive.
+        * ``minimum_overlap`` (``Union[float, str]``): minimal overlap percentage; default: ``"0"``
+        * ``contains`` (``bool``): ``True`` if product geometry contains the search area; default: ``False``
+        * ``intersects`` (``bool``): ``True`` if product geometry intersects the search area; default: ``False``
+        * ``within`` (``bool``): ``True`` if product geometry is within the search area; default: ``False``
     """
 
     def proceed(

eodag/plugins/crunch/filter_property.py

@@ -34,10 +34,11 @@ class FilterProperty(Crunch):
 
     Filter products, retaining only those whose property match criteria
 
-    :param config: Crunch configuration, should contain :
+    :param config: Crunch configuration, must contain :
 
-                   - `property=value` : property key from product.properties, associated to its filter value
-                   - `operator` : (optional) Operator used for filtering (one of `lt,le,eq,ne,ge,gt`). Default is `eq`
+        * ``<property>`` ``(Any)`` (**mandatory**): property key from ``product.properties``, associated to its filter
+          value
+        * ``operator`` (``str``): Operator used for filtering (one of ``lt,le,eq,ne,ge,gt``). Default is ``eq``
     """
 
     def proceed(
@@ -77,10 +78,9 @@ class FilterProperty(Crunch):
         for product in products:
             if property_key not in product.properties.keys():
                 logger.warning(
-                    "%s not found in product.properties, filtering disabled.",
-                    property_key,
+                    f"{property_key} not found in {product}.properties, product skipped",
                 )
-                return products
+                continue
             if operator_method(product.properties[property_key], property_value):
                 add_to_filtered(product)
 

eodag/plugins/download/aws.py

@@ -70,6 +70,7 @@ from eodag.utils.exceptions import (
     AuthenticationError,
     DownloadError,
     MisconfiguredError,
+    NoMatchingProductType,
     NotAvailableError,
     TimeOutError,
 )
@@ -216,12 +217,28 @@ class AwsDownload(Download):
     :param provider: provider name
     :param config: Download plugin configuration:
 
-        * ``config.base_uri`` (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
+        * :attr:`~eodag.config.PluginConfig.type` (``str``) (**mandatory**): AwsDownload
+        * :attr:`~eodag.config.PluginConfig.base_uri` (``str``) (**mandatory**): s3 endpoint url
+        * :attr:`~eodag.config.PluginConfig.requester_pays` (``bool``): whether download is done
+          from a requester-pays bucket or not; default: ``False``
+        * :attr:`~eodag.config.PluginConfig.flatten_top_dirs` (``bool``): if the directory structure
+          should be flattened; default: ``True``
+        * :attr:`~eodag.config.PluginConfig.ignore_assets` (``bool``): ignore assets and download
+          using ``downloadLink``; default: ``False``
+        * :attr:`~eodag.config.PluginConfig.ssl_verify` (``bool``): if the ssl certificates should
+          be verified in requests; default: ``True``
+        * :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
+          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
+
     """
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
@@ -234,8 +251,8 @@ class AwsDownload(Download):
         product: EOProduct,
         auth: Optional[Union[AuthBase, Dict[str, str]]] = 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.
@@ -465,7 +482,8 @@ class AwsDownload(Download):
         ignore_assets: Optional[bool] = False,
     ) -> 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
@@ -611,19 +629,20 @@ 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(
@@ -631,12 +650,12 @@ class AwsDownload(Download):
         product: EOProduct,
         auth: Optional[Union[AuthBase, Dict[str, str]]] = 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"""
-        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
@@ -649,7 +668,7 @@ class AwsDownload(Download):
                         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.
-        :returns: Dictionnary of :class:`~fastapi.responses.StreamingResponse` keyword-arguments
+        :returns: Dictionary of :class:`~fastapi.responses.StreamingResponse` keyword-arguments
         """
         if progress_callback is None:
             logger.info(
@@ -713,12 +732,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(
@@ -751,7 +770,6 @@ class AwsDownload(Download):
             product_chunk: Any, progress_callback: ProgressCallback
         ) -> Any:
             try:
-
                 chunk_start = 0
                 chunk_end = chunk_start + chunk_size - 1
 
@@ -782,7 +800,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(
@@ -800,8 +817,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 (
@@ -829,7 +845,7 @@ class AwsDownload(Download):
 
         :param bucket_name: Bucket containg objects
         :param prefix: Prefix used to try auth
-        :param auth_dict: Dictionnary containing authentication keys
+        :param auth_dict: Dictionary containing authentication keys
         :returns: The rasterio environement variables
         """
         if self.s3_session is not None:
@@ -857,7 +873,7 @@ class AwsDownload(Download):
         :param bucket_name: Bucket containg objects
         :param prefix: Prefix used to filter objects on auth try
                        (not used to filter returned objects)
-        :param auth_dict: Dictionnary containing authentication keys
+        :param auth_dict: Dictionary containing authentication keys
         :returns: The boto3 authenticated objects
         """
         auth_methods: List[
@@ -901,7 +917,7 @@ class AwsDownload(Download):
         """Auth strategy using no-sign-request"""
 
         s3_resource = boto3.resource(
-            service_name="s3", endpoint_url=getattr(self.config, "base_uri", None)
+            service_name="s3", endpoint_url=getattr(self.config, "s3_endpoint", None)
         )
         s3_resource.meta.client.meta.events.register(
             "choose-signer.s3.*", disable_signing
@@ -919,7 +935,7 @@ class AwsDownload(Download):
             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(
@@ -958,7 +974,7 @@ class AwsDownload(Download):
             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(
@@ -979,7 +995,7 @@ class AwsDownload(Download):
 
         s3_session = boto3.session.Session()
         s3_resource = s3_session.resource(
-            service_name="s3", endpoint_url=getattr(self.config, "base_uri", None)
+            service_name="s3", endpoint_url=getattr(self.config, "s3_endpoint", None)
         )
         if self.requester_pays:
             objects = s3_resource.Bucket(bucket_name).objects.filter(
@@ -1313,8 +1329,8 @@ class AwsDownload(Download):
         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,
+        wait: float = DEFAULT_DOWNLOAD_WAIT,
+        timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
         **kwargs: Unpack[DownloadConf],
     ) -> List[str]:
         """