dara-core 1.20.1a1__py3-none-any.whl → 1.20.1a3__py3-none-any.whl

dara/core/internal/registries.py

@@ -15,8 +15,9 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
+from collections.abc import Mapping
 from datetime import datetime
-from typing import Any, Callable, Mapping, Set
+from typing import Any, Callable, Set
 
 from dara.core.auth import BaseAuthConfig
 from dara.core.base_definitions import ActionDef, ActionResolverDef, UploadResolverDef
@@ -26,23 +27,25 @@ from dara.core.definitions import (
     EndpointConfiguration,
     Template,
 )
-from dara.core.interactivity.data_variable import DataVariableRegistryEntry
 from dara.core.interactivity.derived_variable import (
     DerivedVariableRegistryEntry,
     LatestValueRegistryEntry,
 )
+from dara.core.interactivity.server_variable import ServerVariableRegistryEntry
+from dara.core.internal.download import DownloadDataEntry
 from dara.core.internal.registry import Registry, RegistryType
 from dara.core.internal.websocket import CustomClientMessagePayload
 from dara.core.persistence import BackendStoreEntry
 
-action_def_registry = Registry[ActionDef](RegistryType.ACTION_DEF, CORE_ACTIONS)   # all registered actions
-action_registry = Registry[ActionResolverDef](RegistryType.ACTION)   # functions for actions requiring backend calls
+action_def_registry = Registry[ActionDef](RegistryType.ACTION_DEF, CORE_ACTIONS)  # all registered actions
+action_registry = Registry[ActionResolverDef](RegistryType.ACTION)  # functions for actions requiring backend calls
 upload_resolver_registry = Registry[UploadResolverDef](
     RegistryType.UPLOAD_RESOLVER
-)   # functions for upload resolvers requiring backend calls
+)  # functions for upload resolvers requiring backend calls
 component_registry = Registry[ComponentTypeAnnotation](RegistryType.COMPONENTS, CORE_COMPONENTS)
 config_registry = Registry[EndpointConfiguration](RegistryType.ENDPOINT_CONFIG)
-data_variable_registry = Registry[DataVariableRegistryEntry](RegistryType.DATA_VARIABLE, allow_duplicates=False)
+server_variable_registry = Registry[ServerVariableRegistryEntry](RegistryType.SERVER_VARIABLE, allow_duplicates=False)
+"""map of server variable uid -> server variable entry"""
 derived_variable_registry = Registry[DerivedVariableRegistryEntry](
     RegistryType.DERIVED_VARIABLE, allow_duplicates=False
 )
@@ -69,3 +72,6 @@ custom_ws_handlers_registry = Registry[Callable[[str, CustomClientMessagePayload
 
 backend_store_registry = Registry[BackendStoreEntry](RegistryType.BACKEND_STORE, allow_duplicates=False)
 """map of store uid -> store instance"""
+
+download_code_registry = Registry[DownloadDataEntry](RegistryType.DOWNLOAD_CODE, allow_duplicates=False)
+"""map of download codes -> download data entry, used only to allow overriding download code behaviour via RegistryLookup"""

dara/core/internal/registry.py

@@ -16,8 +16,9 @@ limitations under the License.
 """
 
 import copy
+from collections.abc import MutableMapping
 from enum import Enum
-from typing import Generic, MutableMapping, Optional, TypeVar
+from typing import Generic, Optional, TypeVar
 
 from dara.core.metrics import CACHE_METRICS_TRACKER, total_size
 
@@ -31,7 +32,7 @@ class RegistryType(str, Enum):
     DOWNLOAD = 'Download'
     COMPONENTS = 'Components'
     ENDPOINT_CONFIG = 'Endpoint Configuration'
-    DATA_VARIABLE = 'DataVariable'
+    SERVER_VARIABLE = 'ServerVariable'
     DERIVED_VARIABLE = 'DerivedVariable'
     LAST_VALUE = 'LatestValue'
     TEMPLATE = 'Template'
@@ -43,6 +44,7 @@ class RegistryType(str, Enum):
     PENDING_TOKENS = 'Pending tokens'
     CUSTOM_WS_HANDLERS = 'Custom WS handlers'
     BACKEND_STORE = 'Backend Store'
+    DOWNLOAD_CODE = 'Download Code'
 
 
 class Registry(Generic[T]):

dara/core/internal/registry_lookup.py

@@ -15,7 +15,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 """
 
-from typing import Callable, Coroutine, Dict, Literal
+from collections.abc import Coroutine
+from typing import Callable, Dict, Literal, TypeVar, Union
 
 from dara.core.internal.registry import Registry, RegistryType
 from dara.core.internal.utils import async_dedupe
@@ -23,25 +24,30 @@ from dara.core.internal.utils import async_dedupe
 RegistryLookupKey = Literal[
     RegistryType.ACTION,
     RegistryType.COMPONENTS,
-    RegistryType.DATA_VARIABLE,
     RegistryType.DERIVED_VARIABLE,
+    RegistryType.SERVER_VARIABLE,
     RegistryType.STATIC_KWARGS,
     RegistryType.UPLOAD_RESOLVER,
     RegistryType.BACKEND_STORE,
+    RegistryType.DOWNLOAD_CODE,
 ]
 CustomRegistryLookup = Dict[RegistryLookupKey, Callable[[str], Coroutine]]
 
+RegistryType = TypeVar('RegistryType')
+
 
 class RegistryLookup:
     """
     Manages registry Lookup.
     """
 
-    def __init__(self, handlers: CustomRegistryLookup = {}):
+    def __init__(self, handlers: Union[CustomRegistryLookup, None] = None):
+        if handlers is None:
+            handlers = {}
         self.handlers = handlers
 
     @async_dedupe
-    async def get(self, registry: Registry, uid: str):
+    async def get(self, registry: Registry[RegistryType], uid: str) -> RegistryType:
         """
         Get the entry from registry by uid.
         If uid is not in registry and it has a external handler that defined, will execute the handler
@@ -62,4 +68,4 @@ class RegistryLookup:
                 return entry
             raise ValueError(
                 f'Could not find uid {uid} in {registry.name} registry, did you register it before the app was initialized?'
-            ).with_traceback(e.__traceback__)
+            ) from e

dara/core/internal/routing.py

@@ -16,14 +16,13 @@ limitations under the License.
 """
 
 import inspect
-import json
 import os
+from collections.abc import Mapping
 from functools import wraps
 from importlib.metadata import version
-from typing import Any, Callable, Dict, List, Mapping, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 import anyio
-import pandas
 from fastapi import (
     APIRouter,
     Body,
@@ -39,25 +38,28 @@ from fastapi.responses import StreamingResponse
 from pandas import DataFrame
 from pydantic import BaseModel
 from starlette.background import BackgroundTask
+from starlette.status import HTTP_415_UNSUPPORTED_MEDIA_TYPE
 
 from dara.core.auth.routes import verify_session
-from dara.core.base_definitions import ActionResolverDef, BaseTask, UploadResolverDef
+from dara.core.base_definitions import ActionResolverDef, BaseTask, NonTabularDataError, UploadResolverDef
 from dara.core.configuration import Configuration
-from dara.core.interactivity.any_data_variable import DataVariableRegistryEntry, upload
+from dara.core.interactivity.any_data_variable import upload
 from dara.core.interactivity.filtering import FilterQuery, Pagination
+from dara.core.interactivity.server_variable import ServerVariable
 from dara.core.internal.cache_store import CacheStore
 from dara.core.internal.download import DownloadRegistryEntry
 from dara.core.internal.execute_action import CURRENT_ACTION_ID
 from dara.core.internal.normalization import NormalizedPayload, denormalize, normalize
-from dara.core.internal.pandas_utils import df_to_json
+from dara.core.internal.pandas_utils import data_response_to_json, df_to_json, is_data_response
 from dara.core.internal.registries import (
     action_def_registry,
     action_registry,
     backend_store_registry,
     component_registry,
-    data_variable_registry,
     derived_variable_registry,
+    download_code_registry,
     latest_value_registry,
+    server_variable_registry,
     static_kwargs_registry,
     template_registry,
     upload_resolver_registry,
@@ -86,7 +88,7 @@ def error_decorator(handler: Callable[..., Any]):
                 if isinstance(err, HTTPException):
                     raise err
                 dev_logger.error('Unhandled error', error=err)
-                raise HTTPException(status_code=500, detail=str(err))
+                raise HTTPException(status_code=500, detail=str(err)) from err
 
         return _async_inner_func
 
@@ -99,7 +101,7 @@ def error_decorator(handler: Callable[..., Any]):
             if isinstance(err, HTTPException):
                 raise err
             dev_logger.error('Unhandled error', error=err)
-            raise HTTPException(status_code=500, detail=str(err))
+            raise HTTPException(status_code=500, detail=str(err)) from err
 
     return _inner_func
 
@@ -113,7 +115,7 @@ def create_router(config: Configuration):
     core_api_router = APIRouter()
 
     @core_api_router.get('/actions', dependencies=[Depends(verify_session)])
-    async def get_actions():   # pylint: disable=unused-variable
+    async def get_actions():
         return action_def_registry.get_all().items()
 
     class ActionRequestBody(BaseModel):
@@ -133,7 +135,7 @@ def create_router(config: Configuration):
         """Execution id, unique to this request"""
 
     @core_api_router.post('/action/{uid}', dependencies=[Depends(verify_session)])
-    async def get_action(uid: str, body: ActionRequestBody):  # pylint: disable=unused-variable
+    async def get_action(uid: str, body: ActionRequestBody):
         store: CacheStore = utils_registry.get('Store')
         task_mgr: TaskManager = utils_registry.get('TaskManager')
         registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
@@ -150,7 +152,14 @@ def create_router(config: Configuration):
 
         # Execute the action - kick off a background task to run the handler
         response = await action_def.execute_action(
-            action_def, body.input, values, static_kwargs, body.execution_id, body.ws_channel, store, task_mgr
+            action_def,
+            body.input,
+            values,
+            static_kwargs,
+            body.execution_id,
+            body.ws_channel,
+            store,
+            task_mgr,
         )
 
         if isinstance(response, BaseTask):
@@ -159,15 +168,22 @@ def create_router(config: Configuration):
 
         return {'execution_id': response}
 
-    @core_api_router.get('/download')
-    async def get_download(code: str):   # pylint: disable=unused-variable
+    @core_api_router.get('/download')  # explicitly unauthenticated
+    async def get_download(code: str):
         store: CacheStore = utils_registry.get('Store')
 
         try:
             data_entry = await store.get(DownloadRegistryEntry, key=code)
 
+            # If not found directly in the store, use the override registry
+            # to check if we can get the download entry from there
             if data_entry is None:
-                raise ValueError('Invalid or expired download code')
+                registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
+                # NOTE: This will throw a Value/KeyError if the code is not found so no need to rethrow
+                data_entry = await registry_mgr.get(download_code_registry, code)
+                # We managed to find one from the lookup,
+                # remove it from the registry immediately because it's one time use
+                download_code_registry.remove(code)
 
             async_file, cleanup = await data_entry.download(data_entry)
 
@@ -188,11 +204,11 @@ def create_router(config: Configuration):
                 background=BackgroundTask(cleanup),
             )
 
-        except KeyError:
-            raise ValueError('Invalid or expired download code')
+        except (KeyError, ValueError) as e:
+            raise ValueError('Invalid or expired download code') from e
 
     @core_api_router.get('/config', dependencies=[Depends(verify_session)])
-    async def get_config():  # pylint: disable=unused-variable
+    async def get_config():
         return {
             **config.model_dump(
                 include={
@@ -209,13 +225,13 @@ def create_router(config: Configuration):
         }
 
     @core_api_router.get('/auth-config')
-    async def get_auth_config():  # pylint: disable=unused-variable
+    async def get_auth_config():
         return {
             'auth_components': config.auth_config.component_config.model_dump(),
         }
 
     @core_api_router.get('/components', dependencies=[Depends(verify_session)])
-    async def get_components(name: Optional[str] = None):  # pylint: disable=unused-variable
+    async def get_components(name: Optional[str] = None):
         """
         If name is passed, will try to register the component
 
@@ -236,7 +252,7 @@ def create_router(config: Configuration):
         ws_channel: str
 
     @core_api_router.post('/components/{component}', dependencies=[Depends(verify_session)])
-    async def get_component(component: str, body: ComponentRequestBody):  # pylint: disable=unused-variable
+    async def get_component(component: str, body: ComponentRequestBody):
         CURRENT_COMPONENT_ID.set(body.uid)
         WS_CHANNEL.set(body.ws_channel)
         store: CacheStore = utils_registry.get('Store')
@@ -265,7 +281,7 @@ def create_router(config: Configuration):
         raise HTTPException(status_code=400, detail='Requesting this type of component is not supported')
 
     @core_api_router.get('/derived-variable/{uid}/latest', dependencies=[Depends(verify_session)])
-    async def get_latest_derived_variable(uid: str):  # pylint: disable=unused-variable
+    async def get_latest_derived_variable(uid: str):
         try:
             store: CacheStore = utils_registry.get('Store')
             latest_value_entry = latest_value_registry.get(uid)
@@ -289,129 +305,67 @@ def create_router(config: Configuration):
             return latest_value
 
         except KeyError as err:
-            raise ValueError(f'Could not find latest value for derived variable with uid: {uid}').with_traceback(
-                err.__traceback__
-            )
+            raise ValueError(f'Could not find latest value for derived variable with uid: {uid}') from err
 
-    class DataVariableRequestBody(BaseModel):
+    class TabularRequestBody(BaseModel):
         filters: Optional[FilterQuery] = None
-        cache_key: Optional[str] = None
-        ws_channel: Optional[str] = None
+        ws_channel: str
+        dv_values: Optional[NormalizedPayload[List[Any]]] = None
+        """DerivedVariable values if variable is a DerivedVariable"""
+        force_key: Optional[str] = None
+        """Optional force key if variable is a DerivedVariable and a recalculation is forced"""
 
-    @core_api_router.post('/data-variable/{uid}', dependencies=[Depends(verify_session)])
-    async def get_data_variable(
+    @core_api_router.post('/tabular-variable/{uid}', dependencies=[Depends(verify_session)])
+    async def get_tabular_variable(
         uid: str,
-        body: DataVariableRequestBody,
+        body: TabularRequestBody,
         offset: Optional[int] = None,
         limit: Optional[int] = None,
         order_by: Optional[str] = None,
         index: Optional[str] = None,
-    ):   # pylint: disable=unused-variable
-        try:
-            store: CacheStore = utils_registry.get('Store')
-            task_mgr: TaskManager = utils_registry.get('TaskManager')
-            registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
-            data_variable_entry: DataVariableRegistryEntry = await registry_mgr.get(data_variable_registry, uid)
-
-            data = None
-            WS_CHANNEL.set(body.ws_channel)
-
-            if data_variable_entry.type == 'derived':
-                if body.cache_key is None:
-                    raise HTTPException(status_code=400, detail='Cache key is required for derived data variables')
-
-                if body.ws_channel is None:
-                    raise HTTPException(
-                        status_code=400, detail='Websocket channel is required for derived data variables'
-                    )
-
-                derived_variable_entry = await registry_mgr.get(derived_variable_registry, uid)
-
-                data = await data_variable_entry.get_data(
-                    derived_variable_entry,
-                    data_variable_entry,
-                    body.cache_key,
-                    store,
-                    body.filters,
-                    Pagination(offset=offset, limit=limit, orderBy=order_by, index=index),
-                    format_for_display=True,
-                )
-                if isinstance(data, BaseTask):
-                    await task_mgr.run_task(data, body.ws_channel)
-                    return {'task_id': data.task_id}
-            elif data_variable_entry.type == 'plain':
-                data = await data_variable_entry.get_data(
-                    data_variable_entry,
-                    store,
-                    body.filters,
-                    Pagination(offset=offset, limit=limit, orderBy=order_by, index=index),
-                    format_for_display=True,
-                )
-
-            dev_logger.debug(
-                f'DataVariable {data_variable_entry.uid[:3]}..{data_variable_entry.uid[-3:]}',
-                'return value',
-                {'value': data.describe() if isinstance(data, pandas.DataFrame) else None, 'uid': uid},  # type: ignore
-            )
-
-            if data is None:
-                return None
-
-            # Explicitly convert to JSON to avoid implicit serialization;
-            # return as records as that makes more sense in a JSON structure
-            return Response(
-                content=df_to_json(data) if isinstance(data, pandas.DataFrame) else data, media_type='application/json'
-            )   # type: ignore
-        except ValueError as e:
-            raise HTTPException(status_code=400, detail=str(e))
-
-    class DataVariableCountRequestBody(BaseModel):
-        cache_key: Optional[str] = None
-        filters: Optional[FilterQuery] = None
+    ):
+        """
+        Generic endpoint for getting tabular data from a variable.
+        Supports ServerVariables and DerivedVariables.
+        """
+        WS_CHANNEL.set(body.ws_channel)
 
-    @core_api_router.post('/data-variable/{uid}/count', dependencies=[Depends(verify_session)])
-    async def get_data_variable_count(uid: str, body: Optional[DataVariableCountRequestBody] = None):
         try:
-            store: CacheStore = utils_registry.get('Store')
+            pagination = Pagination(offset=offset, limit=limit, orderBy=order_by, index=index)
             registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
-            variable_def = await registry_mgr.get(data_variable_registry, uid)
-
-            if variable_def.type == 'plain':
-                return await variable_def.get_total_count(
-                    variable_def, store, body.filters if body is not None else None
-                )
 
-            if body is None or body.cache_key is None:
-                raise HTTPException(
-                    status_code=400, detail="Cache key is required when requesting DerivedDataVariable's count"
-                )
+            # ServerVariable
+            if body.dv_values is None:
+                server_variable_entry = await registry_mgr.get(server_variable_registry, uid)
+                data_response = await ServerVariable.get_tabular_data(server_variable_entry, body.filters, pagination)
+                return Response(data_response_to_json(data_response), media_type='application/json')
 
-            return await variable_def.get_total_count(variable_def, store, body.cache_key, body.filters)
-        except ValueError as e:
-            raise HTTPException(status_code=400, detail=str(e))
-
-    @core_api_router.get('/data-variable/{uid}/schema', dependencies=[Depends(verify_session)])
-    async def get_data_variable_schema(uid: str, cache_key: Optional[str] = None):
-        try:
+            # DerivedVariable
             store: CacheStore = utils_registry.get('Store')
-            registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
-            data_def = await registry_mgr.get(data_variable_registry, uid)
+            task_mgr: TaskManager = utils_registry.get('TaskManager')
+            variable_def = await registry_mgr.get(derived_variable_registry, uid)
+            values = denormalize(body.dv_values.data, body.dv_values.lookup)
 
-            if data_def.type == 'plain':
-                return await data_def.get_schema(data_def, store)
+            result = await variable_def.get_tabular_data(
+                variable_def, store, task_mgr, values, body.force_key, pagination, body.filters
+            )
 
-            if cache_key is None:
-                raise HTTPException(
-                    status_code=400, detail='Cache key is required when requesting DerivedDataVariable schema'
-                )
+            if isinstance(result, BaseTask):
+                await task_mgr.run_task(result, body.ws_channel)
+                return {'task_id': result.task_id}
 
-            # Use the other registry for derived variables
-            derived_ref = await registry_mgr.get(derived_variable_registry, uid)
-            data = await data_def.get_schema(derived_ref, store, cache_key)
-            content = json.dumps(jsonable_encoder(data)) if isinstance(data, dict) else data
-            return Response(content=content, media_type='application/json')
-        except ValueError as e:
-            raise HTTPException(status_code=400, detail=str(e))
+            return Response(data_response_to_json(result), media_type='application/json')
+        except NonTabularDataError as e:
+            raise HTTPException(status_code=HTTP_415_UNSUPPORTED_MEDIA_TYPE, detail=str(e)) from e
+
+    @core_api_router.get('/server-variable/{uid}/sequence', dependencies=[Depends(verify_session)])
+    async def get_server_variable_sequence(
+        uid: str,
+    ):
+        registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
+        server_variable_entry = await registry_mgr.get(server_variable_registry, uid)
+        seq_num = await ServerVariable.get_sequence_number(server_variable_entry)
+        return {'sequence_number': seq_num}
 
     @core_api_router.post('/data/upload', dependencies=[Depends(verify_session)])
     async def upload_data(
@@ -427,7 +381,10 @@ def create_router(config: Configuration):
         registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
 
         if data_uid is None and resolver_id is None:
-            raise HTTPException(400, 'Neither resolver_id or data_uid specified, at least one of them is required')
+            raise HTTPException(
+                400,
+                'Neither resolver_id or data_uid specified, at least one of them is required',
+            )
 
         try:
             # If resolver id is provided, run the custom
@@ -440,16 +397,15 @@ def create_router(config: Configuration):
 
             return {'status': 'SUCCESS'}
         except Exception as e:
-            raise HTTPException(status_code=400, detail=str(e))
+            raise HTTPException(status_code=400, detail=str(e)) from e
 
     class DerivedStateRequestBody(BaseModel):
         values: NormalizedPayload[List[Any]]
-        force: bool
+        force_key: Optional[str] = None
         ws_channel: str
-        is_data_variable: Optional[bool] = False
 
     @core_api_router.post('/derived-variable/{uid}', dependencies=[Depends(verify_session)])
-    async def get_derived_variable(uid: str, body: DerivedStateRequestBody):  # pylint: disable=unused-variable
+    async def get_derived_variable(uid: str, body: DerivedStateRequestBody):
         task_mgr: TaskManager = utils_registry.get('TaskManager')
         store: CacheStore = utils_registry.get('Store')
         registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
@@ -457,7 +413,7 @@ def create_router(config: Configuration):
 
         values = denormalize(body.values.data, body.values.lookup)
 
-        result = await variable_def.get_value(variable_def, store, task_mgr, values, body.force)
+        result = await variable_def.get_value(variable_def, store, task_mgr, values, body.force_key)
 
         response: Any = result
 
@@ -466,7 +422,10 @@ def create_router(config: Configuration):
         if isinstance(result['value'], BaseTask):
             # Kick off the task
             await task_mgr.run_task(result['value'], body.ws_channel)
-            response = {'task_id': result['value'].task_id, 'cache_key': result['cache_key']}
+            response = {
+                'task_id': result['value'].task_id,
+                'cache_key': result['cache_key'],
+            }
 
         dev_logger.debug(
             f'DerivedVariable {variable_def.uid[:3]}..{variable_def.uid[-3:]}',
@@ -512,7 +471,7 @@ def create_router(config: Configuration):
                 tg.start_soon(_write, store_uid, value)
 
     @core_api_router.get('/tasks/{task_id}', dependencies=[Depends(verify_session)])
-    async def get_task_result(task_id: str):   # pylint: disable=unused-variable
+    async def get_task_result(task_id: str):
         try:
             task_mgr: TaskManager = utils_registry.get('TaskManager')
             res = await task_mgr.get_result(task_id)
@@ -523,30 +482,35 @@ def create_router(config: Configuration):
                 {'value': res},
             )
 
-            # Serialize dataframes correctly
+            # Serialize dataframes correctly, either direct or as a DataResponse
             if isinstance(res, DataFrame):
-                return Response(df_to_json(res))
+                return Response(df_to_json(res), media_type='application/json')
+            elif is_data_response(res):
+                return Response(data_response_to_json(res), media_type='application/json')
 
             return res
-        except Exception as e:
-            raise ValueError(f'The result for task id {task_id} could not be found').with_traceback(e.__traceback__)
+        except Exception as err:
+            raise ValueError(f'The result for task id {task_id} could not be found') from err
 
     @core_api_router.delete('/tasks/{task_id}', dependencies=[Depends(verify_session)])
-    async def cancel_task(task_id: str):   # pylint: disable=unused-variable
+    async def cancel_task(task_id: str):
         try:
             task_mgr: TaskManager = utils_registry.get('TaskManager')
             return await task_mgr.cancel_task(task_id)
         except TaskManagerError as e:
-            dev_logger.error(f'The task id {task_id} could not be found, it may have already been cancelled', e)
+            dev_logger.error(
+                f'The task id {task_id} could not be found, it may have already been cancelled',
+                e,
+            )
 
     @core_api_router.get('/template/{template}', dependencies=[Depends(verify_session)])
-    async def get_template(template: str):  # pylint: disable=unused-variable
+    async def get_template(template: str):
         try:
             selected_template = template_registry.get(template)
             normalized_template, lookup = normalize(jsonable_encoder(selected_template))
             return {'data': normalized_template, 'lookup': lookup}
-        except KeyError:
-            raise HTTPException(status_code=404, detail=f'Template: {template}, not found in registry')
+        except KeyError as err:
+            raise HTTPException(status_code=404, detail=f'Template: {template}, not found in registry') from err
         except Exception as e:
             dev_logger.error('Something went wrong while trying to get the template', e)
 

dara/core/internal/scheduler.py

@@ -20,7 +20,7 @@ from datetime import datetime
 from multiprocessing import get_context
 from multiprocessing.process import BaseProcess
 from pickle import PicklingError
-from typing import Any, List, Optional, Union
+from typing import Any, List, Optional, Union, cast
 
 from croniter import croniter
 from pydantic import BaseModel, field_validator
@@ -56,25 +56,28 @@ class ScheduledJob(BaseModel):
             job_process = ctx.Process(target=self._refresh_timer, args=(func, args), daemon=True)
             job_process.start()
             return job_process
-        except PicklingError:
+        except PicklingError as err:
             raise PicklingError(
                 """
             Unable to pickle scheduled function. Please ensure that the function you are trying
             to schedule is not in the same file as the ConfigurationBuilder is defined and that
             the function is not a lambda.
             """
-            )
+            ) from err
 
     def _refresh_timer(self, func, args):
         while self.continue_running and not (self.run_once and not self.first_execution):
-            interval = self.interval
+            interval: int
             # If there's more than one interval to wait, i.e. this is a weekday process
-            if type(interval) == list:
+            if isinstance(self.interval, list):
                 # Wait the first interval if this is the first execution of the job
                 interval = self.interval[0] if self.first_execution else self.interval[1]
+            else:
+                interval = self.interval
+
             self.first_execution = False
             # Wait the interval and then run the job
-            time.sleep(interval)
+            time.sleep(cast(int, interval))
             func(*args)
 
 
@@ -176,7 +179,7 @@ class ScheduledJobFactory(BaseModel):
 
     @field_validator('weekday', mode='before')
     @classmethod
-    def validate_weekday(cls, weekday: Any) -> datetime:  # pylint: disable=E0213
+    def validate_weekday(cls, weekday: Any) -> datetime:
         if isinstance(weekday, datetime):
             return weekday
         if isinstance(weekday, str):
@@ -283,7 +286,9 @@ class Scheduler:
     def _weekday(self, weekday: int):
         # The job must execute on a weekly interval
         return ScheduledJobFactory(
-            interval=self.interval * 604800, run_once=self._run_once, weekday=str(weekday)  # type: ignore
+            interval=self.interval * 604800,
+            run_once=self._run_once,
+            weekday=str(weekday),  # type: ignore
         )
 
     def monday(self) -> ScheduledJobFactory:

dara/core/internal/settings.py

@@ -74,7 +74,7 @@ def generate_env_file(filename='.env'):
         f.write(env_content)
 
 
-@lru_cache()
+@lru_cache
 def get_settings():
     """
     Get a cached instance of the settings, loading values from the .env if present.
@@ -83,7 +83,7 @@ def get_settings():
 
     # Test purposes - if DARA_TEST_FLAG is set then override env with .env.test
     if os.environ.get('DARA_TEST_FLAG', None) is not None:
-        return Settings(**dotenv_values('.env.test'))
+        return Settings(**dotenv_values('.env.test'))  # type: ignore
 
     env_error = False