eodag 4.0.0a1__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

eodag/api/product/_product.py

@@ -38,7 +38,8 @@ try:
 except ImportError:
     from eodag.api.product._assets import AssetsDict
 
-from eodag.api.product.drivers import DRIVERS, LEGACY_DRIVERS, NoDriver
+from eodag.api.product.drivers import DRIVERS
+from eodag.api.product.drivers.generic import GenericDriver
 from eodag.api.product.metadata_mapping import (
     DEFAULT_GEOMETRY,
     NOT_AVAILABLE,
@@ -48,6 +49,7 @@ from eodag.api.product.metadata_mapping import (
 from eodag.utils import (
     DEFAULT_DOWNLOAD_TIMEOUT,
     DEFAULT_DOWNLOAD_WAIT,
+    DEFAULT_SHAPELY_GEOMETRY,
     DEFAULT_STREAM_REQUESTS_TIMEOUT,
     USER_AGENT,
     ProgressCallback,
@@ -68,12 +70,6 @@ if TYPE_CHECKING:
     from eodag.types.download_args import DownloadConf
     from eodag.utils import Unpack
 
-try:
-    from shapely.errors import GEOSException
-except ImportError:
-    # shapely < 2.0 compatibility
-    from shapely.errors import TopologicalError as GEOSException
-
 
 logger = logging.getLogger("eodag.product")
 
@@ -142,6 +138,7 @@ class EOProduct:
             and value != NOT_MAPPED
             and NOT_AVAILABLE not in str(value)
             and not key.startswith("_")
+            and value is not None
         }
         common_stac_properties = {
             key: self.properties[key]
@@ -160,9 +157,7 @@ class EOProduct:
             )
             and "eodag:default_geometry" not in properties
         ):
-            raise MisconfiguredError(
-                f"No geometry available to build EOProduct(id={properties.get('id')}, provider={provider})"
-            )
+            product_geometry = DEFAULT_SHAPELY_GEOMETRY
         elif not properties["geometry"] or properties["geometry"] == NOT_AVAILABLE:
             product_geometry = properties.pop(
                 "eodag:default_geometry", DEFAULT_GEOMETRY
@@ -170,9 +165,11 @@ class EOProduct:
         else:
             product_geometry = properties["geometry"]
 
-        self.geometry = self.search_intersection = get_geometry_from_various(
-            geometry=product_geometry
-        )
+        geometry_obj = get_geometry_from_various(geometry=product_geometry)
+        # whole world as default geometry
+        if geometry_obj is None:
+            geometry_obj = DEFAULT_SHAPELY_GEOMETRY
+        self.geometry = self.search_intersection = geometry_obj
 
         self.search_kwargs = kwargs
         if self.search_kwargs.get("geometry") is not None:
@@ -181,7 +178,7 @@ class EOProduct:
             )
             try:
                 self.search_intersection = self.geometry.intersection(searched_geom)
-            except (GEOSException, ShapelyError):
+            except ShapelyError:
                 logger.warning(
                     "Unable to intersect the requested extent: %s with the product "
                     "geometry: %s",
@@ -597,21 +594,10 @@ class EOProduct:
 
     def get_driver(self) -> DatasetDriver:
         """Get the most appropriate driver"""
-        try:
-            for driver_conf in DRIVERS:
-                if all([criteria(self) for criteria in driver_conf["criteria"]]):
-                    driver = driver_conf["driver"]
-                    break
-            # use legacy driver for deprecated get_data method usage
-            for lecacy_conf in LEGACY_DRIVERS:
-                if all([criteria(self) for criteria in lecacy_conf["criteria"]]):
-                    driver.legacy = lecacy_conf["driver"]
-                    break
-            return driver
-        except TypeError:
-            logger.info("No driver matching")
-            pass
-        return NoDriver()
+        for driver_conf in DRIVERS:
+            if all([criteria(self) for criteria in driver_conf["criteria"]]):
+                return driver_conf["driver"]
+        return GenericDriver()
 
     def _repr_html_(self):
         thumbnail = self.properties.get("eodag:thumbnail") or self.properties.get(

eodag/api/product/drivers/__init__.py

@@ -20,27 +20,11 @@ from __future__ import annotations
 
 from typing import Callable, TypedDict
 
-from eodag.api.product.drivers.base import DatasetDriver, NoDriver
+from eodag.api.product.drivers.base import DatasetDriver
 from eodag.api.product.drivers.generic import GenericDriver
 from eodag.api.product.drivers.sentinel1 import Sentinel1Driver
 from eodag.api.product.drivers.sentinel2 import Sentinel2Driver
 
-try:
-    # import from eodag-cube if installed
-    from eodag_cube.api.product.drivers.generic import (  # pyright: ignore[reportMissingImports]; isort: skip
-        GenericDriver as GenericDriver_cube,
-    )
-    from eodag_cube.api.product.drivers.sentinel2_l1c import (  # pyright: ignore[reportMissingImports]; isort: skip
-        Sentinel2L1C as Sentinel2L1C_cube,
-    )
-    from eodag_cube.api.product.drivers.stac_assets import (  # pyright: ignore[reportMissingImports]; isort: skip
-        StacAssets as StacAssets_cube,
-    )
-except ImportError:
-    GenericDriver_cube = NoDriver
-    Sentinel2L1C_cube = NoDriver
-    StacAssets_cube = NoDriver
-
 
 class DriverCriteria(TypedDict):
     """Driver criteria definition"""
@@ -76,29 +60,5 @@ DRIVERS: list[DriverCriteria] = [
 ]
 
 
-#: list of legacy drivers and their criteria
-LEGACY_DRIVERS: list[DriverCriteria] = [
-    {
-        "criteria": [
-            lambda prod: True if len(getattr(prod, "assets", {})) > 0 else False
-        ],
-        "driver": StacAssets_cube(),
-    },
-    {
-        "criteria": [lambda prod: True if "assets" in prod.properties else False],
-        "driver": StacAssets_cube(),
-    },
-    {
-        "criteria": [
-            lambda prod: True if getattr(prod, "collection") == "S2_MSI_L1C" else False
-        ],
-        "driver": Sentinel2L1C_cube(),
-    },
-    {
-        "criteria": [lambda prod: True],
-        "driver": GenericDriver_cube(),
-    },
-]
-
 # exportable content
-__all__ = ["DRIVERS", "DatasetDriver", "GenericDriver", "NoDriver", "Sentinel2Driver"]
+__all__ = ["DRIVERS", "DatasetDriver", "GenericDriver", "Sentinel2Driver"]

eodag/api/product/drivers/base.py

@@ -44,9 +44,6 @@ class DatasetDriver(metaclass=type):
     criteria.
     """
 
-    #: legacy driver for deprecated :meth:`~eodag_cube.api.product._product.EOProduct.get_data` method usage
-    legacy: DatasetDriver
-
     #: list of patterns to match asset keys and roles
     ASSET_KEYS_PATTERNS_ROLES: list[AssetPatterns] = []
 
@@ -79,11 +76,3 @@ class DatasetDriver(metaclass=type):
                 return normalized_key or extracted_key, roles
         logger.debug(f"No key & roles could be guessed for {href}")
         return None, None
-
-
-class NoDriver(DatasetDriver):
-    """A default :attr:`~eodag.api.product.drivers.base.DatasetDriver.legacy` driver that does not implement any of the
-    methods it should implement, used for all collections for  which the deprecated
-    :meth:`~eodag_cube.api.product._product.EOProduct.get_data` method is not implemented. Expect a
-    :exc:`NotImplementedError` when trying to get the data in that case.
-    """

eodag/api/product/metadata_mapping.py

@@ -42,6 +42,7 @@ from shapely.ops import transform
 from eodag.types.queryables import Queryables
 from eodag.utils import (
     DEFAULT_PROJ,
+    DEFAULT_SHAPELY_GEOMETRY,
     deepcopy,
     dict_items_recursive_apply,
     format_string,
@@ -151,6 +152,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
 
     The currently understood converters are:
         - ``ceda_collection_name``: generate a CEDA collection name from a string
+        - ``wekeo_to_cop_collection``: converts the name of a collection from the WEkEO format to the Copernicus format
         - ``csv_list``: convert to a comma separated list
         - ``datetime_to_timestamp_milliseconds``: converts a utc date string to a timestamp in milliseconds
         - ``dict_filter_and_sub``: filter dict items using jsonpath and then apply recursive_sub_str
@@ -160,6 +162,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
         - ``from_georss``: convert GeoRSS to shapely geometry / WKT in DEFAULT_PROJ
         - ``get_ecmwf_time``: get the time of a datetime string in the ECMWF format
         - ``get_group_name``: get the matching regex group name
+        - ``literalize_unicode``: convert a string to its raw Unicode literal form
         - ``not_available``: replace value with "Not Available"
         - ``recursive_sub_str``: recursively substitue in the structure (e.g. dict) values matching a regex
         - ``remove_extension``: on a string that contains dots, only take the first part of the list obtained by
@@ -251,6 +254,9 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                 field_name = conversion_func_spec.groupdict()["field_name"]
                 converter = conversion_func_spec.groupdict()["converter"]
                 self.custom_args = conversion_func_spec.groupdict()["args"]
+                # converts back "_COLON_" to ":"
+                if self.custom_args is not None and "_COLON_" in self.custom_args:
+                    self.custom_args = self.custom_args.replace("_COLON_", ":")
                 self.custom_converter = getattr(self, "convert_{}".format(converter))
 
             return super(MetadataFormatter, self).get_field(field_name, args, kwargs)
@@ -383,14 +389,16 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
         @staticmethod
         def convert_to_bounds(input_geom_unformatted: Any) -> list[float]:
             input_geom = get_geometry_from_various(geometry=input_geom_unformatted)
+            if input_geom is None:
+                input_geom = DEFAULT_SHAPELY_GEOMETRY
             if isinstance(input_geom, MultiPolygon):
                 geoms = [geom for geom in input_geom.geoms]
                 # sort with larger one at first (stac-browser only plots first one)
                 geoms.sort(key=lambda x: x.area, reverse=True)
-                min_lon = 180
-                min_lat = 90
-                max_lon = -180
-                max_lat = -90
+                min_lon = 180.0
+                min_lat = 90.0
+                max_lon = -180.0
+                max_lat = -90.0
                 for geom in geoms:
                     min_lon = min(min_lon, geom.bounds[0])
                     min_lat = min(min_lat, geom.bounds[1])
@@ -661,7 +669,13 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             match = data_regex.search(value)
             if match:
                 return match.group("name").replace("/", "_").upper()
-            return "NOT_AVAILABLE"
+            return NOT_AVAILABLE
+
+        @staticmethod
+        def convert_literalize_unicode(value: str) -> str:
+            if value == NOT_AVAILABLE:
+                return value
+            return value.encode("raw_unicode_escape").decode("utf-8")
 
         @staticmethod
         def convert_recursive_sub_str(
@@ -1051,6 +1065,11 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                     assets_dict[asset_basename] = assets_dict.pop(asset_name)
             return assets_dict
 
+        @staticmethod
+        def convert_wekeo_to_cop_collection(val: str, prefix: str) -> str:
+            """Converts the name of a collection from the WEkEO format to the Copernicus format."""
+            return val.removeprefix(prefix).lower().replace("_", "-")
+
     # if stac extension colon separator `:` is in search params, parse it to prevent issues with vformat
     if re.search(r"{[\w-]*:[\w#-]*\(?.*}", search_param):
         search_param = re.sub(
@@ -1059,6 +1078,16 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             search_param,
         )
         kwargs = {k.replace(":", "_COLON_"): v for k, v in kwargs.items()}
+    # convert colons `:` in the parameters passed to the converter (e.g. 'foo#boo(fun:with:colons)')
+    if re.search(r"{[\w-]*#[\w-]*\([^)]*:.*}", search_param):
+        search_param = re.sub(
+            r"({[\w-]*#[\w-]*)\(([^)]*)(.*})",
+            lambda m: m.group(1)
+            + "("
+            + m.group(2).replace(":", "_COLON_")
+            + m.group(3),
+            search_param,
+        )
 
     return MetadataFormatter().vformat(search_param, args, kwargs)
 

eodag/api/search_result.py

@@ -19,9 +19,11 @@ from __future__ import annotations
 
 import logging
 from collections import UserList
-from typing import TYPE_CHECKING, Annotated, Any, Iterable, Optional, Union
+from typing import TYPE_CHECKING, Annotated, Any, Iterable, Iterator, Optional, Union
 
-from shapely.geometry import GeometryCollection, shape
+from shapely.geometry import GeometryCollection
+from shapely.geometry import mapping as shapely_mapping
+from shapely.geometry import shape
 from typing_extensions import Doc
 
 from eodag.api.product import EOProduct, unregistered_product_from_item
@@ -36,6 +38,7 @@ from eodag.utils.exceptions import MisconfiguredError
 if TYPE_CHECKING:
     from shapely.geometry.base import BaseGeometry
 
+    from eodag.api.core import EODataAccessGateway
     from eodag.plugins.crunch.base import Crunch
     from eodag.plugins.manager import PluginManager
 
@@ -48,6 +51,11 @@ class SearchResult(UserList[EOProduct]):
 
     :param products: A list of products resulting from a search
     :param number_matched: (optional) the estimated total number of matching results
+    :param errors: (optional) stored errors encountered during the search. Tuple of (provider name, exception)
+    :param search_params: (optional) search parameters stored to use in pagination
+    :param next_page_token: (optional) next page token value to use in pagination
+    :param next_page_token_key: (optional) next page token key to use in pagination
+    :param raise_errors: (optional) whether to raise errors encountered during the search
 
     :cvar data: List of products
     :ivar number_matched: Estimated total number of matching results
@@ -62,10 +70,19 @@ class SearchResult(UserList[EOProduct]):
         products: list[EOProduct],
         number_matched: Optional[int] = None,
         errors: Optional[list[tuple[str, Exception]]] = None,
+        search_params: Optional[dict[str, Any]] = None,
+        next_page_token: Optional[str] = None,
+        next_page_token_key: Optional[str] = None,
+        raise_errors: Optional[bool] = False,
     ) -> None:
         super().__init__(products)
         self.number_matched = number_matched
         self.errors = errors if errors is not None else []
+        self.search_params = search_params
+        self.next_page_token = next_page_token
+        self.next_page_token_key = next_page_token_key
+        self.raise_errors = raise_errors
+        self._dag: Optional["EODataAccessGateway"] = None
 
     def crunch(self, cruncher: Crunch, **search_params: Any) -> SearchResult:
         """Do some crunching with the underlying EO products.
@@ -149,18 +166,46 @@ class SearchResult(UserList[EOProduct]):
         :param feature_collection: A collection representing a search result.
         :returns: An eodag representation of a search result
         """
+
+        products = [
+            EOProduct.from_geojson(feature)
+            for feature in feature_collection.get("features", [])
+        ]
+        props = feature_collection.get("metadata", {}) or {}
+
+        eodag_search_params = props.get("eodag:search_params", {})
+        if eodag_search_params and eodag_search_params.get("geometry"):
+            eodag_search_params["geometry"] = shape(eodag_search_params["geometry"])
+
         return SearchResult(
-            [
-                EOProduct.from_geojson(feature)
-                for feature in feature_collection["features"]
-            ]
+            products=products,
+            number_matched=props.get("eodag:number_matched"),
+            next_page_token=props.get("eodag:next_page_token"),
+            next_page_token_key=props.get("eodag:next_page_token_key"),
+            search_params=eodag_search_params or None,
+            raise_errors=props.get("eodag:raise_errors"),
         )
 
     def as_geojson_object(self) -> dict[str, Any]:
         """GeoJSON representation of SearchResult"""
+
+        geojson_search_params = {} | (self.search_params or {})
+        # search_params shapely geometry to wkt
+        if self.search_params and self.search_params.get("geometry"):
+            geojson_search_params["geometry"] = shapely_mapping(
+                self.search_params["geometry"]
+            )
+
         return {
             "type": "FeatureCollection",
             "features": [product.as_dict() for product in self],
+            "metadata": {
+                "eodag:number_matched": self.number_matched,
+                "eodag:next_page_token": self.next_page_token,
+                "eodag:next_page_token_key": self.next_page_token_key,
+                "eodag:search_params": geojson_search_params or None,
+                "eodag:raise_errors": self.raise_errors,
+            },
         }
 
     def as_shapely_geometry_object(self) -> GeometryCollection:
@@ -218,6 +263,93 @@ class SearchResult(UserList[EOProduct]):
 
         return super().extend(other)
 
+    def next_page(self, update: bool = True) -> Iterator[SearchResult]:
+        """
+        Retrieve and iterate over the next pages of search results, if available.
+
+        This method uses the current search parameters and next page token to request
+        additional results from the provider. If ``update`` is ``True``, the current ``SearchResult``
+        instance is updated with new products and pagination information as pages are fetched.
+
+        :param update: If ``True``, update the current ``SearchResult`` with new results.
+        :returns: An iterator yielding ``SearchResult`` objects for each subsequent page.
+
+        Example:
+
+        >>> first_page = SearchResult([])  # result of a search
+        >>> for new_results in first_page.next_page():
+        ...     continue  # do something with new_results
+        """
+
+        def get_next_page(current):
+            if current.search_params is None:
+                current.search_params = {}
+            # Update the next_page_token in the search params
+            current.search_params["next_page_token"] = current.next_page_token
+            current.search_params["next_page_token_key"] = current.next_page_token_key
+            # Ensure the provider is in the search params
+            if "provider" in current.search_params:
+                current.search_params["provider"] = current.search_params.get(
+                    "provider", None
+                )
+            elif current.data and hasattr(current.data[-1], "provider"):
+                current.search_params["provider"] = current.data[-1].provider
+            search_plugins, search_kwargs = current._dag._prepare_search(
+                **current.search_params
+            )
+            # If number_matched was provided, ensure it is passed to the next search
+            if current.number_matched:
+                search_kwargs["number_matched"] = current.number_matched
+            for i, search_plugin in enumerate(search_plugins):
+                # validate no needed for next pages
+                search_kwargs["validate"] = False
+                return current._dag._do_search(
+                    search_plugin,
+                    raise_errors=self.raise_errors,
+                    **search_kwargs,
+                )
+
+        # Do not iterate if there is no next page token
+        #  or if the current one returned less than the maximum number of items asked for.
+        if self.next_page_token is None:
+            return
+
+        new_results = get_next_page(self)
+        old_results = self
+
+        while new_results.data:
+            # The products between two iterations are compared. If they
+            # are actually the same product, it means the iteration failed at
+            # progressing for some reason.
+            if (
+                old_results.data[0].properties["id"]
+                == new_results.data[0].properties["id"]
+            ):
+                logger.warning(
+                    "Iterate over pages: stop iterating since the next page "
+                    "appears to have the same products as in the previous one. "
+                    "This provider may not implement pagination.",
+                )
+                break
+            if update:
+                self.data += new_results.data
+                self.search_params = new_results.search_params
+                self.next_page_token = new_results.next_page_token
+                self.next_page_token_key = new_results.next_page_token_key
+            yield new_results
+            # Stop iterating if there is no next page token
+            #  or if the current one returned less than the maximum number of items asked for.
+            if (
+                new_results.next_page_token is None
+                or len(new_results) < new_results.search_params["items_per_page"]
+            ):
+                break
+            old_results = new_results
+            new_results = get_next_page(new_results)
+            if not new_results:
+                break
+        return
+
     @classmethod
     def _from_stac_item(
         cls, feature: dict[str, Any], plugins_manager: PluginManager
@@ -331,13 +463,13 @@ def _import_stac_item_from_known_provider(
                 )
                 eo_product = products[0]
 
-                configured_pts = [
+                configured_cols = [
                     k
                     for k, v in search_plugin.config.products.items()
                     if v.get("_collection") == feature.get("collection")
                 ]
-                if len(configured_pts) > 0:
-                    eo_product.collection = configured_pts[0]
+                if len(configured_cols) > 0:
+                    eo_product.collection = configured_cols[0]
                 else:
                     eo_product.collection = feature.get("collection")
 
@@ -380,6 +512,9 @@ class RawSearchResult(UserList[dict[str, Any]]):
 
     query_params: dict[str, Any]
     collection_def_params: dict[str, Any]
+    search_params: dict[str, Any]
+    next_page_token: Optional[str] = None
+    next_page_token_key: Optional[str] = None
 
     def __init__(self, results: list[Any]) -> None:
         super(RawSearchResult, self).__init__(results)

eodag/cli.py

@@ -49,6 +49,7 @@ from urllib.parse import parse_qs
 
 import click
 
+from eodag.api.collection import CollectionsList
 from eodag.api.core import EODataAccessGateway, SearchResult
 from eodag.utils import DEFAULT_ITEMS_PER_PAGE, DEFAULT_PAGE
 from eodag.utils.exceptions import NoMatchingCollection, UnsupportedProvider
@@ -142,8 +143,8 @@ def version() -> None:
 
 @eodag.command(
     name="search",
-    help="Search satellite images by their collections, instrument, platform, "
-    "platform identifier, processing level or sensor type. It is mandatory to provide "
+    help="Search satellite images by their collections, instruments, constellation, "
+    "platform, processing level or sensor type. It is mandatory to provide "
     "at least one of the previous criteria for eodag to perform a search. "
     "Optionally crunch the search results before storing them in a geojson file",
 )
@@ -423,14 +424,14 @@ def search_crunch(ctx: Context, **kwargs: Any) -> None:
     "--no-fetch", is_flag=True, help="Do not fetch providers for new collections"
 )
 @click.pass_context
-def list_pt(ctx: Context, **kwargs: Any) -> None:
+def list_col(ctx: Context, **kwargs: Any) -> None:
     """Print the list of supported collections"""
     setup_logging(verbose=ctx.obj["verbosity"])
     dag = EODataAccessGateway()
     provider = kwargs.pop("provider")
     fetch_providers = not kwargs.pop("no_fetch")
     text_wrapper = textwrap.TextWrapper()
-    guessed_collections = []
+    guessed_collections = CollectionsList([])
     try:
         guessed_collections = dag.guess_collection(
             **kwargs,
@@ -457,22 +458,24 @@ def list_pt(ctx: Context, **kwargs: Any) -> None:
             sys.exit(1)
     try:
         if guessed_collections:
-            collections = [
-                pt
-                for pt in dag.list_collections(
-                    provider=provider, fetch_providers=fetch_providers
-                )
-                if pt["ID"] in guessed_collections
-            ]
+            collections = CollectionsList(
+                [
+                    col
+                    for col in dag.list_collections(
+                        provider=provider, fetch_providers=fetch_providers
+                    )
+                    if col.id in [guessed_col.id for guessed_col in guessed_collections]
+                ]
+            )
         else:
             collections = dag.list_collections(
                 provider=provider, fetch_providers=fetch_providers
             )
         click.echo("Listing available collections:")
         for collection in collections:
-            click.echo("\n* {}: ".format(collection["ID"]))
-            for prop, value in collection.items():
-                if prop != "ID":
+            click.echo("\n* {}: ".format(collection.id))
+            for prop, value in collection.model_dump().items():
+                if prop != "id":
                     text_wrapper.initial_indent = "    - {}: ".format(prop)
                     text_wrapper.subsequent_indent = " " * len(
                         text_wrapper.initial_indent
@@ -498,7 +501,7 @@ def list_pt(ctx: Context, **kwargs: Any) -> None:
     "DEFAULT: ext_collections.json",
 )
 @click.pass_context
-def discover_pt(ctx: Context, **kwargs: Any) -> None:
+def discover_col(ctx: Context, **kwargs: Any) -> None:
     """Fetch external collections configuration and save result"""
     setup_logging(verbose=ctx.obj["verbosity"])
     dag = EODataAccessGateway()

eodag/config.py

@@ -38,7 +38,6 @@ from typing import (
 import orjson
 import requests
 import yaml
-import yaml.constructor
 import yaml.parser
 from annotated_types import Gt
 from jsonpath_ng import JSONPath
@@ -241,10 +240,15 @@ class PluginConfig(yaml.YAMLObject):
         next_page_url_tpl: str
         #: The query-object for POST pagination requests.
         next_page_query_obj: str
+        #: Next page token key used in pagination. Can be guessed from ``KNOWN_NEXT_PAGE_TOKEN_KEYS`` (but needed by
+        # ``stac-fastapi-eodag`` that cannot guess and will use ``page`` as default).
+        next_page_token_key: str
         #: The endpoint for counting the number of items satisfying a request
         count_endpoint: str
         #: Index of the starting page
         start_page: int
+        #: Key in the current page URL for the next page URL
+        parse_url_key: str
 
     class Sort(TypedDict):
         """Configuration for sort during search"""
@@ -300,7 +304,7 @@ class PluginConfig(yaml.YAMLObject):
         results_entry: Union[JSONPath, str]
         #: Mapping for the collection id
         generic_collection_id: str
-        #: Mapping for collection metadata (e.g. ``abstract``, ``licence``) which can be parsed from the provider
+        #: Mapping for collection metadata (e.g. ``description``, ``license``) which can be parsed from the provider
         #: result
         generic_collection_parsable_metadata: dict[str, str]
         #: Mapping for collection properties which can be parsed from the result and are not collection metadata
@@ -311,7 +315,7 @@ class PluginConfig(yaml.YAMLObject):
         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 collection metadata returned by the endpoint given in single_collection_fetch_url. If ``ID``
+        #: Mapping for collection metadata returned by the endpoint given in single_collection_fetch_url. If ``id``
         #: is redefined in this mapping, it will replace ``generic_collection_id`` value
         single_collection_parsable_metadata: dict[str, str]
 
@@ -331,6 +335,30 @@ class PluginConfig(yaml.YAMLObject):
         #: :class:`~eodag.plugins.search.base.Search` Key in the json result where the constraints can be found
         constraints_entry: str
 
+    class CollectionSelector(TypedDict, total=False):
+        """Define the criteria to select a collection in :class:`~eodag.config.PluginConfig.DynamicDiscoverQueryables`.
+
+        The selector matches if the field value starts with the given prefix,
+        i.e. it matches if ``parameters[field].startswith(prefix)==True``"""
+
+        #: Field in the search parameters to match
+        field: str
+        #: Prefix to match in the field
+        prefix: str
+
+    class DynamicDiscoverQueryables(TypedDict, total=False):
+        """Configuration for queryables dynamic discovery.
+
+        The given configuration for queryables discovery is used if any collection selector
+        matches the search parameters.
+        """
+
+        #: List of collection selection criterias
+        collection_selector: list[PluginConfig.CollectionSelector]
+
+        #: Configuration for queryables discovery to use
+        discover_queryables: PluginConfig.DiscoverQueryables
+
     class OrderOnResponse(TypedDict):
         """Configuration for order on-response during download"""
 
@@ -501,6 +529,12 @@ class PluginConfig(yaml.YAMLObject):
     version: str
     #: :class:`~eodag.plugins.apis.ecmwf.EcmwfApi` url of the authentication endpoint
     auth_endpoint: str
+    #: :class:`~eodag.plugins.search.build_search_result.WekeoECMWFSearch`
+    #: Configurations for the queryables dynamic auto-discovery.
+    #: A configuration is used based on the given selection criterias. The first match is used.
+    #: If no match is found, it falls back to standard behaviors (e.g. discovery using
+    #: :attr:`~eodag.config.PluginConfig.discover_queryables`).
+    dynamic_discover_queryables: list[PluginConfig.DynamicDiscoverQueryables]
 
     # download ---------------------------------------------------------------------------------------------------------
     #: :class:`~eodag.plugins.download.base.Download` Default endpoint url