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

eodag/rest/types/eodag_search.py

@@ -49,10 +49,7 @@ from eodag.rest.utils.cql_evaluate import EodagEvaluator
 from eodag.utils import DEFAULT_ITEMS_PER_PAGE
 
 if TYPE_CHECKING:
-    try:
-        from typing import Self
-    except ImportError:
-        from _typeshed import Self
+    from typing_extensions import Self
 
 Geometry = Union[
     Dict[str, Any],
@@ -113,18 +110,11 @@ 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")
-    sortBy: 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
-
     @model_validator(mode="after")
     def remove_timeFromAscendingNode(self) -> Self:  # pylint: disable=invalid-name
         """TimeFromAscendingNode are just used for translation and not for search"""
@@ -314,14 +304,14 @@ class EODAGSearch(BaseModel):
             return ",".join(v)
         return v
 
-    @field_validator("sortBy", mode="before")
+    @field_validator("sort_by", mode="before")
     @classmethod
     def parse_sortby(
         cls,
         sortby_post_params: List[Dict[str, str]],
     ) -> List[Tuple[str, str]]:
         """
-        Convert STAC POST sortby to EODAG sortby
+        Convert STAC POST sortby to EODAG sort_by
         """
         special_fields = {
             "start": "startTimeFromAscendingNode",
@@ -370,9 +360,21 @@ 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"""
         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, Dict, List, Optional, Union
 
 from pydantic import (
     BaseModel,
@@ -32,7 +32,6 @@ from pydantic import (
 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
@@ -51,14 +50,16 @@ class QueryablesGetParams(BaseModel):
         dumped: Dict[str, Any] = handler(self)
         return {EODAGSearch.to_eodag(k): v for k, v in dumped.items()}
 
-    @computed_field
+    # 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
 
-    @computed_field
+    # 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"""
@@ -70,11 +71,8 @@ class StacQueryableProperty(BaseModel):
     """A class representing a queryable property.
 
     :param description: The description of the queryables property
-    :type description: str
     :param ref: (optional) A reference link to the schema of the property.
-    :type ref: str
     :param type: (optional) possible types of the property
-    :type type: list[str]
     """
 
     description: str
@@ -114,19 +112,12 @@ class StacQueryables(BaseModel):
     """A class representing queryable properties for the STAC API.
 
     :param json_schema: The URL of the JSON schema.
-    :type json_schema: str
     :param q_id: (optional) The identifier of the queryables.
-    :type q_id: str
     :param q_type: The type of the object.
-    :type q_type: str
     :param title: The title of the queryables.
-    :type title: str
     :param description: The description of the queryables
-    :type description: str
     :param properties: A dictionary of queryable properties.
-    :type properties: dict
     :param additional_properties: Whether additional properties are allowed.
-    :type additional_properties: bool
     """
 
     json_schema: str = Field(

eodag/rest/types/stac_search.py

@@ -16,9 +16,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Model describing a STAC search POST request"""
+
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Tuple, Union
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    Union,
+)
 
 import geojson
 from pydantic import (
@@ -42,16 +53,12 @@ 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
 
 if TYPE_CHECKING:
-    try:
-        from typing import Self
-    except ImportError:
-        from _typeshed import Self
+    from typing_extensions import Self
 
 NumType = Union[float, int]
 
@@ -74,15 +81,13 @@ Geometry = Union[
 Direction = Annotated[Literal["asc", "desc"], StringConstraints(min_length=1)]
 
 
-class Sortby(BaseModel):
+class SortBy(BaseModel):
     """
     A class representing a parameter with which we want to sort results and its sorting order in a
     POST search
 
     :param field: The name of the parameter with which we want to sort results
-    :type field: str
     :param direction: The sorting order of the parameter
-    :type direction: str
     """
 
     __pydantic_config__ = ConfigDict(extra="forbid")
@@ -120,7 +125,7 @@ class SearchPostRequest(BaseModel):
         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")
@@ -262,16 +267,16 @@ 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"
         field = sortby_param.lstrip("+-")
-        sortby.append(Sortby(field=field, direction=direction))
+        sortby.append(SortBy(field=field, direction=direction))
     return sortby

eodag/rest/utils/rfc3339.py

@@ -33,7 +33,6 @@ def str_to_interval(
 
     :param interval: The interval string to convert to a :class:`datetime.datetime`
         tuple.
-    :type interval: str
 
     :raises: :class:`ValueError`
     """

eodag/types/__init__.py

@@ -18,13 +18,25 @@
 """EODAG types"""
 from __future__ import annotations
 
-from typing import Any, Dict, List, Literal, Optional, Tuple, TypedDict, Union
+from typing import (
+    Annotated,
+    Any,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    TypedDict,
+    Union,
+    get_args,
+    get_origin,
+)
 
 from annotated_types import Gt, Lt
 from pydantic import Field
 from pydantic.fields import FieldInfo
 
-from eodag.utils import Annotated, copy_deepcopy, get_args, get_origin
+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
@@ -183,7 +195,7 @@ def python_field_definition_to_json(
     """Get json field definition from python `typing.Annotated`
 
     >>> from pydantic import Field
-    >>> from eodag.utils import Annotated
+    >>> from typing import Annotated
     >>> python_field_definition_to_json(
     ...     Annotated[
     ...         Optional[str],
@@ -200,7 +212,7 @@ def python_field_definition_to_json(
             "%s must be an instance of Annotated" % python_field_definition
         )
 
-    json_field_definition = dict()
+    json_field_definition: Dict[str, Any] = dict()
 
     python_field_args = get_args(python_field_definition)
 
@@ -210,6 +222,10 @@ def python_field_definition_to_json(
         type_data = python_type_to_json(type(enum_args[0]))
         if isinstance(type_data, str):
             json_field_definition["type"] = type_data
+        elif type_data is None:
+            json_field_definition["type"] = json_field_definition[
+                "min"
+            ] = json_field_definition["max"] = None
         else:
             json_field_definition["type"] = [row["type"] for row in type_data]
             json_field_definition["min"] = [
@@ -224,6 +240,10 @@ def python_field_definition_to_json(
         field_type = python_type_to_json(python_field_args[0])
         if isinstance(field_type, str):
             json_field_definition["type"] = field_type
+        elif field_type is None:
+            json_field_definition["type"] = json_field_definition[
+                "min"
+            ] = json_field_definition["max"] = None
         else:
             json_field_definition["type"] = [row["type"] for row in field_type]
             json_field_definition["min"] = [
@@ -300,9 +320,7 @@ class ProviderSortables(TypedDict):
     maximum number of used sortable(s) in a search request with the provider
 
     :param sortables: The list of sortable parameter(s) of a provider
-    :type sortables: list[str]
     :param max_sort_params: (optional) The allowed maximum number of sortable(s) in a search request with the provider
-    :type max_sort_params: int
     """
 
     sortables: List[str]

eodag/types/download_args.py

@@ -17,15 +17,24 @@
 # limitations under the License.
 from __future__ import annotations
 
-from typing import Dict, TypedDict
+from typing import Dict, Optional, TypedDict
 
 
 class DownloadConf(TypedDict, total=False):
-    """Download configuration"""
+    """Download configuration
 
-    outputs_prefix: str
-    outputs_extension: str
+    :cvar output_dir: where to store downloaded products, as an absolute file path
+                         (Default: local temporary directory)
+    :cvar output_extension: downloaded file extension
+    :cvar extract: whether to extract the downloaded products, only applies to archived products
+    :cvar dl_url_params: additional parameters to pass over to the download url as an url parameter
+    :cvar delete_archive: whether to delete the downloaded archives
+    :cvar asset: regex filter to identify assets to download
+    """
+
+    output_dir: str
+    output_extension: str
     extract: bool
     dl_url_params: Dict[str, str]
     delete_archive: bool
-    asset: str
+    asset: Optional[str]

eodag/types/queryables.py

@@ -15,12 +15,11 @@
 # 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 Optional
+from typing import Annotated, Optional
 
 from annotated_types import Lt
 from pydantic import BaseModel, Field
 from pydantic.types import PositiveInt
-from typing_extensions import Annotated
 
 Percentage = Annotated[PositiveInt, Lt(100)]
 

eodag/types/search_args.py

@@ -17,7 +17,7 @@
 # limitations under the License.
 import re
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Tuple, Union, cast
+from typing import Annotated, Any, Dict, List, Optional, Tuple, Union, cast
 
 from annotated_types import MinLen
 from pydantic import BaseModel, ConfigDict, Field, conint, field_validator
@@ -27,7 +27,7 @@ from shapely.geometry import Polygon, shape
 from shapely.geometry.base import GEOMETRY_TYPES, BaseGeometry
 
 from eodag.types.bbox import BBox
-from eodag.utils import DEFAULT_ITEMS_PER_PAGE, DEFAULT_PAGE, Annotated
+from eodag.utils import DEFAULT_ITEMS_PER_PAGE, DEFAULT_PAGE
 from eodag.utils.exceptions import ValidationError
 
 NumType = Union[float, int]
@@ -51,7 +51,7 @@ class SearchArgs(BaseModel):
     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
-    sortBy: Optional[SortByList] = Field(None)  # type: ignore
+    sort_by: Optional[SortByList] = Field(None)  # type: ignore
 
     @field_validator("start", "end", mode="before")
     @classmethod
@@ -87,18 +87,17 @@ class SearchArgs(BaseModel):
 
         raise TypeError(f"Invalid geometry type: {type(v)}")
 
-    @field_validator("sortBy", mode="before")
+    @field_validator("sort_by", mode="before")
     @classmethod
     def check_sort_by_arg(
-        cls, sort_by_arg: Optional[SortByList]  # type: ignore
+        cls,
+        sort_by_arg: Optional[SortByList],  # type: ignore
     ) -> Optional[SortByList]:  # type: ignore
-        """Check if the sortBy argument is correct
+        """Check if the sort_by argument is correct
 
-        :param sort_by_arg: The sortBy argument
-        :type sort_by_arg: str
-        :returns: The sortBy argument with sorting order parsed (whitespace(s) are
+        :param sort_by_arg: The sort_by argument
+        :returns: The sort_by argument with sorting order parsed (whitespace(s) are
                   removed and only the 3 first letters in uppercase are kept)
-        :rtype: str
         """
         if sort_by_arg is None:
             return None
@@ -120,7 +119,7 @@ class SearchArgs(BaseModel):
             )
             sort_by_arg[i] = (sort_param, sort_order[:3])
         # remove duplicates
-        pruned_sort_by_arg: SortByList = list(set(sort_by_arg))  # type: ignore
+        pruned_sort_by_arg: SortByList = list(dict.fromkeys(sort_by_arg))  # type: ignore
         for i, sort_by_tuple in enumerate(pruned_sort_by_arg):
             for j, sort_by_tuple_tmp in enumerate(pruned_sort_by_arg):
                 # since duplicated tuples or dictionnaries have been removed, if two sorting parameters are equal,

eodag/types/whoosh.py

@@ -56,9 +56,7 @@ class EODAGQueryParser(QueryParser):
         EODAG QueryParser initialization
 
         :param filters: list of fieldnames to filter on
-        :type filters: List[str]
         :param schema: Whoosh Schema
-        :type schma: :class:whoosh.fields.Schema
         """
         super().__init__(
             None,