eodag 3.3.0__tar.gz → 3.3.1__tar.gz

{eodag-3.3.0 → eodag-3.3.1}/CHANGES.rst

@@ -2,7 +2,31 @@
 Release history
 ===============
 
-.. _changelog-unreleased:
+
+v3.3.1 (2025-04-17)
+===================
+
+Bug Fixes
+---------
+
+* **core**: Missing queryables from metadata-mapping (`#1614`_, `9789c0c`_)
+
+* **core**: Provider queryables metadata (`#1613`_, `f1b066a`_)
+
+* **core**: Reset errors between SearchResult instances (`#1607`_, `48b0779`_)
+
+* **plugins**: Send client_id/client_secret with refresh_token in TokenAuth (`#1597`_, `9b626a9`_, thanks
+  `@jgaucher-cs <https://github.com/jgaucher-cs>`_)
+
+.. _#1597: https://github.com/CS-SI/eodag/pull/1597
+.. _#1607: https://github.com/CS-SI/eodag/pull/1607
+.. _#1613: https://github.com/CS-SI/eodag/pull/1613
+.. _#1614: https://github.com/CS-SI/eodag/pull/1614
+.. _48b0779: https://github.com/CS-SI/eodag/commit/48b07797b3a17c26e33f6f8ee2f51488a0829162
+.. _9789c0c: https://github.com/CS-SI/eodag/commit/9789c0c4a52aa180422e1f0a0c2b8d86c373a0ee
+.. _9b626a9: https://github.com/CS-SI/eodag/commit/9b626a91c7563d505632c830a98d18993ec95199
+.. _f1b066a: https://github.com/CS-SI/eodag/commit/f1b066a8feffef3d1c20147776128793177fcfeb
+
 
 v3.3.0 (2025-04-10)
 ===================

{eodag-3.3.0/eodag.egg-info → eodag-3.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eodag
-Version: 3.3.0
+Version: 3.3.1
 Summary: Earth Observation Data Access Gateway
 Home-page: https://github.com/CS-SI/eodag
 Author: CS GROUP - France
@@ -317,7 +317,7 @@ An eodag instance can be exposed through a STAC compliant REST api from the comm
 
 .. code-block:: bash
 
-    docker run -p 5000:5000 --rm csspace/eodag-server:3.3.0
+    docker run -p 5000:5000 --rm csspace/eodag-server:3.3.1
 
 You can also browse over your STAC API server using `STAC Browser <https://github.com/radiantearth/stac-browser>`_.
 Simply run:

{eodag-3.3.0 → eodag-3.3.1}/README.rst

@@ -187,7 +187,7 @@ An eodag instance can be exposed through a STAC compliant REST api from the comm
 
 .. code-block:: bash
 
-    docker run -p 5000:5000 --rm csspace/eodag-server:3.3.0
+    docker run -p 5000:5000 --rm csspace/eodag-server:3.3.1
 
 You can also browse over your STAC API server using `STAC Browser <https://github.com/radiantearth/stac-browser>`_.
 Simply run:

{eodag-3.3.0 → eodag-3.3.1}/charts/eodag-server/Chart.yaml

@@ -1,5 +1,5 @@
 apiVersion: v2
-appVersion: 3.3.0
+appVersion: 3.3.1
 dependencies:
 - name: common
   repository:  oci://registry-1.docker.io/bitnamicharts
@@ -15,4 +15,4 @@ name: eodag-server
 sources:
 - https://github.com/CS-SI/eodag
 type: application
-version: 3.3.0
+version: 3.3.1

{eodag-3.3.0 → eodag-3.3.1}/docs/stac_rest.rst

@@ -115,7 +115,7 @@ available on `https://hub.docker.com/r/csspace/eodag-server <https://hub.docker.
 
 .. code-block:: bash
 
-    $ docker run -p 5000:5000 --rm csspace/eodag-server:3.3.0
+    $ docker run -p 5000:5000 --rm csspace/eodag-server:3.3.1
 
 Example
 -------

{eodag-3.3.0 → eodag-3.3.1}/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-3.3.0 → eodag-3.3.1}/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-3.3.0 → eodag-3.3.1}/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-3.3.0 → eodag-3.3.1}/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-3.3.0 → eodag-3.3.1}/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,