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

eodag/rest/types/eodag_search.py

@@ -115,13 +115,6 @@ class EODAGSearch(BaseModel):
 
     _to_eodag_map: Dict[str, str]
 
-    @model_validator(mode="after")
-    def set_raise_errors(self) -> Self:
-        """Set raise_errors to True if provider is set"""
-        if self.provider:
-            self.raise_errors = True
-        return self
-
     @model_validator(mode="after")
     def remove_timeFromAscendingNode(self) -> Self:  # pylint: disable=invalid-name
         """TimeFromAscendingNode are just used for translation and not for search"""
@@ -367,9 +360,27 @@ class EODAGSearch(BaseModel):
         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"""
+        # 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
+        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

@@ -17,7 +17,7 @@
 # limitations under the License.
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Annotated, Any, ClassVar, Dict, List, Optional, Union
 
 from pydantic import (
     BaseModel,
@@ -32,7 +32,6 @@ from pydantic import (
 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
@@ -132,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",
@@ -155,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/types/stac_search.py

@@ -19,7 +19,17 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Tuple, Union
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    Union,
+)
 
 import geojson
 from pydantic import (
@@ -43,7 +53,6 @@ from shapely.geometry import (
     shape,
 )
 from shapely.geometry.base import GEOMETRY_TYPES, BaseGeometry
-from typing_extensions import Annotated
 
 from eodag.rest.utils.rfc3339 import rfc3339_str_to_datetime, str_to_interval
 from eodag.utils.exceptions import ValidationError

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,15 +16,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """EODAG types"""
+
 from __future__ import annotations
 
-from typing import Any, Dict, List, Literal, Optional, Tuple, TypedDict, Union
+from typing import (
+    Annotated,
+    Any,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    TypedDict,
+    Union,
+    get_args,
+    get_origin,
+)
 
 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 Annotated, copy_deepcopy, get_args, get_origin
+from eodag.utils import copy_deepcopy
 from eodag.utils.exceptions import ValidationError
 
 # Types mapping from JSON Schema and OpenAPI 3.1.0 specifications to Python
@@ -58,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"
     """
@@ -71,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
     """
@@ -106,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 = {}
@@ -126,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
 
@@ -161,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"]}
@@ -178,12 +209,12 @@ 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`
 
     >>> from pydantic import Field
-    >>> from eodag.utils import Annotated
+    >>> from typing import Annotated
     >>> python_field_definition_to_json(
     ...     Annotated[
     ...         Optional[str],
@@ -240,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"]):
@@ -279,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
 
@@ -294,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)
@@ -303,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,13 +17,13 @@
 # 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):
     """Download configuration
 
-    :cvar output_prefix: where to store downloaded products, as an absolute file path
+    :cvar output_dir: where to store downloaded products, as an absolute file path
                          (Default: local temporary directory)
     :cvar output_extension: downloaded file extension
     :cvar extract: whether to extract the downloaded products, only applies to archived products
@@ -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

eodag/types/queryables.py

@@ -15,12 +15,20 @@
 # 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 Optional
+from __future__ import annotations
+
+from collections import UserDict
+from datetime import date, datetime
+from typing import Annotated, Any, Optional, Union
 
 from annotated_types import Lt
 from pydantic import BaseModel, Field
+from pydantic.fields import FieldInfo
 from pydantic.types import PositiveInt
-from typing_extensions import Annotated
+from pydantic_core import PydanticUndefined
+
+from eodag.types import annotated_dict_to_model, model_fields_to_annotated
+from eodag.utils.repr import remove_class_repr, shorter_type_repr
 
 Percentage = Annotated[PositiveInt, Lt(100)]
 
@@ -29,17 +37,11 @@ class CommonQueryables(BaseModel):
     """A class representing search common queryable properties."""
 
     productType: Annotated[str, Field()]
-    id: Annotated[Optional[str], Field(None)]
-    start: Annotated[Optional[str], Field(None, alias="startTimeFromAscendingNode")]
-    end: Annotated[Optional[str], Field(None, alias="completionTimeFromAscendingNode")]
-    geom: Annotated[Optional[str], Field(None, alias="geometry")]
 
     @classmethod
     def get_queryable_from_alias(cls, value: str) -> str:
         """Get queryable parameter from alias
 
-        >>> CommonQueryables.get_queryable_from_alias('startTimeFromAscendingNode')
-        'start'
         >>> CommonQueryables.get_queryable_from_alias('productType')
         'productType'
         """
@@ -50,75 +52,180 @@ class CommonQueryables(BaseModel):
         }
         return alias_map.get(value, value)
 
+    @classmethod
+    def get_with_default(
+        cls, field: str, default: Optional[Any]
+    ) -> Annotated[Any, FieldInfo]:
+        """Get field and set default value."""
+        annotated_fields = model_fields_to_annotated(cls.model_fields)
+        f = annotated_fields[field]
+        if default is None:
+            return f
+        f.__metadata__[0].default = default
+        return f
+
 
 class Queryables(CommonQueryables):
-    """A class representing all search queryable properties."""
+    """A class representing all search queryable properties.
 
-    uid: Annotated[Optional[str], Field(None)]
+    Parameters default value is set to ``None`` to have them not required.
+    """
+
+    start: Annotated[
+        Union[datetime, date], Field(None, alias="startTimeFromAscendingNode")
+    ]
+    end: Annotated[
+        Union[datetime, date], Field(None, alias="completionTimeFromAscendingNode")
+    ]
+    geom: Annotated[str, Field(None, alias="geometry")]
+    uid: Annotated[str, Field(None)]
     # OpenSearch Parameters for Collection Search (Table 3)
-    doi: Annotated[Optional[str], Field(None)]
-    platform: Annotated[Optional[str], Field(None)]
-    platformSerialIdentifier: Annotated[Optional[str], Field(None)]
-    instrument: Annotated[Optional[str], Field(None)]
-    sensorType: Annotated[Optional[str], Field(None)]
-    compositeType: Annotated[Optional[str], Field(None)]
-    processingLevel: Annotated[Optional[str], Field(None)]
-    orbitType: Annotated[Optional[str], Field(None)]
-    spectralRange: Annotated[Optional[str], Field(None)]
-    wavelengths: Annotated[Optional[str], Field(None)]
-    hasSecurityConstraints: Annotated[Optional[str], Field(None)]
-    dissemination: Annotated[Optional[str], Field(None)]
+    doi: Annotated[str, Field(None)]
+    platform: Annotated[str, Field(None)]
+    platformSerialIdentifier: Annotated[str, Field(None)]
+    instrument: Annotated[str, Field(None)]
+    sensorType: Annotated[str, Field(None)]
+    compositeType: Annotated[str, Field(None)]
+    processingLevel: Annotated[str, Field(None)]
+    orbitType: Annotated[str, Field(None)]
+    spectralRange: Annotated[str, Field(None)]
+    wavelengths: Annotated[str, Field(None)]
+    hasSecurityConstraints: Annotated[str, Field(None)]
+    dissemination: Annotated[str, Field(None)]
     # INSPIRE obligated OpenSearch Parameters for Collection Search (Table 4)
-    title: Annotated[Optional[str], Field(None)]
-    topicCategory: Annotated[Optional[str], Field(None)]
-    keyword: Annotated[Optional[str], Field(None)]
-    abstract: Annotated[Optional[str], Field(None)]
-    resolution: Annotated[Optional[int], Field(None)]
-    organisationName: Annotated[Optional[str], Field(None)]
-    organisationRole: Annotated[Optional[str], Field(None)]
-    publicationDate: Annotated[Optional[str], Field(None)]
-    lineage: Annotated[Optional[str], Field(None)]
-    useLimitation: Annotated[Optional[str], Field(None)]
-    accessConstraint: Annotated[Optional[str], Field(None)]
-    otherConstraint: Annotated[Optional[str], Field(None)]
-    classification: Annotated[Optional[str], Field(None)]
-    language: Annotated[Optional[str], Field(None)]
-    specification: Annotated[Optional[str], Field(None)]
+    title: Annotated[str, Field(None)]
+    topicCategory: Annotated[str, Field(None)]
+    keyword: Annotated[str, Field(None)]
+    abstract: Annotated[str, Field(None)]
+    resolution: Annotated[int, Field(None)]
+    organisationName: Annotated[str, Field(None)]
+    organisationRole: Annotated[str, Field(None)]
+    publicationDate: Annotated[str, Field(None)]
+    lineage: Annotated[str, Field(None)]
+    useLimitation: Annotated[str, Field(None)]
+    accessConstraint: Annotated[str, Field(None)]
+    otherConstraint: Annotated[str, Field(None)]
+    classification: Annotated[str, Field(None)]
+    language: Annotated[str, Field(None)]
+    specification: Annotated[str, Field(None)]
     # OpenSearch Parameters for Product Search (Table 5)
-    parentIdentifier: Annotated[Optional[str], Field(None)]
-    productionStatus: Annotated[Optional[str], Field(None)]
-    acquisitionType: Annotated[Optional[str], Field(None)]
-    orbitNumber: Annotated[Optional[int], Field(None)]
-    orbitDirection: Annotated[Optional[str], Field(None)]
-    track: Annotated[Optional[str], Field(None)]
-    frame: Annotated[Optional[str], Field(None)]
-    swathIdentifier: Annotated[Optional[str], Field(None)]
-    cloudCover: Annotated[Optional[Percentage], Field(None)]
-    snowCover: Annotated[Optional[Percentage], Field(None)]
-    lowestLocation: Annotated[Optional[str], Field(None)]
-    highestLocation: Annotated[Optional[str], Field(None)]
-    productVersion: Annotated[Optional[str], Field(None)]
-    productQualityStatus: Annotated[Optional[str], Field(None)]
-    productQualityDegradationTag: Annotated[Optional[str], Field(None)]
-    processorName: Annotated[Optional[str], Field(None)]
-    processingCenter: Annotated[Optional[str], Field(None)]
-    creationDate: Annotated[Optional[str], Field(None)]
-    modificationDate: Annotated[Optional[str], Field(None)]
-    processingDate: Annotated[Optional[str], Field(None)]
-    sensorMode: Annotated[Optional[str], Field(None)]
-    archivingCenter: Annotated[Optional[str], Field(None)]
-    processingMode: Annotated[Optional[str], Field(None)]
+    parentIdentifier: Annotated[str, Field(None)]
+    productionStatus: Annotated[str, Field(None)]
+    acquisitionType: Annotated[str, Field(None)]
+    orbitNumber: Annotated[int, Field(None)]
+    orbitDirection: Annotated[str, Field(None)]
+    track: Annotated[str, Field(None)]
+    frame: Annotated[str, Field(None)]
+    swathIdentifier: Annotated[str, Field(None)]
+    cloudCover: Annotated[Percentage, Field(None)]
+    snowCover: Annotated[Percentage, Field(None)]
+    lowestLocation: Annotated[str, Field(None)]
+    highestLocation: Annotated[str, Field(None)]
+    productVersion: Annotated[str, Field(None)]
+    productQualityStatus: Annotated[str, Field(None)]
+    productQualityDegradationTag: Annotated[str, Field(None)]
+    processorName: Annotated[str, Field(None)]
+    processingCenter: Annotated[str, Field(None)]
+    creationDate: Annotated[str, Field(None)]
+    modificationDate: Annotated[str, Field(None)]
+    processingDate: Annotated[str, Field(None)]
+    sensorMode: Annotated[str, Field(None)]
+    archivingCenter: Annotated[str, Field(None)]
+    processingMode: Annotated[str, Field(None)]
     # OpenSearch Parameters for Acquistion Parameters Search (Table 6)
-    availabilityTime: Annotated[Optional[str], Field(None)]
-    acquisitionStation: Annotated[Optional[str], Field(None)]
-    acquisitionSubType: Annotated[Optional[str], Field(None)]
-    illuminationAzimuthAngle: Annotated[Optional[str], Field(None)]
-    illuminationZenithAngle: Annotated[Optional[str], Field(None)]
-    illuminationElevationAngle: Annotated[Optional[str], Field(None)]
-    polarizationMode: Annotated[Optional[str], Field(None)]
-    polarizationChannels: Annotated[Optional[str], Field(None)]
-    antennaLookDirection: Annotated[Optional[str], Field(None)]
-    minimumIncidenceAngle: Annotated[Optional[float], Field(None)]
-    maximumIncidenceAngle: Annotated[Optional[float], Field(None)]
-    dopplerFrequency: Annotated[Optional[float], Field(None)]
-    incidenceAngleVariation: Annotated[Optional[float], Field(None)]
+    availabilityTime: Annotated[str, Field(None)]
+    acquisitionStation: Annotated[str, Field(None)]
+    acquisitionSubType: Annotated[str, Field(None)]
+    illuminationAzimuthAngle: Annotated[str, Field(None)]
+    illuminationZenithAngle: Annotated[str, Field(None)]
+    illuminationElevationAngle: Annotated[str, Field(None)]
+    polarizationMode: Annotated[str, Field(None)]
+    polarizationChannels: Annotated[str, Field(None)]
+    antennaLookDirection: Annotated[str, Field(None)]
+    minimumIncidenceAngle: Annotated[float, Field(None)]
+    maximumIncidenceAngle: Annotated[float, Field(None)]
+    dopplerFrequency: Annotated[float, Field(None)]
+    incidenceAngleVariation: Annotated[float, Field(None)]
+
+
+class QueryablesDict(UserDict):
+    """Class inheriting from UserDict which contains queryables with their annotated type;
+
+    :param additional_properties: if additional properties (properties not given in EODAG config)
+                                  are allowed
+    :param kwargs: named arguments to initialise the dict (queryable keys + annotated types)
+    """
+
+    additional_properties: bool = Field(True)
+    additional_information: str = Field("")
+
+    def __init__(
+        self, additional_properties: bool, additional_information: str = "", **kwargs
+    ):
+        self.additional_properties = additional_properties
+        self.additional_information = additional_information
+        super().__init__(kwargs)
+
+    def _repr_html_(self, embedded: bool = False) -> str:
+        add_info = (
+            f" additional_information={self.additional_information}"
+            if self.additional_information
+            else ""
+        )
+        thead = (
+            f"""<thead><tr><td style='text-align: left; color: grey;'>
+                {type(self).__name__}&ensp;({len(self)})&ensp;-&ensp;additional_properties={
+                self.additional_properties}
+            """
+            + add_info
+            + "</td></tr></thead>"
+            if not embedded
+            else ""
+        )
+        tr_style = "style='background-color: transparent;'" if embedded else ""
+        return (
+            f"<table>{thead}<tbody>"
+            + "".join(
+                [
+                    f"""<tr {tr_style}><td style='text-align: left;'>
+                        <details><summary style='color: grey;'>
+                        <span style='color: black'>'{k}'</span>:&ensp;
+                        typing.Annotated[{
+                        "<span style='color: black'>" + shorter_type_repr(v.__args__[0]) + "</span>,&ensp;"
+                    }
+                    FieldInfo({"'default': '<span style='color: black'>"
+                               + str(v.__metadata__[0].get_default()) + "</span>',&ensp;"
+                               if v.__metadata__[0].get_default()
+                               and v.__metadata__[0].get_default() != PydanticUndefined else ""}
+                            {"'required': <span style='color: black'>"
+                             + str(v.__metadata__[0].is_required()) + "</span>,"}
+                            ...
+                        )]
+                    </summary>
+                        <span style='color: grey'>typing.Annotated[</span><table style='margin: 0;'>
+                            <tr style='background-color: transparent;'>
+                                <td style='padding: 5px 0 0 10px; text-align: left; vertical-align:top;'>
+                                {remove_class_repr(str(v.__args__[0]))},</td>
+                            </tr><tr style='background-color: transparent;'>
+                                <td style='padding: 5px 0 0 10px; text-align: left; vertical-align:top;'>
+                                {v.__metadata__[0].__repr__()}</td>
+                            </tr>
+                        </table><span style='color: grey'>]</span>
+                    </details>
+                    </td></tr>
+                    """
+                    for k, v in self.items()
+                ]
+            )
+            + "</tbody></table>"
+        )
+
+    def get_model(self, model_name: str = "Queryables") -> BaseModel:
+        """
+        Converts object from :class:`eodag.api.product.QueryablesDict` to :class:`pydantic.BaseModel`
+        so that validation can be performed
+
+        :param model_name: name used for :class:`pydantic.BaseModel` creation
+        :return: pydantic BaseModel of the queryables dict
+        """
+        return annotated_dict_to_model(model_name, self.data)

eodag/types/search_args.py

@@ -17,7 +17,7 @@
 # limitations under the License.
 import re
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Tuple, Union, cast
+from typing import Annotated, Any, Dict, List, Optional, Tuple, Union, cast
 
 from annotated_types import MinLen
 from pydantic import BaseModel, ConfigDict, Field, conint, field_validator
@@ -27,7 +27,7 @@ from shapely.geometry import Polygon, shape
 from shapely.geometry.base import GEOMETRY_TYPES, BaseGeometry
 
 from eodag.types.bbox import BBox
-from eodag.utils import DEFAULT_ITEMS_PER_PAGE, DEFAULT_PAGE, Annotated
+from eodag.utils import DEFAULT_ITEMS_PER_PAGE, DEFAULT_PAGE
 from eodag.utils.exceptions import ValidationError
 
 NumType = Union[float, int]
@@ -119,7 +119,7 @@ class SearchArgs(BaseModel):
             )
             sort_by_arg[i] = (sort_param, sort_order[:3])
         # remove duplicates
-        pruned_sort_by_arg: SortByList = list(set(sort_by_arg))  # type: ignore
+        pruned_sort_by_arg: SortByList = list(dict.fromkeys(sort_by_arg))  # type: ignore
         for i, sort_by_tuple in enumerate(pruned_sort_by_arg):
             for j, sort_by_tuple_tmp in enumerate(pruned_sort_by_arg):
                 # since duplicated tuples or dictionnaries have been removed, if two sorting parameters are equal,