eodag 2.12.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

eodag/plugins/search/static_stac_search.py

@@ -18,22 +18,20 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, cast
+from unittest import mock
 
 import geojson
 
+from eodag.api.product.metadata_mapping import get_metadata_path_value
 from eodag.api.search_result import SearchResult
 from eodag.plugins.crunch.filter_date import FilterDate
 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.utils import (
-    DEFAULT_ITEMS_PER_PAGE,
-    DEFAULT_PAGE,
-    HTTP_REQ_TIMEOUT,
-    MockResponse,
-)
-from eodag.utils.stac_reader import fetch_stac_items
+from eodag.utils import HTTP_REQ_TIMEOUT, MockResponse
+from eodag.utils.stac_reader import fetch_stac_collections, fetch_stac_items
 
 if TYPE_CHECKING:
     from eodag.api.product import EOProduct
@@ -62,55 +60,121 @@ class StaticStacSearch(StacSearch):
     Then it uses crunchers to only keep products matching query parameters.
 
     :param provider: An eodag providers configuration dictionary
-    :type provider: dict
     :param config: Path to the user configuration file
-    :type config: str
     """
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
+        # prevent search parameters from being queried when they are known in the configuration or not
+        for param, mapping in config.metadata_mapping.items():
+            # only keep one queryable to allow the mock search request
+            if param != "productType":
+                config.metadata_mapping[param] = get_metadata_path_value(mapping)
+        config.discover_metadata["auto_discovery"] = False
+        # there is no endpoint for fetching queryables with a static search
+        config.discover_queryables["fetch_url"] = None
+        config.discover_queryables["product_type_fetch_url"] = None
+
         super(StaticStacSearch, self).__init__(provider, config)
         self.config.__dict__.setdefault("max_connections", 100)
         self.config.__dict__.setdefault("timeout", HTTP_REQ_TIMEOUT)
-
-    def discover_product_types(self) -> Dict[str, Any]:
-        """Fetch product types is disabled for `StaticStacSearch`
-
-        :returns: empty dict
-        :rtype: dict
+        self.config.__dict__.setdefault("ssl_verify", True)
+        self.config.__dict__.setdefault("pagination", {})
+        self.config.__dict__["pagination"].setdefault(
+            "total_items_nb_key_path", "$.null"
+        )
+        self.config.__dict__["pagination"].setdefault("max_items_per_page", -1)
+        # disable product types discovery by default (if endpoints equals to STAC API default)
+        if (
+            getattr(self.config, "discover_product_types", {}).get("fetch_url")
+            == "{api_endpoint}/../collections"
+        ):
+            self.config.discover_product_types = {"fetch_url": None}
+
+    def discover_product_types(self, **kwargs: Any) -> Optional[Dict[str, Any]]:
+        """Fetch product types list from a static STAC Catalog provider using `discover_product_types` conf
+
+        :returns: configuration dict containing fetched product types information
         """
-        return {}
+        fetch_url = cast(
+            str,
+            self.config.discover_product_types["fetch_url"].format(
+                **self.config.__dict__
+            ),
+        )
+        collections = fetch_stac_collections(
+            fetch_url,
+            collection=kwargs.get("q"),
+            max_connections=self.config.max_connections,
+            timeout=int(self.config.timeout),
+            ssl_verify=self.config.ssl_verify,
+        )
+        if "q" in kwargs:
+            collections = [c for c in collections if c["id"] == kwargs["q"]]
+        collections_mock_response = {"collections": collections}
+
+        # discover_product_types on mocked QueryStringSearch._request
+        with mock.patch(
+            "eodag.plugins.search.qssearch.QueryStringSearch._request",
+            autospec=True,
+            return_value=MockResponse(collections_mock_response, 200),
+        ):
+            conf_update_dict = super(StaticStacSearch, self).discover_product_types(
+                **kwargs
+            )
+
+        return conf_update_dict
 
     def query(
         self,
-        product_type: Optional[str] = None,
-        items_per_page: int = DEFAULT_ITEMS_PER_PAGE,
-        page: int = DEFAULT_PAGE,
-        count: bool = True,
+        prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
     ) -> Tuple[List[EOProduct], Optional[int]]:
         """Perform a search on a static STAC Catalog"""
 
+        # only return 1 page if pagination is disabled
+        if (
+            prep.page
+            and prep.page > 1
+            and prep.items_per_page is not None
+            and prep.items_per_page <= 0
+        ):
+            return ([], 0) if prep.count else ([], None)
+
+        product_type = kwargs.get("productType", prep.product_type)
+        # provider product type specific conf
+        self.product_type_def_params = (
+            self.get_product_type_def_params(product_type, **kwargs)
+            if product_type is not None
+            else {}
+        )
+
+        for collection in self.get_collections(prep, **kwargs):
+            # skip empty collection if one is required in api_endpoint
+            if "{collection}" in self.config.api_endpoint and not collection:
+                continue
+            search_endpoint = self.config.api_endpoint.rstrip("/").format(
+                collection=collection
+            )
+
         features = fetch_stac_items(
-            self.config.api_endpoint,
+            search_endpoint,
             recursive=True,
             max_connections=self.config.max_connections,
-            timeout=self.config.timeout,
+            timeout=int(self.config.timeout),
+            ssl_verify=self.config.ssl_verify,
         )
         nb_features = len(features)
         feature_collection = geojson.FeatureCollection(features)
 
-        # save StaticStacSearch._request and mock it to make return loaded static results
-        stacapi_request = self._request
-        self._request = (
-            lambda url, info_message=None, exception_message=None: MockResponse(
-                feature_collection, 200
+        # query on mocked StacSearch._request
+        with mock.patch(
+            "eodag.plugins.search.qssearch.StacSearch._request",
+            autospec=True,
+            return_value=MockResponse(feature_collection, 200),
+        ):
+            eo_products, _ = super(StaticStacSearch, self).query(
+                PreparedSearch(items_per_page=nb_features, page=1, count=True), **kwargs
             )
-        )
-
-        # query on mocked StacSearch
-        eo_products, _ = super(StaticStacSearch, self).query(
-            items_per_page=nb_features, page=1, count=True, **kwargs
-        )
         # filter using query params
         search_result = SearchResult(eo_products)
         # Filter by date
@@ -124,9 +188,10 @@ class StaticStacSearch(StacSearch):
             )
 
         # Filter by geometry
-        if "geometry" in kwargs.keys():
+        geometry = kwargs.pop("geometry", None)
+        if geometry:
             search_result = search_result.crunch(
-                FilterOverlap({"intersects": True}), geometry=kwargs.pop("geometry")
+                FilterOverlap({"intersects": True}), geometry=geometry
             )
         # Filter by cloudCover
         if "cloudCover" in kwargs.keys():
@@ -151,7 +216,8 @@ class StaticStacSearch(StacSearch):
                     FilterProperty({property_key: property_value, "operator": "eq"})
                 )
 
-        # restore plugin._request
-        self._request = stacapi_request
-
-        return search_result.data, len(search_result)
+        return (
+            (search_result.data, len(search_result))
+            if prep.count
+            else (search_result.data, None)
+        )