eodag 3.0.0b3__py3-none-any.whl → 3.1.0__py3-none-any.whl

eodag/rest/core.py

@@ -50,13 +50,10 @@ from eodag.rest.constants import (
     CACHE_KEY_COLLECTIONS,
     CACHE_KEY_QUERYABLES,
 )
+from eodag.rest.errors import ResponseSearchError
 from eodag.rest.stac import StacCatalog, StacCollection, StacCommon, StacItem
 from eodag.rest.types.eodag_search import EODAGSearch
-from eodag.rest.types.queryables import (
-    QueryablesGetParams,
-    StacQueryableProperty,
-    StacQueryables,
-)
+from eodag.rest.types.queryables import QueryablesGetParams, StacQueryables
 from eodag.rest.types.stac_search import SearchPostRequest
 from eodag.rest.utils import (
     Cruncher,
@@ -80,7 +77,7 @@ from eodag.utils.exceptions import (
 )
 
 if TYPE_CHECKING:
-    from typing import Any, Dict, List, Optional, Tuple, Union
+    from typing import Any, Optional, Union
 
     from fastapi import Request
     from requests.auth import AuthBase
@@ -119,12 +116,12 @@ def get_home_page_content(base_url: str, ipp: Optional[int] = None) -> str:
     reason="Function internally used by get_home_page_content, also deprecated",
     version="2.6.1",
 )
-def format_product_types(product_types: List[Dict[str, Any]]) -> str:
+def format_product_types(product_types: list[dict[str, Any]]) -> str:
     """Format product_types
 
     :param product_types: A list of EODAG product types as returned by the core api
     """
-    result: List[str] = []
+    result: list[str] = []
     for pt in product_types:
         result.append(f'* *__{pt["ID"]}__*: {pt["abstract"]}')
     return "\n".join(sorted(result))
@@ -133,17 +130,15 @@ def format_product_types(product_types: List[Dict[str, Any]]) -> str:
 def search_stac_items(
     request: Request,
     search_request: SearchPostRequest,
-    catalogs: Optional[List[str]] = None,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """
-    Search and retrieve STAC items from the given catalogs.
+    Search and retrieve STAC items based on the given search request.
 
-    This function takes a search request and optional catalogs list, performs a search using EODAG API, and returns a
+    This function takes a search request, performs a search using EODAG API, and returns a
     dictionary of STAC items.
 
     :param request: The incoming HTTP request with state information.
-    :param search_request: The search criteria for STAC items.
-    :param catalogs: (optional) A list of catalogs to search within. Defaults to None.
+    :param search_request: The search criteria for STAC items
     :returns: A dictionary containing the STAC items and related metadata.
 
     The function handles the conversion of search criteria into STAC and EODAG compatible formats, validates the input
@@ -165,60 +160,54 @@ def search_stac_items(
     if search_request.spatial_filter:
         stac_args["geometry"] = search_request.spatial_filter
     try:
-        eodag_args = EODAGSearch.model_validate(
-            stac_args, context={"isCatalog": bool(catalogs)}
-        )
+        eodag_args = EODAGSearch.model_validate(stac_args)
     except pydanticValidationError as e:
         raise ValidationError(format_pydantic_error(e)) from e
 
     catalog_url = re.sub("/items.*", "", request.state.url)
-
     catalog = StacCatalog(
-        url=(
-            catalog_url
-            if catalogs
-            else catalog_url.replace(
-                "/search", f"/collections/{eodag_args.productType}"
-            )
-        ),
+        url=catalog_url.replace("/search", f"/collections/{eodag_args.productType}"),
         stac_config=stac_config,
         root=request.state.url_root,
         provider=eodag_args.provider,
         eodag_api=eodag_api,
-        catalogs=catalogs or [eodag_args.productType],  # type: ignore
+        collection=eodag_args.productType,  # type: ignore
     )
 
     # get products by ids
     if eodag_args.ids:
-        search_results = SearchResult([])
+        results = SearchResult([])
         for item_id in eodag_args.ids:
-            sr = eodag_api.search(
-                id=item_id,
-                productType=catalogs[0] if catalogs else eodag_args.productType,
-                provider=eodag_args.provider,
+            results.extend(
+                eodag_api.search(
+                    id=item_id,
+                    productType=eodag_args.productType,
+                    provider=eodag_args.provider,
+                )
             )
-            search_results.extend(sr)
-        search_results.number_matched = len(search_results)
-        total = len(search_results)
-
-    elif time_interval_overlap(eodag_args, catalog):
-        criteria = {
-            **catalog.search_args,
-            **eodag_args.model_dump(exclude_none=True),
-        }
+        results.number_matched = len(results)
+        total = len(results)
 
-        search_results = eodag_api.search(count=True, **criteria)
-        total = search_results.number_matched or 0
-        if search_request.crunch:
-            search_results = crunch_products(
-                search_results, search_request.crunch, **criteria
-            )
     else:
-        # return empty results
-        search_results = SearchResult([], 0)
-        total = 0
+        criteria = eodag_args.model_dump(exclude_none=True)
+        # remove provider prefixes
+        # quickfix for ecmwf fake extension to not impact items creation
+        stac_extensions = list(stac_config["extensions"].keys()) + ["ecmwf"]
+        for key in list(criteria):
+            if ":" in key and key.split(":")[0] not in stac_extensions:
+                new_key = key.split(":")[1]
+                criteria[new_key] = criteria.pop(key)
+
+        results = eodag_api.search(count=True, **criteria)
+        total = results.number_matched or 0
+
+    if len(results) == 0 and results.errors:
+        raise ResponseSearchError(results.errors)
+
+    if search_request.crunch:
+        results = crunch_products(results, search_request.crunch, **criteria)
 
-    for record in search_results:
+    for record in results:
         record.product_type = eodag_api.get_alias_from_product_type(record.product_type)
 
     items = StacItem(
@@ -228,7 +217,7 @@ def search_stac_items(
         eodag_api=eodag_api,
         root=request.state.url_root,
     ).get_stac_items(
-        search_results=search_results,
+        search_results=results,
         total=total,
         next_link=get_next_link(
             request, search_request, total, eodag_args.items_per_page
@@ -243,7 +232,7 @@ def search_stac_items(
 
 def download_stac_item(
     request: Request,
-    catalogs: List[str],
+    collection_id: str,
     item_id: str,
     provider: Optional[str] = None,
     asset: Optional[str] = None,
@@ -251,13 +240,13 @@ def download_stac_item(
 ) -> Response:
     """Download item
 
-    :param catalogs: Catalogs list (only first is used as product_type)
+    :param collection_id: id of the product type
     :param item_id: Product ID
     :param provider: (optional) Chosen provider
     :param kwargs: additional download parameters
     :returns: a stream of the downloaded data (zip file)
     """
-    product_type = catalogs[0]
+    product_type = collection_id
 
     search_results = eodag_api.search(
         id=item_id, productType=product_type, provider=provider, **kwargs
@@ -320,8 +309,8 @@ def download_stac_item(
 
 def _order_and_update(
     product: EOProduct,
-    auth: Union[AuthBase, Dict[str, str], None],
-    query_args: Dict[str, Any],
+    auth: Union[AuthBase, dict[str, str], None],
+    query_args: dict[str, Any],
 ) -> None:
     """Order product if needed and update given kwargs with order-status-dict"""
     if product.properties.get("storageStatus") != ONLINE_STATUS and hasattr(
@@ -338,13 +327,11 @@ def _order_and_update(
     if (
         product.properties.get("storageStatus") != ONLINE_STATUS
         and NOT_AVAILABLE in product.properties.get("orderStatusLink", "")
-        and hasattr(product.downloader, "order_download")
+        and hasattr(product.downloader, "_order")
     ):
         # first order
         logger.debug("Order product")
-        order_status_dict = product.downloader.order_download(
-            product=product, auth=auth
-        )
+        order_status_dict = product.downloader._order(product=product, auth=auth)
         query_args.update(order_status_dict or {})
 
     if (
@@ -355,18 +342,18 @@ def _order_and_update(
         product.properties["storageStatus"] = STAGING_STATUS
 
     if product.properties.get("storageStatus") == STAGING_STATUS and hasattr(
-        product.downloader, "order_download_status"
+        product.downloader, "_order_status"
     ):
         # check order status if needed
         logger.debug("Checking product order status")
-        product.downloader.order_download_status(product=product, auth=auth)
+        product.downloader._order_status(product=product, auth=auth)
 
     if product.properties.get("storageStatus") != ONLINE_STATUS:
         raise NotAvailableError("Product is not available yet")
 
 
 @lru_cache(maxsize=1)
-def get_detailled_collections_list() -> List[Dict[str, Any]]:
+def get_detailled_collections_list() -> list[dict[str, Any]]:
     """Returns detailled collections / product_types list as a list of
     config dicts
 
@@ -383,17 +370,17 @@ async def all_collections(
     instrument: Optional[str] = None,
     constellation: Optional[str] = None,
     datetime: Optional[str] = None,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Build STAC collections
 
     :param url: Requested URL
     :param root: The API root
     :param filters: Search collections filters
     :param provider: (optional) Chosen provider
-    :returns: Collections dictionnary
+    :returns: Collections dictionary
     """
 
-    async def _fetch() -> Dict[str, Any]:
+    async def _fetch() -> dict[str, Any]:
         stac_collection = StacCollection(
             url=request.state.url,
             stac_config=stac_config,
@@ -413,7 +400,10 @@ async def all_collections(
         # # parse f-strings
         format_args = deepcopy(stac_config)
         format_args["collections"].update(
-            {"url": stac_collection.url, "root": stac_collection.root}
+            {
+                "url": stac_collection.url,
+                "root": stac_collection.root,
+            }
         )
 
         collections["links"] = [
@@ -423,14 +413,16 @@ async def all_collections(
         collections = format_dict_items(collections, **format_args)
         return collections
 
-    hashed_collections = hash(f"{provider}:{q}:{platform}:{instrument}:{constellation}")
+    hashed_collections = hash(
+        f"{provider}:{q}:{platform}:{instrument}:{constellation}:{datetime}"
+    )
     cache_key = f"{CACHE_KEY_COLLECTIONS}:{hashed_collections}"
     return await cached(_fetch, cache_key, request)
 
 
 async def get_collection(
     request: Request, collection_id: str, provider: Optional[str] = None
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Build STAC collection by id
 
     :param url: Requested URL
@@ -440,7 +432,7 @@ async def get_collection(
     :returns: Collection dictionary
     """
 
-    async def _fetch() -> Dict[str, Any]:
+    async def _fetch() -> dict[str, Any]:
         stac_collection = StacCollection(
             url=request.state.url,
             stac_config=stac_config,
@@ -462,32 +454,26 @@ async def get_collection(
 async def get_stac_catalogs(
     request: Request,
     url: str,
-    catalogs: Optional[Tuple[str, ...]] = None,
     provider: Optional[str] = None,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Build STAC catalog
 
     :param url: Requested URL
     :param root: (optional) API root
-    :param catalogs: (optional) Catalogs list
     :param provider: (optional) Chosen provider
     :returns: Catalog dictionary
     """
 
-    async def _fetch() -> Dict[str, Any]:
+    async def _fetch() -> dict[str, Any]:
         return StacCatalog(
             url=url,
             stac_config=stac_config,
             root=request.state.url_root,
             provider=provider,
             eodag_api=eodag_api,
-            catalogs=list(catalogs) if catalogs else None,
         ).data
 
-    hashed_catalogs = hash(":".join(catalogs) if catalogs else None)
-    return await cached(
-        _fetch, f"{CACHE_KEY_COLLECTION}:{provider}:{hashed_catalogs}", request
-    )
+    return await cached(_fetch, f"{CACHE_KEY_COLLECTION}:{provider}", request)
 
 
 def time_interval_overlap(eodag_args: EODAGSearch, catalog: StacCatalog) -> bool:
@@ -495,7 +481,10 @@ def time_interval_overlap(eodag_args: EODAGSearch, catalog: StacCatalog) -> bool
     # check if time filtering appears both in search arguments and catalog
     # (for catalogs built by date: i.e. `year/2020/month/05`)
     if not set(["start", "end"]) <= set(eodag_args.model_dump().keys()) or not set(
-        ["start", "end"]
+        [
+            "start",
+            "end",
+        ]
     ) <= set(catalog.search_args.keys()):
         return True
 
@@ -534,10 +523,10 @@ def time_interval_overlap(eodag_args: EODAGSearch, catalog: StacCatalog) -> bool
 
 
 @lru_cache(maxsize=1)
-def get_stac_conformance() -> Dict[str, str]:
+def get_stac_conformance() -> dict[str, str]:
     """Build STAC conformance
 
-    :returns: conformance dictionnary
+    :returns: conformance dictionary
     """
     return stac_config["conformance"]
 
@@ -551,11 +540,11 @@ def get_stac_api_version() -> str:
 
 
 @lru_cache(maxsize=1)
-def get_stac_extension_oseo(url: str) -> Dict[str, str]:
+def get_stac_extension_oseo(url: str) -> dict[str, str]:
     """Build STAC OGC / OpenSearch Extension for EO
 
     :param url: Requested URL
-    :returns: Catalog dictionnary
+    :returns: Catalog dictionary
     """
 
     def apply_method(_: str, x: str) -> str:
@@ -582,50 +571,96 @@ async def get_queryables(
     request: Request,
     params: QueryablesGetParams,
     provider: Optional[str] = None,
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Fetch the queryable properties for a collection.
 
     :param collection_id: The ID of the collection.
     :returns: A set containing the STAC standardized queryable properties for a collection.
     """
 
-    async def _fetch() -> Dict[str, Any]:
+    async def _fetch() -> dict[str, Any]:
         python_queryables = eodag_api.list_queryables(
-            provider=provider, **params.model_dump(exclude_none=True, by_alias=True)
+            provider=provider,
+            fetch_providers=False,
+            **params.model_dump(exclude_none=True, by_alias=True),
         )
-        python_queryables.pop("start")
-        python_queryables.pop("end")
-
-        # productType and id are already default in stac collection and id
-        python_queryables.pop("productType", None)
-        python_queryables.pop("id", None)
 
-        stac_queryables: Dict[str, StacQueryableProperty] = deepcopy(
-            StacQueryables.default_properties
+        python_queryables_json = python_queryables.get_model().model_json_schema(
+            by_alias=True
         )
-        for param, queryable in python_queryables.items():
-            stac_param = EODAGSearch.to_stac(param)
-            # only keep "datetime" queryable for dates
-            if stac_param in stac_queryables or stac_param in (
-                "start_datetime",
-                "end_datetime",
-            ):
-                continue
 
-            stac_queryables[
-                stac_param
-            ] = StacQueryableProperty.from_python_field_definition(
-                stac_param, queryable
-            )
+        properties: dict[str, Any] = python_queryables_json["properties"]
+        required: list[str] = python_queryables_json.get("required") or []
 
-        if params.collection:
-            stac_queryables.pop("collection")
+        # productType is either simply removed or replaced by collection later.
+        if "productType" in properties:
+            properties.pop("productType")
+        if "productType" in required:
+            required.remove("productType")
+
+        stac_properties: dict[str, Any] = {}
+
+        # get stac default properties to set prefixes
+        stac_item_properties = list(stac_config["item"]["properties"].values())
+        stac_item_properties.extend(stac_config["metadata_ignore"])
+        for param, queryable in properties.items():
+            # convert key to STAC format
+            if param in OSEO_METADATA_MAPPING.keys() and not any(
+                param in str(prop) for prop in stac_item_properties
+            ):
+                param = f"oseo:{param}"
+            stac_param = EODAGSearch.to_stac(param, stac_item_properties, provider)
+
+            queryable["title"] = stac_param.split(":")[-1]
+
+            # remove null default values
+            if not queryable.get("default"):
+                queryable.pop("default", None)
+
+            stac_properties[stac_param] = queryable
+            required = list(map(lambda x: x.replace(param, stac_param), required))
+
+        # due to certain metadata mappings we might only get end_datetime but we can
+        # assume that start_datetime is also available
+        if (
+            "end_datetime" in stac_properties
+            and "start_datetime" not in stac_properties
+        ):
+            stac_properties["start_datetime"] = deepcopy(
+                stac_properties["end_datetime"]
+            )
+            stac_properties["start_datetime"]["title"] = "start_datetime"
+        # if we can search by start_datetime we can search by datetime
+        if "start_datetime" in stac_properties:
+            stac_properties["datetime"] = StacQueryables.possible_properties[
+                "datetime"
+            ].model_dump()
+
+        # format spatial extend properties to STAC format.
+        if "geometry" in stac_properties:
+            stac_properties["bbox"] = StacQueryables.possible_properties[
+                "bbox"
+            ].model_dump()
+            stac_properties["geometry"] = StacQueryables.possible_properties[
+                "geometry"
+            ].model_dump()
+
+        if not params.collection:
+            stac_properties["collection"] = StacQueryables.default_properties[
+                "collection"
+            ].model_dump()
+
+        additional_properties = python_queryables.additional_properties
+        description = "Queryable names for the EODAG STAC API Item Search filter. "
+        description += python_queryables.additional_information
 
         return StacQueryables(
             q_id=request.state.url,
-            additional_properties=bool(not params.collection),
-            properties=stac_queryables,
-        ).model_dump(mode="json", by_alias=True)
+            additional_properties=additional_properties,
+            properties=stac_properties,
+            required=required or None,
+            description=description,
+        ).model_dump(mode="json", by_alias=True, exclude_none=True)
 
     hashed_queryables = hash(params.model_dump_json())
     return await cached(
@@ -652,7 +687,7 @@ def crunch_products(
             f'Unknown crunch name. Use one of: {", ".join(crunchers.keys())}'
         )
 
-    cruncher_config: Dict[str, Any] = {}
+    cruncher_config: dict[str, Any] = {}
     for config_param in cruncher.config_params:
         config_param_value = kwargs.get(config_param)
         if not config_param_value:
@@ -685,17 +720,22 @@ def eodag_api_init() -> None:
             ext_col = StacCollection.ext_stac_collections.get(key)
             if not ext_col:
                 continue
-            platform: Union[str, List[str]] = ext_col.get("summaries", {}).get(
+            platform: Union[str, list[str]] = ext_col.get("summaries", {}).get(
                 "platform"
             )
-            constellation: Union[str, List[str]] = ext_col.get("summaries", {}).get(
+            constellation: Union[str, list[str]] = ext_col.get("summaries", {}).get(
                 "constellation"
             )
+            processing_level: Union[str, list[str]] = ext_col.get("summaries", {}).get(
+                "processing:level"
+            )
             # Check if platform or constellation are lists and join them into a string if they are
             if isinstance(platform, list):
                 platform = ",".join(platform)
             if isinstance(constellation, list):
                 constellation = ",".join(constellation)
+            if isinstance(processing_level, list):
+                processing_level = ",".join(processing_level)
 
             update_fields = {
                 "title": ext_col.get("title"),
@@ -706,7 +746,7 @@ def eodag_api_init() -> None:
                 ),
                 "platform": constellation,
                 "platformSerialIdentifier": platform,
-                "processingLevel": ext_col.get("summaries", {}).get("processing:level"),
+                "processingLevel": processing_level,
                 "license": ext_col["license"],
                 "missionStartDate": ext_col["extent"]["temporal"]["interval"][0][0],
                 "missionEndDate": ext_col["extent"]["temporal"]["interval"][-1][1],