eodag 3.0.1__py3-none-any.whl → 3.1.0b1__py3-none-any.whl

eodag/rest/core.py

@@ -33,7 +33,6 @@ 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,
@@ -54,11 +53,7 @@ from eodag.rest.constants import (
 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,
@@ -193,28 +188,18 @@ def search_stac_items(
         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),
-        }
+    else:
+        criteria = eodag_args.model_dump(exclude_none=True)
         # remove provider prefixes
-        stac_extensions = stac_config["extensions"]
-        keys_to_update = {}
-        for key in criteria:
+        # 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]
-                keys_to_update[key] = new_key
-        for key, new_key in keys_to_update.items():
-            criteria[new_key] = criteria[key]
-            criteria.pop(key)
+                criteria[new_key] = criteria.pop(key)
 
         results = eodag_api.search(count=True, **criteria)
         total = results.number_matched or 0
-    else:
-        # return empty results
-        results = SearchResult([], 0)
-        total = 0
 
     if len(results) == 0 and results.errors:
         raise ResponseSearchError(results.errors)
@@ -342,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 (
@@ -359,11 +342,11 @@ 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")
@@ -417,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"] = [
@@ -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
 
@@ -591,51 +580,87 @@ async def get_queryables(
 
     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
         )
+
+        properties: Dict[str, Any] = python_queryables_json["properties"]
+        required: List[str] = python_queryables_json.get("required") or []
+
+        # 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(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():
-            if param in default_mapping and not any(
+        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)
-            # 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
-            )
+            queryable["title"] = stac_param.split(":")[-1]
+
+            # remove null default values
+            if not queryable.get("default"):
+                queryable.pop("default", None)
 
-        if params.collection:
-            stac_queryables.pop("collection")
+            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(
@@ -701,11 +726,16 @@ def eodag_api_init() -> None:
             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"),
@@ -716,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],

eodag/rest/server.py

@@ -61,7 +61,12 @@ from eodag.rest.core import (
 from eodag.rest.errors import add_exception_handlers
 from eodag.rest.types.queryables import QueryablesGetParams
 from eodag.rest.types.stac_search import SearchPostRequest, sortby2list
-from eodag.rest.utils import format_pydantic_error, str2json, str2list
+from eodag.rest.utils import (
+    LIVENESS_PROBE_PATH,
+    format_pydantic_error,
+    str2json,
+    str2list,
+)
 from eodag.utils import parse_header, update_nested_dict
 
 if TYPE_CHECKING:
@@ -120,6 +125,17 @@ app = FastAPI(lifespan=lifespan, title="EODAG", docs_url="/api.html")
 stac_api_config = load_stac_api_config()
 
 
+@router.api_route(
+    methods=["GET", "HEAD"],
+    path=LIVENESS_PROBE_PATH,
+    include_in_schema=False,
+    status_code=200,
+)
+async def liveness_probe(request: Request) -> Dict[str, bool]:
+    "Endpoint meant to be used as liveness probe by deployment platforms"
+    return {"success": True}
+
+
 @router.api_route(
     methods=["GET", "HEAD"], path="/api", tags=["Capabilities"], include_in_schema=False
 )
@@ -375,13 +391,24 @@ async def list_collection_queryables(
     :returns: A json object containing the list of available queryable properties for the specified collection.
     """
     logger.info(f"{request.method} {request.state.url}")
-    additional_params = dict(request.query_params)
+    # split by `,` to handle list of parameters
+    additional_params = {k: v.split(",") for k, v in dict(request.query_params).items()}
     provider = additional_params.pop("provider", None)
 
+    datetime = additional_params.pop("datetime", None)
+
     queryables = await get_queryables(
         request,
-        QueryablesGetParams(collection=collection_id, **additional_params),
-        provider=provider,
+        QueryablesGetParams.model_validate(
+            {
+                **additional_params,
+                **{
+                    "collection": collection_id,
+                    "datetime": datetime[0] if datetime else None,
+                },
+            }
+        ),
+        provider=provider[0] if provider else None,
     )
 
     return ORJSONResponse(queryables)

eodag/rest/types/eodag_search.py

@@ -367,6 +367,12 @@ class EODAGSearch(BaseModel):
         provider: Optional[str] = None,
     ) -> str:
         """Get the alias of a field in a Pydantic model"""
+        # quick fix. TODO: refactor of EODAGSearch.
+        if field_name in ("productType", "id", "start_datetime", "end_datetime"):
+            return field_name
+        # another quick fix to handle different names of geometry
+        if field_name == "geometry":
+            field_name = "geom"
         field = cls.model_fields.get(field_name)
         if field is not None and field.alias is not None:
             return field.alias

eodag/rest/types/queryables.py

@@ -131,14 +131,12 @@ class StacQueryables(BaseModel):
         default="Queryable names for the EODAG STAC API Item Search filter."
     )
     default_properties: ClassVar[Dict[str, StacQueryableProperty]] = {
-        "id": StacQueryableProperty(
-            description="ID",
-            ref="https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/item.json#/id",
-        ),
         "collection": StacQueryableProperty(
             description="Collection",
             ref="https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/item.json#/collection",
-        ),
+        )
+    }
+    possible_properties: ClassVar[Dict[str, StacQueryableProperty]] = {
         "geometry": StacQueryableProperty(
             description="Geometry",
             ref="https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/item.json#/geometry",
@@ -154,7 +152,8 @@ class StacQueryables(BaseModel):
             items={"type": "number"},
         ),
     }
-    properties: Dict[str, StacQueryableProperty] = Field()
+    properties: Dict[str, Any] = Field()
+    required: Optional[List[str]] = Field(None)
     additional_properties: bool = Field(
         default=True, serialization_alias="additionalProperties"
     )

eodag/rest/utils/__init__.py

@@ -55,6 +55,9 @@ __all__ = ["get_date", "get_datetime"]
 
 logger = logging.getLogger("eodag.rest.utils")
 
+# Path of the liveness endpoint
+LIVENESS_PROBE_PATH = "/_mgmt/ping"
+
 
 class Cruncher(NamedTuple):
     """Type hinted Cruncher namedTuple"""

eodag/types/__init__.py

@@ -16,6 +16,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """EODAG types"""
+
 from __future__ import annotations
 
 from typing import (
@@ -33,7 +34,7 @@ from typing import (
 )
 
 from annotated_types import Gt, Lt
-from pydantic import Field
+from pydantic import BaseModel, Field, create_model
 from pydantic.fields import FieldInfo
 
 from eodag.utils import copy_deepcopy
@@ -70,8 +71,8 @@ def json_type_to_python(json_type: Union[str, List[str]]) -> type:
 
 
 def _get_min_or_max(type_info: Union[Lt, Gt, Any]) -> Tuple[str, Any]:
-    """
-    checks if the value from an Annotated object is a minimum or maximum
+    """Checks if the value from an Annotated object is a minimum or maximum
+
     :param type_info: info from Annotated
     :return: "min" or "max"
     """
@@ -83,10 +84,10 @@ def _get_min_or_max(type_info: Union[Lt, Gt, Any]) -> Tuple[str, Any]:
 
 
 def _get_type_info_from_annotated(
-    annotated_type: Annotated[type, Any]
+    annotated_type: Annotated[type, Any],
 ) -> Dict[str, Any]:
-    """
-    retrieves type information from an annotated object
+    """Retrieves type information from an annotated object
+
     :param annotated_type: annotated object
     :return: dict containing type and min/max if available
     """
@@ -118,7 +119,8 @@ def python_type_to_json(
     :param python_type: the python type
     :returns: the json type
     """
-    if get_origin(python_type) is Union:
+    origin = get_origin(python_type)
+    if origin is Union:
         json_type = list()
         for single_python_type in get_args(python_type):
             type_data = {}
@@ -138,8 +140,10 @@ def python_type_to_json(
         return list(JSON_TYPES_MAPPING.keys())[
             list(JSON_TYPES_MAPPING.values()).index(python_type)
         ]
-    elif get_origin(python_type) == Annotated:
+    elif origin is Annotated:
         return [_get_type_info_from_annotated(python_type)]
+    elif origin is list:
+        raise NotImplementedError("Never completed")
     else:
         return None
 
@@ -173,12 +177,27 @@ def json_field_definition_to_python(
         title=json_field_definition.get("title", None),
         description=json_field_definition.get("description", None),
         pattern=json_field_definition.get("pattern", None),
+        le=json_field_definition.get("maximum"),
+        ge=json_field_definition.get("minimum"),
     )
 
-    if "enum" in json_field_definition and (
-        isinstance(json_field_definition["enum"], (list, set))
-    ):
-        python_type = Literal[tuple(sorted(json_field_definition["enum"]))]  # type: ignore
+    enum = json_field_definition.get("enum")
+
+    if python_type in (list, set):
+        items = json_field_definition.get("items", None)
+        if isinstance(items, list):
+            python_type = Tuple[  # type: ignore
+                tuple(
+                    json_field_definition_to_python(item, required=required)
+                    for item in items
+                )
+            ]
+        elif isinstance(items, dict):
+            enum = items.get("enum")
+
+    if enum:
+        literal = Literal[tuple(sorted(enum))]  # type: ignore
+        python_type = List[literal] if python_type in (list, set) else literal  # type: ignore
 
     if "$ref" in json_field_definition:
         field_type_kwargs["json_schema_extra"] = {"$ref": json_field_definition["$ref"]}
@@ -190,7 +209,7 @@ def json_field_definition_to_python(
 
 
 def python_field_definition_to_json(
-    python_field_definition: Annotated[Any, FieldInfo]
+    python_field_definition: Annotated[Any, FieldInfo],
 ) -> Dict[str, Any]:
     """Get json field definition from python `typing.Annotated`
 
@@ -252,6 +271,7 @@ def python_field_definition_to_json(
             json_field_definition["max"] = [
                 row["max"] if "max" in row else None for row in field_type
             ]
+
     if "min" in json_field_definition and json_field_definition["min"].count(
         None
     ) == len(json_field_definition["min"]):
@@ -291,7 +311,7 @@ def python_field_definition_to_json(
 
 
 def model_fields_to_annotated(
-    model_fields: Dict[str, FieldInfo]
+    model_fields: Dict[str, FieldInfo],
 ) -> Dict[str, Annotated[Any, FieldInfo]]:
     """Convert BaseModel.model_fields from FieldInfo to Annotated
 
@@ -306,7 +326,7 @@ def model_fields_to_annotated(
     :param model_fields: BaseModel.model_fields to convert
     :returns: Annotated tuple usable as create_model argument
     """
-    annotated_model_fields = dict()
+    annotated_model_fields: Dict[str, Annotated[Any, FieldInfo]] = dict()
     for param, field_info in model_fields.items():
         field_type = field_info.annotation or type(None)
         new_field_info = copy_deepcopy(field_info)
@@ -315,6 +335,27 @@ def model_fields_to_annotated(
     return annotated_model_fields
 
 
+def annotated_dict_to_model(
+    model_name: str, annotated_fields: Dict[str, Annotated[Any, FieldInfo]]
+) -> BaseModel:
+    """Convert a dictionary of Annotated values to a Pydantic BaseModel.
+
+    :param model_name: name of the model to be created
+    :param annotated_fields: dict containing the parameters and annotated values that should become
+                             the properties of the model
+    :returns: pydantic model
+    """
+    fields = {
+        name: (field.__args__[0], field.__metadata__[0])
+        for name, field in annotated_fields.items()
+    }
+    return create_model(
+        model_name,
+        **fields,  # type: ignore
+        __config__={"arbitrary_types_allowed": True},
+    )
+
+
 class ProviderSortables(TypedDict):
     """A class representing sortable parameter(s) of a provider and the allowed
     maximum number of used sortable(s) in a search request with the provider

eodag/types/download_args.py

@@ -17,7 +17,7 @@
 # limitations under the License.
 from __future__ import annotations
 
-from typing import Dict, Optional, TypedDict
+from typing import Dict, Optional, TypedDict, Union
 
 
 class DownloadConf(TypedDict, total=False):
@@ -33,7 +33,7 @@ class DownloadConf(TypedDict, total=False):
     """
 
     output_dir: str
-    output_extension: str
+    output_extension: Union[str, None]
     extract: bool
     dl_url_params: Dict[str, str]
     delete_archive: bool