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

eodag/types/__init__.py

@@ -22,11 +22,9 @@ from __future__ import annotations
 from typing import (
     Annotated,
     Any,
-    Dict,
-    List,
     Literal,
     Optional,
-    Tuple,
+    Type,
     TypedDict,
     Union,
     get_args,
@@ -34,15 +32,18 @@ from typing import (
 )
 
 from annotated_types import Gt, Lt
-from pydantic import BaseModel, Field, create_model
+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 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,
@@ -53,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")
@@ -70,7 +71,7 @@ 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]:
+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
@@ -85,7 +86,7 @@ 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]:
+) -> dict[str, Any]:
     """Retrieves type information from an annotated object
 
     :param annotated_type: annotated object
@@ -108,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)
@@ -149,7 +150,7 @@ def python_type_to_json(
 
 
 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]:
@@ -186,7 +187,7 @@ def json_field_definition_to_python(
     if python_type in (list, set):
         items = json_field_definition.get("items", None)
         if isinstance(items, list):
-            python_type = Tuple[  # type: ignore
+            python_type = tuple[  # type: ignore
                 tuple(
                     json_field_definition_to_python(item, required=required)
                     for item in items
@@ -197,20 +198,28 @@ def json_field_definition_to_python(
 
     if enum:
         literal = Literal[tuple(sorted(enum))]  # type: ignore
-        python_type = List[literal] if python_type in (list, set) else literal  # 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]:
+) -> dict[str, Any]:
     """Get json field definition from python `typing.Annotated`
 
     >>> from pydantic import Field
@@ -231,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)
 
@@ -311,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
@@ -326,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[str, Annotated[Any, FieldInfo]] = 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)
@@ -335,26 +344,76 @@ 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]]
+    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 = {
-        name: (field.__args__[0], field.__metadata__[0])
-        for name, field in annotated_fields.items()
-    }
-    return create_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
-        __config__={"arbitrary_types_allowed": True},
     )
 
+    return custom_model
+
 
 class ProviderSortables(TypedDict):
     """A class representing sortable parameter(s) of a provider and the allowed
@@ -364,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,7 +17,7 @@
 # limitations under the License.
 from __future__ import annotations
 
-from typing import Dict, Optional, TypedDict, Union
+from typing import Optional, TypedDict, Union
 
 
 class DownloadConf(TypedDict, total=False):
@@ -35,6 +35,6 @@ class DownloadConf(TypedDict, total=False):
     output_dir: 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

@@ -148,7 +148,7 @@ class Queryables(CommonQueryables):
     incidenceAngleVariation: Annotated[float, Field(None)]
 
 
-class QueryablesDict(UserDict):
+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)
@@ -160,7 +160,10 @@ class QueryablesDict(UserDict):
     additional_information: str = Field("")
 
     def __init__(
-        self, additional_properties: bool, additional_information: str = "", **kwargs
+        self,
+        additional_properties: bool = True,
+        additional_information: str = "",
+        **kwargs: Any,
     ):
         self.additional_properties = additional_properties
         self.additional_information = additional_information

eodag/types/search_args.py

@@ -17,7 +17,7 @@
 # limitations under the License.
 import re
 from datetime import datetime
-from typing import Annotated, Any, Dict, List, Optional, Tuple, Union, cast
+from typing import Annotated, Any, Optional, Union, cast
 
 from annotated_types import MinLen
 from pydantic import BaseModel, ConfigDict, Field, conint, field_validator
@@ -31,10 +31,10 @@ from eodag.utils import DEFAULT_ITEMS_PER_PAGE, DEFAULT_PAGE
 from eodag.utils.exceptions import ValidationError
 
 NumType = Union[float, int]
-GeomArgs = Union[List[NumType], Tuple[NumType], Dict[str, NumType], str, BaseGeometry]
+GeomArgs = Union[list[NumType], tuple[NumType], dict[str, NumType], str, BaseGeometry]
 
 PositiveInt = conint(gt=0)
-SortByList = Annotated[List[Tuple[str, str]], MinLen(1)]
+SortByList = Annotated[list[tuple[str, str]], MinLen(1)]
 
 
 class SearchArgs(BaseModel):
@@ -48,7 +48,7 @@ class SearchArgs(BaseModel):
     start: Optional[str] = Field(None)
     end: Optional[str] = Field(None)
     geom: Optional[BaseGeometry] = Field(None)
-    locations: Optional[Dict[str, str]] = Field(None)
+    locations: Optional[dict[str, str]] = Field(None)
     page: Optional[int] = Field(DEFAULT_PAGE, gt=0)  # type: ignore
     items_per_page: Optional[PositiveInt] = Field(DEFAULT_ITEMS_PER_PAGE)  # type: ignore
     sort_by: Optional[SortByList] = Field(None)  # type: ignore

eodag/types/whoosh.py

@@ -15,8 +15,6 @@
 # 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 List
-
 from whoosh.fields import Schema
 from whoosh.index import _DEF_INDEX_NAME, FileIndex
 from whoosh.matching import NullMatcher
@@ -52,7 +50,7 @@ class EODAGQueryParser(QueryParser):
 
     def __init__(
         self,
-        filters: List[str],
+        filters: list[str],
         schema: Schema,
     ):
         """