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

eodag/api/core.py

@@ -1599,6 +1599,7 @@ class EODataAccessGateway:
                 if kwargs.get("raise_errors"):
                     raise
                 logger.warning(e)
+                results.errors.append((plugin.provider, e))
                 continue
 
             # try using crunch to get unique result
@@ -1622,7 +1623,7 @@ class EODataAccessGateway:
                     "Several products found for this id (%s). You may try searching using more selective criteria.",
                     results,
                 )
-        return SearchResult([], 0)
+        return SearchResult([], 0, results.errors)
 
     def _fetch_external_product_type(self, provider: str, product_type: str):
         plugins = self._plugins_manager.get_search_plugins(provider=provider)

eodag/api/search_result.py

@@ -193,8 +193,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>
@@ -214,13 +214,12 @@ class SearchResult(UserList):
         return super().extend(other)
 
 
-class RawSearchResult(UserList):
+class RawSearchResult(UserList[dict[str, Any]]):
     """An object representing a collection of raw/unparsed search results obtained from a provider.
 
     :param results: A list of raw/unparsed search results
     """
 
-    data: list[Any]
     query_params: dict[str, Any]
     product_type_def_params: dict[str, Any]
 

eodag/config.py

@@ -615,6 +615,9 @@ class PluginConfig(yaml.YAMLObject):
     #: :class:`~eodag.plugins.authentication.token.TokenAuth`
     #: type of the token
     token_type: str
+    #: :class:`~eodag.plugins.authentication.token.TokenAuth`
+    #: key to get the expiration time of the token
+    token_expiration_key: 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

@@ -18,6 +18,7 @@
 from __future__ import annotations
 
 import logging
+from datetime import datetime, timedelta
 from typing import TYPE_CHECKING, Any, Optional
 from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
 
@@ -72,6 +73,8 @@ class TokenAuth(Authentication):
           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.token_expiration_key` (``str``): key to get expiration time of
+          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.auth_error_code` (``int``): which error code is
@@ -91,6 +94,7 @@ class TokenAuth(Authentication):
         super(TokenAuth, self).__init__(provider, config)
         self.token = ""
         self.refresh_token = ""
+        self.token_expiration = datetime.now()
 
     def validate_config_credentials(self) -> None:
         """Validate configured credentials"""
@@ -131,7 +135,11 @@ 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
@@ -168,6 +176,12 @@ class TokenAuth(Authentication):
             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
@@ -179,6 +193,7 @@ 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

eodag/plugins/download/http.py

@@ -216,7 +216,7 @@ class HTTPDownload(Download):
                     product.properties["storageStatus"] = STAGING_STATUS
                 except RequestException as e:
                     self._check_auth_exception(e)
-                    msg = f'{product.properties["title"]} could not be ordered'
+                    msg = f"{product.properties['title']} could not be ordered"
                     if e.response is not None and e.response.status_code == 400:
                         raise ValidationError.from_error(e, msg) from e
                     else:
@@ -255,6 +255,16 @@ class HTTPDownload(Download):
         product.properties.update(
             {k: v for k, v in properties_update.items() if v != NOT_AVAILABLE}
         )
+        # the job id becomes the product id for EcmwfSearch products
+        if "ORDERABLE" in product.properties.get("id", ""):
+            product.properties["id"] = product.properties.get(
+                "orderId", product.properties["id"]
+            )
+            product.properties["title"] = (
+                (product.product_type or product.provider).upper()
+                + "_"
+                + product.properties["id"]
+            )
         if "downloadLink" in product.properties:
             product.remote_location = product.location = product.properties[
                 "downloadLink"
@@ -390,7 +400,10 @@ class HTTPDownload(Download):
                     # success and no need to get status response content
                     skip_parsing_status_response = True
             except RequestException as e:
-                msg = f'{product.properties["title"]} order status could not be checked'
+                msg = (
+                    f"{product.properties.get('title') or product.properties.get('id') or product} "
+                    "order status could not be checked"
+                )
                 if e.response is not None and e.response.status_code == 400:
                     raise ValidationError.from_error(e, msg) from e
                 else:
@@ -426,9 +439,14 @@ class HTTPDownload(Download):
                     f"{product.properties['title']} order status: {status_percent}"
                 )
 
-            status_message = status_dict.get("message")
+            product.properties.update(
+                {k: v for k, v in status_dict.items() if v != NOT_AVAILABLE}
+            )
+
             product.properties["orderStatus"] = status_dict.get("status")
 
+            status_message = status_dict.get("message")
+
             # handle status error
             errors: dict[str, Any] = status_config.get("error", {})
             if errors and errors.items() <= status_dict.items():
@@ -436,13 +454,14 @@ class HTTPDownload(Download):
                     f"Provider {product.provider} returned: {status_dict.get('error_message', status_message)}"
                 )
 
+        product.properties["storageStatus"] = STAGING_STATUS
+
         success_status: dict[str, Any] = status_config.get("success", {}).get("status")
         # if not success
         if (success_status and success_status != status_dict.get("status")) or (
             success_code and success_code != response.status_code
         ):
-            error = NotAvailableError(status_message)
-            raise error
+            return None
 
         product.properties["storageStatus"] = ONLINE_STATUS
 
@@ -461,7 +480,11 @@ class HTTPDownload(Download):
                     product.properties["title"],
                     e,
                 )
-                return None
+                msg = f"{product.properties['title']} order status could not be checked"
+                if e.response is not None and e.response.status_code == 400:
+                    raise ValidationError.from_error(e, msg) from e
+                else:
+                    raise DownloadError.from_error(e, msg) from e
 
         result_type = config_on_success.get("result_type", "json")
         result_entry = config_on_success.get("results_entry")
@@ -626,6 +649,8 @@ class HTTPDownload(Download):
             if fs_path is not None:
                 ext = Path(product.filename).suffix
                 path = Path(fs_path).with_suffix(ext)
+                if "ORDERABLE" in path.stem and product.properties.get("title"):
+                    path = path.with_stem(sanitize(product.properties["title"]))
 
                 with open(path, "wb") as fhandle:
                     for chunk in chunk_iterator:
@@ -961,17 +986,21 @@ class HTTPDownload(Download):
             auth = None
 
         s = requests.Session()
-        self.stream = s.request(
-            req_method,
-            req_url,
-            stream=True,
-            auth=auth,
-            params=params,
-            headers=USER_AGENT,
-            timeout=DEFAULT_STREAM_REQUESTS_TIMEOUT,
-            verify=ssl_verify,
-            **req_kwargs,
-        )
+        try:
+            self.stream = s.request(
+                req_method,
+                req_url,
+                stream=True,
+                auth=auth,
+                params=params,
+                headers=USER_AGENT,
+                timeout=DEFAULT_STREAM_REQUESTS_TIMEOUT,
+                verify=ssl_verify,
+                **req_kwargs,
+            )
+        except requests.exceptions.MissingSchema:
+            # location is not a valid url -> product is not available yet
+            raise NotAvailableError("Product is not available yet")
         try:
             self.stream.raise_for_status()
         except requests.exceptions.Timeout as exc: