eodag 3.0.1__py3-none-any.whl → 3.1.0__py3-none-any.whl

eodag/plugins/apis/ecmwf.py

@@ -20,16 +20,17 @@ from __future__ import annotations
 import logging
 import os
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Annotated
 
 import geojson
 from ecmwfapi import ECMWFDataServer, ECMWFService
 from ecmwfapi.api import APIException, Connection, get_apikey_values
+from pydantic.fields import FieldInfo
 
 from eodag.plugins.apis.base import Api
 from eodag.plugins.search import PreparedSearch
 from eodag.plugins.search.base import Search
-from eodag.plugins.search.build_search_result import BuildPostSearchResult
+from eodag.plugins.search.build_search_result import ECMWFSearch, ecmwf_mtd
 from eodag.utils import (
     DEFAULT_DOWNLOAD_TIMEOUT,
     DEFAULT_DOWNLOAD_WAIT,
@@ -43,13 +44,14 @@ from eodag.utils.exceptions import AuthenticationError, DownloadError
 from eodag.utils.logging import get_logging_verbose
 
 if TYPE_CHECKING:
-    from typing import Any, Dict, List, Optional, Tuple, Union
+    from typing import Any, Optional, Union
 
     from requests.auth import AuthBase
 
     from eodag.api.product import EOProduct
     from eodag.api.search_result import SearchResult
     from eodag.config import PluginConfig
+    from eodag.types import S3SessionKwargs
     from eodag.types.download_args import DownloadConf
     from eodag.utils import DownloadedCallback, ProgressCallback, Unpack
 
@@ -58,7 +60,7 @@ logger = logging.getLogger("eodag.apis.ecmwf")
 ECMWF_MARS_KNOWN_FORMATS = {"grib": "grib", "netcdf": "nc"}
 
 
-class EcmwfApi(Api, BuildPostSearchResult):
+class EcmwfApi(Api, ECMWFSearch):
     """A plugin that enables to build download-request and download data on ECMWF MARS.
 
     Builds a single ready-to-download :class:`~eodag.api.product._product.EOProduct`
@@ -69,15 +71,16 @@ class EcmwfApi(Api, BuildPostSearchResult):
     query).
 
     This class inherits from :class:`~eodag.plugins.apis.base.Api` for compatibility and
-    :class:`~eodag.plugins.search.build_search_result.BuildPostSearchResult` for the creation
+    :class:`~eodag.plugins.search.build_search_result.ECMWFSearch` for the creation
     of the search result.
 
     :param provider: provider name
     :param config: Api plugin configuration:
 
         * :attr:`~eodag.config.PluginConfig.type` (``str``) (**mandatory**): EcmwfApi
-        * :attr:`~eodag.config.PluginConfig.api_endpoint` (``str``) (**mandatory**): url of the ecmwf api
-        * :attr:`~eodag.config.PluginConfig.metadata_mapping` (``Dict[str, Union[str, list]]``): how
+        * :attr:`~eodag.config.PluginConfig.auth_endpoint` (``str``) (**mandatory**): url of
+          the authentication endpoint of the ecmwf api
+        * :attr:`~eodag.config.PluginConfig.metadata_mapping` (``dict[str, Union[str, list]]``): how
           parameters should be mapped between the provider and eodag; If a string is given, this is
           the mapping parameter returned by provider -> eodag parameter. If a list with 2 elements
           is given, the first one is the mapping eodag parameter -> provider query parameters
@@ -86,14 +89,19 @@ class EcmwfApi(Api, BuildPostSearchResult):
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
         # init self.config.metadata_mapping using Search Base plugin
+        config.metadata_mapping = {
+            **ecmwf_mtd(),
+            **config.metadata_mapping,
+        }
         Search.__init__(self, provider, config)
 
         # needed by QueryStringSearch.build_query_string / format_free_text_search
         self.config.__dict__.setdefault("free_text_search_operations", {})
         # needed for compatibility
         self.config.__dict__.setdefault("pagination", {"next_page_query_obj": "{{}}"})
+        self.config.__dict__.setdefault("api_endpoint", "")
 
-    def do_search(self, *args: Any, **kwargs: Any) -> List[Dict[str, Any]]:
+    def do_search(self, *args: Any, **kwargs: Any) -> list[dict[str, Any]]:
         """Should perform the actual search request."""
         return [{}]
 
@@ -101,16 +109,16 @@ class EcmwfApi(Api, BuildPostSearchResult):
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> Tuple[List[EOProduct], Optional[int]]:
+    ) -> tuple[list[EOProduct], Optional[int]]:
         """Build ready-to-download SearchResult"""
 
         # check productType, dates, geometry, use defaults if not specified
         # productType
         if not kwargs.get("productType"):
             kwargs["productType"] = "%s_%s_%s" % (
-                kwargs.get("dataset", "mars"),
-                kwargs.get("type", ""),
-                kwargs.get("levtype", ""),
+                kwargs.get("ecmwf:dataset", "mars"),
+                kwargs.get("ecmwf:type", ""),
+                kwargs.get("ecmwf:levtype", ""),
             )
         # start date
         if "startTimeFromAscendingNode" not in kwargs:
@@ -132,9 +140,9 @@ class EcmwfApi(Api, BuildPostSearchResult):
         if "geometry" in kwargs:
             kwargs["geometry"] = get_geometry_from_various(geometry=kwargs["geometry"])
 
-        return BuildPostSearchResult.query(self, prep, **kwargs)
+        return ECMWFSearch.query(self, prep, **kwargs)
 
-    def authenticate(self) -> Dict[str, Optional[str]]:
+    def authenticate(self) -> dict[str, Optional[str]]:
         """Check credentials and returns information needed for auth
 
         :returns: {key, url, email} dictionary
@@ -143,7 +151,7 @@ class EcmwfApi(Api, BuildPostSearchResult):
         # Get credentials from eodag or using ecmwf conf
         email = getattr(self.config, "credentials", {}).get("username", None)
         key = getattr(self.config, "credentials", {}).get("password", None)
-        url = getattr(self.config, "api_endpoint", None)
+        url = getattr(self.config, "auth_endpoint", None)
         if not all([email, key, url]):
             key, url, email = get_apikey_values()
 
@@ -165,10 +173,10 @@ class EcmwfApi(Api, BuildPostSearchResult):
     def download(
         self,
         product: EOProduct,
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = 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 data from ECMWF MARS"""
@@ -254,13 +262,13 @@ class EcmwfApi(Api, BuildPostSearchResult):
     def download_all(
         self,
         products: SearchResult,
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = 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]:
+    ) -> list[str]:
         """
         Download all using parent (base plugin) method
         """
@@ -277,3 +285,15 @@ class EcmwfApi(Api, BuildPostSearchResult):
     def clear(self) -> None:
         """Clear search context"""
         pass
+
+    def discover_queryables(
+        self, **kwargs: Any
+    ) -> Optional[dict[str, Annotated[Any, FieldInfo]]]:
+        """Fetch queryables list from provider using metadata mapping
+
+        :param kwargs: additional filters for queryables (`productType` and other search
+                       arguments)
+        :returns: fetched queryable parameters dict
+        """
+        product_type = kwargs.get("productType", None)
+        return self.queryables_from_metadata_mapping(product_type)

eodag/plugins/apis/usgs.py

@@ -22,7 +22,7 @@ import os
 import shutil
 import tarfile
 import zipfile
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union, cast
+from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
 import requests
 from jsonpath_ng.ext import parse
@@ -61,6 +61,7 @@ if TYPE_CHECKING:
 
     from eodag.api.search_result import SearchResult
     from eodag.config import PluginConfig
+    from eodag.types import S3SessionKwargs
     from eodag.types.download_args import DownloadConf
     from eodag.utils import DownloadedCallback, Unpack
 
@@ -86,7 +87,7 @@ class UsgsApi(Api):
           file should be extracted; default: ``True``
         * :attr:`~eodag.config.PluginConfig.order_enabled` (``bool``): if the product has to
           be ordered to download it; default: ``False``
-        * :attr:`~eodag.config.PluginConfig.metadata_mapping` (``Dict[str, Union[str, list]]``): how
+        * :attr:`~eodag.config.PluginConfig.metadata_mapping` (``dict[str, Union[str, list]]``): how
           parameters should be mapped between the provider and eodag; If a string is given, this is
           the mapping parameter returned by provider -> eodag parameter. If a list with 2 elements
           is given, the first one is the mapping eodag parameter -> provider query parameters
@@ -99,7 +100,7 @@ class UsgsApi(Api):
         # Same method as in base.py, Search.__init__()
         # Prepare the metadata mapping
         # Do a shallow copy, the structure is flat enough for this to be sufficient
-        metas: Dict[str, Any] = DEFAULT_METADATA_MAPPING.copy()
+        metas: dict[str, Any] = DEFAULT_METADATA_MAPPING.copy()
         # Update the defaults with the mapping value. This will add any new key
         # added by the provider mapping that is not in the default metadata.
         metas.update(self.config.metadata_mapping)
@@ -127,7 +128,7 @@ class UsgsApi(Api):
                 api.logout()
                 continue
             except USGSError as e:
-                if i == 0:
+                if i == 0 and os.path.isfile(api.TMPFILE):
                     # `.usgs` API file key might be obsolete
                     # Remove it and try again
                     os.remove(api.TMPFILE)
@@ -138,7 +139,7 @@ class UsgsApi(Api):
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> Tuple[List[EOProduct], Optional[int]]:
+    ) -> tuple[list[EOProduct], Optional[int]]:
         """Search for data on USGS catalogues"""
         page = prep.page if prep.page is not None else DEFAULT_PAGE
         items_per_page = (
@@ -164,7 +165,7 @@ class UsgsApi(Api):
         start_date = kwargs.pop("startTimeFromAscendingNode", None)
         end_date = kwargs.pop("completionTimeFromAscendingNode", None)
         geom = kwargs.pop("geometry", None)
-        footprint: Dict[str, str] = {}
+        footprint: dict[str, str] = {}
         if hasattr(geom, "bounds"):
             (
                 footprint["lonmin"],
@@ -175,7 +176,7 @@ class UsgsApi(Api):
         else:
             footprint = geom
 
-        final: List[EOProduct] = []
+        final: list[EOProduct] = []
         if footprint and len(footprint.keys()) == 4:  # a rectangle (or bbox)
             lower_left = {
                 "longitude": footprint["lonmin"],
@@ -295,10 +296,10 @@ class UsgsApi(Api):
     def download(
         self,
         product: EOProduct,
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = 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 data from USGS catalogues"""
@@ -340,7 +341,7 @@ class UsgsApi(Api):
             product.properties["productId"],
         )
 
-        req_urls: List[str] = []
+        req_urls: list[str] = []
         try:
             if len(download_request_results["data"]["preparingDownloads"]) > 0:
                 req_urls.extend(
@@ -375,7 +376,7 @@ class UsgsApi(Api):
         logger.debug(f"Downloading {req_url}")
         ssl_verify = getattr(self.config, "ssl_verify", True)
 
-        @self._download_retry(product, wait, timeout)
+        @self._order_download_retry(product, wait, timeout)
         def download_request(
             product: EOProduct,
             fs_path: str,
@@ -464,13 +465,13 @@ class UsgsApi(Api):
     def download_all(
         self,
         products: SearchResult,
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = 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]:
+    ) -> list[str]:
         """
         Download all using parent (base plugin) method
         """

eodag/plugins/authentication/aws_auth.py

@@ -17,9 +17,10 @@
 # limitations under the License.
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Dict
+from typing import TYPE_CHECKING, Optional, cast
 
 from eodag.plugins.authentication.base import Authentication
+from eodag.types import S3SessionKwargs
 
 if TYPE_CHECKING:
     from mypy_boto3_s3.client import S3Client
@@ -53,12 +54,12 @@ class AwsAuth(Authentication):
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
         super(AwsAuth, self).__init__(provider, config)
-        self.aws_access_key_id = None
-        self.aws_secret_access_key = None
-        self.aws_session_token = None
-        self.profile_name = None
+        self.aws_access_key_id: Optional[str] = None
+        self.aws_secret_access_key: Optional[str] = None
+        self.aws_session_token: Optional[str] = None
+        self.profile_name: Optional[str] = None
 
-    def authenticate(self) -> Dict[str, str]:
+    def authenticate(self) -> S3SessionKwargs:
         """Authenticate
 
         :returns: dict containing AWS/boto3 non-empty credentials
@@ -75,10 +76,12 @@ class AwsAuth(Authentication):
         )
         self.profile_name = credentials.get("aws_profile", self.profile_name)
 
-        auth_keys = [
-            "aws_access_key_id",
-            "aws_secret_access_key",
-            "aws_session_token",
-            "profile_name",
-        ]
-        return {k: getattr(self, k) for k in auth_keys if getattr(self, k)}
+        auth_dict = cast(
+            S3SessionKwargs,
+            {
+                k: getattr(self, k)
+                for k in S3SessionKwargs.__annotations__
+                if getattr(self, k, None)
+            },
+        )
+        return auth_dict

eodag/plugins/authentication/base.py

@@ -17,7 +17,7 @@
 # limitations under the License.
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Dict, Union
+from typing import TYPE_CHECKING, Union
 
 from eodag.plugins.base import PluginTopic
 from eodag.utils.exceptions import MisconfiguredError
@@ -25,6 +25,8 @@ from eodag.utils.exceptions import MisconfiguredError
 if TYPE_CHECKING:
     from requests.auth import AuthBase
 
+    from eodag.types import S3SessionKwargs
+
 
 class Authentication(PluginTopic):
     """Plugins authentication Base plugin
@@ -34,11 +36,11 @@ class Authentication(PluginTopic):
 
         * :attr:`~eodag.config.PluginConfig.matching_url` (``str``): URL pattern to match with search plugin endpoint or
           download link
-        * :attr:`~eodag.config.PluginConfig.matching_conf` (``Dict[str, Any]``): Part of the search or download plugin
+        * :attr:`~eodag.config.PluginConfig.matching_conf` (``dict[str, Any]``): Part of the search or download plugin
           configuration that needs authentication and helps identifying it
     """
 
-    def authenticate(self) -> Union[AuthBase, Dict[str, str]]:
+    def authenticate(self) -> Union[AuthBase, S3SessionKwargs]:
         """Authenticate"""
         raise NotImplementedError
 

eodag/plugins/authentication/header.py

@@ -17,7 +17,7 @@
 # limitations under the License.
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Dict
+from typing import TYPE_CHECKING
 
 from requests.auth import AuthBase
 
@@ -38,7 +38,7 @@ class HTTPHeaderAuth(Authentication):
     :param config: Authentication plugin configuration:
 
         * :attr:`~eodag.config.PluginConfig.type` (``str``) (**mandatory**): HTTPHeaderAuth
-        * :attr:`~eodag.config.PluginConfig.headers` (``Dict[str, str]``): dictionary containing
+        * :attr:`~eodag.config.PluginConfig.headers` (``dict[str, str]``): dictionary containing
           all keys/value pairs that should be added to the headers
 
     Below an example for the configuration in the providers config file is shown::
@@ -106,7 +106,7 @@ class HTTPHeaderAuth(Authentication):
 class HeaderAuth(AuthBase):
     """HeaderAuth custom authentication class to be used with requests module"""
 
-    def __init__(self, authentication_headers: Dict[str, str]) -> None:
+    def __init__(self, authentication_headers: dict[str, str]) -> None:
         self.auth_headers = authentication_headers
 
     def __call__(self, request: PreparedRequest) -> PreparedRequest:

eodag/plugins/authentication/keycloak.py

@@ -18,7 +18,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict
+from typing import TYPE_CHECKING, Any
 
 import requests
 
@@ -56,7 +56,7 @@ class KeycloakOIDCPasswordAuth(OIDCRefreshTokenBase):
           token should be added to the query string (``qs``) or to the header (``header``)
         * :attr:`~eodag.config.PluginConfig.token_qs_key` (``str``): (**mandatory if token_provision=qs**)
           key of the param added to the query string
-        * :attr:`~eodag.config.PluginConfig.allowed_audiences` (``List[str]``) (**mandatory**):
+        * :attr:`~eodag.config.PluginConfig.allowed_audiences` (``list[str]``) (**mandatory**):
           The allowed audiences that have to be present in the user token.
         * :attr:`~eodag.config.PluginConfig.auth_error_code` (``int``): which error code is
           returned in case of an authentication error
@@ -130,7 +130,7 @@ class KeycloakOIDCPasswordAuth(OIDCRefreshTokenBase):
             key=getattr(self.config, "token_qs_key", None),
         )
 
-    def _request_new_token(self) -> Dict[str, Any]:
+    def _request_new_token(self) -> dict[str, Any]:
         logger.debug("fetching new access token")
         req_data = {
             "client_id": self.config.client_id,
@@ -154,7 +154,7 @@ class KeycloakOIDCPasswordAuth(OIDCRefreshTokenBase):
             return self._request_new_token_error(e)
         return response.json()
 
-    def _get_token_with_refresh_token(self) -> Dict[str, str]:
+    def _get_token_with_refresh_token(self) -> dict[str, str]:
         logger.debug("fetching access token with refresh token")
         req_data = {
             "client_id": self.config.client_id,

eodag/plugins/authentication/oauth.py

@@ -17,12 +17,13 @@
 # limitations under the License.
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Dict, Optional
+from typing import TYPE_CHECKING, Optional
 
 from eodag.plugins.authentication.base import Authentication
 
 if TYPE_CHECKING:
     from eodag.config import PluginConfig
+    from eodag.types import S3SessionKwargs
 
 
 class OAuth(Authentication):
@@ -43,9 +44,12 @@ class OAuth(Authentication):
         self.access_key: Optional[str] = None
         self.secret_key: Optional[str] = None
 
-    def authenticate(self) -> Dict[str, str]:
+    def authenticate(self) -> S3SessionKwargs:
         """Authenticate"""
         self.validate_config_credentials()
         self.access_key = self.config.credentials["aws_access_key_id"]
         self.secret_key = self.config.credentials["aws_secret_access_key"]
-        return {"access_key": self.access_key, "secret_key": self.secret_key}
+        return {
+            "aws_access_key_id": self.access_key,
+            "aws_secret_access_key": self.secret_key,
+        }

eodag/plugins/authentication/openid_connect.py

@@ -22,7 +22,7 @@ import re
 import string
 from datetime import datetime, timedelta, timezone
 from random import SystemRandom
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 import jwt
 import requests
@@ -68,10 +68,10 @@ class OIDCRefreshTokenBase(Authentication):
         self.session = requests.Session()
 
         self.access_token = ""
-        self.access_token_expiration = datetime.min
+        self.access_token_expiration = datetime.min.replace(tzinfo=timezone.utc)
 
         self.refresh_token = ""
-        self.refresh_token_expiration = datetime.min
+        self.refresh_token_expiration = datetime.min.replace(tzinfo=timezone.utc)
 
         try:
             response = requests.get(self.config.oidc_config_url)
@@ -88,7 +88,7 @@ class OIDCRefreshTokenBase(Authentication):
         self.authorization_endpoint = auth_config["authorization_endpoint"]
         self.algorithms = auth_config["id_token_signing_alg_values_supported"]
 
-    def decode_jwt_token(self, token: str) -> Dict[str, Any]:
+    def decode_jwt_token(self, token: str) -> dict[str, Any]:
         """Decode JWT token."""
         try:
             key = self.jwks_client.get_signing_key_from_jwt(token).key
@@ -144,13 +144,13 @@ class OIDCRefreshTokenBase(Authentication):
 
         return self.access_token
 
-    def _request_new_token(self) -> Dict[str, str]:
+    def _request_new_token(self) -> dict[str, str]:
         """Fetch the access token with a new authentication"""
         raise NotImplementedError(
             "Incomplete OIDC refresh token retrieval mechanism implementation"
         )
 
-    def _request_new_token_error(self, e: requests.RequestException) -> Dict[str, str]:
+    def _request_new_token_error(self, e: requests.RequestException) -> dict[str, str]:
         """Handle RequestException raised by `self._request_new_token()`"""
         if self.access_token:
             # try using already retrieved token if authenticate() fails (OTP use-case)
@@ -186,7 +186,7 @@ class OIDCRefreshTokenBase(Authentication):
                 )
             )
 
-    def _get_token_with_refresh_token(self) -> Dict[str, str]:
+    def _get_token_with_refresh_token(self) -> dict[str, str]:
         """Fetch the access token with the refresh token"""
         raise NotImplementedError(
             "Incomplete OIDC refresh token retrieval mechanism implementation"
@@ -241,21 +241,21 @@ class OIDCAuthorizationCodeFlowAuth(OIDCRefreshTokenBase):
           authentication_uri_source=config**) The URL of the authentication backend of the OIDC provider
         * :attr:`~eodag.config.PluginConfig.user_consent_form_xpath` (``str``): The xpath to
           the user consent form. The form is searched in the content of the response to the authorization request
-        * :attr:`~eodag.config.PluginConfig.user_consent_form_data` (``Dict[str, str]``): The data that
+        * :attr:`~eodag.config.PluginConfig.user_consent_form_data` (``dict[str, str]``): The data that
           will be passed with the POST request on the form 'action' URL. The data are given as
           key value pairs, the keys representing the data key and the value being either a 'constant'
           string value, or a string of the form 'xpath(<path-to-a-value-to-be-retrieved>)' and representing a
           value to be retrieved in the user consent form. The xpath must resolve directly to a
           string value, not to an HTML element. Example: ``xpath(//input[@name="sessionDataKeyConsent"]/@value)``
-        * :attr:`~eodag.config.PluginConfig.additional_login_form_data` (``Dict[str, str]``): A mapping
+        * :attr:`~eodag.config.PluginConfig.additional_login_form_data` (``dict[str, str]``): A mapping
           giving additional data to be passed to the login POST request. The value follows
           the same rules as with user_consent_form_data
-        * :attr:`~eodag.config.PluginConfig.exchange_url_error_pattern` (``Dict[str, str]``): Key/value
+        * :attr:`~eodag.config.PluginConfig.exchange_url_error_pattern` (``dict[str, str]``): Key/value
           pairs of patterns/messages. If exchange_url contains the given pattern, the associated
           message will be sent in an AuthenticationError
         * :attr:`~eodag.config.PluginConfig.client_secret` (``str``): The OIDC provider's client
           secret of the eodag provider
-        * :attr:`~eodag.config.PluginConfig.token_exchange_params` (``Dict[str, str]``): mandatory
+        * :attr:`~eodag.config.PluginConfig.token_exchange_params` (``dict[str, str]``): mandatory
           keys for the dict: redirect_uri, client_id; A mapping between OIDC url query string
           and token handler query string params (only necessary if they are not the same as for OIDC).
           This is eodag provider dependant
@@ -298,7 +298,7 @@ class OIDCAuthorizationCodeFlowAuth(OIDCRefreshTokenBase):
             key=getattr(self.config, "token_qs_key", None),
         )
 
-    def _request_new_token(self) -> Dict[str, str]:
+    def _request_new_token(self) -> dict[str, str]:
         """Fetch the access token with a new authentication"""
         logger.debug("Fetching access token from %s", self.token_endpoint)
         state = self.compute_state()
@@ -326,12 +326,12 @@ class OIDCAuthorizationCodeFlowAuth(OIDCRefreshTokenBase):
             return self._request_new_token_error(e)
         return token_response.json()
 
-    def _get_token_with_refresh_token(self) -> Dict[str, str]:
+    def _get_token_with_refresh_token(self) -> dict[str, str]:
         """Fetch the access token with the refresh token"""
         logger.debug(
             "Fetching access token with refresh token from %s.", self.token_endpoint
         )
-        token_data: Dict[str, Any] = {
+        token_data: dict[str, Any] = {
             "refresh_token": self.refresh_token,
             "grant_type": "refresh_token",
         }
@@ -379,6 +379,12 @@ class OIDCAuthorizationCodeFlowAuth(OIDCRefreshTokenBase):
 
         login_document = etree.HTML(authorization_response.text)
         login_forms = login_document.xpath(self.config.login_form_xpath)
+
+        if not login_forms:
+            # we assume user is already logged in
+            # no form found because we got redirected to the redirect_uri
+            return authorization_response
+
         login_form = login_forms[0]
 
         # Get the form data to pass to the login form from config or from the login form
@@ -435,7 +441,7 @@ class OIDCAuthorizationCodeFlowAuth(OIDCRefreshTokenBase):
             verify=ssl_verify,
         )
 
-    def _prepare_token_post_data(self, token_data: Dict[str, Any]) -> Dict[str, Any]:
+    def _prepare_token_post_data(self, token_data: dict[str, Any]) -> dict[str, Any]:
         """Prepare the common data to post to the token URI"""
         token_data.update(
             {
@@ -471,7 +477,7 @@ class OIDCAuthorizationCodeFlowAuth(OIDCRefreshTokenBase):
                 "The state received in the authorized url does not match initially computed state"
             )
         code = qs["code"][0]
-        token_exchange_data: Dict[str, Any] = {
+        token_exchange_data: dict[str, Any] = {
             "code": code,
             "state": state,
             "grant_type": "authorization_code",

eodag/plugins/authentication/sas_auth.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 
 import logging
 from json import JSONDecodeError
-from typing import TYPE_CHECKING, Dict, Optional
+from typing import TYPE_CHECKING, Optional
 
 import requests
 from requests.auth import AuthBase
@@ -42,13 +42,13 @@ class RequestsSASAuth(AuthBase):
         self,
         auth_uri: str,
         signed_url_key: str,
-        headers: Optional[Dict[str, str]] = None,
+        headers: Optional[dict[str, str]] = None,
         ssl_verify: bool = True,
     ) -> None:
         self.auth_uri = auth_uri
         self.signed_url_key = signed_url_key
         self.headers = headers
-        self.signed_urls: Dict[str, str] = {}
+        self.signed_urls: dict[str, str] = {}
         self.ssl_verify = ssl_verify
 
     def __call__(self, request: PreparedRequest) -> PreparedRequest:
@@ -97,7 +97,7 @@ class SASAuth(Authentication):
           get the signed url
         * :attr:`~eodag.config.PluginConfig.signed_url_key` (``str``) (**mandatory**): key to
           get the signed url
-        * :attr:`~eodag.config.PluginConfig.headers` (``Dict[str, str]``) (**mandatory if
+        * :attr:`~eodag.config.PluginConfig.headers` (``dict[str, str]``) (**mandatory if
           apiKey is used**): headers to be added to the requests
         * :attr:`~eodag.config.PluginConfig.ssl_verify` (``bool``): if the ssl certificates should be
           verified in the requests; default: ``True``