eodag 3.10.1__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

eodag/api/product/__init__.py

@@ -55,8 +55,8 @@ def unregistered_product_from_item(
                 # properties cleanup
                 for prop in ("start_datetime", "end_datetime"):
                     products[0].properties.pop(prop, None)
-                # set product type if not already set
-                if products[0].product_type is None:
-                    products[0].product_type = products[0].properties.get("productType")
+                # set collection if not already set
+                if products[0].collection is None:
+                    products[0].collection = products[0].properties.get("collection")
                 return products[0]
     return None

eodag/api/product/_product.py

@@ -38,7 +38,8 @@ try:
 except ImportError:
     from eodag.api.product._assets import AssetsDict
 
-from eodag.api.product.drivers import DRIVERS, LEGACY_DRIVERS, NoDriver
+from eodag.api.product.drivers import DRIVERS
+from eodag.api.product.drivers.generic import GenericDriver
 from eodag.api.product.metadata_mapping import (
     DEFAULT_GEOMETRY,
     NOT_AVAILABLE,
@@ -52,9 +53,10 @@ from eodag.utils import (
     DEFAULT_STREAM_REQUESTS_TIMEOUT,
     USER_AGENT,
     ProgressCallback,
+    format_string,
     get_geometry_from_various,
 )
-from eodag.utils.exceptions import DownloadError, MisconfiguredError
+from eodag.utils.exceptions import DownloadError, MisconfiguredError, ValidationError
 from eodag.utils.repr import dict_to_html_table
 
 if TYPE_CHECKING:
@@ -99,8 +101,8 @@ class EOProduct:
     provider: str
     #: The metadata of the product
     properties: dict[str, Any]
-    #: The product type
-    product_type: Optional[str]
+    #: The collection
+    collection: Optional[str]
     #: The geometry of the product
     geometry: BaseGeometry
     #: The intersection between the product's geometry and the search area.
@@ -122,8 +124,12 @@ class EOProduct:
         self, provider: str, properties: dict[str, Any], **kwargs: Any
     ) -> None:
         self.provider = provider
-        self.product_type = kwargs.get("productType")
-        self.location = self.remote_location = properties.get("downloadLink", "")
+        self.collection = (
+            kwargs.get("collection")
+            or properties.pop("collection", None)
+            or properties.get("_collection")
+        )
+        self.location = self.remote_location = properties.get("eodag:download_link", "")
         self.assets = AssetsDict(self)
         self.properties = {
             key: value
@@ -131,18 +137,31 @@ class EOProduct:
             if key != "geometry"
             and value != NOT_MAPPED
             and NOT_AVAILABLE not in str(value)
+            and not key.startswith("_")
             and value is not None
         }
+        common_stac_properties = {
+            key: self.properties[key]
+            for key in sorted(self.properties)
+            if ":" not in key
+        }
+        extensions_stac_properties = {
+            key: self.properties[key] for key in sorted(self.properties) if ":" in key
+        }
+        self.properties = common_stac_properties | extensions_stac_properties
+
         if "geometry" not in properties or (
             (
                 properties["geometry"] == NOT_AVAILABLE
                 or properties["geometry"] == NOT_MAPPED
             )
-            and "defaultGeometry" not in properties
+            and "eodag:default_geometry" not in properties
         ):
             product_geometry = DEFAULT_SHAPELY_GEOMETRY
         elif not properties["geometry"] or properties["geometry"] == NOT_AVAILABLE:
-            product_geometry = properties.pop("defaultGeometry", DEFAULT_GEOMETRY)
+            product_geometry = properties.pop(
+                "eodag:default_geometry", DEFAULT_GEOMETRY
+            )
         else:
             product_geometry = properties["geometry"]
 
@@ -188,9 +207,9 @@ class EOProduct:
             "id": self.properties["id"],
             "assets": self.assets.as_dict(),
             "properties": {
-                "eodag_product_type": self.product_type,
-                "eodag_provider": self.provider,
-                "eodag_search_intersection": search_intersection,
+                "eodag:collection": self.collection,
+                "eodag:provider": self.provider,
+                "eodag:search_intersection": search_intersection,
                 **{
                     key: value
                     for key, value in self.properties.items()
@@ -209,16 +228,22 @@ class EOProduct:
         :param feature: The representation of a :class:`~eodag.api.product._product.EOProduct`
                         as a Python dict
         :returns: An instance of :class:`~eodag.api.product._product.EOProduct`
+        :raises: :class:`~eodag.utils.exceptions.ValidationError`
         """
-        properties = feature["properties"]
-        properties["geometry"] = feature["geometry"]
-        properties["id"] = feature["id"]
-        provider = feature["properties"]["eodag_provider"]
-        product_type = feature["properties"]["eodag_product_type"]
-        obj = cls(provider, properties, productType=product_type)
-        obj.search_intersection = geometry.shape(
-            feature["properties"]["eodag_search_intersection"]
-        )
+        try:
+            properties = feature["properties"]
+            properties["geometry"] = feature["geometry"]
+            properties["id"] = feature["id"]
+            provider = properties.pop("eodag:provider")
+            collection = properties.pop("eodag:collection")
+            search_intersection = properties.pop("eodag:search_intersection")
+        except KeyError as e:
+            raise ValidationError(
+                "Key %s not found in geojson, make sure it comes from a serialized SearchResult"
+                % e.args[0]
+            ) from e
+        obj = cls(provider, properties, collection=collection)
+        obj.search_intersection = geometry.shape(search_intersection)
         obj.assets = AssetsDict(obj, feature.get("assets", {}))
         return obj
 
@@ -248,12 +273,12 @@ class EOProduct:
         download_plugin = plugins_manager.get_download_plugin(self)
         if len(self.assets) > 0:
             matching_url = next(iter(self.assets.values()))["href"]
-        elif self.properties.get("storageStatus") != ONLINE_STATUS:
-            matching_url = self.properties.get("orderLink") or self.properties.get(
-                "downloadLink"
-            )
+        elif self.properties.get("order:status") != ONLINE_STATUS:
+            matching_url = self.properties.get(
+                "eodag:order_link"
+            ) or self.properties.get("eodag:download_link")
         else:
-            matching_url = self.properties.get("downloadLink")
+            matching_url = self.properties.get("eodag:download_link")
 
         try:
             auth_plugin = next(
@@ -420,7 +445,7 @@ class EOProduct:
         :raises HTTPError: If the HTTP request to the quicklook URL fails.
         """
         with requests.get(
-            self.properties["quicklook"],
+            self.properties["eodag:quicklook"],
             stream=True,
             auth=auth,
             headers=USER_AGENT,
@@ -464,17 +489,19 @@ class EOProduct:
         def format_quicklook_address() -> None:
             """If the quicklook address is a Python format string, resolve the
             formatting with the properties of the product."""
-            fstrmatch = re.match(r".*{.+}*.*", self.properties["quicklook"])
+            fstrmatch = re.match(r".*{.+}*.*", self.properties["eodag:quicklook"])
             if fstrmatch:
-                self.properties["quicklook"].format(
-                    {
+                self.properties["eodag:quicklook"] = format_string(
+                    None,
+                    self.properties["eodag:quicklook"],
+                    **{
                         prop_key: prop_val
                         for prop_key, prop_val in self.properties.items()
-                        if prop_key != "quicklook"
-                    }
+                        if prop_key != "eodag:quicklook"
+                    },
                 )
 
-        if self.properties.get("quicklook") is None:
+        if self.properties.get("eodag:quicklook") is None:
             logger.warning(
                 "Missing information to retrieve quicklook for EO product: %s",
                 self.properties["id"],
@@ -517,11 +544,11 @@ class EOProduct:
             # it is a HTTP URL. If not, we assume it is a base64 string, in which case
             # we just decode the content, write it into the quicklook_file and return it.
             if not (
-                self.properties["quicklook"].startswith("http")
-                or self.properties["quicklook"].startswith("https")
+                self.properties["eodag:quicklook"].startswith("http")
+                or self.properties["eodag:quicklook"].startswith("https")
             ):
                 with open(quicklook_file, "wb") as fd:
-                    img = self.properties["quicklook"].encode("ascii")
+                    img = self.properties["eodag:quicklook"].encode("ascii")
                     fd.write(base64.b64decode(img))
                 return quicklook_file
 
@@ -567,24 +594,15 @@ class EOProduct:
 
     def get_driver(self) -> DatasetDriver:
         """Get the most appropriate driver"""
-        try:
-            for driver_conf in DRIVERS:
-                if all([criteria(self) for criteria in driver_conf["criteria"]]):
-                    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.info("No driver matching")
-            pass
-        return NoDriver()
+        for driver_conf in DRIVERS:
+            if all([criteria(self) for criteria in driver_conf["criteria"]]):
+                return driver_conf["driver"]
+        return GenericDriver()
 
     def _repr_html_(self):
-        thumbnail = self.properties.get("thumbnail")
+        thumbnail = self.properties.get("eodag:thumbnail") or self.properties.get(
+            "eodag:quicklook"
+        )
         thumbnail_html = (
             f"<img src='{thumbnail}' width=100 alt='thumbnail'/>"
             if thumbnail and not thumbnail.startswith("s3")
@@ -604,13 +622,13 @@ class EOProduct:
                     <td style='text-align: left; vertical-align: top;'>
                         {dict_to_html_table({
                          "provider": self.provider,
-                         "product_type": self.product_type,
+                         "collection": self.collection,
                          "properties[&quot;id&quot;]": self.properties.get('id'),
-                         "properties[&quot;startTimeFromAscendingNode&quot;]": self.properties.get(
-                             'startTimeFromAscendingNode'
+                         "properties[&quot;start_datetime&quot;]": self.properties.get(
+                             'start_datetime'
                          ),
-                         "properties[&quot;completionTimeFromAscendingNode&quot;]": self.properties.get(
-                             'completionTimeFromAscendingNode'
+                         "properties[&quot;end_datetime&quot;]": self.properties.get(
+                             'end_datetime'
                          ),
                          }, brackets=False)}
                         <details><summary style='color: grey; margin-top: 10px;'>properties:&ensp;({len(

eodag/api/product/drivers/__init__.py

@@ -20,27 +20,11 @@ from __future__ import annotations
 
 from typing import Callable, TypedDict
 
-from eodag.api.product.drivers.base import DatasetDriver, NoDriver
+from eodag.api.product.drivers.base import DatasetDriver
 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:
-    # 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:
-    GenericDriver_cube = NoDriver
-    Sentinel2L1C_cube = NoDriver
-    StacAssets_cube = NoDriver
-
 
 class DriverCriteria(TypedDict):
     """Driver criteria definition"""
@@ -56,7 +40,7 @@ DRIVERS: list[DriverCriteria] = [
     {
         "criteria": [
             lambda prod: True
-            if (prod.product_type or "").startswith("S2_MSI_")
+            if (prod.collection or "").startswith("S2_MSI_")
             else False
         ],
         "driver": Sentinel2Driver(),
@@ -64,7 +48,7 @@ DRIVERS: list[DriverCriteria] = [
     {
         "criteria": [
             lambda prod: True
-            if (prod.product_type or "").startswith("S1_SAR_")
+            if (prod.collection or "").startswith("S1_SAR_")
             else False
         ],
         "driver": Sentinel1Driver(),
@@ -76,31 +60,5 @@ DRIVERS: list[DriverCriteria] = [
 ]
 
 
-#: 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", "GenericDriver", "NoDriver", "Sentinel2Driver"]
+__all__ = ["DRIVERS", "DatasetDriver", "GenericDriver", "Sentinel2Driver"]

eodag/api/product/drivers/base.py

@@ -21,8 +21,6 @@ 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
 
@@ -46,9 +44,6 @@ class DatasetDriver(metaclass=type):
     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] = []
 
@@ -81,26 +76,3 @@ class DatasetDriver(metaclass=type):
                 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`.
-
-        :param eo_product: The product whom underlying dataset address is to be retrieved
-        :param band: The band to retrieve (e.g: 'B01')
-        :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 :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.
-    """