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

eodag/api/product/metadata_mapping.py

@@ -42,7 +42,6 @@ from shapely.ops import transform
 from eodag.types.queryables import Queryables
 from eodag.utils import (
     DEFAULT_PROJ,
-    _deprecated,
     deepcopy,
     dict_items_recursive_apply,
     format_string,
@@ -58,6 +57,8 @@ from eodag.utils.dates import get_timestamp
 from eodag.utils.exceptions import ValidationError
 
 if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
     from shapely.geometry.base import BaseGeometry
 
     from eodag.config import PluginConfig
@@ -70,9 +71,9 @@ INGEST_CONVERSION_REGEX = re.compile(
 )
 NOT_AVAILABLE = "Not Available"
 NOT_MAPPED = "Not Mapped"
-ONLINE_STATUS = "ONLINE"
-STAGING_STATUS = "STAGING"
-OFFLINE_STATUS = "OFFLINE"
+ONLINE_STATUS = "succeeded"
+STAGING_STATUS = "ordered"
+OFFLINE_STATUS = "orderable"
 COORDS_ROUNDING_PRECISION = 4
 WKT_MAX_LEN = 1600
 COMPLEX_QS_REGEX = re.compile(r"^(.+=)?([^=]*)({.+})+([^=&]*)$")
@@ -96,23 +97,23 @@ def get_metadata_path(
             search:
                 ...
                 metadata_mapping:
-                    productType:
-                        - productType
-                        - $.properties.productType
+                    platform:
+                        - platform
+                        - $.properties.platform
                     id: $.properties.id
                     ...
                 ...
             ...
 
-    Then the metadata `id` is not queryable for this provider meanwhile `productType`
-    is queryable. The first value of the `metadata_mapping.productType` is how the
-    eodag search parameter `productType` is interpreted in the
+    Then the metadata `id` is not queryable for this provider meanwhile `platform`
+    is queryable. The first value of the `metadata_mapping.platform` is how the
+    eodag search parameter `platform` is interpreted in the
     :class:`~eodag.plugins.search.base.Search` plugin implemented by `provider`, and is
     used when eodag delegates search process to the corresponding plugin.
 
     :param map_value: The value originating from the definition of `metadata_mapping`
                       in the provider search config. For example, it is the list
-                      `['productType', '$.properties.productType']` with the sample
+                      `['platform', '$.properties.platform']` with the sample
                       above. Or the string `$.properties.id`.
     :returns: Either, None and the path to the metadata value, or a list of converter
              and its args, and the path to the metadata value.
@@ -159,15 +160,19 @@ 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
+        - ``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
           splitting the string on dots
         - ``replace_str``: execute "string".replace(old, new)
+        - ``replace_str_tuple``: apply multiple replacements on a string (parts or complete)
+        - ``replace_tuple``: apply multiple replacements matching whole value
         - ``s2msil2a_title_to_aws_productinfo``: used to generate SAFE format metadata for data from AWS
         - ``sanitize``: sanitize string
         - ``slice_str``: slice a string (equivalent to s[start, end, step])
+        - ``split``: split a string using given separator
         - ``split_cop_dem_id``: get the bbox by splitting the product id
-        - ``split_corine_id``: get the product type by splitting the product id
+        - ``split_corine_id``: get the collection by splitting the product id
         - ``to_bounds_lists``: convert to list(s) of bounds
         - ``to_datetime_dict``: convert a datetime string to a dictionary where values are either a string or a list
         - ``to_ewkt``: convert to EWKT (Extended Well-Known text)
@@ -199,6 +204,44 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             self.custom_converter: Optional[Callable] = None
             self.custom_args: Optional[str] = None
 
+        def parse(self, format_string: str):
+            """
+            Rewrite field names in the template before the base parser sees them.
+            Replaces `{foo:bar}` with `{foo__bar}`.
+            """
+            pattern = re.compile(r"{([^{}]+)}")
+
+            def rewrite_field(field: str) -> str:
+                # If there's a format spec (e.g., {foo:bar:.2f}), preserve it
+                if ":" in field and not field.lstrip().startswith(("!", ".", ":")):
+                    before_colon, *after = field.split(":")
+                    # Don't confuse format spec with field name colons
+                    if len(after) == 1 and "." in after[0]:
+                        # It's a format specifier, leave it
+                        return field
+                    return field.replace(":", "__", 1)
+                return field
+
+            # Replace in string (but not in format_spec itself)
+            safe_template = pattern.sub(
+                lambda m: "{" + rewrite_field(m.group(1)) + "}", format_string
+            )
+
+            # Yield from base class
+            yield from super().parse(safe_template)
+
+        def get_value(
+            self, key: Any, args: "Sequence[Any]", kwargs: "Mapping[str, Any]"
+        ) -> Any:
+            """
+            Look up rewritten field name in kwargs by converting __ back to :
+            """
+            if isinstance(key, str):
+                original_key = key.replace("__", ":")
+                key_with_COLON = key.replace("__", "_COLON_")
+                return kwargs.get(original_key) or kwargs.get(key_with_COLON)
+            return super().get_value(key, args, kwargs)
+
         def get_field(self, field_name: str, args: Any, kwargs: Any) -> Any:
             conversion_func_spec = self.CONVERSION_REGEX.match(field_name)
             # Register a custom converter if any for later use (see convert_field)
@@ -529,11 +572,15 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             return re.sub(old, new, value)
 
         @staticmethod
-        def convert_replace_str_tuple(value: Any, args: str) -> str:
+        def convert_replace_str_tuple(
+            value: Union[str, dict[Any, Any]], args: str
+        ) -> str:
             """
-            Apply multiple replacements on a string.
-            args should be a string representing a list/tuple of (old, new) pairs.
-            Example: '(("old1", "new1"), ("old2", "new2"))'
+            Apply multiple replacements on a string (parts or complete).
+
+            :param value: input string or dict.
+            :param args: string representing a list/tuple of (old, new) pairs, like
+                         ``'(("old1", "new1"), ("old2", "new2"))'``
             """
             if isinstance(value, dict):
                 value = MetadataFormatter.convert_to_geojson(value)
@@ -557,6 +604,57 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
 
             return value
 
+        @staticmethod
+        def convert_replace_tuple(value: Any, args: str) -> Any:
+            """
+            Apply multiple replacements matching whole value.
+
+            :param value: input to replace
+            :param args: string representing a list/tuple of (old, new) pairs, like
+                         ``'((["old1"], "new1"), ("old2", ["new2"]))'``
+            """
+            # args sera une chaîne représentant une liste/tuple de tuples
+            replacements = ast.literal_eval(args)
+
+            if not isinstance(replacements, (list, tuple)):
+                raise TypeError(
+                    f"convert_replace_str_tuple expects a list/tuple of (old,new) pairs. "
+                    f"Got {type(replacements)}: {replacements}"
+                )
+
+            for old, new in replacements:
+                if old == value:
+                    return new
+
+            return value
+
+        @staticmethod
+        def convert_not_available(value: Any) -> str:
+            """Convert any value to "Not Available".
+
+            This is more useful than "$.null" to keep original jsonpath while parsing in metadata_mapping.
+            """
+            return NOT_AVAILABLE
+
+        @staticmethod
+        def convert_split(value: str, separator: str) -> list[str]:
+            """Split a string using given separator"""
+            if value == NOT_AVAILABLE:
+                return [NOT_AVAILABLE]
+            if not isinstance(value, str):
+                logger.warning(
+                    "Could not split non-string value %s (type %s)", value, type(value)
+                )
+                return [NOT_AVAILABLE]
+            if not isinstance(separator, str):
+                logger.warning(
+                    "Could not split string using non-string separator %s (type %s)",
+                    separator,
+                    type(separator),
+                )
+                return [NOT_AVAILABLE]
+            return value.split(separator)
+
         @staticmethod
         def convert_ceda_collection_name(value: str) -> str:
             data_regex = re.compile(r"/data/(?P<name>.+?)/?$")
@@ -653,7 +751,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                 int(x.strip()) if x.strip().lstrip("-").isdigit() else None
                 for x in args.split(",")
             ]
-            return string[cmin:cmax:cstep]
+            return string[cmin:cmax:cstep] or NOT_AVAILABLE
 
         @staticmethod
         def convert_to_lower(string: str) -> str:
@@ -702,7 +800,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             if id_match:
                 id_dict = id_match.groupdict()
                 return (
-                    "https://roda.sentinel-hub.com/sentinel-s2-l2a/tiles/%s/%s/%s/%s/%s/%s/0/{collection}.json"
+                    "https://roda.sentinel-hub.com/sentinel-s2-l2a/tiles/%s/%s/%s/%s/%s/%s/0/{_collection}.json"
                     % (
                         id_dict["tile1"],
                         id_dict["tile2"],
@@ -716,49 +814,10 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                 logger.error("Could not extract title infos from %s" % string)
                 return NOT_AVAILABLE
 
-        @staticmethod
-        @_deprecated(
-            reason="Method that was used in previous wekeo provider configuration, but not used anymore",
-            version="3.7.1",
-        )
-        def convert_split_id_into_s1_params(product_id: str) -> dict[str, str]:
-            parts: list[str] = re.split(r"_(?!_)", product_id)
-            if len(parts) < 9:
-                logger.error(
-                    "id %s does not match expected Sentinel-1 id format", product_id
-                )
-                raise ValueError
-            params = {"sensorMode": parts[1]}
-            level = "LEVEL" + parts[3][0]
-            params["processingLevel"] = level
-            start_date = datetime.strptime(parts[4], "%Y%m%dT%H%M%S") - timedelta(
-                seconds=1
-            )
-            params["startDate"] = start_date.strftime("%Y-%m-%dT%H:%M:%SZ")
-            end_date = datetime.strptime(parts[5], "%Y%m%dT%H%M%S") + timedelta(
-                seconds=1
-            )
-            params["endDate"] = end_date.strftime("%Y-%m-%dT%H:%M:%SZ")
-            product_type = parts[2][:3]
-            if product_type == "GRD" and parts[-1] == "COG":
-                product_type = "GRD-COG"
-            elif product_type == "GRD" and parts[-2] == "CARD" and parts[-1] == "BS":
-                product_type = "CARD-BS"
-            params["productType"] = product_type
-            polarisation_mapping = {
-                "SV": "VV",
-                "SH": "HH",
-                "DH": "HH+HV",
-                "DV": "VV+VH",
-            }
-            polarisation = polarisation_mapping[parts[3][2:]]
-            params["polarisation"] = polarisation
-            return params
-
         @staticmethod
         def convert_split_id_into_s3_params(product_id: str) -> dict[str, str]:
             parts: list[str] = re.split(r"_(?!_)", product_id)
-            params = {"productType": product_id[4:15]}
+            params = {"collection": product_id[4:15]}
             dates = re.findall("[0-9]{8}T[0-9]{6}", product_id)
             start_date = datetime.strptime(dates[0], "%Y%m%dT%H%M%S") - timedelta(
                 seconds=1
@@ -772,48 +831,6 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             params["sat"] = "Sentinel-" + parts[0][1:]
             return params
 
-        @staticmethod
-        @_deprecated(
-            reason="Method that was used in previous wekeo provider configuration, but not used anymore",
-            version="3.7.1",
-        )
-        def convert_split_id_into_s5p_params(product_id: str) -> dict[str, str]:
-            parts: list[str] = re.split(r"_(?!_)", product_id)
-            params = {
-                "productType": product_id[9:19],
-                "processingMode": parts[1],
-                "processingLevel": parts[2].replace("_", ""),
-            }
-            start_date = datetime.strptime(parts[-6], "%Y%m%dT%H%M%S") - timedelta(
-                seconds=10
-            )
-            params["startDate"] = start_date.strftime("%Y-%m-%dT%H:%M:%SZ")
-            end_date = datetime.strptime(parts[-5], "%Y%m%dT%H%M%S") + timedelta(
-                seconds=10
-            )
-            params["endDate"] = end_date.strftime("%Y-%m-%dT%H:%M:%SZ")
-            return params
-
-        @staticmethod
-        @_deprecated(
-            reason="Method that was used in previous wekeo provider configuration, but not used anymore",
-            version="3.7.1",
-        )
-        def convert_split_cop_dem_id(product_id: str) -> list[int]:
-            parts = product_id.split("_")
-            lattitude = parts[3]
-            longitude = parts[5]
-            if lattitude[0] == "N":
-                lat_num = int(lattitude[1:])
-            else:
-                lat_num = -1 * int(lattitude[1:])
-            if longitude[0] == "E":
-                long_num = int(longitude[1:])
-            else:
-                long_num = -1 * int(longitude[1:])
-            bbox = [long_num - 1, lat_num - 1, long_num + 1, lat_num + 1]
-            return bbox
-
         @staticmethod
         def convert_dates_from_cmems_id(product_id: str):
             date_format_1 = "[0-9]{10}"
@@ -1035,8 +1052,12 @@ 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"{[\w-]*:[\w#-]*}", search_param):
-        search_param = re.sub(r"{([\w-]*):([\w#-]*)}", 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)
@@ -1059,6 +1080,7 @@ def properties_from_json(
                              `discovery_path` (String representation of jsonpath)
     :returns: The metadata of the :class:`~eodag.api.product._product.EOProduct`
     """
+    extracted_value: Any
     properties: dict[str, Any] = {}
     templates = {}
     used_jsonpaths = []
@@ -1069,7 +1091,7 @@ def properties_from_json(
         else:
             conversion_or_none, path_or_text = value
         if isinstance(path_or_text, str):
-            if re.search(r"({[^{}:]+})+", path_or_text):
+            if re.search(r"{[^{}]+}", path_or_text):
                 templates[metadata] = path_or_text
             else:
                 properties[metadata] = path_or_text
@@ -1078,11 +1100,13 @@ def properties_from_json(
                 match = path_or_text.find(json)
             except KeyError:
                 match = []
-            if len(match) == 1:
+            if len(match) == 0:
+                extracted_value = NOT_AVAILABLE
+            elif len(match) == 1:
                 extracted_value = match[0].value
                 used_jsonpaths.append(match[0].full_path)
             else:
-                extracted_value = NOT_AVAILABLE
+                extracted_value = [m.value for m in match]
             if extracted_value is None:
                 properties[metadata] = None
             else:
@@ -1154,6 +1178,7 @@ def properties_from_json(
             if isinstance(discovery_jsonpath, JSONPath)
             else []
         )
+        mtd_prefix = discovery_config.get("metadata_prefix", "provider")
         for found_jsonpath in discovered_properties:
             if "metadata_path_id" in discovery_config.keys():
                 found_key_paths = string_to_jsonpath(
@@ -1175,8 +1200,13 @@ def properties_from_json(
             if (
                 re.compile(discovery_pattern).match(found_key)
                 and found_key not in properties.keys()
+                and f"{mtd_prefix}:{found_key}" not in properties.keys()
                 and used_jsonpath not in used_jsonpaths
             ):
+                # prepend with default STAC prefix if none is already used
+                if ":" not in found_key:
+                    found_key = f"{mtd_prefix}:{found_key}"
+
                 if "metadata_path_value" in discovery_config.keys():
                     found_value_path = string_to_jsonpath(
                         discovery_config["metadata_path_value"], force=True
@@ -1401,7 +1431,7 @@ def mtd_cfg_as_conversion_and_querypath(
 
 
 def format_query_params(
-    product_type: str,
+    collection: str,
     config: PluginConfig,
     query_dict: dict[str, Any],
     error_context: str = "",
@@ -1412,14 +1442,14 @@ def format_query_params(
     # . not allowed in eodag_search_key, replaced with %2E
     query_dict = {k.replace(".", "%2E"): v for k, v in query_dict.items()}
 
-    product_type_metadata_mapping = dict(
+    collection_metadata_mapping = dict(
         config.metadata_mapping,
-        **config.products.get(product_type, {}).get("metadata_mapping", {}),
+        **config.products.get(collection, {}).get("metadata_mapping", {}),
     )
 
     # Raise error if non-queryables parameters are used and raise_mtd_discovery_error configured
     if (
-        raise_mtd_discovery_error := config.products.get(product_type, {})
+        raise_mtd_discovery_error := config.products.get(collection, {})
         .get("discover_metadata", {})
         .get("raise_mtd_discovery_error")
     ) is None:
@@ -1433,7 +1463,7 @@ def format_query_params(
     queryables = _get_queryables(
         query_dict,
         config,
-        product_type_metadata_mapping,
+        collection_metadata_mapping,
         raise_mtd_discovery_error,
         error_context,
     )
@@ -1458,7 +1488,7 @@ def format_query_params(
             parts = provider_search_param.split("=")
             if len(parts) == 1:
                 formatted_query_param = format_metadata(
-                    provider_search_param, product_type, **query_dict
+                    provider_search_param, collection, **query_dict
                 )
                 formatted_query_param = formatted_query_param.replace("'", '"')
                 if "{{" in provider_search_param:
@@ -1469,6 +1499,11 @@ def format_query_params(
                     formatted_query_param = remove_str_array_quotes(
                         formatted_query_param
                     )
+                    if NOT_AVAILABLE in formatted_query_param:
+                        raise ValidationError(
+                            "Could not parse %s query parameter, got %s"
+                            % (eodag_search_key, formatted_query_param)
+                        )
 
                     # json query string (for POST request)
                     update_nested_dict(
@@ -1482,7 +1517,7 @@ def format_query_params(
             else:
                 provider_search_key, provider_value = parts
                 query_params[provider_search_key] = format_metadata(
-                    provider_value, product_type, **query_dict
+                    provider_value, collection, **query_dict
                 )
         else:
             query_params[provider_search_param] = user_input
@@ -1496,12 +1531,12 @@ def format_query_params(
     # Now add formatted free text search parameters (this is for cases where a
     # complex query through a free text search parameter is available for the
     # provider and needed for the consumer)
-    product_type_metadata_mapping = dict(
+    collection_metadata_mapping = dict(
         config.metadata_mapping,
-        **config.products.get(product_type, {}).get("metadata_mapping", {}),
+        **config.products.get(collection, {}).get("metadata_mapping", {}),
     )
     literal_search_params.update(
-        _format_free_text_search(config, product_type_metadata_mapping, **query_dict)
+        _format_free_text_search(config, collection_metadata_mapping, **query_dict)
     )
     for provider_search_key, provider_value in literal_search_params.items():
         if isinstance(provider_value, list):
@@ -1598,7 +1633,7 @@ def _get_queryables(
             # raise an error when a query param not allowed by the provider is found
             if not isinstance(md_mapping, list) and raise_mtd_discovery_error:
                 raise ValidationError(
-                    "Search parameters which are not queryable are disallowed for this product type on this provider: "
+                    "Search parameters which are not queryable are disallowed for this collection on this provider: "
                     f"please remove '{eodag_search_key}' from your search parameters. {error_context}",
                     {eodag_search_key},
                 )
@@ -1720,102 +1755,3 @@ def get_provider_queryable_key(
         return ""
     else:
         return eodag_key
-
-
-# Keys taken from OpenSearch extension for Earth Observation http://docs.opengeospatial.org/is/13-026r9/13-026r9.html
-# For a metadata to be queryable, The way to query it must be specified in the
-# provider metadata_mapping configuration parameter. It will be automatically
-# detected as queryable by eodag when this is done
-OSEO_METADATA_MAPPING = {
-    # Opensearch resource identifier within the search engine context (in our case
-    # within the context of the data provider)
-    "uid": "$.uid",
-    # OpenSearch Parameters for Collection Search (Table 3)
-    "productType": "$.properties.productType",
-    "doi": "$.properties.doi",
-    "platform": "$.properties.platform",
-    "platformSerialIdentifier": "$.properties.platformSerialIdentifier",
-    "instrument": "$.properties.instrument",
-    "sensorType": "$.properties.sensorType",
-    "compositeType": "$.properties.compositeType",
-    "processingLevel": "$.properties.processingLevel",
-    "orbitType": "$.properties.orbitType",
-    "spectralRange": "$.properties.spectralRange",
-    "wavelengths": "$.properties.wavelengths",
-    "hasSecurityConstraints": "$.properties.hasSecurityConstraints",
-    "dissemination": "$.properties.dissemination",
-    # INSPIRE obligated OpenSearch Parameters for Collection Search (Table 4)
-    "title": "$.properties.title",
-    "topicCategory": "$.properties.topicCategory",
-    "keyword": "$.properties.keyword",
-    "abstract": "$.properties.abstract",
-    "resolution": "$.properties.resolution",
-    "organisationName": "$.properties.organisationName",
-    "organisationRole": "$.properties.organisationRole",
-    "publicationDate": "$.properties.publicationDate",
-    "lineage": "$.properties.lineage",
-    "useLimitation": "$.properties.useLimitation",
-    "accessConstraint": "$.properties.accessConstraint",
-    "otherConstraint": "$.properties.otherConstraint",
-    "classification": "$.properties.classification",
-    "language": "$.properties.language",
-    "specification": "$.properties.specification",
-    # OpenSearch Parameters for Product Search (Table 5)
-    "parentIdentifier": "$.properties.parentIdentifier",
-    "productionStatus": "$.properties.productionStatus",
-    "acquisitionType": "$.properties.acquisitionType",
-    "orbitNumber": "$.properties.orbitNumber",
-    "orbitDirection": "$.properties.orbitDirection",
-    "track": "$.properties.track",
-    "frame": "$.properties.frame",
-    "swathIdentifier": "$.properties.swathIdentifier",
-    "cloudCover": "$.properties.cloudCover",
-    "snowCover": "$.properties.snowCover",
-    "lowestLocation": "$.properties.lowestLocation",
-    "highestLocation": "$.properties.highestLocation",
-    "productVersion": "$.properties.productVersion",
-    "productQualityStatus": "$.properties.productQualityStatus",
-    "productQualityDegradationTag": "$.properties.productQualityDegradationTag",
-    "processorName": "$.properties.processorName",
-    "processingCenter": "$.properties.processingCenter",
-    "creationDate": "$.properties.creationDate",
-    "modificationDate": "$.properties.modificationDate",
-    "processingDate": "$.properties.processingDate",
-    "sensorMode": "$.properties.sensorMode",
-    "archivingCenter": "$.properties.archivingCenter",
-    "processingMode": "$.properties.processingMode",
-    # OpenSearch Parameters for Acquistion Parameters Search (Table 6)
-    "availabilityTime": "$.properties.availabilityTime",
-    "acquisitionStation": "$.properties.acquisitionStation",
-    "acquisitionSubType": "$.properties.acquisitionSubType",
-    "startTimeFromAscendingNode": "$.properties.startTimeFromAscendingNode",
-    "completionTimeFromAscendingNode": "$.properties.completionTimeFromAscendingNode",
-    "illuminationAzimuthAngle": "$.properties.illuminationAzimuthAngle",
-    "illuminationZenithAngle": "$.properties.illuminationZenithAngle",
-    "illuminationElevationAngle": "$.properties.illuminationElevationAngle",
-    "polarizationMode": "$.properties.polarizationMode",
-    "polarizationChannels": "$.properties.polarizationChannels",
-    "antennaLookDirection": "$.properties.antennaLookDirection",
-    "minimumIncidenceAngle": "$.properties.minimumIncidenceAngle",
-    "maximumIncidenceAngle": "$.properties.maximumIncidenceAngle",
-    "dopplerFrequency": "$.properties.dopplerFrequency",
-    "incidenceAngleVariation": "$.properties.incidenceAngleVariation",
-}
-DEFAULT_METADATA_MAPPING = dict(
-    OSEO_METADATA_MAPPING,
-    **{
-        # Custom parameters (not defined in the base document referenced above)
-        # id differs from uid. The id is an identifier by which a product which is
-        # distributed by many providers can be retrieved (a property that it has in common
-        # in the catalogues of all the providers on which it is referenced)
-        "id": "$.id",
-        # The geographic extent of the product
-        "geometry": "$.geometry",
-        # The url of the quicklook
-        "quicklook": "$.properties.quicklook",
-        # The url to download the product "as is" (literal or as a template to be completed
-        # either after the search result is obtained from the provider or during the eodag
-        # download phase)
-        "downloadLink": "$.properties.downloadLink",
-    },
-)

eodag/api/search_result.py

@@ -140,7 +140,7 @@ class SearchResult(UserList[EOProduct]):
         Use cruncher :class:`~eodag.plugins.crunch.filter_property.FilterProperty`,
         filter for online products.
         """
-        return self.filter_property(storageStatus="ONLINE")
+        return self.filter_property(**{"order:status": "succeeded"})
 
     @staticmethod
     def from_geojson(feature_collection: dict[str, Any]) -> SearchResult:
@@ -260,7 +260,7 @@ def _import_stac_item_from_eodag_server(
         assets = {
             k: v["alternate"]["origin"]
             for k, v in feature.get("assets", {}).items()
-            if k not in ("thumbnail", "downloadLink")
+            if k not in ("thumbnail", "downloadLink", "eodag:download_link")
             and "origin" in v.get("alternate", {})
         }
         if assets:
@@ -274,6 +274,12 @@ def _import_stac_item_from_eodag_server(
                 .get("alternate", {})
                 .get("origin", {})
                 .get("href")
+            ) or (
+                feature.get("assets", {})
+                .get("eodag:download_link", {})
+                .get("alternate", {})
+                .get("origin", {})
+                .get("href")
             )
             if download_link:
                 updated_item["assets"] = {}
@@ -328,12 +334,12 @@ def _import_stac_item_from_known_provider(
                 configured_pts = [
                     k
                     for k, v in search_plugin.config.products.items()
-                    if v.get("productType") == feature.get("collection")
+                    if v.get("_collection") == feature.get("collection")
                 ]
                 if len(configured_pts) > 0:
-                    eo_product.product_type = configured_pts[0]
+                    eo_product.collection = configured_pts[0]
                 else:
-                    eo_product.product_type = feature.get("collection")
+                    eo_product.collection = feature.get("collection")
 
                 eo_product._register_downloader_from_manager(plugins_manager)
                 imported_products.append(eo_product)
@@ -359,7 +365,7 @@ def _import_stac_item_from_unknown_provider(
     except MisconfiguredError:
         pass
     if eo_product is not None:
-        eo_product.product_type = feature.get("collection")
+        eo_product.collection = feature.get("collection")
         eo_product._register_downloader_from_manager(plugins_manager)
         return SearchResult([eo_product])
     else:
@@ -373,7 +379,7 @@ class RawSearchResult(UserList[dict[str, Any]]):
     """
 
     query_params: dict[str, Any]
-    product_type_def_params: dict[str, Any]
+    collection_def_params: dict[str, Any]
 
     def __init__(self, results: list[Any]) -> None:
         super(RawSearchResult, self).__init__(results)