refactor: adapt code to collection and provider object (#80)

- In eodag a `collection` is now an object and there is also a
`CollectionsList` and `CollectionsDict` class. This PR updates the
collections initialisation and search to the new objects.
- For providers there is a `Provider` and `ProvidersDict` class. The
method `available_providers` for the `EODataAccessGateway` is deprecated
and the `providers` property is used instead.

Author: jlahovnik

stac_fastapi/eodag/client.py

@@ -49,7 +49,7 @@ async def landing_page(self, **kwargs) -> stac.LandingPage:
                     link["title"] = "Collections"
 
         # add federation backends infos
-        federation_backends = request.app.state.dag.available_providers()
+        federation_backends = request.app.state.dag.providers.names
         federation_dict = {fb: get_federation_backend_dict(request, fb) for fb in federation_backends}
         landing_page["federation"] = federation_dict
 

stac_fastapi/eodag/core.py

@@ -38,10 +38,12 @@
 from stac_fastapi.types.rfc3339 import str_to_interval
 from stac_fastapi.types.search import BaseSearchPostRequest
 from stac_fastapi.types.stac import Collection, Collections, Item, ItemCollection
-from stac_pydantic.links import Relations
+from stac_pydantic.links import Links, Relations
 from stac_pydantic.shared import MimeTypes
 
 from eodag import EOProduct, SearchResult
+from eodag.api.collection import Collection as EodagCollection
+from eodag.api.collection import CollectionsList
 from eodag.plugins.search.build_search_result import ECMWFSearch
 from eodag.utils import deepcopy, get_geometry_from_various
 from eodag.utils.exceptions import NoMatchingCollection as EodagNoMatchingCollection
@@ -92,19 +94,19 @@ class EodagCoreClient(CustomCoreClient):
     post_request_model: type[BaseModel] = attr.ib(default=BaseSearchPostRequest)
     stac_metadata_model: type[CommonStacMetadata] = attr.ib(default=CommonStacMetadata)
 
-    def _get_collection(self, collection: dict[str, Any], request: Request) -> Collection:
+    def _get_collection(self, collection: EodagCollection, request: Request) -> Collection:
         """Convert a EODAG produt type to a STAC collection."""
 
         # extend collection with external stac collection if any
-        extended_collection = Collection(deepcopy(request.app.state.ext_stac_collections.get(collection["ID"], {})))
+        extended_collection = Collection(deepcopy(request.app.state.ext_stac_collections.get(collection.id, {})))
         extended_collection["type"] = "Collection"
 
-        platform_value = [p for p in (collection.get("platform") or "").split(",") if p]
-        constellation = [c for c in (collection.get("constellation") or "").split(",") if c]
-        processing_level = [pl for pl in (collection.get("processing:level") or "").split(",") if pl]
-        instruments = collection.get("instruments") or []
+        platform_value = [p for p in (collection.platform or "").split(",") if p]
+        constellation = [c for c in (collection.constellation or "").split(",") if c]
+        processing_level = [pl for pl in (collection.processing_level or "").split(",") if pl]
+        instruments = collection.instruments or []
 
-        federation_backends = request.app.state.dag.available_providers(collection["_id"])
+        federation_backends = request.app.state.dag.providers.filter(collection._id).names
 
         summaries: dict[str, Any] = {
             "platform": platform_value,
@@ -114,31 +116,31 @@ def _get_collection(self, collection: dict[str, Any], request: Request) -> Colle
             "federation:backends": federation_backends,
         }
         extended_collection["summaries"] = {
-            **collection.get("summaries", {}),
+            **(getattr(collection, "summaries", {}) or {}),
             **{k: v for k, v in summaries.items() if v},
         }
 
         extended_collection["extent"] = {
             "spatial": extended_collection.get("extent", {}).get("spatial")
-            or collection.get("extent", {}).get("spatial")
+            or collection.extent.spatial.to_dict()
             or {"bbox": [[-180.0, -90.0, 180.0, 90.0]]},
             "temporal": extended_collection.get("extent", {}).get("temporal")
-            or collection.get("extent", {}).get("temporal")
+            or collection.extent.temporal.to_dict()
             or {"interval": [[None, None]]},
         }
 
         for key in ["license", "description", "title"]:
-            if value := collection.get(key):
+            if value := getattr(collection, key):
                 extended_collection[key] = value
 
-        keywords = collection.get("keywords", [])
+        keywords = collection.keywords or []
         keywords = keywords.split(",") if isinstance(keywords, str) else keywords
         try:
             extended_collection["keywords"] = list(set(keywords + extended_collection.get("keywords", [])))
         except TypeError as e:
-            logger.warning("Could not merge keywords from external collection for %s: %s", collection["ID"], str(e))
+            logger.warning("Could not merge keywords from external collection for %s: %s", collection.id, str(e))
 
-        extended_collection["id"] = collection["ID"]
+        extended_collection["id"] = collection.id
 
         # keep only federation backends which allow order mechanism
         # to create "retrieve" collection links from them
@@ -155,14 +157,14 @@ def has_ecmwf_search_plugin(federation_backends, request):
         ):
             extension_names.remove("CollectionOrderExtension")
 
+        extra_links = (collection.links or Links([])).root
+        extended_coll_links = Links(extended_collection.get("links", [])).root
         extended_collection["links"] = CollectionLinks(
             collection_id=extended_collection["id"],
             request=request,
-        ).get_links(
-            extensions=extension_names, extra_links=collection.get("links", []) + extended_collection.get("links", [])
-        )
+        ).get_links(extensions=extension_names, extra_links=extra_links + extended_coll_links)
 
-        return extended_collection
+        return Collection(**extended_collection)
 
     def _search_base(self, search_request: BaseSearchPostRequest, request: Request) -> ItemCollection:
         eodag_args = prepare_search_base_args(search_request=search_request, model=self.stac_metadata_model)
@@ -175,11 +177,12 @@ def _search_base(self, search_request: BaseSearchPostRequest, request: Request)
 
         # check if the collection exists
         if collection := eodag_args.get("collection"):
-            all_pt = request.app.state.dag.list_collections(fetch_providers=False)
+            all_coll = request.app.state.dag.list_collections(fetch_providers=False)
             # only check the first collection (EODAG search only support a single collection)
-            existing_pt = [pt for pt in all_pt if pt["ID"] == collection]
-            if not existing_pt:
+            existing_coll = [coll for coll in all_coll if coll.id == collection]
+            if not existing_coll:
                 raise NoMatchingCollection(f"Collection {collection} does not exist.")
+            eodag_args["collection"] = existing_coll[0].id
         else:
             raise HTTPException(status_code=400, detail="A collection is required")
 
@@ -265,7 +268,7 @@ async def all_collections(
             provider = parsed_query.get("federation:backends")
             provider = provider[0] if isinstance(provider, list) else provider
 
-        all_pt = request.app.state.dag.list_collections(provider=provider, fetch_providers=False)
+        all_colls = request.app.state.dag.list_collections(provider=provider, fetch_providers=False)
 
         # datetime & free-text-search filters
         if any((q, datetime)):
@@ -279,31 +282,32 @@ async def all_collections(
                 guessed_collections = request.app.state.dag.guess_collection(
                     free_text=free_text, start_date=start, end_date=end
                 )
+                guessed_collections_ids = [coll.id for coll in guessed_collections]
             except EodagNoMatchingCollection:
-                collections = []
+                collections = CollectionsList([])
             else:
-                collections = [pt for pt in all_pt if pt["ID"] in guessed_collections]
+                collections = CollectionsList([coll for coll in all_colls if coll.id in guessed_collections_ids])
         else:
-            collections = all_pt
+            collections = all_colls
 
-        collections = [self._get_collection(pt, request) for pt in collections]
+        formatted_collections = [self._get_collection(coll, request) for coll in collections]
 
         # bbox filter
         if bbox:
             bbox_geom = get_geometry_from_various(geometry=bbox)
 
             default_extent = [[-180.0, -90.0, 180.0, 90.0]]
-            collections = [
+            formatted_collections = [
                 c
-                for c in collections
+                for c in formatted_collections
                 if check_poly_is_point(
                     get_geometry_from_various(  # type: ignore
                         geometry=c.get("extent", {}).get("spatial", {}).get("bbox", default_extent)[0]
                     )
                 ).intersection(bbox_geom)
             ]
 
-        total = len(collections)
+        total = len(formatted_collections)
 
         links = [
             {
@@ -318,7 +322,7 @@ async def all_collections(
             limit = limit if limit is not None else 10
             offset = offset if offset is not None else 0
 
-            collections = collections[offset : offset + limit]
+            formatted_collections = formatted_collections[offset : offset + limit]
 
             if offset + limit < total:
                 next_link = {"body": {"limit": limit, "offset": offset + limit}}
@@ -337,10 +341,10 @@ async def all_collections(
         links.extend(paging_links)
 
         return Collections(
-            collections=collections,
+            collections=formatted_collections,
             links=links,
             numberMatched=total,
-            numberReturned=len(collections),
+            numberReturned=len(formatted_collections),
         )
 
     async def get_collection(self, collection_id: str, request: Request, **kwargs: Any) -> Collection:
@@ -356,7 +360,7 @@ async def get_collection(self, collection_id: str, request: Request, **kwargs: A
         :raises NotFoundError: If the collection does not exist.
         """
         collection = next(
-            (pt for pt in request.app.state.dag.list_collections(fetch_providers=False) if pt["ID"] == collection_id),
+            (c for c in request.app.state.dag.list_collections(fetch_providers=False) if c.id == collection_id),
             None,
         )
         if collection is None:
@@ -422,7 +426,7 @@ async def item_collection(
         item_collection = self._search_base(search_request, request)
         extension_names = [type(ext).__name__ for ext in self.extensions]
         links = ItemCollectionLinks(collection_id=collection_id, request=request).get_links(
-            extensions=extension_names, extra_links=item_collection["links"]
+            extensions=extension_names, extra_links=Links(item_collection["links"]).root
         )
         item_collection["links"] = links
         return item_collection

stac_fastapi/eodag/dag.py

@@ -22,7 +22,10 @@
 import logging
 from typing import TYPE_CHECKING
 
+from stac_pydantic.collection import Extent, SpatialExtent, TimeInterval
+
 from eodag import EODataAccessGateway
+from eodag.api.collection import CollectionsList
 from eodag.utils.exceptions import (
     RequestError,
     TimeOutError,
@@ -39,7 +42,7 @@
 
 
 def fetch_external_stac_collections(
-    collections: list[dict[str, Any]],
+    collections: CollectionsList,
 ) -> dict[str, dict[str, Any]]:
     """Load external STAC collections
 
@@ -49,10 +52,10 @@ def fetch_external_stac_collections(
     ext_stac_collections: dict[str, dict[str, Any]] = {}
 
     for collection in collections:
-        file_path = collection.get("stacCollection")
+        file_path = getattr(collection, "eodag_stac_collection", None)
         if not file_path:
             continue
-        logger.info(f"Fetching external STAC collection for {collection['ID']}")
+        logger.info(f"Fetching external STAC collection for {collection.id}")
 
         try:
             ext_stac_collection = fetch_json(file_path)
@@ -63,7 +66,7 @@ def fetch_external_stac_collections(
             )
             ext_stac_collection = {}
 
-        ext_stac_collections[collection["ID"]] = ext_stac_collection
+        ext_stac_collections[collection.id] = ext_stac_collection
     return ext_stac_collections
 
 
@@ -80,8 +83,8 @@ def init_dag(app: FastAPI) -> None:
     app.state.ext_stac_collections = ext_stac_collections
 
     # update eodag collections config form external stac collections
-    for p, p_f in dag.collections_config.source.items():
-        for key in (p, p_f.get("alias")):
+    for c, c_f in dag.collections_config.items():
+        for key in (c, getattr(c_f, "alias", None)):
             if key is None:
                 continue
             ext_col = ext_stac_collections.get(key)
@@ -98,23 +101,27 @@ def init_dag(app: FastAPI) -> None:
                 constellation = ",".join(constellation)
             if isinstance(processing_level, list):
                 processing_level = ",".join(processing_level)
+            ext_extent = ext_col["extent"]
+            temporal_ext = TimeInterval(**ext_extent.get("temporal", [[None, None]]))
+            spatial_ext = SpatialExtent(**ext_extent.get("spatial", {"bbox": [[-180.0, -90.0, 180.0, 90.0]]}))
 
             update_fields: dict[str, Any] = {
-                "title": p_f.get("title") or ext_col.get("title"),
-                "description": p_f.get("description") or ext_col["description"],
+                "title": c_f.title or ext_col.get("title"),
+                "description": c_f.description or ext_col["description"],
                 "keywords": ext_col.get("keywords"),
-                "instruments": p_f.get("instruments") or instruments,
-                "platform": p_f.get("platform") or platform,
-                "constellation": p_f.get("constellation") or constellation,
-                "processing:level": p_f.get("processing:level") or processing_level,
+                "instruments": c_f.instruments or instruments,
+                "platform": c_f.platform or platform,
+                "constellation": c_f.constellation or constellation,
+                "processing_level": c_f.processing_level or processing_level,
                 "license": ext_col["license"],
-                "extent": ext_col["extent"],
+                "extent": Extent(temporal=temporal_ext, spatial=spatial_ext),
             }
             clean = {k: v for k, v in update_fields.items() if v is not None}
-            p_f.update(clean)
+            for field, value in clean.items():
+                setattr(c_f, field, value)
 
     # pre-build search plugins
-    for provider in dag.available_providers():
+    for provider in dag.providers:
         next(dag._plugins_manager.get_search_plugins(provider=provider))
 
     app.state.dag = dag

stac_fastapi/eodag/models/links.py

@@ -23,7 +23,7 @@
 import attr
 import geojson
 from stac_fastapi.types.requests import get_base_url
-from stac_pydantic.links import Relations
+from stac_pydantic.links import Link, Relations
 from stac_pydantic.shared import MimeTypes
 from starlette.requests import Request
 
@@ -105,7 +105,7 @@ def create_links(self, extensions: list[str]) -> list[dict[str, Any]]:
     def get_links(
         self,
         extensions: list[str],
-        extra_links: Optional[list[dict[str, Any]]] = None,
+        extra_links: Optional[list[Link]] = None,
         request_json: Optional[dict[str, Any]] = None,
     ) -> list[dict[str, Any]]:
         """
@@ -129,11 +129,9 @@ def get_links(
             # to be stored in pgstac and for the hrefs in the
             # links of response STAC objects to be resolved
             # to the request url.
-            links += [
-                {**link, "href": self.resolve(link["href"])}
-                for link in extra_links
-                if link["rel"] not in INFERRED_LINK_RELS
-            ]
+            for link in extra_links:
+                link.href = self.resolve(link.href)
+            links += [link.model_dump() for link in extra_links if link.rel not in INFERRED_LINK_RELS]
 
         return links
 

stac_fastapi/eodag/models/stac_metadata.py

@@ -210,20 +210,20 @@ def create_stac_metadata_model(
     return model
 
 
-def get_federation_backend_dict(request: Request, provider: str) -> dict[str, Any]:
+def get_federation_backend_dict(request: Request, provider_name: str) -> dict[str, Any]:
     """Generate Federation backend dict
 
     :param request: FastAPI request
-    :param provider: provider name
+    :param provider_name: provider name
     :return: Federation backend dictionary
     """
-    provider_config = next(
-        p for p in request.app.state.dag.providers_config.values() if provider in [p.name, getattr(p, "group", None)]
+    provider = next(
+        p for p in request.app.state.dag.providers.values() if provider_name in [p.name, getattr(p, "group", None)]
     )
     return {
-        "title": getattr(provider_config, "group", provider_config.name),
-        "description": getattr(provider_config, "description", None),
-        "url": getattr(provider_config, "url", None),
+        "title": provider.group or provider.name,
+        "description": provider.title,
+        "url": provider.url,
     }
 
 
@@ -260,9 +260,8 @@ def create_stac_item(
 
     settings: Settings = get_settings()
 
-    collection = request.app.state.dag.collections_config.source.get(product.collection, {}).get(
-        "alias", product.collection
-    )
+    collection_obj = request.app.state.dag.collections_config.get(product.collection)
+    collection = collection_obj.id if collection_obj else product.collection
 
     feature = Item(
         type="Feature",