eodag 3.0.0b3__py3-none-any.whl → 3.1.0__py3-none-any.whl

eodag/plugins/search/stac_list_assets.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+# Copyright 2024, CS GROUP - France, https://www.csgroup.eu/
+#
+# This file is part of EODAG project
+#     https://www.github.com/CS-SI/EODAG
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.
+import logging
+from types import MethodType
+from typing import Any, List
+
+from botocore.exceptions import BotoCoreError
+
+from eodag.api.product import EOProduct  # type: ignore
+from eodag.api.search_result import RawSearchResult
+from eodag.plugins.search.qssearch import StacSearch
+from eodag.utils.exceptions import RequestError
+from eodag.utils.s3 import update_assets_from_s3
+
+logger = logging.getLogger("eodag.search.stac_list_assets")
+
+
+def patched_register_downloader(self, downloader, authenticator):
+    """Add the download information to the product.
+
+    :param self: product to which information should be added
+    :param downloader: The download method that it can use
+                      :class:`~eodag.plugins.download.base.Download` or
+                      :class:`~eodag.plugins.api.base.Api`
+    :param authenticator: The authentication method needed to perform the download
+                         :class:`~eodag.plugins.authentication.base.Authentication`
+    """
+    # register downloader
+    self.register_downloader_only(downloader, authenticator)
+    # and also update assets
+    try:
+        update_assets_from_s3(
+            self, authenticator, getattr(downloader.config, "s3_endpoint", None)
+        )
+    except BotoCoreError as e:
+        raise RequestError.from_error(e, "could not update assets") from e
+
+
+class StacListAssets(StacSearch):
+    """``StacListAssets`` is an extension of :class:`~eodag.plugins.search.qssearch.StacSearch`.
+
+    It executes a Search on given STAC API endpoint and updates assets with content listed by the plugin using
+    ``downloadLink`` :class:`~eodag.api.product._product.EOProduct` property.
+
+    :param provider: provider name
+    :param config: It has the same Search plugin configuration as :class:`~eodag.plugins.search.qssearch.StacSearch` and
+                   one additional parameter:
+
+        * :attr:`~eodag.config.PluginConfig.s3_endpoint` (``str``): s3 endpoint if not hosted on AWS
+    """
+
+    def __init__(self, provider, config):
+        super(StacSearch, self).__init__(provider, config)
+
+    def normalize_results(
+        self, results: RawSearchResult, **kwargs: Any
+    ) -> List[EOProduct]:
+        """Build EOProducts from provider results"""
+
+        products = super(StacSearch, self).normalize_results(results, **kwargs)
+
+        for product in products:
+            # backup original register_downloader to register_downloader_only
+            product.register_downloader_only = product.register_downloader
+            # patched register_downloader that will also update assets
+            product.register_downloader = MethodType(
+                patched_register_downloader, product
+            )
+
+        return products

eodag/plugins/search/static_stac_search.py

@@ -18,7 +18,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, cast
+from typing import TYPE_CHECKING, Any, Optional
 from unittest import mock
 
 import geojson
@@ -44,23 +44,23 @@ logger = logging.getLogger("eodag.search.static_stac_search")
 class StaticStacSearch(StacSearch):
     """Static STAC Catalog search plugin
 
-    The available configuration parameters for this plugin are
-    (to be set in provider configuration):
+    This plugin first loads all STAC items found in the catalog, and converts them to
+    EOProducts using :class:`~eodag.plugins.search.qssearch.StacSearch`.
+    Then it uses crunchers to only keep products matching query parameters.
 
-        - **api_endpoint**: (mandatory) path to the catalog (url or local system path)
+    The plugin inherits the configuration parameters from :class:`~eodag.plugins.search.qssearch.PostJsonSearch`
+    (via the :class:`~eodag.plugins.search.qssearch.StacSearch` inheritance) with the following particularities:
 
-        - **max_connections**: (optional) Maximum number of connections for HTTP requests,
-          defaut is 100.
+    :param provider: provider name
+    :param config: Search plugin configuration:
 
-        - **timeout**: (mandatory) Timeout in seconds for each internal HTTP request,
-          default is 5.
+        * :attr:`~eodag.config.PluginConfig.api_endpoint` (``str``) (**mandatory**): path to the catalog;
+          in contrast to the api_endpoint for other plugin types this can be a url or local system path.
+        * :attr:`~eodag.config.PluginConfig.max_connections` (``int``): Maximum number of concurrent
+          connections for HTTP requests; default: ``100``
+        * :attr:`~eodag.config.PluginConfig.timeout` (``int``): Timeout in seconds for each
+          internal HTTP request; default: ``5``
 
-    This plugin first loads all STAC items found in the catalog, and converts them to
-    EOProducts using StacSearch.
-    Then it uses crunchers to only keep products matching query parameters.
-
-    :param provider: An eodag providers configuration dictionary
-    :param config: Path to the user configuration file
     """
 
     def __init__(self, provider: str, config: PluginConfig) -> None:
@@ -88,19 +88,18 @@ class StaticStacSearch(StacSearch):
             getattr(self.config, "discover_product_types", {}).get("fetch_url")
             == "{api_endpoint}/../collections"
         ):
-            self.config.discover_product_types = {"fetch_url": None}
+            self.config.discover_product_types = {}
 
-    def discover_product_types(self, **kwargs: Any) -> Optional[Dict[str, Any]]:
+    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
         """
-        fetch_url = cast(
-            str,
-            self.config.discover_product_types["fetch_url"].format(
-                **self.config.__dict__
-            ),
-        )
+        unformatted_fetch_url = self.config.discover_product_types.get("fetch_url")
+        if unformatted_fetch_url is None:
+            return None
+        fetch_url = unformatted_fetch_url.format(**self.config.__dict__)
+
         collections = fetch_stac_collections(
             fetch_url,
             collection=kwargs.get("q"),
@@ -128,7 +127,7 @@ class StaticStacSearch(StacSearch):
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> Tuple[List[EOProduct], Optional[int]]:
+    ) -> tuple[list[EOProduct], Optional[int]]:
         """Perform a search on a static STAC Catalog"""
 
         # only return 1 page if pagination is disabled
@@ -143,7 +142,7 @@ class StaticStacSearch(StacSearch):
         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)
+            self.get_product_type_def_params(product_type, format_variables=kwargs)
             if product_type is not None
             else {}
         )