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

eodag/api/core.py

@@ -24,27 +24,15 @@ import re
 import shutil
 import tempfile
 from operator import itemgetter
-from typing import (
-    TYPE_CHECKING,
-    Annotated,
-    Any,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Optional, Tuple, Union
 
 import geojson
 import pkg_resources
 import yaml.parser
 from pkg_resources import resource_filename
-from pydantic.fields import FieldInfo
 from whoosh import analysis, fields
 from whoosh.fields import Schema
-from whoosh.index import create_in, exists_in, open_dir
+from whoosh.index import exists_in, open_dir
 from whoosh.qparser import QueryParser
 
 from eodag.api.product.metadata_mapping import (
@@ -69,11 +57,11 @@ from eodag.config import (
 )
 from eodag.plugins.manager import PluginManager
 from eodag.plugins.search import PreparedSearch
-from eodag.plugins.search.build_search_result import BuildPostSearchResult
+from eodag.plugins.search.build_search_result import MeteoblueSearch
 from eodag.plugins.search.qssearch import PostJsonSearch
 from eodag.types import model_fields_to_annotated
-from eodag.types.queryables import CommonQueryables
-from eodag.types.whoosh import EODAGQueryParser
+from eodag.types.queryables import CommonQueryables, QueryablesDict
+from eodag.types.whoosh import EODAGQueryParser, create_in
 from eodag.utils import (
     DEFAULT_DOWNLOAD_TIMEOUT,
     DEFAULT_DOWNLOAD_WAIT,
@@ -84,7 +72,6 @@ from eodag.utils import (
     HTTP_REQ_TIMEOUT,
     MockResponse,
     _deprecated,
-    copy_deepcopy,
     get_geometry_from_various,
     makedirs,
     obj_md5sum,
@@ -93,6 +80,7 @@ from eodag.utils import (
     uri_to_path,
 )
 from eodag.utils.exceptions import (
+    AuthenticationError,
     EodagError,
     NoMatchingProductType,
     PluginImplementationError,
@@ -219,9 +207,10 @@ class EODataAccessGateway:
                         "eodag",
                         os.path.join("resources", "locations_conf_template.yml"),
                     )
-                    with open(locations_conf_template) as infile, open(
-                        locations_conf_path, "w"
-                    ) as outfile:
+                    with (
+                        open(locations_conf_template) as infile,
+                        open(locations_conf_path, "w") as outfile,
+                    ):
                         # The template contains paths in the form of:
                         # /path/to/locations/file.shp
                         path_template = "/path/to/locations/"
@@ -317,13 +306,18 @@ class EODataAccessGateway:
                     product_type, **{"md5": self.product_types_config_md5}
                 )
                 # add to index
-                ix_writer.add_document(
-                    **{
-                        k: v
-                        for k, v in versioned_product_type.items()
-                        if k in product_types_schema.names()
-                    }
-                )
+                try:
+                    ix_writer.add_document(
+                        **{
+                            k: v
+                            for k, v in versioned_product_type.items()
+                            if k in product_types_schema.names()
+                        }
+                    )
+                except TypeError as e:
+                    logger.error(
+                        f"Cannot write product type {product_type['ID']} into index. e={e} product_type={product_type}"
+                    )
             ix_writer.commit()
 
     def set_preferred_provider(self, provider: str) -> None:
@@ -1773,12 +1767,12 @@ class EODataAccessGateway:
         for plugin in self._plugins_manager.get_search_plugins(
             product_type=product_type, provider=provider
         ):
-            # exclude BuildPostSearchResult plugins from search fallback for unknow product_type
+            # exclude MeteoblueSearch plugins from search fallback for unknown product_type
             if (
                 provider != plugin.provider
                 and preferred_provider != plugin.provider
                 and product_type not in self.product_types_config
-                and isinstance(plugin, BuildPostSearchResult)
+                and isinstance(plugin, MeteoblueSearch)
             ):
                 continue
             search_plugins.append(plugin)
@@ -1801,27 +1795,7 @@ class EODataAccessGateway:
         # Add product_types_config to plugin config. This dict contains product
         # type metadata that will also be stored in each product's properties.
         for search_plugin in search_plugins:
-            try:
-                search_plugin.config.product_type_config = dict(
-                    [
-                        p
-                        for p in self.list_product_types(
-                            search_plugin.provider, fetch_providers=False
-                        )
-                        if p["_id"] == product_type
-                    ][0],
-                    **{"productType": product_type},
-                )
-                # If the product isn't in the catalog, it's a generic product type.
-            except IndexError:
-                # Construct the GENERIC_PRODUCT_TYPE metadata
-                search_plugin.config.product_type_config = dict(
-                    ID=GENERIC_PRODUCT_TYPE,
-                    **self.product_types_config[GENERIC_PRODUCT_TYPE],
-                    productType=product_type,
-                )
-            # Remove the ID since this is equal to productType.
-            search_plugin.config.product_type_config.pop("ID", None)
+            self._attach_product_type_config(search_plugin, product_type)
 
         return search_plugins, kwargs
 
@@ -2038,8 +2012,8 @@ class EODataAccessGateway:
         search_result: SearchResult,
         downloaded_callback: Optional[DownloadedCallback] = None,
         progress_callback: Optional[ProgressCallback] = None,
-        wait: int = DEFAULT_DOWNLOAD_WAIT,
-        timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
+        wait: float = DEFAULT_DOWNLOAD_WAIT,
+        timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
         **kwargs: Unpack[DownloadConf],
     ) -> List[str]:
         """Download all products resulting from a search.
@@ -2201,8 +2175,8 @@ class EODataAccessGateway:
         self,
         product: EOProduct,
         progress_callback: Optional[ProgressCallback] = None,
-        wait: int = DEFAULT_DOWNLOAD_WAIT,
-        timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
+        wait: float = DEFAULT_DOWNLOAD_WAIT,
+        timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
         **kwargs: Unpack[DownloadConf],
     ) -> str:
         """Download a single product.
@@ -2280,67 +2254,96 @@ class EODataAccessGateway:
         return self._plugins_manager.get_crunch_plugin(name, **plugin_conf)
 
     def list_queryables(
-        self, provider: Optional[str] = None, **kwargs: Any
-    ) -> Dict[str, Annotated[Any, FieldInfo]]:
+        self,
+        provider: Optional[str] = None,
+        fetch_providers: bool = True,
+        **kwargs: Any,
+    ) -> QueryablesDict:
         """Fetch the queryable properties for a given product type and/or provider.
 
         :param provider: (optional) The provider.
+        :param fetch_providers: If new product types should be fetched from the providers; default: True
         :param kwargs: additional filters for queryables (`productType` or other search
                        arguments)
 
         :raises UnsupportedProductType: If the specified product type is not available for the
                                         provider.
 
-        :returns: A dict containing the EODAG queryable properties, associating
-                  parameters to their annotated type
+        :returns: A :class:`~eodag.api.product.queryables.QuerybalesDict` containing the EODAG queryable
+                  properties, associating parameters to their annotated type, and a additional_properties attribute
         """
+        # only fetch providers if product type is not found
         available_product_types = [
             pt["ID"]
             for pt in self.list_product_types(provider=provider, fetch_providers=False)
         ]
-        product_type = kwargs.get("productType")
+        product_type: Optional[str] = kwargs.get("productType")
+        pt_alias: Optional[str] = product_type
 
         if product_type:
+            if product_type not in available_product_types:
+                if fetch_providers:
+                    # fetch providers and try again
+                    available_product_types = [
+                        pt["ID"]
+                        for pt in self.list_product_types(
+                            provider=provider, fetch_providers=True
+                        )
+                    ]
+                raise UnsupportedProductType(f"{product_type} is not available.")
             try:
                 kwargs["productType"] = product_type = self.get_product_type_from_alias(
                     product_type
                 )
             except NoMatchingProductType as e:
-                raise UnsupportedProductType(f"{product_type} is not available") from e
-
-        if product_type and product_type not in available_product_types:
-            self.fetch_product_types_list()
+                raise UnsupportedProductType(f"{product_type} is not available.") from e
 
         if not provider and not product_type:
-            return model_fields_to_annotated(CommonQueryables.model_fields)
+            return QueryablesDict(
+                additional_properties=True,
+                **model_fields_to_annotated(CommonQueryables.model_fields),
+            )
 
-        providers_queryables: Dict[str, Dict[str, Annotated[Any, FieldInfo]]] = {}
+        queryables: QueryablesDict = QueryablesDict(
+            additional_properties=True, additional_information="", **{}
+        )
 
         for plugin in self._plugins_manager.get_search_plugins(product_type, provider):
+            # attach product type config
+            product_type_configs = {}
+            if product_type:
+                self._attach_product_type_config(plugin, product_type)
+                product_type_configs[product_type] = plugin.config.product_type_config
+            else:
+                for pt in available_product_types:
+                    self._attach_product_type_config(plugin, pt)
+                    product_type_configs[pt] = plugin.config.product_type_config
+
+            # authenticate if required
             if getattr(plugin.config, "need_auth", False) and (
                 auth := self._plugins_manager.get_auth_plugin(plugin)
             ):
-                plugin.auth = auth.authenticate()
-            providers_queryables[plugin.provider] = plugin.list_queryables(
-                filters=kwargs, product_type=product_type
+                try:
+                    plugin.auth = auth.authenticate()
+                except AuthenticationError:
+                    logger.debug(
+                        "queryables from provider %s could not be fetched due to an authentication error",
+                        plugin.provider,
+                    )
+            plugin_queryables = plugin.list_queryables(
+                kwargs,
+                available_product_types,
+                product_type_configs,
+                product_type,
+                pt_alias,
             )
-
-        queryable_keys: Set[str] = set.intersection(  # type: ignore
-            *[set(q.keys()) for q in providers_queryables.values()]
-        )
-        queryables = {
-            k: v
-            for k, v in list(providers_queryables.values())[0].items()
-            if k in queryable_keys
-        }
-
-        # always keep at least CommonQueryables
-        common_queryables = copy_deepcopy(CommonQueryables.model_fields)
-        for key, queryable in common_queryables.items():
-            if key in kwargs:
-                queryable.default = kwargs[key]
-
-        queryables.update(model_fields_to_annotated(common_queryables))
+            queryables.update(plugin_queryables)
+            if not plugin_queryables.additional_properties:
+                queryables.additional_properties = False
+            if plugin_queryables.additional_information:
+                queryables.additional_information += (
+                    f"{provider}: {plugin_queryables.additional_information}"
+                )
 
         return queryables
 
@@ -2375,3 +2378,30 @@ class EODataAccessGateway:
                 ],
             }
         return sortables
+
+    def _attach_product_type_config(self, plugin: Search, product_type: str) -> None:
+        """
+        Attach product_types_config to plugin config. This dict contains product
+        type metadata that will also be stored in each product's properties.
+        """
+        try:
+            plugin.config.product_type_config = dict(
+                [
+                    p
+                    for p in self.list_product_types(
+                        plugin.provider, fetch_providers=False
+                    )
+                    if p["_id"] == product_type
+                ][0],
+                **{"productType": product_type},
+            )
+            # If the product isn't in the catalog, it's a generic product type.
+        except IndexError:
+            # Construct the GENERIC_PRODUCT_TYPE metadata
+            plugin.config.product_type_config = dict(
+                ID=GENERIC_PRODUCT_TYPE,
+                **self.product_types_config[GENERIC_PRODUCT_TYPE],
+                productType=product_type,
+            )
+        # Remove the ID since this is equal to productType.
+        plugin.config.product_type_config.pop("ID", None)

eodag/api/product/_assets.py

@@ -98,12 +98,12 @@ class AssetsDict(UserDict):
                 <details><summary style='color: grey;'>
                     <span style='color: black'>'{k}'</span>:&ensp;
                     {{
-                        {"'roles': '<span style='color: black'>"+str(v['roles'])+"</span>',&ensp;"
-                            if v.get("roles") else ""}
-                        {"'type': '"+str(v['type'])+"',&ensp;"
-                            if v.get("type") else ""}
-                        {"'title': '<span style='color: black'>"+str(v['title'])+"</span>',&ensp;"
-                            if v.get("title") else ""}
+                        {"'roles': '<span style='color: black'>" + str(v['roles']) + "</span>',&ensp;"
+                         if v.get("roles") else ""}
+                        {"'type': '" + str(v['type']) + "',&ensp;"
+                         if v.get("type") else ""}
+                        {"'title': '<span style='color: black'>" + str(v['title']) + "</span>',&ensp;"
+                         if v.get("title") else ""}
                         ...
                     }}
                 </summary>

eodag/api/product/_product.py

@@ -116,6 +116,7 @@ class EOProduct:
     properties: Dict[str, Any]
     product_type: Optional[str]
     location: str
+    filename: str
     remote_location: str
     search_kwargs: Any
     geometry: BaseGeometry
@@ -281,8 +282,8 @@ class EOProduct:
     def download(
         self,
         progress_callback: Optional[ProgressCallback] = None,
-        wait: int = DEFAULT_DOWNLOAD_WAIT,
-        timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
+        wait: float = DEFAULT_DOWNLOAD_WAIT,
+        timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
         **kwargs: Unpack[DownloadConf],
     ) -> str:
         """Download the EO product using the provided download plugin and the
@@ -525,22 +526,21 @@ class EOProduct:
                 <tr style='background-color: transparent;'>
                     <td style='text-align: left; vertical-align: top;'>
                         {dict_to_html_table({
-                            "provider": self.provider,
-                            "product_type": self.product_type,
-                            "properties[&quot;id&quot;]": self.properties.get('id', None),
-                            "properties[&quot;startTimeFromAscendingNode&quot;]": self.properties.get(
-                                'startTimeFromAscendingNode', None
-                            ),
-                            "properties[&quot;completionTimeFromAscendingNode&quot;]": self.properties.get(
-                                'completionTimeFromAscendingNode', None
-                            ),
-                        }, brackets=False)}
-                        <details><summary style='color: grey; margin-top: 10px;'>properties:&ensp;({
-                            len(self.properties)
-                        })</summary>{dict_to_html_table(self.properties, depth=1)}</details>
-                        <details><summary style='color: grey; margin-top: 10px;'>assets:&ensp;({
-                            len(self.assets)
-                        })</summary>{self.assets._repr_html_(embeded=True)}</details>
+                         "provider": self.provider,
+                         "product_type": self.product_type,
+                         "properties[&quot;id&quot;]": self.properties.get('id', None),
+                         "properties[&quot;startTimeFromAscendingNode&quot;]": self.properties.get(
+                             'startTimeFromAscendingNode', None
+                         ),
+                         "properties[&quot;completionTimeFromAscendingNode&quot;]": self.properties.get(
+                             'completionTimeFromAscendingNode', None
+                         ),
+                         }, brackets=False)}
+                        <details><summary style='color: grey; margin-top: 10px;'>properties:&ensp;({len(
+                             self.properties)})</summary>{
+                                 dict_to_html_table(self.properties, depth=1)}</details>
+                        <details><summary style='color: grey; margin-top: 10px;'>assets:&ensp;({len(
+                                     self.assets)})</summary>{self.assets._repr_html_(embeded=True)}</details>
                     </td>
                     <td {geom_style} title='geometry'>geometry<br />{self.geometry._repr_svg_()}</td>
                     <td {thumbnail_style} title='properties[&quot;thumbnail&quot;]'>{thumbnail_html}</td>

eodag/api/product/metadata_mapping.py

@@ -40,6 +40,7 @@ from typing import (
 import geojson
 import orjson
 import pyproj
+import shapely
 from dateutil.parser import isoparse
 from dateutil.relativedelta import relativedelta
 from dateutil.tz import UTC, tzutc
@@ -179,6 +180,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
         - ``recursive_sub_str``: recursively substitue in the structure (e.g. dict)
           values matching a regex
         - ``slice_str``: slice a string (equivalent to s[start, end, step])
+        - ``to_lower``: Convert a string to lowercase
+        - ``to_upper``: Convert a string to uppercase
         - ``fake_l2a_title_from_l1c``: used to generate SAFE format metadata for data from AWS
         - ``s2msil2a_title_to_aws_productinfo``: used to generate SAFE format metadata for data from AWS
         - ``split_cop_dem_id``: get the bbox by splitting the product id
@@ -363,6 +366,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
 
         @staticmethod
         def convert_to_nwse_bounds(input_geom: BaseGeometry) -> List[float]:
+            if isinstance(input_geom, str):
+                input_geom = shapely.wkt.loads(input_geom)
             return list(input_geom.bounds[-1:] + input_geom.bounds[:-1])
 
         @staticmethod
@@ -558,6 +563,16 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             ]
             return string[cmin:cmax:cstep]
 
+        @staticmethod
+        def convert_to_lower(string: str) -> str:
+            """Convert a string to lowercase."""
+            return string.lower()
+
+        @staticmethod
+        def convert_to_upper(string: str) -> str:
+            """Convert a string to uppercase."""
+            return string.upper()
+
         @staticmethod
         def convert_fake_l2a_title_from_l1c(string: str) -> str:
             id_regex = re.compile(
@@ -834,7 +849,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             date_object = datetime.strptime(utc_date, "%Y-%m-%dT%H:%M:%S.%fZ")
             date_object_second_year = date_object + relativedelta(years=1)
             return [
-                f'{date_object.strftime("%Y")}_{date_object_second_year.strftime("%y")}'
+                f"{date_object.strftime('%Y')}_{date_object_second_year.strftime('%y')}"
             ]
 
         @staticmethod
@@ -902,10 +917,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             return assets_dict
 
     # if stac extension colon separator `:` is in search params, parse it to prevent issues with vformat
-    if re.search(r"{[a-zA-Z0-9_-]*:[a-zA-Z0-9_-]*}", search_param):
-        search_param = re.sub(
-            r"{([a-zA-Z0-9_-]*):([a-zA-Z0-9_-]*)}", r"{\1_COLON_\2}", search_param
-        )
+    if re.search(r"{[\w-]*:[\w#-]*}", search_param):
+        search_param = re.sub(r"{([\w-]*):([\w#-]*)}", r"{\1_COLON_\2}", search_param)
         kwargs = {k.replace(":", "_COLON_"): v for k, v in kwargs.items()}
 
     return MetadataFormatter().vformat(search_param, args, kwargs)
@@ -975,10 +988,24 @@ def properties_from_json(
                     if re.search(r"({[^{}:]+})+", conversion_or_none):
                         conversion_or_none = conversion_or_none.format(**properties)
 
-                    properties[metadata] = format_metadata(
-                        "{%s%s%s}" % (metadata, SEP, conversion_or_none),
-                        **{metadata: extracted_value},
-                    )
+                    if extracted_value == NOT_AVAILABLE:
+                        # try if value can be formatted even if it is not available
+                        try:
+                            properties[metadata] = format_metadata(
+                                "{%s%s%s}" % (metadata, SEP, conversion_or_none),
+                                **{metadata: extracted_value},
+                            )
+                        except ValueError:
+                            logger.debug(
+                                f"{metadata}: {extracted_value} could not be formatted with {conversion_or_none}"
+                            )
+                            continue
+                    else:
+                        # in this case formatting should work, otherwise something is wrong in the mapping
+                        properties[metadata] = format_metadata(
+                            "{%s%s%s}" % (metadata, SEP, conversion_or_none),
+                            **{metadata: extracted_value},
+                        )
         # properties as python objects when possible (format_metadata returns only strings)
         try:
             properties[metadata] = ast.literal_eval(properties[metadata])
@@ -1462,7 +1489,7 @@ def get_queryable_from_provider(
     :param metadata_mapping: metadata-mapping configuration
     :returns: EODAG configured queryable parameter or None
     """
-    pattern = rf"\b{provider_queryable}\b"
+    pattern = rf"\"{provider_queryable}\""
     # if 1:1 mapping exists privilege this one instead of other mapping
     # e.g. provider queryable = year -> use year and not date in which year also appears
     mapping_values = [
@@ -1498,7 +1525,8 @@ def get_provider_queryable_key(
     provider_queryables: Dict[str, Any],
     metadata_mapping: Dict[str, Union[List[Any], str]],
 ) -> str:
-    """finds the provider queryable corresponding to the given eodag key based on the metadata mapping
+    """Finds the provider queryable corresponding to the given eodag key based on the metadata mapping
+
     :param eodag_key: key in eodag
     :param provider_queryables: queryables returned from the provider
     :param metadata_mapping: metadata mapping from which the keys are retrieved

eodag/cli.py

@@ -57,6 +57,11 @@ from eodag.utils import DEFAULT_ITEMS_PER_PAGE, DEFAULT_PAGE, parse_qs
 from eodag.utils.exceptions import NoMatchingProductType, UnsupportedProvider
 from eodag.utils.logging import setup_logging
 
+try:
+    from eodag.rest.utils import LIVENESS_PROBE_PATH
+except ImportError:
+    pass
+
 if TYPE_CHECKING:
     from click import Context
 
@@ -70,6 +75,18 @@ CRUNCHERS = [
 ]
 
 
+class LivenessFilter:
+    """
+    Filter out requests to the liveness probe endpoint
+    """
+
+    def filter(self, record):
+        """
+        Filter method required by the Python logging API.
+        """
+        return LIVENESS_PROBE_PATH not in record.getMessage()
+
+
 class MutuallyExclusiveOption(click.Option):
     """Mutually Exclusive Options for Click
     from https://gist.github.com/jacobtolar/fb80d5552a9a9dfc32b12a829fa21c0c
@@ -679,7 +696,9 @@ def serve_rest(
         try:
             pid = os.fork()
         except OSError as e:
-            raise Exception("%s [%d]" % (e.strerror, e.errno))
+            raise Exception(
+                "%s [%d]" % (e.strerror, e.errno) if e.errno is not None else e.strerror
+            )
 
         if pid == 0:
             os.setsid()
@@ -691,8 +710,10 @@ def serve_rest(
 
         logging_config = uvicorn.config.LOGGING_CONFIG
         uvicorn_fmt = "%(asctime)-15s %(name)-32s [%(levelname)-8s] %(message)s"
+        logging_config["filters"] = {"liveness": {"()": LivenessFilter}}
         logging_config["formatters"]["access"]["fmt"] = uvicorn_fmt
         logging_config["formatters"]["default"]["fmt"] = uvicorn_fmt
+        logging_config["loggers"]["uvicorn.access"]["filters"] = ["liveness"]
 
         eodag_formatter = logging.Formatter(
             "%(asctime)-15s %(name)-32s [%(levelname)-8s] (tid=%(thread)d) %(message)s"

eodag/config.py

@@ -287,8 +287,10 @@ class PluginConfig(yaml.YAMLObject):
         #: 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
+        #: 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
@@ -307,6 +309,10 @@ 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"""
@@ -434,17 +440,6 @@ class PluginConfig(yaml.YAMLObject):
     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
     #: :class:`~eodag.plugins.search.base.Search` Parameters to remove from queryables
     remove_from_queryables: List[str]
     #: :class:`~eodag.plugins.search.base.Search` Parameters to be passed as is in the search url query string
@@ -477,15 +472,17 @@ class PluginConfig(yaml.YAMLObject):
     #: :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]
     #: :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
@@ -539,6 +536,9 @@ class PluginConfig(yaml.YAMLObject):
     #: Dictionary containing all keys/value pairs that should be added to the headers
     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
     #: :class:`~eodag.plugins.authentication.base.Authentication`