eodag 3.0.1__py3-none-any.whl → 3.1.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,15 +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]
-        #: Mapping for product type properties which can be parsed from the result that are not product type metadata
-        generic_product_type_parsable_properties: 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]
+        #: 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]
         #: 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"""
@@ -307,12 +306,16 @@ class PluginConfig(yaml.YAMLObject):
         result_type: str
         #: JsonPath to retrieve the queryables from the provider result
         results_entry: str
+        #: :class:`~eodag.plugins.search.base.Search` URL of the constraint file used to build queryables
+        constraints_url: str
+        #: :class:`~eodag.plugins.search.base.Search` Key in the json result where the constraints can be found
+        constraints_entry: str
 
     class OrderOnResponse(TypedDict):
         """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):
         """
@@ -345,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"""
@@ -357,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"""
@@ -365,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
@@ -394,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,
@@ -405,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
@@ -433,26 +436,15 @@ 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]]]
-    #: :class:`~eodag.plugins.search.base.Search` URL of the constraint file used to build queryables
-    constraints_file_url: str
-    #: :class:`~eodag.plugins.search.base.Search`
-    #: Key which is used in the eodag configuration to map the eodag product type to the provider product type
-    constraints_file_dataset_key: str
-    #: :class:`~eodag.plugins.search.base.Search` Key in the json result where the constraints can be found
-    constraints_entry: str
-    #: :class:`~eodag.plugins.search.base.Search`
-    #: Whether only a provider result containing constraints_entry is accepted as valid and used to create constraints
-    #: or not
-    stop_without_constraints_entry_key: bool
+    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.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
@@ -469,23 +461,25 @@ 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
-    #: :class:`~eodag.plugins.search.build_search_result.BuildSearchResult`
+    #: :class:`~eodag.plugins.search.build_search_result.ECMWFSearch`
     #: Whether end date should be excluded from search request or not
     end_date_excluded: bool
-    #: :class:`~eodag.plugins.search.build_search_result.BuildSearchResult`
+    #: :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
+    #: :class:`~eodag.plugins.apis.ecmwf.EcmwfApi` url of the authentication endpoint
+    auth_endpoint: str
 
     # download ---------------------------------------------------------------------------------------------------------
     #: :class:`~eodag.plugins.download.base.Download` Default endpoint url
@@ -504,13 +498,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
@@ -521,7 +515,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
@@ -532,12 +526,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]
     #: :class:`~eodag.plugins.authentication.base.Authentication`
     #: The key pointing to the token in the response from the token server
     token_key: str
@@ -549,7 +546,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 +558,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 +582,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 +605,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 +615,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 +637,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 +663,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 +671,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 +711,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 +755,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 +779,7 @@ def provider_config_init(
             and provider_config.search.type
             in [
                 "StacSearch",
+                "StacListAssets",
                 "StaticStacSearch",
             ]
         ):
@@ -796,7 +794,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 +812,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 +870,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 +883,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 +921,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 +942,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 +974,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 +983,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]
     """