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

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)

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)