fix(dummy): Correct dummyclient

Author: devsjc

src/quartz_api/cmd/main.py

@@ -45,10 +45,10 @@
 from starlette.responses import FileResponse
 from starlette.staticfiles import StaticFiles
 
+from quartz_api.internal import service
 from quartz_api.internal.backends import DataPlatformClient, DummyClient, QuartzClient
 from quartz_api.internal.middleware import audit, auth
 from quartz_api.internal.models import DatabaseInterface, get_db_client
-from quartz_api.internal import service
 
 log = logging.getLogger(__name__)
 logging.basicConfig(level=logging.DEBUG, stream=sys.stdout)

src/quartz_api/internal/backends/dataplatform/client.py

@@ -183,23 +183,20 @@ async def save_api_call_to_db(self, url: str, authdata: dict[str, str]) -> None:
     async def get_substations(
         self,
         authdata: dict[str, str],
-    ) -> list[models.Site]:
+    ) -> list[models.Substation]:
         req = dp.ListLocationsRequest(
             energy_source_filter=dp.EnergySource.SOLAR,
             location_type_filter=dp.LocationType.PRIMARY_SUBSTATION,
             user_oauth_id_filter=authdata["sub"],
         )
         resp = await self.dp_client.list_locations(req)
         return [
-            models.Site(
-                site_uuid=loc.location_uuid,
-                client_site_name=loc.location_name,
-                orientation=loc.metadata.fields["orientation"].number_value
-                if "orientation" in loc.metadata.fields
-                else None,
-                tilt=loc.metadata.fields["tilt"].number_value
-                if "tilt" in loc.metadata.fields
-                else None,
+            models.Substation(
+                substation_uuid=loc.location_uuid,
+                substation_name=loc.location_name,
+                substation_type="primary"
+                if loc.location_type == dp.LocationType.PRIMARY_SUBSTATION
+                else "unknown",
                 capacity_kw=loc.effective_capacity_watts // 1000.0,
                 latitude=loc.latlng.latitude,
                 longitude=loc.latlng.longitude,
@@ -213,7 +210,6 @@ async def get_substation_forecast(
         substation_uuid: UUID,
         authdata: dict[str, str],
     ) -> list[models.PredictedPower]:
-
         # Get the substation
         req = dp.ListLocationsRequest(
             location_uuids_filter=[substation_uuid],
@@ -249,25 +245,25 @@ async def get_substation_forecast(
         )
 
         # Scale the forecast to the substation capacity
-        scale_factor: float = (
-            substation.effective_capacity_watts / gsp.effective_capacity_watts
-        )
+        scale_factor: float = substation.effective_capacity_watts / gsp.effective_capacity_watts
         for value in forecast:
             value.PowerKW = value.PowerKW * scale_factor
 
         log.debug(
             "gsp=%s, substation=%s, scalefactor=%s, scaling GSP to substation",
-            gsp.location_uuid, substation.location_uuid, scale_factor,
+            gsp.location_uuid,
+            substation.location_uuid,
+            scale_factor,
         )
 
         return forecast
 
     @override
-    async def get_location(
+    async def get_substation(
         self,
         location_uuid: UUID,
         authdata: dict[str, str],
-    ) -> models.SiteProperties:
+    ) -> models.SubstationProperties:
         req = dp.ListLocationsRequest(
             location_uuids_filter=[location_uuid],
             energy_source_filter=dp.EnergySource.SOLAR,
@@ -281,15 +277,9 @@ async def get_location(
             )
         loc = resp.locations[0]
 
-        return models.Site(
-            site_uuid=loc.location_uuid,
-            client_site_name=loc.location_name,
-            orientation=loc.metadata.fields["orientation"].number_value
-            if "orientation" in loc.metadata.fields
-            else None,
-            tilt=loc.metadata.fields["tilt"].number_value
-            if "tilt" in loc.metadata.fields
-            else None,
+        return models.SubstationProperties(
+            substation_name=loc.location_name,
+            substation_type="primary",
             capacity_kw=loc.effective_capacity_watts // 1000.0,
             latitude=loc.latlng.latitude,
             longitude=loc.latlng.longitude,
@@ -339,7 +329,7 @@ async def _get_predicted_power_production_for_location(
         oauth_id: str | None,
         forecast_horizon: models.ForecastHorizon = models.ForecastHorizon.latest,
         forecast_horizon_minutes: int | None = None,
-        smooth_flag: bool = True, # noqa: ARG002
+        smooth_flag: bool = True,  # noqa: ARG002
     ) -> list[models.PredictedPower]:
         """Local function to retrieve predicted values regardless of energy type."""
         if oauth_id is not None:

src/quartz_api/internal/backends/dataplatform/test_client.py

@@ -12,19 +12,19 @@
 
 TEST_TIMESTAMP_UTC = dt.datetime(2024, 2, 1, 12, 0, 0, tzinfo=dt.UTC)
 
+
 def mock_list_locations(req: dp.ListLocationsRequest) -> dp.ListLocationsResponse:
     if req.user_oauth_id_filter != "access_user":
         return dp.ListLocationsResponse(locations=[])
 
     match req.location_type_filter:
         case dp.LocationType.SITE:
-            capacity = 1e3            
+            capacity = 1e3
         case dp.LocationType.PRIMARY_SUBSTATION:
             capacity = 1e5
         case _:
             capacity = 1e6
 
-
     return dp.ListLocationsResponse(
         locations=[
             dp.ListLocationsResponseLocationSummary(
@@ -253,7 +253,7 @@ class TestCase:
                 self.assertEqual(len(resp), tc.expected_num_substations)
 
     @patch("dp_sdk.ocf.dp.DataPlatformDataServiceStub")
-    async def test_get_location(
+    async def test_get_substation(
         self,
         client_mock: dp.DataPlatformDataServiceStub,
     ) -> None:
@@ -266,7 +266,7 @@ class TestCase:
 
         testcases: list[TestCase] = [
             TestCase(
-                name="Should return location when user has access",
+                name="Should return substation when user has access",
                 location_uuid=str(uuid.uuid4()),
                 authdata={"sub": "access_user"},
                 should_error=False,
@@ -286,12 +286,12 @@ class TestCase:
             with self.subTest(tc.name):
                 if tc.should_error:
                     with self.assertRaises(HTTPException):
-                        await client.get_location(
+                        await client.get_substation(
                             location_uuid=tc.location_uuid,
                             authdata=tc.authdata,
                         )
                 else:
-                    resp = await client.get_location(
+                    resp = await client.get_substation(
                         location_uuid=tc.location_uuid,
                         authdata=tc.authdata,
                     )
@@ -350,4 +350,3 @@ class TestCase:
                     )
                     actual_values = [v.PowerKW for v in resp]
                     self.assertListEqual(actual_values, tc.expected_values)
-

src/quartz_api/internal/backends/dummydb/client.py

@@ -182,28 +182,29 @@ async def post_site_generation(
     async def get_substations(
         self,
         authdata: dict[str, str],
-    ) -> list[models.Site]:
+    ) -> list[models.Substation]:
         uuid = str(uuid4())
 
-        site = models.Site(
-            site_uuid=uuid,
-            client_site_id=1,
+        sub = models.Substation(
+            substation_uuid=uuid,
+            substation_name="Dummy Substation",
+            substation_type="primary",
             latitude=26,
             longitude=76,
             capacity_kw=76,
         )
 
-        return [site]
+        return [sub]
 
     @override
-    async def get_location(
+    async def get_substation(
         self,
         location_uuid: str,
         authdata: dict[str, str],
-    ) -> models.Site:
-        return models.Site(
-            site_uuid=uuid4(),
-            client_site_id=1,
+    ) -> models.SubstationProperties:
+        return models.SubstationProperties(
+            substation_name="Dummy Substation",
+            substation_type="primary",
             latitude=26,
             longitude=76,
             capacity_kw=76,
@@ -215,7 +216,7 @@ async def get_substation_forecast(
         location: str,
         authdata: dict[str, str],
     ) -> list[models.PredictedPower]:
-        values = self.get_predicted_solar_power_production_for_location(location="dummy")
+        values = await self.get_predicted_solar_power_production_for_location(location="dummy")
 
         return values
 

src/quartz_api/internal/backends/quartzdb/client.py

@@ -447,12 +447,12 @@ async def get_substation_forecast(
         raise NotImplementedError("QuartzDB backend does not support substations")
 
     @override
-    async def get_location(
+    async def get_substation(
         self,
         location_uuid: str,
         auth: AuthDependency,
-    ) -> models.Site:
-        raise NotImplementedError("QuartzDB backend does not support locations")
+    ) -> models.SubstationProperties:
+        raise NotImplementedError("QuartzDB backend does not support substations")
 
 def check_user_has_access_to_site(
     session: Session,

src/quartz_api/internal/models/db_interface.py

@@ -9,11 +9,11 @@
 from .endpoint_types import (
     ActualPower,
     ForecastHorizon,
-    LocationPropertiesBase,
     PredictedPower,
     Site,
     SiteProperties,
     Substation,
+    SubstationProperties,
 )
 
 
@@ -133,12 +133,12 @@ async def get_substation_forecast(
         pass
 
     @abc.abstractmethod
-    async def get_location(
+    async def get_substation(
         self,
         location_uuid: UUID,
         authdata: dict[str, str],
-    ) -> LocationPropertiesBase:
-        """Get location metadata."""
+    ) -> SubstationProperties:
+        """Get substation metadata."""
         pass
 
 def get_db_client() -> DatabaseInterface:

src/quartz_api/internal/service/substations/router.py

@@ -38,7 +38,7 @@ async def get_substation(
     auth: AuthDependency,
 ) -> models.SubstationProperties:
     """Get a substation by UUID."""
-    substation = await db.get_location(
+    substation = await db.get_substation(
         location_uuid=substation_uuid,
         authdata=auth,
     )
@@ -59,3 +59,4 @@ async def get_substation_forecast(
         authdata=auth,
     )
     return forecast
+