Add put endpoint for editing site

.bumpversion.cfg

@@ -1,7 +1,7 @@
 [bumpversion]
 commit = True
 tag = True
-current_version = 0.0.36
+current_version = 0.0.47
 
 [bumpversion:file:pv_site_api/__init__.py]
 search = __version__ = "{current_version}"

codecov.yml

@@ -0,0 +1,8 @@
+coverage:
+  status:
+    project:
+      default:
+        target: 90%
+    patch:
+      default:
+        target: 90%

pv_site_api/__init__.py

@@ -1,3 +1,25 @@
 """pv_site_api package"""
 
-__version__ = "0.0.36"
+import structlog
+
+__version__ = "0.0.47"
+
+# Add required processors and formatters to structlog
+structlog.configure(
+    processors=[
+        structlog.processors.EventRenamer("message", replace_by="_event"),
+        structlog.stdlib.PositionalArgumentsFormatter(),
+        structlog.processors.CallsiteParameterAdder(
+            [
+                structlog.processors.CallsiteParameter.FILENAME,
+                structlog.processors.CallsiteParameter.LINENO,
+            ],
+        ),
+        structlog.processors.dict_tracebacks,
+        structlog.stdlib.add_log_level,
+        structlog.processors.TimeStamper(fmt="iso"),
+        structlog.processors.StackInfoRenderer(),
+        structlog.processors.format_exc_info,
+        structlog.processors.JSONRenderer(sort_keys=True),
+    ],
+)

pv_site_api/_db_helpers.py

@@ -9,9 +9,10 @@
 import datetime as dt
 import uuid
 from collections import defaultdict
-from typing import Any
+from typing import Any, Optional
 
 import sqlalchemy as sa
+import structlog
 from pvsite_datamodel.read.generation import get_pv_generation_by_sites
 from pvsite_datamodel.sqlmodels import ForecastSQL, ForecastValueSQL, InverterSQL, SiteSQL
 from sqlalchemy.orm import Session, aliased
@@ -24,6 +25,9 @@
     SiteForecastValues,
 )
 
+logger = structlog.stdlib.get_logger()
+
+
 # Sqlalchemy rows are tricky to type: we use this to make the code more readable.
 Row = Any
 
@@ -46,6 +50,7 @@ def _get_forecasts_for_horizon(
         .where(ForecastSQL.site_uuid.in_(site_uuids))
         # Also filtering on `timestamp_utc` makes the query faster.
         .where(ForecastSQL.timestamp_utc >= start_utc - dt.timedelta(minutes=horizon_minutes))
+        .where(ForecastSQL.timestamp_utc < end_utc)
         .where(ForecastValueSQL.horizon_minutes == horizon_minutes)
         .where(ForecastValueSQL.start_utc >= start_utc)
         .where(ForecastValueSQL.start_utc < end_utc)
@@ -61,7 +66,9 @@ def _get_inverters_by_site(session: Session, site_uuid: str) -> list[Row]:
     return query.all()
 
 
-def _get_latest_forecast_by_sites(session: Session, site_uuids: list[str]) -> list[Row]:
+def _get_latest_forecast_by_sites(
+    session: Session, site_uuids: list[str], start_utc: Optional[dt.datetime] = None
+) -> list[Row]:
     """Get the latest forecast for given site uuids."""
     # Get the latest forecast for each site.
     subquery = (
@@ -77,11 +84,15 @@ def _get_latest_forecast_by_sites(session: Session, site_uuids: list[str]) -> li
     forecast_subq = aliased(ForecastSQL, subquery, name="ForecastSQL")
 
     # Join the forecast values.
-    query = (
-        session.query(forecast_subq, ForecastValueSQL)
-        .join(ForecastValueSQL)
-        .order_by(forecast_subq.timestamp_utc, ForecastValueSQL.start_utc)
-    )
+    query = session.query(forecast_subq, ForecastValueSQL)
+    query = query.join(ForecastValueSQL)
+
+    # only get future forecast values. This solves the case when a forecast is made 1 day a go,
+    # but since then, no new forecast have been made
+    if start_utc is not None:
+        query = query.filter(ForecastValueSQL.start_utc >= start_utc)
+
+    query.order_by(forecast_subq.timestamp_utc, ForecastValueSQL.start_utc)
 
     return query.all()
 
@@ -141,6 +152,8 @@ def get_forecasts_by_sites(
     This is what we show in the UI.
     """
 
+    logger.info(f"Getting forecast for {len(site_uuids)} sites")
+
     end_utc = dt.datetime.utcnow()
 
     rows_past = _get_forecasts_for_horizon(
@@ -150,9 +163,16 @@ def get_forecasts_by_sites(
         end_utc=end_utc,
         horizon_minutes=horizon_minutes,
     )
-    rows_future = _get_latest_forecast_by_sites(session, site_uuids)
+    logger.debug("Found %s past forecasts", len(rows_past))
+
+    rows_future = _get_latest_forecast_by_sites(
+        session=session, site_uuids=site_uuids, start_utc=start_utc
+    )
+    logger.debug("Found %s future forecasts", len(rows_future))
 
+    logger.debug("Formatting forecasts to pydantic objects")
     forecasts = _forecast_rows_to_pydantic(rows_past + rows_future)
+    logger.debug("Formatting forecasts to pydantic objects: done")
 
     return forecasts
 
@@ -161,13 +181,16 @@ def get_generation_by_sites(
     session: Session, site_uuids: list[str], start_utc: dt.datetime
 ) -> list[MultiplePVActual]:
     """Get the generation since yesterday (midnight) for a list of sites."""
+    logger.info(f"Getting generation for {len(site_uuids)} sites")
     rows = get_pv_generation_by_sites(
         session=session, start_utc=start_utc, site_uuids=[uuid.UUID(su) for su in site_uuids]
     )
 
     # Go through the rows and split the data by site.
     pv_actual_values_per_site: dict[str, list[PVActualValue]] = defaultdict(list)
 
+    # TODO can we speed this up?
+    logger.info("Formatting generation 1")
     for row in rows:
         site_uuid = str(row.site_uuid)
         pv_actual_values_per_site[site_uuid].append(
@@ -177,11 +200,21 @@ def get_generation_by_sites(
             )
         )
 
-    return [
+    logger.info("Formatting generation 2")
+    multiple_pv_actuals = [
         MultiplePVActual(site_uuid=site_uuid, pv_actual_values=pv_actual_values)
         for site_uuid, pv_actual_values in pv_actual_values_per_site.items()
     ]
 
+    logger.debug("Getting generation for {len(site_uuids)} sites: done")
+    return multiple_pv_actuals
+
+
+def get_sites_by_uuids(session: Session, site_uuids: list[str]) -> list[PVSiteMetadata]:
+    sites = session.query(SiteSQL).where(SiteSQL.site_uuid.in_(site_uuids)).all()
+    pydantic_sites = [site_to_pydantic(site) for site in sites]
+    return pydantic_sites
+
 
 def site_to_pydantic(site: SiteSQL) -> PVSiteMetadata:
     """Converts a SiteSQL object into a PVSiteMetadata object."""

pv_site_api/auth.py

@@ -0,0 +1,37 @@
+import jwt
+from fastapi import Depends, HTTPException
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+
+token_auth_scheme = HTTPBearer()
+
+
+class Auth:
+    """Fast api dependency that validates an JWT token."""
+
+    def __init__(self, domain: str, api_audience: str, algorithm: str):
+        self._domain = domain
+        self._api_audience = api_audience
+        self._algorithm = algorithm
+
+        self._jwks_client = jwt.PyJWKClient(f"https://{domain}/.well-known/jwks.json")
+
+    def __call__(self, auth_credentials: HTTPAuthorizationCredentials = Depends(token_auth_scheme)):
+        token = auth_credentials.credentials
+
+        try:
+            signing_key = self._jwks_client.get_signing_key_from_jwt(token).key
+        except (jwt.exceptions.PyJWKClientError, jwt.exceptions.DecodeError) as e:
+            raise HTTPException(status_code=401, detail=str(e))
+
+        try:
+            payload = jwt.decode(
+                token,
+                signing_key,
+                algorithms=self._algorithm,
+                audience=self._api_audience,
+                issuer=f"https://{self._domain}/",
+            )
+        except Exception as e:
+            raise HTTPException(status_code=401, detail=str(e))
+
+        return payload

pv_site_api/cache.py

@@ -0,0 +1,77 @@
+""" Caching utils for api"""
+import json
+import os
+from datetime import datetime, timedelta, timezone
+from functools import wraps
+
+import structlog
+
+logger = structlog.stdlib.get_logger()
+
+CACHE_TIME_SECONDS = 120
+cache_time_seconds = int(os.getenv("CACHE_TIME_SECONDS", CACHE_TIME_SECONDS))
+
+
+def cache_response(func):
+    """
+    Decorator that caches the response of a FastAPI async function.
+
+    Example:
+    ```
+        app = FastAPI()
+
+        @app.get("/")
+        @cache_response
+        async def example():
+            return {"message": "Hello World"}
+    ```
+    """
+    response = {}
+    last_updated = {}
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):  # noqa
+        nonlocal response
+        nonlocal last_updated
+
+        # get the variables that go into the route
+        # we don't want to use the cache for different variables
+        route_variables = kwargs.copy()
+
+        # drop session and user
+        for var in ["session", "user"]:
+            if var in route_variables:
+                route_variables.pop(var)
+
+        # make into string
+        route_variables = json.dumps(route_variables)
+        args_as_json = json.dumps(args)
+        function_name = func.__name__
+        key = f"{function_name}_{args_as_json}_{route_variables}"
+
+        # seeing if we need to run the function
+        now = datetime.now(tz=timezone.utc)
+        last_updated_datetime = last_updated.get(key)
+        refresh_cache = (last_updated_datetime is None) or (
+            now - timedelta(seconds=cache_time_seconds) > last_updated_datetime
+        )
+
+        # check if it's been called before
+        if last_updated_datetime is None:
+            logger.debug(f"First time this is route run for {key}")
+
+        # re-run if cache time out is up
+        elif refresh_cache:
+            logger.debug(f"Not using cache as longer than {cache_time_seconds} seconds for {key}")
+
+        if refresh_cache:
+            # calling function
+            response[key] = func(*args, **kwargs)
+            last_updated[key] = now
+            return response[key]
+        else:
+            # use cache
+            logger.debug(f"Using cache route {key}")
+            return response[key]
+
+    return wrapper