Optimize Visualization Page load

Author: daniel-slaugh

domains/sta/services/datastream.py

@@ -204,6 +204,105 @@ def list(
             for datastream in queryset.all()
         ]
 
+    def list_visualization_bootstrap(
+        self,
+        principal: Optional[User | APIKey],
+        filtering: Optional[dict] = None,
+    ) -> dict[str, Sequence[dict]]:
+        filtering = filtering or {}
+        queryset = Datastream.objects.visible(principal=principal)
+
+        if "thing__workspace_id" in filtering:
+            queryset = self.apply_filters(
+                queryset,
+                "thing__workspace_id",
+                filtering["thing__workspace_id"],
+            )
+
+        datastream_rows = list(
+            queryset.select_related("thing", "observed_property", "processing_level")
+            .order_by("id")
+            .values(
+                "id",
+                "name",
+                "thing_id",
+                "thing__workspace_id",
+                "thing__name",
+                "thing__sampling_feature_code",
+                "observed_property_id",
+                "observed_property__name",
+                "observed_property__code",
+                "processing_level_id",
+                "processing_level__definition",
+                "unit_id",
+                "no_data_value",
+                "value_count",
+                "phenomenon_begin_time",
+                "phenomenon_end_time",
+                "intended_time_spacing",
+                "intended_time_spacing_unit",
+            )
+            .distinct()
+        )
+
+        things_by_id: dict[str, dict] = {}
+        observed_properties_by_id: dict[str, dict] = {}
+        processing_levels_by_id: dict[str, dict] = {}
+        datastreams: list[dict] = []
+
+        for row in datastream_rows:
+            thing_id = str(row["thing_id"])
+            observed_property_id = str(row["observed_property_id"])
+            processing_level_id = str(row["processing_level_id"])
+
+            things_by_id.setdefault(
+                thing_id,
+                {
+                    "id": thing_id,
+                    "workspace_id": str(row["thing__workspace_id"]),
+                    "name": row["thing__name"],
+                    "sampling_feature_code": row["thing__sampling_feature_code"],
+                },
+            )
+            observed_properties_by_id.setdefault(
+                observed_property_id,
+                {
+                    "id": observed_property_id,
+                    "name": row["observed_property__name"],
+                    "code": row["observed_property__code"],
+                },
+            )
+            processing_levels_by_id.setdefault(
+                processing_level_id,
+                {
+                    "id": processing_level_id,
+                    "definition": row["processing_level__definition"],
+                },
+            )
+            datastreams.append(
+                {
+                    "id": str(row["id"]),
+                    "name": row["name"],
+                    "thing_id": thing_id,
+                    "observed_property_id": observed_property_id,
+                    "processing_level_id": processing_level_id,
+                    "unit_id": str(row["unit_id"]),
+                    "no_data_value": row["no_data_value"],
+                    "value_count": row["value_count"],
+                    "phenomenon_begin_time": row["phenomenon_begin_time"],
+                    "phenomenon_end_time": row["phenomenon_end_time"],
+                    "intended_time_spacing": row["intended_time_spacing"],
+                    "intended_time_spacing_unit": row["intended_time_spacing_unit"],
+                }
+            )
+
+        return {
+            "things": list(things_by_id.values()),
+            "datastreams": datastreams,
+            "observed_properties": list(observed_properties_by_id.values()),
+            "processing_levels": list(processing_levels_by_id.values()),
+        }
+
     def get(
         self,
         principal: Optional[User | APIKey],

interfaces/api/schemas/__init__.py

@@ -77,6 +77,8 @@
     UnitPatchBody,
 )
 from .datastream import (
+    DatastreamVisualizationBootstrapQueryParameters,
+    DatastreamVisualizationBootstrapResponse,
     DatastreamSummaryResponse,
     DatastreamDetailResponse,
     DatastreamQueryParameters,

interfaces/api/schemas/datastream.py

@@ -7,6 +7,7 @@
     BaseGetResponse,
     BasePostBody,
     BasePatchBody,
+    BaseQueryParameters,
     CollectionQueryParameters,
 )
 from .attachment import TagGetResponse, FileAttachmentGetResponse
@@ -164,6 +165,54 @@ class DatastreamQueryParameters(CollectionQueryParameters):
     )
 
 
+class DatastreamVisualizationBootstrapQueryParameters(BaseQueryParameters):
+    thing__workspace_id: list[uuid.UUID] = Query(
+        [], description="Filter visualization bootstrap datastreams by workspace ID.", alias="workspace_id"
+    )
+
+
+class VisualizationThingResponse(BaseGetResponse):
+    id: uuid.UUID
+    workspace_id: uuid.UUID
+    name: str = Field(..., max_length=200)
+    sampling_feature_code: str = Field(..., max_length=200)
+
+
+class VisualizationObservedPropertyResponse(BaseGetResponse):
+    id: uuid.UUID
+    name: str = Field(..., max_length=255)
+    code: str = Field(..., max_length=255)
+
+
+class VisualizationProcessingLevelResponse(BaseGetResponse):
+    id: uuid.UUID
+    definition: Optional[str] = None
+
+
+class VisualizationDatastreamResponse(BaseGetResponse):
+    id: uuid.UUID
+    name: str = Field(..., max_length=255)
+    thing_id: uuid.UUID
+    observed_property_id: uuid.UUID
+    processing_level_id: uuid.UUID
+    unit_id: uuid.UUID
+    no_data_value: float
+    value_count: Optional[int] = Field(None, ge=0)
+    phenomenon_begin_time: Optional[ISODatetime] = None
+    phenomenon_end_time: Optional[ISODatetime] = None
+    intended_time_spacing: Optional[float] = None
+    intended_time_spacing_unit: Optional[
+        Literal["seconds", "minutes", "hours", "days"]
+    ] = None
+
+
+class DatastreamVisualizationBootstrapResponse(BaseGetResponse):
+    things: list[VisualizationThingResponse]
+    datastreams: list[VisualizationDatastreamResponse]
+    observed_properties: list[VisualizationObservedPropertyResponse]
+    processing_levels: list[VisualizationProcessingLevelResponse]
+
+
 class DatastreamSummaryResponse(
     BaseGetResponse, DatastreamFields, DatastreamRelatedFields
 ):

interfaces/api/views/datastream.py

@@ -8,6 +8,8 @@
 from interfaces.http.request import HydroServerHttpRequest
 from interfaces.api.schemas import VocabularyQueryParameters
 from interfaces.api.schemas import (
+    DatastreamVisualizationBootstrapQueryParameters,
+    DatastreamVisualizationBootstrapResponse,
     DatastreamSummaryResponse,
     DatastreamDetailResponse,
     DatastreamQueryParameters,
@@ -55,6 +57,29 @@ def get_datastreams(
     )
 
 
+@datastream_router.get(
+    "/visualization-bootstrap",
+    auth=[session_auth, bearer_auth, apikey_auth, anonymous_auth],
+    response={
+        200: DatastreamVisualizationBootstrapResponse,
+        401: str,
+    },
+    by_alias=True,
+)
+def get_datastream_visualization_bootstrap(
+    request: HydroServerHttpRequest,
+    query: Query[DatastreamVisualizationBootstrapQueryParameters],
+):
+    """
+    Get the lean metadata required to bootstrap the visualization page.
+    """
+
+    return 200, datastream_service.list_visualization_bootstrap(
+        principal=request.principal,
+        filtering=query.dict(exclude_unset=True),
+    )
+
+
 @datastream_router.post(
     "",
     auth=[session_auth, bearer_auth, apikey_auth],

tests/sta/services/test_datastream.py

@@ -170,6 +170,83 @@ def test_list_datastream(
         assert (DatastreamSummaryResponse.from_orm(thing) for thing in result)
 
 
+def test_list_datastream_visualization_bootstrap_returns_lean_metadata():
+    bootstrap = datastream_service.list_visualization_bootstrap(principal=None)
+
+    assert bootstrap["things"] == [
+        {
+            "id": "3b7818af-eff7-4149-8517-e5cad9dc22e1",
+            "workspace_id": "6e0deaf2-a92b-421b-9ece-86783265596f",
+            "name": "Public Thing",
+            "sampling_feature_code": "UWRL",
+        }
+    ]
+    assert Counter(datastream["name"] for datastream in bootstrap["datastreams"]) == Counter(
+        ["Public Datastream 1", "Public Datastream 2"]
+    )
+    assert bootstrap["observed_properties"] == [
+        {
+            "id": "d66414cc-ff33-4e12-bbe0-2c048abd1f40",
+            "name": "Public Assigned Observed Property",
+            "code": "Public",
+        },
+        {
+            "id": "a5746e4e-f479-4476-a462-6a8f7874794d",
+            "name": "System Assigned Observed Property",
+            "code": "System",
+        },
+    ]
+    assert bootstrap["processing_levels"] == [
+        {
+            "id": "a7ff1528-e485-4def-b325-45330c1c448c",
+            "definition": "Public Assigned Processing Level",
+        },
+        {
+            "id": "90777619-9d5c-44a5-87f0-ccd5844f9cc0",
+            "definition": "System Assigned Processing Level",
+        },
+    ]
+    assert all(
+        set(datastream) == {
+            "id",
+            "name",
+            "thing_id",
+            "observed_property_id",
+            "processing_level_id",
+            "unit_id",
+            "no_data_value",
+            "value_count",
+            "phenomenon_begin_time",
+            "phenomenon_end_time",
+            "intended_time_spacing",
+            "intended_time_spacing_unit",
+        }
+        for datastream in bootstrap["datastreams"]
+    )
+
+
+def test_list_datastream_visualization_bootstrap_filters_by_workspace(get_principal):
+    bootstrap = datastream_service.list_visualization_bootstrap(
+        principal=get_principal("owner"),
+        filtering={"thing__workspace_id": ["b27c51a0-7374-462d-8a53-d97d47176c10"]},
+    )
+
+    assert Counter(datastream["name"] for datastream in bootstrap["datastreams"]) == Counter(
+        [
+            "Private Datastream 4",
+            "Private Datastream 5",
+            "Private Datastream 6",
+            "Private Datastream 7",
+        ]
+    )
+    assert Counter(thing["name"] for thing in bootstrap["things"]) == Counter(
+        [
+            "Private Thing",
+            "Public Thing Private Workspace",
+        ]
+    )
+
+
 @pytest.mark.parametrize(
     "principal, datastream, message, error_code",
     [