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

eodag/rest/stac.py

@@ -21,14 +21,15 @@ 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, Callable, Dict, List, Optional, Tuple, cast
+from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
 
 import dateutil.parser
 import geojson
 import shapefile
 from dateutil import tz
 from dateutil.relativedelta import relativedelta
+from jsonpath_ng.jsonpath import Child
 from shapely.geometry import shape
 from shapely.geometry.base import BaseGeometry
 from shapely.ops import unary_union
@@ -38,10 +39,14 @@ from eodag.api.product.metadata_mapping import (
     format_metadata,
     get_metadata_path,
 )
+from eodag.rest.config import Settings
+from eodag.rest.utils.rfc3339 import str_to_interval
 from eodag.utils import (
+    DEFAULT_MISSION_START_DATE,
     deepcopy,
     dict_items_recursive_apply,
     format_dict_items,
+    guess_file_type,
     jsonpath_parse_dict_items,
     string_to_jsonpath,
     update_nested_dict,
@@ -50,8 +55,11 @@ from eodag.utils import (
 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
@@ -61,9 +69,38 @@ 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",
+]
+
 
 class StacCommon:
     """Stac common object
@@ -113,14 +150,15 @@ 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
+        apply_method: Callable[[str, str], Optional[str]] = lambda _, v: (
+            None if v == "None" else v
         )
-
+        self.data = dict_items_recursive_apply(self.data, apply_method)
         # 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
+        apply_method: Callable[[str, str], Optional[str]] = lambda k, v: (
+            str(v) if k in ["title", "id"] else v
         )
+        self.data = dict_items_recursive_apply(self.data, apply_method)
 
         # empty stac_extensions: "" to []
         if not self.data.get("stac_extensions", True):
@@ -153,15 +191,20 @@ 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):
@@ -213,7 +256,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 +271,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 +348,19 @@ 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)
 
             # 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,8 +375,91 @@ 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
+        assets["downloadLink"] = {
+            "title": "Download link",
+            "href": downloadlink_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
+
+        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
 
@@ -359,36 +472,30 @@ class StacItem(StacCommon):
         """
         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 +509,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
@@ -427,12 +534,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(
@@ -521,12 +626,6 @@ class StacItem(StacCommon):
         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],
@@ -545,14 +644,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,7 +661,7 @@ 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):
@@ -579,6 +679,34 @@ class StacCollection(StacCommon):
     :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
+        :type eodag_api: :class:`eodag.api.core.EODataAccessGateway`
+        """
+        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,145 +723,161 @@ 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
+        :param product_type: Dictionary containing information about the product type.
+        :type product_type: dict
+        :return: A list of provider names.
         :rtype: list
         """
-        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.
+        :type collection_model: Any
+        :param product_type: Dictionary containing information about the product type.
+        :type product_type: dict
+        :return: A dictionary representing the STAC collection for the given product type.
+        :rtype: dict
         """
-        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"]
-                        )
+        # 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 "keywords" lists
+        if "keywords" in ext_stac_collection:
+            try:
+                ext_stac_collection["keywords"] = [
+                    k
+                    for k in set(
+                        ext_stac_collection["keywords"]
+                        + product_type_collection["keywords"]
                     )
+                    if k is not None
                 ]
-            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__},
+            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['keywords'])}, ",
+                    f"Product type keywords: {str(product_type_collection['keywords'])}",
                 )
-                providers_models.append(provider_m)
 
-            # 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},
-            )
-            product_type_collection = format_dict_items(
-                product_type_collection, **format_args
-            )
+        # merge providers
+        if "providers" in ext_stac_collection:
+            ext_stac_collection["providers"] += product_type_collection["providers"]
 
-            collection_list.append(product_type_collection)
+        product_type_collection.update(ext_stac_collection)
 
-        return collection_list
+        # 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
+        )
 
-    def get_collections(
-        self, filters: Optional[Dict[str, Any]] = None
-    ) -> Dict[str, Any]:
-        """Build STAC collections
+        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,
+    ) -> List[Dict[str, Any]]:
+        """Build STAC collections list
 
         :param filters: (optional) Additional filters for collections search
         :type filters: dict
-        :returns: Collections dictionnary
-        :rtype: dict
+        :returns: STAC collection dicts list
+        :rtype: list
         """
-        collections = deepcopy(self.stac_config["collections"])
-        collections["collections"] = self.__get_collection_list(filters)
-
-        # # parse f-strings
-        format_args = deepcopy(self.stac_config)
-        format_args["collections"].update({"url": self.url, "root": self.root})
-
-        collections["links"] = [
-            format_dict_items(link, **format_args) for link in collections["links"]
-        ]
-
-        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"]
-        ]
-
-        self.update_data(collections)
-        return self.as_dict()
+        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
+
+        # 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)
 
-        self.update_data(collection)
-        return self.as_dict()
+        return collection_list
 
 
 class StacCatalog(StacCommon):
@@ -751,9 +895,6 @@ class StacCatalog(StacCommon):
     :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
     """
 
     def __init__(
@@ -763,8 +904,7 @@ class StacCatalog(StacCommon):
         provider: Optional[str],
         eodag_api: EODataAccessGateway,
         root: str = "/",
-        catalogs: List[str] = [],
-        fetch_providers: bool = True,
+        catalogs: Optional[List[str]] = None,
     ) -> None:
         super(StacCatalog, self).__init__(
             url=url,
@@ -791,7 +931,7 @@ class StacCatalog(StacCommon):
             self.data["links"] += self.children
 
         # build catalog
-        self.__build_stac_catalog(catalogs, fetch_providers=fetch_providers)
+        self.__build_stac_catalog(catalogs)
 
     def __update_data_from_catalog_config(self, catalog_config: Dict[str, Any]) -> bool:
         """Updates configuration and data using given input catalog config
@@ -817,40 +957,43 @@ class StacCatalog(StacCommon):
 
         return True
 
-    def set_children(self, children: List[Dict[str, Any]] = []) -> bool:
+    def set_children(self, children: Optional[List[Dict[str, Any]]] = None) -> bool:
         """Set catalog children / links
 
         :param children: (optional) Children list
         :type children: list
         """
-        self.children = children
+        self.children = children or []
         self.data["links"] = [
             link for link in self.data["links"] if link["rel"] != "child"
         ]
-        self.data["links"] += children
+        self.data["links"] += self.children
         return True
 
     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)
+        ).get_collection_list(collection=product_type)
+
+        if not collections:
+            raise NotAvailableError(f"Collection {product_type} does not exist.")
 
         cat_model = deepcopy(self.stac_config["catalogs"]["product_type"]["model"])
         # 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,13 +1003,13 @@ 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]:
+    def get_stac_years_list(self, **_: Any) -> List[int]:
         """Get catalog available years list
 
         :returns: Years list
@@ -876,7 +1019,7 @@ class StacCatalog(StacCommon):
 
         return list(range(extent_date_min.year, extent_date_max.year + 1))
 
-    def get_stac_months_list(self, **kwargs: Any) -> List[int]:
+    def get_stac_months_list(self, **_: Any) -> List[int]:
         """Get catalog available months list
 
         :returns: Months list
@@ -891,7 +1034,7 @@ class StacCatalog(StacCommon):
             )
         )
 
-    def get_stac_days_list(self, **kwargs: Any) -> List[int]:
+    def get_stac_days_list(self, **_: Any) -> List[int]:
         """Get catalog available days list
 
         :returns: Days list
@@ -905,7 +1048,7 @@ class StacCatalog(StacCommon):
             )
         )
 
-    def set_stac_year_by_id(self, year: str, **kwargs: Any) -> Dict[str, Any]:
+    def set_stac_year_by_id(self, year: str, **_: Any) -> Dict[str, Any]:
         """Updates and returns catalog with given year
 
         :param year: Year number
@@ -916,12 +1059,12 @@ class StacCatalog(StacCommon):
         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))]
+            [extent_date_min, dateutil.parser.parse(f"{year}-01-01T00:00:00Z")]
         )
         datetime_max = min(
             [
                 extent_date_max,
-                dateutil.parser.parse("{}-01-01T00:00:00Z".format((year)))
+                dateutil.parser.parse(f"{year}-01-01T00:00:00Z")
                 + relativedelta(years=1),
             ]
         )
@@ -932,7 +1075,7 @@ class StacCatalog(StacCommon):
 
         return parsed_dict
 
-    def set_stac_month_by_id(self, month: str, **kwargs: Any) -> Dict[str, Any]:
+    def set_stac_month_by_id(self, month: str, **_: Any) -> Dict[str, Any]:
         """Updates and returns catalog with given month
 
         :param month: Month number
@@ -946,13 +1089,13 @@ class StacCatalog(StacCommon):
         datetime_min = max(
             [
                 extent_date_min,
-                dateutil.parser.parse("{}-{}-01T00:00:00Z".format(year, month)),
+                dateutil.parser.parse(f"{year}-{month}-01T00:00:00Z"),
             ]
         )
         datetime_max = min(
             [
                 extent_date_max,
-                dateutil.parser.parse("{}-{}-01T00:00:00Z".format(year, month))
+                dateutil.parser.parse(f"{year}-{month}-01T00:00:00Z")
                 + relativedelta(months=1),
             ]
         )
@@ -963,7 +1106,7 @@ class StacCatalog(StacCommon):
 
         return parsed_dict
 
-    def set_stac_day_by_id(self, day: str, **kwargs: Any) -> Dict[str, Any]:
+    def set_stac_day_by_id(self, day: str, **_: Any) -> Dict[str, Any]:
         """Updates and returns catalog with given day
 
         :param day: Day number
@@ -978,13 +1121,13 @@ class StacCatalog(StacCommon):
         datetime_min = max(
             [
                 extent_date_min,
-                dateutil.parser.parse("{}-{}-{}T00:00:00Z".format(year, month, day)),
+                dateutil.parser.parse(f"{year}-{month}-{day}T00:00:00Z"),
             ]
         )
         datetime_max = min(
             [
                 extent_date_max,
-                dateutil.parser.parse("{}-{}-{}T00:00:00Z".format(year, month, day))
+                dateutil.parser.parse(f"{year}-{month}-{day}T00:00:00Z")
                 + relativedelta(days=1),
             ]
         )
@@ -1049,8 +1192,8 @@ class StacCatalog(StacCommon):
                 "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",
+                "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)
@@ -1060,15 +1203,15 @@ class StacCatalog(StacCommon):
         # update search args
         self.search_args.update(
             {
-                "dtstart": datetime_min.isoformat().split("T")[0],
-                "dtend": datetime_max.isoformat().split("T")[0],
+                "start": datetime_min.isoformat().replace("+00:00", "Z"),
+                "end": datetime_max.isoformat().replace("+00:00", "Z"),
             }
         )
         return parsed_dict
 
     # get / set cloud_cover filter --------------------------------------------
 
-    def get_stac_cloud_covers_list(self, **kwargs: Any) -> List[int]:
+    def get_stac_cloud_covers_list(self, **_: Any) -> List[int]:
         """Get cloud_cover list
 
         :returns: cloud_cover list
@@ -1076,9 +1219,7 @@ class StacCatalog(StacCommon):
         """
         return list(range(0, 101, 10))
 
-    def set_stac_cloud_cover_by_id(
-        self, cloud_cover: str, **kwargs: Any
-    ) -> Dict[str, Any]:
+    def set_stac_cloud_cover_by_id(self, cloud_cover: str, **_: Any) -> Dict[str, Any]:
         """Updates and returns catalog with given max cloud_cover
 
         :param cloud_cover: Cloud_cover number
@@ -1096,7 +1237,7 @@ class StacCatalog(StacCommon):
         self.update_data(parsed_dict)
 
         # update search args
-        self.search_args.update({"query": {"eo:cloud_cover": {"lte": cloud_cover}}})
+        self.search_args.update({"cloudCover": cloud_cover})
 
         return parsed_dict
 
@@ -1112,23 +1253,21 @@ class StacCatalog(StacCommon):
         """
 
         if catalog_name not in self.stac_config["catalogs"]:
-            logger.warning(
-                "no entry found for {} in location_config".format(catalog_name)
-            )
+            logger.warning("no entry found for %s in location_config", 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)
+                    "no %s key found for %s in location_config", 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()]
+            countries_list: List[str] = [rec[attr] for rec in shp.records()]  # type: ignore
 
         # remove duplicates
         countries_list = list(set(countries_list))
@@ -1153,7 +1292,7 @@ class StacCatalog(StacCommon):
 
         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)
+                "no entry found for %s's list in location_config", catalog_name
             )
             return {}
         location_config = self.stac_config["catalogs"][location_list_cat_key]
@@ -1161,9 +1300,7 @@ class StacCatalog(StacCommon):
         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
-                    )
+                    "no %s key found for %s's list in location_config", k, catalog_name
                 )
                 return {}
         path = location_config["path"]
@@ -1176,9 +1313,9 @@ class StacCatalog(StacCommon):
                 if shaperec.record.as_dict().get(attr, None) == location
             ]
 
-        if len(geom_hits) == 0:
+        if not geom_hits:
             logger.warning(
-                "no feature found in %s matching %s=%s" % (path, attr, location)
+                "no feature found in %s matching %s=%s", path, attr, location
             )
             return {}
 
@@ -1216,41 +1353,44 @@ class StacCatalog(StacCommon):
             )
 
             # set default child/parent for this location
-            parsed["location"]["parent_key"] = "{}_list".format(loc["name"])
+            parsed["location"]["parent_key"] = f"{loc['name']}_list"
 
-            locations_config["{}_list".format(loc["name"])] = parsed["locations_list"]
+            locations_config[f"{loc['name']}_list"] = 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:
+    def __build_stac_catalog(self, catalogs: Optional[List[str]] = None) -> 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`
         """
+        settings = Settings.from_environment()
+
         # update conf with user shp locations
         locations_config = self.build_locations_config()
 
-        self.stac_config["catalogs"] = dict(
-            deepcopy(self.stac_config["catalogs"]), **locations_config
-        )
+        self.stac_config["catalogs"] = {
+            **deepcopy(self.stac_config["catalogs"]),
+            **locations_config,
+        }
 
-        if len(catalogs) == 0:
+        if not catalogs:
             # Build root catalog combined with landing page
             self.__update_data_from_catalog_config(
                 {
-                    "model": dict(
-                        deepcopy(self.stac_config["landing_page"]),
-                        **{"provider": self.provider},
-                    )
+                    "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,
+                        },
+                    }
                 }
             )
 
@@ -1258,7 +1398,7 @@ class StacCatalog(StacCommon):
             product_types_list = [
                 pt
                 for pt in self.eodag_api.list_product_types(
-                    provider=self.provider, fetch_providers=fetch_providers
+                    provider=self.provider, fetch_providers=False
                 )
             ]
             self.set_children(
@@ -1268,16 +1408,17 @@ class StacCatalog(StacCommon):
                         "href": urljoin(
                             self.url, f"{STAC_CATALOGS_PREFIX}/{product_type['ID']}"
                         ),
-                        "title": product_type["ID"],
+                        "title": product_type["title"],
                     }
                     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"])
-            )
+            return self
+
+        # 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:
@@ -1286,12 +1427,11 @@ class StacCatalog(StacCommon):
                 cat_data_value = cat
 
                 # update data
+                cat_data_name_dict = self.stac_config["catalogs"][cat_data_name]
                 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"]
+                    f"set_stac_{cat_data_name}_by_id"
+                    if "catalog_type" not in cat_data_name_dict.keys()
+                    else f"set_stac_{cat_data_name_dict['catalog_type']}_by_id"
                 )
                 set_data_method = getattr(self, set_data_method_name)
                 set_data_method(cat_data_value, catalog_name=cat_data_name)
@@ -1355,21 +1495,20 @@ class StacCatalog(StacCommon):
                         for c in self.stac_config["catalogs"].keys()
                         if self.stac_config["catalogs"][c]["model"]["id"] == cat
                     ][0]
-                except IndexError:
+                except IndexError as e:
                     raise ValidationError(
-                        "Bad settings for %s in stac_config catalogs" % cat
-                    )
+                        f"Bad settings for {cat} in stac_config catalogs"
+                    ) from e
                 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
+                    f"get_stac_{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"]
+                    else f"get_stac_{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)
@@ -1388,11 +1527,3 @@ class StacCatalog(StacCommon):
                     )
 
         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()