eodag 3.3.1__py3-none-any.whl → 3.4.0__py3-none-any.whl

eodag/api/product/_product.py

@@ -313,7 +313,6 @@ class EOProduct:
                 "EO product is unable to download itself due to lacking of a "
                 "download plugin"
             )
-
         auth = (
             self.downloader_auth.authenticate()
             if self.downloader_auth is not None
@@ -323,7 +322,6 @@ class EOProduct:
         progress_callback, close_progress_callback = self._init_progress_bar(
             progress_callback
         )
-
         fs_path = self.downloader.download(
             self,
             auth=auth,
@@ -369,6 +367,47 @@ class EOProduct:
         progress_callback.refresh()
         return (progress_callback, close_progress_callback)
 
+    def _download_quicklook(
+        self,
+        quicklook_file: str,
+        progress_callback: ProgressCallback,
+        ssl_verify: Optional[bool] = None,
+        auth: Optional[AuthBase] = None,
+    ):
+
+        """Download the quicklook image from the EOProduct's quicklook URL.
+
+        This method performs an HTTP GET request to retrieve the quicklook image and saves it
+        locally at the specified path. It optionally verifies SSL certificates, uses HTTP
+        authentication, and can display a download progress if a callback is provided.
+
+        :param quicklook_file: The full path (including filename) where the quicklook will be saved.
+        :param progress_callback: A callable that accepts the current and total download sizes
+                                to display or log the download progress. It must support `reset(total)`
+                                and be callable with downloaded chunk sizes.
+        :param ssl_verify: (optional) Whether to verify SSL certificates. Defaults to True.
+        :param auth: (optional) Authentication credentials (e.g., tuple or object) used for the
+                        HTTP request if the resource requires authentication.
+        :raises HTTPError: If the HTTP request to the quicklook URL fails.
+        """
+        with requests.get(
+            self.properties["quicklook"],
+            stream=True,
+            auth=auth,
+            headers=USER_AGENT,
+            timeout=DEFAULT_STREAM_REQUESTS_TIMEOUT,
+            verify=ssl_verify,
+        ) as stream:
+            stream.raise_for_status()
+            stream_size = int(stream.headers.get("content-length", 0))
+            progress_callback.reset(stream_size)
+            with open(quicklook_file, "wb") as fhandle:
+                for chunk in stream.iter_content(chunk_size=64 * 1024):
+                    if chunk:
+                        fhandle.write(chunk)
+                        progress_callback(len(chunk))
+            logger.info("Download recorded in %s", quicklook_file)
+
     def get_quicklook(
         self,
         filename: Optional[str] = None,
@@ -378,6 +417,9 @@ class EOProduct:
         """Download the quicklook image of a given EOProduct from its provider if it
         exists.
 
+        This method retrieves the quicklook URL from the EOProduct metadata and delegates
+        the download to the internal `download_quicklook` method.
+
         :param filename: (optional) The name to give to the downloaded quicklook. If not
                          given, it defaults to the product's ID (without file extension).
         :param output_dir: (optional) The absolute path of the directory where to store
@@ -403,18 +445,6 @@ class EOProduct:
                     }
                 )
 
-        # progress bar init
-        if progress_callback is None:
-            progress_callback = ProgressCallback()
-            # one shot progress callback to close after download
-            close_progress_callback = True
-        else:
-            close_progress_callback = False
-            # update units as bar may have been previously used for extraction
-            progress_callback.unit = "B"
-            progress_callback.unit_scale = True
-        progress_callback.desc = "quicklooks/%s" % self.properties.get("id", "")
-
         if self.properties.get("quicklook", None) is None:
             logger.warning(
                 "Missing information to retrieve quicklook for EO product: %s",
@@ -442,6 +472,18 @@ class EOProduct:
         )
 
         if not os.path.isfile(quicklook_file):
+
+            # progress bar init
+            if progress_callback is None:
+                progress_callback = ProgressCallback()
+                # one shot progress callback to close after download
+                close_progress_callback = True
+            else:
+                close_progress_callback = False
+                # update units as bar may have been previously used for extraction
+                progress_callback.unit = "B"
+                progress_callback.unit_scale = True
+            progress_callback.desc = "quicklooks/%s" % self.properties.get("id", "")
             # VERY SPECIAL CASE (introduced by the onda provider): first check if
             # 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.
@@ -468,30 +510,25 @@ class EOProduct:
                 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()
-                except RequestException as e:
-                    import traceback as tb
+            try:
+                self._download_quicklook(
+                    quicklook_file, progress_callback, ssl_verify, auth
+                )
+            except RequestException as e:
 
-                    logger.error("Error while getting resource :\n%s", tb.format_exc())
+                logger.debug(
+                    f"Error while getting resource with authentication. {e} \nTrying without authentication..."
+                )
+                try:
+                    self._download_quicklook(
+                        quicklook_file, progress_callback, ssl_verify, None
+                    )
+                except RequestException as e_no_auth:
+                    logger.error(
+                        f"Failed to get resource with authentication: {e} \n \
+                        Failed to get resource even without authentication. {e_no_auth}"
+                    )
                     return str(e)
-                else:
-                    stream_size = int(stream.headers.get("content-length", 0))
-                    progress_callback.reset(stream_size)
-                    with open(quicklook_file, "wb") as fhandle:
-                        for chunk in stream.iter_content(chunk_size=64 * 1024):
-                            if chunk:
-                                fhandle.write(chunk)
-                                progress_callback(len(chunk))
-                    logger.info("Download recorded in %s", quicklook_file)
 
             # close progress bar if needed
             if close_progress_callback:

eodag/plugins/manager.py

@@ -20,10 +20,9 @@ from __future__ import annotations
 import logging
 import re
 from operator import attrgetter
-from pathlib import Path
 from typing import TYPE_CHECKING, Any, Iterator, Optional, Union, cast
 
-import pkg_resources
+import importlib_metadata
 
 from eodag.config import (
     AUTH_TOPIC_KEYS,
@@ -91,12 +90,12 @@ class PluginManager:
             # have it discovered as long as they declare an entry point of the type
             # 'eodag.plugins.search' for example in its setup script. See the setup
             # script of eodag for an example of how to do this.
-            for entry_point in pkg_resources.iter_entry_points(
-                "eodag.plugins.{}".format(topic)
+            for entry_point in importlib_metadata.entry_points(
+                group="eodag.plugins.{}".format(topic)
             ):
                 try:
                     entry_point.load()
-                except pkg_resources.DistributionNotFound:
+                except ModuleNotFoundError:
                     logger.debug(
                         "%s plugin skipped, eodag[%s] or eodag[all] needed",
                         entry_point.name,
@@ -112,18 +111,12 @@ class PluginManager:
                         "Check that the plugin module (%s) is importable",
                         entry_point.module_name,
                     )
-                if (
-                    entry_point.dist
-                    and entry_point.dist.key != "eodag"
-                    and entry_point.dist.location is not None
-                ):
+                if entry_point.dist and entry_point.dist.name != "eodag":
                     # use plugin providers if any
+                    name = entry_point.dist.name
+                    dist = entry_point.dist
                     plugin_providers_config_path = [
-                        str(x)
-                        for x in Path(
-                            entry_point.dist.location,
-                            pkg_resources.to_filename(entry_point.dist.key),
-                        ).rglob("providers.yml")
+                        str(x) for x in dist.locate_file(name).rglob("providers.yml")
                     ]
                     if plugin_providers_config_path:
                         plugin_providers_config = load_config(

eodag/plugins/search/cop_marine.py

@@ -37,7 +37,7 @@ from eodag.api.product import AssetsDict
 from eodag.config import PluginConfig
 from eodag.plugins.search import PreparedSearch
 from eodag.plugins.search.static_stac_search import StaticStacSearch
-from eodag.utils import get_bucket_name_and_prefix
+from eodag.utils import get_bucket_name_and_prefix, get_geometry_from_various
 from eodag.utils.exceptions import RequestError, UnsupportedProductType, ValidationError
 
 if TYPE_CHECKING:
@@ -215,10 +215,14 @@ class CopMarineSearch(StaticStacSearch):
 
         item_id = os.path.splitext(item_key.split("/")[-1])[0]
         download_url = s3_url + "/" + item_key
+        geometry = (
+            get_geometry_from_various(**dataset_item)
+            or self.config.metadata_mapping["defaultGeometry"]
+        )
         properties = {
             "id": item_id,
             "title": item_id,
-            "geometry": self.config.metadata_mapping["defaultGeometry"],
+            "geometry": geometry,
             "downloadLink": download_url,
             "dataset": dataset_item["id"],
         }
@@ -308,10 +312,16 @@ class CopMarineSearch(StaticStacSearch):
                 "parameter product type is required for search with cop_marine provider"
             )
         collection_dict, datasets_items_list = self._get_product_type_info(product_type)
+        geometry = kwargs.pop("geometry", None)
         products: list[EOProduct] = []
         start_index = items_per_page * (page - 1) + 1
         num_total = 0
         for i, dataset_item in enumerate(datasets_items_list):
+            # Filter by geometry
+            if "id" not in kwargs and geometry:
+                dataset_geom = get_geometry_from_various(**dataset_item)
+                if dataset_geom and not dataset_geom.intersects(geometry):
+                    continue
             try:
                 logger.debug("searching data for dataset %s", dataset_item["id"])
 

eodag/plugins/search/qssearch.py

@@ -70,6 +70,7 @@ from eodag.api.search_result import RawSearchResult
 from eodag.plugins.search import PreparedSearch
 from eodag.plugins.search.base import Search
 from eodag.types import json_field_definition_to_python, model_fields_to_annotated
+from eodag.types.queryables import Queryables
 from eodag.types.search_args import SortByList
 from eodag.utils import (
     DEFAULT_SEARCH_TIMEOUT,
@@ -80,6 +81,7 @@ from eodag.utils import (
     REQ_RETRY_TOTAL,
     USER_AGENT,
     _deprecated,
+    copy_deepcopy,
     deepcopy,
     dict_items_recursive_apply,
     format_dict_items,
@@ -1896,30 +1898,47 @@ class StacSearch(PostJsonSearch):
                     "No queryable found for %s on %s", product_type, self.provider
                 )
                 return None
-
             # convert json results to pydantic model fields
             field_definitions: dict[str, Any] = dict()
+            STAC_TO_EODAG_QUERYABLES = {
+                "start_datetime": "start",
+                "end_datetime": "end",
+                "datetime": None,
+                "bbox": "geom",
+            }
             for json_param, json_mtd in json_queryables.items():
-                param = (
+                param = STAC_TO_EODAG_QUERYABLES.get(
+                    json_param,
                     get_queryable_from_provider(
                         json_param, self.get_metadata_mapping(product_type)
                     )
-                    or json_param
+                    or json_param,
                 )
+                if param is None:
+                    continue
 
-                default = kwargs.get(param, None)
+                default = kwargs.get(param, json_mtd.get("default"))
                 annotated_def = json_field_definition_to_python(
                     json_mtd, default_value=default
                 )
                 field_definitions[param] = get_args(annotated_def)
 
             python_queryables = create_model("m", **field_definitions).model_fields
-            # replace geometry by geom
             geom_queryable = python_queryables.pop("geometry", None)
             if geom_queryable:
                 python_queryables["geom"] = geom_queryable
 
-        return model_fields_to_annotated(python_queryables)
+            queryables_dict = model_fields_to_annotated(python_queryables)
+
+            # append "datetime" as "start" & "end" if needed
+            if "datetime" in json_queryables:
+                eodag_queryables = copy_deepcopy(
+                    model_fields_to_annotated(Queryables.model_fields)
+                )
+                queryables_dict.setdefault("start", eodag_queryables["start"])
+                queryables_dict.setdefault("end", eodag_queryables["end"])
+
+            return queryables_dict
 
 
 class PostJsonSearchWithStacQueryables(StacSearch, PostJsonSearch):

eodag/plugins/search/static_stac_search.py

@@ -18,10 +18,11 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Annotated, Any, Optional
 from unittest import mock
 
 import geojson
+from pydantic.fields import FieldInfo
 
 from eodag.api.product.metadata_mapping import get_metadata_path_value
 from eodag.api.search_result import SearchResult
@@ -30,6 +31,7 @@ from eodag.plugins.crunch.filter_overlap import FilterOverlap
 from eodag.plugins.crunch.filter_property import FilterProperty
 from eodag.plugins.search import PreparedSearch
 from eodag.plugins.search.qssearch import StacSearch
+from eodag.types.queryables import Queryables
 from eodag.utils import HTTP_REQ_TIMEOUT, MockResponse
 from eodag.utils.stac_reader import fetch_stac_collections, fetch_stac_items
 
@@ -123,6 +125,34 @@ class StaticStacSearch(StacSearch):
 
         return conf_update_dict
 
+    def discover_queryables(
+        self, **kwargs: Any
+    ) -> dict[str, Annotated[Any, FieldInfo]]:
+        """Set static available queryables for :class:`~eodag.plugins.search.static_stac_search.StaticStacSearch`
+        search plugin
+
+        :param kwargs: additional filters for queryables (`productType` and other search
+                       arguments)
+        :returns: queryable parameters dict
+        """
+        return {
+            "productType": Queryables.get_with_default(
+                "productType", kwargs.get("productType")
+            ),
+            "id": Queryables.get_with_default("id", kwargs.get("id")),
+            "start": Queryables.get_with_default(
+                "start", kwargs.get("start") or kwargs.get("startTimeFromAscendingNode")
+            ),
+            "end": Queryables.get_with_default(
+                "end",
+                kwargs.get("end") or kwargs.get("completionTimeFromAscendingNode"),
+            ),
+            "geom": Queryables.get_with_default(
+                "geom",
+                kwargs.get("geom") or kwargs.get("geometry") or kwargs.get("area"),
+            ),
+        }
+
     def query(
         self,
         prep: PreparedSearch = PreparedSearch(),