eodag 3.1.0b1__py3-none-any.whl → 3.2.0__py3-none-any.whl

eodag/config.py

@@ -20,17 +20,15 @@ from __future__ import annotations
 import logging
 import os
 import tempfile
+from importlib.resources import files as res_files
 from inspect import isclass
 from typing import (
     Annotated,
     Any,
-    Dict,
     ItemsView,
     Iterator,
-    List,
     Literal,
     Optional,
-    Tuple,
     TypedDict,
     Union,
     ValuesView,
@@ -44,7 +42,6 @@ import yaml.constructor
 import yaml.parser
 from annotated_types import Gt
 from jsonpath_ng import JSONPath
-from pkg_resources import resource_filename
 
 from eodag.api.product.metadata_mapping import mtd_cfg_as_conversion_and_querypath
 from eodag.utils import (
@@ -79,7 +76,7 @@ class SimpleYamlProxyConfig:
 
     def __init__(self, conf_file_path: str) -> None:
         try:
-            self.source: Dict[str, Any] = cached_yaml_load(conf_file_path)
+            self.source: dict[str, Any] = cached_yaml_load(conf_file_path)
         except yaml.parser.ParserError as e:
             print("Unable to load user configuration file")
             raise e
@@ -127,12 +124,12 @@ class ProviderConfig(yaml.YAMLObject):
     name: str
     group: str
     priority: int = 0  # Set default priority to 0
-    roles: List[str]
+    roles: list[str]
     description: str
     url: str
     api: PluginConfig
     search: PluginConfig
-    products: Dict[str, Any]
+    products: dict[str, Any]
     download: PluginConfig
     auth: PluginConfig
     search_auth: PluginConfig
@@ -154,7 +151,7 @@ class ProviderConfig(yaml.YAMLObject):
         return loader.construct_yaml_object(node, cls)
 
     @classmethod
-    def from_mapping(cls, mapping: Dict[str, Any]) -> ProviderConfig:
+    def from_mapping(cls, mapping: dict[str, Any]) -> ProviderConfig:
         """Build a :class:`~eodag.config.ProviderConfig` from a mapping"""
         cls.validate(mapping)
         for key in PLUGINS_TOPICS_KEYS:
@@ -165,7 +162,7 @@ class ProviderConfig(yaml.YAMLObject):
         return c
 
     @staticmethod
-    def validate(config_keys: Union[Tuple[str, ...], Dict[str, Any]]) -> None:
+    def validate(config_keys: Union[tuple[str, ...], dict[str, Any]]) -> None:
         """Validate a :class:`~eodag.config.ProviderConfig`
 
         :param config_keys: The configurations keys to validate
@@ -181,7 +178,7 @@ class ProviderConfig(yaml.YAMLObject):
                 "type of plugin"
             )
 
-    def update(self, mapping: Optional[Dict[str, Any]]) -> None:
+    def update(self, mapping: Optional[dict[str, Any]]) -> None:
         """Update the configuration parameters with values from `mapping`
 
         :param mapping: The mapping from which to override configuration parameters
@@ -197,7 +194,7 @@ class ProviderConfig(yaml.YAMLObject):
             },
         )
         for key in PLUGINS_TOPICS_KEYS:
-            current_value: Optional[Dict[str, Any]] = getattr(self, key, None)
+            current_value: Optional[dict[str, Any]] = getattr(self, key, None)
             mapping_value = mapping.get(key, {})
             if current_value is not None:
                 current_value.update(mapping_value)
@@ -240,14 +237,14 @@ class PluginConfig(yaml.YAMLObject):
         """Configuration for sort during search"""
 
         #: Default sort settings
-        sort_by_default: List[Tuple[str, str]]
+        sort_by_default: list[tuple[str, str]]
         #: F-string template to add to :attr:`~eodag.config.PluginConfig.Pagination.next_page_url_tpl` to sort search
         #: results
         sort_by_tpl: str
         #: Mapping between eodag and provider query parameters used for sort
-        sort_param_mapping: Dict[str, str]
+        sort_param_mapping: dict[str, str]
         #: Mapping between eodag and provider sort-order parameters
-        sort_order_mapping: Dict[Literal["ascending", "descending"], str]
+        sort_order_mapping: dict[Literal["ascending", "descending"], str]
         #: Maximum number of allowed sort parameters per request
         max_sort_params: Annotated[int, Gt(0)]
 
@@ -271,7 +268,7 @@ class PluginConfig(yaml.YAMLObject):
         #: HTTP method used to fetch product types
         fetch_method: str
         #: Request body to fetch product types using POST method
-        fetch_body: Dict[str, Any]
+        fetch_body: dict[str, Any]
         #: Maximum number of connections for concurrent HTTP requests
         max_connections: int
         #: The f-string template for pagination requests.
@@ -286,17 +283,17 @@ class PluginConfig(yaml.YAMLObject):
         generic_product_type_id: str
         #: Mapping for product type metadata (e.g. ``abstract``, ``licence``) which can be parsed from the provider
         #: result
-        generic_product_type_parsable_metadata: Dict[str, str]
+        generic_product_type_parsable_metadata: dict[str, str]
         #: Mapping for product type properties which can be parsed from the result and are not product type metadata
-        generic_product_type_parsable_properties: Dict[str, str]
+        generic_product_type_parsable_properties: dict[str, str]
         #: Mapping for product type properties which cannot be parsed from the result and are not product type metadata
-        generic_product_type_unparsable_properties: Dict[str, str]
+        generic_product_type_unparsable_properties: dict[str, str]
         #: URL to fetch data for a single collection
         single_collection_fetch_url: str
         #: Query string to be added to the fetch_url to filter for a collection
         single_collection_fetch_qs: str
         #: Mapping for product type metadata returned by the endpoint given in single_collection_fetch_url
-        single_product_type_parsable_metadata: Dict[str, str]
+        single_product_type_parsable_metadata: dict[str, str]
 
     class DiscoverQueryables(TypedDict, total=False):
         """Configuration for queryables discovery"""
@@ -318,7 +315,7 @@ class PluginConfig(yaml.YAMLObject):
         """Configuration for order on-response during download"""
 
         #: Parameters metadata-mapping to apply to the order response
-        metadata_mapping: Dict[str, Union[str, List[str]]]
+        metadata_mapping: dict[str, Union[str, list[str]]]
 
     class OrderStatusSuccess(TypedDict):
         """
@@ -351,7 +348,7 @@ class PluginConfig(yaml.YAMLObject):
         #: Request HTTP method
         method: str
         #: Request hearders
-        headers: Dict[str, Any]
+        headers: dict[str, Any]
 
     class OrderStatusOnSuccess(TypedDict, total=False):
         """Configuration for order status on-success during download"""
@@ -363,7 +360,7 @@ class PluginConfig(yaml.YAMLObject):
         #: Key in the success response that gives access to the result
         results_entry: str
         #: Metadata-mapping to apply to the success status result
-        metadata_mapping: Dict[str, Union[str, List[str]]]
+        metadata_mapping: dict[str, Union[str, list[str]]]
 
     class OrderStatus(TypedDict, total=False):
         """Configuration for order status during download"""
@@ -371,11 +368,11 @@ class PluginConfig(yaml.YAMLObject):
         #: Order status request configuration
         request: PluginConfig.OrderStatusRequest
         #: Metadata-mapping used to parse order status response
-        metadata_mapping: Dict[str, Union[str, List[str]]]
+        metadata_mapping: dict[str, Union[str, list[str]]]
         #: Configuration to identify order status success during download
         success: PluginConfig.OrderStatusSuccess
         #: Part of the order status response that tells there is an error
-        error: Dict[str, Any]
+        error: dict[str, Any]
         #: Configuration to identify order status ordered during download
         ordered: PluginConfig.OrderStatusOrdered
         #: Configuration for order status on-success during download
@@ -400,7 +397,7 @@ class PluginConfig(yaml.YAMLObject):
     #: :class:`~eodag.plugins.base.PluginTopic` Default s3 bucket
     s3_bucket: str
     #: :class:`~eodag.plugins.base.PluginTopic` Authentication error codes
-    auth_error_code: Union[int, List[int]]
+    auth_error_code: Union[int, list[int]]
     #: :class:`~eodag.plugins.base.PluginTopic` Time to wait until request timeout in seconds
     timeout: float
     #: :class:`~eodag.plugins.base.PluginTopic` :class:`urllib3.util.Retry` ``total`` parameter,
@@ -411,13 +408,13 @@ class PluginConfig(yaml.YAMLObject):
     retry_backoff_factor: int
     #: :class:`~eodag.plugins.base.PluginTopic` :class:`urllib3.util.Retry` ``status_forcelist`` parameter,
     #: list of integer HTTP status codes that we should force a retry on
-    retry_status_forcelist: List[int]
+    retry_status_forcelist: list[int]
 
     # search & api -----------------------------------------------------------------------------------------------------
     # copied from ProviderConfig in PluginManager.get_search_plugins()
     priority: int
     # per product type metadata-mapping, set in core._prepare_search
-    product_type_config: Dict[str, Any]
+    product_type_config: dict[str, Any]
 
     #: :class:`~eodag.plugins.search.base.Search` Plugin API endpoint
     api_endpoint: str
@@ -439,15 +436,18 @@ class PluginConfig(yaml.YAMLObject):
     #: :class:`~eodag.plugins.search.base.Search` Configuration for the queryables auto-discovery
     discover_queryables: PluginConfig.DiscoverQueryables
     #: :class:`~eodag.plugins.search.base.Search` The mapping between eodag metadata and the plugin specific metadata
-    metadata_mapping: Dict[str, Union[str, List[str]]]
+    metadata_mapping: dict[str, Union[str, list[str]]]
     #: :class:`~eodag.plugins.search.base.Search` Parameters to remove from queryables
-    remove_from_queryables: List[str]
+    remove_from_queryables: list[str]
     #: :class:`~eodag.plugins.search.base.Search` Parameters to be passed as is in the search url query string
-    literal_search_params: Dict[str, str]
+    literal_search_params: dict[str, str]
     #: :class:`~eodag.plugins.search.qssearch.QueryStringSearch` Characters that should not be quoted in the url params
-    dont_quote: List[str]
+    dont_quote: list[str]
+    #: :class:`~eodag.plugins.search.qssearch.QueryStringSearch` Guess assets keys using their ``href``.
+    #: Use their original key if ``False``
+    asset_key_from_href: bool
     #: :class:`~eodag.plugins.search.qssearch.ODataV4Search` Dict describing free text search request build
-    free_text_search_operations: Dict[str, Any]
+    free_text_search_operations: dict[str, Any]
     #: :class:`~eodag.plugins.search.qssearch.ODataV4Search` Set to ``True`` if the metadata is not given in the search
     #: result and a two step search has to be performed
     per_product_metadata_query: bool
@@ -464,11 +464,11 @@ class PluginConfig(yaml.YAMLObject):
     #: if date parameters are mandatory in the request
     dates_required: bool
     #: :class:`~eodag.plugins.search.csw.CSWSearch` Search definition dictionary
-    search_definition: Dict[str, Any]
+    search_definition: dict[str, Any]
     #: :class:`~eodag.plugins.search.qssearch.PostJsonSearch` Whether to merge responses or not (`aws_eos` specific)
     merge_responses: bool
     #: :class:`~eodag.plugins.search.qssearch.PostJsonSearch` Collections names (`aws_eos` specific)
-    collection: List[str]
+    collection: list[str]
     #: :class:`~eodag.plugins.search.static_stac_search.StaticStacSearch`
     #: Maximum number of connections for concurrent HTTP requests
     max_connections: int
@@ -477,7 +477,7 @@ class PluginConfig(yaml.YAMLObject):
     end_date_excluded: bool
     #: :class:`~eodag.plugins.search.build_search_result.ECMWFSearch`
     #: List of parameters used to parse metadata but that must not be included to the query
-    remove_from_query: List[str]
+    remove_from_query: list[str]
     #: :class:`~eodag.plugins.search.csw.CSWSearch`
     #: OGC Catalogue Service version
     version: str
@@ -501,13 +501,13 @@ class PluginConfig(yaml.YAMLObject):
     #: :class:`~eodag.plugins.download.base.Download` Whether ignore assets and download using ``downloadLink`` or not
     ignore_assets: bool
     #: :class:`~eodag.plugins.download.base.Download` Product type specific configuration
-    products: Dict[str, Dict[str, Any]]
+    products: dict[str, dict[str, Any]]
     #: :class:`~eodag.plugins.download.http.HTTPDownload` Whether the product has to be ordered to download it or not
     order_enabled: bool
     #: :class:`~eodag.plugins.download.http.HTTPDownload` HTTP request method for the order request
     order_method: str
     #: :class:`~eodag.plugins.download.http.HTTPDownload` Headers to be added to the order request
-    order_headers: Dict[str, str]
+    order_headers: dict[str, str]
     #: :class:`~eodag.plugins.download.http.HTTPDownload`
     #: Dictionary containing the key :attr:`~eodag.config.PluginConfig.metadata_mapping` which can be used to add new
     #: product properties based on the data in response to the order request
@@ -518,7 +518,7 @@ class PluginConfig(yaml.YAMLObject):
     #: Do not authenticate the download request but only the order and order status ones
     no_auth_download: bool
     #: :class:`~eodag.plugins.download.http.HTTPDownload` Parameters to be added to the query params of the request
-    dl_url_params: Dict[str, str]
+    dl_url_params: dict[str, str]
     #: :class:`~eodag.plugins.download.s3rest.S3RestDownload`
     #: At which level of the path part of the url the bucket can be found
     bucket_path_level: int
@@ -529,15 +529,15 @@ class PluginConfig(yaml.YAMLObject):
 
     # auth -------------------------------------------------------------------------------------------------------------
     #: :class:`~eodag.plugins.authentication.base.Authentication` Authentication credentials dictionary
-    credentials: Dict[str, str]
+    credentials: dict[str, str]
     #: :class:`~eodag.plugins.authentication.base.Authentication` Authentication URL
     auth_uri: str
     #: :class:`~eodag.plugins.authentication.base.Authentication`
     #: Dictionary containing all keys/value pairs that should be added to the headers
-    headers: Dict[str, str]
+    headers: dict[str, str]
     #: :class:`~eodag.plugins.authentication.base.Authentication`
     #: Dictionary containing all keys/value pairs that should be added to the headers for token retrieve only
-    retrieve_headers: Dict[str, str]
+    retrieve_headers: dict[str, str]
     #: :class:`~eodag.plugins.authentication.base.Authentication`
     #: The key pointing to the token in the response from the token server
     token_key: str
@@ -549,7 +549,7 @@ class PluginConfig(yaml.YAMLObject):
     matching_url: str
     #: :class:`~eodag.plugins.authentication.base.Authentication` Part of the search or download plugin configuration
     #: that needs authentication
-    matching_conf: Dict[str, Any]
+    matching_conf: dict[str, Any]
     #: :class:`~eodag.plugins.authentication.openid_connect.OIDCRefreshTokenBase`
     #: How the token should be used in the request
     token_provision: str
@@ -561,7 +561,7 @@ class PluginConfig(yaml.YAMLObject):
     #: The OIDC provider's ``.well-known/openid-configuration`` url.
     oidc_config_url: str
     #: :class:`~eodag.plugins.authentication.openid_connect.OIDCRefreshTokenBase` The OIDC token audiences
-    allowed_audiences: List[str]
+    allowed_audiences: list[str]
     #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
     #: Whether a user consent is needed during the authentication or not
     user_consent_needed: str
@@ -585,16 +585,16 @@ class PluginConfig(yaml.YAMLObject):
     user_consent_form_xpath: str
     #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
     #: The data that will be passed with the POST request on the form 'action' URL
-    user_consent_form_data: Dict[str, str]
+    user_consent_form_data: dict[str, str]
     #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
     #: Additional data to be passed to the login POST request
-    additional_login_form_data: Dict[str, str]
+    additional_login_form_data: dict[str, str]
     #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
     #: Key/value pairs of patterns/messages used for Authentication errors
-    exchange_url_error_pattern: Dict[str, str]
+    exchange_url_error_pattern: dict[str, str]
     #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
     #: A mapping between OIDC url query string and token handler query string params
-    token_exchange_params: Dict[str, str]
+    token_exchange_params: dict[str, str]
     #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
     #: Refers to the name of the query param to be used in the query request
     token_qs_key: str
@@ -608,7 +608,7 @@ class PluginConfig(yaml.YAMLObject):
     signed_url_key: str
     #: :class:`~eodag.plugins.authentication.token.TokenAuth`
     #: Credentials json structure if they should be sent as POST data
-    req_data: Dict[str, Any]
+    req_data: dict[str, Any]
     #: :class:`~eodag.plugins.authentication.token.TokenAuth`
     #: URL used to fetch the access token with a refresh token
     refresh_uri: str
@@ -618,7 +618,7 @@ class PluginConfig(yaml.YAMLObject):
     #: :class:`~eodag.plugins.authentication.token_exchange.OIDCTokenExchangeAuth`
     #: The full :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth` plugin configuration
     #: used to retrieve subject token
-    subject: Dict[str, Any]
+    subject: dict[str, Any]
     #: :class:`~eodag.plugins.authentication.token_exchange.OIDCTokenExchangeAuth`
     #: Identifies the issuer of the `subject_token`
     subject_issuer: str
@@ -640,21 +640,21 @@ class PluginConfig(yaml.YAMLObject):
         return loader.construct_yaml_object(node, cls)
 
     @classmethod
-    def from_mapping(cls, mapping: Dict[str, Any]) -> PluginConfig:
+    def from_mapping(cls, mapping: dict[str, Any]) -> PluginConfig:
         """Build a :class:`~eodag.config.PluginConfig` from a mapping"""
         c = cls()
         c.__dict__.update(mapping)
         return c
 
     @staticmethod
-    def validate(config_keys: Tuple[Any, ...]) -> None:
+    def validate(config_keys: tuple[Any, ...]) -> None:
         """Validate a :class:`~eodag.config.PluginConfig`"""
         if "type" not in config_keys:
             raise ValidationError(
                 "A Plugin config must specify the Plugin it configures"
             )
 
-    def update(self, mapping: Optional[Dict[Any, Any]]) -> None:
+    def update(self, mapping: Optional[dict[Any, Any]]) -> None:
         """Update the configuration parameters with values from `mapping`
 
         :param mapping: The mapping from which to override configuration parameters
@@ -666,7 +666,7 @@ class PluginConfig(yaml.YAMLObject):
         )
 
 
-def load_default_config() -> Dict[str, ProviderConfig]:
+def load_default_config() -> dict[str, ProviderConfig]:
     """Load the providers configuration into a dictionary.
 
     Load from eodag `resources/providers.yml` or `EODAG_PROVIDERS_CFG_FILE` environment
@@ -674,24 +674,24 @@ def load_default_config() -> Dict[str, ProviderConfig]:
 
     :returns: The default provider's configuration
     """
-    eodag_providers_cfg_file = os.getenv(
-        "EODAG_PROVIDERS_CFG_FILE"
-    ) or resource_filename("eodag", "resources/providers.yml")
+    eodag_providers_cfg_file = os.getenv("EODAG_PROVIDERS_CFG_FILE") or str(
+        res_files("eodag") / "resources" / "providers.yml"
+    )
     return load_config(eodag_providers_cfg_file)
 
 
-def load_config(config_path: str) -> Dict[str, ProviderConfig]:
+def load_config(config_path: str) -> dict[str, ProviderConfig]:
     """Load the providers configuration into a dictionary from a given file
 
     :param config_path: The path to the provider config file
     :returns: The default provider's configuration
     """
     logger.debug("Loading configuration from %s", config_path)
-    config: Dict[str, ProviderConfig] = {}
+    config: dict[str, ProviderConfig] = {}
     try:
         # Providers configs are stored in this file as separated yaml documents
         # Load all of it
-        providers_configs: List[ProviderConfig] = cached_yaml_load_all(config_path)
+        providers_configs: list[ProviderConfig] = cached_yaml_load_all(config_path)
     except yaml.parser.ParserError as e:
         logger.error("Unable to load configuration")
         raise e
@@ -714,7 +714,7 @@ def credentials_in_auth(auth_conf: PluginConfig) -> bool:
 
 
 def share_credentials(
-    providers_config: Dict[str, ProviderConfig],
+    providers_config: dict[str, ProviderConfig],
 ) -> None:
     """Share credentials between plugins having the same matching criteria
 
@@ -758,7 +758,7 @@ def share_credentials(
 
 def provider_config_init(
     provider_config: ProviderConfig,
-    stac_search_default_conf: Optional[Dict[str, Any]] = None,
+    stac_search_default_conf: Optional[dict[str, Any]] = None,
 ) -> None:
     """Applies some default values to provider config
 
@@ -782,6 +782,7 @@ def provider_config_init(
             and provider_config.search.type
             in [
                 "StacSearch",
+                "StacListAssets",
                 "StaticStacSearch",
             ]
         ):
@@ -796,7 +797,7 @@ def provider_config_init(
         pass
 
 
-def override_config_from_file(config: Dict[str, Any], file_path: str) -> None:
+def override_config_from_file(config: dict[str, Any], file_path: str) -> None:
     """Override a configuration with the values in a file
 
     :param config: An eodag providers configuration dictionary
@@ -814,14 +815,14 @@ def override_config_from_file(config: Dict[str, Any], file_path: str) -> None:
     override_config_from_mapping(config, config_in_file)
 
 
-def override_config_from_env(config: Dict[str, Any]) -> None:
+def override_config_from_env(config: dict[str, Any]) -> None:
     """Override a configuration with environment variables values
 
     :param config: An eodag providers configuration dictionary
     """
 
     def build_mapping_from_env(
-        env_var: str, env_value: str, mapping: Dict[str, Any]
+        env_var: str, env_value: str, mapping: dict[str, Any]
     ) -> None:
         """Recursively build a dictionary from an environment variable.
 
@@ -872,7 +873,7 @@ def override_config_from_env(config: Dict[str, Any]) -> None:
             new_map = mapping.setdefault(parts[0], {})
             build_mapping_from_env("__".join(parts[1:]), env_value, new_map)
 
-    mapping_from_env: Dict[str, Any] = {}
+    mapping_from_env: dict[str, Any] = {}
     for env_var in os.environ:
         if env_var.startswith("EODAG__"):
             build_mapping_from_env(
@@ -885,7 +886,7 @@ def override_config_from_env(config: Dict[str, Any]) -> None:
 
 
 def override_config_from_mapping(
-    config: Dict[str, Any], mapping: Dict[str, Any]
+    config: dict[str, Any], mapping: dict[str, Any]
 ) -> None:
     """Override a configuration with the values in a mapping
 
@@ -923,7 +924,7 @@ def override_config_from_mapping(
                 )
 
         # try overriding conf
-        old_conf: Optional[Dict[str, Any]] = config.get(provider)
+        old_conf: Optional[dict[str, Any]] = config.get(provider)
         if old_conf is not None:
             old_conf.update(new_conf)
         else:
@@ -944,7 +945,7 @@ def override_config_from_mapping(
                 logger.debug(tb.format_exc())
 
 
-def merge_configs(config: Dict[str, Any], other_config: Dict[str, Any]) -> None:
+def merge_configs(config: dict[str, Any], other_config: dict[str, Any]) -> None:
     """Override a configuration with the values of another configuration
 
     :param config: An eodag providers configuration dictionary
@@ -976,7 +977,7 @@ def merge_configs(config: Dict[str, Any], other_config: Dict[str, Any]) -> None:
             config[provider] = new_conf
 
 
-def load_yml_config(yml_path: str) -> Dict[Any, Any]:
+def load_yml_config(yml_path: str) -> dict[Any, Any]:
     """Load a conf dictionary from given yml absolute path
 
     :returns: The yml configuration file
@@ -985,39 +986,35 @@ def load_yml_config(yml_path: str) -> Dict[Any, Any]:
     return dict_items_recursive_apply(config.source, string_to_jsonpath)
 
 
-def load_stac_config() -> Dict[str, Any]:
+def load_stac_config() -> dict[str, Any]:
     """Load the stac configuration into a dictionary
 
     :returns: The stac configuration
     """
-    return load_yml_config(
-        resource_filename("eodag", os.path.join("resources/", "stac.yml"))
-    )
+    return load_yml_config(str(res_files("eodag") / "resources" / "stac.yml"))
 
 
-def load_stac_api_config() -> Dict[str, Any]:
+def load_stac_api_config() -> dict[str, Any]:
     """Load the stac API configuration into a dictionary
 
     :returns: The stac API configuration
     """
-    return load_yml_config(
-        resource_filename("eodag", os.path.join("resources/", "stac_api.yml"))
-    )
+    return load_yml_config(str(res_files("eodag") / "resources" / "stac_api.yml"))
 
 
-def load_stac_provider_config() -> Dict[str, Any]:
+def load_stac_provider_config() -> dict[str, Any]:
     """Load the stac provider configuration into a dictionary
 
     :returns: The stac provider configuration
     """
     return SimpleYamlProxyConfig(
-        resource_filename("eodag", os.path.join("resources/", "stac_provider.yml"))
+        str(res_files("eodag") / "resources" / "stac_provider.yml")
     ).source
 
 
 def get_ext_product_types_conf(
     conf_uri: str = EXT_PRODUCT_TYPES_CONF_URI,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Read external product types conf
 
     :param conf_uri: URI to local or remote configuration file

eodag/plugins/apis/base.py

@@ -57,5 +57,5 @@ class Api(Search, Download):
     :param provider: An EODAG provider name
     :type provider: str
     :param config: An EODAG plugin configuration
-    :type config: Dict[str, Any]
+    :type config: dict[str, Any]
     """

eodag/plugins/apis/ecmwf.py

@@ -30,11 +30,7 @@ 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 (
-    ECMWF_KEYWORDS,
-    ECMWFSearch,
-    keywords_to_mdt,
-)
+from eodag.plugins.search.build_search_result import ECMWFSearch, ecmwf_mtd
 from eodag.utils import (
     DEFAULT_DOWNLOAD_TIMEOUT,
     DEFAULT_DOWNLOAD_WAIT,
@@ -48,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
 
@@ -83,7 +80,7 @@ class EcmwfApi(Api, ECMWFSearch):
         * :attr:`~eodag.config.PluginConfig.type` (``str``) (**mandatory**): EcmwfApi
         * :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
+        * :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
@@ -93,7 +90,7 @@ class EcmwfApi(Api, ECMWFSearch):
     def __init__(self, provider: str, config: PluginConfig) -> None:
         # init self.config.metadata_mapping using Search Base plugin
         config.metadata_mapping = {
-            **keywords_to_mdt(ECMWF_KEYWORDS, "ecmwf"),
+            **ecmwf_mtd(),
             **config.metadata_mapping,
         }
         Search.__init__(self, provider, config)
@@ -104,7 +101,7 @@ class EcmwfApi(Api, ECMWFSearch):
         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 [{}]
 
@@ -112,7 +109,7 @@ class EcmwfApi(Api, ECMWFSearch):
         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
@@ -145,7 +142,7 @@ class EcmwfApi(Api, ECMWFSearch):
 
         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
@@ -176,7 +173,7 @@ class EcmwfApi(Api, ECMWFSearch):
     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: float = DEFAULT_DOWNLOAD_WAIT,
         timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
@@ -265,13 +262,13 @@ class EcmwfApi(Api, ECMWFSearch):
     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: float = DEFAULT_DOWNLOAD_WAIT,
         timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
         **kwargs: Unpack[DownloadConf],
-    ) -> List[str]:
+    ) -> list[str]:
         """
         Download all using parent (base plugin) method
         """
@@ -291,7 +288,7 @@ class EcmwfApi(Api, ECMWFSearch):
 
     def discover_queryables(
         self, **kwargs: Any
-    ) -> Optional[Dict[str, Annotated[Any, FieldInfo]]]:
+    ) -> Optional[dict[str, Annotated[Any, FieldInfo]]]:
         """Fetch queryables list from provider using metadata mapping
 
         :param kwargs: additional filters for queryables (`productType` and other search