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

eodag/api/product/_assets.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 
 import re
 from collections import UserDict
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Optional
 
 from eodag.utils.exceptions import NotAvailableError
 from eodag.utils.repr import dict_to_html_table
@@ -31,12 +31,27 @@ if TYPE_CHECKING:
 
 
 class AssetsDict(UserDict):
-    """A UserDict object listing assets contained in a
-    :class:`~eodag.api.product._product.EOProduct` resulting from a search.
+    """A UserDict object which values are :class:`~eodag.api.product._assets.Asset`
+    contained in a :class:`~eodag.api.product._product.EOProduct` resulting from a
+    search.
 
     :param product: Product resulting from a search
     :param args: (optional) Arguments used to init the dictionary
     :param kwargs: (optional) Additional named-arguments used to init the dictionary
+
+    Example
+    -------
+
+    >>> from eodag.api.product import EOProduct
+    >>> product = EOProduct(
+    ...     provider="foo",
+    ...     properties={"id": "bar", "geometry": "POINT (0 0)"}
+    ... )
+    >>> type(product.assets)
+    <class 'eodag.api.product._assets.AssetsDict'>
+    >>> product.assets.update({"foo": {"href": "http://somewhere/something"}})
+    >>> product.assets
+    {'foo': {'href': 'http://somewhere/something'}}
     """
 
     product: EOProduct
@@ -45,10 +60,10 @@ class AssetsDict(UserDict):
         self.product = product
         super(AssetsDict, self).__init__(*args, **kwargs)
 
-    def __setitem__(self, key: str, value: Dict[str, Any]) -> None:
+    def __setitem__(self, key: str, value: dict[str, Any]) -> None:
         super().__setitem__(key, Asset(self.product, key, value))
 
-    def as_dict(self) -> Dict[str, Any]:
+    def as_dict(self) -> dict[str, Any]:
         """Builds a representation of AssetsDict to enable its serialization
 
         :returns: The representation of a :class:`~eodag.api.product._assets.AssetsDict`
@@ -56,7 +71,7 @@ class AssetsDict(UserDict):
         """
         return {k: v.as_dict() for k, v in self.data.items()}
 
-    def get_values(self, asset_filter: str = "") -> List[Asset]:
+    def get_values(self, asset_filter: str = "") -> list[Asset]:
         """
         retrieves the assets matching the given filter
 
@@ -98,12 +113,12 @@ class AssetsDict(UserDict):
                 <details><summary style='color: grey;'>
                     <span style='color: black'>'{k}'</span>:&ensp;
                     {{
-                        {"'roles': '<span style='color: black'>"+str(v['roles'])+"</span>',&ensp;"
-                            if v.get("roles") else ""}
-                        {"'type': '"+str(v['type'])+"',&ensp;"
-                            if v.get("type") else ""}
-                        {"'title': '<span style='color: black'>"+str(v['title'])+"</span>',&ensp;"
-                            if v.get("title") else ""}
+                        {"'roles': '<span style='color: black'>" + str(v['roles']) + "</span>',&ensp;"
+                         if v.get("roles") else ""}
+                        {"'type': '" + str(v['type']) + "',&ensp;"
+                         if v.get("type") else ""}
+                        {"'title': '<span style='color: black'>" + str(v['title']) + "</span>',&ensp;"
+                         if v.get("title") else ""}
                         ...
                     }}
                 </summary>
@@ -119,13 +134,27 @@ class AssetsDict(UserDict):
 
 
 class Asset(UserDict):
-    """A UserDict object containg one of the assets of a
-    :class:`~eodag.api.product._product.EOProduct` resulting from a search.
+    """A UserDict object containg one of the
+    :attr:`~eodag.api.product._product.EOProduct.assets` resulting from a search.
 
     :param product: Product resulting from a search
     :param key: asset key
     :param args: (optional) Arguments used to init the dictionary
     :param kwargs: (optional) Additional named-arguments used to init the dictionary
+
+    Example
+    -------
+
+    >>> from eodag.api.product import EOProduct
+    >>> product = EOProduct(
+    ...     provider="foo",
+    ...     properties={"id": "bar", "geometry": "POINT (0 0)"}
+    ... )
+    >>> product.assets.update({"foo": {"href": "http://somewhere/something"}})
+    >>> type(product.assets["foo"])
+    <class 'eodag.api.product._assets.Asset'>
+    >>> product.assets["foo"]
+    {'href': 'http://somewhere/something'}
     """
 
     product: EOProduct
@@ -138,7 +167,7 @@ class Asset(UserDict):
         self.key = key
         super(Asset, self).__init__(*args, **kwargs)
 
-    def as_dict(self) -> Dict[str, Any]:
+    def as_dict(self) -> dict[str, Any]:
         """Builds a representation of Asset to enable its serialization
 
         :returns: The representation of a :class:`~eodag.api.product._assets.Asset` as a

eodag/api/product/_product.py

@@ -22,7 +22,7 @@ import logging
 import os
 import re
 import tempfile
-from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import requests
 from requests import RequestException
@@ -38,7 +38,7 @@ try:
 except ImportError:
     from eodag.api.product._assets import AssetsDict
 
-from eodag.api.product.drivers import DRIVERS, NoDriver
+from eodag.api.product.drivers import DRIVERS, LEGACY_DRIVERS, NoDriver
 from eodag.api.product.metadata_mapping import (
     DEFAULT_GEOMETRY,
     NOT_AVAILABLE,
@@ -89,20 +89,6 @@ class EOProduct:
 
     :param provider: The provider from which the product originates
     :param properties: The metadata of the product
-    :ivar product_type: The product type
-    :vartype product_type: str
-    :ivar location: The path to the product, either remote or local if downloaded
-    :vartype location: str
-    :ivar remote_location: The remote path to the product
-    :vartype remote_location: str
-    :ivar search_kwargs: The search kwargs used by eodag to search for the product
-    :vartype search_kwargs: Any
-    :ivar geometry: The geometry of the product
-    :vartype geometry: :class:`shapely.geometry.base.BaseGeometry`
-    :ivar search_intersection: The intersection between the product's geometry
-                               and the search area.
-    :vartype search_intersection: :class:`shapely.geometry.base.BaseGeometry` or None
-
 
     .. note::
         The geojson spec `enforces <https://github.com/geojson/draft-geojson/pull/6>`_
@@ -112,18 +98,31 @@ class EOProduct:
         mentioned CRS.
     """
 
+    #: The provider from which the product originates
     provider: str
-    properties: Dict[str, Any]
+    #: The metadata of the product
+    properties: dict[str, Any]
+    #: The product type
     product_type: Optional[str]
-    location: str
-    remote_location: str
-    search_kwargs: Any
+    #: The geometry of the product
     geometry: BaseGeometry
+    #: The intersection between the product's geometry and the search area.
     search_intersection: Optional[BaseGeometry]
+    #: The path to the product, either remote or local if downloaded
+    location: str
+    #: The remote path to the product
+    remote_location: str
+    #: Assets of the product
     assets: AssetsDict
+    #: Driver enables additional methods to be called on the EOProduct
+    driver: DatasetDriver
+    #: Product data filename, stored during download
+    filename: str
+    #: Product search keyword arguments, stored during search
+    search_kwargs: Any
 
     def __init__(
-        self, provider: str, properties: Dict[str, Any], **kwargs: Any
+        self, provider: str, properties: dict[str, Any], **kwargs: Any
     ) -> None:
         self.provider = provider
         self.product_type = kwargs.get("productType")
@@ -174,7 +173,7 @@ class EOProduct:
         self.downloader: Optional[Union[Api, Download]] = None
         self.downloader_auth: Optional[Authentication] = None
 
-    def as_dict(self) -> Dict[str, Any]:
+    def as_dict(self) -> dict[str, Any]:
         """Builds a representation of EOProduct as a dictionary to enable its geojson
         serialization
 
@@ -185,7 +184,7 @@ class EOProduct:
         if self.search_intersection is not None:
             search_intersection = geometry.mapping(self.search_intersection)
 
-        geojson_repr: Dict[str, Any] = {
+        geojson_repr: dict[str, Any] = {
             "type": "Feature",
             "geometry": geometry.mapping(self.geometry),
             "id": self.properties["id"],
@@ -205,7 +204,7 @@ class EOProduct:
         return geojson_repr
 
     @classmethod
-    def from_geojson(cls, feature: Dict[str, Any]) -> EOProduct:
+    def from_geojson(cls, feature: dict[str, Any]) -> EOProduct:
         """Builds an :class:`~eodag.api.product._product.EOProduct` object from its
         representation as geojson
 
@@ -281,8 +280,8 @@ class EOProduct:
     def download(
         self,
         progress_callback: Optional[ProgressCallback] = None,
-        wait: int = DEFAULT_DOWNLOAD_WAIT,
-        timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
+        wait: float = DEFAULT_DOWNLOAD_WAIT,
+        timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
         **kwargs: Unpack[DownloadConf],
     ) -> str:
         """Download the EO product using the provided download plugin and the
@@ -355,7 +354,7 @@ class EOProduct:
 
     def _init_progress_bar(
         self, progress_callback: Optional[ProgressCallback]
-    ) -> Tuple[ProgressCallback, bool]:
+    ) -> tuple[ProgressCallback, bool]:
         # progress bar init
         if progress_callback is None:
             progress_callback = ProgressCallback(position=1)
@@ -462,12 +461,20 @@ class EOProduct:
             )
             if not isinstance(auth, AuthBase):
                 auth = None
+            # Read the ssl_verify parameter used on the provider config
+            # to ensure the same behavior for get_quicklook as other download functions
+            ssl_verify = (
+                getattr(self.downloader.config, "ssl_verify", True)
+                if self.downloader
+                else True
+            )
             with requests.get(
                 self.properties["quicklook"],
                 stream=True,
                 auth=auth,
                 headers=USER_AGENT,
                 timeout=DEFAULT_STREAM_REQUESTS_TIMEOUT,
+                verify=ssl_verify,
             ) as stream:
                 try:
                     stream.raise_for_status()
@@ -497,11 +504,16 @@ class EOProduct:
         try:
             for driver_conf in DRIVERS:
                 if all([criteria(self) for criteria in driver_conf["criteria"]]):
-                    return driver_conf["driver"]
+                    driver = driver_conf["driver"]
+                    break
+            # use legacy driver for deprecated get_data method usage
+            for lecacy_conf in LEGACY_DRIVERS:
+                if all([criteria(self) for criteria in lecacy_conf["criteria"]]):
+                    driver.legacy = lecacy_conf["driver"]
+                    break
+            return driver
         except TypeError:
-            logger.warning(
-                "Drivers definition seems out-of-date, please update eodag-cube"
-            )
+            logger.info("No driver matching")
             pass
         return NoDriver()
 
@@ -525,22 +537,21 @@ class EOProduct:
                 <tr style='background-color: transparent;'>
                     <td style='text-align: left; vertical-align: top;'>
                         {dict_to_html_table({
-                            "provider": self.provider,
-                            "product_type": self.product_type,
-                            "properties[&quot;id&quot;]": self.properties.get('id', None),
-                            "properties[&quot;startTimeFromAscendingNode&quot;]": self.properties.get(
-                                'startTimeFromAscendingNode', None
-                            ),
-                            "properties[&quot;completionTimeFromAscendingNode&quot;]": self.properties.get(
-                                'completionTimeFromAscendingNode', None
-                            ),
-                        }, brackets=False)}
-                        <details><summary style='color: grey; margin-top: 10px;'>properties:&ensp;({
-                            len(self.properties)
-                        })</summary>{dict_to_html_table(self.properties, depth=1)}</details>
-                        <details><summary style='color: grey; margin-top: 10px;'>assets:&ensp;({
-                            len(self.assets)
-                        })</summary>{self.assets._repr_html_(embeded=True)}</details>
+                         "provider": self.provider,
+                         "product_type": self.product_type,
+                         "properties[&quot;id&quot;]": self.properties.get('id', None),
+                         "properties[&quot;startTimeFromAscendingNode&quot;]": self.properties.get(
+                             'startTimeFromAscendingNode', None
+                         ),
+                         "properties[&quot;completionTimeFromAscendingNode&quot;]": self.properties.get(
+                             'completionTimeFromAscendingNode', None
+                         ),
+                         }, brackets=False)}
+                        <details><summary style='color: grey; margin-top: 10px;'>properties:&ensp;({len(
+                             self.properties)})</summary>{
+                                 dict_to_html_table(self.properties, depth=1)}</details>
+                        <details><summary style='color: grey; margin-top: 10px;'>assets:&ensp;({len(
+                                     self.assets)})</summary>{self.assets._repr_html_(embeded=True)}</details>
                     </td>
                     <td {geom_style} title='geometry'>geometry<br />{self.geometry._repr_svg_()}</td>
                     <td {thumbnail_style} title='properties[&quot;thumbnail&quot;]'>{thumbnail_html}</td>

eodag/api/product/drivers/__init__.py

@@ -16,14 +16,91 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """EODAG drivers package"""
+from __future__ import annotations
+
+from typing import Callable, TypedDict
+
 from eodag.api.product.drivers.base import DatasetDriver, NoDriver
+from eodag.api.product.drivers.generic import GenericDriver
+from eodag.api.product.drivers.sentinel1 import Sentinel1Driver
+from eodag.api.product.drivers.sentinel2 import Sentinel2Driver
 
 try:
-    from eodag_cube.api.product.drivers import (  # pyright: ignore[reportMissingImports]
-        DRIVERS,
+    # import from eodag-cube if installed
+    from eodag_cube.api.product.drivers.generic import (  # pyright: ignore[reportMissingImports]; isort: skip
+        GenericDriver as GenericDriver_cube,
+    )
+    from eodag_cube.api.product.drivers.sentinel2_l1c import (  # pyright: ignore[reportMissingImports]; isort: skip
+        Sentinel2L1C as Sentinel2L1C_cube,
+    )
+    from eodag_cube.api.product.drivers.stac_assets import (  # pyright: ignore[reportMissingImports]; isort: skip
+        StacAssets as StacAssets_cube,
     )
 except ImportError:
-    DRIVERS = []
+    GenericDriver_cube = NoDriver
+    Sentinel2L1C_cube = NoDriver
+    StacAssets_cube = NoDriver
+
+
+class DriverCriteria(TypedDict):
+    """Driver criteria definition"""
+
+    #: Function that returns True if the driver is suitable for the given :class:`~eodag.api.product._product.EOProduct`
+    criteria: list[Callable[..., bool]]
+    #: driver to use
+    driver: DatasetDriver
+
+
+#: list of drivers and their criteria
+DRIVERS: list[DriverCriteria] = [
+    {
+        "criteria": [
+            lambda prod: True
+            if (prod.product_type or "").startswith("S2_MSI_")
+            else False
+        ],
+        "driver": Sentinel2Driver(),
+    },
+    {
+        "criteria": [
+            lambda prod: True
+            if (prod.product_type or "").startswith("S1_SAR_")
+            else False
+        ],
+        "driver": Sentinel1Driver(),
+    },
+    {
+        "criteria": [lambda prod: True],
+        "driver": GenericDriver(),
+    },
+]
+
+
+#: list of legacy drivers and their criteria
+LEGACY_DRIVERS: list[DriverCriteria] = [
+    {
+        "criteria": [
+            lambda prod: True if len(getattr(prod, "assets", {})) > 0 else False
+        ],
+        "driver": StacAssets_cube(),
+    },
+    {
+        "criteria": [lambda prod: True if "assets" in prod.properties else False],
+        "driver": StacAssets_cube(),
+    },
+    {
+        "criteria": [
+            lambda prod: True
+            if getattr(prod, "product_type") == "S2_MSI_L1C"
+            else False
+        ],
+        "driver": Sentinel2L1C_cube(),
+    },
+    {
+        "criteria": [lambda prod: True],
+        "driver": GenericDriver_cube(),
+    },
+]
 
 # exportable content
-__all__ = ["DRIVERS", "DatasetDriver", "NoDriver"]
+__all__ = ["DRIVERS", "DatasetDriver", "GenericDriver", "NoDriver", "Sentinel2Driver"]

eodag/api/product/drivers/base.py

@@ -17,15 +17,72 @@
 # limitations under the License.
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+import logging
+import re
+from typing import TYPE_CHECKING, Optional, TypedDict
+
+from eodag.utils import _deprecated
 
 if TYPE_CHECKING:
     from eodag.api.product import EOProduct
 
 
+class AssetPatterns(TypedDict):
+    """Asset patterns definition"""
+
+    #: pattern to match and extract asset key
+    pattern: re.Pattern
+    #: roles associated to the asset key
+    roles: list[str]
+
+
+logger = logging.getLogger("eodag.driver.base")
+
+
 class DatasetDriver(metaclass=type):
-    """Dataset driver"""
+    """Parent class for all dataset drivers.
+
+    Drivers will provide methods adapted to a given :class:`~eodag.api.product._product.EOProduct` related to predefined
+    criteria.
+    """
+
+    #: legacy driver for deprecated :meth:`~eodag_cube.api.product._product.EOProduct.get_data` method usage
+    legacy: DatasetDriver
 
+    #: list of patterns to match asset keys and roles
+    ASSET_KEYS_PATTERNS_ROLES: list[AssetPatterns] = []
+
+    #: strip non-alphanumeric characters at the beginning and end of the key
+    STRIP_SPECIAL_PATTERN = re.compile(r"^[^A-Z0-9]+|[^A-Z0-9]+$", re.IGNORECASE)
+
+    def _normalize_key(self, key, eo_product):
+        # default cleanup
+        norm_key = key.replace(eo_product.properties.get("id", ""), "")
+        norm_key = re.sub(self.STRIP_SPECIAL_PATTERN, "", norm_key)
+
+        return norm_key
+
+    def guess_asset_key_and_roles(
+        self, href: str, eo_product: EOProduct
+    ) -> tuple[Optional[str], Optional[list[str]]]:
+        """Guess the asset key and roles from the given href.
+
+        :param href: The asset href
+        :param eo_product: The product to which the asset belongs
+        :returns: The asset key and roles
+        """
+        for pattern_dict in self.ASSET_KEYS_PATTERNS_ROLES:
+            if matched := pattern_dict["pattern"].match(href):
+                extracted_key, roles = (
+                    "".join([m for m in matched.groups() if m is not None]),
+                    pattern_dict.get("roles"),
+                )
+                normalized_key = self._normalize_key(extracted_key, eo_product)
+                return normalized_key or extracted_key, roles
+        logger.debug(f"No key & roles could be guessed for {href}")
+        return None, None
+
+    @_deprecated(reason="Method used by deprecated get_data", version="3.1.0")
     def get_data_address(self, eo_product: EOProduct, band: str) -> str:
         """Retrieve the address of the dataset represented by `eo_product`.
 
@@ -34,12 +91,16 @@ class DatasetDriver(metaclass=type):
         :returns: An address for the dataset
         :raises: :class:`~eodag.utils.exceptions.AddressNotFound`
         :raises: :class:`~eodag.utils.exceptions.UnsupportedDatasetAddressScheme`
+
+        .. deprecated:: 3.1.0
+           Method used by deprecated :meth:`~eodag_cube.api.product._product.EOProduct.get_data`
         """
         raise NotImplementedError
 
 
 class NoDriver(DatasetDriver):
-    """A default driver that does not implement any of the methods it should implement, used for all product types for
-    which the :meth:`~eodag.api.product._product.EOProduct.get_data` method is not yet implemented in eodag. Expect a
+    """A default :attr:`~eodag.api.product.drivers.base.DatasetDriver.legacy` driver that does not implement any of the
+    methods it should implement, used for all product types for  which the deprecated
+    :meth:`~eodag_cube.api.product._product.EOProduct.get_data` method is not implemented. Expect a
     :exc:`NotImplementedError` when trying to get the data in that case.
     """

eodag/api/product/drivers/generic.py

@@ -0,0 +1,65 @@
+# -*- 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 logging
+import re
+
+from eodag.api.product.drivers.base import AssetPatterns, DatasetDriver
+
+logger = logging.getLogger("eodag.driver.generic")
+
+
+class GenericDriver(DatasetDriver):
+    """Generic default Driver"""
+
+    #: list of patterns to match asset keys and roles
+    ASSET_KEYS_PATTERNS_ROLES: list[AssetPatterns] = [
+        # data
+        {
+            "pattern": re.compile(
+                r"^(?:.*[/\\])?([^/\\]+)(\.jp2|\.tiff?|\.dat|\.nc|\.grib2?)$",
+                re.IGNORECASE,
+            ),
+            "roles": ["data"],
+        },
+        # metadata
+        {
+            "pattern": re.compile(
+                r"^(?:.*[/\\])?([^/\\]+)(\.xml|\.xsd|\.safe|\.json)$", re.IGNORECASE
+            ),
+            "roles": ["metadata"],
+        },
+        # thumbnail
+        {
+            "pattern": re.compile(
+                r"^(?:.*[/\\])?(thumbnail)(\.jpg|\.jpeg|\.png)$", re.IGNORECASE
+            ),
+            "roles": ["thumbnail"],
+        },
+        # quicklook
+        {
+            "pattern": re.compile(
+                r"^(?:.*[/\\])?([^/\\]+-ql|preview|quick-?look)(\.jpg|\.jpeg|\.png)$",
+                re.IGNORECASE,
+            ),
+            "roles": ["overview"],
+        },
+        # default
+        {"pattern": re.compile(r"^(?:.*[/\\])?([^/\\]+)$"), "roles": ["auxiliary"]},
+    ]

eodag/api/product/drivers/sentinel1.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+# Copyright 2025, 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 Sentinel1Driver(DatasetDriver):
+    """Driver for Sentinel1 products"""
+
+    #: pattern to match data-role keys
+    DATA_PATTERN = re.compile(r"[vh]{2}", re.IGNORECASE)
+
+    #: list of patterns to replace in asset keys
+    REPLACE_PATTERNS = [
+        (re.compile(r"s1a?", re.IGNORECASE), ""),
+        (re.compile(r"grd", re.IGNORECASE), ""),
+        (re.compile(r"slc", re.IGNORECASE), ""),
+        (re.compile(r"ocn", re.IGNORECASE), ""),
+        (re.compile(r"iw", re.IGNORECASE), ""),
+        (re.compile(r"ew", re.IGNORECASE), ""),
+        (re.compile(r"wv", re.IGNORECASE), ""),
+        (re.compile(r"sm", re.IGNORECASE), ""),
+        (re.compile(r"raw([-_]s)?", re.IGNORECASE), ""),
+        (re.compile(r"[t?0-9]{3,}", re.IGNORECASE), ""),
+        (re.compile(r"-+"), "-"),
+        (re.compile(r"-+\."), "."),
+        (re.compile(r"_+"), "_"),
+        (re.compile(r"_+\."), "."),
+    ]
+
+    #: list of patterns to match asset keys and roles
+    ASSET_KEYS_PATTERNS_ROLES: list[AssetPatterns] = [
+        # data
+        {
+            "pattern": re.compile(
+                r"^.*?([vh]{2}).*\.(?:jp2|tiff?|dat)$", 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:
+        if self.DATA_PATTERN.fullmatch(key):
+            return key.upper()
+
+        key = super()._normalize_key(key, eo_product)
+
+        for pattern, replacement in self.REPLACE_PATTERNS:
+            key = pattern.sub(replacement, key)
+
+        return super()._normalize_key(key, eo_product)