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

eodag/rest/stac.py

@@ -21,37 +21,43 @@ import logging
 import os
 from collections import defaultdict
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, cast
-from urllib.parse import parse_qs, urlencode, urlparse
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from urllib.parse import (
+    parse_qs,
+    quote,
+    urlencode,
+    urlparse,
+    urlsplit,
+    urlunparse,
+    urlunsplit,
+)
 
-import dateutil.parser
 import geojson
-import shapefile
-from dateutil import tz
-from dateutil.relativedelta import relativedelta
-from shapely.geometry import shape
-from shapely.geometry.base import BaseGeometry
-from shapely.ops import unary_union
+from jsonpath_ng.jsonpath import Child
 
 from eodag.api.product.metadata_mapping import (
     DEFAULT_METADATA_MAPPING,
     format_metadata,
     get_metadata_path,
 )
+from eodag.rest.config import Settings
+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,
-    urljoin,
 )
 from eodag.utils.exceptions import (
     NoMatchingProductType,
     NotAvailableError,
-    ValidationError,
+    RequestError,
+    TimeOutError,
 )
+from eodag.utils.requests import fetch_json
 
 if TYPE_CHECKING:
     from eodag.api.core import EODataAccessGateway
@@ -61,23 +67,52 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger("eodag.rest.stac")
 
-DEFAULT_MISSION_START_DATE = "2015-01-01T00:00:00Z"
-STAC_CATALOGS_PREFIX = "catalogs"
+# fields not to put in item properties
+COLLECTION_PROPERTIES = [
+    "abstract",
+    "instrument",
+    "platform",
+    "platformSerialIdentifier",
+    "processingLevel",
+    "sensorType",
+    "md5",
+    "license",
+    "title",
+    "missionStartDate",
+    "missionEndDate",
+    "keywords",
+    "stacCollection",
+]
+IGNORED_ITEM_PROPERTIES = [
+    "_id",
+    "id",
+    "keyword",
+    "quicklook",
+    "thumbnail",
+    "downloadLink",
+    "orderLink",
+    "_dc_qs",
+    "qs",
+    "defaultGeometry",
+    "_date",
+]
+
+
+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
-    :type url: str
     :param stac_config: STAC configuration from stac.yml conf file
-    :type stac_config: dict
     :param provider: (optional) Chosen provider
-    :type provider: str
     :param eodag_api: EODAG python API instance
-    :type eodag_api: :class:`eodag.api.core.EODataAccessGateway`
     :param root: (optional) API root
-    :type root: str
     """
 
     def __init__(
@@ -100,7 +135,6 @@ class StacCommon:
         """Updates data using given input STAC dict data
 
         :param data: Catalog data (parsed STAC dict)
-        :type data: dict
         """
         self.data.update(data)
 
@@ -112,15 +146,18 @@ class StacCommon:
         ):
             for i, bbox in enumerate(self.data["extent"]["spatial"]["bbox"]):
                 self.data["extent"]["spatial"]["bbox"][i] = [float(x) for x in bbox]
-        # "None" values to None
-        self.data = dict_items_recursive_apply(
-            self.data, lambda k, v: None if v == "None" else v
-        )
 
-        # ids and titles as str
-        self.data = dict_items_recursive_apply(
-            self.data, lambda k, v: str(v) if k in ["title", "id"] else v
-        )
+        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):
@@ -133,15 +170,10 @@ class StacCommon:
         """Parse STAC extension from config and return as dict
 
         :param url: Requested URL
-        :type url: str
         :param stac_config: STAC configuration from stac.yml conf file
-        :type stac_config: dict
         :param extension: Extension name
-        :type extension: str
         :param kwargs: Additional variables needed for parsing extension
-        :type kwargs: Any
-        :returns: STAC extension as dictionnary
-        :rtype: dict
+        :returns: STAC extension as dictionary
         """
         extension_model = deepcopy(stac_config).get("extensions", {}).get(extension, {})
 
@@ -153,30 +185,30 @@ class StacCommon:
         }
         return format_dict_items(extension_model, **format_args)
 
-    def as_dict(self) -> Dict[str, Any]:
-        """Returns object data as dictionnary
-
-        :returns: STAC data dictionnary
-        :rtype: dict
-        """
-        return geojson.loads(geojson.dumps(self.data))
-
-    __geo_interface__ = property(as_dict)
+    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
-    :type url: str
     :param stac_config: STAC configuration from stac.yml conf file
-    :type stac_config: dict
     :param provider: (optional) Chosen provider
-    :type provider: str
     :param eodag_api: EODAG python API instance
-    :type eodag_api: :class:`eodag.api.core.EODataAccessGateway`
     :param root: (optional) API root
-    :type root: str
     """
 
     def __init__(
@@ -201,11 +233,8 @@ class StacItem(StacCommon):
         """Build STAC items list from EODAG search results
 
         :param search_results: EODAG search results
-        :type search_results: :class:`~eodag.api.search_result.SearchResult`
         :param catalog: STAC catalog dict used for parsing item metadata
-        :type catalog: dict
         :returns: STAC item dicts list
-        :rtype: list
         """
         if len(search_results) <= 0:
             return []
@@ -213,7 +242,6 @@ class StacItem(StacCommon):
         item_model = self.__filter_item_model_properties(
             self.stac_config["item"], str(search_results[0].product_type)
         )
-        provider_model = deepcopy(self.stac_config["provider"])
 
         # check if some items need to be converted
         need_conversion: Dict[str, Any] = {}
@@ -229,77 +257,62 @@ class StacItem(StacCommon):
                         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:
-            # parse jsonpath
-            provider_dict = jsonpath_parse_dict_items(
-                provider_model,
-                {
-                    "provider": self.eodag_api.providers_config[
-                        product.provider
-                    ].__dict__
-                },
-            )
-
             product_dict = deepcopy(product.__dict__)
-            if isinstance(product.assets, dict):
-                product_dict["assets"] = product.assets
-            else:
-                product_dict["assets"] = product.assets.as_dict()
 
-            product_item = jsonpath_parse_dict_items(
+            product_item: Dict[str, Any] = jsonpath_parse_dict_items(
                 item_model,
                 {
                     "product": product_dict,
-                    "providers": [provider_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
-            url_parts = urlparse(str(product_item["assets"]["downloadLink"]["href"]))
+            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
-            if self.provider:
-                query_dict.update(provider=[self.provider])
+            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
-            _dc_qs = product_item["assets"]["downloadLink"].pop("_dc_qs", None)
             if _dc_qs:
-                query_dict.update(_dc_qs=_dc_qs)
-
-            # update download link with up-to-date query-args
+                query_dict.update(_dc_qs=[_dc_qs])
             if query_dict:
-                product_item["assets"]["downloadLink"][
-                    "href"
-                ] = f"{without_arg_url}?{urlencode(query_dict, doseq=True)}"
+                downloadlink_href = (
+                    f"{without_arg_url}?{urlencode(query_dict, doseq=True)}"
+                )
 
-            # move origin asset urls to alternate links and replace with eodag-server ones
-            origin_assets = product_item["assets"].pop("origin_assets", {})
-            if getattr(product, "assets", False):
-                # replace origin asset urls with eodag-server ones
-                for asset_key, asset_value in origin_assets.items():
-                    # use origin asset as default
-                    product_item["assets"][asset_key] = asset_value
-                    # origin assets as alternate link
-                    product_item["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:
-                        product_item["assets"][asset_key][
-                            "href"
-                        ] += f"/{asset_key}?{urlencode(query_dict, doseq=True)}"
-                    else:
-                        product_item["assets"][asset_key]["href"] += f"/{asset_key}"
+            # 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():
@@ -321,16 +334,23 @@ class StacItem(StacCommon):
             format_args = deepcopy(self.stac_config)
             format_args["catalog"] = catalog
             format_args["item"] = product_item
-            product_item: Dict[str, Any] = format_dict_items(
-                product_item, **format_args
-            )
+            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:
+            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}"
@@ -345,50 +365,128 @@ class StacItem(StacCommon):
 
         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", None):
+                    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", None)
+        ):
+            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, catalog: Dict[str, Any]
+        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
-        :type search_results: :class:`~eodag.api.search_result.SearchResult`
         :param catalog: STAC catalog dict used for parsing item metadata
-        :type catalog: dict
-        :returns: Items dictionnary
-        :rtype: dict
+        :returns: Items dictionary
         """
         items_model = deepcopy(self.stac_config["items"])
 
-        search_results.numberMatched = search_results.properties["totalResults"]
-        search_results.numberReturned = len(search_results)
-
-        # next page link
         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"]
 
-        search_results.timeStamp = (
-            datetime.now(timezone.utc).isoformat().replace("+00:00", "") + "Z"
-        )
+        timestamp = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
 
         # parse jsonpath
         items = jsonpath_parse_dict_items(
-            items_model, {"search_results": search_results.__dict__}
+            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)
 
-        # last page: remove next page link
-        if (
-            search_results.properties["itemsPerPage"]
-            * search_results.properties["page"]
-            >= search_results.properties["totalResults"]
-        ):
-            items["links"] = [link for link in items["links"] if link["rel"] != "next"]
+        if next_link:
+            items["links"].append(next_link)
 
         # provide static catalog to build features
         if "search?" in catalog["url"]:
@@ -402,7 +500,7 @@ class StacItem(StacCommon):
         items["features"] = self.__get_item_list(search_results, catalog)
 
         self.update_data(items)
-        return geojson.loads(geojson.dumps(self.data))
+        return self.data
 
     def __filter_item_model_properties(
         self, item_model: Dict[str, Any], product_type: str
@@ -412,11 +510,8 @@ class StacItem(StacCommon):
         part of oseo extension.
 
         :param item_model: Item model from stac_config
-        :type item_model: dict
         :param product_type: Product type
-        :type product_type: str
         :returns: Filtered item model
-        :rtype: dict
         """
         try:
             product_type_dict = [
@@ -427,12 +522,10 @@ class StacItem(StacCommon):
                 if pt["ID"] == product_type
                 or ("alias" in pt and pt["alias"] == product_type)
             ][0]
-        except IndexError:
+        except IndexError as e:
             raise NoMatchingProductType(
-                "Product type {} not available for {}".format(
-                    product_type, self.provider
-                )
-            )
+                f"Product type {product_type} not available for {self.provider}"
+            ) from e
 
         result_item_model = deepcopy(item_model)
         result_item_model["stac_extensions"] = list(
@@ -479,9 +572,7 @@ class StacItem(StacCommon):
         """Removes empty properties, unused extensions, and add missing extensions
 
         :param item: STAC item data
-        :type item: dict
         :returns: Filtered item model
-        :rtype: dict
         """
         all_extensions_dict: Dict[str, str] = deepcopy(
             self.stac_config["stac_extensions"]
@@ -512,21 +603,13 @@ class StacItem(StacCommon):
         """Build STAC item from EODAG product
 
         :param product: EODAG product
-        :type product: :class:`eodag.api.product._product.EOProduct`
         :returns: STAC item
-        :rtype: list
         """
         product_type = str(product.product_type)
 
         item_model = self.__filter_item_model_properties(
             self.stac_config["item"], product_type
         )
-        provider_model = deepcopy(self.stac_config["provider"])
-
-        provider_dict = jsonpath_parse_dict_items(
-            provider_model,
-            {"provider": self.eodag_api.providers_config[product.provider].__dict__},
-        )
 
         catalog = StacCatalog(
             url=self.url.split("/items")[0],
@@ -534,7 +617,7 @@ class StacItem(StacCommon):
             root=self.root,
             provider=self.provider,
             eodag_api=self.eodag_api,
-            catalogs=[product_type],
+            collection=product_type,
         )
 
         product_dict = deepcopy(product.__dict__)
@@ -545,14 +628,15 @@ class StacItem(StacCommon):
             item_model,
             {
                 "product": product_dict,
-                "providers": provider_dict,
+                "providers": [self.get_provider_dict(product.provider)],
             },
         )
         # parse f-strings
         format_args = deepcopy(self.stac_config)
-        format_args["catalog"] = dict(
-            catalog.as_dict(), **{"url": catalog.url, "root": catalog.root}
-        )
+        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"]]
@@ -561,24 +645,46 @@ class StacItem(StacCommon):
         product_item = self.__filter_item_properties_values(product_item)
 
         self.update_data(product_item)
-        return self.as_dict()
+        return self.data
 
 
 class StacCollection(StacCommon):
     """Stac collection object
 
     :param url: Requested URL
-    :type url: str
     :param stac_config: STAC configuration from stac.yml conf file
-    :type stac_config: dict
     :param provider: (optional) Chosen provider
-    :type provider: str
     :param eodag_api: EODAG python API instance
-    :type eodag_api: :class:`eodag.api.core.EODataAccessGateway`
     :param root: (optional) API root
-    :type root: str
     """
 
+    # 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,
@@ -595,165 +701,174 @@ class StacCollection(StacCommon):
             root=root,
         )
 
-    def __get_product_types(
-        self, filters: Optional[Dict[str, Any]] = None
-    ) -> List[Dict[str, Any]]:
-        """Returns a list of supported product types
+    def __list_product_type_providers(self, product_type: Dict[str, Any]) -> List[str]:
+        """Retrieve a list of providers for a given product type.
 
-        :param filters: (optional) Additional filters for product types search
-        :type filters: dict
-        :returns: List of corresponding product types
-        :rtype: list
+        :param product_type: Dictionary containing information about the product type.
+        :return: A list of provider names.
         """
-        if filters is None:
-            filters = {}
-        try:
-            guessed_product_types = self.eodag_api.guess_product_type(**filters)
-        except NoMatchingProductType:
-            guessed_product_types = []
-        if guessed_product_types:
-            product_types = [
-                pt
-                for pt in self.eodag_api.list_product_types(provider=self.provider)
-                if pt["ID"] in guessed_product_types
-            ]
-        else:
-            product_types = self.eodag_api.list_product_types(provider=self.provider)
-        return product_types
+        if self.provider:
+            return [self.provider]
 
-    def __get_collection_list(
-        self, filters: Optional[Dict[str, Any]] = None
-    ) -> List[Dict[str, Any]]:
-        """Build STAC collections list
+        return [
+            plugin.provider
+            for plugin in self.eodag_api._plugins_manager.get_search_plugins(
+                product_type=product_type.get("_id", product_type["ID"])
+            )
+        ]
 
-        :param filters: (optional) Additional filters for collections search
-        :type filters: dict
-        :returns: STAC collection dicts list
-        :rtype: list
+    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.
         """
-        collection_model = deepcopy(self.stac_config["collection"])
-        provider_model = deepcopy(self.stac_config["provider"])
+        providers = self.__list_product_type_providers(product_type)
 
-        product_types = self.__get_product_types(filters)
+        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())
 
-        collection_list: List[Dict[str, Any]] = []
-        for product_type in product_types:
-            if self.provider:
-                providers = [self.provider]
-            else:
-                # get available providers for each product_type
-                providers = [
-                    plugin.provider
-                    for plugin in self.eodag_api._plugins_manager.get_search_plugins(
-                        product_type=(
-                            product_type.get("_id", None) or product_type["ID"]
-                        )
-                    )
-                ]
-            providers_models: List[Dict[str, Any]] = []
-            for provider in providers:
-                provider_m = jsonpath_parse_dict_items(
-                    provider_model,
-                    {"provider": self.eodag_api.providers_config[provider].__dict__},
-                )
-                providers_models.append(provider_m)
+        # 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"], {})
+        )
 
-            # parse jsonpath
-            product_type_collection = jsonpath_parse_dict_items(
-                collection_model,
-                {
-                    "product_type": product_type,
-                    "providers": providers_models,
-                },
-            )
-            # parse f-strings
-            format_args = deepcopy(self.stac_config)
-            format_args["collection"] = dict(
-                product_type_collection,
-                **{"url": f"{self.url}/{product_type['ID']}", "root": self.root},
+        # 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)}"
             )
-            product_type_collection = format_dict_items(
-                product_type_collection, **format_args
+            logger.debug(
+                f"External collection keywords: {str(ext_stac_collection.get('keywords'))}, ",
+                f"Product type keywords: {str(product_type_collection['keywords'])}",
             )
 
-            collection_list.append(product_type_collection)
+        # merge providers
+        if "providers" in ext_stac_collection:
+            ext_stac_collection["providers"] += product_type_collection["providers"]
 
-        return collection_list
-
-    def get_collections(
-        self, filters: Optional[Dict[str, Any]] = None
-    ) -> Dict[str, Any]:
-        """Build STAC collections
-
-        :param filters: (optional) Additional filters for collections search
-        :type filters: dict
-        :returns: Collections dictionnary
-        :rtype: dict
-        """
-        collections = deepcopy(self.stac_config["collections"])
-        collections["collections"] = self.__get_collection_list(filters)
+        product_type_collection.update(ext_stac_collection)
 
-        # # parse f-strings
+        # parse f-strings
         format_args = deepcopy(self.stac_config)
-        format_args["collections"].update({"url": self.url, "root": self.root})
+        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
+        )
 
-        collections["links"] = [
-            format_dict_items(link, **format_args) for link in collections["links"]
-        ]
+        return product_type_collection
 
-        collections["links"] += [
-            {
-                "rel": "child",
-                "title": collec["id"],
-                "href": [
-                    link["href"] for link in collec["links"] if link["rel"] == "self"
-                ][0],
-            }
-            for collec in collections["collections"]
-        ]
+    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,
+    ) -> List[Dict[str, Any]]:
+        """Build STAC collections list
 
-        self.update_data(collections)
-        return self.as_dict()
+        :param filters: (optional) Additional filters for collections search
+        :returns: STAC collection dicts list
+        """
+        collection_model = deepcopy(self.stac_config["collection"])
 
-    def get_collection_by_id(self, collection_id: str) -> Dict[str, Any]:
-        """Build STAC collection by its id
+        start, end = str_to_interval(datetime)
 
-        :param collection_id: Product type as collection ID
-        :type collection_id: str
-        :returns: Collection dictionary
-        :rtype: dict
-        """
-        collection_list = self.__get_collection_list(
-            filters={"productType": collection_id}
+        all_pt = self.eodag_api.list_product_types(
+            provider=self.provider, fetch_providers=False
         )
 
-        try:
-            collection = collection_list[0]
-        except IndexError:
-            raise NotAvailableError("%s collection not found" % collection_id)
+        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
 
-        self.update_data(collection)
-        return self.as_dict()
+        # 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
+            )
+            collection_list.append(stac_collection)
+
+        return collection_list
 
 
 class StacCatalog(StacCommon):
     """Stac Catalog object
 
     :param url: Requested URL
-    :type url: str
     :param stac_config: STAC configuration from stac.yml conf file
-    :type stac_config: dict
     :param provider: Chosen provider
-    :type provider: (optional) str
     :param eodag_api: EODAG python API instance
-    :type eodag_api: :class:`eodag.api.core.EODataAccessGateway`
     :param root: (optional) API root
-    :type root: str
-    :param catalogs: (optional) Catalogs list
-    :type catalogs: list
-    :param fetch_providers: (optional) Whether to fetch providers for new product
-                            types or not
-    :type fetch_providers: bool
+    :param collection: (optional) product type id
     """
 
     def __init__(
@@ -763,8 +878,7 @@ class StacCatalog(StacCommon):
         provider: Optional[str],
         eodag_api: EODataAccessGateway,
         root: str = "/",
-        catalogs: List[str] = [],
-        fetch_providers: bool = True,
+        collection: Optional[str] = None,
     ) -> None:
         super(StacCatalog, self).__init__(
             url=url,
@@ -791,13 +905,12 @@ class StacCatalog(StacCommon):
             self.data["links"] += self.children
 
         # build catalog
-        self.__build_stac_catalog(catalogs, fetch_providers=fetch_providers)
+        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]
-        :type catalog_config: dict
         """
         model = catalog_config["model"]
 
@@ -817,40 +930,66 @@ class StacCatalog(StacCommon):
 
         return True
 
-    def set_children(self, children: List[Dict[str, Any]] = []) -> bool:
-        """Set catalog children / links
+    def __build_stac_catalog(self, collection: Optional[str] = None) -> StacCatalog:
+        """Build nested catalog from catalag list
 
-        :param children: (optional) Children list
-        :type children: list
+        :param collection: (optional) product type id
+        :returns: This catalog obj
         """
-        self.children = children
-        self.data["links"] = [
-            link for link in self.data["links"] if link["rel"] != "child"
-        ]
-        self.data["links"] += children
-        return True
+        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, **kwargs: Any
+        self, product_type: str, **_: Any
     ) -> Dict[str, Any]:
         """Updates catalog with given product_type
 
         :param product_type: Product type
-        :type product_type: str
         """
-        collection = StacCollection(
+        collections = StacCollection(
             url=self.url,
             stac_config=self.stac_config,
             provider=self.provider,
             eodag_api=self.eodag_api,
             root=self.root,
-        ).get_collection_by_id(product_type)
-
-        cat_model = deepcopy(self.stac_config["catalogs"]["product_type"]["model"])
+        ).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"] = collection
+        format_args["collection"] = collections[0]
         try:
             parsed_dict: Dict[str, Any] = format_dict_items(cat_model, **format_args)
         except Exception:
@@ -860,539 +999,6 @@ class StacCatalog(StacCommon):
         self.update_data(parsed_dict)
 
         # update search args
-        self.search_args.update({"product_type": product_type})
+        self.search_args.update({"productType": product_type})
 
         return parsed_dict
-
-    # get / set dates filters -------------------------------------------------
-
-    def get_stac_years_list(self, **kwargs: Any) -> List[int]:
-        """Get catalog available years list
-
-        :returns: Years list
-        :rtype: list
-        """
-        extent_date_min, extent_date_max = self.get_datetime_extent()
-
-        return list(range(extent_date_min.year, extent_date_max.year + 1))
-
-    def get_stac_months_list(self, **kwargs: Any) -> List[int]:
-        """Get catalog available months list
-
-        :returns: Months list
-        :rtype: list
-        """
-        extent_date_min, extent_date_max = self.get_datetime_extent()
-
-        return list(
-            range(
-                extent_date_min.month,
-                (extent_date_max - relativedelta(days=1)).month + 1,
-            )
-        )
-
-    def get_stac_days_list(self, **kwargs: Any) -> List[int]:
-        """Get catalog available days list
-
-        :returns: Days list
-        :rtype: list
-        """
-        extent_date_min, extent_date_max = self.get_datetime_extent()
-
-        return list(
-            range(
-                extent_date_min.day, (extent_date_max - relativedelta(days=1)).day + 1
-            )
-        )
-
-    def set_stac_year_by_id(self, year: str, **kwargs: Any) -> Dict[str, Any]:
-        """Updates and returns catalog with given year
-
-        :param year: Year number
-        :type year: str
-        :returns: Updated catalog
-        :rtype: dict
-        """
-        extent_date_min, extent_date_max = self.get_datetime_extent()
-
-        datetime_min = max(
-            [extent_date_min, dateutil.parser.parse("{}-01-01T00:00:00Z".format(year))]
-        )
-        datetime_max = min(
-            [
-                extent_date_max,
-                dateutil.parser.parse("{}-01-01T00:00:00Z".format((year)))
-                + relativedelta(years=1),
-            ]
-        )
-
-        catalog_model = deepcopy(self.stac_config["catalogs"]["year"]["model"])
-
-        parsed_dict = self.set_stac_date(datetime_min, datetime_max, catalog_model)
-
-        return parsed_dict
-
-    def set_stac_month_by_id(self, month: str, **kwargs: Any) -> Dict[str, Any]:
-        """Updates and returns catalog with given month
-
-        :param month: Month number
-        :type month: str
-        :returns: Updated catalog
-        :rtype: dict
-        """
-        extent_date_min, extent_date_max = self.get_datetime_extent()
-        year = extent_date_min.year
-
-        datetime_min = max(
-            [
-                extent_date_min,
-                dateutil.parser.parse("{}-{}-01T00:00:00Z".format(year, month)),
-            ]
-        )
-        datetime_max = min(
-            [
-                extent_date_max,
-                dateutil.parser.parse("{}-{}-01T00:00:00Z".format(year, month))
-                + relativedelta(months=1),
-            ]
-        )
-
-        catalog_model = deepcopy(self.stac_config["catalogs"]["month"]["model"])
-
-        parsed_dict = self.set_stac_date(datetime_min, datetime_max, catalog_model)
-
-        return parsed_dict
-
-    def set_stac_day_by_id(self, day: str, **kwargs: Any) -> Dict[str, Any]:
-        """Updates and returns catalog with given day
-
-        :param day: Day number
-        :type day: str
-        :returns: Updated catalog
-        :rtype: dict
-        """
-        extent_date_min, extent_date_max = self.get_datetime_extent()
-        year = extent_date_min.year
-        month = extent_date_min.month
-
-        datetime_min = max(
-            [
-                extent_date_min,
-                dateutil.parser.parse("{}-{}-{}T00:00:00Z".format(year, month, day)),
-            ]
-        )
-        datetime_max = min(
-            [
-                extent_date_max,
-                dateutil.parser.parse("{}-{}-{}T00:00:00Z".format(year, month, day))
-                + relativedelta(days=1),
-            ]
-        )
-
-        catalog_model = deepcopy(self.stac_config["catalogs"]["day"]["model"])
-
-        parsed_dict = self.set_stac_date(datetime_min, datetime_max, catalog_model)
-
-        return parsed_dict
-
-    def get_datetime_extent(self) -> Tuple[datetime, datetime]:
-        """Returns catalog temporal extent as datetime objs
-
-        :returns: Start & stop dates
-        :rtype: tuple
-        """
-        extent_date_min = dateutil.parser.parse(DEFAULT_MISSION_START_DATE).replace(
-            tzinfo=tz.UTC
-        )
-        extent_date_max = datetime.now(timezone.utc).replace(tzinfo=tz.UTC)
-        for interval in self.data["extent"]["temporal"]["interval"]:
-            extent_date_min_str, extent_date_max_str = interval
-            # date min
-            if extent_date_min_str:
-                extent_date_min = max(
-                    extent_date_min, dateutil.parser.parse(extent_date_min_str)
-                )
-            # date max
-            if extent_date_max_str:
-                extent_date_max = min(
-                    extent_date_max, dateutil.parser.parse(extent_date_max_str)
-                )
-
-        return (
-            extent_date_min.replace(tzinfo=tz.UTC),
-            extent_date_max.replace(tzinfo=tz.UTC),
-        )
-
-    def set_stac_date(
-        self,
-        datetime_min: datetime,
-        datetime_max: datetime,
-        catalog_model: Dict[str, Any],
-    ):
-        """Updates catalog data using given dates
-
-        :param datetime_min: Date min of interval
-        :type datetime_min: :class:`datetime`
-        :param datetime_max: Date max of interval
-        :type datetime_max: :class:`datetime`
-        :param catalog_model: Catalog model to use, from yml stac_config[catalogs]
-        :type catalog_model: dict
-        :returns: Updated catalog
-        :rtype: dict
-        """
-        # parse f-strings
-        format_args = deepcopy(self.stac_config)
-        format_args["catalog"] = defaultdict(str, **self.data)
-        format_args["date"] = defaultdict(
-            str,
-            {
-                "year": datetime_min.year,
-                "month": datetime_min.month,
-                "day": datetime_min.day,
-                "min": datetime_min.isoformat().replace("+00:00", "") + "Z",
-                "max": datetime_max.isoformat().replace("+00:00", "") + "Z",
-            },
-        )
-        parsed_dict: Dict[str, Any] = format_dict_items(catalog_model, **format_args)
-
-        self.update_data(parsed_dict)
-
-        # update search args
-        self.search_args.update(
-            {
-                "dtstart": datetime_min.isoformat().split("T")[0],
-                "dtend": datetime_max.isoformat().split("T")[0],
-            }
-        )
-        return parsed_dict
-
-    # get / set cloud_cover filter --------------------------------------------
-
-    def get_stac_cloud_covers_list(self, **kwargs: Any) -> List[int]:
-        """Get cloud_cover list
-
-        :returns: cloud_cover list
-        :rtype: list
-        """
-        return list(range(0, 101, 10))
-
-    def set_stac_cloud_cover_by_id(
-        self, cloud_cover: str, **kwargs: Any
-    ) -> Dict[str, Any]:
-        """Updates and returns catalog with given max cloud_cover
-
-        :param cloud_cover: Cloud_cover number
-        :type cloud_cover: str
-        :returns: Updated catalog
-        :rtype: dict
-        """
-        cat_model = deepcopy(self.stac_config["catalogs"]["cloud_cover"]["model"])
-        # parse f-strings
-        format_args = deepcopy(self.stac_config)
-        format_args["catalog"] = defaultdict(str, **self.data)
-        format_args["cloud_cover"] = cloud_cover
-        parsed_dict: Dict[str, Any] = format_dict_items(cat_model, **format_args)
-
-        self.update_data(parsed_dict)
-
-        # update search args
-        self.search_args.update({"query": {"eo:cloud_cover": {"lte": cloud_cover}}})
-
-        return parsed_dict
-
-    # get / set locations filter ----------------------------------------------
-
-    def get_stac_location_list(self, catalog_name: str) -> List[str]:
-        """Get locations list using stac_conf & locations_config
-
-        :param catalog_name: Catalog/location name
-        :type catalog_name: str
-        :returns: Locations list
-        :rtype: list
-        """
-
-        if catalog_name not in self.stac_config["catalogs"]:
-            logger.warning(
-                "no entry found for {} in location_config".format(catalog_name)
-            )
-            return []
-        location_config = self.stac_config["catalogs"][catalog_name]
-
-        for k in ["path", "attr"]:
-            if k not in location_config.keys():
-                logger.warning(
-                    "no {} key found for {} in location_config".format(k, catalog_name)
-                )
-                return []
-        path = location_config["path"]
-        attr = location_config["attr"]
-
-        with shapefile.Reader(path) as shp:
-            countries_list: List[str] = [rec[attr] for rec in shp.records()]
-
-        # remove duplicates
-        countries_list = list(set(countries_list))
-
-        countries_list.sort()
-
-        return countries_list
-
-    def set_stac_location_by_id(
-        self, location: str, catalog_name: str
-    ) -> Dict[str, Any]:
-        """Updates and returns catalog with given location
-
-        :param location: Feature attribute value for shp filtering
-        :type location: str
-        :param catalog_name: Catalog/location name
-        :type catalog_name: str
-        :returns: Updated catalog
-        :rtype: dict
-        """
-        location_list_cat_key = catalog_name + "_list"
-
-        if location_list_cat_key not in self.stac_config["catalogs"]:
-            logger.warning(
-                "no entry found for {}'s list in location_config".format(catalog_name)
-            )
-            return {}
-        location_config = self.stac_config["catalogs"][location_list_cat_key]
-
-        for k in ["path", "attr"]:
-            if k not in location_config.keys():
-                logger.warning(
-                    "no {} key found for {}'s list in location_config".format(
-                        k, catalog_name
-                    )
-                )
-                return {}
-        path = location_config["path"]
-        attr = location_config["attr"]
-
-        with shapefile.Reader(path) as shp:
-            geom_hits = [
-                shape(shaperec.shape)
-                for shaperec in shp.shapeRecords()
-                if shaperec.record.as_dict().get(attr, None) == location
-            ]
-
-        if len(geom_hits) == 0:
-            logger.warning(
-                "no feature found in %s matching %s=%s" % (path, attr, location)
-            )
-            return {}
-
-        geom = cast(BaseGeometry, unary_union(geom_hits))
-
-        cat_model = deepcopy(self.stac_config["catalogs"]["country"]["model"])
-        # parse f-strings
-        format_args = deepcopy(self.stac_config)
-        format_args["catalog"] = defaultdict(str, **self.data)
-        format_args["feature"] = defaultdict(str, {"geometry": geom, "id": location})
-        parsed_dict: Dict[str, Any] = format_dict_items(cat_model, **format_args)
-
-        self.update_data(parsed_dict)
-
-        # update search args
-        self.search_args.update({"geom": geom})
-
-        return parsed_dict
-
-    def build_locations_config(self) -> Dict[str, str]:
-        """Build locations config from stac_conf[locations_catalogs] & eodag_api.locations_config
-
-        :returns: Locations configuration dict
-        :rtype: dict
-        """
-        user_config_locations_list = self.eodag_api.locations_config
-
-        locations_config_model = deepcopy(self.stac_config["locations_catalogs"])
-
-        locations_config: Dict[str, str] = {}
-        for loc in user_config_locations_list:
-            # parse jsonpath
-            parsed = jsonpath_parse_dict_items(
-                locations_config_model, {"shp_location": loc}
-            )
-
-            # set default child/parent for this location
-            parsed["location"]["parent_key"] = "{}_list".format(loc["name"])
-
-            locations_config["{}_list".format(loc["name"])] = parsed["locations_list"]
-            locations_config[loc["name"]] = parsed["location"]
-
-        return locations_config
-
-    def __build_stac_catalog(
-        self, catalogs: List[str] = [], fetch_providers: bool = True
-    ) -> StacCatalog:
-        """Build nested catalog from catalag list
-
-        :param catalogs: (optional) Catalogs list
-        :type catalogs: list
-        :param fetch_providers: (optional) Whether to fetch providers for new product
-                                types or not
-        :type fetch_providers: bool
-        :returns: This catalog obj
-        :rtype: :class:`eodag.stac.StacCatalog`
-        """
-        # update conf with user shp locations
-        locations_config = self.build_locations_config()
-
-        self.stac_config["catalogs"] = dict(
-            deepcopy(self.stac_config["catalogs"]), **locations_config
-        )
-
-        if len(catalogs) == 0:
-            # Build root catalog combined with landing page
-            self.__update_data_from_catalog_config(
-                {
-                    "model": dict(
-                        deepcopy(self.stac_config["landing_page"]),
-                        **{"provider": self.provider},
-                    )
-                }
-            )
-
-            # build children : product_types
-            product_types_list = [
-                pt
-                for pt in self.eodag_api.list_product_types(
-                    provider=self.provider, fetch_providers=fetch_providers
-                )
-            ]
-            self.set_children(
-                [
-                    {
-                        "rel": "child",
-                        "href": urljoin(
-                            self.url, f"{STAC_CATALOGS_PREFIX}/{product_type['ID']}"
-                        ),
-                        "title": product_type["ID"],
-                    }
-                    for product_type in product_types_list
-                ]
-            )
-        else:
-            # use product_types_list as base for building nested catalogs
-            self.__update_data_from_catalog_config(
-                deepcopy(self.stac_config["catalogs"]["product_types_list"])
-            )
-
-        for idx, cat in enumerate(catalogs):
-            if idx % 2 == 0:
-                # even: cat is a filtering value ----------------------------------
-                cat_data_name = self.catalog_config["child_key"]
-                cat_data_value = cat
-
-                # update data
-                set_data_method_name = (
-                    "set_stac_%s_by_id" % cat_data_name
-                    if "catalog_type"
-                    not in self.stac_config["catalogs"][cat_data_name].keys()
-                    else "set_stac_%s_by_id"
-                    % self.stac_config["catalogs"][cat_data_name]["catalog_type"]
-                )
-                set_data_method = getattr(self, set_data_method_name)
-                set_data_method(cat_data_value, catalog_name=cat_data_name)
-
-                if idx == len(catalogs) - 1:
-                    # build children : remaining filtering keys
-                    remaining_catalogs_list = [
-                        c
-                        for c in self.stac_config["catalogs"].keys()
-                        # keep filters not used yet AND
-                        if self.stac_config["catalogs"][c]["model"]["id"]
-                        not in catalogs
-                        and (
-                            # filters with no parent_key constraint (no key, or key=None) OR
-                            "parent_key" not in self.stac_config["catalogs"][c]
-                            or not self.stac_config["catalogs"][c]["parent_key"]
-                            # filters matching parent_key constraint
-                            or self.stac_config["catalogs"][c]["parent_key"]
-                            == cat_data_name
-                        )
-                        # AND filters that match parent attr constraint (locations)
-                        and (
-                            "parent" not in self.stac_config["catalogs"][c]
-                            or not self.stac_config["catalogs"][c]["parent"]["key"]
-                            or (
-                                self.stac_config["catalogs"][c]["parent"]["key"]
-                                == cat_data_name
-                                and self.stac_config["catalogs"][c]["parent"]["attr"]
-                                == cat_data_value
-                            )
-                        )
-                    ]
-
-                    self.set_children(
-                        [
-                            {
-                                "rel": "child",
-                                "href": self.url
-                                + "/"
-                                + self.stac_config["catalogs"][c]["model"]["id"],
-                                "title": str(
-                                    self.stac_config["catalogs"][c]["model"]["id"]
-                                ),
-                            }
-                            for c in remaining_catalogs_list
-                        ]
-                        + [
-                            {
-                                "rel": "items",
-                                "href": self.url + "/items",
-                                "title": "items",
-                            }
-                        ]
-                    )
-
-            else:
-                # odd: cat is a filtering key -------------------------------------
-                try:
-                    cat_key = [
-                        c
-                        for c in self.stac_config["catalogs"].keys()
-                        if self.stac_config["catalogs"][c]["model"]["id"] == cat
-                    ][0]
-                except IndexError:
-                    raise ValidationError(
-                        "Bad settings for %s in stac_config catalogs" % cat
-                    )
-                cat_config = deepcopy(self.stac_config["catalogs"][cat_key])
-                # update data
-                self.__update_data_from_catalog_config(cat_config)
-
-                # get filtering values list
-                get_data_method_name = (
-                    "get_stac_%s" % cat_key
-                    if "catalog_type"
-                    not in self.stac_config["catalogs"][cat_key].keys()
-                    else "get_stac_%s"
-                    % self.stac_config["catalogs"][cat_key]["catalog_type"]
-                )
-                get_data_method = getattr(self, get_data_method_name)
-                cat_data_list = get_data_method(catalog_name=cat_key)
-
-                if idx == len(catalogs) - 1:
-                    # filtering values list as children (do not include items)
-                    self.set_children(
-                        [
-                            {
-                                "rel": "child",
-                                "href": self.url + "/" + str(filtering_data),
-                                "title": str(filtering_data),
-                            }
-                            for filtering_data in cat_data_list
-                        ]
-                    )
-
-        return self
-
-    def get_stac_catalog(self) -> Dict[str, Any]:
-        """Get nested STAC catalog as data dict
-
-        :returns: Catalog dictionnary
-        :rtype: dict
-        """
-        return self.as_dict()