eodag 3.10.0__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

eodag/resources/stac_provider.yml

@@ -37,27 +37,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}'
+    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#csv_list}'
       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 +67,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/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')",
         ),
     ]
@@ -91,80 +74,61 @@ class Queryables(CommonQueryables):
         Union[str, dict[str, float], BaseGeometry],
         Field(
             None,
+            alias="geometry",
             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)
 

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 token expiration margin in seconds
@@ -337,11 +339,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.
@@ -350,7 +352,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:
@@ -475,20 +477,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))
@@ -972,7 +960,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"})
@@ -996,6 +986,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)}"
@@ -1601,3 +1612,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/exceptions.py

@@ -49,11 +49,11 @@ class UnsupportedProvider(EodagError):
     """An error indicating that eodag does not support a provider"""
 
 
-class UnsupportedProductType(EodagError):
-    """An error indicating that eodag does not support a product type"""
+class UnsupportedCollection(EodagError):
+    """An error indicating that eodag does not support a collection"""
 
-    def __init__(self, product_type: str) -> None:
-        self.product_type = product_type
+    def __init__(self, collection: str) -> None:
+        self.collection = collection
 
 
 class UnsupportedDatasetAddressScheme(EodagError):
@@ -70,8 +70,8 @@ class NotAvailableError(EodagError):
     """An error indicating that the product is not available for download"""
 
 
-class NoMatchingProductType(EodagError):
-    """An error indicating that eodag was unable to derive a product type from a set
+class NoMatchingCollection(EodagError):
+    """An error indicating that eodag was unable to derive a collection from a set
     of search parameters"""
 
 

eodag/utils/free_text_search.py

@@ -197,17 +197,17 @@ def compile_free_text_query(query: str) -> Callable[[dict[str, str]], bool]:
     >>> evaluator = compile_free_text_query('("FooAndBar" OR BAR) AND "FOOBAR collection"')
     >>> evaluator({
     ...     "title": "titleFOOBAR - Lorem FOOBAR collection",
-    ...     "abstract": "abstract FOOBAR - This is FOOBAR. FooAndBar"
+    ...     "description": "abstract FOOBAR - This is FOOBAR. FooAndBar"
     ... })
     True
     >>> evaluator({
     ...     "title": "collection FOOBAR",
-    ...     "abstract": "abstract FOOBAR - This is FOOBAR. FooAndBar"
+    ...     "description": "abstract FOOBAR - This is FOOBAR. FooAndBar"
     ... })
     False
     >>> evaluator({
     ...     "title": "titleFOOBAR - Lorem FOOBAR ",
-    ...     "abstract": "abstract FOOBAR - This is FOOBAR."
+    ...     "description": "abstract FOOBAR - This is FOOBAR."
     ... })
     False
     >>> evaluator({"title": "Only Bar here"})