eodag 3.4.2__py3-none-any.whl → 3.4.3__py3-none-any.whl

eodag/api/core.py

@@ -658,7 +658,7 @@ class EODataAccessGateway:
             discovery_conf = getattr(
                 provider_search_config, "discover_product_types", {}
             )
-            if discovery_conf.get("fetch_url", None):
+            if discovery_conf.get("fetch_url"):
                 providers_discovery_configs_fetchable[
                     provider_to_fetch
                 ] = discovery_conf
@@ -744,7 +744,7 @@ class EODataAccessGateway:
                     user_discovery_conf == default_discovery_conf
                     or user_discovery_conf == default_discovery_conf_parsed
                 ) and (
-                    not default_discovery_conf.get("fetch_url", None)
+                    not default_discovery_conf.get("fetch_url")
                     or "ext_product_types_conf" not in locals()
                     or "ext_product_types_conf" in locals()
                     and (
@@ -856,7 +856,7 @@ class EODataAccessGateway:
                         continue
                     if not getattr(
                         search_plugin_config, "discover_product_types", {}
-                    ).get("fetch_url", None):
+                    ).get("fetch_url"):
                         # conf has been updated and provider product types are no more discoverable
                         continue
                     provider_products_config = (
@@ -980,7 +980,7 @@ class EODataAccessGateway:
         product_types = [
             k
             for k, v in self.product_types_config.items()
-            if v.get("alias", None) == alias_or_id
+            if v.get("alias") == alias_or_id
         ]
 
         if len(product_types) > 1:
@@ -1310,8 +1310,8 @@ class EODataAccessGateway:
         # since it might be modified if the next_page_url mechanism is used by the
         # plugin. (same thing for next_page_query_obj, next_page_query_obj with POST reqs)
         pagination_config = getattr(search_plugin.config, "pagination", {})
-        prev_next_page_url_tpl = pagination_config.get("next_page_url_tpl", None)
-        prev_next_page_query_obj = pagination_config.get("next_page_query_obj", None)
+        prev_next_page_url_tpl = pagination_config.get("next_page_url_tpl")
+        prev_next_page_query_obj = pagination_config.get("next_page_query_obj")
         # Page has to be set to a value even if use_next is True, this is required
         # internally by the search plugin (see collect_search_urls)
         kwargs.update(
@@ -1549,7 +1549,7 @@ class EODataAccessGateway:
         :param kwargs: Search criteria to help finding the right product
         :returns: A search result with one EO product or None at all
         """
-        product_type = kwargs.get("productType", None)
+        product_type = kwargs.get("productType")
         if product_type is not None:
             try:
                 product_type = self.get_product_type_from_alias(product_type)
@@ -1686,7 +1686,7 @@ class EODataAccessGateway:
                        * other criteria compatible with the provider
         :returns: Search plugins list and the prepared kwargs to make a query.
         """
-        product_type = kwargs.get("productType", None)
+        product_type: Optional[str] = kwargs.get("productType")
         if product_type is None:
             try:
                 guesses = self.guess_product_type(**kwargs)
@@ -1706,7 +1706,7 @@ class EODataAccessGateway:
                 # By now, only use the best bet
                 product_type = guesses[0]
             except NoMatchingProductType:
-                queried_id = kwargs.get("id", None)
+                queried_id = kwargs.get("id")
                 if queried_id is None:
                     logger.info(
                         "No product type could be guessed with provided arguments"
@@ -1750,7 +1750,7 @@ class EODataAccessGateway:
             product_type
             not in self._plugins_manager.product_type_to_provider_config_map.keys()
         ):
-            if provider:
+            if provider and product_type:
                 # Try to get specific product type from external provider
                 logger.debug(f"Fetching {provider} to find {product_type} product type")
                 self._fetch_external_product_type(provider, product_type)
@@ -1795,7 +1795,8 @@ class EODataAccessGateway:
         # Add product_types_config to plugin config. This dict contains product
         # type metadata that will also be stored in each product's properties.
         for search_plugin in search_plugins:
-            self._attach_product_type_config(search_plugin, product_type)
+            if product_type is not None:
+                self._attach_product_type_config(search_plugin, product_type)
 
         return search_plugins, kwargs
 

eodag/api/product/_product.py

@@ -143,7 +143,7 @@ class EOProduct:
             and "defaultGeometry" not in properties
         ):
             raise MisconfiguredError(
-                f"No geometry available to build EOProduct(id={properties.get('id', None)}, provider={provider})"
+                f"No geometry available to build EOProduct(id={properties.get('id')}, provider={provider})"
             )
         elif not properties["geometry"] or properties["geometry"] == NOT_AVAILABLE:
             product_geometry = properties.pop("defaultGeometry", DEFAULT_GEOMETRY)
@@ -445,7 +445,7 @@ class EOProduct:
                     }
                 )
 
-        if self.properties.get("quicklook", None) is None:
+        if self.properties.get("quicklook") is None:
             logger.warning(
                 "Missing information to retrieve quicklook for EO product: %s",
                 self.properties["id"],
@@ -555,7 +555,7 @@ class EOProduct:
         return NoDriver()
 
     def _repr_html_(self):
-        thumbnail = self.properties.get("thumbnail", None)
+        thumbnail = self.properties.get("thumbnail")
         thumbnail_html = (
             f"<img src='{thumbnail}' width=100 alt='thumbnail'/>"
             if thumbnail and not thumbnail.startswith("s3")
@@ -576,12 +576,12 @@ class EOProduct:
                         {dict_to_html_table({
                          "provider": self.provider,
                          "product_type": self.product_type,
-                         "properties[&quot;id&quot;]": self.properties.get('id', None),
+                         "properties[&quot;id&quot;]": self.properties.get('id'),
                          "properties[&quot;startTimeFromAscendingNode&quot;]": self.properties.get(
-                             'startTimeFromAscendingNode', None
+                             'startTimeFromAscendingNode'
                          ),
                          "properties[&quot;completionTimeFromAscendingNode&quot;]": self.properties.get(
-                             'completionTimeFromAscendingNode', None
+                             'completionTimeFromAscendingNode'
                          ),
                          }, brackets=False)}
                         <details><summary style='color: grey; margin-top: 10px;'>properties:&ensp;({len(

eodag/api/product/metadata_mapping.py

@@ -424,7 +424,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                 return Polygon(polygon_args)
             elif len(georss) == 1 and "multisurface" in georss[0].tag.lower():
                 # Multipolygon
-                from_proj = getattr(georss[0], "attrib", {}).get("srsName", None)
+                from_proj = getattr(georss[0], "attrib", {}).get("srsName")
                 if from_proj:
                     from_proj = pyproj.CRS(from_proj)
                     to_proj = pyproj.CRS(DEFAULT_PROJ)
@@ -1030,8 +1030,8 @@ def properties_from_json(
     if not discovery_config:
         discovery_config = {}
 
-    discovery_pattern = discovery_config.get("metadata_pattern", None)
-    discovery_path = discovery_config.get("metadata_path", None)
+    discovery_pattern = discovery_config.get("metadata_pattern")
+    discovery_path = discovery_config.get("metadata_path")
     if discovery_pattern and discovery_path:
         discovery_jsonpath = string_to_jsonpath(discovery_path)
         discovered_properties = (
@@ -1215,8 +1215,8 @@ def properties_from_xml(
     # adds missing discovered properties
     if not discovery_config:
         discovery_config = {}
-    discovery_pattern = discovery_config.get("metadata_pattern", None)
-    discovery_path = discovery_config.get("metadata_path", None)
+    discovery_pattern = discovery_config.get("metadata_pattern")
+    discovery_path = discovery_config.get("metadata_path")
     if discovery_pattern and discovery_path:
         discovered_properties = root.xpath(
             discovery_path,
@@ -1524,7 +1524,7 @@ def get_provider_queryable_path(
     :param metadata_mapping: metadata-mapping configuration
     :returns: EODAG configured queryable path or None
     """
-    parameter_conf = metadata_mapping.get(queryable, None)
+    parameter_conf = metadata_mapping.get(queryable)
     if isinstance(parameter_conf, list):
         return parameter_conf[0]
     else:

eodag/config.py

@@ -851,7 +851,7 @@ def override_config_from_env(config: dict[str, Any]) -> None:
         iter_parts = iter(parts)
         env_type = get_type_hints(PluginConfig).get(next(iter_parts, ""), str)
         child_env_type = (
-            get_type_hints(env_type).get(next(iter_parts, ""), None)
+            get_type_hints(env_type).get(next(iter_parts, ""))
             if isclass(env_type)
             else None
         )
@@ -961,7 +961,7 @@ def merge_configs(config: dict[str, Any], other_config: dict[str, Any]) -> None:
     other_config = dict(config, **other_config)
 
     for provider, new_conf in other_config.items():
-        old_conf = config.get(provider, None)
+        old_conf = config.get(provider)
 
         if old_conf:
             # update non-objects values

eodag/plugins/apis/ecmwf.py

@@ -123,16 +123,14 @@ class EcmwfApi(Api, ECMWFSearch):
         # start date
         if "startTimeFromAscendingNode" not in kwargs:
             kwargs["startTimeFromAscendingNode"] = (
-                getattr(self.config, "product_type_config", {}).get(
-                    "missionStartDate", None
-                )
+                getattr(self.config, "product_type_config", {}).get("missionStartDate")
                 or DEFAULT_MISSION_START_DATE
             )
         # end date
         if "completionTimeFromAscendingNode" not in kwargs:
             kwargs["completionTimeFromAscendingNode"] = getattr(
                 self.config, "product_type_config", {}
-            ).get("missionEndDate", None) or datetime.now(timezone.utc).isoformat(
+            ).get("missionEndDate") or datetime.now(timezone.utc).isoformat(
                 timespec="seconds"
             )
 
@@ -149,8 +147,8 @@ class EcmwfApi(Api, ECMWFSearch):
         :raises: :class:`~eodag.utils.exceptions.AuthenticationError`
         """
         # Get credentials from eodag or using ecmwf conf
-        email = getattr(self.config, "credentials", {}).get("username", None)
-        key = getattr(self.config, "credentials", {}).get("password", None)
+        email = getattr(self.config, "credentials", {}).get("username")
+        key = getattr(self.config, "credentials", {}).get("password")
         url = getattr(self.config, "auth_endpoint", None)
         if not all([email, key, url]):
             key, url, email = get_apikey_values()
@@ -295,5 +293,5 @@ class EcmwfApi(Api, ECMWFSearch):
                        arguments)
         :returns: fetched queryable parameters dict
         """
-        product_type = kwargs.get("productType", None)
+        product_type = kwargs.get("productType")
         return self.queryables_from_metadata_mapping(product_type)

eodag/plugins/apis/usgs.py

@@ -241,7 +241,7 @@ class UsgsApi(Api):
             download_options = api.download_options(
                 usgs_dataset, list(results_by_entity_id.keys())
             )
-            if download_options.get("data", None) is not None:
+            if download_options.get("data") is not None:
                 for download_option in download_options["data"]:
                     # update results with available downloadSystem
                     if (

eodag/plugins/authentication/generic.py

@@ -46,7 +46,11 @@ class GenericAuth(Authentication):
         """Authenticate"""
         self.validate_config_credentials()
         method = getattr(self.config, "method", "basic")
-
+        if not all(x in self.config.credentials for x in ["username", "password"]):
+            raise MisconfiguredError(
+                f"Missing credentials for provider {self.provider}",
+                "You must provide 'username' and 'password' in the configuration.",
+            )
         if method == "digest":
             return HTTPDigestAuth(
                 self.config.credentials["username"],

eodag/plugins/authentication/openid_connect.py

@@ -31,7 +31,12 @@ from requests.auth import AuthBase
 
 from eodag.plugins.authentication import Authentication
 from eodag.utils import HTTP_REQ_TIMEOUT, USER_AGENT, parse_qs, repeatfunc, urlparse
-from eodag.utils.exceptions import AuthenticationError, MisconfiguredError, TimeOutError
+from eodag.utils.exceptions import (
+    AuthenticationError,
+    MisconfiguredError,
+    RequestError,
+    TimeOutError,
+)
 
 if TYPE_CHECKING:
     from requests import PreparedRequest, Response
@@ -304,12 +309,17 @@ class OIDCAuthorizationCodeFlowAuth(OIDCRefreshTokenBase):
         state = self.compute_state()
         authentication_response = self.authenticate_user(state)
         exchange_url = authentication_response.url
+
         for err_pattern, err_message in getattr(
             self.config, "exchange_url_error_pattern", {}
         ).items():
             if err_pattern in exchange_url:
                 raise AuthenticationError(err_message)
+
         if not exchange_url.startswith(self.config.redirect_uri):
+            if "Invalid username or password" in authentication_response.text:
+                raise AuthenticationError("Invalid username or password")
+
             raise AuthenticationError(
                 f"Could not authenticate user with provider {self.provider}.",
                 "Please verify your credentials",
@@ -369,13 +379,20 @@ class OIDCAuthorizationCodeFlowAuth(OIDCRefreshTokenBase):
             "redirect_uri": self.config.redirect_uri,
         }
         ssl_verify = getattr(self.config, "ssl_verify", True)
-        authorization_response = self.session.get(
-            self.authorization_endpoint,
-            params=params,
-            headers=USER_AGENT,
-            timeout=HTTP_REQ_TIMEOUT,
-            verify=ssl_verify,
-        )
+        try:
+            authorization_response = self.session.get(
+                self.authorization_endpoint,
+                params=params,
+                headers=USER_AGENT,
+                timeout=HTTP_REQ_TIMEOUT,
+                verify=ssl_verify,
+            )
+        except requests.exceptions.Timeout as exc:
+            raise TimeoutError(exc, "The authentication request timed out.") from exc
+        except requests.RequestException as exc:
+            raise RequestError.from_error(
+                exc, "An error occurred while authenticating the user."
+            ) from exc
 
         login_document = etree.HTML(authorization_response.text)
         login_forms = login_document.xpath(self.config.login_form_xpath)
@@ -413,13 +430,20 @@ class OIDCAuthorizationCodeFlowAuth(OIDCRefreshTokenBase):
             auth_uri = getattr(self.config, "authentication_uri", None)
             if not auth_uri:
                 raise MisconfiguredError("authentication_uri is missing")
-        return self.session.post(
-            auth_uri,
-            data=login_data,
-            headers=USER_AGENT,
-            timeout=HTTP_REQ_TIMEOUT,
-            verify=ssl_verify,
-        )
+        try:
+            return self.session.post(
+                auth_uri,
+                data=login_data,
+                headers=USER_AGENT,
+                timeout=HTTP_REQ_TIMEOUT,
+                verify=ssl_verify,
+            )
+        except requests.exceptions.Timeout as exc:
+            raise TimeoutError(exc, "The authentication request timed out.") from exc
+        except requests.RequestException as exc:
+            raise RequestError.from_error(
+                exc, "An error occurred while authenticating the user."
+            ) from exc
 
     def grant_user_consent(self, authentication_response: Response) -> Response:
         """Grant user consent"""
@@ -433,13 +457,20 @@ class OIDCAuthorizationCodeFlowAuth(OIDCRefreshTokenBase):
             for key, value in self.config.user_consent_form_data.items()
         }
         ssl_verify = getattr(self.config, "ssl_verify", True)
-        return self.session.post(
-            self.authorization_endpoint,
-            data=user_consent_data,
-            headers=USER_AGENT,
-            timeout=HTTP_REQ_TIMEOUT,
-            verify=ssl_verify,
-        )
+        try:
+            return self.session.post(
+                self.authorization_endpoint,
+                data=user_consent_data,
+                headers=USER_AGENT,
+                timeout=HTTP_REQ_TIMEOUT,
+                verify=ssl_verify,
+            )
+        except requests.exceptions.Timeout as exc:
+            raise TimeoutError(exc, "The authentication request timed out.") from exc
+        except requests.RequestException as exc:
+            raise RequestError.from_error(
+                exc, "An error occurred while authenticating the user."
+            ) from exc
 
     def _prepare_token_post_data(self, token_data: dict[str, Any]) -> dict[str, Any]:
         """Prepare the common data to post to the token URI"""
@@ -487,14 +518,21 @@ class OIDCAuthorizationCodeFlowAuth(OIDCRefreshTokenBase):
             self.config.token_exchange_post_data_method: token_exchange_data
         }
         ssl_verify = getattr(self.config, "ssl_verify", True)
-        r = self.session.post(
-            self.token_endpoint,
-            headers=USER_AGENT,
-            timeout=HTTP_REQ_TIMEOUT,
-            verify=ssl_verify,
-            **post_request_kwargs,
-        )
-        return r
+        try:
+            r = self.session.post(
+                self.token_endpoint,
+                headers=USER_AGENT,
+                timeout=HTTP_REQ_TIMEOUT,
+                verify=ssl_verify,
+                **post_request_kwargs,
+            )
+            return r
+        except requests.exceptions.Timeout as exc:
+            raise TimeoutError(exc, "The authentication request timed out.") from exc
+        except requests.RequestException as exc:
+            raise RequestError.from_error(
+                exc, "An error occurred while authenticating the user."
+            ) from exc
 
     def _constant_or_xpath_extracted(
         self, value: str, form_element: Any

eodag/plugins/authentication/sas_auth.py

@@ -116,7 +116,7 @@ class SASAuth(Authentication):
         headers = deepcopy(USER_AGENT)
 
         # update headers with subscription key if exists
-        apikey = getattr(self.config, "credentials", {}).get("apikey", None)
+        apikey = getattr(self.config, "credentials", {}).get("apikey")
         ssl_verify = getattr(self.config, "ssl_verify", True)
         if apikey:
             headers_update = format_dict_items(self.config.headers, apikey=apikey)

eodag/plugins/crunch/filter_date.py

@@ -69,7 +69,7 @@ class FilterDate(Crunch):
             return []
 
         # filter start date
-        filter_start_str = self.config.__dict__.get("start", None)
+        filter_start_str = self.config.__dict__.get("start")
         if filter_start_str:
             filter_start = dateutil.parser.parse(filter_start_str)
             if not filter_start.tzinfo:
@@ -78,7 +78,7 @@ class FilterDate(Crunch):
             filter_start = None
 
         # filter end date
-        filter_end_str = self.config.__dict__.get("end", None)
+        filter_end_str = self.config.__dict__.get("end")
         if filter_end_str:
             filter_end = dateutil.parser.parse(filter_end_str)
             if not filter_end.tzinfo:
@@ -93,9 +93,7 @@ class FilterDate(Crunch):
         for product in products:
 
             # product start date
-            product_start_str = product.properties.get(
-                "startTimeFromAscendingNode", None
-            )
+            product_start_str = product.properties.get("startTimeFromAscendingNode")
             if product_start_str:
                 product_start = dateutil.parser.parse(product_start_str)
                 if not product_start.tzinfo:
@@ -104,9 +102,7 @@ class FilterDate(Crunch):
                 product_start = None
 
             # product end date
-            product_end_str = product.properties.get(
-                "completionTimeFromAscendingNode", None
-            )
+            product_end_str = product.properties.get("completionTimeFromAscendingNode")
             if product_end_str:
                 product_end = dateutil.parser.parse(product_end_str)
                 if not product_end.tzinfo:

eodag/plugins/crunch/filter_property.py

@@ -64,7 +64,7 @@ class FilterProperty(Crunch):
             return products
 
         property_key = next(iter(self.config.__dict__))
-        property_value = self.config.__dict__.get(property_key, None)
+        property_value = self.config.__dict__.get(property_key)
 
         logger.debug(
             "Start filtering for products matching operator.%s(product.properties['%s'], %s)",

eodag/plugins/download/aws.py

@@ -289,7 +289,7 @@ class AwsDownload(Download):
         )
 
         # do not try to build SAFE if asset filter is used
-        asset_filter = kwargs.get("asset", None)
+        asset_filter = kwargs.get("asset")
         if asset_filter:
             build_safe = False
             ignore_assets = False
@@ -736,7 +736,7 @@ class AwsDownload(Download):
             product.product_type, {}
         )
         # do not try to build SAFE if asset filter is used
-        asset_filter = kwargs.get("asset", None)
+        asset_filter = kwargs.get("asset")
         if asset_filter:
             build_safe = False
         else:
@@ -800,7 +800,7 @@ class AwsDownload(Download):
             # update headers
             filename = os.path.basename(list(unique_product_chunks)[0].key)
             headers = {"content-disposition": f"attachment; filename={filename}"}
-            if assets_values and assets_values[0].get("type", None):
+            if assets_values and assets_values[0].get("type"):
                 headers["content-type"] = assets_values[0]["type"]
 
             return StreamResponse(

eodag/plugins/download/base.py

@@ -28,6 +28,7 @@ from datetime import datetime, timedelta
 from time import sleep
 from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union
 
+from eodag.api.product.metadata_mapping import ONLINE_STATUS
 from eodag.plugins.base import PluginTopic
 from eodag.utils import (
     DEFAULT_DOWNLOAD_TIMEOUT,
@@ -600,15 +601,21 @@ class Download(PluginTopic):
                     if datetime_now >= product.next_try:
                         product.next_try += timedelta(minutes=wait)
                         try:
-                            return order_download(*args, **kwargs)
-
+                            download = order_download(*args, **kwargs)
                         except NotAvailableError as e:
-                            if not getattr(self.config, "order_enabled", False):
-                                raise NotAvailableError(
-                                    f"Product is not available for download and order is not supported for"
-                                    f" {self.provider}, {e}"
-                                )
                             not_available_info = str(e)
+                        else:
+                            if (
+                                product.properties.get("storageStatus", ONLINE_STATUS)
+                                == ONLINE_STATUS
+                            ) or timeout <= 0:
+                                return download
+
+                        if not getattr(self.config, "order_enabled", False):
+                            raise NotAvailableError(
+                                f"Product is not available for download and order is not supported for"
+                                f" {self.provider}, {not_available_info}"
+                            )
 
                     if datetime_now >= product.next_try and datetime_now < stop_time:
                         wait_seconds: Union[float, int] = (

eodag/plugins/download/http.py

@@ -77,6 +77,7 @@ from eodag.utils.exceptions import (
 )
 
 if TYPE_CHECKING:
+    from jsonpath_ng import JSONPath
     from requests import Response
 
     from eodag.api.product import Asset, EOProduct  # type: ignore
@@ -538,7 +539,9 @@ class HTTPDownload(Download):
                     else {}
                 )
                 if result_entry:
-                    entry_jsonpath = string_to_jsonpath(result_entry, force=True)
+                    entry_jsonpath: JSONPath = string_to_jsonpath(
+                        result_entry, force=True
+                    )
                     json_response = entry_jsonpath.find(json_response)
                     raise NotImplementedError(
                         'result_entry in config.on_success is not yet supported for result_type "json"'
@@ -611,7 +614,7 @@ class HTTPDownload(Download):
         # download assets if exist instead of remote_location
         if len(product.assets) > 0 and (
             not getattr(self.config, "ignore_assets", False)
-            or kwargs.get("asset", None) is not None
+            or kwargs.get("asset") is not None
         ):
             try:
                 fs_path = self._download_assets(
@@ -622,11 +625,11 @@ class HTTPDownload(Download):
                     progress_callback,
                     **kwargs,
                 )
-                if kwargs.get("asset", None) is None:
+                if kwargs.get("asset") is None:
                     product.location = path_to_uri(fs_path)
                 return fs_path
             except NotAvailableError as e:
-                if kwargs.get("asset", None) is not None:
+                if kwargs.get("asset") is not None:
                     raise NotAvailableError(e).with_traceback(e.__traceback__)
                 else:
                     pass
@@ -661,6 +664,9 @@ class HTTPDownload(Download):
 
                 if is_empty:
                     raise DownloadError(f"product {product.properties['id']} is empty")
+                else:
+                    # make sure storage status is online
+                    product.properties["storageStatus"] = ONLINE_STATUS
 
                 return path
             else:
@@ -718,7 +724,7 @@ class HTTPDownload(Download):
 
     def _check_product_filename(self, product: EOProduct) -> str:
         filename = None
-        asset_content_disposition = self.stream.headers.get("content-disposition", None)
+        asset_content_disposition = self.stream.headers.get("content-disposition")
         if asset_content_disposition:
             filename = cast(
                 Optional[str],
@@ -769,7 +775,7 @@ class HTTPDownload(Download):
             or kwargs.get("asset") is not None
         ):
             try:
-                assets_values = product.assets.get_values(kwargs.get("asset", None))
+                assets_values = product.assets.get_values(kwargs.get("asset"))
                 chunks_tuples = self._stream_download_assets(
                     product,
                     auth,
@@ -786,7 +792,7 @@ class HTTPDownload(Download):
                     assets_values[0].headers[
                         "content-disposition"
                     ] = f"attachment; filename={assets_values[0].filename}"
-                    if assets_values[0].get("type", None):
+                    if assets_values[0].get("type"):
                         assets_values[0].headers["content-type"] = assets_values[0][
                             "type"
                         ]
@@ -814,7 +820,7 @@ class HTTPDownload(Download):
                         },
                     )
             except NotAvailableError as e:
-                if kwargs.get("asset", None) is not None:
+                if kwargs.get("asset") is not None:
                     raise NotAvailableError(e).with_traceback(e.__traceback__)
                 else:
                     pass
@@ -903,7 +909,7 @@ class HTTPDownload(Download):
             self._order(product=product, auth=auth)
 
         if (
-            product.properties.get("orderStatusLink", None)
+            product.properties.get("orderStatusLink")
             and product.properties.get("storageStatus") != ONLINE_STATUS
         ):
             self._order_status(product=product, auth=auth)
@@ -1151,7 +1157,7 @@ class HTTPDownload(Download):
                     if not getattr(asset, "filename", None):
                         # try getting filename in GET header if was not found in HEAD result
                         asset_content_disposition = stream.headers.get(
-                            "content-disposition", None
+                            "content-disposition"
                         )
                         if asset_content_disposition:
                             asset.filename = cast(
@@ -1203,7 +1209,7 @@ class HTTPDownload(Download):
         if not assets_urls:
             raise NotAvailableError("No assets available for %s" % product)
 
-        assets_values = product.assets.get_values(kwargs.get("asset", None))
+        assets_values = product.assets.get_values(kwargs.get("asset"))
 
         chunks_tuples = self._stream_download_assets(
             product, auth, progress_callback, assets_values=assets_values, **kwargs
@@ -1289,7 +1295,7 @@ class HTTPDownload(Download):
         if flatten_top_dirs:
             flatten_top_directories(fs_dir_path)
 
-        if kwargs.get("asset", None) is None:
+        if kwargs.get("asset") is None:
             # save hash/record file
             with open(record_filename, "w") as fh:
                 fh.write(product.remote_location)