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

eodag/rest/types/stac_search.py

@@ -19,17 +19,7 @@
 
 from __future__ import annotations
 
-from typing import (
-    TYPE_CHECKING,
-    Annotated,
-    Any,
-    Dict,
-    List,
-    Literal,
-    Optional,
-    Tuple,
-    Union,
-)
+from typing import TYPE_CHECKING, Annotated, Any, Literal, Optional, Union
 
 import geojson
 from pydantic import (
@@ -63,8 +53,8 @@ if TYPE_CHECKING:
 NumType = Union[float, int]
 
 BBox = Union[
-    Tuple[NumType, NumType, NumType, NumType],
-    Tuple[NumType, NumType, NumType, NumType, NumType, NumType],
+    tuple[NumType, NumType, NumType, NumType],
+    tuple[NumType, NumType, NumType, NumType, NumType, NumType],
 ]
 
 Geometry = Union[
@@ -106,8 +96,8 @@ class SearchPostRequest(BaseModel):
     model_config = ConfigDict(populate_by_name=True, arbitrary_types_allowed=True)
 
     provider: Optional[str] = None
-    collections: Optional[List[str]] = None
-    ids: Optional[List[str]] = None
+    collections: Optional[list[str]] = None
+    ids: Optional[list[str]] = None
     bbox: Optional[BBox] = None
     intersects: Optional[Geometry] = None
     datetime: Optional[str] = None
@@ -117,21 +107,21 @@ class SearchPostRequest(BaseModel):
     page: Optional[PositiveInt] = Field(  # type: ignore
         default=None, description="Page number, must be a positive integer."
     )
-    query: Optional[Dict[str, Any]] = None
-    filter: Optional[Dict[str, Any]] = None
+    query: Optional[dict[str, Any]] = None
+    filter: Optional[dict[str, Any]] = None
     filter_lang: Optional[str] = Field(
         default=None,
         alias="filter-lang",
         description="The language used for filtering.",
         validate_default=True,
     )
-    sortby: Optional[List[SortBy]] = None
+    sortby: Optional[list[SortBy]] = None
     crunch: Optional[str] = None
 
     @field_serializer("intersects")
     def serialize_intersects(
         self, intersects: Optional[Geometry]
-    ) -> Optional[Dict[str, Any]]:
+    ) -> Optional[dict[str, Any]]:
         """Serialize intersects from shapely to a proper dict"""
         if intersects:
             return geojson.loads(geojson.dumps(intersects))  # type: ignore
@@ -150,7 +140,7 @@ class SearchPostRequest(BaseModel):
 
     @model_validator(mode="before")
     @classmethod
-    def only_one_spatial(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    def only_one_spatial(cls, values: dict[str, Any]) -> dict[str, Any]:
         """Check bbox and intersects are not both supplied."""
         if "intersects" in values and "bbox" in values:
             raise ValueError("intersects and bbox parameters are mutually exclusive")
@@ -170,7 +160,7 @@ class SearchPostRequest(BaseModel):
 
     @field_validator("ids", "collections", mode="before")
     @classmethod
-    def str_to_str_list(cls, v: Union[str, List[str]]) -> List[str]:
+    def str_to_str_list(cls, v: Union[str, list[str]]) -> list[str]:
         """Convert ids and collections strings to list of strings"""
         if isinstance(v, str):
             return [i.strip() for i in v.split(",")]
@@ -178,7 +168,7 @@ class SearchPostRequest(BaseModel):
 
     @field_validator("intersects", mode="before")
     @classmethod
-    def validate_intersects(cls, v: Union[Dict[str, Any], Geometry]) -> Geometry:
+    def validate_intersects(cls, v: Union[dict[str, Any], Geometry]) -> Geometry:
         """Verify format of intersects"""
         if isinstance(v, BaseGeometry):
             return v
@@ -224,7 +214,7 @@ class SearchPostRequest(BaseModel):
             # Single date is interpreted as end date
             values = ["..", v]
 
-        dates: List[str] = []
+        dates: list[str] = []
         for value in values:
             if value == ".." or value == "":
                 dates.append("..")
@@ -267,13 +257,13 @@ class SearchPostRequest(BaseModel):
 
 def sortby2list(
     v: Optional[str],
-) -> Optional[List[SortBy]]:
+) -> Optional[list[SortBy]]:
     """
     Convert sortby filter parameter GET syntax to POST syntax
     """
     if not v:
         return None
-    sortby: List[SortBy] = []
+    sortby: list[SortBy] = []
     for sortby_param in v.split(","):
         sortby_param = sortby_param.strip()
         direction: Direction = "desc" if sortby_param.startswith("-") else "asc"

eodag/rest/utils/__init__.py

@@ -23,17 +23,7 @@ import logging
 import os
 from io import BufferedReader
 from shutil import make_archive, rmtree
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    Iterator,
-    List,
-    NamedTuple,
-    Optional,
-    Union,
-)
+from typing import TYPE_CHECKING, Any, Callable, Iterator, NamedTuple, Optional, Union
 from urllib.parse import unquote_plus, urlencode
 
 import orjson
@@ -55,12 +45,15 @@ __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"""
 
     clazz: Callable[..., Any]
-    config_params: List[str]
+    config_params: list[str]
 
 
 crunchers = {
@@ -87,19 +80,19 @@ def format_pydantic_error(e: pydanticValidationError) -> str:
 
 def is_dict_str_any(var: Any) -> bool:
     """Verify whether the variable is of type dict[str, Any]"""
-    if isinstance(var, Dict):
+    if isinstance(var, dict):
         return all(isinstance(k, str) for k in var.keys())  # type: ignore
     return False
 
 
-def str2list(v: Optional[str]) -> Optional[List[str]]:
+def str2list(v: Optional[str]) -> Optional[list[str]]:
     """Convert string to list base on , delimiter."""
     if v:
         return v.split(",")
     return None
 
 
-def str2json(k: str, v: Optional[str] = None) -> Optional[Dict[str, Any]]:
+def str2json(k: str, v: Optional[str] = None) -> Optional[dict[str, Any]]:
     """decoding a URL parameter and then parsing it as JSON."""
     if not v:
         return None
@@ -109,25 +102,25 @@ def str2json(k: str, v: Optional[str] = None) -> Optional[Dict[str, Any]]:
         raise ValidationError(f"{k}: Incorrect JSON object") from e
 
 
-def flatten_list(nested_list: Union[Any, List[Any]]) -> List[Any]:
+def flatten_list(nested_list: Union[Any, list[Any]]) -> list[Any]:
     """Flatten a nested list structure into a single list."""
     if not isinstance(nested_list, list):
         return [nested_list]
     else:
-        flattened: List[Any] = []
+        flattened: list[Any] = []
         for element in nested_list:
             flattened.extend(flatten_list(element))
         return flattened
 
 
-def list_to_str_list(input_list: List[Any]) -> List[str]:
+def list_to_str_list(input_list: list[Any]) -> list[str]:
     """Attempt to convert a list of any type to a list of strings."""
     try:
         # Try to convert each element to a string
         return [str(element) for element in input_list]
     except Exception as e:
         # Raise an exception if any element cannot be converted
-        raise TypeError(f"Failed to convert to List[str]: {e}") from e
+        raise TypeError(f"Failed to convert to list[str]: {e}") from e
 
 
 def get_next_link(
@@ -135,7 +128,7 @@ def get_next_link(
     search_request: SearchPostRequest,
     total_results: Optional[int],
     items_per_page: int,
-) -> Optional[Dict[str, Any]]:
+) -> Optional[dict[str, Any]]:
     """Generate next link URL and body"""
     body = search_request.model_dump(exclude_none=True)
     if "bbox" in body:
@@ -156,7 +149,7 @@ def get_next_link(
         params["page"] = str(page + 1)
         url += f"?{urlencode(params)}"
 
-    next: Dict[str, Any] = {
+    next: dict[str, Any] = {
         "rel": "next",
         "href": url,
         "title": "Next page",

eodag/rest/utils/cql_evaluate.py

@@ -16,13 +16,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from datetime import datetime as dt
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Optional, Union
 
 from pygeofilter import ast
 from pygeofilter.backends.evaluator import Evaluator, handle
 from pygeofilter.values import Geometry, Interval
 
-simpleNode = Union[ast.Attribute, str, int, complex, float, List[Any], Tuple[Any, ...]]
+simpleNode = Union[ast.Attribute, str, int, complex, float, list[Any], tuple[Any, ...]]
 
 
 class EodagEvaluator(Evaluator):
@@ -36,7 +36,7 @@ class EodagEvaluator(Evaluator):
         return node
 
     @handle(Geometry)
-    def spatial(self, node: Geometry) -> Dict[str, Any]:
+    def spatial(self, node: Geometry) -> dict[str, Any]:
         """handle geometry"""
         return node.geometry
 
@@ -46,7 +46,7 @@ class EodagEvaluator(Evaluator):
         return node.strftime("%Y-%m-%dT%H:%M:%SZ")
 
     @handle(Interval)
-    def interval(self, _, *interval: Any) -> List[Any]:
+    def interval(self, _, *interval: Any) -> list[Any]:
         """handle datetime interval"""
         return list(interval)
 
@@ -60,7 +60,7 @@ class EodagEvaluator(Evaluator):
     )
     def predicate(
         self, node: ast.Predicate, lhs: Any, rhs: Any
-    ) -> Optional[Dict[str, Any]]:
+    ) -> Optional[dict[str, Any]]:
         """
         Handle predicates
         Verify the property is first attribute in each predicate
@@ -114,6 +114,6 @@ class EodagEvaluator(Evaluator):
         return {lhs.name: list(rhs)}
 
     @handle(ast.And)
-    def combination(self, _, lhs: Dict[str, str], rhs: Dict[str, str]):
+    def combination(self, _, lhs: dict[str, str], rhs: dict[str, str]):
         """handle combinations"""
         return {**lhs, **rhs}

eodag/rest/utils/rfc3339.py

@@ -16,14 +16,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import datetime
-from typing import Optional, Tuple
+from typing import Optional
 
 from eodag.utils.rest import rfc3339_str_to_datetime
 
 
 def str_to_interval(
     interval: Optional[str],
-) -> Tuple[Optional[datetime.datetime], Optional[datetime.datetime]]:
+) -> tuple[Optional[datetime.datetime], Optional[datetime.datetime]]:
     """Extract a tuple of datetimes from an interval string.
 
     Interval strings are defined by

eodag/types/__init__.py

@@ -16,16 +16,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """EODAG types"""
+
 from __future__ import annotations
 
 from typing import (
     Annotated,
     Any,
-    Dict,
-    List,
     Literal,
     Optional,
-    Tuple,
+    Type,
     TypedDict,
     Union,
     get_args,
@@ -33,15 +32,18 @@ from typing import (
 )
 
 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 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,
@@ -52,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")
@@ -69,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"
     """
@@ -83,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
     """
@@ -107,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)
@@ -118,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 = {}
@@ -138,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]:
@@ -173,25 +178,48 @@ 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
@@ -212,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)
 
@@ -252,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"]):
@@ -291,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
@@ -306,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)
@@ -315,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
@@ -323,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
+from typing import Optional, TypedDict, Union
 
 
 class DownloadConf(TypedDict, total=False):
@@ -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]