eodag 3.1.0b1__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
@@ -63,7 +53,7 @@ class Cruncher(NamedTuple):
     """Type hinted Cruncher namedTuple"""
 
     clazz: Callable[..., Any]
-    config_params: List[str]
+    config_params: list[str]
 
 
 crunchers = {
@@ -90,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
@@ -112,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(
@@ -138,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:
@@ -159,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

@@ -22,11 +22,8 @@ from __future__ import annotations
 from typing import (
     Annotated,
     Any,
-    Dict,
-    List,
     Literal,
     Optional,
-    Tuple,
     TypedDict,
     Union,
     get_args,
@@ -42,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,
@@ -53,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")
@@ -70,7 +67,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 +82,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 +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)
@@ -149,7 +146,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 +183,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,7 +194,7 @@ 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"]}
@@ -210,7 +207,7 @@ def json_field_definition_to_python(
 
 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 +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)
 
@@ -311,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
@@ -326,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[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)
@@ -336,7 +333,7 @@ def model_fields_to_annotated(
 
 
 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.
 
@@ -364,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, 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,
     ):
         """