eodag 3.0.0b2__py3-none-any.whl → 3.0.1__py3-none-any.whl

eodag/config.py

@@ -22,6 +22,7 @@ import os
 import tempfile
 from inspect import isclass
 from typing import (
+    Annotated,
     Any,
     Dict,
     ItemsView,
@@ -44,13 +45,11 @@ import yaml.parser
 from annotated_types import Gt
 from jsonpath_ng import JSONPath
 from pkg_resources import resource_filename
-from requests.auth import AuthBase
-from typing_extensions import Doc
 
+from eodag.api.product.metadata_mapping import mtd_cfg_as_conversion_and_querypath
 from eodag.utils import (
     HTTP_REQ_TIMEOUT,
     USER_AGENT,
-    Annotated,
     cached_yaml_load,
     cached_yaml_load_all,
     cast_scalar_value,
@@ -58,6 +57,7 @@ from eodag.utils import (
     dict_items_recursive_apply,
     merge_mappings,
     slugify,
+    sort_dict,
     string_to_jsonpath,
     update_nested_dict,
     uri_to_path,
@@ -69,6 +69,8 @@ logger = logging.getLogger("eodag.config")
 EXT_PRODUCT_TYPES_CONF_URI = (
     "https://cs-si.github.io/eodag/eodag/resources/ext_product_types.json"
 )
+AUTH_TOPIC_KEYS = ("auth", "search_auth", "download_auth")
+PLUGINS_TOPICS_KEYS = ("api", "search", "download") + AUTH_TOPIC_KEYS
 
 
 class SimpleYamlProxyConfig:
@@ -110,22 +112,16 @@ class ProviderConfig(yaml.YAMLObject):
     """Representation of eodag configuration.
 
     :param name: The name of the provider
-    :type name: str
     :param priority: (optional) The priority of the provider while searching a product.
                      Lower value means lower priority. (Default: 0)
-    :type priority: int
     :param api: (optional) The configuration of a plugin of type Api
-    :type api: :class:`~eodag.config.PluginConfig`
     :param search: (optional) The configuration of a plugin of type Search
-    :type search: :class:`~eodag.config.PluginConfig`
     :param products: (optional) The products types supported by the provider
-    :type products: dict
     :param download: (optional) The configuration of a plugin of type Download
-    :type download: :class:`~eodag.config.PluginConfig`
     :param auth: (optional) The configuration of a plugin of type Authentication
-    :type auth: :class:`~eodag.config.PluginConfig`
+    :param search_auth: (optional) The configuration of a plugin of type Authentication for search
+    :param download_auth: (optional) The configuration of a plugin of type Authentication for download
     :param kwargs: Additional configuration variables for this provider
-    :type kwargs: Any
     """
 
     name: str
@@ -139,6 +135,8 @@ class ProviderConfig(yaml.YAMLObject):
     products: Dict[str, Any]
     download: PluginConfig
     auth: PluginConfig
+    search_auth: PluginConfig
+    download_auth: PluginConfig
     product_types_fetched: bool  # set in core.update_product_types_list
 
     yaml_loader = yaml.Loader
@@ -159,7 +157,7 @@ class ProviderConfig(yaml.YAMLObject):
     def from_mapping(cls, mapping: Dict[str, Any]) -> ProviderConfig:
         """Build a :class:`~eodag.config.ProviderConfig` from a mapping"""
         cls.validate(mapping)
-        for key in ("api", "search", "download", "auth"):
+        for key in PLUGINS_TOPICS_KEYS:
             if key in mapping:
                 mapping[key] = PluginConfig.from_mapping(mapping[key])
         c = cls()
@@ -171,15 +169,13 @@ class ProviderConfig(yaml.YAMLObject):
         """Validate a :class:`~eodag.config.ProviderConfig`
 
         :param config_keys: The configurations keys to validate
-        :type config_keys: dict
         """
         if "name" not in config_keys:
             raise ValidationError("Provider config must have name key")
-        if not any(k in config_keys for k in ("api", "search", "download", "auth")):
+        if not any(k in config_keys for k in PLUGINS_TOPICS_KEYS):
             raise ValidationError("A provider must implement at least one plugin")
-        if "api" in config_keys and any(
-            k in config_keys for k in ("search", "download", "auth")
-        ):
+        non_api_keys = [k for k in PLUGINS_TOPICS_KEYS if k != "api"]
+        if "api" in config_keys and any(k in config_keys for k in non_api_keys):
             raise ValidationError(
                 "A provider implementing an Api plugin must not implement any other "
                 "type of plugin"
@@ -189,7 +185,6 @@ class ProviderConfig(yaml.YAMLObject):
         """Update the configuration parameters with values from `mapping`
 
         :param mapping: The mapping from which to override configuration parameters
-        :type mapping: dict
         """
         if mapping is None:
             mapping = {}
@@ -198,11 +193,10 @@ class ProviderConfig(yaml.YAMLObject):
             {
                 key: value
                 for key, value in mapping.items()
-                if key not in ("name", "api", "search", "download", "auth")
-                and value is not None
+                if key not in PLUGINS_TOPICS_KEYS and value is not None
             },
         )
-        for key in ("api", "search", "download", "auth"):
+        for key in PLUGINS_TOPICS_KEYS:
             current_value: Optional[Dict[str, Any]] = getattr(self, key, None)
             mapping_value = mapping.get(key, {})
             if current_value is not None:
@@ -212,43 +206,112 @@ class ProviderConfig(yaml.YAMLObject):
 
 
 class PluginConfig(yaml.YAMLObject):
-    """Representation of a plugin config
-
-    :param name: The name of the plugin class to use to instantiate the plugin object
-    :type name: str
-    :param metadata_mapping: (optional) The mapping between eodag metadata and
-                                  the plugin specific metadata
-    :type metadata_mapping: dict
-    :param free_params: (optional) Additional configuration parameters
-    :type free_params: dict
+    """Representation of a plugin config.
+
+    This class variables describe available plugins configuration parameters.
     """
 
     class Pagination(TypedDict):
         """Search pagination configuration"""
 
+        #: The maximum number of items per page that the provider can handle
         max_items_per_page: int
+        #: Key path for the number of total items in the provider result
         total_items_nb_key_path: Union[str, JSONPath]
+        #: Key path for the next page URL
         next_page_url_key_path: Union[str, JSONPath]
+        #: Key path for the next page POST request query-object (body)
         next_page_query_obj_key_path: Union[str, JSONPath]
+        # TODO: change this typing to bool and adapt code to it
         next_page_merge_key_path: Union[str, JSONPath]
+        #: Template to add to :attr:`~eodag.config.PluginConfig.Pagination.next_page_url_tpl` to enable count in
+        #: search request
         count_tpl: str
+        #: The f-string template for pagination requests.
         next_page_url_tpl: str
+        #: The query-object for POST pagination requests.
         next_page_query_obj: str
+        #: The endpoint for counting the number of items satisfying a request
         count_endpoint: str
+        #: Index of the starting page
         start_page: int
 
     class Sort(TypedDict):
         """Configuration for sort during search"""
 
+        #: Default sort settings
         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]
+        #: Mapping between eodag and provider sort-order parameters
         sort_order_mapping: Dict[Literal["ascending", "descending"], str]
+        #: Maximum number of allowed sort parameters per request
         max_sort_params: Annotated[int, Gt(0)]
 
+    class DiscoverMetadata(TypedDict):
+        """Configuration for metadata discovery (search result properties)"""
+
+        #: Whether metadata discovery is enabled or not
+        auto_discovery: bool
+        #: Metadata regex pattern used for discovery in search result properties
+        metadata_pattern: str
+        #: Configuration/template that will be used to query for a discovered parameter
+        search_param: str
+        #: Path to the metadata in search result
+        metadata_path: str
+
+    class DiscoverProductTypes(TypedDict, total=False):
+        """Configuration for product types discovery"""
+
+        #: URL from which the product types can be fetched
+        fetch_url: Optional[str]
+        #: HTTP method used to fetch product types
+        fetch_method: str
+        #: Request body to fetch product types using POST method
+        fetch_body: Dict[str, Any]
+        #: Maximum number of connections for concurrent HTTP requests
+        max_connections: int
+        #: The f-string template for pagination requests.
+        next_page_url_tpl: str
+        #: Index of the starting page for pagination requests.
+        start_page: int
+        #: Type of the provider result
+        result_type: str
+        #: JsonPath to the list of product types
+        results_entry: Union[JSONPath, str]
+        #: Mapping for the product type id
+        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]
+        #: 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]
+
+    class DiscoverQueryables(TypedDict, total=False):
+        """Configuration for queryables discovery"""
+
+        #: URL to fetch the queryables valid for all product types
+        fetch_url: Optional[str]
+        #: URL to fetch the queryables for a specific product type
+        product_type_fetch_url: Optional[str]
+        #: Type of the result
+        result_type: str
+        #: JsonPath to retrieve the queryables from the provider result
+        results_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]]]
 
     class OrderStatusSuccess(TypedDict):
@@ -259,136 +322,312 @@ class PluginConfig(yaml.YAMLObject):
         At least one is required
         """
 
-        status: Annotated[str, Doc("Variable in the order status response json body")]
-        message: Annotated[str, Doc("Variable in the order status response json body")]
-        http_code: Annotated[int, Doc("HTTP code of the order status response")]
+        #: Success value for ``status``
+        status: str
+        #: Success value for ``message``
+        message: str
+        #: Success value for status response HTTP code
+        http_code: int
 
-    class OrderStatusOrdered(TypedDict):
+    class OrderStatusOrdered(TypedDict, total=False):
         """
         Configuration to identify order status ordered during download
         """
 
-        http_code: Annotated[int, Doc("HTTP code of the order status response")]
+        #: HTTP code of the order status response
+        http_code: int
 
-    class OrderStatusRequest(TypedDict):
+    class OrderStatusRequest(TypedDict, total=False):
         """
         Order status request configuration
         """
 
-        method: Annotated[str, Doc("Request HTTP method")]
-        headers: Annotated[Dict[str, Any], Doc("Request hearders")]
+        #: Request HTTP method
+        method: str
+        #: Request hearders
+        headers: Dict[str, Any]
 
-    class OrderStatusOnSuccess(TypedDict):
+    class OrderStatusOnSuccess(TypedDict, total=False):
         """Configuration for order status on-success during download"""
 
-        need_search: Annotated[bool, Doc("If a new search is needed on success")]
+        #: Whether a new search is needed on success or not
+        need_search: bool
+        #: Return type of the success result
         result_type: str
+        #: 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]]]
 
-    class OrderStatus(TypedDict):
+    class OrderStatus(TypedDict, total=False):
         """Configuration for order status during download"""
 
+        #: Order status request configuration
         request: PluginConfig.OrderStatusRequest
-        metadata_mapping: Annotated[
-            Dict[str, Union[str, List[str]]],
-            Doc("Metadata-mapping used to parse order status response"),
-        ]
+        #: Metadata-mapping used to parse order status response
+        metadata_mapping: Dict[str, Union[str, List[str]]]
+        #: Configuration to identify order status success during download
         success: PluginConfig.OrderStatusSuccess
-        error: Annotated[
-            Dict[str, Any],
-            Doc("Part of the order status response that tells there is an error"),
-        ]
+        #: Part of the order status response that tells there is an error
+        error: Dict[str, Any]
+        #: Configuration to identify order status ordered during download
         ordered: PluginConfig.OrderStatusOrdered
+        #: Configuration for order status on-success during download
         on_success: PluginConfig.OrderStatusOnSuccess
 
+    class MetadataPreMapping(TypedDict, total=False):
+        """Configuration which can be used to simplify further metadata extraction"""
+
+        #: JsonPath of the metadata entry
+        metadata_path: str
+        #: Key to get the metadata id
+        metadata_path_id: str
+        #: Key to get the metadata value
+        metadata_path_value: str
+
+    #: :class:`~eodag.plugins.base.PluginTopic` The name of the plugin class to use to instantiate the plugin object
     name: str
+    #: :class:`~eodag.plugins.base.PluginTopic` Plugin type
     type: str
-
-    # search & api ---------------------------------------------------------------------
-    priority: int  # copied from ProviderConfig in PluginManager.get_search_plugins()
-    products: Dict[
-        str, Any
-    ]  # copied from ProviderConfig in PluginManager.get_search_plugins()
-    product_type_config: Dict[str, Any]  # set in core._prepare_search
-    auth: Union[AuthBase, Dict[str, str]]  # set in core._do_search
+    #: :class:`~eodag.plugins.base.PluginTopic` Whether the ssl certificates should be verified in the request or not
+    ssl_verify: bool
+    #: :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]]
+    #: :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,
+    #: total number of retries to allow
+    retry_total: int
+    #: :class:`~eodag.plugins.base.PluginTopic` :class:`urllib3.util.Retry` ``backoff_factor`` parameter,
+    #: backoff factor to apply between attempts after the second try
+    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]
+
+    # 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]
+
+    #: :class:`~eodag.plugins.search.base.Search` Plugin API endpoint
     api_endpoint: str
+    #: :class:`~eodag.plugins.search.base.Search` Whether Search plugin needs authentification or not
     need_auth: bool
+    #: :class:`~eodag.plugins.search.base.Search` Return type of the provider result
     result_type: str
+    #: :class:`~eodag.plugins.search.base.Search`
+    #: Key in the provider search result that gives access to the result entries
     results_entry: str
+    #: :class:`~eodag.plugins.search.base.Search` Dict containing parameters for pagination
     pagination: PluginConfig.Pagination
+    #: :class:`~eodag.plugins.search.base.Search` Configuration for sorting the results
     sort: PluginConfig.Sort
-    query_params_key: str
-    discover_metadata: Dict[str, Union[str, bool]]
-    discover_product_types: Dict[str, Any]
-    discover_queryables: Dict[str, Any]
+    #: :class:`~eodag.plugins.search.base.Search` Configuration for the metadata auto-discovery
+    discover_metadata: PluginConfig.DiscoverMetadata
+    #: :class:`~eodag.plugins.search.base.Search` Configuration for the product types auto-discovery
+    discover_product_types: PluginConfig.DiscoverProductTypes
+    #: :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]]]
-    free_params: Dict[Any, Any]
+    #: :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
+    #: :class:`~eodag.plugins.search.base.Search` Parameters to remove from queryables
     remove_from_queryables: List[str]
-    free_text_search_operations: Dict[str, Any]  # ODataV4Search
-    metadata_pre_mapping: Dict[str, Any]  # ODataV4Search
-    data_request_url: str  # DataRequestSearch
-    status_url: str  # DataRequestSearch
-    result_url: str  # DataRequestSearch
-    search_definition: Dict[str, Any]  # CSWSearch
-    merge_responses: bool  # PostJsonSearch for aws_eos
-    collection: bool  # PostJsonSearch for aws_eos
-    max_connections: int  # StaticStacSearch
-    timeout: float  # StaticStacSearch
-    s3_bucket: str  # CreodiasS3Search
-    end_date_excluded: bool  # BuildSearchResult
-    remove_from_query: List[str]  # BuildSearchResult
-    ssl_verify: bool
-
-    # download -------------------------------------------------------------------------
+    #: :class:`~eodag.plugins.search.base.Search` Parameters to be passed as is in the search url query string
+    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]
+    #: :class:`~eodag.plugins.search.qssearch.ODataV4Search` Dict describing free text search request build
+    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
+    #: :class:`~eodag.plugins.search.qssearch.ODataV4Search` Dict used to simplify further metadata extraction
+    metadata_pre_mapping: PluginConfig.MetadataPreMapping
+    #: :class:`~eodag.plugins.search.data_request_search.DataRequestSearch` URL to which the data request shall be sent
+    data_request_url: str
+    #: :class:`~eodag.plugins.search.data_request_search.DataRequestSearch` URL to fetch the status of the data request
+    status_url: str
+    #: :class:`~eodag.plugins.search.data_request_search.DataRequestSearch`
+    #: URL to fetch the search result when the data request is done
+    result_url: str
+    #: :class:`~eodag.plugins.search.data_request_search.DataRequestSearch`
+    #: 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]
+    #: :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]
+    #: :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`
+    #: Whether end date should be excluded from search request or not
+    end_date_excluded: bool
+    #: :class:`~eodag.plugins.search.build_search_result.BuildSearchResult`
+    #: List of parameters used to parse metadata but that must not be included to the query
+    remove_from_query: List[str]
+    #: :class:`~eodag.plugins.search.csw.CSWSearch`
+    #: OGC Catalogue Service version
+    version: str
+
+    # download ---------------------------------------------------------------------------------------------------------
+    #: :class:`~eodag.plugins.download.base.Download` Default endpoint url
     base_uri: str
-    outputs_prefix: str
+    #: :class:`~eodag.plugins.download.base.Download` Where to store downloaded products, as an absolute file path
+    output_dir: str
+    #: :class:`~eodag.plugins.download.base.Download`
+    #: Whether the content of the downloaded file should be extracted or not
     extract: bool
-    outputs_extension: str
-    order_enabled: bool  # HTTPDownload
-    order_method: str  # HTTPDownload
-    order_headers: Dict[str, str]  # HTTPDownload
-
+    #: :class:`~eodag.plugins.download.base.Download` Which extension should be used for the downloaded file
+    output_extension: str
+    #: :class:`~eodag.plugins.download.base.Download` Whether the directory structure should be flattened or not
+    flatten_top_dirs: bool
+    #: :class:`~eodag.plugins.download.base.Download` Level in extracted path tree where to find data
+    archive_depth: int
+    #: :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]]
+    #: :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]
+    #: :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
     order_on_response: PluginConfig.OrderOnResponse
+    #: :class:`~eodag.plugins.download.http.HTTPDownload` Order status handling
     order_status: PluginConfig.OrderStatus
-    no_auth_download: Annotated[
-        bool,
-        Doc(
-            "Do not authenticate the download request but only the order and order status ones."
-        ),
-    ]
-    bucket_path_level: int  # S3RestDownload
-    requester_pays: bool  # AwsDownload
-    flatten_top_dirs: bool
-
-    # auth -----------------------------------------------------------------------------
+    #: :class:`~eodag.plugins.download.http.HTTPDownload`
+    #: 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]
+    #: :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
+    #: :class:`~eodag.plugins.download.aws.AwsDownload` Whether download is done from a requester-pays bucket or not
+    requester_pays: bool
+    #: :class:`~eodag.plugins.download.aws.AwsDownload` S3 endpoint
+    s3_endpoint: str
+
+    # auth -------------------------------------------------------------------------------------------------------------
+    #: :class:`~eodag.plugins.authentication.base.Authentication` Authentication credentials dictionary
     credentials: Dict[str, str]
+    #: :class:`~eodag.plugins.authentication.base.Authentication` Authentication URL
     auth_uri: str
-    auth_base_uri: str
-    auth_error_code: int
+    #: :class:`~eodag.plugins.authentication.base.Authentication`
+    #: Dictionary containing all keys/value pairs that should be added to the headers
     headers: Dict[str, str]
-    token_provision: str  # KeycloakOIDCPasswordAuth
-    client_id: str  # KeycloakOIDCPasswordAuth
-    client_secret: str  # KeycloakOIDCPasswordAuth
-    realm: str  # KeycloakOIDCPasswordAuth
-    user_consent_needed: str  # OIDCAuthorizationCodeFlowAuth
-    authentication_uri_source: str  # OIDCAuthorizationCodeFlowAuth
-    redirect_uri: str  # OIDCAuthorizationCodeFlowAuth
-    authorization_uri: str  # OIDCAuthorizationCodeFlowAuth
-    login_form_xpath: str  # OIDCAuthorizationCodeFlowAuth
-    user_consent_form_xpath: str  # OIDCAuthorizationCodeFlowAuth
-    user_consent_form_data: Dict[str, str]  # OIDCAuthorizationCodeFlowAuth
-    token_exchange_post_data_method: str  # OIDCAuthorizationCodeFlowAuth
-    token_uri: str  # OIDCAuthorizationCodeFlowAuth
-    token_key: str  # OIDCAuthorizationCodeFlowAuth
-    req_data: Dict[str, Any]  # TokenAuth
-    signed_url_key: str  # SASAuth
-    refresh_uri: str  # TokenAuth
-    refresh_token_key: str  # TokenAuth
-    subject: Dict[str, Any]  # TokenExchangeAuth
-    subject_issuer: str  # TokenExchangeAuth
-    audience: str  # TokenExchangeAuth
+    #: :class:`~eodag.plugins.authentication.base.Authentication`
+    #: The key pointing to the token in the response from the token server
+    token_key: str
+    #: :class:`~eodag.plugins.authentication.base.Authentication`
+    #: Key to get the refresh token in the response from the token server
+    refresh_token_key: str
+    #: :class:`~eodag.plugins.authentication.base.Authentication` URL pattern to match with search plugin endpoint or
+    #: download link
+    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]
+    #: :class:`~eodag.plugins.authentication.openid_connect.OIDCRefreshTokenBase`
+    #: How the token should be used in the request
+    token_provision: str
+    #: :class:`~eodag.plugins.authentication.openid_connect.OIDCRefreshTokenBase` The OIDC provider's client ID
+    client_id: str
+    #: :class:`~eodag.plugins.authentication.openid_connect.OIDCRefreshTokenBase` The OIDC provider's client secret
+    client_secret: str
+    #: :class:`~eodag.plugins.authentication.openid_connect.OIDCRefreshTokenBase`
+    #: 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]
+    #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
+    #: Whether a user consent is needed during the authentication or not
+    user_consent_needed: str
+    #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
+    #: Where to look for the :attr:`~eodag.config.PluginConfig.authorization_uri`
+    authentication_uri_source: str
+    #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
+    #: The callback url that will handle the code given by the OIDC provider
+    authentication_uri: str
+    #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
+    #: The URL of the authentication backend of the OIDC provider
+    redirect_uri: str
+    #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
+    #: The authorization url of the server (where to query for grants)
+    authorization_uri: str
+    #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
+    #: The xpath to the HTML form element representing the user login form
+    login_form_xpath: str
+    #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
+    #: The xpath to the user consent form
+    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]
+    #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
+    #: Additional data to be passed to the login POST request
+    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]
+    #: :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]
+    #: :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
+    #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
+    #: Way to pass the data to the POST request that is made to the token server
+    token_exchange_post_data_method: str
+    #: :class:`~eodag.plugins.authentication.openid_connect.OIDCAuthorizationCodeFlowAuth`
+    #: The url to query to get the authorized token
+    token_uri: str
+    #: :class:`~eodag.plugins.authentication.sas_auth.SASAuth` Key to get the signed url
+    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]
+    #: :class:`~eodag.plugins.authentication.token.TokenAuth`
+    #: URL used to fetch the access token with a refresh token
+    refresh_uri: str
+    #: :class:`~eodag.plugins.authentication.token.TokenAuth`
+    #: type of the token
+    token_type: str
+    #: :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]
+    #: :class:`~eodag.plugins.authentication.token_exchange.OIDCTokenExchangeAuth`
+    #: Identifies the issuer of the `subject_token`
+    subject_issuer: str
+    #: :class:`~eodag.plugins.authentication.token_exchange.OIDCTokenExchangeAuth`
+    #: Audience that the token ID is intended for. :attr:`~eodag.config.PluginConfig.client_id` of the Relying Party
+    audience: str
+    #: :class:`~eodag.plugins.authentication.generic.GenericAuth`
+    #: which authentication method should be used
+    method: str
 
     yaml_loader = yaml.Loader
     yaml_dumper = yaml.SafeDumper
@@ -419,7 +658,6 @@ class PluginConfig(yaml.YAMLObject):
         """Update the configuration parameters with values from `mapping`
 
         :param mapping: The mapping from which to override configuration parameters
-        :type mapping: dict
         """
         if mapping is None:
             mapping = {}
@@ -429,13 +667,12 @@ class PluginConfig(yaml.YAMLObject):
 
 
 def load_default_config() -> Dict[str, ProviderConfig]:
-    """Load the providers configuration into a dictionnary.
+    """Load the providers configuration into a dictionary.
 
     Load from eodag `resources/providers.yml` or `EODAG_PROVIDERS_CFG_FILE` environment
     variable if exists.
 
     :returns: The default provider's configuration
-    :rtype: dict
     """
     eodag_providers_cfg_file = os.getenv(
         "EODAG_PROVIDERS_CFG_FILE"
@@ -444,12 +681,10 @@ def load_default_config() -> Dict[str, ProviderConfig]:
 
 
 def load_config(config_path: str) -> Dict[str, ProviderConfig]:
-    """Load the providers configuration into a dictionnary from a given file
+    """Load the providers configuration into a dictionary from a given file
 
     :param config_path: The path to the provider config file
-    :type config_path: str
     :returns: The default provider's configuration
-    :rtype: dict
     """
     logger.debug("Loading configuration from %s", config_path)
     config: Dict[str, ProviderConfig] = {}
@@ -462,12 +697,65 @@ def load_config(config_path: str) -> Dict[str, ProviderConfig]:
         raise e
     stac_provider_config = load_stac_provider_config()
     for provider_config in providers_configs:
-        # for provider_config in copy.deepcopy(providers_configs):
         provider_config_init(provider_config, stac_provider_config)
         config[provider_config.name] = provider_config
     return config
 
 
+def credentials_in_auth(auth_conf: PluginConfig) -> bool:
+    """Checks if credentials are set for this Authentication plugin configuration
+
+    :param auth_conf: Authentication plugin configuration
+    :returns: True if credentials are set, else False
+    """
+    return any(
+        c is not None for c in (getattr(auth_conf, "credentials", {}) or {}).values()
+    )
+
+
+def share_credentials(
+    providers_config: Dict[str, ProviderConfig],
+) -> None:
+    """Share credentials between plugins having the same matching criteria
+
+    :param providers_configs: eodag providers configurations
+    """
+    auth_confs_with_creds = [
+        getattr(p, k)
+        for p in providers_config.values()
+        for k in AUTH_TOPIC_KEYS
+        if hasattr(p, k) and credentials_in_auth(getattr(p, k))
+    ]
+    for provider, provider_config in providers_config.items():
+        if auth_confs_with_creds:
+            for auth_topic_key in AUTH_TOPIC_KEYS:
+                provider_config_auth = getattr(provider_config, auth_topic_key, None)
+                if provider_config_auth and not credentials_in_auth(
+                    provider_config_auth
+                ):
+                    # no credentials set for this provider
+                    provider_matching_conf = getattr(
+                        provider_config_auth, "matching_conf", {}
+                    )
+                    provider_matching_url = getattr(
+                        provider_config_auth, "matching_url", None
+                    )
+                    for conf_with_creds in auth_confs_with_creds:
+                        # copy credentials between plugins if `matching_conf` or `matching_url` are matching
+                        if (
+                            provider_matching_conf
+                            and sort_dict(provider_matching_conf)
+                            == sort_dict(getattr(conf_with_creds, "matching_conf", {}))
+                        ) or (
+                            provider_matching_url
+                            and provider_matching_url
+                            == getattr(conf_with_creds, "matching_url", None)
+                        ):
+                            getattr(
+                                providers_config[provider], auth_topic_key
+                            ).credentials = conf_with_creds.credentials
+
+
 def provider_config_init(
     provider_config: ProviderConfig,
     stac_search_default_conf: Optional[Dict[str, Any]] = None,
@@ -475,19 +763,17 @@ def provider_config_init(
     """Applies some default values to provider config
 
     :param provider_config: An eodag provider configuration
-    :type provider_config: :class:`~eodag.config.ProviderConfig`
     :param stac_search_default_conf: default conf to overwrite with provider_config if STAC
-    :type stac_search_default_conf: dict
     """
-    # For the provider, set the default outputs_prefix of its download plugin
+    # For the provider, set the default output_dir of its download plugin
     # as tempdir in a portable way
-    for param_name in ("download", "api"):
-        if param_name in vars(provider_config):
-            param_value = getattr(provider_config, param_name)
-            if not getattr(param_value, "outputs_prefix", None):
-                param_value.outputs_prefix = tempfile.gettempdir()
-            if not getattr(param_value, "delete_archive", None):
-                param_value.delete_archive = True
+    for download_topic_key in ("download", "api"):
+        if download_topic_key in vars(provider_config):
+            download_conf = getattr(provider_config, download_topic_key)
+            if not getattr(download_conf, "output_dir", None):
+                download_conf.output_dir = tempfile.gettempdir()
+            if not getattr(download_conf, "delete_archive", None):
+                download_conf.delete_archive = True
 
     try:
         if (
@@ -514,9 +800,7 @@ 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
-    :type config: dict
     :param file_path: The path to the file from where the new values will be read
-    :type file_path: str
     """
     logger.info("Loading user configuration from: %s", os.path.abspath(file_path))
     with open(os.path.abspath(os.path.realpath(file_path)), "r") as fh:
@@ -534,7 +818,6 @@ def override_config_from_env(config: Dict[str, Any]) -> None:
     """Override a configuration with environment variables values
 
     :param config: An eodag providers configuration dictionary
-    :type config: dict
     """
 
     def build_mapping_from_env(
@@ -554,11 +837,8 @@ def override_config_from_env(config: Dict[str, Any]) -> None:
             }
 
         :param env_var: The environment variable to be transformed into a dictionary
-        :type env_var: str
         :param env_value: The value from environment variable
-        :type env_value: str
         :param mapping: The mapping in which the value will be created
-        :type mapping: dict
         """
         parts = env_var.split("__")
         iter_parts = iter(parts)
@@ -610,11 +890,39 @@ def override_config_from_mapping(
     """Override a configuration with the values in a mapping
 
     :param config: An eodag providers configuration dictionary
-    :type config: dict
     :param mapping: The mapping containing the values to be overriden
-    :type mapping: dict
     """
     for provider, new_conf in mapping.items():
+        # check if metada-mapping as already been built as jsonpath in providers_config
+        if not isinstance(new_conf, dict):
+            continue
+        new_conf_search = new_conf.get("search", {}) or {}
+        new_conf_api = new_conf.get("api", {}) or {}
+        if provider in config and "metadata_mapping" in {
+            **new_conf_search,
+            **new_conf_api,
+        }:
+            search_plugin_key = (
+                "search" if "metadata_mapping" in new_conf_search else "api"
+            )
+            # get some already configured value
+            configured_metadata_mapping = getattr(
+                config[provider], search_plugin_key
+            ).metadata_mapping
+            some_configured_value = next(iter(configured_metadata_mapping.values()))
+            # check if the configured value has already been built as jsonpath
+            if (
+                isinstance(some_configured_value, list)
+                and isinstance(some_configured_value[1], tuple)
+                or isinstance(some_configured_value, tuple)
+            ):
+                # also build as jsonpath the incoming conf
+                mtd_cfg_as_conversion_and_querypath(
+                    deepcopy(mapping[provider][search_plugin_key]["metadata_mapping"]),
+                    mapping[provider][search_plugin_key]["metadata_mapping"],
+                )
+
+        # try overriding conf
         old_conf: Optional[Dict[str, Any]] = config.get(provider)
         if old_conf is not None:
             old_conf.update(new_conf)
@@ -640,9 +948,7 @@ 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
-    :type config: dict
     :param other_config: An eodag providers configuration dictionary
-    :type other_config: dict
     """
     # configs union with other_config values as default
     other_config = dict(config, **other_config)
@@ -671,20 +977,18 @@ def merge_configs(config: Dict[str, Any], other_config: Dict[str, Any]) -> None:
 
 
 def load_yml_config(yml_path: str) -> Dict[Any, Any]:
-    """Load a conf dictionnary from given yml absolute path
+    """Load a conf dictionary from given yml absolute path
 
     :returns: The yml configuration file
-    :rtype: dict
     """
     config = SimpleYamlProxyConfig(yml_path)
     return dict_items_recursive_apply(config.source, string_to_jsonpath)
 
 
 def load_stac_config() -> Dict[str, Any]:
-    """Load the stac configuration into a dictionnary
+    """Load the stac configuration into a dictionary
 
     :returns: The stac configuration
-    :rtype: dict
     """
     return load_yml_config(
         resource_filename("eodag", os.path.join("resources/", "stac.yml"))
@@ -692,10 +996,9 @@ def load_stac_config() -> Dict[str, Any]:
 
 
 def load_stac_api_config() -> Dict[str, Any]:
-    """Load the stac API configuration into a dictionnary
+    """Load the stac API configuration into a dictionary
 
     :returns: The stac API configuration
-    :rtype: dict
     """
     return load_yml_config(
         resource_filename("eodag", os.path.join("resources/", "stac_api.yml"))
@@ -703,10 +1006,9 @@ def load_stac_api_config() -> Dict[str, Any]:
 
 
 def load_stac_provider_config() -> Dict[str, Any]:
-    """Load the stac provider configuration into a dictionnary
+    """Load the stac provider configuration into a dictionary
 
     :returns: The stac provider configuration
-    :rtype: dict
     """
     return SimpleYamlProxyConfig(
         resource_filename("eodag", os.path.join("resources/", "stac_provider.yml"))
@@ -719,9 +1021,7 @@ def get_ext_product_types_conf(
     """Read external product types conf
 
     :param conf_uri: URI to local or remote configuration file
-    :type conf_uri: str
     :returns: The external product types configuration
-    :rtype: dict
     """
     logger.info("Fetching external product types from %s", conf_uri)
     if conf_uri.lower().startswith("http"):