eodag 2.12.1__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

eodag/api/product/__init__.py

@@ -15,8 +15,12 @@
 # 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.
+#
+# type: ignore
 """EODAG product package"""
 try:
-    from eodag_cube.api.product import EOProduct  # noqa
+    # import from eodag-cube if installed
+    from eodag_cube.api.product import Asset, AssetsDict, EOProduct  # noqa
 except ImportError:
+    from ._assets import Asset, AssetsDict  # noqa
     from ._product import EOProduct  # noqa

eodag/api/product/_assets.py

@@ -19,12 +19,15 @@ from __future__ import annotations
 
 import re
 from collections import UserDict
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from eodag.utils.exceptions import NotAvailableError
+from eodag.utils.repr import dict_to_html_table
 
 if TYPE_CHECKING:
     from eodag.api.product import EOProduct
+    from eodag.types.download_args import DownloadConf
+    from eodag.utils import Unpack
 
 
 class AssetsDict(UserDict):
@@ -82,6 +85,43 @@ class AssetsDict(UserDict):
         else:
             return [a for a in self.values() if "href" in a]
 
+    def _repr_html_(self, embeded=False):
+        thead = (
+            f"""<thead><tr><td style='text-align: left; color: grey;'>
+                {type(self).__name__}&ensp;({len(self)})
+                </td></tr></thead>
+            """
+            if not embeded
+            else ""
+        )
+        tr_style = "style='background-color: transparent;'" if embeded else ""
+        return (
+            f"<table>{thead}"
+            + "".join(
+                [
+                    f"""<tr {tr_style}><td style='text-align: left;'>
+                <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 ""}
+                        ...
+                    }}
+                </summary>
+                    {dict_to_html_table(v, depth=1)}
+                </details>
+                </td></tr>
+                """
+                    for k, v in self.items()
+                ]
+            )
+            + "</table>"
+        )
+
 
 class Asset(UserDict):
     """A UserDict object containg one of the assets of a
@@ -98,6 +138,9 @@ class Asset(UserDict):
     """
 
     product: EOProduct
+    size: int
+    filename: Optional[str]
+    rel_path: str
 
     def __init__(self, product: EOProduct, key: str, *args: Any, **kwargs: Any) -> None:
         self.product = product
@@ -113,7 +156,7 @@ class Asset(UserDict):
         """
         return self.data
 
-    def download(self, **kwargs: Any) -> str:
+    def download(self, **kwargs: Unpack[DownloadConf]) -> str:
         """Downloads a single asset
 
         :param kwargs: (optional) Additional named-arguments passed to `plugin.download()`
@@ -122,3 +165,15 @@ class Asset(UserDict):
         :rtype: str
         """
         return self.product.download(asset=self.key, **kwargs)
+
+    def _repr_html_(self):
+        thead = f"""<thead><tr><td style='text-align: left; color: grey;'>
+            {type(self).__name__}&ensp;-&ensp;{self.key}
+            </td></tr></thead>
+        """
+        return f"""<table>{thead}
+                <tr><td style='text-align: left;'>
+                    {dict_to_html_table(self)}
+                </details>
+                </td></tr>
+            </table>"""

eodag/api/product/_product.py

@@ -21,17 +21,27 @@ import base64
 import logging
 import os
 import re
-import urllib.parse
+import tempfile
 from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, Union
 
 import requests
 from requests import RequestException
-from shapely import geometry, wkb, wkt
+from requests.auth import AuthBase
+from shapely import geometry
 from shapely.errors import ShapelyError
 
-from eodag.api.product._assets import AssetsDict
+try:
+    # import from eodag-cube if installed
+    from eodag_cube.api.product import AssetsDict  # type: ignore # noqa
+except ImportError:
+    from eodag.api.product._assets import AssetsDict  # type: ignore # noqa
+
 from eodag.api.product.drivers import DRIVERS, NoDriver
-from eodag.api.product.metadata_mapping import NOT_AVAILABLE, NOT_MAPPED
+from eodag.api.product.metadata_mapping import (
+    DEFAULT_GEOMETRY,
+    NOT_AVAILABLE,
+    NOT_MAPPED,
+)
 from eodag.utils import (
     DEFAULT_DOWNLOAD_TIMEOUT,
     DEFAULT_DOWNLOAD_WAIT,
@@ -41,6 +51,7 @@ from eodag.utils import (
     get_geometry_from_various,
 )
 from eodag.utils.exceptions import DownloadError, MisconfiguredError
+from eodag.utils.repr import dict_to_html_table
 
 if TYPE_CHECKING:
     from shapely.geometry.base import BaseGeometry
@@ -49,6 +60,8 @@ if TYPE_CHECKING:
     from eodag.plugins.apis.base import Api
     from eodag.plugins.authentication.base import Authentication
     from eodag.plugins.download.base import Download
+    from eodag.types.download_args import DownloadConf
+    from eodag.utils import Unpack
 
 try:
     from shapely.errors import GEOSException
@@ -133,40 +146,15 @@ class EOProduct:
             raise MisconfiguredError(
                 f"No geometry available to build EOProduct(id={properties.get('id', None)}, provider={provider})"
             )
-        elif properties["geometry"] == NOT_AVAILABLE:
-            product_geometry = properties.pop("defaultGeometry")
+        elif not properties["geometry"] or properties["geometry"] == NOT_AVAILABLE:
+            product_geometry = properties.pop("defaultGeometry", DEFAULT_GEOMETRY)
         else:
             product_geometry = properties["geometry"]
-        # Let's try 'latmin lonmin latmax lonmax'
-        if isinstance(product_geometry, str):
-            bbox_pattern = re.compile(
-                r"^(-?\d+\.?\d*) (-?\d+\.?\d*) (-?\d+\.?\d*) (-?\d+\.?\d*)$"
-            )
-            found_bbox = bbox_pattern.match(product_geometry)
-            if found_bbox:
-                coords = found_bbox.groups()
-                if len(coords) == 4:
-                    product_geometry = geometry.box(
-                        float(coords[1]),
-                        float(coords[0]),
-                        float(coords[3]),
-                        float(coords[2]),
-                    )
-        # Best effort to understand provider specific geometry (the default is to
-        # assume an object implementing the Geo Interface: see
-        # https://gist.github.com/2217756)
-        if isinstance(product_geometry, str):
-            try:
-                product_geometry = wkt.loads(product_geometry)
-            except (ShapelyError, GEOSException):
-                try:
-                    product_geometry = wkb.loads(product_geometry)
-                # Also catching TypeError because product_geometry can be a
-                # string and not a bytes string
-                except (ShapelyError, GEOSException, TypeError):
-                    # Giv up!
-                    raise
-        self.geometry = self.search_intersection = geometry.shape(product_geometry)
+
+        self.geometry = self.search_intersection = get_geometry_from_various(
+            geometry=product_geometry
+        )
+
         self.search_kwargs = kwargs
         if self.search_kwargs.get("geometry") is not None:
             searched_geom = get_geometry_from_various(
@@ -273,31 +261,23 @@ class EOProduct:
         # resolve locations and properties if needed with downloader configuration
         location_attrs = ("location", "remote_location")
         for location_attr in location_attrs:
-            try:
-                setattr(
-                    self,
-                    location_attr,
-                    urllib.parse.unquote(getattr(self, location_attr))
-                    % vars(self.downloader.config),
-                )
-            except ValueError as e:
-                logger.debug(
-                    f"Could not resolve product.{location_attr} ({getattr(self, location_attr)})"
-                    f" in register_downloader: {str(e)}"
-                )
+            if "%(" in getattr(self, location_attr):
+                try:
+                    setattr(
+                        self,
+                        location_attr,
+                        getattr(self, location_attr) % vars(self.downloader.config),
+                    )
+                except ValueError as e:
+                    logger.debug(
+                        f"Could not resolve product.{location_attr} ({getattr(self, location_attr)})"
+                        f" in register_downloader: {str(e)}"
+                    )
 
         for k, v in self.properties.items():
-            if isinstance(v, str):
+            if isinstance(v, str) and "%(" in v:
                 try:
-                    if "%" in v:
-                        parsed = urllib.parse.urlparse(v)
-                        prop = urllib.parse.unquote(parsed.path) % vars(
-                            self.downloader.config
-                        )
-                        parsed = parsed._replace(path=urllib.parse.quote(prop))
-                        self.properties[k] = urllib.parse.urlunparse(parsed)
-                    else:
-                        self.properties[k] = v % vars(self.downloader.config)
+                    self.properties[k] = v % vars(self.downloader.config)
                 except (TypeError, ValueError) as e:
                     logger.debug(
                         f"Could not resolve {k} property ({v}) in register_downloader: {str(e)}"
@@ -308,7 +288,7 @@ class EOProduct:
         progress_callback: Optional[ProgressCallback] = None,
         wait: int = DEFAULT_DOWNLOAD_WAIT,
         timeout: int = DEFAULT_DOWNLOAD_TIMEOUT,
-        **kwargs: Any,
+        **kwargs: Unpack[DownloadConf],
     ) -> str:
         """Download the EO product using the provided download plugin and the
         authenticator if necessary.
@@ -351,13 +331,6 @@ class EOProduct:
             else self.downloader_auth
         )
 
-        # resolve remote location if needed with downloader configuration
-        self.remote_location = urllib.parse.unquote(self.remote_location) % vars(
-            self.downloader.config
-        )
-        if not self.location.startswith("file"):
-            self.location = urllib.parse.unquote(self.location)
-
         progress_callback, close_progress_callback = self._init_progress_bar(
             progress_callback
         )
@@ -469,9 +442,13 @@ class EOProduct:
         if base_dir is not None:
             quicklooks_base_dir = os.path.abspath(os.path.realpath(base_dir))
         else:
-            quicklooks_base_dir = os.path.join(
-                self.downloader.config.outputs_prefix, "quicklooks"
+            tempdir = tempfile.gettempdir()
+            outputs_prefix = (
+                getattr(self.downloader.config, "outputs_prefix", tempdir)
+                if self.downloader
+                else tempdir
             )
+            quicklooks_base_dir = os.path.join(outputs_prefix, "quicklooks")
         if not os.path.isdir(quicklooks_base_dir):
             os.makedirs(quicklooks_base_dir)
         quicklook_file = os.path.join(
@@ -497,6 +474,8 @@ class EOProduct:
                 if self.downloader_auth is not None
                 else None
             )
+            if not isinstance(auth, AuthBase):
+                auth = None
             with requests.get(
                 self.properties["quicklook"],
                 stream=True,
@@ -539,3 +518,45 @@ class EOProduct:
             )
             pass
         return NoDriver()
+
+    def _repr_html_(self):
+        thumbnail = self.properties.get("thumbnail", None)
+        thumbnail_html = (
+            f"<img src='{thumbnail}' width=100 alt='thumbnail'/>"
+            if thumbnail and not thumbnail.startswith("s3")
+            else ""
+        )
+        geom_style = "style='color: grey; text-align: center; min-width:100px; vertical-align: top;'"
+        thumbnail_style = (
+            "style='padding-top: 1.5em; min-width:100px; vertical-align: top;'"
+        )
+
+        return f"""<table>
+                <thead><tr style='background-color: transparent;'><td style='text-align: left; color: grey;'>
+                {type(self).__name__}
+                </td></tr></thead>
+
+                <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>
+                    </td>
+                    <td {geom_style} title='geometry'>geometry<br />{self.geometry._repr_svg_()}</td>
+                    <td {thumbnail_style} title='properties[&quot;thumbnail&quot;]'>{thumbnail_html}</td>
+                </tr>
+            </table>"""