eodag 3.0.0b3__py3-none-any.whl → 3.1.0__py3-none-any.whl

eodag/api/product/drivers/sentinel2.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+# Copyright 2021, CS GROUP - France, http://www.c-s.fr
+#
+# This file is part of EODAG project
+#     https://www.github.com/CS-SI/EODAG
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from eodag.api.product.drivers.base import AssetPatterns, DatasetDriver
+
+if TYPE_CHECKING:
+    from eodag.api.product._product import EOProduct
+
+
+class Sentinel2Driver(DatasetDriver):
+    """Driver for Sentinel2 products"""
+
+    #: Band keys associated with their default Ground Sampling Distance (GSD)
+    BANDS_DEFAULT_GSD = {
+        "10M": ("B02", "B03", "B04", "B08", "TCI"),
+        "20M": ("B05", "B06", "B07", "B11", "B12", "B8A"),
+        "60M": ("B01", "B09", "B10"),
+    }
+
+    #: list of patterns to match asset keys and roles
+    ASSET_KEYS_PATTERNS_ROLES: list[AssetPatterns] = [
+        # masks
+        {
+            "pattern": re.compile(r"^.*?(MSK_[^/\\]+)\.(?:jp2|tiff?)$", re.IGNORECASE),
+            "roles": ["data-mask"],
+        },
+        # visual
+        {
+            "pattern": re.compile(
+                r"^.*?(TCI)(_[0-9]+m)?\.(?:jp2|tiff?)$", re.IGNORECASE
+            ),
+            "roles": ["visual"],
+        },
+        # bands
+        {
+            "pattern": re.compile(
+                r"^.*?([A-Z]+[0-9]*[A-Z]?)(_[0-9]+m)?\.(?:jp2|tiff?)$", re.IGNORECASE
+            ),
+            "roles": ["data"],
+        },
+        # metadata
+        {
+            "pattern": re.compile(
+                r"^(?:.*[/\\])?([^/\\]+)(\.xml|\.xsd|\.safe|\.json)$", re.IGNORECASE
+            ),
+            "roles": ["metadata"],
+        },
+        # thumbnail
+        {
+            "pattern": re.compile(
+                r"^(?:.*[/\\])?(thumbnail)(\.jpe?g|\.png)$", re.IGNORECASE
+            ),
+            "roles": ["thumbnail"],
+        },
+        # quicklook
+        {
+            "pattern": re.compile(
+                r"^(?:.*[/\\])?[^/\\]+(-ql|preview|quick-?look)(\.jpe?g|\.png)$",
+                re.IGNORECASE,
+            ),
+            "roles": ["overview"],
+        },
+        # default
+        {"pattern": re.compile(r"^(?:.*[/\\])?([^/\\]+)$"), "roles": ["auxiliary"]},
+    ]
+
+    def _normalize_key(self, key: str, eo_product: EOProduct) -> str:
+        upper_key = key.upper()
+        # check if key matched any normalized
+        for res in self.BANDS_DEFAULT_GSD:
+            if res in upper_key:
+                for norm_key in self.BANDS_DEFAULT_GSD[res]:
+                    if norm_key in upper_key:
+                        return norm_key
+
+        return super()._normalize_key(key, eo_product)

eodag/api/product/metadata_mapping.py

@@ -23,24 +23,14 @@ 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
 from jsonpath_ng.jsonpath import Child, JSONPath
 from lxml import etree
@@ -86,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.
 
@@ -135,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`
@@ -152,7 +142,7 @@ def get_search_param(map_value: List[str]) -> str:
 
 
 def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
-    """Format a string of form {<field_name>#<conversion_function>}
+    """Format a string of form ``{<field_name>#<conversion_function>}``
 
     The currently understood converters are:
         - ``datetime_to_timestamp_milliseconds``: converts a utc date string to a timestamp in
@@ -178,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
@@ -331,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)
@@ -341,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]
@@ -352,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
@@ -373,8 +367,8 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             )
 
         @staticmethod
-        def convert_to_geojson(string: str) -> str:
-            return geojson.dumps(string)
+        def convert_to_geojson(value: Any) -> str:
+            return geojson.dumps(value)
 
         @staticmethod
         def convert_from_ewkt(ewkt_string: str) -> Union[BaseGeometry, str]:
@@ -443,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 = [
@@ -468,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
@@ -502,14 +496,21 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
             return NOT_AVAILABLE
 
         @staticmethod
-        def convert_replace_str(string: str, args: str) -> str:
+        def convert_replace_str(value: Any, args: str) -> str:
+            if isinstance(value, dict):
+                value = MetadataFormatter.convert_to_geojson(value)
+            elif not isinstance(value, str):
+                raise TypeError(
+                    f"convert_replace_str expects a string or a dict (apply to_geojson). Got {type(value)}"
+                )
+
             old, new = ast.literal_eval(args)
-            return re.sub(old, new, string)
+            return re.sub(old, new, value)
 
         @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,
@@ -519,8 +520,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)
 
@@ -530,8 +531,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)
@@ -557,6 +558,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(
@@ -600,8 +611,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
@@ -635,8 +646,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(
@@ -652,8 +663,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],
@@ -670,7 +681,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]
@@ -709,7 +720,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" => {
@@ -761,7 +772,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" => {
@@ -801,7 +812,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"]
@@ -831,9 +842,9 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
         def convert_get_hydrological_year(date: str):
             utc_date = MetadataFormatter.convert_to_iso_utc_datetime(date)
             date_object = datetime.strptime(utc_date, "%Y-%m-%dT%H:%M:%S.%fZ")
-            date_object_second_year = date_object + timedelta(days=365)
+            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
@@ -845,8 +856,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.
 
@@ -873,8 +884,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]
@@ -883,7 +894,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
@@ -901,20 +912,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
@@ -927,7 +936,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():
@@ -974,10 +983,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])
@@ -1057,8 +1080,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
@@ -1076,7 +1099,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)
@@ -1204,11 +1227,11 @@ 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]:
-    """Metadata configuration dictionary to querypath with conversion dictionnary
+) -> 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)`
 
@@ -1255,8 +1278,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"]
@@ -1268,7 +1291,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)
@@ -1298,8 +1321,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
@@ -1358,10 +1381,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():
@@ -1400,13 +1423,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))
@@ -1453,7 +1476,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
 
@@ -1461,15 +1484,27 @@ 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 = [
+        v[0] if isinstance(v, list) else "" for v in metadata_mapping.values()
+    ]
+    if provider_queryable in mapping_values:
+        ind = mapping_values.index(provider_queryable)
+        return Queryables.get_queryable_from_alias(list(metadata_mapping.keys())[ind])
     for param, param_conf in metadata_mapping.items():
-        if isinstance(param_conf, list) and re.search(pattern, param_conf[0]):
+        if (
+            isinstance(param_conf, list)
+            and param_conf[0]
+            and re.search(pattern, param_conf[0])
+        ):
             return Queryables.get_queryable_from_alias(param)
     return None
 
 
 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
 
@@ -1486,10 +1521,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