eodag 3.3.0__py3-none-any.whl → 3.3.2__py3-none-any.whl

eodag/api/product/_product.py

@@ -313,7 +313,6 @@ class EOProduct:
                 "EO product is unable to download itself due to lacking of a "
                 "download plugin"
             )
-
         auth = (
             self.downloader_auth.authenticate()
             if self.downloader_auth is not None
@@ -323,7 +322,6 @@ class EOProduct:
         progress_callback, close_progress_callback = self._init_progress_bar(
             progress_callback
         )
-
         fs_path = self.downloader.download(
             self,
             auth=auth,
@@ -369,6 +367,47 @@ class EOProduct:
         progress_callback.refresh()
         return (progress_callback, close_progress_callback)
 
+    def _download_quicklook(
+        self,
+        quicklook_file: str,
+        progress_callback: ProgressCallback,
+        ssl_verify: Optional[bool] = None,
+        auth: Optional[AuthBase] = None,
+    ):
+
+        """Download the quicklook image from the EOProduct's quicklook URL.
+
+        This method performs an HTTP GET request to retrieve the quicklook image and saves it
+        locally at the specified path. It optionally verifies SSL certificates, uses HTTP
+        authentication, and can display a download progress if a callback is provided.
+
+        :param quicklook_file: The full path (including filename) where the quicklook will be saved.
+        :param progress_callback: A callable that accepts the current and total download sizes
+                                to display or log the download progress. It must support `reset(total)`
+                                and be callable with downloaded chunk sizes.
+        :param ssl_verify: (optional) Whether to verify SSL certificates. Defaults to True.
+        :param auth: (optional) Authentication credentials (e.g., tuple or object) used for the
+                        HTTP request if the resource requires authentication.
+        :raises HTTPError: If the HTTP request to the quicklook URL fails.
+        """
+        with requests.get(
+            self.properties["quicklook"],
+            stream=True,
+            auth=auth,
+            headers=USER_AGENT,
+            timeout=DEFAULT_STREAM_REQUESTS_TIMEOUT,
+            verify=ssl_verify,
+        ) as stream:
+            stream.raise_for_status()
+            stream_size = int(stream.headers.get("content-length", 0))
+            progress_callback.reset(stream_size)
+            with open(quicklook_file, "wb") as fhandle:
+                for chunk in stream.iter_content(chunk_size=64 * 1024):
+                    if chunk:
+                        fhandle.write(chunk)
+                        progress_callback(len(chunk))
+            logger.info("Download recorded in %s", quicklook_file)
+
     def get_quicklook(
         self,
         filename: Optional[str] = None,
@@ -378,6 +417,9 @@ class EOProduct:
         """Download the quicklook image of a given EOProduct from its provider if it
         exists.
 
+        This method retrieves the quicklook URL from the EOProduct metadata and delegates
+        the download to the internal `download_quicklook` method.
+
         :param filename: (optional) The name to give to the downloaded quicklook. If not
                          given, it defaults to the product's ID (without file extension).
         :param output_dir: (optional) The absolute path of the directory where to store
@@ -403,18 +445,6 @@ class EOProduct:
                     }
                 )
 
-        # progress bar init
-        if progress_callback is None:
-            progress_callback = ProgressCallback()
-            # one shot progress callback to close after download
-            close_progress_callback = True
-        else:
-            close_progress_callback = False
-            # update units as bar may have been previously used for extraction
-            progress_callback.unit = "B"
-            progress_callback.unit_scale = True
-        progress_callback.desc = "quicklooks/%s" % self.properties.get("id", "")
-
         if self.properties.get("quicklook", None) is None:
             logger.warning(
                 "Missing information to retrieve quicklook for EO product: %s",
@@ -442,6 +472,18 @@ class EOProduct:
         )
 
         if not os.path.isfile(quicklook_file):
+
+            # progress bar init
+            if progress_callback is None:
+                progress_callback = ProgressCallback()
+                # one shot progress callback to close after download
+                close_progress_callback = True
+            else:
+                close_progress_callback = False
+                # update units as bar may have been previously used for extraction
+                progress_callback.unit = "B"
+                progress_callback.unit_scale = True
+            progress_callback.desc = "quicklooks/%s" % self.properties.get("id", "")
             # VERY SPECIAL CASE (introduced by the onda provider): first check if
             # it is a HTTP URL. If not, we assume it is a base64 string, in which case
             # we just decode the content, write it into the quicklook_file and return it.
@@ -468,30 +510,25 @@ class EOProduct:
                 if self.downloader
                 else True
             )
-            with requests.get(
-                self.properties["quicklook"],
-                stream=True,
-                auth=auth,
-                headers=USER_AGENT,
-                timeout=DEFAULT_STREAM_REQUESTS_TIMEOUT,
-                verify=ssl_verify,
-            ) as stream:
-                try:
-                    stream.raise_for_status()
-                except RequestException as e:
-                    import traceback as tb
+            try:
+                self._download_quicklook(
+                    quicklook_file, progress_callback, ssl_verify, auth
+                )
+            except RequestException as e:
 
-                    logger.error("Error while getting resource :\n%s", tb.format_exc())
+                logger.debug(
+                    f"Error while getting resource with authentication. {e} \nTrying without authentication..."
+                )
+                try:
+                    self._download_quicklook(
+                        quicklook_file, progress_callback, ssl_verify, None
+                    )
+                except RequestException as e_no_auth:
+                    logger.error(
+                        f"Failed to get resource with authentication: {e} \n \
+                        Failed to get resource even without authentication. {e_no_auth}"
+                    )
                     return str(e)
-                else:
-                    stream_size = int(stream.headers.get("content-length", 0))
-                    progress_callback.reset(stream_size)
-                    with open(quicklook_file, "wb") as fhandle:
-                        for chunk in stream.iter_content(chunk_size=64 * 1024):
-                            if chunk:
-                                fhandle.write(chunk)
-                                progress_callback(len(chunk))
-                    logger.info("Download recorded in %s", quicklook_file)
 
             # close progress bar if needed
             if close_progress_callback:

eodag/api/search_result.py

@@ -36,7 +36,7 @@ if TYPE_CHECKING:
     from eodag.plugins.crunch.base import Crunch
 
 
-class SearchResult(UserList):
+class SearchResult(UserList[EOProduct]):
     """An object representing a collection of :class:`~eodag.api.product._product.EOProduct` resulting from a search.
 
     :param products: A list of products resulting from a search
@@ -46,8 +46,6 @@ class SearchResult(UserList):
     :ivar number_matched: Estimated total number of matching results
     """
 
-    data: list[EOProduct]
-
     errors: Annotated[
         list[tuple[str, Exception]], Doc("Tuple of provider name, exception")
     ]
@@ -56,11 +54,11 @@ class SearchResult(UserList):
         self,
         products: list[EOProduct],
         number_matched: Optional[int] = None,
-        errors: list[tuple[str, Exception]] = [],
+        errors: Optional[list[tuple[str, Exception]]] = None,
     ) -> None:
         super().__init__(products)
         self.number_matched = number_matched
-        self.errors = errors
+        self.errors = errors if errors is not None else []
 
     def crunch(self, cruncher: Crunch, **search_params: Any) -> SearchResult:
         """Do some crunching with the underlying EO products.
@@ -193,8 +191,8 @@ class SearchResult(UserList):
                 <details><summary style='color: grey; font-family: monospace;'>
                     {i}&ensp;
                     {type(p).__name__}(id=<span style='color: black;'>{
-                    p.properties["id"]
-                }</span>, provider={p.provider})
+                        p.properties["id"]
+                    }</span>, provider={p.provider})
                 </summary>
                 {p._repr_html_()}
                 </details>

eodag/config.py

@@ -618,6 +618,9 @@ class PluginConfig(yaml.YAMLObject):
     #: :class:`~eodag.plugins.authentication.token.TokenAuth`
     #: key to get the expiration time of the token
     token_expiration_key: str
+    #: :class:`~eodag.plugins.authentication.token.TokenAuth`
+    #: HTTP method to use
+    request_method: str
     #: :class:`~eodag.plugins.authentication.token_exchange.OIDCTokenExchangeAuth`
     #: The full :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth` plugin configuration
     #: used to retrieve subject token

eodag/plugins/authentication/token.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import logging
 from datetime import datetime, timedelta
+from threading import Lock
 from typing import TYPE_CHECKING, Any, Optional
 from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
 
@@ -77,6 +78,7 @@ class TokenAuth(Authentication):
           the token (given in s)
         * :attr:`~eodag.config.PluginConfig.ssl_verify` (``bool``): if the ssl certificates
           should be verified in the requests; default: ``True``
+        * :attr:`~eodag.config.PluginConfig.request_method` (``str``): HTTP method to use; default: ``POST``
         * :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
@@ -95,6 +97,19 @@ class TokenAuth(Authentication):
         self.token = ""
         self.refresh_token = ""
         self.token_expiration = datetime.now()
+        self.auth_lock = Lock()
+
+    def __getstate__(self):
+        """Exclude attributes that can't be pickled from serialization."""
+        state = dict(self.__dict__)
+        del state["auth_lock"]
+        return state
+
+    def __setstate__(self, state):
+        """Exclude attributes that can't be pickled from deserialization."""
+        self.__dict__.update(state)
+        # Init them manually
+        self.auth_lock = Lock()
 
     def validate_config_credentials(self) -> None:
         """Validate configured credentials"""
@@ -134,61 +149,67 @@ class TokenAuth(Authentication):
 
     def authenticate(self) -> AuthBase:
         """Authenticate"""
-        self.validate_config_credentials()
-        if self.token and self.token_expiration > datetime.now():
-            logger.debug("using existing access token")
-            return RequestsTokenAuth(
-                self.token, "header", headers=getattr(self.config, "headers", {})
-            )
-        s = requests.Session()
-        try:
-            # First get the token
-            response = self._token_request(session=s)
-            response.raise_for_status()
-        except requests.exceptions.Timeout as exc:
-            raise TimeOutError(exc, timeout=HTTP_REQ_TIMEOUT) from exc
-        except RequestException as e:
-            response_text = getattr(e.response, "text", "").strip()
-            # check if error is identified as auth_error in provider conf
-            auth_errors = getattr(self.config, "auth_error_code", [None])
-            if not isinstance(auth_errors, list):
-                auth_errors = [auth_errors]
-            if (
-                e.response is not None
-                and getattr(e.response, "status_code", None)
-                and e.response.status_code in auth_errors
-            ):
-                raise AuthenticationError(
-                    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(
-                    "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]
+
+        # Use a thread lock to avoid several threads requesting the token at the same time
+        with self.auth_lock:
+
+            self.validate_config_credentials()
+            if self.token and self.token_expiration > datetime.now():
+                logger.debug("using existing access token")
+                return RequestsTokenAuth(
+                    self.token, "header", headers=getattr(self.config, "headers", {})
+                )
+            s = requests.Session()
+            try:
+                # First get the token
+                response = self._token_request(session=s)
+                response.raise_for_status()
+            except requests.exceptions.Timeout as exc:
+                raise TimeOutError(exc, timeout=HTTP_REQ_TIMEOUT) from exc
+            except RequestException as e:
+                response_text = getattr(e.response, "text", "").strip()
+                # check if error is identified as auth_error in provider conf
+                auth_errors = getattr(self.config, "auth_error_code", [None])
+                if not isinstance(auth_errors, list):
+                    auth_errors = [auth_errors]
+                if (
+                    e.response is not None
+                    and getattr(e.response, "status_code", None)
+                    and e.response.status_code in auth_errors
+                ):
+                    raise AuthenticationError(
+                        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(
+                        "Could no get authentication token", str(e), response_text
+                    ) from e
             else:
-                token = response.text
-            self.token = token
-            if getattr(self.config, "refresh_token_key", None):
-                self.refresh_token = response.json()[self.config.refresh_token_key]
-            if getattr(self.config, "token_expiration_key", None):
-                expiration_time = response.json()[self.config.token_expiration_key]
-                self.token_expiration = datetime.now() + timedelta(
-                    seconds=expiration_time
+                if getattr(self.config, "token_type", "text") == "json":
+                    token = response.json()[self.config.token_key]
+                else:
+                    token = response.text
+                self.token = token
+                if getattr(self.config, "refresh_token_key", None):
+                    self.refresh_token = response.json()[self.config.refresh_token_key]
+                if getattr(self.config, "token_expiration_key", None):
+                    expiration_time = response.json()[self.config.token_expiration_key]
+                    self.token_expiration = datetime.now() + timedelta(
+                        seconds=expiration_time
+                    )
+
+                if not hasattr(self.config, "headers"):
+                    raise MisconfiguredError(
+                        f"Missing headers configuration for {self}"
+                    )
+                # Return auth class set with obtained token
+                return RequestsTokenAuth(
+                    token, "header", headers=getattr(self.config, "headers", {})
                 )
 
-            if not hasattr(self.config, "headers"):
-                raise MisconfiguredError(f"Missing headers configuration for {self}")
-            # Return auth class set with obtained token
-            return RequestsTokenAuth(
-                token, "header", headers=getattr(self.config, "headers", {})
-            )
-
     def _token_request(
         self,
         session: requests.Session,
@@ -217,14 +238,36 @@ class TokenAuth(Authentication):
         # append headers to req if some are specified in config
         req_kwargs: dict[str, Any] = {"headers": dict(headers, **USER_AGENT)}
         ssl_verify = getattr(self.config, "ssl_verify", True)
+        method = getattr(self.config, "request_method", "POST")
+
+        def set_request_data(call_refresh: bool) -> None:
+            """Set the request data contents for POST requests"""
+            if method != "POST":
+                return
+
+            # append req_data to credentials if specified in config
+            data = dict(getattr(self.config, "req_data", {}), **self.config.credentials)
+
+            # when refreshing the token, we pass only the client_id/secret if present,
+            # not other parameters (username/password, scope, ...)
+            if call_refresh:
+                data = {
+                    k: v for k, v in data.items() if k in ["client_id", "client_secret"]
+                }
+                # the grant type is always refresh_token
+                data["grant_type"] = "refresh_token"
+                # and we add the old refresh token value to the request
+                data["refresh_token"] = self.refresh_token
+
+            req_kwargs["data"] = data
 
         if self.refresh_token:
             logger.debug("fetching access token with refresh token")
             session.mount(self.config.refresh_uri, HTTPAdapter(max_retries=retries))
+            set_request_data(call_refresh=True)
             try:
                 response = session.post(
                     self.config.refresh_uri,
-                    data={"refresh_token": self.refresh_token},
                     timeout=HTTP_REQ_TIMEOUT,
                     verify=ssl_verify,
                     **req_kwargs,
@@ -237,14 +280,8 @@ class TokenAuth(Authentication):
         logger.debug("fetching access token from %s", self.config.auth_uri)
         # append headers to req if some are specified in config
         session.mount(self.config.auth_uri, HTTPAdapter(max_retries=retries))
-        method = getattr(self.config, "request_method", "POST")
 
-        # send credentials also as data in POST requests
-        if method == "POST":
-            # append req_data to credentials if specified in config
-            req_kwargs["data"] = dict(
-                getattr(self.config, "req_data", {}), **self.config.credentials
-            )
+        set_request_data(call_refresh=False)
 
         # credentials as auth tuple if possible
         req_kwargs["auth"] = (

eodag/plugins/search/base.py

@@ -337,7 +337,9 @@ class Search(PluginTopic):
         try:
             filters["productType"] = product_type
             queryables = self.discover_queryables(**{**default_values, **filters}) or {}
-        except NotImplementedError:
+        except NotImplementedError as e:
+            if str(e):
+                logger.debug(str(e))
             queryables = self.queryables_from_metadata_mapping(product_type, alias)
 
         return QueryablesDict(**queryables)
@@ -381,12 +383,12 @@ class Search(PluginTopic):
             for pt in available_product_types:
                 self.config.product_type_config = product_type_configs[pt]
                 pt_queryables = self._get_product_type_queryables(pt, None, filters)
-                # only use key and type because values and defaults will vary between product types
-                pt_queryables_neutral = {
-                    k: Annotated[v.__args__[0], Field(default=None)]
-                    for k, v in pt_queryables.items()
-                }
-                all_queryables.update(pt_queryables_neutral)
+                all_queryables.update(pt_queryables)
+            # reset defaults because they may vary between product types
+            for k, v in all_queryables.items():
+                v.__metadata__[0].default = getattr(
+                    Queryables.model_fields.get(k, Field(None)), "default", None
+                )
             return QueryablesDict(
                 additional_properties=True,
                 additional_information=additional_info,

eodag/plugins/search/qssearch.py

@@ -1810,8 +1810,7 @@ class StacSearch(PostJsonSearch):
             not self.config.discover_queryables["fetch_url"]
             and not self.config.discover_queryables["product_type_fetch_url"]
         ):
-            logger.info(f"Cannot fetch queryables with {self.provider}")
-            return None
+            raise NotImplementedError()
 
         product_type = kwargs.get("productType", None)
         provider_product_type = (
@@ -1823,18 +1822,16 @@ class StacSearch(PostJsonSearch):
             provider_product_type
             and not self.config.discover_queryables["product_type_fetch_url"]
         ):
-            logger.info(
+            raise NotImplementedError(
                 f"Cannot fetch queryables for a specific product type with {self.provider}"
             )
-            return None
         if (
             not provider_product_type
             and not self.config.discover_queryables["fetch_url"]
         ):
-            logger.info(
-                f"Cannot fetch global queryables with {self.provider}. A product type must be specified"
+            raise ValidationError(
+                f"Cannot fetch global queryables for {self.provider}. A product type must be specified"
             )
-            return None
 
         try:
             unparsed_fetch_url = (
@@ -1843,7 +1840,9 @@ class StacSearch(PostJsonSearch):
                 else self.config.discover_queryables["fetch_url"]
             )
             if unparsed_fetch_url is None:
-                return None
+                raise PluginImplementationError(
+                    f"Cannot fetch queryables for {self.provider}: missing url"
+                )
 
             fetch_url = unparsed_fetch_url.format(
                 provider_product_type=provider_product_type,
@@ -1864,9 +1863,12 @@ class StacSearch(PostJsonSearch):
                     "{} {} instance:".format(self.provider, self.__class__.__name__),
                 ),
             )
-        except (RequestError, KeyError, AttributeError) as e:
-            logger.warning("failure in queryables discovery: %s", e)
-            return None
+        except (KeyError, AttributeError) as e:
+            raise PluginImplementationError(
+                "failure in queryables discovery: %s", e
+            ) from e
+        except RequestError as e:
+            raise RequestError("failure in queryables discovery: %s", e) from e
         else:
             json_queryables = dict()
             try:
@@ -1875,17 +1877,16 @@ class StacSearch(PostJsonSearch):
                 # extract results from response json
                 results_entry = self.config.discover_queryables["results_entry"]
                 if not isinstance(results_entry, JSONPath):
-                    logger.warning(
+                    raise MisconfiguredError(
                         f"Could not parse {self.provider} discover_queryables.results_entry"
                         f" as JSONPath: {results_entry}"
                     )
-                    return None
                 json_queryables = [
                     match.value for match in results_entry.find(resp_as_json)
                 ][0]
 
             except KeyError as e:
-                logger.warning(
+                raise MisconfiguredError(
                     "Incomplete %s discover_queryables configuration: %s",
                     self.provider,
                     e,