dara-core 1.20.0__py3-none-any.whl → 1.20.1a1__py3-none-any.whl

dara/core/internal/cache_store/cache_store.py

@@ -6,6 +6,7 @@ from dara.core.base_definitions import (
     LruCachePolicy,
     MostRecentCachePolicy,
     PendingTask,
+    PendingValue,
     TTLCachePolicy,
 )
 from dara.core.internal.cache_store.base_impl import CacheStoreImpl, PolicyT
@@ -22,7 +23,7 @@ def cache_impl_for_policy(policy: PolicyT) -> CacheStoreImpl[PolicyT]:
     """
     impl: Optional[CacheStoreImpl] = None
 
-    if isinstance(policy, (LruCachePolicy, MostRecentCachePolicy)):
+    if isinstance(policy, LruCachePolicy) or isinstance(policy, MostRecentCachePolicy):
         impl = LRUCache(policy)
     elif isinstance(policy, TTLCachePolicy):
         impl = TTLCache(policy)
@@ -61,24 +62,21 @@ class CacheScopeStore(Generic[PolicyT]):
 
         return await cache.delete(key)
 
-    async def get(self, key: str, unpin: bool = False, raise_for_missing: bool = False) -> Optional[Any]:
+    async def get(self, key: str, unpin: bool = False) -> Optional[Any]:
         """
         Retrieve an entry from the cache.
 
         :param key: The key of the entry to retrieve.
         :param unpin: If true, the entry will be unpinned if it is pinned.
-        :param raise_for_missing: If true, an exception will be raised if the entry is not found
         """
         scope = get_cache_scope(self.policy.cache_type)
         cache = self.caches.get(scope)
 
         # No cache for this scope yet
         if cache is None:
-            if raise_for_missing:
-                raise KeyError(f'No cache found for {scope}')
             return None
 
-        return await cache.get(key, unpin=unpin, raise_for_missing=raise_for_missing)
+        return await cache.get(key, unpin=unpin)
 
     async def set(self, key: str, value: Any, pin: bool = False):
         """
@@ -152,30 +150,21 @@ class CacheStore:
 
         return prev_entry
 
-    async def get(
-        self,
-        registry_entry: CachedRegistryEntry,
-        key: str,
-        unpin: bool = False,
-        raise_for_missing: bool = False,
-    ) -> Optional[Any]:
+    async def get(self, registry_entry: CachedRegistryEntry, key: str, unpin: bool = False) -> Optional[Any]:
         """
         Retrieve an entry from the cache for the given registry entry and cache key.
 
         :param registry_entry: The registry entry to retrieve the value for.
         :param key: The key of the entry to retrieve.
         :param unpin: If true, the entry will be unpinned if it is pinned.
-        :param raise_for_missing: If true, an exception will be raised if the entry is not found
         """
         registry_store = self.registry_stores.get(registry_entry.to_store_key())
 
         # No store for this entry yet
         if registry_store is None:
-            if raise_for_missing:
-                raise KeyError(f'No cache store found for {registry_entry.to_store_key()}')
             return None
 
-        return await registry_store.get(key, unpin=unpin, raise_for_missing=raise_for_missing)
+        return await registry_store.get(key, unpin=unpin)
 
     async def get_or_wait(self, registry_entry: CachedRegistryEntry, key: str):
         """
@@ -188,6 +177,9 @@ class CacheStore:
 
         value = await self.get(registry_entry, key)
 
+        if isinstance(value, PendingValue):
+            return await value.wait()
+
         if isinstance(value, PendingTask):
             return await value.run()
 
@@ -198,6 +190,7 @@ class CacheStore:
         registry_entry: CachedRegistryEntry,
         key: str,
         value: Any,
+        error: Optional[Exception] = None,
         pin: bool = False,
     ):
         """
@@ -220,11 +213,12 @@ class CacheStore:
 
         prev_value = await registry_store.get(key)
 
-        # If the previous value was a PendingTask, resolve it with the new value
-        # This handles cache-coordinated tasks (e.g., DerivedVariables) where PendingTasks
-        # are stored in cache to coordinate multiple callers with the same cache key
-        if isinstance(prev_value, PendingTask):
-            prev_value.resolve(value)
+        # If previous value was a PendingValue, resolve it
+        if isinstance(prev_value, PendingValue):
+            if error is not None:
+                prev_value.error(error)
+            else:
+                prev_value.resolve(value)
 
         # Update size
         self._update_size(prev_value, value)
@@ -234,6 +228,15 @@ class CacheStore:
 
         return value
 
+    async def set_pending(self, registry_entry: CachedRegistryEntry, key: str):
+        """
+        Set a pending value for the given registry entry and cache key.
+
+        :param registry_entry: The registry entry to store the value for.
+        :param key: The key of the entry to set.
+        """
+        return await self.set(registry_entry, key, PendingValue())
+
     async def clear(self):
         """
         Empty all stores.

dara/core/internal/cache_store/keep_all.py

@@ -42,21 +42,18 @@ class KeepAllCache(CacheStoreImpl[KeepAllCachePolicy]):
             del self.cache[key]
             return entry
 
-    async def get(self, key: str, unpin: bool = False, raise_for_missing: bool = False) -> Optional[Any]:
+    async def get(self, key: str, unpin: bool = False) -> Optional[Any]:
         """
         Retrieve a value from the cache.
 
         :param key: The key of the value to retrieve.
         :param unpin: This parameter is ignored in KeepAllCache as entries are never evicted.
-        :param raise_for_missing: If true, an exception will be raised if the entry is not found
         :return: The value associated with the key, or None if the key is not in the cache.
         """
         async with self.lock:
             entry = self.cache.get(key)
 
             if entry is None:
-                if raise_for_missing:
-                    raise KeyError(f'No cache entry found for {key}')
                 return None
 
             if unpin:

dara/core/internal/cache_store/lru.py

@@ -88,13 +88,12 @@ class LRUCache(CacheStoreImpl[LruCachePolicy]):
             self.cache.pop(key, None)
             return node.value
 
-    async def get(self, key: str, unpin: bool = False, raise_for_missing: bool = False) -> Optional[Any]:
+    async def get(self, key: str, unpin: bool = False) -> Optional[Any]:
         """
         Retrieve a value from the cache.
 
         :param key: The key of the value to retrieve.
         :param unpin: If true, the entry will be unpinned if it is pinned.
-        :param raise_for_missing: If true, an exception will be raised if the entry is not found
         :return: The value associated with the key, or None if the key is not in the cache.
         """
         async with self.lock:
@@ -104,9 +103,6 @@ class LRUCache(CacheStoreImpl[LruCachePolicy]):
                     node.pin = False
                 self._move_to_front(node)
                 return node.value
-
-        if raise_for_missing:
-            raise KeyError(f'No cache entry found for {key}')
         return None
 
     async def set(self, key: str, value: Any, pin: bool = False) -> None:

dara/core/internal/cache_store/ttl.py

@@ -52,13 +52,12 @@ class TTLCache(CacheStoreImpl[TTLCachePolicy]):
             _, key = heapq.heappop(self.expiration_heap)
             self.unpinned_cache.pop(key, None)
 
-    async def get(self, key: str, unpin: bool = False, raise_for_missing: bool = False) -> Any:
+    async def get(self, key: str, unpin: bool = False) -> Any:
         """
         Retrieve a value from the cache.
 
         :param key: The key of the value to retrieve.
         :param unpin: If true, the entry will be unpinned if it is pinned.
-        :param raise_for_missing: If true, an exception will be raised if the entry is not found
         :return: The value associated with the key, or None if the key is not in the cache.
         """
         async with self.lock:
@@ -76,8 +75,6 @@ class TTLCache(CacheStoreImpl[TTLCachePolicy]):
             elif key in self.unpinned_cache:
                 return self.unpinned_cache[key].value
 
-            if raise_for_missing:
-                raise KeyError(f'No cache entry found for {key}')
             return None
 
     async def set(self, key: str, value: Any, pin: bool = False) -> None:

dara/core/internal/cgroup.py

@@ -22,7 +22,7 @@ import sys
 
 from dara.core.logging import dev_logger, eng_logger
 
-CGROUP_V2_INDICATOR_PATH = '/sys/fs/cgroup/cgroup.controllers'  # Used to determine whether we're using cgroupv2
+CGROUP_V2_INDICATOR_PATH = '/sys/fs/cgroup/cgroup.controllers'   # Used to determine whether we're using cgroupv2
 
 CGROUP_V1_MEM_PATH = '/sys/fs/cgroup/memory/memory.limit_in_bytes'
 CGROUP_V2_MEM_PATH = '/sys/fs/cgroup/memory.max'

dara/core/internal/dependency_resolution.py

@@ -20,25 +20,36 @@ from typing import Any, List, Literal, Optional, Union
 from typing_extensions import TypedDict, TypeGuard
 
 from dara.core.base_definitions import BaseTask, PendingTask
-from dara.core.interactivity import DerivedVariable
-from dara.core.interactivity.server_variable import ServerVariable
+from dara.core.interactivity import DataVariable, DerivedDataVariable, DerivedVariable
+from dara.core.interactivity.filtering import FilterQuery
 from dara.core.internal.cache_store import CacheStore
+from dara.core.internal.pandas_utils import remove_index
 from dara.core.internal.registry_lookup import RegistryLookup
 from dara.core.internal.tasks import TaskManager
 from dara.core.logging import dev_logger
 
 
 class ResolvedDerivedVariable(TypedDict):
+    deps: List[int]
     type: Literal['derived']
     uid: str
     values: List[Any]
-    force_key: Optional[str]
+    force: bool
 
 
-class ResolvedServerVariable(TypedDict):
-    type: Literal['server']
+class ResolvedDerivedDataVariable(TypedDict):
+    deps: List[int]
+    type: Literal['derived-data']
+    uid: str
+    values: List[Any]
+    filters: Optional[Union[FilterQuery, dict]]
+    force: bool
+
+
+class ResolvedDataVariable(TypedDict):
+    filters: Optional[Union[FilterQuery, dict]]
+    type: Literal['data']
     uid: str
-    sequence_number: int
 
 
 class ResolvedSwitchVariable(TypedDict):
@@ -53,47 +64,21 @@ def is_resolved_derived_variable(obj: Any) -> TypeGuard[ResolvedDerivedVariable]
     return isinstance(obj, dict) and 'uid' in obj and obj.get('type') == 'derived'
 
 
-def is_resolved_server_variable(obj: Any) -> TypeGuard[ResolvedServerVariable]:
-    return isinstance(obj, dict) and 'uid' in obj and obj.get('type') == 'server'
-
-
-def is_resolved_switch_variable(obj: Any) -> TypeGuard[ResolvedSwitchVariable]:
-    return isinstance(obj, dict) and 'uid' in obj and obj.get('type') == 'switch'
+def is_resolved_derived_data_variable(obj: Any) -> TypeGuard[ResolvedDerivedDataVariable]:
+    return isinstance(obj, dict) and 'uid' in obj and obj.get('type') == 'derived-data'
 
 
-def is_forced(value: Any) -> bool:
-    """
-    Whether a value is a Derived(Data)Variable with a force_key or any of its values are forced
-    """
-    if not is_resolved_derived_variable(value):
-        return False
+def is_resolved_data_variable(obj: Any) -> TypeGuard[ResolvedDataVariable]:
+    return isinstance(obj, dict) and 'uid' in obj and obj.get('type') == 'data'
 
-    return value.get('force_key') is not None or any(is_forced(v) for v in value.get('values', []))
 
-
-def clean_force_key(value: Any) -> Any:
-    """
-    Clean an argument to a value to remove force keys
-    """
-    if value is None:
-        return value
-
-    if isinstance(value, dict):
-        # clone the dict to avoid mutating the original
-        value = value.copy()
-        # Remove force key from the value
-        value.pop('force_key', None)
-        return {k: clean_force_key(v) for k, v in value.items()}
-    if isinstance(value, list):
-        return [clean_force_key(v) for v in value]
-    return value
+def is_resolved_switch_variable(obj: Any) -> TypeGuard[ResolvedSwitchVariable]:
+    return isinstance(obj, dict) and 'uid' in obj and obj.get('type') == 'switch'
 
 
 async def resolve_dependency(
     entry: Union[
-        ResolvedDerivedVariable,
-        ResolvedSwitchVariable,
-        Any,
+        ResolvedDerivedDataVariable, ResolvedDataVariable, ResolvedDerivedVariable, ResolvedSwitchVariable, Any
     ],
     store: CacheStore,
     task_mgr: TaskManager,
@@ -106,11 +91,14 @@ async def resolve_dependency(
     :param store: store instance
     :param task_mgr: task manager instance
     """
+    if is_resolved_derived_data_variable(entry):
+        return await _resolve_derived_data_var(entry, store, task_mgr)
+
     if is_resolved_derived_variable(entry):
         return await _resolve_derived_var(entry, store, task_mgr)
 
-    if is_resolved_server_variable(entry):
-        return await _resolve_server_var(entry)
+    if is_resolved_data_variable(entry):
+        return await _resolve_data_var(entry, store)
 
     if is_resolved_switch_variable(entry):
         return await _resolve_switch_var(entry, store, task_mgr)
@@ -118,10 +106,34 @@ async def resolve_dependency(
     return entry
 
 
+async def _resolve_derived_data_var(entry: ResolvedDerivedDataVariable, store: CacheStore, task_mgr: TaskManager):
+    """
+    Resolve a derived data variable from the registry
+
+    :param entry: derived data variable entry
+    :param store: store instance to use for caching
+    :param task_mgr: task manager instance
+    """
+    from dara.core.internal.registries import (
+        data_variable_registry,
+        derived_variable_registry,
+        utils_registry,
+    )
+
+    registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
+    dv_var = await registry_mgr.get(derived_variable_registry, str(entry.get('uid')))
+    data_var = await registry_mgr.get(data_variable_registry, str(entry.get('uid')))
+
+    input_values: List[Any] = entry.get('values', [])
+
+    result = await DerivedDataVariable.resolve_value(
+        data_var, dv_var, store, task_mgr, input_values, entry.get('force', False), entry.get('filters', None)
+    )
+    return remove_index(result)
+
+
 async def _resolve_derived_var(
-    derived_variable_entry: ResolvedDerivedVariable,
-    store: CacheStore,
-    task_mgr: TaskManager,
+    derived_variable_entry: ResolvedDerivedVariable, store: CacheStore, task_mgr: TaskManager
 ):
     """
     Resolve a derived variable from the registry and get it's new value based on the dynamic variable mapping passed
@@ -137,27 +149,25 @@ async def _resolve_derived_var(
     var = await registry_mgr.get(derived_variable_registry, str(derived_variable_entry.get('uid')))
     input_values: List[Any] = derived_variable_entry.get('values', [])
     result = await DerivedVariable.get_value(
-        var_entry=var,
-        store=store,
-        task_mgr=task_mgr,
-        args=input_values,
-        force_key=derived_variable_entry.get('force_key'),
+        var, store, task_mgr, input_values, derived_variable_entry.get('force', False)
     )
     return result['value']
 
 
-async def _resolve_server_var(resolved_server_variable: ResolvedServerVariable) -> Any:
+async def _resolve_data_var(data_variable_entry: ResolvedDataVariable, store: CacheStore):
     """
-    Resolve a server variable.
+    Resolve a data variable from the registry and get it's new value based on the dynamic variable mapping passed
+    in.
 
-    :param server_variable_entry: server var entry
+    :param data_variable_entry: data var entry
     :param store: the store instance to use for caching
     """
-    from dara.core.internal.registries import server_variable_registry, utils_registry
+    from dara.core.internal.registries import data_variable_registry, utils_registry
 
     registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
-    server_var_entry = await registry_mgr.get(server_variable_registry, resolved_server_variable['uid'])
-    return await ServerVariable.get_value(server_var_entry)
+    var = await registry_mgr.get(data_variable_registry, str(data_variable_entry.get('uid')))
+    result = await DataVariable.get_value(var, store, data_variable_entry.get('filters', None))
+    return remove_index(result)
 
 
 def _normalize_lookup_key(value: Any) -> str:
@@ -218,11 +228,7 @@ def _evaluate_condition(condition: dict) -> bool:
             raise ValueError(f'Unknown condition operator: {operator}')
 
 
-async def _resolve_switch_var(
-    switch_variable_entry: ResolvedSwitchVariable,
-    store: CacheStore,
-    task_mgr: TaskManager,
-):
+async def _resolve_switch_var(switch_variable_entry: ResolvedSwitchVariable, store: CacheStore, task_mgr: TaskManager):
     """
     Resolve a switch variable by evaluating its constituent parts and returning the appropriate value.
 

dara/core/internal/devtools.py

@@ -21,26 +21,22 @@ import sys
 import traceback
 from contextlib import contextmanager
 from datetime import datetime
-from typing import Optional
 
 from dara.core.internal.websocket import WebsocketManager
 from dara.core.logging import eng_logger
 
 
-def print_stacktrace(err: Optional[BaseException] = None) -> str:
+def print_stacktrace():
     """
     Prints out the current stack trace. Will also extract any exceptions and print them at the end.
     """
-    if err is not None:
-        return ''.join(traceback.format_exception(type(err), err, err.__traceback__))
-
     exc = sys.exc_info()[0]
     stack = traceback.extract_stack()[:-1]
 
     trc = 'Traceback (most recent call last):\n'
     stackstr = trc + ''.join(traceback.format_list(stack))
     if exc is not None:
-        stackstr += '  ' + traceback.format_exc().lstrip(trc)
+        stackstr += '  ' + traceback.format_exc().lstrip(trc)   # pylint:disable=bad-str-strip-call
     else:
         stackstr += '   Exception'
 
@@ -56,17 +52,14 @@ def handle_system_exit(error_msg: str):
     try:
         yield
     except SystemExit as e:
-        raise InterruptedError(error_msg) from e
+        raise InterruptedError(error_msg).with_traceback(e.__traceback__)
 
 
-def get_error_for_channel(err: Optional[BaseException] = None) -> dict:
+def get_error_for_channel() -> dict:
     """
     Get error from current stacktrace to send to the client
     """
-    return {
-        'error': print_stacktrace(err),
-        'time': str(datetime.now()),
-    }
+    return {'error': print_stacktrace(), 'time': str(datetime.now())}
 
 
 async def send_error_for_session(ws_mgr: WebsocketManager, session_id: str):

dara/core/internal/download.py

@@ -18,9 +18,7 @@ limitations under the License.
 from __future__ import annotations
 
 import os
-from collections.abc import Awaitable
-from contextvars import ContextVar
-from typing import Callable, Optional, Tuple
+from typing import Awaitable, Callable, Optional, Tuple
 from uuid import uuid4
 
 import anyio
@@ -39,13 +37,13 @@ class DownloadDataEntry(BaseModel):
     file_path: str
     cleanup_file: bool
     identity_name: Optional[str] = None
-    download: Callable[[DownloadDataEntry], Awaitable[Tuple[anyio.AsyncFile, Callable[..., Awaitable]]]]
+    download: Callable[['DownloadDataEntry'], Awaitable[Tuple[anyio.AsyncFile, Callable[..., Awaitable]]]]
     """Handler for getting the file from the entry"""
 
 
 DownloadRegistryEntry = CachedRegistryEntry(
     uid='_dara_download', cache=Cache.Policy.TTL(ttl=60 * 10)
-)  # expire the codes after 10 minutes
+)   # expire the codes after 10 minutes
 
 
 async def download(data_entry: DownloadDataEntry) -> Tuple[anyio.AsyncFile, Callable[..., Awaitable]]:
@@ -74,13 +72,6 @@ async def download(data_entry: DownloadDataEntry) -> Tuple[anyio.AsyncFile, Call
     return (async_file, cleanup)
 
 
-GENERATE_CODE_OVERRIDE = ContextVar[Optional[Callable[[str], str]]]('GENERATE_CODE_OVERRIDE', default=None)
-"""
-Optional context variable which can be used to override the default behaviour of code generation.
-Invoked with the file path to generate a download code for.
-"""
-
-
 async def generate_download_code(file_path: str, cleanup_file: bool) -> str:
     """
     Generate a one-time download code for a given dataset.
@@ -96,7 +87,7 @@ async def generate_download_code(file_path: str, cleanup_file: bool) -> str:
     user = USER.get()
 
     # Unique download id
-    uid = override(file_path) if (override := GENERATE_CODE_OVERRIDE.get()) else str(uuid4())
+    uid = str(uuid4())
 
     # Put it in the store under the registry entry with TTL configured
     await store.set(

dara/core/internal/encoder_registry.py

@@ -14,13 +14,13 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 """
-
-from collections.abc import MutableMapping
+# pylint: disable=unnecessary-lambda
 from inspect import Parameter, isclass
 from typing import (
     Any,
     Callable,
     Dict,
+    MutableMapping,
     Optional,
     Type,
     Union,
@@ -99,11 +99,11 @@ def _tuple_key_deserialize(d):
         if isinstance(key, str) and key.startswith('__tuple__'):
             key_list = []
             for each in key[10:-1].split(', '):
-                if (each.startswith("'") and each.endswith("'")) or (each.startswith('"') and each.endswith('"')):
+                if (each.startswith("'") and each.endswith(("'"))) or (each.startswith('"') and each.endswith(('"'))):
                     key_list.append(each[1:-1])
                 else:
                     key_list.append(each)
-            encoded_key = tuple(key_list)
+            encoded_key = encoded_key = tuple(key_list)
         else:
             encoded_key = key
 
@@ -112,7 +112,7 @@ def _tuple_key_deserialize(d):
     return encoded_dict
 
 
-def _df_deserialize(x):
+def _df_deserialize(x):  # pylint: disable=inconsistent-return-statements
     """
     A function to deserialize data into a DataFrame
 
@@ -240,14 +240,14 @@ def deserialize(value: Any, typ: Optional[Type]):
         return value
 
     # Already matches type
-    if type(value) is typ:
+    if type(value) == typ:
         return value
 
     # Handle Optional[foo] / Union[foo, None] -> call deserialize(value, foo)
     if get_origin(typ) == Union:
         args = get_args(typ)
         if len(args) == 2 and type(None) in args:
-            not_none_arg = args[0] if args[0] is not type(None) else args[1]
+            not_none_arg = args[0] if args[0] != type(None) else args[1]
             return deserialize(value, not_none_arg)
 
     try:

dara/core/internal/execute_action.py

@@ -14,13 +14,11 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 """
-
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Mapping
 from contextvars import ContextVar
-from typing import Any, Callable, Optional, Union
+from typing import Any, Callable, Mapping, Optional, Union
 
 import anyio
 
@@ -32,7 +30,11 @@ from dara.core.interactivity.actions import (
     ActionImpl,
 )
 from dara.core.internal.cache_store import CacheStore
-from dara.core.internal.dependency_resolution import resolve_dependency
+from dara.core.internal.dependency_resolution import (
+    is_resolved_derived_data_variable,
+    is_resolved_derived_variable,
+    resolve_dependency,
+)
 from dara.core.internal.encoder_registry import deserialize
 from dara.core.internal.tasks import MetaTask, TaskManager
 from dara.core.internal.utils import run_user_handler
@@ -143,15 +145,15 @@ async def execute_action(
     if values is not None:
         annotations = action.__annotations__
 
-        async def _resolve_kwarg(val: Any, key: str):
+        for key, value in values.items():
+            # Override `force` property to be false
+            if is_resolved_derived_variable(value) or is_resolved_derived_data_variable(value):
+                value['force'] = False
+
             typ = annotations.get(key)
-            val = await resolve_dependency(val, store, task_mgr)
+            val = await resolve_dependency(value, store, task_mgr)
             resolved_kwargs[key] = deserialize(val, typ)
 
-        async with anyio.create_task_group() as tg:
-            for key, value in values.items():
-                tg.start_soon(_resolve_kwarg, value, key)
-
     # Merge resolved dynamic kwargs with static kwargs received
     resolved_kwargs = {**resolved_kwargs, **static_kwargs}
 
@@ -175,11 +177,9 @@ async def execute_action(
 
         # Note: no associated registry entry, the result are not persisted in cache
         # Return a metatask which, when all dependencies are ready, will stream the action results to the frontend
-        meta_task = MetaTask(
+        return MetaTask(
             process_result=_stream_action, args=[action, ctx], kwargs=resolved_kwargs, notify_channels=notify_channels
         )
-        task_mgr.register_task(meta_task)
-        return meta_task
 
     # No tasks - run directly as an asyncio task and return the execution id
     # Originally used to use FastAPI BackgroundTasks, but these ended up causing a blocking behavior that blocked some

dara/core/internal/hashing.py

@@ -31,6 +31,8 @@ def hash_object(obj: Union[BaseModel, dict, None]):
     if isinstance(obj, BaseModel):
         obj = obj.model_dump()
 
-    filter_hash = hashlib.sha1(usedforsecurity=False)  # nosec B303 # we don't use this for security purposes just as a cache key
+    filter_hash = hashlib.sha1(
+        usedforsecurity=False
+    )   # nosec B303 # we don't use this for security purposes just as a cache key
     filter_hash.update(json.dumps(obj or {}, sort_keys=True).encode())
     return filter_hash.hexdigest()

dara/core/internal/import_discovery.py

@@ -93,9 +93,10 @@ def run_discovery(
     # If module root is passed through, use it
     if 'module_root' in kwargs:
         root = kwargs.get('module_root')
-    # Try to infer from module_name
-    elif module_name is not None:
-        root = module_name.split('.')[0]
+    else:
+        # Try to infer from module_name
+        if module_name is not None:
+            root = module_name.split('.')[0]
 
     for k, v in global_symbols.items():
         # Ignore already encountered functions