eodag 3.9.1__py3-none-any.whl → 4.0.0a1__py3-none-any.whl

eodag/rest/stac.py

@@ -1,1032 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright 2018, CS Systemes d'Information, 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.
-from __future__ import annotations
-
-import logging
-import os
-import warnings
-from collections import defaultdict
-from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Any, Optional
-from urllib.parse import (
-    parse_qs,
-    quote,
-    urlencode,
-    urlparse,
-    urlsplit,
-    urlunparse,
-    urlunsplit,
-)
-
-import geojson
-from jsonpath_ng.jsonpath import Child
-from shapely.geometry import Polygon
-
-from eodag.api.product.metadata_mapping import (
-    DEFAULT_METADATA_MAPPING,
-    format_metadata,
-    get_metadata_path,
-)
-from eodag.rest.config import Settings
-from eodag.rest.types.stac_search import SearchPostRequest
-from eodag.rest.utils.rfc3339 import str_to_interval
-from eodag.utils import (
-    deepcopy,
-    dict_items_recursive_apply,
-    format_dict_items,
-    guess_file_type,
-    jsonpath_parse_dict_items,
-    string_to_jsonpath,
-    update_nested_dict,
-)
-from eodag.utils.exceptions import (
-    NoMatchingProductType,
-    NotAvailableError,
-    RequestError,
-    TimeOutError,
-    ValidationError,
-)
-from eodag.utils.requests import fetch_json
-
-if TYPE_CHECKING:
-    from eodag.api.core import EODataAccessGateway
-    from eodag.api.product import EOProduct
-    from eodag.api.search_result import SearchResult
-
-
-warnings.warn(
-    "The module `eodag.rest.stac` is deprecated since v3.9.0 and will be removed in a future version. "
-    "The STAC server has moved to https://github.com/CS-SI/stac-fastapi-eodag",
-    category=DeprecationWarning,
-    stacklevel=2,
-)
-
-logger = logging.getLogger("eodag.rest.stac")
-
-# fields not to put in item properties
-COLLECTION_PROPERTIES = [
-    "abstract",
-    "instrument",
-    "platform",
-    "platformSerialIdentifier",
-    "processingLevel",
-    "sensorType",
-    "md5",
-    "license",
-    "title",
-    "missionStartDate",
-    "missionEndDate",
-    "keywords",
-    "stacCollection",
-    "alias",
-    "productType",
-]
-IGNORED_ITEM_PROPERTIES = [
-    "_id",
-    "id",
-    "keyword",
-    "quicklook",
-    "thumbnail",
-    "downloadLink",
-    "orderLink",
-    "_dc_qs",
-    "qs",
-    "defaultGeometry",
-    "_date",
-    "productType",
-]
-
-
-def _quote_url_path(url: str) -> str:
-    parsed = urlsplit(url)
-    path = quote(parsed.path)
-    components = (parsed.scheme, parsed.netloc, path, parsed.query, parsed.fragment)
-    return urlunsplit(components)
-
-
-class StacCommon:
-    """Stac common object
-
-    :param url: Requested URL
-    :param stac_config: STAC configuration from stac.yml conf file
-    :param provider: (optional) Chosen provider
-    :param eodag_api: EODAG python API instance
-    :param root: (optional) API root
-    """
-
-    def __init__(
-        self,
-        url: str,
-        stac_config: dict[str, Any],
-        provider: Optional[str],
-        eodag_api: EODataAccessGateway,
-        root: str = "/",
-    ) -> None:
-        self.url = url.rstrip("/") if len(url) > 1 else url
-        self.stac_config = stac_config
-        self.provider = provider
-        self.eodag_api = eodag_api
-        self.root = root.rstrip("/") if len(root) > 1 else root
-
-        self.data: dict[str, Any] = {}
-
-    def update_data(self, data: dict[str, Any]) -> None:
-        """Updates data using given input STAC dict data
-
-        :param data: Catalog data (parsed STAC dict)
-        """
-        self.data.update(data)
-
-        # bbox: str to float
-        if (
-            "extent" in self.data.keys()
-            and "spatial" in self.data["extent"].keys()
-            and "bbox" in self.data["extent"]["spatial"].keys()
-        ):
-            for i, bbox in enumerate(self.data["extent"]["spatial"]["bbox"]):
-                self.data["extent"]["spatial"]["bbox"][i] = [float(x) for x in bbox]
-
-        def apply_method_none(_: str, v: str) -> Optional[str]:
-            """ "None" values to None"""
-            return None if v == "None" else v
-
-        self.data = dict_items_recursive_apply(self.data, apply_method_none)
-
-        def apply_method_ids(k, v):
-            """ids and titles as str"""
-            return str(v) if k in ["title", "id"] else v
-
-        self.data = dict_items_recursive_apply(self.data, apply_method_ids)
-
-        # empty stac_extensions: "" to []
-        if not self.data.get("stac_extensions", True):
-            self.data["stac_extensions"] = []
-
-    @staticmethod
-    def get_stac_extension(
-        url: str, stac_config: dict[str, Any], extension: str, **kwargs: Any
-    ) -> dict[str, str]:
-        """Parse STAC extension from config and return as dict
-
-        :param url: Requested URL
-        :param stac_config: STAC configuration from stac.yml conf file
-        :param extension: Extension name
-        :param kwargs: Additional variables needed for parsing extension
-        :returns: STAC extension as dictionary
-        """
-        extension_model = deepcopy(stac_config).get("extensions", {}).get(extension, {})
-
-        # parse f-strings
-        format_args = deepcopy(stac_config)
-        format_args["extension"] = {
-            "url": url,
-            "properties": kwargs.get("properties", {}),
-        }
-        return format_dict_items(extension_model, **format_args)
-
-    def get_provider_dict(self, provider: str) -> dict[str, Any]:
-        """Generate STAC provider dict"""
-        provider_config = next(
-            p
-            for p in self.eodag_api.providers_config.values()
-            if provider in [p.name, getattr(p, "group", None)]
-        )
-        return {
-            "name": getattr(provider_config, "group", provider_config.name),
-            "description": getattr(provider_config, "description", None),
-            "roles": getattr(provider_config, "roles", None),
-            "url": getattr(provider_config, "url", None),
-            "priority": getattr(provider_config, "priority", None),
-        }
-
-
-class StacItem(StacCommon):
-    """Stac item object
-
-    :param url: Requested URL
-    :param stac_config: STAC configuration from stac.yml conf file
-    :param provider: (optional) Chosen provider
-    :param eodag_api: EODAG python API instance
-    :param root: (optional) API root
-    """
-
-    def __init__(
-        self,
-        url: str,
-        stac_config: dict[str, Any],
-        provider: Optional[str],
-        eodag_api: EODataAccessGateway,
-        root: str = "/",
-    ) -> None:
-        super(StacItem, self).__init__(
-            url=url,
-            stac_config=stac_config,
-            provider=provider,
-            eodag_api=eodag_api,
-            root=root,
-        )
-
-    def __get_item_list(
-        self, search_results: SearchResult, catalog: dict[str, Any]
-    ) -> list[dict[str, Any]]:
-        """Build STAC items list from EODAG search results
-
-        :param search_results: EODAG search results
-        :param catalog: STAC catalog dict used for parsing item metadata
-        :returns: STAC item dicts list
-        """
-        if len(search_results) <= 0:
-            return []
-
-        item_model = self.__filter_item_model_properties(
-            self.stac_config["item"], str(search_results[0].product_type)
-        )
-
-        # check if some items need to be converted
-        need_conversion: dict[str, Any] = {}
-        for k, v in item_model["properties"].items():
-            if isinstance(v, str):
-                conversion, item_model["properties"][k] = get_metadata_path(
-                    item_model["properties"][k]
-                )
-                if conversion is not None:
-                    need_conversion[k] = conversion
-                    # convert str to jsonpath if needed
-                    item_model["properties"][k] = string_to_jsonpath(
-                        k, item_model["properties"][k]
-                    )
-
-        item_props = [
-            p.right.fields[0]
-            for p in item_model["properties"].values()
-            if isinstance(p, Child)
-        ]
-        ignored_props = COLLECTION_PROPERTIES + item_props + IGNORED_ITEM_PROPERTIES
-
-        item_list: list[dict[str, Any]] = []
-        for product in search_results:
-            product_dict = deepcopy(product.__dict__)
-
-            product_item: dict[str, Any] = jsonpath_parse_dict_items(
-                item_model,
-                {
-                    "product": product_dict,
-                    "providers": [self.get_provider_dict(product.provider)],
-                },
-            )
-
-            # add additional item props
-            for p in set(product.properties) - set(ignored_props):
-                prefix = getattr(
-                    self.eodag_api.providers_config[product.provider],
-                    "group",
-                    product.provider,
-                )
-                key = p if ":" in p else f"{prefix}:{p}"
-                product_item["properties"][key] = product.properties[p]
-
-            # parse download link
-            downloadlink_href = (
-                f"{catalog['url']}/items/{product.properties['id']}/download"
-            )
-            _dc_qs = product.properties.get("_dc_qs")
-            url_parts = urlparse(downloadlink_href)
-            query_dict = parse_qs(url_parts.query)
-            without_arg_url = (
-                f"{url_parts.scheme}://{url_parts.netloc}{url_parts.path}"
-                if url_parts.scheme
-                else f"{url_parts.netloc}{url_parts.path}"
-            )
-            # add provider to query-args
-            p_config = self.eodag_api.providers_config[product.provider]
-            query_dict.update(provider=[getattr(p_config, "group", p_config.name)])
-            # add datacube query-string to query-args
-            if _dc_qs:
-                query_dict.update(_dc_qs=[_dc_qs])
-            if query_dict:
-                downloadlink_href = (
-                    f"{without_arg_url}?{urlencode(query_dict, doseq=True)}"
-                )
-
-            # generate STAC assets
-            product_item["assets"] = self._get_assets(
-                product, downloadlink_href, without_arg_url, query_dict, _dc_qs
-            )
-
-            # apply conversion if needed
-            for prop_key, prop_val in need_conversion.items():
-                conv_func, conv_args = prop_val
-                # colon `:` in key breaks format() method, hide it
-                formatable_prop_key = prop_key.replace(":", "")
-                if conv_args is not None:
-                    product_item["properties"][prop_key] = format_metadata(
-                        "{%s#%s(%s)}" % (formatable_prop_key, conv_func, conv_args),
-                        **{formatable_prop_key: product_item["properties"][prop_key]},
-                    )
-                else:
-                    product_item["properties"][prop_key] = format_metadata(
-                        "{%s#%s}" % (formatable_prop_key, conv_func),
-                        **{formatable_prop_key: product_item["properties"][prop_key]},
-                    )
-
-            # parse f-strings
-            format_args = deepcopy(self.stac_config)
-            format_args["catalog"] = catalog
-            format_args["item"] = product_item
-            product_item = format_dict_items(product_item, **format_args)
-            product_item["bbox"] = [float(i) for i in product_item["bbox"]]
-
-            # transform shapely geometry to geojson
-            product_item["geometry"] = geojson.loads(
-                geojson.dumps(product_item["geometry"])
-            )
-
-            # remove empty properties
-            product_item = self.__filter_item_properties_values(product_item)
-
-            # quote invalid characters in links
-            for link in product_item["links"]:
-                link["href"] = _quote_url_path(link["href"])
-
-            # update item link with datacube query-string
-            if _dc_qs or self.provider:
-                url_parts = urlparse(str(product_item["links"][0]["href"]))
-                without_arg_url = (
-                    f"{url_parts.scheme}://{url_parts.netloc}{url_parts.path}"
-                    if url_parts.scheme
-                    else f"{url_parts.netloc}{url_parts.path}"
-                )
-                product_item["links"][0][
-                    "href"
-                ] = f"{without_arg_url}?{urlencode(query_dict, doseq=True)}"
-
-            item_list.append(product_item)
-
-        return item_list
-
-    def _get_assets(
-        self,
-        product: EOProduct,
-        downloadlink_href: str,
-        without_arg_url: str,
-        query_dict: Optional[dict[str, Any]] = None,
-        _dc_qs: Optional[str] = None,
-    ) -> dict[str, Any]:
-        assets: dict[str, Any] = {}
-        settings = Settings.from_environment()
-
-        if _dc_qs:
-            parsed = urlparse(product.remote_location)
-            fragments = parsed.fragment.split("?")
-            parsed = parsed._replace(fragment=f"{fragments[0]}?_dc_qs={_dc_qs}")
-            origin_href = urlunparse(parsed)
-        else:
-            origin_href = product.remote_location
-
-        # update download link with up-to-date query-args
-        quoted_href = _quote_url_path(
-            downloadlink_href
-        )  # quote invalid characters in url
-        assets["downloadLink"] = {
-            "title": "Download link",
-            "href": quoted_href,
-            "type": "application/zip",
-        }
-
-        if not origin_href.startswith(tuple(settings.origin_url_blacklist)):
-            assets["downloadLink"]["alternate"] = {
-                "origin": {
-                    "title": "Origin asset link",
-                    "href": origin_href,
-                }
-            }
-
-        if "storageStatus" in product.properties:
-            assets["downloadLink"]["storage:tier"] = product.properties["storageStatus"]
-
-        # move origin asset urls to alternate links and replace with eodag-server ones
-        if product.assets:
-            origin_assets = product.assets.as_dict()
-            # replace origin asset urls with eodag-server ones
-            for asset_key, asset_value in origin_assets.items():
-                # use origin asset as default
-                assets[asset_key] = asset_value
-                # origin assets as alternate link
-                if not asset_value["href"].startswith(
-                    tuple(settings.origin_url_blacklist)
-                ):
-                    assets[asset_key]["alternate"] = {
-                        "origin": {
-                            "title": "Origin asset link",
-                            "href": asset_value["href"],
-                        }
-                    }
-                # use server-mode assets download links
-                asset_value["href"] = without_arg_url
-                if query_dict:
-                    assets[asset_key][
-                        "href"
-                    ] += f"/{asset_key}?{urlencode(query_dict, doseq=True)}"
-                else:
-                    assets[asset_key]["href"] += f"/{asset_key}"
-                if asset_type := asset_value.get("type"):
-                    assets[asset_key]["type"] = asset_type
-                    if origin := assets[asset_key].get("alternate", {}).get("origin"):
-                        origin["type"] = asset_type
-                asset_value["href"] = _quote_url_path(asset_value["href"])
-
-        if thumbnail_url := product.properties.get(
-            "quicklook", product.properties.get("thumbnail")
-        ):
-            assets["thumbnail"] = {
-                "title": "Thumbnail",
-                "href": thumbnail_url,
-                "role": "thumbnail",
-            }
-            if mime_type := guess_file_type(thumbnail_url):
-                assets["thumbnail"]["type"] = mime_type
-        return assets
-
-    def get_stac_items(
-        self,
-        search_results: SearchResult,
-        total: int,
-        catalog: dict[str, Any],
-        next_link: Optional[dict[str, Any]],
-    ) -> dict[str, Any]:
-        """Build STAC items from EODAG search results
-
-        :param search_results: EODAG search results
-        :param catalog: STAC catalog dict used for parsing item metadata
-        :returns: Items dictionary
-        """
-        items_model = deepcopy(self.stac_config["items"])
-
-        if "?" in self.url:
-            # search endpoint: use page url as self link
-            for i, _ in enumerate(items_model["links"]):
-                if items_model["links"][i]["rel"] == "self":
-                    items_model["links"][i]["href"] = catalog["url"]
-
-        timestamp = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
-
-        # parse jsonpath
-        items = jsonpath_parse_dict_items(
-            items_model,
-            {
-                "numberMatched": total,
-                "numberReturned": len(search_results),
-                "timeStamp": timestamp,
-            },
-        )
-        # parse f-strings
-        format_args = deepcopy(self.stac_config)
-        format_args["catalog"] = catalog
-        items = format_dict_items(items, **format_args)
-
-        if next_link:
-            items["links"].append(next_link)
-
-        # provide static catalog to build features
-        if "search?" in catalog["url"]:
-            catalog["url"] = os.path.join(
-                catalog["url"].split("search?")[0],
-                "collections",
-                catalog["id"],
-            )
-        else:
-            catalog["url"] = catalog["url"].split("?")[0]
-        items["features"] = self.__get_item_list(search_results, catalog)
-
-        self.update_data(items)
-        return self.data
-
-    def __filter_item_model_properties(
-        self, item_model: dict[str, Any], product_type: str
-    ) -> dict[str, Any]:
-        """Filter item model depending on product type metadata and its extensions.
-        Removes not needed parameters, and adds supplementary ones as
-        part of oseo extension.
-
-        :param item_model: Item model from stac_config
-        :param product_type: Product type
-        :returns: Filtered item model
-        """
-        try:
-            product_type_dict = [
-                pt
-                for pt in self.eodag_api.list_product_types(
-                    provider=self.provider, fetch_providers=False
-                )
-                if pt["ID"] == product_type
-                or ("alias" in pt and pt["alias"] == product_type)
-            ][0]
-        except IndexError as e:
-            raise NoMatchingProductType(
-                f"Product type {product_type} not available for {self.provider}"
-            ) from e
-
-        result_item_model = deepcopy(item_model)
-        result_item_model["stac_extensions"] = list(
-            self.stac_config["stac_extensions"].values()
-        )
-
-        # build jsonpath for eodag product default properties and adapt path
-        eodag_properties_dict = {
-            k: string_to_jsonpath(k, v.replace("$.", "$.product."))
-            for k, v in DEFAULT_METADATA_MAPPING.items()
-            if "$.properties." in v
-        }
-        # add missing properties as oseo:missingProperty
-        for k, v in eodag_properties_dict.items():
-            if (
-                v not in result_item_model["properties"].values()
-                and k not in self.stac_config["metadata_ignore"]
-                and not any(
-                    k in str(prop) for prop in result_item_model["properties"].values()
-                )
-            ):
-                result_item_model["properties"]["oseo:" + k] = string_to_jsonpath(k, v)
-
-        # Filter out unneeded extensions
-        if product_type_dict.get("sensorType", "RADAR") != "RADAR":
-            result_item_model["stac_extensions"].remove(
-                self.stac_config["stac_extensions"]["sar"]
-            )
-
-        # Filter out unneeded properties
-        extensions_prefixes = [
-            k
-            for k, v in self.stac_config["stac_extensions"].items()
-            if v in result_item_model["stac_extensions"]
-        ]
-        for k, v in item_model["properties"].items():
-            # remove key if extension not in stac_extensions
-            if ":" in k and k.split(":")[0] not in extensions_prefixes:
-                result_item_model["properties"].pop(k, None)
-
-        return result_item_model
-
-    def __filter_item_properties_values(self, item: dict[str, Any]) -> dict[str, Any]:
-        """Removes empty properties, unused extensions, and add missing extensions
-
-        :param item: STAC item data
-        :returns: Filtered item model
-        """
-        all_extensions_dict: dict[str, str] = deepcopy(
-            self.stac_config["stac_extensions"]
-        )
-        # parse f-strings with root
-        all_extensions_dict = format_dict_items(
-            all_extensions_dict, **{"catalog": {"root": self.root}}
-        )
-
-        item["stac_extensions"] = []
-        # dict to list of keys to permit pop() while iterating
-        for k in list(item["properties"]):
-            extension_prefix: str = k.split(":")[0]
-
-            if item["properties"][k] is None:
-                item["properties"].pop(k, None)
-            # feed found extensions list
-            elif (
-                extension_prefix in all_extensions_dict.keys()
-                and all_extensions_dict[extension_prefix] not in item["stac_extensions"]
-            ):
-                # append path from item extensions
-                item["stac_extensions"].append(all_extensions_dict[extension_prefix])
-
-        return item
-
-    def get_stac_item_from_product(self, product: EOProduct) -> dict[str, Any]:
-        """Build STAC item from EODAG product
-
-        :param product: EODAG product
-        :returns: STAC item
-        """
-        product_type = str(product.product_type)
-
-        item_model = self.__filter_item_model_properties(
-            self.stac_config["item"], product_type
-        )
-
-        catalog = StacCatalog(
-            url=self.url.split("/items")[0],
-            stac_config=self.stac_config,
-            root=self.root,
-            provider=self.provider,
-            eodag_api=self.eodag_api,
-            collection=product_type,
-        )
-
-        product_dict = deepcopy(product.__dict__)
-        product_dict["assets"] = product.assets.as_dict()
-
-        # parse jsonpath
-        product_item = jsonpath_parse_dict_items(
-            item_model,
-            {
-                "product": product_dict,
-                "providers": [self.get_provider_dict(product.provider)],
-            },
-        )
-        # parse f-strings
-        format_args = deepcopy(self.stac_config)
-        format_args["catalog"] = {
-            **catalog.data,
-            **{"url": catalog.url, "root": catalog.root},
-        }
-        format_args["item"] = product_item
-        product_item = format_dict_items(product_item, **format_args)
-        product_item["bbox"] = [float(i) for i in product_item["bbox"]]
-
-        # remove empty properties
-        product_item = self.__filter_item_properties_values(product_item)
-
-        self.update_data(product_item)
-        return self.data
-
-
-class StacCollection(StacCommon):
-    """Stac collection object
-
-    :param url: Requested URL
-    :param stac_config: STAC configuration from stac.yml conf file
-    :param provider: (optional) Chosen provider
-    :param eodag_api: EODAG python API instance
-    :param root: (optional) API root
-    """
-
-    # External STAC collections
-    ext_stac_collections: dict[str, dict[str, Any]] = dict()
-
-    @classmethod
-    def fetch_external_stac_collections(cls, eodag_api: EODataAccessGateway) -> None:
-        """Load external STAC collections
-
-        :param eodag_api: EODAG python API instance
-        """
-        list_product_types = eodag_api.list_product_types(fetch_providers=False)
-        for product_type in list_product_types:
-            ext_stac_collection_path = product_type.get("stacCollection")
-            if not ext_stac_collection_path:
-                continue
-            logger.info(f"Fetching external STAC collection for {product_type['ID']}")
-
-            try:
-                ext_stac_collection = fetch_json(ext_stac_collection_path)
-            except (RequestError, TimeOutError) as e:
-                logger.debug(e)
-                logger.warning(
-                    f"Could not read remote external STAC collection from {ext_stac_collection_path}",
-                )
-                ext_stac_collection = {}
-
-            cls.ext_stac_collections[product_type["ID"]] = ext_stac_collection
-
-    def __init__(
-        self,
-        url: str,
-        stac_config: dict[str, Any],
-        provider: Optional[str],
-        eodag_api: EODataAccessGateway,
-        root: str = "/",
-    ) -> None:
-        super(StacCollection, self).__init__(
-            url=url,
-            stac_config=stac_config,
-            provider=provider,
-            eodag_api=eodag_api,
-            root=root,
-        )
-
-    def __list_product_type_providers(self, product_type: dict[str, Any]) -> list[str]:
-        """Retrieve a list of providers for a given product type.
-
-        :param product_type: Dictionary containing information about the product type.
-        :return: A list of provider names.
-        """
-        if self.provider:
-            return [self.provider]
-
-        return [
-            plugin.provider
-            for plugin in self.eodag_api._plugins_manager.get_search_plugins(
-                product_type=product_type.get("_id", product_type["ID"])
-            )
-        ]
-
-    def __generate_stac_collection(
-        self, collection_model: Any, product_type: dict[str, Any]
-    ) -> dict[str, Any]:
-        """Generate a STAC collection dictionary for a given product type.
-
-        :param collection_model: The base model for the STAC collection.
-        :param product_type: Dictionary containing information about the product type.
-        :return: A dictionary representing the STAC collection for the given product type.
-        """
-        providers = self.__list_product_type_providers(product_type)
-
-        providers_dict: dict[str, dict[str, Any]] = {}
-        for provider in providers:
-            p_dict = self.get_provider_dict(provider)
-            providers_dict.setdefault(p_dict["name"], p_dict)
-        providers_list = list(providers_dict.values())
-
-        # parse jsonpath
-        product_type_collection = jsonpath_parse_dict_items(
-            collection_model,
-            {
-                "product_type": product_type,
-                "providers": providers_list,
-            },
-        )
-        # override EODAG's collection with the external collection
-        ext_stac_collection = deepcopy(
-            self.ext_stac_collections.get(product_type["ID"], {})
-        )
-
-        # update links (keep eodag links as defaults)
-        ext_stac_collection.setdefault("links", {})
-        for link in product_type_collection["links"]:
-            ext_stac_collection["links"] = [
-                x for x in ext_stac_collection["links"] if x["rel"] != link["rel"]
-            ]
-            ext_stac_collection["links"].append(link)
-
-        # merge "summaries"
-        ext_stac_collection["summaries"] = {
-            k: v
-            for k, v in {
-                **ext_stac_collection.get("summaries", {}),
-                **product_type_collection["summaries"],
-            }.items()
-            if v and any(v)
-        }
-
-        # merge "keywords" lists
-        try:
-            ext_stac_collection["keywords"] = [
-                k
-                for k in set(
-                    ext_stac_collection.get("keywords", [])
-                    + product_type_collection["keywords"]
-                )
-                if k is not None
-            ]
-        except TypeError as e:
-            logger.warning(
-                f"Could not merge keywords from external collection for {product_type['ID']}: {str(e)}"
-            )
-            logger.debug(
-                f"External collection keywords: {str(ext_stac_collection.get('keywords'))}, ",
-                f"Product type keywords: {str(product_type_collection['keywords'])}",
-            )
-
-        product_type_collection.update(ext_stac_collection)
-
-        # parse f-strings
-        format_args = deepcopy(self.stac_config)
-        format_args["collection"] = {
-            **product_type_collection,
-            **{
-                "url": self.url
-                if self.url.endswith(product_type["ID"])
-                else f"{self.url}/{product_type['ID']}",
-                "root": self.root,
-            },
-        }
-        product_type_collection = format_dict_items(
-            product_type_collection, **format_args
-        )
-
-        return product_type_collection
-
-    def get_collection_list(
-        self,
-        collection: Optional[str] = None,
-        q: Optional[str] = None,
-        platform: Optional[str] = None,
-        instrument: Optional[str] = None,
-        constellation: Optional[str] = None,
-        datetime: Optional[str] = None,
-        bbox: Optional[str] = None,
-    ) -> list[dict[str, Any]]:
-        """Build STAC collections list
-
-        :param filters: (optional) Additional filters for collections search
-        :returns: STAC collection dicts list
-        """
-        collection_model = deepcopy(self.stac_config["collection"])
-
-        start, end = str_to_interval(datetime)
-
-        all_pt = self.eodag_api.list_product_types(
-            provider=self.provider, fetch_providers=False
-        )
-
-        if any((collection, q, platform, instrument, constellation, datetime)):
-            try:
-                guessed_product_types = self.eodag_api.guess_product_type(
-                    free_text=q,
-                    platformSerialIdentifier=platform,
-                    instrument=instrument,
-                    platform=constellation,
-                    productType=collection,
-                    missionStartDate=start.isoformat() if start else None,
-                    missionEndDate=end.isoformat() if end else None,
-                )
-            except NoMatchingProductType:
-                product_types = []
-            else:
-                product_types = [
-                    pt for pt in all_pt if pt["ID"] in guessed_product_types
-                ]
-        else:
-            product_types = all_pt
-
-        _bbox_poly = None
-        if bbox:
-            try:
-                _bbox = [float(x) for x in bbox.split(",")]
-                SearchPostRequest.validate_bbox(_bbox)  # type: ignore
-                _bbox_poly = Polygon.from_bounds(*_bbox)
-            except ValueError as e:
-                raise ValidationError(f"Wrong bbox: {e}")
-
-        # list product types with all metadata using guessed ids
-        collection_list: list[dict[str, Any]] = []
-        for product_type in product_types:
-            stac_collection = self.__generate_stac_collection(
-                collection_model, product_type
-            )
-            # Apply bbox filter
-            if _bbox_poly:
-                _other_bbox_poly = Polygon.from_bounds(
-                    *stac_collection["extent"]["spatial"]["bbox"][0]
-                )
-                if _bbox_poly.intersects(_other_bbox_poly):
-                    collection_list.append(stac_collection)
-            else:
-                collection_list.append(stac_collection)
-
-        return collection_list
-
-
-class StacCatalog(StacCommon):
-    """Stac Catalog object
-
-    :param url: Requested URL
-    :param stac_config: STAC configuration from stac.yml conf file
-    :param provider: Chosen provider
-    :param eodag_api: EODAG python API instance
-    :param root: (optional) API root
-    :param collection: (optional) product type id
-    """
-
-    def __init__(
-        self,
-        url: str,
-        stac_config: dict[str, Any],
-        provider: Optional[str],
-        eodag_api: EODataAccessGateway,
-        root: str = "/",
-        collection: Optional[str] = None,
-    ) -> None:
-        super(StacCatalog, self).__init__(
-            url=url,
-            stac_config=stac_config,
-            provider=provider,
-            eodag_api=eodag_api,
-            root=root,
-        )
-        self.data = {}
-
-        self.shp_location_config = eodag_api.locations_config
-        self.search_args: dict[str, Any] = {}
-        self.children: list[dict[str, Any]] = []
-
-        self.catalog_config = deepcopy(stac_config["catalog"])
-
-        self.__update_data_from_catalog_config({"model": {}})
-
-        # expand links
-        self.parent = "/".join(self.url.rstrip("/").split("/")[:-1])
-        if self.parent != self.root:
-            self.data["links"].append({"rel": "parent", "href": self.parent})
-        if self.children:
-            self.data["links"] += self.children
-
-        # build catalog
-        self.__build_stac_catalog(collection)
-
-    def __update_data_from_catalog_config(self, catalog_config: dict[str, Any]) -> bool:
-        """Updates configuration and data using given input catalog config
-
-        :param catalog_config: Catalog config, from yml stac_config[catalogs]
-        """
-        model = catalog_config["model"]
-
-        self.catalog_config = update_nested_dict(self.catalog_config, catalog_config)
-
-        # parse f-strings
-        # defaultdict usage will return "" for missing keys in format_args
-        format_args = deepcopy(self.stac_config)
-        format_args["catalog"] = defaultdict(
-            str, dict(model, **{"root": self.root, "url": self.url})
-        )
-        # use existing data as parent_catalog
-        format_args["parent_catalog"] = defaultdict(str, **self.data)
-        parsed_model = format_dict_items(self.catalog_config["model"], **format_args)
-
-        self.update_data(parsed_model)
-
-        return True
-
-    def __build_stac_catalog(self, collection: Optional[str] = None) -> StacCatalog:
-        """Build nested catalog from catalag list
-
-        :param collection: (optional) product type id
-        :returns: This catalog obj
-        """
-        settings = Settings.from_environment()
-
-        if not collection:
-            # Build root catalog combined with landing page
-            self.__update_data_from_catalog_config(
-                {
-                    "model": {
-                        **deepcopy(self.stac_config["landing_page"]),
-                        **{
-                            "provider": self.provider,
-                            "id": settings.stac_api_landing_id,
-                            "title": settings.stac_api_title,
-                            "description": settings.stac_api_description,
-                        },
-                    }
-                }
-            )
-        else:
-            self.set_stac_product_type_by_id(collection)
-        return self
-
-    def set_stac_product_type_by_id(
-        self, product_type: str, **_: Any
-    ) -> dict[str, Any]:
-        """Updates catalog with given product_type
-
-        :param product_type: Product type
-        """
-        collections = StacCollection(
-            url=self.url,
-            stac_config=self.stac_config,
-            provider=self.provider,
-            eodag_api=self.eodag_api,
-            root=self.root,
-        ).get_collection_list(collection=product_type)
-
-        if not collections:
-            raise NotAvailableError(f"Collection {product_type} does not exist.")
-
-        cat_model = {
-            "id": "{collection[id]}",
-            "title": "{collection[title]}",
-            "description": "{collection[description]}",
-            "extent": "{collection[extent]}",
-            "crs": "http://www.opengis.net/def/crs/OGC/1.3/CRS84",
-            "keywords": "{collection[keywords]}",
-            "license": "{collection[license]}",
-            "providers": "{collection[providers]}",
-            "summaries": "{collection[summaries]}",
-        }
-        # parse f-strings
-        format_args = deepcopy(self.stac_config)
-        format_args["catalog"] = defaultdict(str, **self.data)
-        format_args["collection"] = collections[0]
-        try:
-            parsed_dict: dict[str, Any] = format_dict_items(cat_model, **format_args)
-        except Exception:
-            logger.error("Could not format product_type catalog")
-            raise
-
-        self.update_data(parsed_dict)
-
-        # update search args
-        self.search_args.update({"productType": product_type})
-
-        return parsed_dict