feat: adds cache (#10)

* feat: caches sheets and refactors

Author: jtyoung84

aind-smartsheet-service-server/README.md

@@ -13,7 +13,7 @@ Requires docker to build and run package locally.
 
 - Create a file called env/webapp.env with appropriate env variables.
 - Run `docker build -t aind-smartsheet-service-server-local:latest .`
-- Run `docker run -p 58350:58350 -p 5000:80 --env-file=env/webapp.env aind-smartsheet-service-server-local:latest`
+- Run `docker run -p 5000:80 --env-file=env/webapp.env aind-smartsheet-service-server-local:latest`
 - Service will be available at `http://localhost:5000`
 - Check docs at `http://localhost:5000/docs`
 

aind-smartsheet-service-server/pyproject.toml

@@ -18,10 +18,11 @@ dynamic = ["version"]
 
 dependencies = [
     'aind-settings-utils>=0.0.3',
-    'aind-smartsheet-api==0.2.0',
+    'smartsheet-python-sdk>=3.0',
     'pydantic>=2.0',
     'pydantic-settings>=2.0',
     'fastapi[standard]>=0.114.0',
+    'fastapi-cache2[redis]>=0.2.2',
 ]
 
 [project.optional-dependencies]

aind-smartsheet-service-server/src/aind_smartsheet_service_server/configs.py

@@ -5,7 +5,7 @@
 from aind_settings_utils.aws import (
     ParameterStoreAppBaseSettings,
 )
-from pydantic import Field, SecretStr
+from pydantic import Field, RedisDsn, SecretStr
 from pydantic_settings import SettingsConfigDict
 
 
@@ -32,6 +32,12 @@ class Settings(ParameterStoreAppBaseSettings):
     protocols_id: int = Field(
         ..., description="SmartSheet ID of protocols info"
     )
+    redis_url: Optional[RedisDsn] = Field(default=None)
     model_config = SettingsConfigDict(
         env_prefix="SMARTSHEET_", case_sensitive=False
     )
+
+
+def get_settings() -> Settings:
+    """Return a settings object"""
+    return Settings()

aind-smartsheet-service-server/src/aind_smartsheet_service_server/handler.py

@@ -1,58 +1,121 @@
 """Module to handle smartsheet api responses"""
 
-from typing import Any, List, Optional, Type
+from typing import Any, Dict, List, Optional, Type, TypeVar
 
-from aind_smartsheet_api.client import SmartsheetClient
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
 
 from aind_smartsheet_service_server.models import (
     FundingModel,
     PerfusionsModel,
     ProtocolsModel,
+    SheetFields,
+    SheetRow,
 )
 
+T = TypeVar("T", bound=BaseModel)
 
-class SessionHandler:
-    """Handle session object to get data"""
 
-    def __init__(self, session: SmartsheetClient):
+class SheetHandler:
+    """Handle raw sheet object"""
+
+    def __init__(self, raw_sheet: str, validate: bool = True):
         """Class constructor"""
-        self.session = session
+        self.raw_sheet = raw_sheet
+        self.validate = validate
+
+    def _get_sheet_fields(self) -> SheetFields:
+        """
+        Returns
+        -------
+        SheetFields
+
+        """
+        return SheetFields.model_validate_json(self.raw_sheet)
 
-    def get_parsed_sheet(
-        self, sheet_id: int, model: Type[BaseModel]
-    ) -> List[Any]:
+    @staticmethod
+    def _column_id_map(sheet_fields: SheetFields) -> Dict[int, str]:
         """
-        Converts the rows in a Smart Sheet into a Pydantic model
+        SmartSheet uses integer ids for the columns. We need a way to
+        map the column titles to the ids so we can retrieve information using
+        just the titles.
         Parameters
         ----------
-        sheet_id : int
-          ID number of smart sheet
-        model : Type[BaseModel]
-          Pydantic model to parse the sheet to
+        sheet_fields : SheetFields
 
         Returns
         -------
-        List[Any]
-          A list of Pydantic models
+        Dict[int, str]
 
         """
-        sheet = self.session.get_parsed_sheet_model(
-            sheet_id=sheet_id, model=model, validate=False
-        )
-        return sheet
+        return {c.id: c.title for c in sheet_fields.columns}
 
     @staticmethod
+    def _map_row_to_dict(
+        row: SheetRow, column_id_map: Dict[int, str]
+    ) -> Dict[str, Any]:
+        """
+        Maps a row into a dictionary that maps the column names to their values
+        Parameters
+        ----------
+        row : SheetRow
+          A SheetRow that will be parsed. This a list of cells with a columnId
+          and a cell value.
+        column_id_map: Dict[int, str]
+          Map of column ids into the column names
+
+        Returns
+        -------
+        Dict[str, Any]
+          The list of row cells is converted to a dictionary.
+
+        """
+        output_dict = {}
+        for cell in row.cells:
+            column_id = cell.columnId
+            column_name = column_id_map[column_id]
+            output_dict[column_name] = cell.value
+        return output_dict
+
+    def _get_parsed_sheet_model(self, model: Type[T]) -> List[T]:
+        """
+        Parse raw sheet json into basic dictionary of {"name": "value"}
+        Parameters
+        ----------
+        model : T
+          BaseModel type
+
+        Returns
+        -------
+        List[T]
+
+        """
+
+        sheet_fields = self._get_sheet_fields()
+        column_id_map = self._column_id_map(sheet_fields=sheet_fields)
+        parsed_rows = list()
+        for row in sheet_fields.rows:
+            row_dict = self._map_row_to_dict(row, column_id_map=column_id_map)
+            try:
+                row_as_model = model.model_validate(row_dict)
+                parsed_rows.append(row_as_model)
+
+            except ValidationError as e:
+                if self.validate:
+                    raise e
+                else:
+                    row_as_model = model.model_construct(**row_dict)
+                    parsed_rows.append(row_as_model)
+        return parsed_rows
+
     def get_project_funding_info(
-        sheet_model: List[FundingModel],
+        self,
         project_name: Optional[str] = None,
         subproject: Optional[str] = None,
     ) -> List[FundingModel]:
         """
         Filters funding sheet by specific project name
         Parameters
         ----------
-        sheet_model : List[FundingModel]
         project_name : str | None
         subproject : str | None
 
@@ -63,6 +126,7 @@ def get_project_funding_info(
           A list of all of that match the project name.
 
         """
+        sheet_model = self._get_parsed_sheet_model(model=FundingModel)
         filtered_rows = [
             r
             for r in sheet_model
@@ -74,20 +138,17 @@ def get_project_funding_info(
         ]
         return filtered_rows
 
-    @staticmethod
-    def get_project_names(sheet_model: List[FundingModel]) -> List[str]:
+    def get_project_names(self) -> List[str]:
         """
         Returns a sorted list of unique project names found in the Funding
         SmartSheet.
-        Parameters
-        ----------
-        sheet_model : List[FundingModel]
 
         Returns
         -------
         List[str]
 
         """
+        sheet_model = self._get_parsed_sheet_model(model=FundingModel)
         project_names = set()
         for funding_model in sheet_model:
             project_name = funding_model.project_name
@@ -99,15 +160,13 @@ def get_project_names(sheet_model: List[FundingModel]) -> List[str]:
         sorted_names = sorted(list(set(project_names)))
         return sorted_names
 
-    @staticmethod
     def get_protocols_info(
-        sheet_model: List[ProtocolsModel], protocol_name: Optional[str] = None
+        self, protocol_name: Optional[str] = None
     ) -> List[ProtocolsModel]:
         """
         Filter protocols Smartsheet by protocols name
         Parameters
         ----------
-        sheet_model : List[ProtocolsModel]
         protocol_name : str | None
 
         Returns
@@ -117,22 +176,21 @@ def get_protocols_info(
           A list of all of that match the project name.
 
         """
+        sheet_model = self._get_parsed_sheet_model(model=ProtocolsModel)
         filtered_rows = [
             r
             for r in sheet_model
             if r.protocol_name == protocol_name or protocol_name is None
         ]
         return filtered_rows
 
-    @staticmethod
     def get_perfusions_info(
-        sheet_model: List[PerfusionsModel], subject_id: Optional[str] = None
+        self, subject_id: Optional[str] = None
     ) -> List[PerfusionsModel]:
         """
 
         Parameters
         ----------
-        sheet_model : List[PerfusionsModel]
         subject_id : str | None
 
         Returns
@@ -141,6 +199,7 @@ def get_perfusions_info(
           In the event that there are multiple project names, will return
           A list of all of that match the project name.
         """
+        sheet_model = self._get_parsed_sheet_model(model=PerfusionsModel)
         filtered_rows = [
             r
             for r in sheet_model

aind-smartsheet-service-server/src/aind_smartsheet_service_server/main.py

@@ -2,12 +2,19 @@
 
 import logging
 import os
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.routing import APIRoute
+from fastapi_cache import FastAPICache
+from fastapi_cache.backends.inmemory import InMemoryBackend
+from fastapi_cache.backends.redis import RedisBackend
+from redis.asyncio import from_url  # noqa
 
 from aind_smartsheet_service_server import __version__ as service_version
+from aind_smartsheet_service_server.configs import get_settings
 from aind_smartsheet_service_server.route import router
 
 # The log level can be set by adding an environment variable before launch.
@@ -21,12 +28,26 @@
 
 """
 
+
+@asynccontextmanager
+async def lifespan(_: FastAPI) -> AsyncIterator[None]:
+    """Init cache and add to lifespan of app"""
+    settings = get_settings()
+    if settings.redis_url is not None:
+        redis = from_url(settings.redis_url)
+        FastAPICache.init(RedisBackend(redis), prefix="fastapi-cache")
+    else:
+        FastAPICache.init(InMemoryBackend(), prefix="fastapi-cache")
+    yield
+
+
 # noinspection PyTypeChecker
 app = FastAPI(
     title="aind-smartsheet-service",
     description=description,
     summary="Serves data from SmartSheet.",
     version=service_version,
+    lifespan=lifespan,
 )
 
 # noinspection PyTypeChecker