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

eodag/api/product/metadata_mapping.py

@@ -23,23 +23,12 @@ import logging
 import re
 from datetime import datetime, timedelta
 from string import Formatter
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    AnyStr,
-    Callable,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Tuple,
-    Union,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, AnyStr, Callable, Iterator, Optional, Union, cast
 
 import geojson
 import orjson
 import pyproj
+import shapely
 from dateutil.parser import isoparse
 from dateutil.relativedelta import relativedelta
 from dateutil.tz import UTC, tzutc
@@ -87,8 +76,8 @@ DEFAULT_GEOMETRY = "POLYGON((180 -90, 180 90, -180 90, -180 -90, 180 -90))"
 
 
 def get_metadata_path(
-    map_value: Union[str, List[str]],
-) -> Tuple[Union[List[str], None], str]:
+    map_value: Union[str, list[str]],
+) -> tuple[Union[list[str], None], str]:
     """Return the jsonpath or xpath to the value of a EO product metadata in a provider
     search result.
 
@@ -136,12 +125,12 @@ def get_metadata_path(
     return None, path
 
 
-def get_metadata_path_value(map_value: Union[str, List[str]]) -> str:
+def get_metadata_path_value(map_value: Union[str, list[str]]) -> str:
     """Get raw metadata path without converter"""
     return map_value[1] if isinstance(map_value, list) else map_value
 
 
-def get_search_param(map_value: List[str]) -> str:
+def get_search_param(map_value: list[str]) -> str:
     """See :func:`~eodag.api.product.metadata_mapping.get_metadata_path`
 
     :param map_value: The value originating from the definition of `metadata_mapping`
@@ -179,6 +168,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
         - ``recursive_sub_str``: recursively substitue in the structure (e.g. dict)
           values matching a regex
         - ``slice_str``: slice a string (equivalent to s[start, end, step])
+        - ``to_lower``: Convert a string to lowercase
+        - ``to_upper``: Convert a string to uppercase
         - ``fake_l2a_title_from_l1c``: used to generate SAFE format metadata for data from AWS
         - ``s2msil2a_title_to_aws_productinfo``: used to generate SAFE format metadata for data from AWS
         - ``split_cop_dem_id``: get the bbox by splitting the product id
@@ -332,7 +323,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             return wkt_value
 
         @staticmethod
-        def convert_to_bounds_lists(input_geom: BaseGeometry) -> List[List[float]]:
+        def convert_to_bounds_lists(input_geom: BaseGeometry) -> list[list[float]]:
             if isinstance(input_geom, MultiPolygon):
                 geoms = [geom for geom in input_geom.geoms]
                 # sort with larger one at first (stac-browser only plots first one)
@@ -342,7 +333,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                 return [list(input_geom.bounds[0:4])]
 
         @staticmethod
-        def convert_to_bounds(input_geom_unformatted: Any) -> List[float]:
+        def convert_to_bounds(input_geom_unformatted: Any) -> list[float]:
             input_geom = get_geometry_from_various(geometry=input_geom_unformatted)
             if isinstance(input_geom, MultiPolygon):
                 geoms = [geom for geom in input_geom.geoms]
@@ -353,16 +344,18 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                 max_lon = -180
                 max_lat = -90
                 for geom in geoms:
-                    min_lon = min(min_lon, geom.bound[0])
-                    min_lat = min(min_lat, geom.bound[1])
-                    max_lon = max(max_lon, geom.bound[2])
-                    max_lat = max(max_lat, geom.bound[3])
+                    min_lon = min(min_lon, geom.bounds[0])
+                    min_lat = min(min_lat, geom.bounds[1])
+                    max_lon = max(max_lon, geom.bounds[2])
+                    max_lat = max(max_lat, geom.bounds[3])
                 return [min_lon, min_lat, max_lon, max_lat]
             else:
                 return list(input_geom.bounds[0:4])
 
         @staticmethod
-        def convert_to_nwse_bounds(input_geom: BaseGeometry) -> List[float]:
+        def convert_to_nwse_bounds(input_geom: BaseGeometry) -> list[float]:
+            if isinstance(input_geom, str):
+                input_geom = shapely.wkt.loads(input_geom)
             return list(input_geom.bounds[-1:] + input_geom.bounds[:-1])
 
         @staticmethod
@@ -444,7 +437,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                         else:
                             yield e
 
-                polygons_list: List[Polygon] = []
+                polygons_list: list[Polygon] = []
                 for elem in flatten_elements(georss[0]):
                     coords_list = elem.text.split()
                     polygon_args = [
@@ -469,7 +462,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
         @staticmethod
         def convert_to_longitude_latitude(
             input_geom_unformatted: Any,
-        ) -> Dict[str, float]:
+        ) -> dict[str, float]:
             bounds = MetadataFormatter.convert_to_bounds(input_geom_unformatted)
             lon = (bounds[0] + bounds[2]) / 2
             lat = (bounds[1] + bounds[3]) / 2
@@ -509,8 +502,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
 
         @staticmethod
         def convert_recursive_sub_str(
-            input_obj: Union[Dict[Any, Any], List[Any]], args: str
-        ) -> Union[Dict[Any, Any], List[Any]]:
+            input_obj: Union[dict[Any, Any], list[Any]], args: str
+        ) -> Union[dict[Any, Any], list[Any]]:
             old, new = ast.literal_eval(args)
             return items_recursive_apply(
                 input_obj,
@@ -520,8 +513,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
 
         @staticmethod
         def convert_dict_update(
-            input_dict: Dict[Any, Any], args: str
-        ) -> Dict[Any, Any]:
+            input_dict: dict[Any, Any], args: str
+        ) -> dict[Any, Any]:
             """Converts"""
             new_items_list = ast.literal_eval(args)
 
@@ -531,8 +524,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
 
         @staticmethod
         def convert_dict_filter(
-            input_dict: Dict[Any, Any], jsonpath_filter_str: str
-        ) -> Dict[Any, Any]:
+            input_dict: dict[Any, Any], jsonpath_filter_str: str
+        ) -> dict[Any, Any]:
             """Fitlers dict items using jsonpath"""
 
             jsonpath_filter = string_to_jsonpath(jsonpath_filter_str, force=True)
@@ -558,6 +551,16 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             ]
             return string[cmin:cmax:cstep]
 
+        @staticmethod
+        def convert_to_lower(string: str) -> str:
+            """Convert a string to lowercase."""
+            return string.lower()
+
+        @staticmethod
+        def convert_to_upper(string: str) -> str:
+            """Convert a string to uppercase."""
+            return string.upper()
+
         @staticmethod
         def convert_fake_l2a_title_from_l1c(string: str) -> str:
             id_regex = re.compile(
@@ -601,8 +604,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                 return NOT_AVAILABLE
 
         @staticmethod
-        def convert_split_id_into_s1_params(product_id: str) -> Dict[str, str]:
-            parts: List[str] = re.split(r"_(?!_)", product_id)
+        def convert_split_id_into_s1_params(product_id: str) -> dict[str, str]:
+            parts: list[str] = re.split(r"_(?!_)", product_id)
             if len(parts) < 9:
                 logger.error(
                     "id %s does not match expected Sentinel-1 id format", product_id
@@ -636,8 +639,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             return params
 
         @staticmethod
-        def convert_split_id_into_s3_params(product_id: str) -> Dict[str, str]:
-            parts: List[str] = re.split(r"_(?!_)", product_id)
+        def convert_split_id_into_s3_params(product_id: str) -> dict[str, str]:
+            parts: list[str] = re.split(r"_(?!_)", product_id)
             params = {"productType": product_id[4:15]}
             dates = re.findall("[0-9]{8}T[0-9]{6}", product_id)
             start_date = datetime.strptime(dates[0], "%Y%m%dT%H%M%S") - timedelta(
@@ -653,8 +656,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             return params
 
         @staticmethod
-        def convert_split_id_into_s5p_params(product_id: str) -> Dict[str, str]:
-            parts: List[str] = re.split(r"_(?!_)", product_id)
+        def convert_split_id_into_s5p_params(product_id: str) -> dict[str, str]:
+            parts: list[str] = re.split(r"_(?!_)", product_id)
             params = {
                 "productType": product_id[9:19],
                 "processingMode": parts[1],
@@ -671,7 +674,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             return params
 
         @staticmethod
-        def convert_split_cop_dem_id(product_id: str) -> List[int]:
+        def convert_split_cop_dem_id(product_id: str) -> list[int]:
             parts = product_id.split("_")
             lattitude = parts[3]
             longitude = parts[5]
@@ -710,7 +713,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
         @staticmethod
         def convert_to_datetime_dict(
             date: str, format: str
-        ) -> Dict[str, Union[List[str], str]]:
+        ) -> dict[str, Union[list[str], str]]:
             """Convert a date (str) to a dictionary where values are in the format given in argument
 
             date == "2021-04-21T18:27:19.123Z" and format == "list" => {
@@ -762,7 +765,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
         @staticmethod
         def convert_interval_to_datetime_dict(
             date: str, separator: str = "/"
-        ) -> Dict[str, List[str]]:
+        ) -> dict[str, list[str]]:
             """Convert a date interval ('/' separated str) to a dictionary where values are lists
 
             date == "2021-04-21/2021-04-22" => {
@@ -802,7 +805,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             }
 
         @staticmethod
-        def convert_get_ecmwf_time(date: str) -> List[str]:
+        def convert_get_ecmwf_time(date: str) -> list[str]:
             """Get the time of a date (str) in the ECMWF format (["HH:00"])
 
             "2021-04-21T18:27:19.123Z" => ["18:00"]
@@ -834,7 +837,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             date_object = datetime.strptime(utc_date, "%Y-%m-%dT%H:%M:%S.%fZ")
             date_object_second_year = date_object + relativedelta(years=1)
             return [
-                f'{date_object.strftime("%Y")}_{date_object_second_year.strftime("%y")}'
+                f"{date_object.strftime('%Y')}_{date_object_second_year.strftime('%y')}"
             ]
 
         @staticmethod
@@ -846,8 +849,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
 
         @staticmethod
         def convert_assets_list_to_dict(
-            assets_list: List[Dict[str, str]], asset_name_key: str = "title"
-        ) -> Dict[str, Dict[str, str]]:
+            assets_list: list[dict[str, str]], asset_name_key: str = "title"
+        ) -> dict[str, dict[str, str]]:
             """Convert a list of assets to a dictionary where keys represent
             name of assets and are found among values of asset dictionaries.
 
@@ -874,8 +877,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
                 "asset3": {"href": "qux", "title": "qux-title", "name": "asset3"},
             }
             """
-            asset_names: List[str] = []
-            assets_dict: Dict[str, Dict[str, str]] = {}
+            asset_names: list[str] = []
+            assets_dict: dict[str, dict[str, str]] = {}
 
             for asset in assets_list:
                 asset_name = asset[asset_name_key]
@@ -884,7 +887,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
 
             # we only keep the equivalent of the path basename in the case where the
             # asset name has a path pattern and this basename is only found once
-            immutable_asset_indexes: List[int] = []
+            immutable_asset_indexes: list[int] = []
             for i, asset_name in enumerate(asset_names):
                 if i in immutable_asset_indexes:
                     continue
@@ -902,20 +905,18 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             return assets_dict
 
     # if stac extension colon separator `:` is in search params, parse it to prevent issues with vformat
-    if re.search(r"{[a-zA-Z0-9_-]*:[a-zA-Z0-9_-]*}", search_param):
-        search_param = re.sub(
-            r"{([a-zA-Z0-9_-]*):([a-zA-Z0-9_-]*)}", r"{\1_COLON_\2}", search_param
-        )
+    if re.search(r"{[\w-]*:[\w#-]*}", search_param):
+        search_param = re.sub(r"{([\w-]*):([\w#-]*)}", r"{\1_COLON_\2}", search_param)
         kwargs = {k.replace(":", "_COLON_"): v for k, v in kwargs.items()}
 
     return MetadataFormatter().vformat(search_param, args, kwargs)
 
 
 def properties_from_json(
-    json: Dict[str, Any],
-    mapping: Dict[str, Any],
-    discovery_config: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Any]:
+    json: dict[str, Any],
+    mapping: dict[str, Any],
+    discovery_config: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
     """Extract properties from a provider json result.
 
     :param json: The representation of a provider result as a json object
@@ -928,7 +929,7 @@ def properties_from_json(
                              `discovery_path` (String representation of jsonpath)
     :returns: The metadata of the :class:`~eodag.api.product._product.EOProduct`
     """
-    properties: Dict[str, Any] = {}
+    properties: dict[str, Any] = {}
     templates = {}
     used_jsonpaths = []
     for metadata, value in mapping.items():
@@ -975,10 +976,24 @@ def properties_from_json(
                     if re.search(r"({[^{}:]+})+", conversion_or_none):
                         conversion_or_none = conversion_or_none.format(**properties)
 
-                    properties[metadata] = format_metadata(
-                        "{%s%s%s}" % (metadata, SEP, conversion_or_none),
-                        **{metadata: extracted_value},
-                    )
+                    if extracted_value == NOT_AVAILABLE:
+                        # try if value can be formatted even if it is not available
+                        try:
+                            properties[metadata] = format_metadata(
+                                "{%s%s%s}" % (metadata, SEP, conversion_or_none),
+                                **{metadata: extracted_value},
+                            )
+                        except ValueError:
+                            logger.debug(
+                                f"{metadata}: {extracted_value} could not be formatted with {conversion_or_none}"
+                            )
+                            continue
+                    else:
+                        # in this case formatting should work, otherwise something is wrong in the mapping
+                        properties[metadata] = format_metadata(
+                            "{%s%s%s}" % (metadata, SEP, conversion_or_none),
+                            **{metadata: extracted_value},
+                        )
         # properties as python objects when possible (format_metadata returns only strings)
         try:
             properties[metadata] = ast.literal_eval(properties[metadata])
@@ -1058,8 +1073,8 @@ def properties_from_xml(
     xml_as_text: AnyStr,
     mapping: Any,
     empty_ns_prefix: str = "ns",
-    discovery_config: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Any]:
+    discovery_config: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
     """Extract properties from a provider xml result.
 
     :param xml_as_text: The representation of a provider result as xml
@@ -1077,7 +1092,7 @@ def properties_from_xml(
                              `discovery_path` (String representation of xpath)
     :returns: the metadata of the :class:`~eodag.api.product._product.EOProduct`
     """
-    properties: Dict[str, Any] = {}
+    properties: dict[str, Any] = {}
     templates = {}
     used_xpaths = []
     root = etree.XML(xml_as_text)
@@ -1205,10 +1220,10 @@ def properties_from_xml(
 
 
 def mtd_cfg_as_conversion_and_querypath(
-    src_dict: Dict[str, Any],
-    dest_dict: Dict[str, Any] = {},
+    src_dict: dict[str, Any],
+    dest_dict: dict[str, Any] = {},
     result_type: str = "json",
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     """Metadata configuration dictionary to querypath with conversion dictionary
     Transform every src_dict value from jsonpath_str to tuple `(conversion, jsonpath_object)`
     or from xpath_str to tuple `(conversion, xpath_str)`
@@ -1256,8 +1271,8 @@ def mtd_cfg_as_conversion_and_querypath(
 
 
 def format_query_params(
-    product_type: str, config: PluginConfig, query_dict: Dict[str, Any]
-) -> Dict[str, Any]:
+    product_type: str, config: PluginConfig, query_dict: dict[str, Any]
+) -> dict[str, Any]:
     """format the search parameters to query parameters"""
     if "raise_errors" in query_dict.keys():
         del query_dict["raise_errors"]
@@ -1269,7 +1284,7 @@ def format_query_params(
         **config.products.get(product_type, {}).get("metadata_mapping", {}),
     )
 
-    query_params: Dict[str, Any] = {}
+    query_params: dict[str, Any] = {}
     # Get all the search parameters that are recognised as queryables by the
     # provider (they appear in the queryables dictionary)
     queryables = _get_queryables(query_dict, config, product_type_metadata_mapping)
@@ -1299,8 +1314,8 @@ def format_query_params(
                     query_params[eodag_search_key] = formatted_query_param
             else:
                 provider_search_key, provider_value = parts
-                query_params.setdefault(provider_search_key, []).append(
-                    format_metadata(provider_value, product_type, **query_dict)
+                query_params[provider_search_key] = format_metadata(
+                    provider_value, product_type, **query_dict
                 )
         else:
             query_params[provider_search_key] = user_input
@@ -1359,10 +1374,10 @@ def _resolve_hashes(formatted_query_param: str) -> str:
 
 
 def _format_free_text_search(
-    config: PluginConfig, metadata_mapping: Dict[str, Any], **kwargs: Any
-) -> Dict[str, Any]:
+    config: PluginConfig, metadata_mapping: dict[str, Any], **kwargs: Any
+) -> dict[str, Any]:
     """Build the free text search parameter using the search parameters"""
-    query_params: Dict[str, Any] = {}
+    query_params: dict[str, Any] = {}
     if not getattr(config, "free_text_search_operations", None):
         return query_params
     for param, operations_config in config.free_text_search_operations.items():
@@ -1401,13 +1416,13 @@ def _format_free_text_search(
 
 
 def _get_queryables(
-    search_params: Dict[str, Any],
+    search_params: dict[str, Any],
     config: PluginConfig,
-    metadata_mapping: Dict[str, Any],
-) -> Dict[str, Any]:
+    metadata_mapping: dict[str, Any],
+) -> dict[str, Any]:
     """Retrieve the metadata mappings that are query-able"""
     logger.debug("Retrieving queryable metadata from metadata_mapping")
-    queryables: Dict[str, Any] = {}
+    queryables: dict[str, Any] = {}
     for eodag_search_key, user_input in search_params.items():
         if user_input is not None:
             md_mapping = metadata_mapping.get(eodag_search_key, (None, NOT_MAPPED))
@@ -1454,7 +1469,7 @@ def _get_queryables(
 
 
 def get_queryable_from_provider(
-    provider_queryable: str, metadata_mapping: Dict[str, Union[str, List[str]]]
+    provider_queryable: str, metadata_mapping: dict[str, Union[str, list[str]]]
 ) -> Optional[str]:
     """Get EODAG configured queryable parameter from provider queryable parameter
 
@@ -1462,7 +1477,7 @@ def get_queryable_from_provider(
     :param metadata_mapping: metadata-mapping configuration
     :returns: EODAG configured queryable parameter or None
     """
-    pattern = rf"\b{provider_queryable}\b"
+    pattern = rf"\"{provider_queryable}\""
     # if 1:1 mapping exists privilege this one instead of other mapping
     # e.g. provider queryable = year -> use year and not date in which year also appears
     mapping_values = [
@@ -1478,7 +1493,7 @@ def get_queryable_from_provider(
 
 
 def get_provider_queryable_path(
-    queryable: str, metadata_mapping: Dict[str, Union[str, List[str]]]
+    queryable: str, metadata_mapping: dict[str, Union[str, list[str]]]
 ) -> Optional[str]:
     """Get EODAG configured queryable path from its parameter
 
@@ -1495,10 +1510,11 @@ def get_provider_queryable_path(
 
 def get_provider_queryable_key(
     eodag_key: str,
-    provider_queryables: Dict[str, Any],
-    metadata_mapping: Dict[str, Union[List[Any], str]],
+    provider_queryables: dict[str, Any],
+    metadata_mapping: dict[str, Union[list[Any], str]],
 ) -> str:
-    """finds the provider queryable corresponding to the given eodag key based on the metadata mapping
+    """Finds the provider queryable corresponding to the given eodag key based on the metadata mapping
+
     :param eodag_key: key in eodag
     :param provider_queryables: queryables returned from the provider
     :param metadata_mapping: metadata mapping from which the keys are retrieved

eodag/api/search_result.py

@@ -18,17 +18,7 @@
 from __future__ import annotations
 
 from collections import UserList
-from typing import (
-    TYPE_CHECKING,
-    Annotated,
-    Any,
-    Dict,
-    Iterable,
-    List,
-    Optional,
-    Tuple,
-    Union,
-)
+from typing import TYPE_CHECKING, Annotated, Any, Iterable, Optional, Union
 
 from shapely.geometry import GeometryCollection, shape
 from typing_extensions import Doc
@@ -56,17 +46,17 @@ class SearchResult(UserList):
     :ivar number_matched: Estimated total number of matching results
     """
 
-    data: List[EOProduct]
+    data: list[EOProduct]
 
     errors: Annotated[
-        List[Tuple[str, Exception]], Doc("Tuple of provider name, exception")
+        list[tuple[str, Exception]], Doc("Tuple of provider name, exception")
     ]
 
     def __init__(
         self,
-        products: List[EOProduct],
+        products: list[EOProduct],
         number_matched: Optional[int] = None,
-        errors: List[Tuple[str, Exception]] = [],
+        errors: list[tuple[str, Exception]] = [],
     ) -> None:
         super().__init__(products)
         self.number_matched = number_matched
@@ -92,7 +82,7 @@ class SearchResult(UserList):
         return self.crunch(FilterDate(dict(start=start, end=end)))
 
     def filter_latest_intersect(
-        self, geometry: Union[Dict[str, Any], BaseGeometry, Any]
+        self, geometry: Union[dict[str, Any], BaseGeometry, Any]
     ) -> SearchResult:
         """
         Apply :class:`~eodag.plugins.crunch.filter_latest_intersect.FilterLatestIntersect` crunch,
@@ -148,7 +138,7 @@ class SearchResult(UserList):
         return self.filter_property(storageStatus="ONLINE")
 
     @staticmethod
-    def from_geojson(feature_collection: Dict[str, Any]) -> SearchResult:
+    def from_geojson(feature_collection: dict[str, Any]) -> SearchResult:
         """Builds an :class:`~eodag.api.search_result.SearchResult` object from its representation as geojson
 
         :param feature_collection: A collection representing a search result.
@@ -161,7 +151,7 @@ class SearchResult(UserList):
             ]
         )
 
-    def as_geojson_object(self) -> Dict[str, Any]:
+    def as_geojson_object(self) -> dict[str, Any]:
         """GeoJSON representation of SearchResult"""
         return {
             "type": "FeatureCollection",
@@ -182,7 +172,7 @@ class SearchResult(UserList):
         return self.as_shapely_geometry_object().wkt
 
     @property
-    def __geo_interface__(self) -> Dict[str, Any]:
+    def __geo_interface__(self) -> dict[str, Any]:
         """Implements the geo-interface protocol.
 
         See https://gist.github.com/sgillies/2217756
@@ -230,9 +220,9 @@ class RawSearchResult(UserList):
     :param results: A list of raw/unparsed search results
     """
 
-    data: List[Any]
-    query_params: Dict[str, Any]
-    product_type_def_params: Dict[str, Any]
+    data: list[Any]
+    query_params: dict[str, Any]
+    product_type_def_params: dict[str, Any]
 
-    def __init__(self, results: List[Any]) -> None:
+    def __init__(self, results: list[Any]) -> None:
         super(RawSearchResult, self).__init__(results)

eodag/cli.py

@@ -48,7 +48,7 @@ import shutil
 import sys
 import textwrap
 from importlib.metadata import metadata
-from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Set
+from typing import TYPE_CHECKING, Any, Mapping
 
 import click
 
@@ -57,6 +57,11 @@ from eodag.utils import DEFAULT_ITEMS_PER_PAGE, DEFAULT_PAGE, parse_qs
 from eodag.utils.exceptions import NoMatchingProductType, UnsupportedProvider
 from eodag.utils.logging import setup_logging
 
+try:
+    from eodag.rest.utils import LIVENESS_PROBE_PATH
+except ImportError:
+    pass
+
 if TYPE_CHECKING:
     from click import Context
 
@@ -70,6 +75,18 @@ CRUNCHERS = [
 ]
 
 
+class LivenessFilter:
+    """
+    Filter out requests to the liveness probe endpoint
+    """
+
+    def filter(self, record):
+        """
+        Filter method required by the Python logging API.
+        """
+        return LIVENESS_PROBE_PATH not in record.getMessage()
+
+
 class MutuallyExclusiveOption(click.Option):
     """Mutually Exclusive Options for Click
     from https://gist.github.com/jacobtolar/fb80d5552a9a9dfc32b12a829fa21c0c
@@ -87,7 +104,7 @@ class MutuallyExclusiveOption(click.Option):
         super(MutuallyExclusiveOption, self).__init__(*args, **kwargs)
 
     def handle_parse_result(
-        self, ctx: Context, opts: Mapping[str, Any], args: List[str]
+        self, ctx: Context, opts: Mapping[str, Any], args: list[str]
     ):
         """Raise error or use parent handle_parse_result()"""
         if self.mutually_exclusive.intersection(opts) and self.name in opts:
@@ -342,9 +359,9 @@ def search_crunch(ctx: Context, **kwargs: Any) -> None:
     count = kwargs.pop("count")
 
     # Process inputs for crunch
-    cruncher_names: Set[Any] = set(kwargs.pop("cruncher") or [])
+    cruncher_names: set[Any] = set(kwargs.pop("cruncher") or [])
     cruncher_args = kwargs.pop("cruncher_args")
-    cruncher_args_dict: Dict[str, Dict[str, Any]] = {}
+    cruncher_args_dict: dict[str, dict[str, Any]] = {}
     if cruncher_args:
         for cruncher, argname, argval in cruncher_args:
             cruncher_args_dict.setdefault(cruncher, {}).setdefault(argname, argval)
@@ -679,7 +696,9 @@ def serve_rest(
         try:
             pid = os.fork()
         except OSError as e:
-            raise Exception("%s [%d]" % (e.strerror, e.errno))
+            raise Exception(
+                "%s [%d]" % (e.strerror, e.errno) if e.errno is not None else e.strerror
+            )
 
         if pid == 0:
             os.setsid()
@@ -691,8 +710,10 @@ def serve_rest(
 
         logging_config = uvicorn.config.LOGGING_CONFIG
         uvicorn_fmt = "%(asctime)-15s %(name)-32s [%(levelname)-8s] %(message)s"
+        logging_config["filters"] = {"liveness": {"()": LivenessFilter}}
         logging_config["formatters"]["access"]["fmt"] = uvicorn_fmt
         logging_config["formatters"]["default"]["fmt"] = uvicorn_fmt
+        logging_config["loggers"]["uvicorn.access"]["filters"] = ["liveness"]
 
         eodag_formatter = logging.Formatter(
             "%(asctime)-15s %(name)-32s [%(levelname)-8s] (tid=%(thread)d) %(message)s"