eodag 3.0.0b2__py3-none-any.whl → 3.0.1__py3-none-any.whl

eodag/rest/core.py

@@ -33,6 +33,7 @@ from requests.models import Response as RequestsResponse
 import eodag
 from eodag import EOProduct
 from eodag.api.product.metadata_mapping import (
+    DEFAULT_METADATA_MAPPING,
     NOT_AVAILABLE,
     OFFLINE_STATUS,
     ONLINE_STATUS,
@@ -50,6 +51,7 @@ 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 (
@@ -80,7 +82,7 @@ from eodag.utils.exceptions import (
 )
 
 if TYPE_CHECKING:
-    from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+    from typing import Any, Dict, List, Optional, Union
 
     from fastapi import Request
     from requests.auth import AuthBase
@@ -105,9 +107,7 @@ def get_home_page_content(base_url: str, ipp: Optional[int] = None) -> str:
     """Compute eodag service home page content
 
     :param base_url: The service root URL
-    :type base_url: str
     :param ipp: (optional) Items per page number
-    :type ipp: int
     """
     base_url = base_url.rstrip("/") + "/"
     content = f"""<h1>EODAG Server</h1><br />
@@ -125,7 +125,6 @@ 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
-    :type product_types: list
     """
     result: List[str] = []
     for pt in product_types:
@@ -136,22 +135,16 @@ 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]:
     """
-    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.
-    :type request: Request
-    :param search_request: The search criteria for STAC items.
-    :type search_request: SearchPostRequest
-    :param catalogs: (optional) A list of catalogs to search within. Defaults to None.
-    :type catalogs: Optional[List[str]]
+    :param search_request: The search criteria for STAC items
     :returns: A dictionary containing the STAC items and related metadata.
-    :rtype: Dict[str, Any]
 
     The function handles the conversion of search criteria into STAC and EODAG compatible formats, validates the input
     using pydantic, and constructs the appropriate URLs for querying the STAC API. It also manages pagination and the
@@ -172,60 +165,64 @@ 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)
+        results.number_matched = len(results)
+        total = len(results)
 
     elif time_interval_overlap(eodag_args, catalog):
         criteria = {
             **catalog.search_args,
             **eodag_args.model_dump(exclude_none=True),
         }
-
-        search_results = eodag_api.search(count=True, **criteria)
-        total = search_results.number_matched
-        if search_request.crunch:
-            search_results = crunch_products(
-                search_results, search_request.crunch, **criteria
-            )
+        # remove provider prefixes
+        stac_extensions = stac_config["extensions"]
+        keys_to_update = {}
+        for key in criteria:
+            if ":" in key and key.split(":")[0] not in stac_extensions:
+                new_key = key.split(":")[1]
+                keys_to_update[key] = new_key
+        for key, new_key in keys_to_update.items():
+            criteria[new_key] = criteria[key]
+            criteria.pop(key)
+
+        results = eodag_api.search(count=True, **criteria)
+        total = results.number_matched or 0
     else:
         # return empty results
-        search_results = SearchResult([], 0)
+        results = SearchResult([], 0)
         total = 0
 
-    for record in search_results:
+    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 results:
         record.product_type = eodag_api.get_alias_from_product_type(record.product_type)
 
     items = StacItem(
@@ -235,7 +232,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
@@ -250,7 +247,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,
@@ -258,18 +255,13 @@ def download_stac_item(
 ) -> Response:
     """Download item
 
-    :param catalogs: Catalogs list (only first is used as product_type)
-    :type catalogs: list
+    :param collection_id: id of the product type
     :param item_id: Product ID
-    :type item_id: str
     :param provider: (optional) Chosen provider
-    :type provider: str
     :param kwargs: additional download parameters
-    :type kwargs: Any
     :returns: a stream of the downloaded data (zip file)
-    :rtype: Response
     """
-    product_type = catalogs[0]
+    product_type = collection_id
 
     search_results = eodag_api.search(
         id=item_id, productType=product_type, provider=provider, **kwargs
@@ -350,11 +342,13 @@ def _order_and_update(
     if (
         product.properties.get("storageStatus") != ONLINE_STATUS
         and NOT_AVAILABLE in product.properties.get("orderStatusLink", "")
-        and hasattr(product.downloader, "orderDownload")
+        and hasattr(product.downloader, "order_download")
     ):
         # first order
         logger.debug("Order product")
-        order_status_dict = product.downloader.orderDownload(product=product, auth=auth)
+        order_status_dict = product.downloader.order_download(
+            product=product, auth=auth
+        )
         query_args.update(order_status_dict or {})
 
     if (
@@ -365,11 +359,11 @@ def _order_and_update(
         product.properties["storageStatus"] = STAGING_STATUS
 
     if product.properties.get("storageStatus") == STAGING_STATUS and hasattr(
-        product.downloader, "orderDownloadStatus"
+        product.downloader, "order_download_status"
     ):
         # check order status if needed
         logger.debug("Checking product order status")
-        product.downloader.orderDownloadStatus(product=product, auth=auth)
+        product.downloader.order_download_status(product=product, auth=auth)
 
     if product.properties.get("storageStatus") != ONLINE_STATUS:
         raise NotAvailableError("Product is not available yet")
@@ -381,7 +375,6 @@ def get_detailled_collections_list() -> List[Dict[str, Any]]:
     config dicts
 
     :returns: List of config dicts
-    :rtype: list
     """
     return eodag_api.list_product_types(fetch_providers=False)
 
@@ -398,15 +391,10 @@ async def all_collections(
     """Build STAC collections
 
     :param url: Requested URL
-    :type url: str
     :param root: The API root
-    :type root: str
     :param filters: Search collections filters
-    :type filters: CollectionsSearchRequest
     :param provider: (optional) Chosen provider
-    :type provider: str
-    :returns: Collections dictionnary
-    :rtype: dict
+    :returns: Collections dictionary
     """
 
     async def _fetch() -> Dict[str, Any]:
@@ -439,7 +427,9 @@ 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)
 
@@ -450,15 +440,10 @@ async def get_collection(
     """Build STAC collection by id
 
     :param url: Requested URL
-    :type url: str
     :param root: API root
-    :type root: str
     :param collection_id: Product_type as ID of the collection
-    :type collection_id: str
     :param provider: (optional) Chosen provider
-    :type provider: str
     :returns: Collection dictionary
-    :rtype: dict
     """
 
     async def _fetch() -> Dict[str, Any]:
@@ -483,21 +468,14 @@ 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]:
     """Build STAC catalog
 
     :param url: Requested URL
-    :type url: str
     :param root: (optional) API root
-    :type root: str
-    :param catalogs: (optional) Catalogs list
-    :type catalogs: list
     :param provider: (optional) Chosen provider
-    :type provider: str
     :returns: Catalog dictionary
-    :rtype: dict
     """
 
     async def _fetch() -> Dict[str, Any]:
@@ -507,13 +485,9 @@ async def get_stac_catalogs(
             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:
@@ -563,8 +537,7 @@ def time_interval_overlap(eodag_args: EODAGSearch, catalog: StacCatalog) -> bool
 def get_stac_conformance() -> Dict[str, str]:
     """Build STAC conformance
 
-    :returns: conformance dictionnary
-    :rtype: dict
+    :returns: conformance dictionary
     """
     return stac_config["conformance"]
 
@@ -573,7 +546,6 @@ def get_stac_api_version() -> str:
     """Get STAC API version
 
     :returns: STAC API version
-    :rtype: str
     """
     return stac_config["stac_api_version"]
 
@@ -583,14 +555,12 @@ def get_stac_extension_oseo(url: str) -> Dict[str, str]:
     """Build STAC OGC / OpenSearch Extension for EO
 
     :param url: Requested URL
-    :type url: str
-    :returns: Catalog dictionnary
-    :rtype: dict
+    :returns: Catalog dictionary
     """
 
-    apply_method: Callable[[str, str], str] = lambda _, x: str(x).replace(
-        "$.product.", "$."
-    )
+    def apply_method(_: str, x: str) -> str:
+        return str(x).replace("$.product.", "$.")
+
     item_mapping = dict_items_recursive_apply(stac_config["item"], apply_method)
 
     # all properties as string type by default
@@ -616,9 +586,7 @@ async def get_queryables(
     """Fetch the queryable properties for a collection.
 
     :param collection_id: The ID of the collection.
-    :type collection_id: str
     :returns: A set containing the STAC standardized queryable properties for a collection.
-    :rtype Dict[str, StacQueryableProperty]: set
     """
 
     async def _fetch() -> Dict[str, Any]:
@@ -635,8 +603,18 @@ async def get_queryables(
         stac_queryables: Dict[str, StacQueryableProperty] = deepcopy(
             StacQueryables.default_properties
         )
+        # get stac default properties to set prefixes
+        stac_item_properties = list(stac_config["item"]["properties"].values())
+        stac_item_properties.extend(list(stac_queryables.keys()))
+        ignore = stac_config["metadata_ignore"]
+        stac_item_properties.extend(ignore)
+        default_mapping = DEFAULT_METADATA_MAPPING.keys()
         for param, queryable in python_queryables.items():
-            stac_param = EODAGSearch.to_stac(param)
+            if param in default_mapping 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)
             # only keep "datetime" queryable for dates
             if stac_param in stac_queryables or stac_param in (
                 "start_datetime",

eodag/rest/errors.py

@@ -0,0 +1,181 @@
+# -*- 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.
+import logging
+from typing import Dict, List, Tuple, Union
+
+from fastapi import FastAPI, Request
+from fastapi.responses import ORJSONResponse
+from starlette import status
+from starlette.exceptions import HTTPException as StarletteHTTPException
+
+from eodag.rest.types.eodag_search import EODAGSearch
+from eodag.utils.exceptions import (
+    AuthenticationError,
+    DownloadError,
+    EodagError,
+    MisconfiguredError,
+    NoMatchingProductType,
+    NotAvailableError,
+    RequestError,
+    TimeOutError,
+    UnsupportedProductType,
+    UnsupportedProvider,
+    ValidationError,
+)
+
+EODAG_DEFAULT_STATUS_CODES = {
+    AuthenticationError: status.HTTP_500_INTERNAL_SERVER_ERROR,
+    DownloadError: status.HTTP_500_INTERNAL_SERVER_ERROR,
+    MisconfiguredError: status.HTTP_500_INTERNAL_SERVER_ERROR,
+    NotAvailableError: status.HTTP_404_NOT_FOUND,
+    NoMatchingProductType: status.HTTP_404_NOT_FOUND,
+    TimeOutError: status.HTTP_504_GATEWAY_TIMEOUT,
+    UnsupportedProductType: status.HTTP_404_NOT_FOUND,
+    UnsupportedProvider: status.HTTP_404_NOT_FOUND,
+    ValidationError: status.HTTP_400_BAD_REQUEST,
+}
+
+logger = logging.getLogger("eodag.rest.server")
+
+
+class ResponseSearchError(Exception):
+    """Represent a EODAG search error response"""
+
+    def __init__(self, errors: List[Tuple[str, Exception]]) -> None:
+        self._errors = errors
+
+    @property
+    def errors(self) -> List[Dict[str, Union[str, int]]]:
+        """return errors as a list of dict"""
+        error_list: List[Dict[str, Union[str, int]]] = []
+        for name, exception in self._errors:
+
+            error_dict: Dict[str, Union[str, int]] = {
+                "provider": name,
+                "error": exception.__class__.__name__,
+            }
+
+            if exception.args:
+                error_dict["message"] = exception.args[0]
+
+            if len(exception.args) > 1:
+                error_dict["detail"] = " ".join([str(i) for i in exception.args[1:]])
+
+            error_dict["status_code"] = EODAG_DEFAULT_STATUS_CODES.get(
+                type(exception), getattr(exception, "status_code", 500)
+            )
+
+            if type(exception) in (MisconfiguredError, AuthenticationError):
+                logger.error("%s: %s", type(exception).__name__, str(exception))
+                error_dict[
+                    "message"
+                ] = "Internal server error: please contact the administrator"
+                error_dict.pop("detail", None)
+
+            if type(exception) is ValidationError:
+                for error_param in exception.parameters:
+                    stac_param = EODAGSearch.to_stac(error_param)
+                    exception.message = exception.message.replace(
+                        error_param, stac_param
+                    )
+                error_dict["message"] = exception.message
+
+            error_list.append(error_dict)
+
+        return error_list
+
+    @property
+    def status_code(self) -> int:
+        """get global errors status code"""
+        if len(self._errors) == 1 and type(self.errors[0]["status_code"]) is int:
+            return self.errors[0]["status_code"]
+
+        return 400
+
+
+async def response_search_error_handler(
+    request: Request, exc: Exception
+) -> ORJSONResponse:
+    """Handle ResponseSearchError exceptions"""
+    if not isinstance(exc, ResponseSearchError):
+        return starlette_exception_handler(request, exc)
+
+    return ORJSONResponse(
+        status_code=exc.status_code,
+        content={"errors": exc.errors},
+    )
+
+
+async def eodag_errors_handler(request: Request, exc: Exception) -> ORJSONResponse:
+    """Handler for EODAG errors"""
+    if not isinstance(exc, EodagError):
+        return starlette_exception_handler(request, exc)
+
+    exception_status_code = getattr(exc, "status_code", None)
+    default_status_code = exception_status_code or 500
+    code = EODAG_DEFAULT_STATUS_CODES.get(type(exc), default_status_code)
+
+    detail = f"{type(exc).__name__}: {str(exc)}"
+
+    if type(exc) in (MisconfiguredError, AuthenticationError, TimeOutError):
+        logger.error("%s: %s", type(exc).__name__, str(exc))
+
+    if type(exc) in (MisconfiguredError, AuthenticationError):
+        detail = "Internal server error: please contact the administrator"
+
+    if type(exc) is ValidationError:
+        for error_param in exc.parameters:
+            stac_param = EODAGSearch.to_stac(error_param)
+            exc.message = exc.message.replace(error_param, stac_param)
+        detail = exc.message
+
+    return ORJSONResponse(
+        status_code=code,
+        content={"description": detail},
+    )
+
+
+def starlette_exception_handler(request: Request, error: Exception) -> ORJSONResponse:
+    """Default errors handle"""
+    description = (
+        getattr(error, "description", None)
+        or getattr(error, "detail", None)
+        or str(error)
+    )
+    return ORJSONResponse(
+        status_code=getattr(error, "status_code", 500),
+        content={"description": description},
+    )
+
+
+def add_exception_handlers(app: FastAPI) -> None:
+    """Add exception handlers to the FastAPI application.
+
+    Args:
+        app: the FastAPI application.
+
+    Returns:
+        None
+    """
+    app.add_exception_handler(StarletteHTTPException, starlette_exception_handler)
+
+    app.add_exception_handler(RequestError, eodag_errors_handler)
+    for exc in EODAG_DEFAULT_STATUS_CODES:
+        app.add_exception_handler(exc, eodag_errors_handler)
+
+    app.add_exception_handler(ResponseSearchError, response_search_error_handler)