Merge branch 'main' into singleton-httpx-client

Author: HansKallekleiv

backend_py/primary/primary/auth/auth_helper.py

@@ -12,6 +12,7 @@
 
 from primary import config
 from primary.services.utils.authenticated_user import AuthenticatedUser
+from primary.middleware.add_browser_cache import no_cache
 
 
 class AuthHelper:
@@ -24,6 +25,7 @@ def __init__(self) -> None:
             methods=["GET"],
         )
 
+    @no_cache
     async def _login_route(self, request: Request, redirect_url_after_login: Optional[str] = None) -> RedirectResponse:
         # print("######################### _login_route()")
 
@@ -55,6 +57,7 @@ async def _login_route(self, request: Request, redirect_url_after_login: Optiona
 
         return RedirectResponse(flow_dict["auth_uri"])
 
+    @no_cache
     async def _authorized_callback_route(self, request: Request) -> Response:
         # print("######################### _authorized_callback_route()")
 

backend_py/primary/primary/config.py

@@ -29,7 +29,7 @@
     "ssdl": [SSDL_RESOURCE_SCOPE],
 }
 
-print(f"{RESOURCE_SCOPES_DICT=}")
-
+DEFAULT_CACHE_MAX_AGE = 3600  # 1 hour
+DEFAULT_STALE_WHILE_REVALIDATE = 3600 * 24  # 24 hour
 REDIS_USER_SESSION_URL = "redis://redis-user-session:6379"
 REDIS_CACHE_URL = "redis://redis-cache:6379"

backend_py/primary/primary/main.py

@@ -12,6 +12,8 @@
 from primary.auth.auth_helper import AuthHelper
 from primary.auth.enforce_logged_in_middleware import EnforceLoggedInMiddleware
 from primary.middleware.add_process_time_to_server_timing_middleware import AddProcessTimeToServerTimingMiddleware
+
+from primary.middleware.add_browser_cache import AddBrowserCacheMiddleware
 from primary.routers.dev.router import router as dev_router
 from primary.routers.explore.router import router as explore_router
 from primary.routers.general import router as general_router
@@ -120,6 +122,7 @@ async def shutdown_event() -> None:
 # Also redirects to /login endpoint for some select paths
 unprotected_paths = ["/logged_in_user", "/alive", "/openapi.json"]
 paths_redirected_to_login = ["/", "/alive_protected"]
+
 app.add_middleware(
     EnforceLoggedInMiddleware,
     unprotected_paths=unprotected_paths,
@@ -133,6 +136,7 @@ async def shutdown_event() -> None:
 
 # This middleware instance measures execution time of the endpoints, including the cost of other middleware
 app.add_middleware(AddProcessTimeToServerTimingMiddleware, metric_name="total")
+app.add_middleware(AddBrowserCacheMiddleware)
 
 
 @app.get("/")

backend_py/primary/primary/middleware/add_browser_cache.py

@@ -0,0 +1,92 @@
+from functools import wraps
+from contextvars import ContextVar
+from typing import Dict, Any, Callable, Awaitable, Union, Never
+
+from starlette.datastructures import MutableHeaders
+from starlette.types import ASGIApp, Scope, Receive, Send, Message
+from primary.config import DEFAULT_CACHE_MAX_AGE, DEFAULT_STALE_WHILE_REVALIDATE
+
+# Initialize with a factory function to ensure a new dict for each context
+def get_default_context() -> Dict[str, Any]:
+    return {"max_age": DEFAULT_CACHE_MAX_AGE, "stale_while_revalidate": DEFAULT_STALE_WHILE_REVALIDATE}
+
+
+cache_context: ContextVar[Dict[str, Any]] = ContextVar("cache_context", default=get_default_context())
+
+
+def add_custom_cache_time(max_age_s: int, stale_while_revalidate_s: int = 0) -> Callable:
+    """
+    Decorator that sets a custom browser cache time for the endpoint response.
+
+    Args:
+        max_age_s (int): The maximum age in seconds for the cache
+        stale_while_revalidate_s (int): The stale-while-revalidate time in seconds
+
+    Example:
+        @add_custom_cache_time(300, 600) # 5 minutes max age, 10 minutes stale-while-revalidate
+        async def my_endpoint():
+            return {"data": "some_data"}
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(*args: Any, **kwargs: Any) -> Callable:
+            context = cache_context.get()
+            context["max_age"] = max_age_s
+            context["stale_while_revalidate"] = stale_while_revalidate_s
+
+            return await func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def no_cache(func: Callable) -> Callable:
+    """
+    Decorator that explicitly disables browser caching for the endpoint response.
+
+    Example:
+        @no_cache
+        async def my_endpoint():
+            return {"data": "some_data"}
+    """
+
+    @wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Callable:
+        context = cache_context.get()
+        context["max_age"] = 0
+        context["stale_while_revalidate"] = 0
+
+        return await func(*args, **kwargs)
+
+    return wrapper
+
+
+class AddBrowserCacheMiddleware:
+    """
+    Adds cache-control to the response headers
+    """
+
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] != "http":
+            return await self.app(scope, receive, send)
+
+        # Set initial context and store token
+        cache_context.set(get_default_context())
+
+        async def send_with_cache_header(message: Message) -> None:
+            if message["type"] == "http.response.start":
+                headers = MutableHeaders(scope=message)
+                context = cache_context.get()
+                cache_control_str = (
+                    f"max-age={context['max_age']}, stale-while-revalidate={context['stale_while_revalidate']}, private"
+                )
+                headers.append("cache-control", cache_control_str)
+
+            await send(message)
+
+        await self.app(scope, receive, send_with_cache_header)

backend_py/primary/primary/routers/explore/router.py

@@ -6,13 +6,15 @@
 from primary.services.sumo_access.case_inspector import CaseInspector
 from primary.services.sumo_access.sumo_inspector import SumoInspector
 from primary.services.utils.authenticated_user import AuthenticatedUser
+from primary.middleware.add_browser_cache import no_cache
 
 from . import schemas
 
 router = APIRouter()
 
 
 @router.get("/fields")
+@no_cache
 async def get_fields(
     authenticated_user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user),
 ) -> List[schemas.FieldInfo]:
@@ -27,6 +29,7 @@ async def get_fields(
 
 
 @router.get("/cases")
+@no_cache
 async def get_cases(
     authenticated_user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user),
     field_identifier: str = Query(description="Field identifier"),
@@ -43,6 +46,7 @@ async def get_cases(
 
 
 @router.get("/cases/{case_uuid}/ensembles")
+@no_cache
 async def get_ensembles(
     authenticated_user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user),
     case_uuid: str = Path(description="Sumo case uuid"),
@@ -55,6 +59,7 @@ async def get_ensembles(
 
 
 @router.get("/cases/{case_uuid}/ensembles/{ensemble_name}")
+@no_cache
 async def get_ensemble_details(
     authenticated_user: AuthenticatedUser = Depends(AuthHelper.get_authenticated_user),
     case_uuid: str = Path(description="Sumo case uuid"),

backend_py/primary/primary/routers/general.py

@@ -9,6 +9,7 @@
 
 from primary.auth.auth_helper import AuthHelper
 from primary.services.graph_access.graph_access import GraphApiAccess
+from primary.middleware.add_browser_cache import no_cache
 
 LOGGER = logging.getLogger(__name__)
 
@@ -25,18 +26,21 @@ class UserInfo(BaseModel):
 
 
 @router.get("/alive")
+@no_cache
 def get_alive() -> str:
     print("entering alive route")
     return f"ALIVE: Backend is alive at this time: {datetime.datetime.now()}"
 
 
 @router.get("/alive_protected")
+@no_cache
 def get_alive_protected() -> str:
     print("entering alive_protected route")
     return f"ALIVE_PROTECTED: Backend is alive at this time: {datetime.datetime.now()}"
 
 
 @router.get("/logged_in_user", response_model=UserInfo)
+@no_cache
 async def get_logged_in_user(
     request: Request,
     includeGraphApiInfo: bool = Query(  # pylint: disable=invalid-name

backend_py/primary/primary/routers/timeseries/converters.py

@@ -1,22 +1,100 @@
-from typing import List, Optional, Sequence
+from typing import Sequence
 
 from primary.services.summary_vector_statistics import VectorStatistics
-from primary.services.sumo_access.summary_access import VectorMetadata
+from primary.services.sumo_access.summary_access import RealizationVector
 from primary.services.utils.statistic_function import StatisticFunction
+from primary.services.summary_delta_vectors import RealizationDeltaVector
+from primary.services.summary_derived_vectors import DerivedVectorType, DerivedRealizationVector
 from . import schemas
 
 
+def to_api_derived_vector_type(derived_type: DerivedVectorType) -> schemas.DerivedVectorType:
+    """
+    Create API DerivedVectorType from service layer DerivedVectorType
+    """
+    return schemas.DerivedVectorType(derived_type.value)
+
+
+def to_api_derived_vector_info(derived_type: DerivedVectorType, source_vector: str) -> schemas.DerivedVectorInfo:
+    """
+    Create API DerivedVectorInfo from service layer DerivedVectorInfo
+    """
+    return schemas.DerivedVectorInfo(
+        type=to_api_derived_vector_type(derived_type),
+        sourceVector=source_vector,
+    )
+
+
+def realization_vector_list_to_api_vector_realization_data_list(
+    realization_vector_list: list[RealizationVector],
+) -> list[schemas.VectorRealizationData]:
+    """
+    Create API VectorRealizationData list from service layer RealizationVector list
+    """
+    return [
+        schemas.VectorRealizationData(
+            realization=real_vec.realization,
+            timestampsUtcMs=real_vec.timestamps_utc_ms,
+            values=real_vec.values,
+            unit=real_vec.metadata.unit,
+            isRate=real_vec.metadata.is_rate,
+        )
+        for real_vec in realization_vector_list
+    ]
+
+
+def derived_vector_realizations_to_api_vector_realization_data_list(
+    derived_realization_vector_list: list[DerivedRealizationVector], derived_vector_info: schemas.DerivedVectorInfo
+) -> list[schemas.VectorRealizationData]:
+    """
+    Create API VectorRealizationData list from service layer DerivedRealizationVector list and derived vector info
+    """
+    return [
+        schemas.VectorRealizationData(
+            realization=real_vec.realization,
+            timestampsUtcMs=real_vec.timestamps_utc_ms,
+            values=real_vec.values,
+            unit=real_vec.unit,
+            isRate=real_vec.is_rate,
+            derivedVectorInfo=derived_vector_info,
+        )
+        for real_vec in derived_realization_vector_list
+    ]
+
+
+def realization_delta_vector_list_to_api_vector_realization_data_list(
+    realization_delta_vector_list: list[RealizationDeltaVector],
+    derived_vector_info: schemas.DerivedVectorInfo | None = None,
+) -> list[schemas.VectorRealizationData]:
+    """
+    Create API VectorRealizationData list from service layer RealizationVector list
+
+    Optional derived_vector_info is included in the API VectorRealizationData if provided
+    """
+    return [
+        schemas.VectorRealizationData(
+            realization=real_vec.realization,
+            timestampsUtcMs=real_vec.timestamps_utc_ms,
+            values=real_vec.values,
+            unit=real_vec.unit,
+            isRate=real_vec.is_rate,
+            derivedVectorInfo=derived_vector_info,
+        )
+        for real_vec in realization_delta_vector_list
+    ]
+
+
 def to_service_statistic_functions(
-    api_stat_funcs: Optional[Sequence[schemas.StatisticFunction]],
-) -> Optional[List[StatisticFunction]]:
+    api_stat_funcs: Sequence[schemas.StatisticFunction] | None = None,
+) -> list[StatisticFunction] | None:
     """
     Convert incoming list of API statistic function enum values to service layer StatisticFunction enums,
     also accounting for the case where the list is None
     """
     if api_stat_funcs is None:
         return None
 
-    service_stat_funcs: List[StatisticFunction] = []
+    service_stat_funcs: list[StatisticFunction] = []
     for api_func_enum in api_stat_funcs:
         service_func_enum = StatisticFunction.from_string_value(api_func_enum.value)
         if service_func_enum:
@@ -26,36 +104,44 @@ def to_service_statistic_functions(
 
 
 def to_api_vector_statistic_data(
-    vector_statistics: VectorStatistics, vector_metadata: VectorMetadata
+    vector_statistics: VectorStatistics,
+    is_rate: bool,
+    unit: str,
+    derived_vector_info: schemas.DerivedVectorInfo | None = None,
 ) -> schemas.VectorStatisticData:
     """
     Create API VectorStatisticData from service layer VectorStatistics
     """
     value_objects = _create_statistic_value_object_list(vector_statistics)
     ret_data = schemas.VectorStatisticData(
         realizations=vector_statistics.realizations,
-        timestamps_utc_ms=vector_statistics.timestamps_utc_ms,
-        value_objects=value_objects,
-        unit=vector_metadata.unit,
-        is_rate=vector_metadata.is_rate,
+        timestampsUtcMs=vector_statistics.timestamps_utc_ms,
+        valueObjects=value_objects,
+        unit=unit,
+        isRate=is_rate,
+        derivedVectorInfo=derived_vector_info,
     )
 
     return ret_data
 
 
 def to_api_delta_ensemble_vector_statistic_data(
-    vector_statistics: VectorStatistics, is_rate: bool, unit: str
+    vector_statistics: VectorStatistics,
+    is_rate: bool,
+    unit: str,
+    derived_vector_info: schemas.DerivedVectorInfo | None = None,
 ) -> schemas.VectorStatisticData:
     """
     Create API VectorStatisticData from service layer VectorStatistics
     """
     value_objects = _create_statistic_value_object_list(vector_statistics)
     ret_data = schemas.VectorStatisticData(
         realizations=vector_statistics.realizations,
-        timestamps_utc_ms=vector_statistics.timestamps_utc_ms,
-        value_objects=value_objects,
+        timestampsUtcMs=vector_statistics.timestamps_utc_ms,
+        valueObjects=value_objects,
         unit=unit,
-        is_rate=is_rate,
+        isRate=is_rate,
+        derivedVectorInfo=derived_vector_info,
     )
 
     return ret_data
@@ -71,6 +157,6 @@ def _create_statistic_value_object_list(vector_statistics: VectorStatistics) ->
         if service_func_enum is not None:
             value_arr = vector_statistics.values_dict.get(service_func_enum)
             if value_arr is not None:
-                value_objects.append(schemas.StatisticValueObject(statistic_function=api_func_enum, values=value_arr))
+                value_objects.append(schemas.StatisticValueObject(statisticFunction=api_func_enum, values=value_arr))
 
     return value_objects