eodag 3.1.0b1__py3-none-any.whl → 3.1.0b2__py3-none-any.whl

eodag/plugins/search/build_search_result.py

@@ -23,18 +23,7 @@ import logging
 import re
 from collections import OrderedDict
 from datetime import datetime, timedelta
-from typing import (
-    TYPE_CHECKING,
-    Annotated,
-    Any,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    Union,
-    cast,
-)
+from typing import TYPE_CHECKING, Annotated, Any, Optional, Union, cast
 from urllib.parse import quote_plus, unquote_plus
 
 import geojson
@@ -61,9 +50,9 @@ from eodag.api.search_result import RawSearchResult
 from eodag.plugins.search import PreparedSearch
 from eodag.plugins.search.qssearch import PostJsonSearch, QueryStringSearch
 from eodag.types import json_field_definition_to_python
-from eodag.types.queryables import Queryables
+from eodag.types.queryables import Queryables, QueryablesDict
 from eodag.utils import (
-    HTTP_REQ_TIMEOUT,
+    DEFAULT_SEARCH_TIMEOUT,
     deepcopy,
     dict_items_recursive_sort,
     get_geometry_from_various,
@@ -205,8 +194,8 @@ COP_DS_KEYWORDS = [
 
 
 def keywords_to_mdt(
-    keywords: List[str], prefix: Optional[str] = None
-) -> Dict[str, Any]:
+    keywords: list[str], prefix: Optional[str] = None
+) -> dict[str, Any]:
     """
     Make metadata mapping dict from a list of keywords
 
@@ -223,7 +212,7 @@ def keywords_to_mdt(
     :param prefix: prefix to be added to the parameter in the mapping
     :return: metadata mapping dict
     """
-    mdt: Dict[str, Any] = {}
+    mdt: dict[str, Any] = {}
     for keyword in keywords:
         key = f"{prefix}:{keyword}" if prefix else keyword
         mdt[key] = [keyword, f'$."{key}"']
@@ -237,6 +226,8 @@ def strip_quotes(value: Any) -> Any:
     'abc'
     >>> strip_quotes(["'abc'", '"def'])
     ['abc', 'def']
+    >>> strip_quotes({"'abc'": 'def"'})
+    {'abc': 'def'}
 
     :param value: value from which quotes should be removed (should be either str or list)
     :return: value without quotes
@@ -245,13 +236,13 @@ def strip_quotes(value: Any) -> Any:
     if isinstance(value, (list, tuple)):
         return [strip_quotes(v) for v in value]
     elif isinstance(value, dict):
-        raise NotImplementedError("Dict value is not supported.")
+        return {strip_quotes(k): strip_quotes(v) for k, v in value.items()}
     else:
         return str(value).strip("'\"")
 
 
 def _update_properties_from_element(
-    prop: Dict[str, Any], element: Dict[str, Any], values: List[str]
+    prop: dict[str, Any], element: dict[str, Any], values: list[str]
 ) -> None:
     """updates a property dict with the given values based on the information from the element dict
     e.g. the type is set based on the type of the element
@@ -333,7 +324,7 @@ class ECMWFSearch(PostJsonSearch):
     :param provider: An eodag providers configuration dictionary
     :param config: Search plugin configuration:
 
-        * :attr:`~eodag.config.PluginConfig.remove_from_query` (``List[str]``): List of parameters
+        * :attr:`~eodag.config.PluginConfig.remove_from_query` (``list[str]``): List of parameters
           used to parse metadata but that must not be included to the query
         * :attr:`~eodag.config.PluginConfig.end_date_excluded` (``bool``): Set to `False` if
           provider does not include end date to search
@@ -350,9 +341,6 @@ class ECMWFSearch(PostJsonSearch):
     """
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
-        # cache fetching method
-        self.fetch_data = functools.lru_cache()(self._fetch_data)
-
         config.metadata_mapping = {
             **keywords_to_mdt(ECMWF_KEYWORDS + COP_DS_KEYWORDS, "ecmwf"),
             **config.metadata_mapping,
@@ -402,7 +390,7 @@ class ECMWFSearch(PostJsonSearch):
                     "metadata_mapping"
                 ] = product_type_metadata_mapping
 
-    def do_search(self, *args: Any, **kwargs: Any) -> List[Dict[str, Any]]:
+    def do_search(self, *args: Any, **kwargs: Any) -> list[dict[str, Any]]:
         """Should perform the actual search request.
 
         :param args: arguments to be used in the search
@@ -416,7 +404,7 @@ class ECMWFSearch(PostJsonSearch):
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> Tuple[List[EOProduct], Optional[int]]:
+    ) -> tuple[list[EOProduct], Optional[int]]:
         """Build ready-to-download SearchResult
 
         :param prep: :class:`~eodag.plugins.search.PreparedSearch` object containing information needed for the search
@@ -439,7 +427,7 @@ class ECMWFSearch(PostJsonSearch):
 
     def build_query_string(
         self, product_type: str, **kwargs: Any
-    ) -> Tuple[Dict[str, Any], str]:
+    ) -> tuple[dict[str, Any], str]:
         """Build The query string using the search parameters
 
         :param product_type: product type id
@@ -464,7 +452,7 @@ class ECMWFSearch(PostJsonSearch):
         )
 
     def _preprocess_search_params(
-        self, params: Dict[str, Any], product_type: Optional[str]
+        self, params: dict[str, Any], product_type: Optional[str]
     ) -> None:
         """Preprocess search parameters before making a request to the CDS API.
 
@@ -543,9 +531,23 @@ class ECMWFSearch(PostJsonSearch):
         if "geometry" in params:
             params["geometry"] = get_geometry_from_various(geometry=params["geometry"])
 
+    def _get_product_type_queryables(
+        self, product_type: Optional[str], alias: Optional[str], filters: dict[str, Any]
+    ) -> QueryablesDict:
+        """Override to set additional_properties to false."""
+        default_values: dict[str, Any] = deepcopy(
+            getattr(self.config, "products", {}).get(product_type, {})
+        )
+        default_values.pop("metadata_mapping", None)
+
+        filters["productType"] = product_type
+        queryables = self.discover_queryables(**{**default_values, **filters}) or {}
+
+        return QueryablesDict(additional_properties=False, **queryables)
+
     def discover_queryables(
         self, **kwargs: Any
-    ) -> Optional[Dict[str, Annotated[Any, FieldInfo]]]:
+    ) -> Optional[dict[str, Annotated[Any, FieldInfo]]]:
         """Fetch queryables list from provider using its constraints file
 
         :param kwargs: additional filters for queryables (`productType` and other search
@@ -571,13 +573,13 @@ class ECMWFSearch(PostJsonSearch):
             getattr(self.config, "discover_queryables", {}).get("constraints_url", ""),
             **kwargs,
         )
-        constraints: List[Dict[str, Any]] = self.fetch_data(constraints_url)
+        constraints: list[dict[str, Any]] = self._fetch_data(constraints_url)
 
         form_url = format_metadata(
             getattr(self.config, "discover_queryables", {}).get("form_url", ""),
             **kwargs,
         )
-        form = self.fetch_data(form_url)
+        form: list[dict[str, Any]] = self._fetch_data(form_url)
 
         formated_kwargs = self.format_as_provider_keyword(
             product_type, processed_kwargs
@@ -600,18 +602,18 @@ class ECMWFSearch(PostJsonSearch):
         # we use non empty kwargs as default to integrate user inputs
         # it is needed because pydantic json schema does not represent "value"
         # but only "default"
-        non_empty_formated: Dict[str, Any] = {
+        non_empty_formated: dict[str, Any] = {
             k: v
             for k, v in formated_kwargs.items()
             if v and (not isinstance(v, list) or all(v))
         }
-        non_empty_kwargs: Dict[str, Any] = {
+        non_empty_kwargs: dict[str, Any] = {
             k: v
             for k, v in processed_kwargs.items()
             if v and (not isinstance(v, list) or all(v))
         }
 
-        required_keywords: Set[str] = set()
+        required_keywords: set[str] = set()
 
         # calculate available values
         if constraints:
@@ -634,7 +636,7 @@ class ECMWFSearch(PostJsonSearch):
                 return self.queryables_from_metadata_mapping(product_type)
             if "{" in values_url:
                 values_url = values_url.format(productType=provider_product_type)
-            data = self.fetch_data(values_url)
+            data = self._fetch_data(values_url)
             available_values = data["constraints"]
             required_keywords = data.get("required", [])
 
@@ -651,7 +653,9 @@ class ECMWFSearch(PostJsonSearch):
                     "completionTimeFromAscendingNode",
                     "geom",
                 }
-                and keyword.replace("ecmwf:", "") not in available_values
+                and keyword not in [f["name"] for f in form]
+                and keyword.replace("ecmwf:", "")
+                not in set(list(available_values.keys()) + [f["name"] for f in form])
             ):
                 raise ValidationError(f"{keyword} is not a queryable parameter")
 
@@ -689,7 +693,7 @@ class ECMWFSearch(PostJsonSearch):
         # area is geom in EODAG.
         if queryables.pop("area", None):
             queryables["geom"] = Annotated[
-                Union[str, Dict[str, float], BaseGeometry],
+                Union[str, dict[str, float], BaseGeometry],
                 Field(
                     None,
                     description="Read EODAG documentation for all supported geometry format.",
@@ -700,10 +704,10 @@ class ECMWFSearch(PostJsonSearch):
 
     def available_values_from_constraints(
         self,
-        constraints: list[Dict[str, Any]],
-        input_keywords: Dict[str, Any],
-        form_keywords: List[str],
-    ) -> Dict[str, List[str]]:
+        constraints: list[dict[str, Any]],
+        input_keywords: dict[str, Any],
+        form_keywords: list[str],
+    ) -> dict[str, list[str]]:
         """
         Filter constraints using input_keywords. Return list of available queryables.
         All constraint entries must have the same parameters.
@@ -727,9 +731,9 @@ class ECMWFSearch(PostJsonSearch):
         )
 
         # filter constraint entries matching input keyword values
-        filtered_constraints: List[Dict[str, Any]]
+        filtered_constraints: list[dict[str, Any]]
 
-        parsed_keywords: List[str] = []
+        parsed_keywords: list[str] = []
         for keyword in ordered_keywords:
             values = input_keywords.get(keyword)
 
@@ -808,7 +812,7 @@ class ECMWFSearch(PostJsonSearch):
             parsed_keywords.append(keyword)
             constraints = filtered_constraints
 
-        available_values: Dict[str, Any] = {k: set() for k in ordered_keywords}
+        available_values: dict[str, Any] = {k: set() for k in ordered_keywords}
 
         # we aggregate the constraint entries left
         for entry in constraints:
@@ -819,10 +823,10 @@ class ECMWFSearch(PostJsonSearch):
 
     def queryables_by_form(
         self,
-        form: List[Dict[str, Any]],
-        available_values: Dict[str, List[str]],
-        defaults: Dict[str, Any],
-    ) -> Dict[str, Annotated[Any, FieldInfo]]:
+        form: list[dict[str, Any]],
+        available_values: dict[str, list[str]],
+        defaults: dict[str, Any],
+    ) -> dict[str, Annotated[Any, FieldInfo]]:
         """
         Generate Annotated field definitions from form entries and available values
         Used by Copernicus services like cop_cds, cop_ads, cop_ewds.
@@ -832,9 +836,9 @@ class ECMWFSearch(PostJsonSearch):
         :param defaults: default values for the parameters
         :return: dict of annotated queryables
         """
-        queryables: Dict[str, Annotated[Any, FieldInfo]] = {}
+        queryables: dict[str, Annotated[Any, FieldInfo]] = {}
 
-        required_list: List[str] = []
+        required_list: list[str] = []
         for element in form:
             name: str = element["name"]
 
@@ -869,9 +873,6 @@ class ECMWFSearch(PostJsonSearch):
                 if fields and (comment := fields[0].get("comment")):
                     prop["description"] = comment
 
-                if d := details.get("default"):
-                    default = default or (d[0] if fields else d)
-
             if name == "area" and isinstance(default, dict):
                 default = list(default.values())
 
@@ -901,10 +902,10 @@ class ECMWFSearch(PostJsonSearch):
 
     def queryables_by_values(
         self,
-        available_values: Dict[str, List[str]],
-        required_keywords: List[str],
-        defaults: Dict[str, Any],
-    ) -> Dict[str, Annotated[Any, FieldInfo]]:
+        available_values: dict[str, list[str]],
+        required_keywords: list[str],
+        defaults: dict[str, Any],
+    ) -> dict[str, Annotated[Any, FieldInfo]]:
         """
         Generate Annotated field definitions from available values.
         Used by ECMWF data providers like dedt_lumi.
@@ -918,7 +919,7 @@ class ECMWFSearch(PostJsonSearch):
         # Needed to map constraints like "xxxx" to eodag parameter "ecmwf:xxxx"
         required = [ecmwf_format(k) for k in required_keywords]
 
-        queryables: Dict[str, Annotated[Any, FieldInfo]] = {}
+        queryables: dict[str, Annotated[Any, FieldInfo]] = {}
         for name, values in available_values.items():
             # Rename keywords from form with metadata mapping.
             # Needed to map constraints like "xxxx" to eodag parameter "ecmwf:xxxx"
@@ -939,8 +940,8 @@ class ECMWFSearch(PostJsonSearch):
         return queryables
 
     def format_as_provider_keyword(
-        self, product_type: str, properties: Dict[str, Any]
-    ) -> Dict[str, Any]:
+        self, product_type: str, properties: dict[str, Any]
+    ) -> dict[str, Any]:
         """Return provider equivalent keyword names from EODAG keywords.
 
         :param product_type: product type id
@@ -973,12 +974,12 @@ class ECMWFSearch(PostJsonSearch):
             if hasattr(self, "auth") and isinstance(self.auth, AuthBase)
             else None
         )
-        timeout = getattr(self.config, "timeout", HTTP_REQ_TIMEOUT)
-        return fetch_json(url, auth=auth, timeout=timeout)
+        timeout = getattr(self.config, "timeout", DEFAULT_SEARCH_TIMEOUT)
+        return functools.lru_cache()(fetch_json)(url, auth=auth, timeout=timeout)
 
     def normalize_results(
         self, results: RawSearchResult, **kwargs: Any
-    ) -> List[EOProduct]:
+    ) -> list[EOProduct]:
         """Build :class:`~eodag.api.product._product.EOProduct` from provider result
 
         :param results: Raw provider result as single dict in list
@@ -1150,7 +1151,7 @@ class MeteoblueSearch(ECMWFSearch):
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> Tuple[List[str], int]:
+    ) -> tuple[list[str], int]:
         """Wraps PostJsonSearch.collect_search_urls to force product count to 1
 
         :param prep: :class:`~eodag.plugins.search.PreparedSearch` object containing information for the search
@@ -1162,7 +1163,7 @@ class MeteoblueSearch(ECMWFSearch):
 
     def do_search(
         self, prep: PreparedSearch = PreparedSearch(items_per_page=None), **kwargs: Any
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Perform the actual search request, and return result in a single element.
 
         :param prep: :class:`~eodag.plugins.search.PreparedSearch` object containing information for the search
@@ -1182,7 +1183,7 @@ class MeteoblueSearch(ECMWFSearch):
 
     def build_query_string(
         self, product_type: str, **kwargs: Any
-    ) -> Tuple[Dict[str, Any], str]:
+    ) -> tuple[dict[str, Any], str]:
         """Build The query string using the search parameters
 
         :param product_type: product type id
@@ -1221,7 +1222,7 @@ class WekeoECMWFSearch(ECMWFSearch):
 
     def normalize_results(
         self, results: RawSearchResult, **kwargs: Any
-    ) -> List[EOProduct]:
+    ) -> list[EOProduct]:
         """Build :class:`~eodag.api.product._product.EOProduct` from provider result
 
         :param results: Raw provider result as single dict in list
@@ -1247,7 +1248,7 @@ class WekeoECMWFSearch(ECMWFSearch):
 
         return normalized
 
-    def do_search(self, *args: Any, **kwargs: Any) -> List[Dict[str, Any]]:
+    def do_search(self, *args: Any, **kwargs: Any) -> list[dict[str, Any]]:
         """Should perform the actual search request.
 
         :param args: arguments to be used in the search
@@ -1258,7 +1259,7 @@ class WekeoECMWFSearch(ECMWFSearch):
 
     def build_query_string(
         self, product_type: str, **kwargs: Any
-    ) -> Tuple[Dict[str, Any], str]:
+    ) -> tuple[dict[str, Any], str]:
         """Build The query string using the search parameters
 
         :param product_type: product type id

eodag/plugins/search/cop_marine.py

@@ -22,7 +22,7 @@ import logging
 import os
 import re
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, cast
+from typing import TYPE_CHECKING, Any, Optional, cast
 from urllib.parse import urlsplit
 
 import boto3
@@ -69,8 +69,8 @@ def _get_date_from_yyyymmdd(date_str: str, item_key: str) -> Optional[datetime]:
 
 
 def _get_dates_from_dataset_data(
-    dataset_item: Dict[str, Any]
-) -> Optional[Dict[str, str]]:
+    dataset_item: dict[str, Any]
+) -> Optional[dict[str, str]]:
     dates = {}
     if "start_datetime" in dataset_item["properties"]:
         dates["start"] = dataset_item["properties"]["start_datetime"]
@@ -96,7 +96,7 @@ def _get_s3_client(endpoint_url: str) -> S3Client:
     )
 
 
-def _check_int_values_properties(properties: Dict[str, Any]):
+def _check_int_values_properties(properties: dict[str, Any]):
     # remove int values with a bit length of more than 64 from the properties
     invalid = []
     for prop, prop_value in properties.items():
@@ -134,7 +134,7 @@ class CopMarineSearch(StaticStacSearch):
 
     def _get_product_type_info(
         self, product_type: str
-    ) -> Tuple[Dict[str, Any], List[Dict[str, Any]]]:
+    ) -> tuple[dict[str, Any], list[dict[str, Any]]]:
         """Fetch product type and associated datasets info"""
 
         fetch_url = cast(str, self.config.discover_product_types["fetch_url"]).format(
@@ -183,13 +183,23 @@ class CopMarineSearch(StaticStacSearch):
         product_id: str,
         s3_url: str,
         product_type: str,
-        dataset_item: Dict[str, Any],
-        collection_dict: Dict[str, Any],
+        dataset_item: dict[str, Any],
+        collection_dict: dict[str, Any],
     ):
+        # try to find date(s) in product id
+        item_dates = re.findall(r"(\d{4})(0[1-9]|1[0-2])([0-3]\d)", product_id)
+        if not item_dates:
+            item_dates = re.findall(r"_(\d{4})(0[1-9]|1[0-2])", product_id)
+        use_dataset_dates = not bool(item_dates)
         for obj in collection_objects["Contents"]:
             if product_id in obj["Key"]:
                 return self._create_product(
-                    product_type, obj["Key"], s3_url, dataset_item, collection_dict
+                    product_type,
+                    obj["Key"],
+                    s3_url,
+                    dataset_item,
+                    collection_dict,
+                    use_dataset_dates,
                 )
         return None
 
@@ -198,8 +208,8 @@ class CopMarineSearch(StaticStacSearch):
         product_type: str,
         item_key: str,
         s3_url: str,
-        dataset_item: Dict[str, Any],
-        collection_dict: Dict[str, Any],
+        dataset_item: dict[str, Any],
+        collection_dict: dict[str, Any],
         use_dataset_dates: bool = False,
     ) -> Optional[EOProduct]:
 
@@ -278,7 +288,7 @@ class CopMarineSearch(StaticStacSearch):
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> Tuple[List[EOProduct], Optional[int]]:
+    ) -> tuple[list[EOProduct], Optional[int]]:
         """
         Implementation of search for the Copernicus Marine provider
         :param prep: object containing search parameterds
@@ -298,7 +308,7 @@ class CopMarineSearch(StaticStacSearch):
                 "parameter product type is required for search with cop_marine provider"
             )
         collection_dict, datasets_items_list = self._get_product_type_info(product_type)
-        products: List[EOProduct] = []
+        products: list[EOProduct] = []
         start_index = items_per_page * (page - 1) + 1
         num_total = 0
         for i, dataset_item in enumerate(datasets_items_list):

eodag/plugins/search/creodias_s3.py

@@ -17,26 +17,16 @@
 # limitations under the License.
 import logging
 from types import MethodType
-from typing import Any, List
+from typing import Any
 
-import boto3
-import botocore
 from botocore.exceptions import BotoCoreError
 
-from eodag.api.product import AssetsDict, EOProduct  # type: ignore
+from eodag.api.product import EOProduct  # type: ignore
 from eodag.api.search_result import RawSearchResult
-from eodag.config import PluginConfig
-from eodag.plugins.authentication.aws_auth import AwsAuth
 from eodag.plugins.search.qssearch import ODataV4Search
-from eodag.utils import guess_file_type
-from eodag.utils.exceptions import (
-    AuthenticationError,
-    MisconfiguredError,
-    NotAvailableError,
-    RequestError,
-)
+from eodag.utils.exceptions import RequestError
+from eodag.utils.s3 import update_assets_from_s3
 
-DATA_EXTENSIONS = ["jp2", "tiff", "nc", "grib"]
 logger = logging.getLogger("eodag.search.creodiass3")
 
 
@@ -54,73 +44,13 @@ def patched_register_downloader(self, downloader, authenticator):
     self.register_downloader_only(downloader, authenticator)
     # and also update assets
     try:
-        _update_assets(self, downloader.config, authenticator)
+        update_assets_from_s3(
+            self, authenticator, getattr(downloader.config, "s3_endpoint", None)
+        )
     except BotoCoreError as e:
         raise RequestError.from_error(e, "could not update assets") from e
 
 
-def _update_assets(product: EOProduct, config: PluginConfig, auth: AwsAuth):
-    product.assets = AssetsDict(product)
-    prefix = (
-        product.properties.get("productIdentifier", None).replace("/eodata/", "") + "/"
-    )
-    if prefix:
-        try:
-            auth_dict = auth.authenticate()
-            required_creds = ["aws_access_key_id", "aws_secret_access_key"]
-            if not all(x in auth_dict for x in required_creds):
-                raise MisconfiguredError(
-                    f"Incomplete credentials for {product.provider}, missing "
-                    f"{[x for x in required_creds if x not in auth_dict]}"
-                )
-            if not getattr(auth, "s3_client", None):
-                auth.s3_client = boto3.client(
-                    "s3",
-                    endpoint_url=config.s3_endpoint,
-                    aws_access_key_id=auth_dict["aws_access_key_id"],
-                    aws_secret_access_key=auth_dict["aws_secret_access_key"],
-                )
-            logger.debug("Listing assets in %s", prefix)
-            product.assets = AssetsDict(product)
-            s3_res = auth.s3_client.list_objects(
-                Bucket=config.s3_bucket, Prefix=prefix, MaxKeys=300
-            )
-            # check if product path has assets or is already a file
-            if "Contents" in s3_res:
-                for asset in s3_res["Contents"]:
-                    asset_basename = (
-                        asset["Key"].split("/")[-1]
-                        if "/" in asset["Key"]
-                        else asset["Key"]
-                    )
-
-                    if len(asset_basename) > 0 and asset_basename not in product.assets:
-                        role = (
-                            "data"
-                            if asset_basename.split(".")[-1] in DATA_EXTENSIONS
-                            else "metadata"
-                        )
-
-                        product.assets[asset_basename] = {
-                            "title": asset_basename,
-                            "roles": [role],
-                            "href": f"s3://{config.s3_bucket}/{asset['Key']}",
-                        }
-                        if mime_type := guess_file_type(asset["Key"]):
-                            product.assets[asset_basename]["type"] = mime_type
-            # update driver
-            product.driver = product.get_driver()
-
-        except botocore.exceptions.ClientError as e:
-            if str(auth.config.auth_error_code) in str(e):
-                raise AuthenticationError(
-                    f"Authentication failed on {config.base_uri} s3"
-                ) from e
-            raise NotAvailableError(
-                f"assets for product {prefix} could not be found"
-            ) from e
-
-
 class CreodiasS3Search(ODataV4Search):
     """
     ``CreodiasS3Search`` is an extension of :class:`~eodag.plugins.search.qssearch.ODataV4Search`,
@@ -139,7 +69,7 @@ class CreodiasS3Search(ODataV4Search):
 
     def normalize_results(
         self, results: RawSearchResult, **kwargs: Any
-    ) -> List[EOProduct]:
+    ) -> list[EOProduct]:
         """Build EOProducts from provider results"""
 
         products = super(CreodiasS3Search, self).normalize_results(results, **kwargs)

eodag/plugins/search/csw.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 
 import logging
 import re
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import pyproj
 from owslib.csw import CatalogueServiceWeb
@@ -60,13 +60,13 @@ class CSWSearch(Search):
         * :attr:`~eodag.config.PluginConfig.api_endpoint` (``str``) (**mandatory**): The endpoint of the
           provider's search interface
         * :attr:`~eodag.config.PluginConfig.version` (``str``): OGC Catalogue Service version; default: ``2.0.2``
-        * :attr:`~eodag.config.PluginConfig.search_definition` (``Dict[str, Any]``) (**mandatory**):
+        * :attr:`~eodag.config.PluginConfig.search_definition` (``dict[str, Any]``) (**mandatory**):
 
-          * **product_type_tags** (``List[Dict[str, Any]``): dict of product type tags
+          * **product_type_tags** (``list[dict[str, Any]``): dict of product type tags
           * **resource_location_filter** (``str``): regex string
-          * **date_tags** (``Dict[str, Any]``): tags for start and end
+          * **date_tags** (``dict[str, Any]``): tags for start and end
 
-        * :attr:`~eodag.config.PluginConfig.metadata_mapping` (``Dict[str, Any]``): The search plugins of this kind can
+        * :attr:`~eodag.config.PluginConfig.metadata_mapping` (``dict[str, Any]``): The search plugins of this kind can
           detect when a metadata mapping is "query-able", and get the semantics of how to format the query string
           parameter that enables to make a query on the corresponding metadata. To make a metadata query-able,
           just configure it in the metadata mapping to be a list of 2 items, the first one being the
@@ -107,7 +107,7 @@ class CSWSearch(Search):
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> Tuple[List[EOProduct], Optional[int]]:
+    ) -> tuple[list[EOProduct], Optional[int]]:
         """Perform a search on a OGC/CSW-like interface"""
         product_type = kwargs.get("productType")
         if product_type is None:
@@ -117,7 +117,7 @@ class CSWSearch(Search):
             self.__init_catalog(**getattr(auth.config, "credentials", {}))
         else:
             self.__init_catalog()
-        results: List[EOProduct] = []
+        results: list[EOProduct] = []
         if self.catalog:
             provider_product_type = self.config.products[product_type]["productType"]
             for product_type_def in self.config.search_definition["product_type_tags"]:
@@ -229,12 +229,12 @@ class CSWSearch(Search):
 
     def __convert_query_params(
         self,
-        product_type_def: Dict[str, Any],
+        product_type_def: dict[str, Any],
         product_type: str,
-        params: Dict[str, Any],
-    ) -> Union[List[OgcExpression], List[List[OgcExpression]]]:
+        params: dict[str, Any],
+    ) -> Union[list[OgcExpression], list[list[OgcExpression]]]:
         """Translates eodag search to CSW constraints using owslib constraint classes"""
-        constraints: List[OgcExpression] = []
+        constraints: list[OgcExpression] = []
         # How the match should be performed (fuzzy, prefix, postfix or exact).
         # defaults to fuzzy
         pt_tag, matching = (