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

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,14 @@
 # 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,
     TypedDict,
     Union,
     get_args,
@@ -33,7 +31,7 @@ from typing import (
 )
 
 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 copy_deepcopy
@@ -41,7 +39,7 @@ 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 +50,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 +67,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 +81,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 +105,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 +116,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 +137,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,12 +174,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"]}
@@ -190,8 +206,8 @@ def json_field_definition_to_python(
 
 
 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 +228,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 +268,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 +308,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 +323,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 +332,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
@@ -323,5 +361,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]