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

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(),