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

eodag/types/__init__.py

@@ -16,20 +16,34 @@
 # 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,
+    Literal,
+    Optional,
+    Type,
+    TypedDict,
+    Union,
+    get_args,
+    get_origin,
+)
 
 from annotated_types import Gt, Lt
-from pydantic import Field
+from pydantic import BaseModel, ConfigDict, Field, create_model
+from pydantic.annotated_handlers import GetJsonSchemaHandler
 from pydantic.fields import FieldInfo
+from pydantic.json_schema import JsonSchemaValue
+from pydantic_core import CoreSchema
 
-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
 # See https://spec.openapis.org/oas/v3.1.0#data-types
-JSON_TYPES_MAPPING: Dict[str, type] = {
+JSON_TYPES_MAPPING: dict[str, type] = {
     "boolean": bool,
     "integer": int,
     "number": float,
@@ -40,7 +54,7 @@ JSON_TYPES_MAPPING: Dict[str, type] = {
 }
 
 
-def json_type_to_python(json_type: Union[str, List[str]]) -> type:
+def json_type_to_python(json_type: Union[str, list[str]]) -> type:
     """Get python type from json type https://spec.openapis.org/oas/v3.1.0#data-types
 
     >>> json_type_to_python("number")
@@ -57,9 +71,9 @@ def json_type_to_python(json_type: Union[str, List[str]]) -> type:
         return type(None)
 
 
-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
+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
+
     :param type_info: info from Annotated
     :return: "min" or "max"
     """
@@ -71,10 +85,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]
-) -> Dict[str, Any]:
-    """
-    retrieves type information from an annotated object
+    annotated_type: Annotated[type, Any],
+) -> dict[str, Any]:
+    """Retrieves type information from an annotated object
+
     :param annotated_type: annotated object
     :return: dict containing type and min/max if available
     """
@@ -95,7 +109,7 @@ def _get_type_info_from_annotated(
 
 def python_type_to_json(
     python_type: type,
-) -> Optional[Union[str, List[Dict[str, Any]]]]:
+) -> Optional[Union[str, list[dict[str, Any]]]]:
     """Get json type from python https://spec.openapis.org/oas/v3.1.0#data-types
 
     >>> python_type_to_json(int)
@@ -106,7 +120,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,14 +141,16 @@ 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
 
 
 def json_field_definition_to_python(
-    json_field_definition: Dict[str, Any],
+    json_field_definition: dict[str, Any],
     default_value: Optional[Any] = None,
     required: Optional[bool] = False,
 ) -> Annotated[Any, FieldInfo]:
@@ -161,29 +178,52 @@ 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"]}
 
-    if not required or default_value:
-        return Annotated[python_type, Field(default=default_value, **field_type_kwargs)]
-    else:
-        return Annotated[python_type, Field(..., **field_type_kwargs)]
+    metadata = [
+        python_type,
+        Field(
+            default_value if not required or default_value is not None else ...,
+            **field_type_kwargs,
+        ),
+    ]
+
+    if required:
+        metadata.append("json_schema_required")
+
+    return Annotated[tuple(metadata)]
 
 
 def python_field_definition_to_json(
-    python_field_definition: Annotated[Any, FieldInfo]
-) -> Dict[str, Any]:
+    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],
@@ -200,7 +240,7 @@ def python_field_definition_to_json(
             "%s must be an instance of Annotated" % python_field_definition
         )
 
-    json_field_definition: Dict[str, Any] = dict()
+    json_field_definition: dict[str, Any] = dict()
 
     python_field_args = get_args(python_field_definition)
 
@@ -240,6 +280,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,8 +320,8 @@ def python_field_definition_to_json(
 
 
 def model_fields_to_annotated(
-    model_fields: Dict[str, FieldInfo]
-) -> Dict[str, Annotated[Any, FieldInfo]]:
+    model_fields: dict[str, FieldInfo],
+) -> dict[str, Annotated[Any, FieldInfo]]:
     """Convert BaseModel.model_fields from FieldInfo to Annotated
 
     >>> from pydantic import create_model
@@ -294,7 +335,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 +344,77 @@ def model_fields_to_annotated(
     return annotated_model_fields
 
 
+class BaseModelCustomJsonSchema(BaseModel):
+    """Base class for generated models with custom json schema."""
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+        cls: Type[BaseModel], core_schema: CoreSchema, handler: GetJsonSchemaHandler
+    ) -> JsonSchemaValue:
+        """
+        Custom get json schema method to handle required fields with default values.
+        This is not supported by Pydantic by default.
+        It requires the field to be marked with the key "json_schema_required" in the metadata dict.
+        Example: Annotated[str, "json_schema_required"]
+        """
+        json_schema = handler.resolve_ref_schema(handler(core_schema))
+
+        json_schema["required"] = [
+            key
+            for key, field_info in cls.model_fields.items()
+            if "json_schema_required" in field_info.metadata
+        ]
+
+        return json_schema
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+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.
+
+    >>> from pydantic import Field
+    >>> annotated_fields = {
+    ...     "field1": Annotated[str, Field(description="A string field"), "json_schema_required"],
+    ...     "field2": Annotated[int, Field(default=42, description="An integer field")],
+    ... }
+    >>> model = annotated_dict_to_model("TestModel", annotated_fields)
+    >>> json_schema = model.model_json_schema()
+    >>> json_schema["required"]
+    ['field1']
+    >>> json_schema["properties"]["field1"]
+    {'description': 'A string field', 'title': 'Field1', 'type': 'string'}
+    >>> json_schema["properties"]["field2"]
+    {'default': 42, 'description': 'An integer field', 'title': 'Field2', 'type': 'integer'}
+    >>> json_schema["title"]
+    'TestModel'
+    >>> json_schema["type"]
+    'object'
+
+    :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 = {}
+    for name, field in annotated_fields.items():
+        base_type, field_info, *metadata = get_args(field)
+        fields[name] = (
+            Annotated[tuple([base_type] + metadata)] if metadata else base_type,
+            field_info,
+        )
+
+    custom_model = create_model(
+        model_name,
+        __base__=BaseModelCustomJsonSchema,
+        **fields,  # type: ignore
+    )
+
+    return custom_model
+
+
 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
@@ -311,5 +423,14 @@ class ProviderSortables(TypedDict):
     :param max_sort_params: (optional) The allowed maximum number of sortable(s) in a search request with the provider
     """
 
-    sortables: List[str]
+    sortables: list[str]
     max_sort_params: Annotated[Optional[int], Gt(0)]
+
+
+class S3SessionKwargs(TypedDict, total=False):
+    """A class representing available keyword arguments to pass to :class:`boto3.session.Session` for authentication"""
+
+    aws_access_key_id: Optional[str]
+    aws_secret_access_key: Optional[str]
+    aws_session_token: Optional[str]
+    profile_name: Optional[str]

eodag/types/bbox.py

@@ -15,14 +15,14 @@
 # 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 Dict, List, Tuple, Union
+from typing import Union
 
 from pydantic import BaseModel, ValidationInfo, field_validator
 from shapely.geometry.polygon import Polygon
 
 NumType = Union[float, int]
 BBoxArgs = Union[
-    List[NumType], Tuple[NumType, NumType, NumType, NumType], Dict[str, NumType]
+    list[NumType], tuple[NumType, NumType, NumType, NumType], dict[str, NumType]
 ]
 
 

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 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,8 +33,8 @@ class DownloadConf(TypedDict, total=False):
     """
 
     output_dir: str
-    output_extension: str
+    output_extension: Union[str, None]
     extract: bool
-    dl_url_params: Dict[str, str]
+    dl_url_params: dict[str, str]
     delete_archive: bool
     asset: Optional[str]

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,183 @@ 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[str, Any]):
+    """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 = True,
+        additional_information: str = "",
+        **kwargs: Any,
+    ):
+        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)