eodag 3.0.0b1__py3-none-any.whl → 3.0.0b3__py3-none-any.whl

eodag/api/product/__init__.py

@@ -16,11 +16,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-# type: ignore
 """EODAG product package"""
 try:
     # import from eodag-cube if installed
-    from eodag_cube.api.product import Asset, AssetsDict, EOProduct  # noqa
+    from eodag_cube.api.product import (  # pyright: ignore[reportMissingImports]
+        Asset,
+        AssetsDict,
+        EOProduct,
+    )
 except ImportError:
-    from ._assets import Asset, AssetsDict  # noqa
-    from ._product import EOProduct  # noqa
+    from ._assets import Asset, AssetsDict  # type: ignore[assignment]
+    from ._product import EOProduct  # type: ignore[assignment]
+
+# exportable content
+__all__ = ["Asset", "AssetsDict", "EOProduct"]

eodag/api/product/_assets.py

@@ -22,6 +22,7 @@ from collections import UserDict
 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
@@ -34,11 +35,8 @@ class AssetsDict(UserDict):
     :class:`~eodag.api.product._product.EOProduct` resulting from a search.
 
     :param product: Product resulting from a search
-    :type product: :class:`~eodag.api.product._product.EOProduct`
     :param args: (optional) Arguments used to init the dictionary
-    :type args: Any
     :param kwargs: (optional) Additional named-arguments used to init the dictionary
-    :type kwargs: Any
     """
 
     product: EOProduct
@@ -55,17 +53,15 @@ class AssetsDict(UserDict):
 
         :returns: The representation of a :class:`~eodag.api.product._assets.AssetsDict`
                   as a Python dict
-        :rtype: dict
         """
         return {k: v.as_dict() for k, v in self.data.items()}
 
     def get_values(self, asset_filter: str = "") -> List[Asset]:
         """
         retrieves the assets matching the given filter
-        :param asset_filter: filter with which the assets should be matched
-        :type asset_filter: str
+
+        :param asset_filter: regex filter with which the assets should be matched
         :return: list of assets
-        :rtype: List[Asset]
         """
         if asset_filter:
             filter_regex = re.compile(asset_filter)
@@ -84,19 +80,52 @@ 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
     :class:`~eodag.api.product._product.EOProduct` resulting from a search.
 
     :param product: Product resulting from a search
-    :type product: :class:`~eodag.api.product._product.EOProduct`
     :param key: asset key
-    :type key: str
     :param args: (optional) Arguments used to init the dictionary
-    :type args: Any
     :param kwargs: (optional) Additional named-arguments used to init the dictionary
-    :type kwargs: Any
     """
 
     product: EOProduct
@@ -114,7 +143,6 @@ class Asset(UserDict):
 
         :returns: The representation of a :class:`~eodag.api.product._assets.Asset` as a
                   Python dict
-        :rtype: dict
         """
         return self.data
 
@@ -122,8 +150,18 @@ class Asset(UserDict):
         """Downloads a single asset
 
         :param kwargs: (optional) Additional named-arguments passed to `plugin.download()`
-        :type kwargs: Any
         :returns: The absolute path to the downloaded product on the local filesystem
-        :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

@@ -32,9 +32,11 @@ from shapely.errors import ShapelyError
 
 try:
     # import from eodag-cube if installed
-    from eodag_cube.api.product import AssetsDict  # type: ignore # noqa
+    from eodag_cube.api.product import (  # pyright: ignore[reportMissingImports]
+        AssetsDict,
+    )
 except ImportError:
-    from eodag.api.product._assets import AssetsDict  # type: ignore # noqa
+    from eodag.api.product._assets import AssetsDict
 
 from eodag.api.product.drivers import DRIVERS, NoDriver
 from eodag.api.product.metadata_mapping import (
@@ -51,6 +53,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
@@ -85,9 +88,7 @@ class EOProduct:
     parameters that led to its creation.
 
     :param provider: The provider from which the product originates
-    :type provider: str
     :param properties: The metadata of the product
-    :type properties: dict
     :ivar product_type: The product type
     :vartype product_type: str
     :ivar location: The path to the product, either remote or local if downloaded
@@ -179,7 +180,6 @@ class EOProduct:
 
         :returns: The representation of a :class:`~eodag.api.product._product.EOProduct` as a
                   Python dict
-        :rtype: dict
         """
         search_intersection = None
         if self.search_intersection is not None:
@@ -211,9 +211,7 @@ class EOProduct:
 
         :param feature: The representation of a :class:`~eodag.api.product._product.EOProduct`
                         as a Python dict
-        :type feature: dict
         :returns: An instance of :class:`~eodag.api.product._product.EOProduct`
-        :rtype: :class:`~eodag.api.product._product.EOProduct`
         """
         properties = feature["properties"]
         properties["geometry"] = feature["geometry"]
@@ -247,11 +245,9 @@ class EOProduct:
         """Give to the product the information needed to download itself.
 
         :param downloader: The download method that it can use
-        :type downloader: Concrete subclass of
                           :class:`~eodag.plugins.download.base.Download` or
                           :class:`~eodag.plugins.api.base.Api`
         :param authenticator: The authentication method needed to perform the download
-        :type authenticator: Concrete subclass of
                              :class:`~eodag.plugins.authentication.base.Authentication`
         """
         self.downloader = downloader
@@ -301,20 +297,15 @@ class EOProduct:
                                   size as inputs and handle progress bar
                                   creation and update to give the user a
                                   feedback on the download progress
-        :type progress_callback: :class:`~eodag.utils.ProgressCallback` or None
         :param wait: (optional) If download fails, wait time in minutes between
                      two download tries
-        :type wait: int
         :param timeout: (optional) If download fails, maximum time in minutes
                         before stop retrying to download
-        :type timeout: int
-        :param kwargs: `outputs_prefix` (str), `extract` (bool), `delete_archive` (bool)
+        :param kwargs: `output_dir` (str), `extract` (bool), `delete_archive` (bool)
                         and `dl_url_params` (dict) can be provided as additional kwargs
                         and will override any other values defined in a configuration
                         file or with environment variables.
-        :type kwargs: Union[str, bool, dict]
         :returns: The absolute path to the downloaded product on the local filesystem
-        :rtype: str
         :raises: :class:`~eodag.utils.exceptions.PluginImplementationError`
         :raises: :class:`RuntimeError`
         """
@@ -382,7 +373,7 @@ class EOProduct:
     def get_quicklook(
         self,
         filename: Optional[str] = None,
-        base_dir: Optional[str] = None,
+        output_dir: Optional[str] = None,
         progress_callback: Optional[ProgressCallback] = None,
     ) -> str:
         """Download the quicklook image of a given EOProduct from its provider if it
@@ -390,18 +381,14 @@ class EOProduct:
 
         :param filename: (optional) The name to give to the downloaded quicklook. If not
                          given, it defaults to the product's ID (without file extension).
-        :type filename: str
-        :param base_dir: (optional) The absolute path of the directory where to store
+        :param output_dir: (optional) The absolute path of the directory where to store
                          the quicklooks in the filesystem. If not given, it defaults to the
-                         `quicklooks` directory under this EO product downloader's ``outputs_prefix``
+                         `quicklooks` directory under this EO product downloader's ``output_dir``
                          config param (e.g. '/tmp/quicklooks/')
-        :type base_dir: str
         :param progress_callback: (optional) A method or a callable object which takes
                                    a current size and a maximum size as inputs and handle progress bar
                                    creation and update to give the user a feedback on the download progress
-        :type progress_callback: :class:`~eodag.utils.ProgressCallback` or None
         :returns: The absolute path of the downloaded quicklook
-        :rtype: str
         """
 
         def format_quicklook_address() -> None:
@@ -438,20 +425,20 @@ class EOProduct:
 
         format_quicklook_address()
 
-        if base_dir is not None:
-            quicklooks_base_dir = os.path.abspath(os.path.realpath(base_dir))
+        if output_dir is not None:
+            quicklooks_output_dir = os.path.abspath(os.path.realpath(output_dir))
         else:
             tempdir = tempfile.gettempdir()
-            outputs_prefix = (
-                getattr(self.downloader.config, "outputs_prefix", tempdir)
+            downloader_output_dir = (
+                getattr(self.downloader.config, "output_dir", 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)
+            quicklooks_output_dir = os.path.join(downloader_output_dir, "quicklooks")
+        if not os.path.isdir(quicklooks_output_dir):
+            os.makedirs(quicklooks_output_dir)
         quicklook_file = os.path.join(
-            quicklooks_base_dir,
+            quicklooks_output_dir,
             filename if filename is not None else self.properties["id"],
         )
 
@@ -517,3 +504,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>"""

eodag/api/product/drivers/__init__.py

@@ -16,9 +16,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """EODAG drivers package"""
-from eodag.api.product.drivers.base import DatasetDriver, NoDriver  # noqa
+from eodag.api.product.drivers.base import DatasetDriver, NoDriver
 
 try:
-    from eodag_cube.api.product.drivers import DRIVERS
+    from eodag_cube.api.product.drivers import (  # pyright: ignore[reportMissingImports]
+        DRIVERS,
+    )
 except ImportError:
     DRIVERS = []
+
+# exportable content
+__all__ = ["DRIVERS", "DatasetDriver", "NoDriver"]

eodag/api/product/drivers/base.py

@@ -30,11 +30,8 @@ class DatasetDriver(metaclass=type):
         """Retrieve the address of the dataset represented by `eo_product`.
 
         :param eo_product: The product whom underlying dataset address is to be retrieved
-        :type eo_product: :class:`~eodag.api.product._product.EOProduct`
         :param band: The band to retrieve (e.g: 'B01')
-        :type band: str
         :returns: An address for the dataset
-        :rtype: str
         :raises: :class:`~eodag.utils.exceptions.AddressNotFound`
         :raises: :class:`~eodag.utils.exceptions.UnsupportedDatasetAddressScheme`
         """

eodag/api/product/metadata_mapping.py

@@ -120,10 +120,8 @@ def get_metadata_path(
                       in the provider search config. For example, it is the list
                       `['productType', '$.properties.productType']` with the sample
                       above. Or the string `$.properties.id`.
-    :type map_value: str or list(str)
     :returns: Either, None and the path to the metadata value, or a list of converter
              and its args, and the path to the metadata value.
-    :rtype: tuple(list(str) or None, str)
     """
     path = get_metadata_path_value(map_value)
     try:
@@ -147,9 +145,7 @@ def get_search_param(map_value: List[str]) -> str:
 
     :param map_value: The value originating from the definition of `metadata_mapping`
                       in the provider search config
-    :type map_value: list
     :returns: The value of the search parameter as defined in the provider config
-    :rtype: str
     """
     # Assume that caller will pass in the value as a list
     return map_value[0]
@@ -190,13 +186,9 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
         - ``get_ecmwf_time``: get the time of a datetime string in the ECMWF format
 
     :param search_param: The string to be formatted
-    :type search_param: str
     :param args: (optional) Additional arguments to use in the formatting process
-    :type args: tuple
     :param kwargs: (optional) Additional named-arguments to use when formatting
-    :type kwargs: Any
     :returns: The formatted string
-    :rtype: str
     """
 
     class MetadataFormatter(Formatter):
@@ -926,7 +918,6 @@ def properties_from_json(
     """Extract properties from a provider json result.
 
     :param json: The representation of a provider result as a json object
-    :type json: dict
     :param mapping: A mapping between :class:`~eodag.api.product._product.EOProduct`'s metadata
                     keys and the location of the values of these properties in the json
                     representation, expressed as a
@@ -934,9 +925,7 @@ def properties_from_json(
     :param discovery_config: (optional) metadata discovery configuration dict, accepting among other items
                              `discovery_pattern` (Regex pattern for metadata key discovery, e.g. "^[a-zA-Z]+$"),
                              `discovery_path` (String representation of jsonpath)
-    :type discovery_config: dict
     :returns: The metadata of the :class:`~eodag.api.product._product.EOProduct`
-    :rtype: dict
     """
     properties: Dict[str, Any] = {}
     templates = {}
@@ -1073,7 +1062,6 @@ def properties_from_xml(
     """Extract properties from a provider xml result.
 
     :param xml_as_text: The representation of a provider result as xml
-    :type xml_as_text: str
     :param mapping: A mapping between :class:`~eodag.api.product._product.EOProduct`'s metadata
                     keys and the location of the values of these properties in the xml
                     representation, expressed as a
@@ -1083,13 +1071,10 @@ def properties_from_xml(
                             not supporting empty namespace prefix. The
                             xpath in `mapping` must use this value to be able to
                             correctly reach empty-namespace prefixed elements
-    :type empty_ns_prefix: str
     :param discovery_config: (optional) metadata discovery configuration dict, accepting among other items
                              `discovery_pattern` (Regex pattern for metadata key discovery, e.g. "^[a-zA-Z]+$"),
                              `discovery_path` (String representation of xpath)
-    :type discovery_config: dict
     :returns: the metadata of the :class:`~eodag.api.product._product.EOProduct`
-    :rtype: dict
     """
     properties: Dict[str, Any] = {}
     templates = {}
@@ -1228,11 +1213,8 @@ def mtd_cfg_as_conversion_and_querypath(
     or from xpath_str to tuple `(conversion, xpath_str)`
 
     :param src_dict: Input dict containing jsonpath str as values
-    :type src_dict: dict
     :param dest_dict: (optional) Output dict containing jsonpath objects as values
-    :type dest_dict: dict
     :returns: dest_dict
-    :rtype: dict
     """
     # check if the configuration has already been converted
     some_configured_value = (
@@ -1476,11 +1458,8 @@ def get_queryable_from_provider(
     """Get EODAG configured queryable parameter from provider queryable parameter
 
     :param provider_queryable: provider queryable parameter
-    :type provider_queryable: str
     :param metadata_mapping: metadata-mapping configuration
-    :type metadata_mapping: Dict[str, Union[str, List[str]]])
     :returns: EODAG configured queryable parameter or None
-    :rtype: Optional[str]
     """
     pattern = rf"\b{provider_queryable}\b"
     for param, param_conf in metadata_mapping.items():
@@ -1495,11 +1474,8 @@ def get_provider_queryable_path(
     """Get EODAG configured queryable path from its parameter
 
     :param queryable: eodag queryable parameter
-    :type queryable: str
     :param metadata_mapping: metadata-mapping configuration
-    :type metadata_mapping: Dict[str, Union[str, List[str]]])
     :returns: EODAG configured queryable path or None
-    :rtype: Optional[str]
     """
     parameter_conf = metadata_mapping.get(queryable, None)
     if isinstance(parameter_conf, list):
@@ -1515,13 +1491,9 @@ def get_provider_queryable_key(
 ) -> str:
     """finds the provider queryable corresponding to the given eodag key based on the metadata mapping
     :param eodag_key: key in eodag
-    :type eodag_key: str
     :param provider_queryables: queryables returned from the provider
-    :type provider_queryables: dict
     :param metadata_mapping: metadata mapping from which the keys are retrieved
-    :type metadata_mapping: Dict[str, Union[List[Any], str]]
     :returns: provider queryable key
-    :rtype: str
     """
     if eodag_key not in metadata_mapping:
         return ""

eodag/api/search_result.py

@@ -39,9 +39,10 @@ class SearchResult(UserList):
     """An object representing a collection of :class:`~eodag.api.product._product.EOProduct` resulting from a search.
 
     :param products: A list of products resulting from a search
-    :type products: list(:class:`~eodag.api.product._product.EOProduct`)
     :param number_matched: (optional) the estimated total number of matching results
-    :type number_matched: Optional[int]
+
+    :cvar data: List of products
+    :ivar number_matched: Estimated total number of matching results
     """
 
     data: List[EOProduct]
@@ -56,11 +57,8 @@ class SearchResult(UserList):
         """Do some crunching with the underlying EO products.
 
         :param cruncher: The plugin instance to use to work on the products
-        :type cruncher: subclass of :class:`~eodag.plugins.crunch.base.Crunch`
         :param search_params: The criteria that have been used to produce this result
-        :type search_params: dict
         :returns: The result of the application of the crunching method to the EO products
-        :rtype: :class:`~eodag.api.search_result.SearchResult`
         """
         crunched_results = cruncher.proceed(self.data, **search_params)
         return SearchResult(crunched_results)
@@ -135,9 +133,7 @@ class SearchResult(UserList):
         """Builds an :class:`~eodag.api.search_result.SearchResult` object from its representation as geojson
 
         :param feature_collection: A collection representing a search result.
-        :type feature_collection: dict
         :returns: An eodag representation of a search result
-        :rtype: :class:`~eodag.api.search_result.SearchResult`
         """
         return SearchResult(
             [
@@ -154,7 +150,7 @@ class SearchResult(UserList):
         }
 
     def as_shapely_geometry_object(self) -> GeometryCollection:
-        """:class:`shapely.geometry.GeometryCollection` representation of SearchResult"""
+        """:class:`shapely.GeometryCollection` representation of SearchResult"""
         return GeometryCollection(
             [
                 shape(feature["geometry"]).buffer(0)
@@ -174,12 +170,38 @@ class SearchResult(UserList):
         """
         return self.as_geojson_object()
 
+    def _repr_html_(self):
+        total_count = f"/{self.number_matched}" if self.number_matched else ""
+        return (
+            f"""<table>
+                <thead><tr><td style='text-align: left; color: grey;'>
+                 {type(self).__name__}&ensp;({len(self)}{total_count})
+                </td></tr></thead>
+            """
+            + "".join(
+                [
+                    f"""<tr><td style='text-align: left;'>
+                <details><summary style='color: grey; font-family: monospace;'>
+                    {i}&ensp;
+                    {type(p).__name__}(id=<span style='color: black;'>{
+                        p.properties['id']
+                    }</span>, provider={p.provider})
+                </summary>
+                {p._repr_html_()}
+                </details>
+                </td></tr>
+                """
+                    for i, p in enumerate(self)
+                ]
+            )
+            + "</table>"
+        )
+
 
 class RawSearchResult(UserList):
     """An object representing a collection of raw/unparsed search results obtained from a provider.
 
     :param results: A list of raw/unparsed search results
-    :type results: List[Any]
     """
 
     data: List[Any]