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

eodag/rest/types/collections_search.py

@@ -15,7 +15,7 @@
 # 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 typing import Any, Optional
 
 from pydantic import (
     BaseModel,
@@ -39,6 +39,6 @@ class CollectionsSearchRequest(BaseModel):
     constellation: Optional[str] = Field(default=None)
 
     @model_serializer(mode="wrap")
-    def _serialize(self, handler: SerializerFunctionWrapHandler) -> Dict[str, Any]:
-        dumped: Dict[str, Any] = handler(self)
+    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

@@ -17,7 +17,7 @@
 # limitations under the License.
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union, cast
+from typing import TYPE_CHECKING, Any, Optional, Union, cast
 
 from pydantic import (
     AliasChoices,
@@ -52,7 +52,7 @@ if TYPE_CHECKING:
     from typing_extensions import Self
 
 Geometry = Union[
-    Dict[str, Any],
+    dict[str, Any],
     Point,
     MultiPoint,
     LineString,
@@ -73,8 +73,8 @@ 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(
+    ids: Optional[list[str]] = Field(None)
+    id: Optional[list[str]] = Field(
         None, alias="ids"
     )  # TODO: remove when updating queryables
     geom: Optional[Geometry] = Field(None, alias="geometry")
@@ -101,7 +101,7 @@ class EODAGSearch(BaseModel):
     orbitNumber: Optional[int] = Field(None, alias="sat:absolute_orbit")
     # TODO: colision in property name. Need to handle "sar:product_type"
     sensorMode: Optional[str] = Field(None, alias="sar:instrument_mode")
-    polarizationChannels: Optional[List[str]] = Field(None, alias="sar:polarizations")
+    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")
     illuminationElevationAngle: Optional[float] = Field(
@@ -110,17 +110,10 @@ class EODAGSearch(BaseModel):
     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")
-    sort_by: Optional[List[Tuple[str, str]]] = Field(None, alias="sortby")
+    sort_by: Optional[list[tuple[str, str]]] = Field(None, alias="sortby")
     raise_errors: bool = False
 
-    _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
+    _to_eodag_map: dict[str, str]
 
     @model_validator(mode="after")
     def remove_timeFromAscendingNode(self) -> Self:  # pylint: disable=invalid-name
@@ -136,7 +129,7 @@ class EODAGSearch(BaseModel):
         if not self.__pydantic_extra__:
             return self
 
-        keys_to_update: Dict[str, str] = {}
+        keys_to_update: dict[str, str] = {}
         for key in self.__pydantic_extra__.keys():
             if key.startswith("unk:"):
                 keys_to_update[key] = key[len("unk:") :]
@@ -152,7 +145,7 @@ class EODAGSearch(BaseModel):
 
     @model_validator(mode="before")
     @classmethod
-    def remove_keys(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    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", "filter_lang"]:
             values.pop(key, None)
@@ -161,8 +154,8 @@ class EODAGSearch(BaseModel):
     @model_validator(mode="before")
     @classmethod
     def parse_collections(
-        cls, values: Dict[str, Any], info: ValidationInfo
-    ) -> Dict[str, Any]:
+        cls, values: dict[str, Any], info: ValidationInfo
+    ) -> dict[str, Any]:
         """convert collections to productType"""
 
         if collections := values.pop("collections", None):
@@ -179,7 +172,7 @@ class EODAGSearch(BaseModel):
 
     @model_validator(mode="before")
     @classmethod
-    def parse_query(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    def parse_query(cls, values: dict[str, Any]) -> dict[str, Any]:
         """
         Convert a STAC query parameter filter with the "eq" operator to a dict.
         """
@@ -197,9 +190,9 @@ class EODAGSearch(BaseModel):
         if not query:
             return values
 
-        query_props: Dict[str, Any] = {}
-        errors: List[InitErrorDetails] = []
-        for property_name, conditions in cast(Dict[str, Any], query).items():
+        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)
 
@@ -212,7 +205,7 @@ class EODAGSearch(BaseModel):
                 continue
 
             # Retrieve the operator and its value
-            operator, value = next(iter(cast(Dict[str, Any], conditions).items()))
+            operator, value = next(iter(cast(dict[str, Any], conditions).items()))
 
             # Validate the operator
             # only eq, in and lte are allowed
@@ -246,7 +239,7 @@ class EODAGSearch(BaseModel):
 
     @model_validator(mode="before")
     @classmethod
-    def parse_cql(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    def parse_cql(cls, values: dict[str, Any]) -> dict[str, Any]:
         """
         Process cql2 filter
         """
@@ -263,7 +256,7 @@ class EODAGSearch(BaseModel):
         if not filter_:
             return values
 
-        errors: List[InitErrorDetails] = []
+        errors: list[InitErrorDetails] = []
         try:
             parsing_result = EodagEvaluator().evaluate(parse_json(filter_))  # type: ignore
         except (ValueError, NotImplementedError) as e:
@@ -278,7 +271,7 @@ class EODAGSearch(BaseModel):
                 title=cls.__name__, line_errors=errors
             )
 
-        cql_args: Dict[str, Any] = cast(Dict[str, Any], parsing_result)
+        cql_args: dict[str, Any] = cast(dict[str, Any], parsing_result)
 
         invalid_keys = {
             "collections": 'Use "collection" instead of "collections"',
@@ -305,7 +298,7 @@ class EODAGSearch(BaseModel):
 
     @field_validator("instrument", mode="before")
     @classmethod
-    def join_instruments(cls, v: Union[str, List[str]]) -> str:
+    def join_instruments(cls, v: Union[str, list[str]]) -> str:
         """convert instruments to instrument"""
         if isinstance(v, list):
             return ",".join(v)
@@ -315,8 +308,8 @@ class EODAGSearch(BaseModel):
     @classmethod
     def parse_sortby(
         cls,
-        sortby_post_params: List[Dict[str, str]],
-    ) -> List[Tuple[str, str]]:
+        sortby_post_params: list[dict[str, str]],
+    ) -> list[tuple[str, str]]:
         """
         Convert STAC POST sortby to EODAG sort_by
         """
@@ -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, Optional, Union
 
 from pydantic import (
     BaseModel,
@@ -25,17 +25,18 @@ from pydantic import (
     Field,
     SerializationInfo,
     SerializerFunctionWrapHandler,
-    computed_field,
+    field_validator,
     model_serializer,
+    model_validator,
 )
 
 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
+    from typing_extensions import Self
 
 
 class QueryablesGetParams(BaseModel):
@@ -43,29 +44,39 @@ class QueryablesGetParams(BaseModel):
 
     collection: Optional[str] = Field(default=None, serialization_alias="productType")
     datetime: Optional[str] = Field(default=None)
+    start_datetime: Optional[str] = Field(default=None)
+    end_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)
+    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
+    @field_validator("datetime", "start_datetime", "end_datetime", mode="before")
+    def validate_datetime(cls, value: Any) -> Optional[str]:
+        """datetime, start_datetime and end_datetime must be a string"""
+        if isinstance(value, list):
+            return value[0]
 
-    # 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
+        return value
+
+    @model_validator(mode="after")
+    def compute_datetimes(self: Self) -> Self:
+        """Start datetime must be a string"""
+        if not self.datetime:
+            return self
+
+        start, end = str_to_interval(self.datetime)
+
+        if not self.start_datetime and start:
+            self.start_datetime = start.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        if not self.end_datetime and end:
+            self.end_datetime = end.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+        return self
 
 
 class StacQueryableProperty(BaseModel):
@@ -78,12 +89,12 @@ class StacQueryableProperty(BaseModel):
 
     description: str
     ref: Optional[str] = Field(default=None, serialization_alias="$ref")
-    type: Optional[Union[str, List[str]]] = None
-    enum: Optional[List[Any]] = None
+    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
+    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
@@ -105,7 +116,7 @@ class StacQueryableProperty(BaseModel):
         _: SerializationInfo,
     ):
         """Remove none value property fields during serialization"""
-        props: Dict[str, Any] = handler(self)
+        props: dict[str, Any] = handler(self)
         return {k: v for k, v in props.items() if v is not None}
 
 
@@ -131,15 +142,13 @@ class StacQueryables(BaseModel):
     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",
-        ),
+    default_properties: ClassVar[dict[str, StacQueryableProperty]] = {
         "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 +164,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,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Annotated, Any, Literal, Optional, Union
 
 import geojson
 from pydantic import (
@@ -43,7 +43,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
@@ -54,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[
@@ -97,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
@@ -108,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
@@ -141,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")
@@ -161,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(",")]
@@ -169,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
@@ -215,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("..")
@@ -258,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