eodag 3.5.1__py3-none-any.whl → 3.7.0__py3-none-any.whl

eodag/plugins/search/base.py

@@ -25,6 +25,7 @@ from pydantic.fields import Field, FieldInfo
 
 from eodag.api.product.metadata_mapping import (
     DEFAULT_METADATA_MAPPING,
+    NOT_AVAILABLE,
     NOT_MAPPED,
     mtd_cfg_as_conversion_and_querypath,
 )
@@ -38,6 +39,7 @@ from eodag.utils import (
     copy_deepcopy,
     deepcopy,
     format_dict_items,
+    string_to_jsonpath,
     update_nested_dict,
 )
 from eodag.utils.exceptions import ValidationError
@@ -158,10 +160,6 @@ class Search(PluginTopic):
         :returns: The product type definition parameters
         """
         if product_type in self.config.products.keys():
-            logger.debug(
-                "Getting provider product type definition parameters for %s",
-                product_type,
-            )
             return self.config.products[product_type]
         elif GENERIC_PRODUCT_TYPE in self.config.products.keys():
             logger.debug(
@@ -439,3 +437,35 @@ class Search(PluginTopic):
             ):
                 queryables[k] = v
         return queryables
+
+    def get_assets_from_mapping(self, provider_item: dict[str, Any]) -> dict[str, Any]:
+        """
+        Create assets based on the assets_mapping in the provider's config
+        and an item returned by the provider
+
+        :param provider_item: dict of item properties returned by the provider
+        :returns: dict containing the asset metadata
+        """
+        assets_mapping = getattr(self.config, "assets_mapping", None)
+        if not assets_mapping:
+            return {}
+        assets = {}
+        for key, values in assets_mapping.items():
+            asset_href = values.get("href")
+            if not asset_href:
+                logger.warning(
+                    "asset mapping %s skipped because no href is available", key
+                )
+                continue
+            json_url_path = string_to_jsonpath(asset_href)
+            if isinstance(json_url_path, str):
+                url_path = json_url_path
+            else:
+                url_match = json_url_path.find(provider_item)
+                if len(url_match) == 1:
+                    url_path = url_match[0].value
+                else:
+                    url_path = NOT_AVAILABLE
+            assets[key] = deepcopy(values)
+            assets[key]["href"] = url_path
+        return assets

eodag/plugins/search/build_search_result.py

@@ -94,6 +94,7 @@ ECMWF_KEYWORDS = {
     "fcperiod",
     "fieldset",
     "filter",
+    "feature",
     "format",
     "frame",
     "frequency",
@@ -317,17 +318,17 @@ def append_time(input_date: date, time: Optional[str]) -> datetime:
 
 
 def parse_date(
-    date_str: str, time: Optional[Union[str, list[str]]]
+    date: str, time: Optional[Union[str, list[str]]]
 ) -> tuple[datetime, datetime]:
     """Parses a date string in formats YYYY-MM-DD, YYYMMDD, solo or in start/end or start/to/end intervals."""
-    if "to" in date_str:
-        start_date_str, end_date_str = date_str.split("/to/")
-    elif "/" in date_str:
-        dates = date_str.split("/")
+    if "to" in date:
+        start_date_str, end_date_str = date.split("/to/")
+    elif "/" in date:
+        dates = date.split("/")
         start_date_str = dates[0]
         end_date_str = dates[-1]
     else:
-        start_date_str = end_date_str = date_str
+        start_date_str = end_date_str = date
 
     # Update YYYYMMDD formatted dates
     if re.match(r"^\d{8}$", start_date_str):
@@ -401,6 +402,8 @@ def ecmwf_temporal_to_eodag(
     start = end = None
 
     if date := params.get("date"):
+        if isinstance(date, list):
+            date = "/".join(date)
         start, end = parse_date(date, params.get("time"))
 
     elif year := (params.get("year") or params.get("hyear")):
@@ -546,7 +549,9 @@ class ECMWFSearch(PostJsonSearch):
         :param params: Search parameters to be preprocessed.
         :param product_type: (optional) product type id
         """
+
         _dc_qs = params.get("_dc_qs")
+
         if _dc_qs is not None:
             # if available, update search params using datacube query-string
             _dc_qp = geojson.loads(unquote_plus(unquote_plus(_dc_qs)))

eodag/plugins/search/cop_marine.py

@@ -284,6 +284,8 @@ class CopMarineSearch(StaticStacSearch):
                 "type": "application/x-netcdf",
             }
         }
+        additional_assets = self.get_assets_from_mapping(dataset_item)
+        assets.update(additional_assets)
         product = EOProduct(self.provider, properties, productType=product_type)
         # use product_type_config as default properties
         product_type_config = getattr(self.config, "product_type_config", {})

eodag/plugins/search/qssearch.py

@@ -35,9 +35,11 @@ from typing import (
 from urllib.error import URLError
 from urllib.parse import (
     parse_qsl,
+    quote,
     quote_plus,
     unquote,
     unquote_plus,
+    urlencode,
     urlparse,
     urlunparse,
 )
@@ -86,10 +88,8 @@ from eodag.utils import (
     dict_items_recursive_apply,
     format_dict_items,
     get_ssl_context,
-    quote,
     string_to_jsonpath,
     update_nested_dict,
-    urlencode,
 )
 from eodag.utils.exceptions import (
     AuthenticationError,
@@ -386,36 +386,48 @@ class QueryStringSearch(Search):
 
         # parse jsonpath on init: product type specific metadata-mapping
         for product_type in self.config.products.keys():
-            if "metadata_mapping" in self.config.products[product_type].keys():
-                self.config.products[product_type][
-                    "metadata_mapping"
-                ] = mtd_cfg_as_conversion_and_querypath(
-                    self.config.products[product_type]["metadata_mapping"]
-                )
+
+            product_type_metadata_mapping = {}
+            # product-type specific metadata-mapping
+            if any(
+                mm in self.config.products[product_type].keys()
+                for mm in ("metadata_mapping", "metadata_mapping_from_product")
+            ):
                 # Complete and ready to use product type specific metadata-mapping
                 product_type_metadata_mapping = deepcopy(self.config.metadata_mapping)
 
-                # update config using provider product type definition metadata_mapping
-                # from another product
-                other_product_for_mapping = cast(
-                    str,
-                    self.config.products[product_type].get(
-                        "metadata_mapping_from_product", ""
-                    ),
+            # metadata_mapping from another product
+            if other_product_for_mapping := self.config.products[product_type].get(
+                "metadata_mapping_from_product"
+            ):
+                other_product_type_def_params = self.get_product_type_def_params(
+                    other_product_for_mapping,
                 )
-                if other_product_for_mapping:
-                    other_product_type_def_params = self.get_product_type_def_params(
-                        other_product_for_mapping,
-                    )
+                # parse mapping to apply
+                if other_product_type_mtd_mapping := other_product_type_def_params.get(
+                    "metadata_mapping", {}
+                ):
                     other_product_type_mtd_mapping = (
                         mtd_cfg_as_conversion_and_querypath(
                             other_product_type_def_params.get("metadata_mapping", {})
                         )
                     )
-                    # updated mapping at the end
-                    for metadata, mapping in other_product_type_mtd_mapping.items():
-                        product_type_metadata_mapping.pop(metadata, None)
-                        product_type_metadata_mapping[metadata] = mapping
+                else:
+                    msg = f"Cannot reuse empty metadata_mapping from {other_product_for_mapping} for {product_type}"
+                    raise MisconfiguredError(msg)
+                # update mapping
+                for metadata, mapping in other_product_type_mtd_mapping.items():
+                    product_type_metadata_mapping.pop(metadata, None)
+                    product_type_metadata_mapping[metadata] = mapping
+
+            # metadata_mapping from current product
+            if "metadata_mapping" in self.config.products[product_type].keys():
+                # parse mapping to apply
+                self.config.products[product_type][
+                    "metadata_mapping"
+                ] = mtd_cfg_as_conversion_and_querypath(
+                    self.config.products[product_type]["metadata_mapping"]
+                )
 
                 # from current product, updated mapping at the end
                 for metadata, mapping in self.config.products[product_type][
@@ -424,6 +436,7 @@ class QueryStringSearch(Search):
                     product_type_metadata_mapping.pop(metadata, None)
                     product_type_metadata_mapping[metadata] = mapping
 
+            if product_type_metadata_mapping:
                 self.config.products[product_type][
                     "metadata_mapping"
                 ] = product_type_metadata_mapping
@@ -1090,6 +1103,8 @@ class QueryStringSearch(Search):
             product.properties = dict(
                 getattr(self.config, "product_type_config", {}), **product.properties
             )
+            additional_assets = self.get_assets_from_mapping(result)
+            product.assets.update(additional_assets)
             # move assets from properties to product's attr, normalize keys & roles
             for key, asset in product.properties.pop("assets", {}).items():
                 norm_key, asset["roles"] = product.driver.guess_asset_key_and_roles(
@@ -1173,7 +1188,10 @@ class QueryStringSearch(Search):
 
         collection = getattr(self.config, "collection", None)
         if collection is None:
-            collection = prep.product_type_def_params.get("collection") or product_type
+            collection = (
+                getattr(prep, "product_type_def_params", {}).get("collection")
+                or product_type
+            )
 
         if collection is None:
             return ()
@@ -1478,13 +1496,17 @@ class PostJsonSearch(QueryStringSearch):
             )
 
             # Add to the query, the queryable parameters set in the provider product type definition
+            product_type_metadata_mapping = {
+                **getattr(self.config, "metadata_mapping", {}),
+                **prep.product_type_def_params.get("metadata_mapping", {}),
+            }
             keywords.update(
                 {
                     k: v
                     for k, v in prep.product_type_def_params.items()
                     if k not in keywords.keys()
-                    and k in self.config.metadata_mapping.keys()
-                    and isinstance(self.config.metadata_mapping[k], list)
+                    and k in product_type_metadata_mapping.keys()
+                    and isinstance(product_type_metadata_mapping[k], list)
                 }
             )