eodag 3.10.1__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

eodag/resources/stac_provider.yml

@@ -19,11 +19,13 @@ search:
   type: StacSearch
   results_entry: features
   pagination:
-    next_page_query_obj: '{{"limit":{items_per_page},"page":{page}}}'
+    next_page_query_obj: '{{"limit":{items_per_page},"{next_page_token_key}":"{next_page_token}"}}'
     total_items_nb_key_path: '$.numberMatched'
     next_page_url_key_path: '$.links[?(@.rel="next")].href'
     next_page_query_obj_key_path: '$.links[?(@.rel="next")].body'
     next_page_merge_key_path: '$.links[?(@.rel="next")].merge'
+    # do not use 'page' as default key, guess from provider response
+    next_page_token_key: null
   sort:
     sort_by_tpl: '{{"sortby": [ {{"field": "{sort_param}", "direction": "{sort_order}" }} ] }}'
     sort_order_mapping:
@@ -37,27 +39,27 @@ search:
       - filter
       - query
     metadata_path: '$.properties.*'
-  discover_product_types:
+  discover_collections:
     fetch_url: '{api_endpoint}/../collections'
     result_type: json
     results_entry: '$.collections[*]'
-    generic_product_type_id: '$.id'
-    generic_product_type_parsable_properties:
-      productType: '$.id'
-    generic_product_type_parsable_metadata:
-      abstract: '$.description'
-      instrument: '{$.summaries.instruments#csv_list}'
-      platform: '{$.summaries.constellation#csv_list}'
-      platformSerialIdentifier: '{$.summaries.platform#csv_list}'
-      processingLevel: '{$.summaries."processing:level"#csv_list}'
-      keywords: '{$.keywords#csv_list}'
+    generic_collection_id: '$.id'
+    generic_collection_parsable_properties:
+      _collection: '$.id'
+    generic_collection_parsable_metadata:
+      description: '$.description'
+      instruments: '$.summaries.instruments'
+      constellation: '{$.summaries.constellation#csv_list}'
+      platform: '{$.summaries.platform#csv_list}'
+      processing:level: '{$.summaries."processing:level"#csv_list}'
+      keywords: '$.keywords'
       license: '$.license'
       title: '$.title'
-      missionStartDate: '$.extent.temporal.interval[0][0]'
+      extent: '$.extent'
     metadata_path: '$.properties.*'
   discover_queryables:
     fetch_url: '{api_endpoint}/../queryables'
-    product_type_fetch_url: '{api_endpoint}/../collections/{provider_product_type}/queryables'
+    collection_fetch_url: '{api_endpoint}/../collections/{provider_collection}/queryables'
     result_type: json
     results_entry: '$.properties[*]'
     queryable_parsable_metadata:
@@ -67,94 +69,50 @@ search:
       pattern: '$.pattern'
   common_metadata_mapping_path: '$'
   metadata_mapping:
-    # OpenSearch Parameters for Collection Search (Table 3)
-    productType:
-      - '{{"collections":["{productType}"]}}'
+    productType: '$.null'
+    _collection:
+      - '{{"collections":["{_collection}"]}}'
       - '$.collection'
-    doi:
-      - '{{"query":{{"sci:doi":{{"eq":"{doi}"}}}}}}'
-      - '$.properties."sci:doi"'
-    processingLevel:
-      - '{{"query":{{"processing:level":{{"eq":"{processingLevel}"}}}}}}'
-      - '$.properties."processing:level"'
-    platform:
-      - '{{"query":{{"constellation":{{"eq":"{platform}"}}}}}}'
+    # common metadata
+    gsd:
+      - '{{"query":{{"gsd":{{"eq":"{gsd}"}}}}}}'
+      - '$.properties.gsd'
+    constellation:
+      - '{{"query":{{"constellation":{{"eq":"{constellation}"}}}}}}'
       - '$.properties.constellation'
-    platformSerialIdentifier:
-      - '{{"query":{{"platform":{{"eq":"{platformSerialIdentifier}"}}}}}}'
+    platform:
+      - '{{"query":{{"platform":{{"eq":"{platform}"}}}}}}'
       - '$.properties.platform'
-    instrument:
-    # to test
-      - '{{"query":{{"instruments":{{"eq":"{instrument}"}}}}}}'
-      - '{$.properties.instruments#csv_list}'
-    # INSPIRE obligated OpenSearch Parameters for Collection Search (Table 4)
+    instruments:
+      - '{{"query":{{"instruments":{{"eq":{instruments}}}}}}}'
+      - '$.properties.instruments'
     title: '$.id'
-    abstract: '$.properties.description'
-    resolution:
-      - '{{"query":{{"gsd":{{"eq":"{resolution}"}}}}}}'
-      - '$.properties.gsd'
-    publicationDate:
-      - '{{"query":{{"published":{{"eq":"{publicationDate}"}}}}}}'
-      - '$.properties.published'
-    # OpenSearch Parameters for Product Search (Table 5)
-    orbitNumber:
-      - '{{"query":{{"sat:relative_orbit":{{"eq":"{orbitNumber}"}}}}}}'
-      - '$.properties."sat:relative_orbit"'
-    orbitDirection:
-      - '{{"query":{{"sat:orbit_state":{{"eq":"{orbitDirection}"}}}}}}'
-      - '{$.properties."sat:orbit_state"#to_lower}'
-    cloudCover:
-      - '{{"query":{{"eo:cloud_cover":{{"lte":"{cloudCover}"}}}}}}'
-      - '$.properties."eo:cloud_cover"'
-    sensorMode:
-      - '{{"query":{{"sar:instrument_mode":{{"eq":"{sensorMode}"}}}}}}'
-      - '$.properties."sar:instrument_mode"'
-    creationDate:
-      - '{{"query":{{"created":{{"eq":"{creationDate}"}}}}}}'
-      - '$.properties.created'
-    modificationDate:
-      - '{{"query":{{"updated":{{"eq":"{modificationDate}"}}}}}}'
-      - '$.properties.updated'
-    productVersion:
-      - '{{"query":{{"version":{{"eq":"{productVersion}"}}}}}}'
-      - '$.properties.version'
-    # OpenSearch Parameters for Acquistion Parameters Search (Table 6)
-    availabilityTime:
-      - '{{"query":{{"availabilityTime":{{"eq":"{availabilityTime}"}}}}}}'
-      - '$.properties.availabilityTime'
-    acquisitionStation:
-      - '{{"query":{{"acquisitionStation":{{"eq":"{acquisitionStation}"}}}}}}'
-      - '$.properties.acquisitionStation'
-    acquisitionSubType:
-      - '{{"query":{{"acquisitionSubType":{{"eq":"{acquisitionSubType}"}}}}}}'
-      - '$.properties.acquisitionSubType'
-    startTimeFromAscendingNode: '$.properties.datetime'
-    completionTimeFromAscendingNode:
-      - '{{"datetime":"{startTimeFromAscendingNode#to_iso_utc_datetime}/{completionTimeFromAscendingNode#to_iso_utc_datetime}"}}'
+    datetime: '$.properties.datetime'
+    start_datetime: '$.properties.start_datetime'
+    end_datetime:
+      - '{{"datetime":"{start_datetime#to_iso_utc_datetime}/{end_datetime#to_iso_utc_datetime}"}}'
       - '$.properties.end_datetime'
-    illuminationAzimuthAngle:
-      - '{{"query":{{"view:sun_azimuth":{{"eq":"{illuminationAzimuthAngle}"}}}}}}'
-      - '$.properties."view:sun_azimuth"'
-    illuminationElevationAngle:
-      - '{{"query":{{"view:sun_elevation":{{"eq":"{illuminationElevationAngle}"}}}}}}'
-      - '$.properties."view:sun_elevation"'
-    polarizationChannels:
-      - '{{"query":{{"sar:polarizations":{{"eq":"{polarizationChannels}"}}}}}}'
-      - '{$.properties.sar:polarizations#csv_list(+)}'
-    dopplerFrequency:
-      - '{{"query":{{"sar:frequency_band":{{"eq":"{dopplerFrequency}"}}}}}}'
-      - '$.properties."sar:frequency_band"'
-    # Custom parameters (not defined in the base document referenced above)
     id:
       - '{{"ids":["{id}"]}}'
       - '$.id'
     geometry:
       - '{{"intersects":{geometry#to_geojson}}}'
       - '($.geometry.`str()`.`sub(/^None$/, POLYGON((180 -90, 180 90, -180 90, -180 -90, 180 -90)))`)|($.geometry[*])'
-    downloadLink: '$.links[?(@.rel="self")].href'
-    quicklook: '$.assets.quicklook.href'
-    thumbnail: '$.assets.thumbnail.href'
-    # storageStatus set to ONLINE for consistency between providers
-    storageStatus: '{$.null#replace_str("Not Available","ONLINE")}'
+    # extensions parameters having specific mapping
+    sar:polarizations:
+      - '{{"query":{{"sar:polarizations":{{"eq":{sar:polarizations}}}}}}}'
+      - '$.properties.sar:polarizations'
+    sar:beam_ids:
+      - '{{"query":{{"sar:beam_ids":{{"eq":{sar:beam_ids}}}}}}}'
+      - '$.properties.sar:beam_ids'
+    eo:cloud_cover:
+      - '{{"query":{{"eo:cloud_cover":{{"lte":{eo:cloud_cover}}}}}}}'
+      - '$.properties."eo:cloud_cover"'
+    # eodag metadata
+    eodag:download_link: '$.links[?(@.rel="self")].href'
+    eodag:quicklook: '$.assets.quicklook.href'
+    eodag:thumbnail: '$.assets.thumbnail.href'
+    # order:status set to succeeded for consistency between providers
+    order:status: '{$.null#replace_str("Not Available","succeeded")}'
     # Normalization code moves assets from properties to product's attr
     assets: '$.assets'

eodag/resources/user_conf_template.yml

@@ -107,6 +107,15 @@ dedt_lumi:
         credentials:
             username:
             password:
+dedt_mn5:
+    priority: # Lower value means lower priority (Default: 0)
+    search:
+    download:
+        output_dir:
+    auth:
+        credentials:
+            username:
+            password:
 earth_search:
     priority: # Lower value means lower priority (Default: 0)
     search: # Search parameters configuration

eodag/types/__init__.py

@@ -153,6 +153,7 @@ def json_field_definition_to_python(
     json_field_definition: dict[str, Any],
     default_value: Optional[Any] = None,
     required: Optional[bool] = False,
+    alias: Optional[str] = None,
 ) -> Annotated[Any, FieldInfo]:
     """Get python field definition from json object
 
@@ -180,6 +181,7 @@ def json_field_definition_to_python(
         pattern=json_field_definition.get("pattern", PydanticUndefined),
         le=json_field_definition.get("maximum", PydanticUndefined),
         ge=json_field_definition.get("minimum", PydanticUndefined),
+        alias=alias or PydanticUndefined,
     )
 
     enum = json_field_definition.get("enum")

eodag/types/queryables.py

@@ -1,20 +1,3 @@
-# -*- coding: utf-8 -*-
-# Copyright 2024, CS GROUP - France, https://www.csgroup.eu/
-#
-# This file is part of EODAG project
-#     https://www.github.com/CS-SI/EODAG
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
 from __future__ import annotations
 
 from collections import UserDict
@@ -36,14 +19,14 @@ Percentage = Annotated[PositiveInt, Lt(100)]
 class CommonQueryables(BaseModel):
     """A class representing search common queryable properties."""
 
-    productType: Annotated[str, Field()]
+    collection: Annotated[str, Field()]
 
     @classmethod
     def get_queryable_from_alias(cls, value: str) -> str:
         """Get queryable parameter from alias
 
-        >>> CommonQueryables.get_queryable_from_alias('productType')
-        'productType'
+        >>> CommonQueryables.get_queryable_from_alias('collection')
+        'collection'
         """
         alias_map = {
             field_info.alias: name
@@ -75,7 +58,7 @@ class Queryables(CommonQueryables):
         str,
         Field(
             None,
-            alias="startTimeFromAscendingNode",
+            alias="start_datetime",
             description="Date/time as string in ISO 8601 format (e.g. '2024-06-10T12:00:00Z')",
         ),
     ]
@@ -83,7 +66,7 @@ class Queryables(CommonQueryables):
         str,
         Field(
             None,
-            alias="completionTimeFromAscendingNode",
+            alias="end_datetime",
             description="Date/time as string in ISO 8601 format (e.g. '2024-06-10T12:00:00Z')",
         ),
     ]
@@ -95,77 +78,57 @@ class Queryables(CommonQueryables):
             description="Read EODAG documentation for all supported geometry format.",
         ),
     ]
-    uid: Annotated[str, Field(None)]
-    # OpenSearch Parameters for Collection Search (Table 3)
-    doi: Annotated[str, Field(None)]
+    # common metadata
+    constellation: Annotated[str, Field(None)]
+    created: Annotated[str, Field(None)]
+    description: Annotated[str, Field(None)]
+    gsd: Annotated[int, Field(None)]
+    id: Annotated[str, Field(None)]
+    instruments: Annotated[str, Field(None)]
+    keywords: Annotated[str, Field(None)]
+    license: Annotated[str, Field(None)]
     platform: Annotated[str, Field(None)]
-    platformSerialIdentifier: Annotated[str, Field(None)]
-    instrument: Annotated[str, Field(None)]
-    sensorType: Annotated[str, Field(None)]
-    compositeType: Annotated[str, Field(None)]
-    processingLevel: Annotated[str, Field(None)]
-    orbitType: Annotated[str, Field(None)]
-    spectralRange: Annotated[str, Field(None)]
-    wavelengths: Annotated[str, Field(None)]
-    hasSecurityConstraints: Annotated[str, Field(None)]
-    dissemination: Annotated[str, Field(None)]
-    # INSPIRE obligated OpenSearch Parameters for Collection Search (Table 4)
+    providers: Annotated[str, Field(None)]
     title: Annotated[str, Field(None)]
-    topicCategory: Annotated[str, Field(None)]
-    keyword: Annotated[str, Field(None)]
-    abstract: Annotated[str, Field(None)]
-    resolution: Annotated[int, Field(None)]
-    organisationName: Annotated[str, Field(None)]
-    organisationRole: Annotated[str, Field(None)]
-    publicationDate: Annotated[str, Field(None)]
-    lineage: Annotated[str, Field(None)]
-    useLimitation: Annotated[str, Field(None)]
-    accessConstraint: Annotated[str, Field(None)]
-    otherConstraint: Annotated[str, Field(None)]
-    classification: Annotated[str, Field(None)]
-    language: Annotated[str, Field(None)]
-    specification: Annotated[str, Field(None)]
-    # OpenSearch Parameters for Product Search (Table 5)
-    parentIdentifier: Annotated[str, Field(None)]
-    productionStatus: Annotated[str, Field(None)]
-    acquisitionType: Annotated[str, Field(None)]
-    orbitNumber: Annotated[int, Field(None)]
-    orbitDirection: Annotated[str, Field(None)]
-    track: Annotated[str, Field(None)]
-    frame: Annotated[str, Field(None)]
-    swathIdentifier: Annotated[str, Field(None)]
-    cloudCover: Annotated[Percentage, Field(None)]
-    snowCover: Annotated[Percentage, Field(None)]
-    lowestLocation: Annotated[str, Field(None)]
-    highestLocation: Annotated[str, Field(None)]
-    productVersion: Annotated[str, Field(None)]
-    productQualityStatus: Annotated[str, Field(None)]
-    productQualityDegradationTag: Annotated[str, Field(None)]
-    processorName: Annotated[str, Field(None)]
-    processingCenter: Annotated[str, Field(None)]
-    creationDate: Annotated[str, Field(None)]
-    modificationDate: Annotated[str, Field(None)]
-    processingDate: Annotated[str, Field(None)]
-    sensorMode: Annotated[str, Field(None)]
-    archivingCenter: Annotated[str, Field(None)]
-    processingMode: Annotated[str, Field(None)]
-    # OpenSearch Parameters for Acquistion Parameters Search (Table 6)
-    availabilityTime: Annotated[str, Field(None)]
-    acquisitionStation: Annotated[str, Field(None)]
-    acquisitionSubType: Annotated[str, Field(None)]
-    illuminationAzimuthAngle: Annotated[str, Field(None)]
-    illuminationZenithAngle: Annotated[str, Field(None)]
-    illuminationElevationAngle: Annotated[str, Field(None)]
-    polarizationMode: Annotated[str, Field(None)]
-    polarizationChannels: Annotated[str, Field(None)]
-    antennaLookDirection: Annotated[str, Field(None)]
-    minimumIncidenceAngle: Annotated[float, Field(None)]
-    maximumIncidenceAngle: Annotated[float, Field(None)]
-    dopplerFrequency: Annotated[float, Field(None)]
-    incidenceAngleVariation: Annotated[float, Field(None)]
-    # Custom parameters (not defined in the base document referenced above)
-    id: Annotated[str, Field(None)]
-    tileIdentifier: Annotated[str, Field(None, pattern=r"[0-9]{2}[A-Z]{3}")]
+    uid: Annotated[str, Field(None)]
+    updated: Annotated[str, Field(None)]
+    # eo extension
+    eo_cloud_cover: Annotated[Percentage, Field(None, alias="eo:cloud_cover")]
+    eo_snow_cover: Annotated[Percentage, Field(None, alias="eo:snow_cover")]
+    # grid extension
+    grid_code: Annotated[
+        str, Field(None, alias="grid:code", pattern=r"^[A-Z0-9]+-[-_.A-Za-z0-9]+$")
+    ]
+    # mgrs extension
+    mgrs_grid_square: Annotated[str, Field(None, alias="mgrs:grid_square")]
+    mgrs_latitude_band: Annotated[str, Field(None, alias="mgrs:latitude_band")]
+    mgrs_utm_zone: Annotated[str, Field(None, alias="mgrs:utm_zone")]
+    # order extension
+    order_status: Annotated[str, Field(None, alias="order:status")]
+    # processing extension
+    processing_level: Annotated[str, Field(None, alias="processing:level")]
+    # product extension
+    product_acquisition_type: Annotated[
+        str, Field(None, alias="product:acquisition_type")
+    ]
+    product_timeliness: Annotated[str, Field(None, alias="product:timeliness")]
+    product_type: Annotated[str, Field(None, alias="product:type")]
+    # sar extension
+    sar_beam_ids: Annotated[str, Field(None, alias="sar:beam_ids")]
+    sar_frequency_band: Annotated[float, Field(None, alias="sar:frequency_band")]
+    sar_instrument_mode: Annotated[str, Field(None, alias="sar:instrument_mode")]
+    sar_polarizations: Annotated[list[str], Field(None, alias="sar:polarizations")]
+    # sat extension
+    sat_absolute_orbit: Annotated[int, Field(None, alias="sat:absolute_orbit")]
+    sat_orbit_cycle: Annotated[int, Field(None, alias="sat:orbit_cycle")]
+    sat_orbit_state: Annotated[str, Field(None, alias="sat:orbit_state")]
+    sat_relative_orbit: Annotated[int, Field(None, alias="sat:relative_orbit")]
+    # sci extension
+    sci_doi: Annotated[str, Field(None, alias="sci:doi")]
+    # view extension
+    view_incidence_angle: Annotated[str, Field(None, alias="view:incidence_angle")]
+    view_sun_azimuth: Annotated[str, Field(None, alias="view:sun_azimuth")]
+    view_sun_elevation: Annotated[str, Field(None, alias="view:sun_elevation")]
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
@@ -190,6 +153,22 @@ class QueryablesDict(UserDict[str, Any]):
         self.additional_properties = additional_properties
         self.additional_information = additional_information
         super().__init__(kwargs)
+        # sort queryables: first without then with extension prefix
+        no_prefix_queryables = {
+            key: self.data[key]
+            for key in sorted(self.data)
+            if ":"
+            not in str(
+                getattr(self.data[key], "__metadata__", [Field()])[0].alias or key
+            )
+        }
+        with_prefix_queryables = {
+            key: self.data[key]
+            for key in sorted(self.data)
+            if ":"
+            in str(getattr(self.data[key], "__metadata__", [Field()])[0].alias or key)
+        }
+        self.data = no_prefix_queryables | with_prefix_queryables
 
     def _repr_html_(self, embedded: bool = False) -> str:
         add_info = (

eodag/types/search_args.py

@@ -43,7 +43,7 @@ class SearchArgs(BaseModel):
     model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
 
     provider: Optional[str] = Field(None)
-    productType: str = Field()
+    collection: str = Field()
     id: Optional[str] = Field(None)
     start: Optional[str] = Field(None)
     end: Optional[str] = Field(None)

eodag/utils/__init__.py

@@ -63,6 +63,8 @@ from typing import (
 from urllib.parse import urlparse, urlsplit
 from urllib.request import url2pathname
 
+from pydantic import ValidationError as PydanticValidationError
+
 if sys.version_info >= (3, 12):
     from typing import Unpack  # type: ignore # noqa
 else:
@@ -94,7 +96,7 @@ logger = py_logging.getLogger("eodag.utils")
 
 DEFAULT_PROJ = "EPSG:4326"
 
-GENERIC_PRODUCT_TYPE = "GENERIC_PRODUCT_TYPE"
+GENERIC_COLLECTION = "GENERIC_COLLECTION"
 GENERIC_STAC_PROVIDER = "generic_stac_provider"
 
 STAC_SEARCH_PLUGINS = [
@@ -129,7 +131,7 @@ DEFAULT_ITEMS_PER_PAGE = 20
 # (DEFAULT_ITEMS_PER_PAGE) to increase it to the known and current minimum value (mundi)
 DEFAULT_MAX_ITEMS_PER_PAGE = 50
 
-# default product-types start date
+# default collections start date
 DEFAULT_MISSION_START_DATE = "2015-01-01T00:00:00.000Z"
 
 # default geometry / whole world bounding box
@@ -138,6 +140,9 @@ DEFAULT_SHAPELY_GEOMETRY = box(-180, -90, 180, 90)
 # default token expiration margin in seconds
 DEFAULT_TOKEN_EXPIRATION_MARGIN = 60
 
+# knwown next page token keys used to guess key in STAC providers next link responses
+KNOWN_NEXT_PAGE_TOKEN_KEYS = ["token", "next", "page", "skip"]
+
 # update missing mimetypes
 mimetypes.add_type("text/xml", ".xsd")
 mimetypes.add_type("application/x-grib", ".grib")
@@ -340,11 +345,11 @@ def merge_mappings(mapping1: dict[Any, Any], mapping2: dict[Any, Any]) -> None:
 
     Do its best to detect the key in ``mapping1`` to override. For example:
 
-    >>> mapping2 = {"keya": "new"}
-    >>> mapping1 = {"keyA": "obsolete"}
+    >>> mapping2 = {"ext_keya": "new"}
+    >>> mapping1 = {"ext:keyA": "obsolete"}
     >>> merge_mappings(mapping1, mapping2)
     >>> mapping1
-    {'keyA': 'new'}
+    {'ext:keyA': 'new'}
 
     If ``mapping2`` has a key that cannot be detected in ``mapping1``, this new key is
     added to ``mapping1`` as is.
@@ -353,7 +358,7 @@ def merge_mappings(mapping1: dict[Any, Any], mapping2: dict[Any, Any]) -> None:
     :param mapping2: The mapping containing values that will override the first mapping
     """
     # A mapping between mapping1 keys as lowercase strings and original mapping1 keys
-    m1_keys_lowercase = {key.lower(): key for key in mapping1}
+    m1_keys_lowercase = {key.lower().replace(":", "_"): key for key in mapping1}
     for key, value in mapping2.items():
         if isinstance(value, dict):
             try:
@@ -478,20 +483,6 @@ class ProgressCallback(tqdm):
         return ProgressCallback(*args, **dict(self.kwargs, **kwargs))
 
 
-@_deprecated(reason="Use ProgressCallback class instead", version="2.2.1")
-class NotebookProgressCallback(tqdm):
-    """A custom progress bar to be used inside Jupyter notebooks"""
-
-    pass
-
-
-@_deprecated(reason="Use ProgressCallback class instead", version="2.2.1")
-def get_progress_callback() -> tqdm:
-    """Get progress_callback"""
-
-    return tqdm()
-
-
 def repeatfunc(func: Callable[..., Any], n: int, *args: Any) -> starmap:
     """Call ``func`` ``n`` times with ``args``"""
     return starmap(func, repeat(args, n))
@@ -975,7 +966,9 @@ def string_to_jsonpath(*args: Any, force: bool = False) -> Union[str, JSONPath]:
         return path_str
 
 
-def format_string(key: str, str_to_format: Any, **format_variables: Any) -> Any:
+def format_string(
+    key: Optional[str], str_to_format: Any, **format_variables: Any
+) -> Any:
     """Format ``"{foo}"``-like string
 
     >>> format_string(None, "foo {bar}, {baz} ?", **{"bar": "qux", "baz": "quux"})
@@ -999,6 +992,27 @@ def format_string(key: str, str_to_format: Any, **format_variables: Any) -> Any:
         # defaultdict usage will return "" for missing keys in format_args
         try:
             result = str_to_format.format_map(defaultdict(str, **format_variables))
+        except (ValueError, TypeError) as e:
+            if not re.search(r"{[\w-]*:[\w-]*}", str_to_format):
+                raise MisconfiguredError(
+                    f"Unable to format str={str_to_format} using {str(format_variables)}: {str(e)}"
+                )
+        # retry parsing colons
+        try:
+            str_without_colons = re.sub(
+                r"{([\w-]*):([\w-]*)}",
+                r"{\1_COLON_\2}",
+                str_to_format,
+            )
+            result = str_without_colons.format_map(
+                defaultdict(
+                    str,
+                    **{
+                        k.replace(":", "_COLON_"): v
+                        for k, v in format_variables.items()
+                    },
+                )
+            )
         except (ValueError, TypeError) as e:
             raise MisconfiguredError(
                 f"Unable to format str={str_to_format} using {str(format_variables)}: {str(e)}"
@@ -1643,3 +1657,65 @@ def parse_le_uint16(data: bytes) -> int:
     65535
     """
     return struct.unpack("<H", data)[0]
+
+
+def format_pydantic_error(e: PydanticValidationError) -> str:
+    """Format Pydantic ValidationError
+
+    :param e: A Pydantic ValidationError object
+    :type e: PydanticValidationError
+    """
+    error_header = f"{e.error_count()} error(s). "
+
+    error_messages = [
+        f'{err["loc"][0]}: {err["msg"]}' if err["loc"] else err["msg"]
+        for err in e.errors()
+    ]
+    return error_header + "; ".join(set(error_messages))
+
+
+def get_collection_dates(
+    collection_dict: dict[str, Any]
+) -> tuple[Optional[str], Optional[str]]:
+    """Extract mission start and end dates from collection configuration.
+
+    Extracts dates from the extent.temporal.interval structure.
+
+    :param collection_dict: Collection configuration dictionary
+    :returns: Tuple of (mission_start_date, mission_end_date) as ISO strings or None
+
+    Example:
+    >>> get_collection_dates({
+    ...     "extent": {"temporal": {"interval": [["2017-10-13T00:00:00Z", "2023-12-31T23:59:59Z"]]}}
+    ... })
+    ('2017-10-13T00:00:00Z', '2023-12-31T23:59:59Z')
+
+    >>> get_collection_dates({
+    ...     "extent": {"temporal": {"interval": [["2017-10-13T00:00:00Z", None]]}}
+    ... })
+    ('2017-10-13T00:00:00Z', None)
+
+    >>> get_collection_dates({})
+    (None, None)
+    """
+    extent_interval = (
+        collection_dict.get("extent", {})
+        .get("temporal", {})
+        .get("interval", [[None, None]])
+    )
+
+    if not extent_interval or len(extent_interval) == 0:
+        return None, None
+
+    mission_start = (
+        extent_interval[0][0]
+        if len(extent_interval) > 0 and len(extent_interval[0]) > 0
+        else None
+    )
+    mission_end = (
+        extent_interval[0][1]
+        if len(extent_interval) > 0 and len(extent_interval[0]) > 1
+        else None
+    )
+
+    return mission_start, mission_end

eodag/utils/dates.py

@@ -35,18 +35,6 @@ RFC3339_PATTERN = (
     r"(Z|([+-])(\d{2}):(\d{2}))?)?$"
 )
 
-# yyyy-mm-dd
-DATE_PATTERN = r"\d{4}-(0[1-9]|1[1,2])-(0[1-9]|[12][0-9]|3[01])"
-
-# yyyymmdd
-COMPACT_DATE_PATTERN = r"\d{4}(0[1-9]|1[1,2])(0[1-9]|[12][0-9]|3[01])"
-
-# yyyy-mm-dd/yyyy-mm-dd, yyyy-mm-dd/to/yyyy-mm-dd
-DATE_RANGE_PATTERN = DATE_PATTERN + r"(/to/|/)" + DATE_PATTERN
-
-# yyyymmdd/yyyymmdd, yyyymmdd/to/yyyymmdd
-COMPACT_DATE_RANGE_PATTERN = COMPACT_DATE_PATTERN + r"(/to/|/)" + COMPACT_DATE_PATTERN
-
 
 def get_timestamp(date_time: str) -> float:
     """Return the Unix timestamp of an ISO8601 date/datetime in seconds.