add a way to serve global pre-computed results

Author: solomon-negusse

app/models/pydantic/datamart.py

@@ -1,7 +1,6 @@
 from enum import Enum
 from typing import Dict, Literal, Optional, Union
 from uuid import UUID
-from abc import ABC, abstractmethod
 
 from pydantic import Field, root_validator, validator
 
@@ -11,16 +10,15 @@
 from ...crud.geostore import get_gadm_geostore_id
 
 
-class AreaOfInterest(StrictBaseModel, ABC):
-    @abstractmethod
+class AreaOfInterest(StrictBaseModel):
     async def get_geostore_id(self) -> UUID:
         """Return the unique identifier for the area of interest."""
         pass
 
 
 class GeostoreAreaOfInterest(AreaOfInterest):
     type: Literal['geostore'] = 'geostore'
-    geostore_id:UUID = Field(..., title="Geostore ID")
+    geostore_id: UUID = Field(..., title="Geostore ID")
 
     async def get_geostore_id(self) -> UUID:
         return self.geostore_id
@@ -34,7 +32,6 @@ class AdminAreaOfInterest(AreaOfInterest):
     provider: str = Field('gadm', title="Administrative Boundary Provider")
     version: str = Field('4.1', title="Administrative Boundary Version")
 
-
     async def get_geostore_id(self) -> UUID:
         admin_level = sum(1 for field in (self.country, self.region, self.subregion) if field is not None) - 1
         geostore_id = await get_gadm_geostore_id(
@@ -64,6 +61,9 @@ def set_version_default(cls, v):
         return v or '4.1'
 
 
+class Global(AreaOfInterest):
+    type: Literal["global"] = "global"
+
 
 class AnalysisStatus(str, Enum):
     saved = "saved"
@@ -99,7 +99,7 @@ class DataMartResourceLinkResponse(Response):
 
 
 class TreeCoverLossByDriverIn(StrictBaseModel):
-    aoi: Union[GeostoreAreaOfInterest, AdminAreaOfInterest] = Field(..., discriminator='type')
+    aoi: Union[GeostoreAreaOfInterest, AdminAreaOfInterest, Global] = Field(..., discriminator='type')
     canopy_cover: int = 30
     dataset_version: Dict[str, str] = {}
 
@@ -132,6 +132,3 @@ class Config:
 
 class TreeCoverLossByDriverResponse(Response):
     data: TreeCoverLossByDriver
-
-
-

app/routes/datamart/land.py

@@ -2,7 +2,7 @@
 
 import re
 import uuid
-from typing import Dict, List, Optional
+from typing import Dict, Optional
 from uuid import UUID
 
 from fastapi import (
@@ -18,6 +18,8 @@
 from fastapi.openapi.models import APIKey
 from fastapi.responses import ORJSONResponse
 from pydantic import ValidationError
+from starlette.status import HTTP_400_BAD_REQUEST
+
 
 from app.crud import datamart as datamart_crud
 from app.errors import RecordNotFoundError
@@ -33,6 +35,7 @@
     AreaOfInterest,
     GeostoreAreaOfInterest,
     AdminAreaOfInterest,
+    Global,
 )
 from app.settings.globals import API_URL
 from app.tasks.datamart.land import (
@@ -45,6 +48,7 @@
 
 router = APIRouter()
 
+
 def _parse_dataset_versions(request: Request) -> Dict[str, str]:
     dataset_versions = {}
     errors = []
@@ -83,6 +87,9 @@ def _parse_area_of_interest(request: Request) -> AreaOfInterest:
                 version=params.get('aoi[version]', None),
             )
 
+        if aoi_type == "global":
+            return Global()
+
         # If neither type is provided, raise an error
         raise HTTPException(status_code=422, detail="Invalid Area of Interest parameters")
     except ValidationError as e:
@@ -111,6 +118,7 @@ def _parse_area_of_interest(request: Request) -> AreaOfInterest:
                     "oneOf": [
                         {"$ref": "#/components/schemas/GeostoreAreaOfInterest"},
                         {"$ref": "#/components/schemas/AdminAreaOfInterest"},
+                        {"$ref": "#/components/schemas/Global"},
                     ]
                 }
             },
@@ -129,7 +137,7 @@ def _parse_area_of_interest(request: Request) -> AreaOfInterest:
                     "tsc_tree_cover_loss_drivers": "v2023",
                 },
                 "description": (
-                        "Pass dataset version overrides as bracketed query parameters.",
+                    "Pass dataset version overrides as bracketed query parameters.",
                 )
             }
         ]
@@ -143,9 +151,9 @@ async def tree_cover_loss_by_driver_search(
     api_key: APIKey = Depends(get_api_key),
 ):
     """Search if a resource exists for a given geostore and canopy cover."""
-    geostore_id = await aoi.get_geostore_id()
+    area_id = "global" if aoi.type == "global" else await aoi.get_geostore_id()
     resource_id = _get_resource_id(
-        "tree_cover_loss_by_driver", geostore_id, canopy_cover, dataset_versions
+        "tree_cover_loss_by_driver", area_id, canopy_cover, dataset_versions
     )
 
     # check if it exists
@@ -198,41 +206,53 @@ async def tree_cover_loss_by_driver_post(
 ):
     """Create new tree cover loss by drivers resource for a given geostore and
     canopy cover."""
-    geostore_id = await data.aoi.get_geostore_id()
 
-    # check geostore is valid
-    try:
-        await get_geostore(geostore_id, GeostoreOrigin.rw)
-    except HTTPException:
-        raise HTTPException(
-            status_code=422,
-            detail=f"Geostore {geostore_id} can't be found or is not valid.",
-        )
+    area_id = "global" if data.aoi.type == "global" else await data.aoi.get_geostore_id()
 
-    # create initial Job item as pending
-    # trigger background task to create item
-    # return 202 accepted
     dataset_version = DEFAULT_LAND_DATASET_VERSIONS | data.dataset_version
     resource_id = _get_resource_id(
         "tree_cover_loss_by_driver",
-        geostore_id,
+        area_id,
         data.canopy_cover,
         dataset_version,
     )
 
+    link = DataMartResourceLink(
+        link=f"{API_URL}/v0/land/tree_cover_loss_by_driver/{resource_id}"
+    )
+    if data.aoi.type == "global":
+        try:
+            _ = await _get_resource(resource_id)
+        except HTTPException:
+            raise HTTPException(
+                HTTP_400_BAD_REQUEST,
+                detail="Global computation not supported for this dataset and pre-computed results are not available."
+            )
+
+        return DataMartResourceLinkResponse(data=link)
+
+    # check geostore is valid
+    try:
+        await get_geostore(area_id, GeostoreOrigin.rw)
+    except HTTPException:
+        raise HTTPException(
+            status_code=422,
+            detail=f"Geostore {area_id} can't be found or is not valid.",
+        )
+
+    # create initial Job item as pending
     await _save_pending_resource(resource_id, request.url.path, api_key)
 
+    # trigger background task to create item
+    # return 202 accepted
     background_tasks.add_task(
         compute_tree_cover_loss_by_driver,
         resource_id,
-        geostore_id,
+        area_id,
         data.canopy_cover,
         dataset_version,
     )
 
-    link = DataMartResourceLink(
-        link=f"{API_URL}/v0/land/tree_cover_loss_by_driver/{resource_id}"
-    )
     return DataMartResourceLinkResponse(data=link)
 
 

tests_v2/unit/app/routes/datamart/test_land.py

@@ -431,3 +431,73 @@ async def test_get_tree_cover_loss_by_drivers_found(
                     in response.json()["data"]["link"]
             )
             mock_get_resources.assert_awaited_with(resource_id)
+
+class TestGlobal:
+    @pytest.mark.asyncio
+    async def test_get_tree_cover_loss_by_drivers_found(
+            self,
+            apikey,
+            async_client: AsyncClient,
+    ):
+        with (
+            patch("app.routes.datamart.land._get_resource", return_value=None) as mock_get_resources,
+        ):
+            api_key, payload = apikey
+            origin = payload["domains"][0]
+
+            headers = {"origin": origin}
+            params = {"x-api-key": api_key, "aoi[type]": "global", "canopy_cover": 30}
+            resource_id = _get_resource_id(
+                "tree_cover_loss_by_driver", "global", 30, DEFAULT_LAND_DATASET_VERSIONS
+            )
+
+            response = await async_client.get(
+                "/v0/land/tree_cover_loss_by_driver", headers=headers, params=params
+            )
+
+            assert response.status_code == 200
+            assert (
+                    f"/v0/land/tree_cover_loss_by_driver/{resource_id}"
+                    in response.json()["data"]["link"]
+            )
+            mock_get_resources.assert_awaited_with(resource_id)
+
+
+    @pytest.mark.asyncio
+    async def test_post_tree_cover_loss_by_drivers(
+        self,
+        apikey,
+        async_client: AsyncClient,
+    ):
+        api_key, payload = apikey
+        origin = payload["domains"][0]
+
+        headers = {"origin": origin, "x-api-key": api_key}
+        payload = {
+            "aoi": {
+                "type": "global",
+            },
+            "canopy_cover": 30,
+            "dataset_version": {"umd_tree_cover_loss": "v1.8"},
+        }
+        with (
+            patch("app.routes.datamart.land._get_resource", return_value=None) as mock_get_resources,
+        ):
+            response = await async_client.post(
+                "/v0/land/tree_cover_loss_by_driver", headers=headers, json=payload
+            )
+
+            assert response.status_code == 202
+
+            body = response.json()
+            assert body["status"] == "success"
+            assert "/v0/land/tree_cover_loss_by_driver/" in body["data"]["link"]
+
+            resource_id = body["data"]["link"].split("/")[-1]
+            try:
+                resource_id = uuid.UUID(resource_id)
+                assert True
+            except ValueError:
+                assert False
+
+            mock_get_resources.assert_awaited_with(resource_id)