chore(repo): Typing

Author: devsjc

src/quartz_api/cmd/main.py

@@ -45,10 +45,9 @@
 from starlette.responses import FileResponse
 from starlette.staticfiles import StaticFiles
 
-from quartz_api.internal import service
+from quartz_api.internal import models, 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
 
 log = logging.getLogger(__name__)
 logging.basicConfig(level=logging.DEBUG, stream=sys.stdout)
@@ -150,7 +149,7 @@ def redoc_html() -> FileResponse:
         case _:
             raise ValueError("Invalid Auth0 configuration")
 
-    db_instance: DatabaseInterface
+    db_instance: models.DatabaseInterface
     match conf.get_string("backend.source"):
         case "quartzdb":
             db_instance = QuartzClient(
@@ -173,7 +172,11 @@ def redoc_html() -> FileResponse:
                 f"Expected one of {list(conf.get('backend').keys())}",
             )
 
-    server.dependency_overrides[get_db_client] = lambda: db_instance
+    server.dependency_overrides[models.get_db_client] = lambda: db_instance
+
+    # Add IANA timezone dependency
+    timezone: str = conf.get_string("api.timezone")
+    server.dependency_overrides[models.get_timezone] = lambda: timezone
 
     # Add middlewares
     server.add_middleware(

src/quartz_api/cmd/server.conf

@@ -13,6 +13,9 @@ api {
   routers = ${?ROUTERS}
   origins = "*"
   origins = ${?ORIGINS}
+  // The IANA timezone string to use for date/time operations
+  timezone = "UTC"
+  timezone = ${?TZ}
 }
 
 // The backend to use for the service

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

@@ -36,7 +36,7 @@ async def get_predicted_solar_power_production_for_location(
         smooth_flag: bool = True,
     ) -> list[models.PredictedPower]:
         values = await self._get_predicted_power_production_for_location(
-            location=location,
+            location_uuid=UUID(location),
             energy_source=dp.EnergySource.SOLAR,
             forecast_horizon=forecast_horizon,
             forecast_horizon_minutes=forecast_horizon_minutes,
@@ -54,7 +54,7 @@ async def get_predicted_wind_power_production_for_location(
         smooth_flag: bool = True,
     ) -> list[models.PredictedPower]:
         values = await self._get_predicted_power_production_for_location(
-            location=location,
+            location_uuid=UUID(location),
             energy_source=dp.EnergySource.WIND,
             forecast_horizon=forecast_horizon,
             forecast_horizon_minutes=forecast_horizon_minutes,
@@ -69,7 +69,7 @@ async def get_actual_solar_power_production_for_location(
         location: str,
     ) -> list[models.ActualPower]:
         values = await self._get_actual_power_production_for_location(
-            location,
+            UUID(location),
             dp.EnergySource.SOLAR,
             oauth_id=None,
         )
@@ -81,7 +81,7 @@ async def get_actual_wind_power_production_for_location(
         location: str,
     ) -> list[models.ActualPower]:
         values = await self._get_actual_power_production_for_location(
-            location,
+            UUID(location),
             dp.EnergySource.WIND,
             oauth_id=None,
         )
@@ -133,7 +133,7 @@ async def get_sites(self, authdata: dict[str, str]) -> list[models.Site]:
     @override
     async def put_site(
         self,
-        site_uuid: str,
+        site_uuid: UUID,
         site_properties: models.SiteProperties,
         authdata: dict[str, str],
     ) -> models.Site:
@@ -142,7 +142,7 @@ async def put_site(
     @override
     async def get_site_forecast(
         self,
-        site_uuid: str,
+        site_uuid: UUID,
         authdata: dict[str, str],
     ) -> list[models.PredictedPower]:
         forecast = await self._get_predicted_power_production_for_location(
@@ -155,7 +155,7 @@ async def get_site_forecast(
     @override
     async def get_site_generation(
         self,
-        site_uuid: str,
+        site_uuid: UUID,
         authdata: dict[str, str],
     ) -> list[models.ActualPower]:
         generation = await self._get_actual_power_production_for_location(
@@ -168,7 +168,7 @@ async def get_site_generation(
     @override
     async def post_site_generation(
         self,
-        site_uuid: str,
+        site_uuid: UUID,
         generation: list[models.ActualPower],
         authdata: dict[str, str],
     ) -> None:
@@ -196,7 +196,7 @@ async def get_substations(
                 substation_name=loc.location_name,
                 substation_type="primary"
                 if loc.location_type == dp.LocationType.PRIMARY_SUBSTATION
-                else "unknown",
+                else "secondary",
                 capacity_kw=loc.effective_capacity_watts // 1000.0,
                 latitude=loc.latlng.latitude,
                 longitude=loc.latlng.longitude,
@@ -288,22 +288,22 @@ async def get_substation(
 
     async def _get_actual_power_production_for_location(
         self,
-        location: str,
+        location_uuid: UUID,
         energy_source: dp.EnergySource,
         oauth_id: str | None,
     ) -> list[models.ActualPower]:
         """Local function to retrieve actual values regardless of energy type."""
         if oauth_id is not None:
             await self._check_user_access(
-                location,
+                location_uuid,
                 energy_source,
                 dp.LocationType.SITE,
                 oauth_id,
             )
 
         start, end = get_window()
         req = dp.GetObservationsAsTimeseriesRequest(
-            location_uuid=location,
+            location_uuid=location_uuid,
             observer_name="ruvnl",
             energy_source=energy_source,
             time_window=dp.TimeWindow(
@@ -324,7 +324,7 @@ async def _get_actual_power_production_for_location(
 
     async def _get_predicted_power_production_for_location(
         self,
-        location: str,
+        location_uuid: UUID,
         energy_source: dp.EnergySource,
         oauth_id: str | None,
         forecast_horizon: models.ForecastHorizon = models.ForecastHorizon.latest,
@@ -334,7 +334,7 @@ async def _get_predicted_power_production_for_location(
         """Local function to retrieve predicted values regardless of energy type."""
         if oauth_id is not None:
             _ = await self._check_user_access(
-                location,
+                location_uuid,
                 energy_source,
                 dp.LocationType.SITE,
                 oauth_id,
@@ -354,7 +354,7 @@ async def _get_predicted_power_production_for_location(
         # taking into account the desired horizon.
         # * At some point, we may want to allow the user to specify a particular forecaster.
         req = dp.GetLatestForecastsRequest(
-            location_uuid=location,
+            location_uuid=location_uuid,
             energy_source=energy_source,
             pivot_timestamp_utc=start - dt.timedelta(minutes=forecast_horizon_minutes),
         )
@@ -368,7 +368,7 @@ async def _get_predicted_power_production_for_location(
         forecaster = resp.forecasts[0].forecaster
 
         req = dp.GetForecastAsTimeseriesRequest(
-            location_uuid=location,
+            location_uuid=location_uuid,
             energy_source=energy_source,
             horizon_mins=forecast_horizon_minutes,
             time_window=dp.TimeWindow(
@@ -391,14 +391,14 @@ async def _get_predicted_power_production_for_location(
 
     async def _check_user_access(
         self,
-        location: str,
+        location_uuid: UUID,
         energy_source: dp.EnergySource,
         location_type: dp.LocationType,
         oauth_id: str,
     ) -> bool:
         """Check if a user has access to a given location."""
         req = dp.ListLocationsRequest(
-            location_uuids_filter=[location],
+            location_uuids_filter=[location_uuid],
             energy_source_filter=energy_source,
             location_type_filter=location_type,
             user_oauth_id_filter=oauth_id,
@@ -407,6 +407,6 @@ async def _check_user_access(
         if len(resp.locations) == 0:
             raise HTTPException(
                 status_code=404,
-                detail=f"No location found for UUID {location} and OAuth ID {oauth_id}",
+                detail=f"No location found for UUID {location_uuid} and OAuth ID {oauth_id}",
             )
         return True

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

@@ -133,20 +133,20 @@ async def test_get_site_forecast(self, client_mock: dp.DataPlatformDataServiceSt
         @dataclasses.dataclass
         class TestCase:
             name: str
-            site_uuid: str
+            site_uuid: uuid.UUID
             authdata: dict[str, str]
             should_error: bool
 
         testcases: list[TestCase] = [
             TestCase(
                 name="Should return forecast when user has access",
-                site_uuid=str(uuid.uuid4()),
+                site_uuid=uuid.uuid4(),
                 authdata={"sub": "access_user"},
                 should_error=False,
             ),
             TestCase(
                 name="Should raise HTTPException when user has no access",
-                site_uuid=str(uuid.uuid4()),
+                site_uuid=uuid.uuid4(),
                 authdata={"sub": "no_access_user"},
                 should_error=True,
             ),
@@ -180,20 +180,20 @@ async def test_get_site_generation(
         @dataclasses.dataclass
         class TestCase:
             name: str
-            site_uuid: str
+            site_uuid: uuid.UUID
             authdata: dict[str, str]
             should_error: bool
 
         testcases: list[TestCase] = [
             TestCase(
                 name="Should return generation when user has access",
-                site_uuid=str(uuid.uuid4()),
+                site_uuid=uuid.uuid4(),
                 authdata={"sub": "access_user"},
                 should_error=False,
             ),
             TestCase(
                 name="Should raise HTTPException when user has no access",
-                site_uuid=str(uuid.uuid4()),
+                site_uuid=uuid.uuid4(),
                 authdata={"sub": "no_access_user"},
                 should_error=True,
             ),
@@ -260,20 +260,20 @@ async def test_get_substation(
         @dataclasses.dataclass
         class TestCase:
             name: str
-            location_uuid: str
+            location_uuid: uuid.UUID
             authdata: dict[str, str]
             should_error: bool
 
         testcases: list[TestCase] = [
             TestCase(
                 name="Should return substation when user has access",
-                location_uuid=str(uuid.uuid4()),
+                location_uuid=uuid.uuid4(),
                 authdata={"sub": "access_user"},
                 should_error=False,
             ),
             TestCase(
                 name="Should raise HTTPException when user has no access",
-                location_uuid=str(uuid.uuid4()),
+                location_uuid=uuid.uuid4(),
                 authdata={"sub": "no_access_user"},
                 should_error=True,
             ),
@@ -305,15 +305,15 @@ async def test_get_substation_forecast(
         @dataclasses.dataclass
         class TestCase:
             name: str
-            substation_uuid: str
+            substation_uuid: uuid.UUID
             authdata: dict[str, str]
             expected_values: list[float]
             should_error: bool
 
         testcases: list[TestCase] = [
             TestCase(
                 name="Should return GSP-scaled forecast when user has access",
-                substation_uuid=str(uuid.uuid4()),
+                substation_uuid=uuid.uuid4(),
                 authdata={"sub": "access_user"},
                 # The forecast returns 5e5 watts for every value, and the substation's
                 # effective capacity is 1e5 watts (10% of the GSP's 1e6 watts), so
@@ -323,7 +323,7 @@ class TestCase:
             ),
             TestCase(
                 name="Should raise HTTPException when user has no access",
-                substation_uuid=str(uuid.uuid4()),
+                substation_uuid=uuid.uuid4(),
                 authdata={"sub": "no_access_user"},
                 expected_values=[],
                 should_error=True,