eodag 2.12.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

eodag/rest/types/collections_search.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+# Copyright 2023, 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.
+from typing import Any, Dict, Optional
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    SerializerFunctionWrapHandler,
+    model_serializer,
+)
+
+from eodag.rest.types.eodag_search import EODAGSearch
+
+
+class CollectionsSearchRequest(BaseModel):
+    """Search args for GET collections"""
+
+    model_config = ConfigDict(frozen=True)
+
+    q: Optional[str] = Field(default=None, serialization_alias="free_text")
+    platform: Optional[str] = Field(default=None)
+    instrument: Optional[str] = Field(default=None)
+    constellation: Optional[str] = Field(default=None)
+
+    @model_serializer(mode="wrap")
+    def _serialize(self, handler: SerializerFunctionWrapHandler) -> Dict[str, Any]:
+        dumped: Dict[str, Any] = handler(self)
+        return {EODAGSearch.to_eodag(k): v for k, v in dumped.items()}

eodag/rest/types/eodag_search.py

@@ -15,16 +15,24 @@
 # 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.
-from typing import Any, Dict, List, Optional, Tuple, Union
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union, cast
 
 from pydantic import (
+    AliasChoices,
+    AliasPath,
     BaseModel,
     ConfigDict,
     Field,
+    ValidationError,
     ValidationInfo,
     field_validator,
     model_validator,
 )
+from pydantic.alias_generators import to_camel, to_snake
+from pydantic_core import InitErrorDetails, PydanticCustomError
+from pygeofilter.parsers.cql2_json import parse as parse_json
 from shapely.geometry import (
     GeometryCollection,
     LinearRing,
@@ -36,8 +44,13 @@ from shapely.geometry import (
     Polygon,
 )
 
+from eodag.rest.utils import flatten_list, is_dict_str_any, list_to_str_list
+from eodag.rest.utils.cql_evaluate import EodagEvaluator
 from eodag.utils import DEFAULT_ITEMS_PER_PAGE
 
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
 Geometry = Union[
     Dict[str, Any],
     Point,
@@ -61,17 +74,25 @@ class EODAGSearch(BaseModel):
     productType: Optional[str] = Field(None, alias="collections", validate_default=True)
     provider: Optional[str] = Field(None)
     ids: Optional[List[str]] = Field(None)
-    id: Optional[List[str]] = Field(None, alias="ids")
+    id: Optional[List[str]] = Field(
+        None, alias="ids"
+    )  # TODO: remove when updating queryables
     geom: Optional[Geometry] = Field(None, alias="geometry")
     start: Optional[str] = Field(None, alias="start_datetime")
     end: Optional[str] = Field(None, alias="end_datetime")
+    startTimeFromAscendingNode: Optional[str] = Field(
+        None,
+        alias="start_datetime",
+        validation_alias=AliasChoices("start_datetime", "datetime"),
+    )
+    completionTimeFromAscendingNode: Optional[str] = Field(None, alias="end_datetime")
     publicationDate: Optional[str] = Field(None, alias="published")
     creationDate: Optional[str] = Field(None, alias="created")
     modificationDate: Optional[str] = Field(None, alias="updated")
     platformSerialIdentifier: Optional[str] = Field(None, alias="platform")
     instrument: Optional[str] = Field(None, alias="instruments")
     platform: Optional[str] = Field(None, alias="constellation")
-    resolution: Optional[int] = Field(None, alias="gsd")
+    resolution: Optional[Union[int, str]] = Field(None, alias="gsd")
     cloudCover: Optional[int] = Field(None, alias="eo:cloud_cover")
     snowCover: Optional[int] = Field(None, alias="eo:snow_cover")
     processingLevel: Optional[str] = Field(None, alias="processing:level")
@@ -83,40 +104,198 @@ class EODAGSearch(BaseModel):
     polarizationChannels: Optional[List[str]] = Field(None, alias="sar:polarizations")
     dopplerFrequency: Optional[str] = Field(None, alias="sar:frequency_band")
     doi: Optional[str] = Field(None, alias="sci:doi")
-    productVersion: Optional[str] = Field(None, alias="version")
     illuminationElevationAngle: Optional[float] = Field(
         None, alias="view:sun_elevation"
     )
     illuminationAzimuthAngle: Optional[float] = Field(None, alias="view:sun_azimuth")
     page: Optional[int] = Field(1)
     items_per_page: int = Field(DEFAULT_ITEMS_PER_PAGE, alias="limit")
-    sortBy: Optional[List[Tuple[str, str]]] = Field(None, alias="sortby")
+    sort_by: Optional[List[Tuple[str, str]]] = Field(None, alias="sortby")
+    raise_errors: bool = False
 
-    @model_validator(mode="before")
-    @classmethod
-    def remove_custom_extensions(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    _to_eodag_map: Dict[str, str]
+
+    @model_validator(mode="after")
+    def remove_timeFromAscendingNode(self) -> Self:  # pylint: disable=invalid-name
+        """TimeFromAscendingNode are just used for translation and not for search"""
+        self.startTimeFromAscendingNode = None  # pylint: disable=invalid-name
+        self.completionTimeFromAscendingNode = None  # pylint: disable=invalid-name
+        return self
+
+    @model_validator(mode="after")
+    def parse_extra_fields(self) -> Self:
         """process unknown and oseo EODAG custom extensions fields"""
         # Transform EODAG custom extensions OSEO and UNK.
+        if not self.__pydantic_extra__:
+            return self
+
         keys_to_update: Dict[str, str] = {}
-        for key in values.keys():
+        for key in self.__pydantic_extra__.keys():
             if key.startswith("unk:"):
                 keys_to_update[key] = key[len("unk:") :]
             elif key.startswith("oseo:"):
                 keys_to_update[key] = key[len("oseo:") :]
 
         for old_key, new_key in keys_to_update.items():
-            values[cls.snake_to_camel(new_key)] = values.pop(old_key)
+            self.__pydantic_extra__[
+                to_camel(to_snake(new_key))
+            ] = self.__pydantic_extra__.pop(old_key)
 
-        return values
+        return self
 
     @model_validator(mode="before")
     @classmethod
     def remove_keys(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         """Remove 'datetime', 'crunch', 'intersects', and 'bbox' keys"""
-        for key in ["datetime", "crunch", "intersects", "bbox"]:
+        for key in ["datetime", "crunch", "intersects", "bbox", "filter_lang"]:
             values.pop(key, None)
         return values
 
+    @model_validator(mode="before")
+    @classmethod
+    def parse_collections(
+        cls, values: Dict[str, Any], info: ValidationInfo
+    ) -> Dict[str, Any]:
+        """convert collections to productType"""
+
+        if collections := values.pop("collections", None):
+            if len(collections) > 1:
+                raise ValueError("Only one collection is supported per search")
+            values["productType"] = collections[0]
+        else:
+            if not getattr(info, "context", None) or not info.context.get(  # type: ignore
+                "isCatalog"
+            ):
+                raise ValueError("A collection is required")
+
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_query(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Convert a STAC query parameter filter with the "eq" operator to a dict.
+        """
+
+        def add_error(error_message: str, input: Any) -> None:
+            errors.append(
+                InitErrorDetails(
+                    type=PydanticCustomError("invalid_query", error_message),  # type: ignore
+                    loc=("query",),
+                    input=input,
+                )
+            )
+
+        query = values.pop("query", None)
+        if not query:
+            return values
+
+        query_props: Dict[str, Any] = {}
+        errors: List[InitErrorDetails] = []
+        for property_name, conditions in cast(Dict[str, Any], query).items():
+            # Remove the prefix "properties." if present
+            prop = property_name.replace("properties.", "", 1)
+
+            # Check if exactly one operator is specified per property
+            if not is_dict_str_any(conditions) or len(conditions) != 1:  # type: ignore
+                add_error(
+                    "Exactly 1 operator must be specified per property",
+                    query[property_name],
+                )
+                continue
+
+            # Retrieve the operator and its value
+            operator, value = next(iter(cast(Dict[str, Any], conditions).items()))
+
+            # Validate the operator
+            # only eq, in and lte are allowed
+            # lte is only supported with eo:cloud_cover
+            # eo:cloud_cover only accept lte operator
+            if (
+                operator not in ("eq", "lte", "in")
+                or (operator == "lte" and prop != "eo:cloud_cover")
+                or (prop == "eo:cloud_cover" and operator != "lte")
+            ):
+                add_error(
+                    f'operator "{operator}" is not supported for property "{prop}"',
+                    query[property_name],
+                )
+                continue
+            if operator == "in" and not isinstance(value, list):
+                add_error(
+                    f'operator "{operator}" requires a value of type list for property "{prop}"',
+                    query[property_name],
+                )
+                continue
+
+            query_props[prop] = value
+
+        if errors:
+            raise ValidationError.from_exception_data(
+                title=cls.__name__, line_errors=errors
+            )
+
+        return {**values, **query_props}
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_cql(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Process cql2 filter
+        """
+
+        def add_error(error_message: str) -> None:
+            errors.append(
+                InitErrorDetails(
+                    type=PydanticCustomError("invalid_filter", error_message),  # type: ignore
+                    loc=("filter",),
+                )
+            )
+
+        filter_ = values.pop("filter", None)
+        if not filter_:
+            return values
+
+        errors: List[InitErrorDetails] = []
+        try:
+            parsing_result = EodagEvaluator().evaluate(parse_json(filter_))  # type: ignore
+        except (ValueError, NotImplementedError) as e:
+            add_error(str(e))
+            raise ValidationError.from_exception_data(
+                title=cls.__name__, line_errors=errors
+            ) from e
+
+        if not is_dict_str_any(parsing_result):
+            add_error("The parsed filter is not a proper dictionary")
+            raise ValidationError.from_exception_data(
+                title=cls.__name__, line_errors=errors
+            )
+
+        cql_args: Dict[str, Any] = cast(Dict[str, Any], parsing_result)
+
+        invalid_keys = {
+            "collections": 'Use "collection" instead of "collections"',
+            "ids": 'Use "id" instead of "ids"',
+        }
+        for k, m in invalid_keys.items():
+            if k in cql_args:
+                add_error(m)
+
+        if errors:
+            raise ValidationError.from_exception_data(
+                title=cls.__name__, line_errors=errors
+            )
+
+        # convert collection to EODAG collections
+        if col := cql_args.pop("collection", None):
+            cql_args["collections"] = col if isinstance(col, list) else [col]
+
+        # convert id to EODAG ids
+        if id := cql_args.pop("id", None):
+            cql_args["ids"] = id if isinstance(id, list) else [id]
+
+        return {**values, **cql_args}
+
     @field_validator("instrument", mode="before")
     @classmethod
     def join_instruments(cls, v: Union[str, List[str]]) -> str:
@@ -125,35 +304,29 @@ class EODAGSearch(BaseModel):
             return ",".join(v)
         return v
 
-    @field_validator("sortBy", mode="before")
+    @field_validator("sort_by", mode="before")
     @classmethod
-    def convert_stac_to_eodag_sortby(
+    def parse_sortby(
         cls,
         sortby_post_params: List[Dict[str, str]],
     ) -> List[Tuple[str, str]]:
         """
-        Convert STAC POST sortby to EODAG sortby
+        Convert STAC POST sortby to EODAG sort_by
         """
-        eodag_sortby: List[Tuple[str, str]] = []
-        for sortby_post_param in sortby_post_params:
-            field = cls.snake_to_camel(cls.to_eodag(sortby_post_param["field"]))
-            eodag_sortby.append((field, sortby_post_param["direction"]))
-        return eodag_sortby
-
-    @field_validator("productType")
-    @classmethod
-    def verify_producttype_is_present(
-        cls, v: Optional[str], info: ValidationInfo
-    ) -> Optional[str]:
-        """Verify productType is present when required"""
-        if not v and (
-            not info
-            or not getattr(info, "context", None)
-            or not info.context.get("isCatalog")  # type: ignore
-        ):
-            raise ValueError("A collection is required")
-
-        return v
+        special_fields = {
+            "start": "startTimeFromAscendingNode",
+            "end": "completionTimeFromAscendingNode",
+        }
+        return [
+            (
+                special_fields.get(
+                    to_camel(to_snake(cls.to_eodag(param["field"]))),
+                    to_camel(to_snake(cls.to_eodag(param["field"]))),
+                ),
+                param["direction"],
+            )
+            for param in sortby_post_params
+        ]
 
     @field_validator("start", "end")
     @classmethod
@@ -164,26 +337,44 @@ class EODAGSearch(BaseModel):
         return v
 
     @classmethod
-    def snake_to_camel(cls, snake_str: str) -> str:
-        """Convert snake_case to camelCase"""
-        # Split the string by underscore and capitalize each component except the first one
-        components = snake_str.split("_")
-        return components[0] + "".join(x.title() for x in components[1:])
+    def _create_to_eodag_map(cls) -> None:
+        """Create mapping to convert fields from STAC to EODAG"""
+        cls._to_eodag_map = {}
+        for name, field_info in cls.model_fields.items():
+            if field_info.validation_alias:
+                if isinstance(field_info.validation_alias, (AliasChoices, AliasPath)):
+                    for a in list_to_str_list(
+                        flatten_list(field_info.validation_alias.convert_to_aliases())
+                    ):
+                        cls._to_eodag_map[a] = name
+                else:
+                    cls._to_eodag_map[field_info.validation_alias] = name
+            elif field_info.alias:
+                cls._to_eodag_map[field_info.alias] = name
 
     @classmethod
     def to_eodag(cls, value: str) -> str:
         """Convert a STAC parameter to its matching EODAG name"""
-        alias_map = {
-            field_info.alias: name
-            for name, field_info in cls.model_fields.items()
-            if field_info.alias
-        }
-        return alias_map.get(value, value)
+        if not isinstance(cls._to_eodag_map, dict) or not cls._to_eodag_map:
+            cls._create_to_eodag_map()
+        return cls._to_eodag_map.get(value, value)
 
     @classmethod
-    def to_stac(cls, field_name: str) -> str:
+    def to_stac(
+        cls,
+        field_name: str,
+        stac_item_properties: Optional[List[str]] = None,
+        provider: Optional[str] = None,
+    ) -> str:
         """Get the alias of a field in a Pydantic model"""
         field = cls.model_fields.get(field_name)
         if field is not None and field.alias is not None:
             return field.alias
+        if (
+            provider
+            and ":" not in field_name
+            and stac_item_properties
+            and field_name not in stac_item_properties
+        ):
+            return f"{provider}:{field_name}"
         return field_name

eodag/rest/types/queryables.py

@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*-
+# Copyright 2023, 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.
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    SerializationInfo,
+    SerializerFunctionWrapHandler,
+    computed_field,
+    model_serializer,
+)
+
+from eodag.rest.types.eodag_search import EODAGSearch
+from eodag.rest.utils.rfc3339 import str_to_interval
+from eodag.types import python_field_definition_to_json
+from eodag.utils import Annotated
+
+if TYPE_CHECKING:
+    from pydantic.fields import FieldInfo
+
+
+class QueryablesGetParams(BaseModel):
+    """Store GET Queryables query params"""
+
+    collection: Optional[str] = Field(default=None, serialization_alias="productType")
+    datetime: Optional[str] = Field(default=None)
+
+    model_config = ConfigDict(extra="allow", frozen=True)
+
+    @model_serializer(mode="wrap")
+    def _serialize(self, handler: SerializerFunctionWrapHandler) -> Dict[str, Any]:
+        dumped: Dict[str, Any] = handler(self)
+        return {EODAGSearch.to_eodag(k): v for k, v in dumped.items()}
+
+    # use [prop-decorator] mypy error code when mypy==1.12 is released
+    @computed_field  # type: ignore[misc]
+    @property
+    def start_datetime(self) -> Optional[str]:
+        """Extract start_datetime property from datetime"""
+        start = str_to_interval(self.datetime)[0]
+        return start.strftime("%Y-%m-%dT%H:%M:%SZ") if start else None
+
+    # use [prop-decorator] mypy error code when mypy==1.12 is released
+    @computed_field  # type: ignore[misc]
+    @property
+    def end_datetime(self) -> Optional[str]:
+        """Extract end_datetime property from datetime"""
+        end = str_to_interval(self.datetime)[1]
+        return end.strftime("%Y-%m-%dT%H:%M:%SZ") if end else None
+
+
+class StacQueryableProperty(BaseModel):
+    """A class representing a queryable property.
+
+    :param description: The description of the queryables property
+    :param ref: (optional) A reference link to the schema of the property.
+    :param type: (optional) possible types of the property
+    """
+
+    description: str
+    ref: Optional[str] = Field(default=None, serialization_alias="$ref")
+    type: Optional[Union[str, List[str]]] = None
+    enum: Optional[List[Any]] = None
+    value: Optional[Any] = None
+    min: Optional[Union[int, List[Union[int, None]]]] = None
+    max: Optional[Union[int, List[Union[int, None]]]] = None
+    oneOf: Optional[List[Any]] = None
+    items: Optional[Any] = None
+
+    @classmethod
+    def from_python_field_definition(
+        cls, id: str, python_field_definition: Annotated[Any, FieldInfo]
+    ) -> StacQueryableProperty:
+        """Build Model from python_field_definition"""
+        def_dict = python_field_definition_to_json(python_field_definition)
+
+        if not def_dict.get("description", None):
+            def_dict["description"] = def_dict.get("title", None) or id
+
+        return cls(**def_dict)
+
+    @model_serializer(mode="wrap")
+    def remove_none(
+        self,
+        handler: SerializerFunctionWrapHandler,
+        _: SerializationInfo,
+    ):
+        """Remove none value property fields during serialization"""
+        props: Dict[str, Any] = handler(self)
+        return {k: v for k, v in props.items() if v is not None}
+
+
+class StacQueryables(BaseModel):
+    """A class representing queryable properties for the STAC API.
+
+    :param json_schema: The URL of the JSON schema.
+    :param q_id: (optional) The identifier of the queryables.
+    :param q_type: The type of the object.
+    :param title: The title of the queryables.
+    :param description: The description of the queryables
+    :param properties: A dictionary of queryable properties.
+    :param additional_properties: Whether additional properties are allowed.
+    """
+
+    json_schema: str = Field(
+        default="https://json-schema.org/draft/2019-09/schema",
+        serialization_alias="$schema",
+    )
+    q_id: Optional[str] = Field(default=None, serialization_alias="$id")
+    q_type: str = Field(default="object", serialization_alias="type")
+    title: str = Field(default="Queryables for EODAG STAC API")
+    description: str = Field(
+        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",
+        ),
+        "geometry": StacQueryableProperty(
+            description="Geometry",
+            ref="https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/item.json#/geometry",
+        ),
+        "datetime": StacQueryableProperty(
+            description="Datetime - use parameters year, month, day, time instead if available",
+            ref="https://schemas.stacspec.org/v1.0.0/item-spec/json-schema/datetime.json#/properties/datetime",
+        ),
+        "bbox": StacQueryableProperty(
+            description="BBox",
+            type="array",
+            oneOf=[{"minItems": 4, "maxItems": 4}, {"minItems": 6, "maxItems": 6}],
+            items={"type": "number"},
+        ),
+    }
+    properties: Dict[str, StacQueryableProperty] = Field()
+    additional_properties: bool = Field(
+        default=True, serialization_alias="additionalProperties"
+    )
+
+    def __contains__(self, name: str) -> bool:
+        return name in self.properties