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

dara/core/interactivity/url_variable.py

@@ -17,16 +17,21 @@ limitations under the License.
 
 from __future__ import annotations
 
-from typing import Any, Generic, Optional, TypeVar
+from typing import Optional, TypeVar
 
-from pydantic import ConfigDict, SerializerFunctionWrapHandler, model_serializer
+from pydantic import ConfigDict
+from typing_extensions import deprecated
 
-from dara.core.interactivity.non_data_variable import NonDataVariable
+from dara.core.interactivity.plain_variable import Variable
+from dara.core.persistence import QueryParamStore
 
 VariableType = TypeVar('VariableType')
 
 
-class UrlVariable(NonDataVariable, Generic[VariableType]):
+@deprecated(
+    'UrlVariable is deprecated and will be removed in a future version. Use dara.core.interactivity.plain_variable.Variable with dara.core.persistence.QueryParamStore instead'
+)
+class UrlVariable(Variable[VariableType]):
     """
     A UrlVariable is very similar to a normal Variable however rather than it's state being stored in the memory of
     the client it's value is stored in the url of page as a query parameter. This is very useful for parameterizing
@@ -48,89 +53,4 @@ class UrlVariable(NonDataVariable, Generic[VariableType]):
         :param default: the initial value for the variable, defaults to None
         :param uid: the unique identifier for this variable; if not provided a random one is generated
         """
-        super().__init__(query=query, default=default, uid=uid)
-
-    def sync(self):
-        """
-        Create an action to synchronise the value of this UrlVariable with input value sent from the component.
-
-        ```python
-
-        from dara.core import UrlVariable
-        from dara.components import Select
-
-        var = UrlVariable('first', query='num')
-        another_var = UrlVariable('second', query='num_two')
-
-        Select(
-            value=var,
-            items=['first', 'second', 'third'],
-            onchange=another_var.sync(),
-        )
-
-        ```
-        """
-        from dara.core.interactivity.actions import (
-            UpdateVariableImpl,
-            assert_no_context,
-        )
-
-        assert_no_context('ctx.update')
-        return UpdateVariableImpl(variable=self, value=UpdateVariableImpl.INPUT)
-
-    def toggle(self):
-        """
-        Create an action to toggle the value of this UrlVariable. Note this only works for boolean variables.
-
-        ```python
-
-        from dara.core import UrlVariable
-        from dara.components import Button
-
-        var = UrlVariable(True, query='show')
-
-        Button(
-            'Toggle',
-            onclick=var.toggle(),
-        )
-
-        ```
-        """
-        from dara.core.interactivity.actions import (
-            UpdateVariableImpl,
-            assert_no_context,
-        )
-
-        assert_no_context('ctx.update')
-        return UpdateVariableImpl(variable=self, value=UpdateVariableImpl.TOGGLE)
-
-    def update(self, value: Any):
-        """
-        Create an action to update the value of this UrlVariable to a provided value.
-
-        ```python
-
-        from dara.core import UrlVariable
-        from dara.components import Button
-
-        show = UrlVariable(True, query='show')
-
-        Button(
-            'Hide',
-            onclick=show.update(False),
-        )
-
-        ```
-        """
-        from dara.core.interactivity.actions import (
-            UpdateVariableImpl,
-            assert_no_context,
-        )
-
-        assert_no_context('ctx.update')
-        return UpdateVariableImpl(variable=self, value=value)
-
-    @model_serializer(mode='wrap')
-    def ser_model(self, nxt: SerializerFunctionWrapHandler) -> dict:
-        parent_dict = nxt(self)
-        return {**parent_dict, '__typename': 'UrlVariable', 'uid': str(parent_dict['uid'])}
+        super().__init__(default=default, uid=uid, store=QueryParamStore(query=query), query=query)

dara/core/internal/cache_store/base_impl.py

@@ -19,12 +19,13 @@ class CacheStoreImpl(abc.ABC, Generic[PolicyT]):
         """
 
     @abc.abstractmethod
-    async def get(self, key: str, unpin: bool = False) -> Any:
+    async def get(self, key: str, unpin: bool = False, raise_for_missing: bool = False) -> 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
         """
 
     @abc.abstractmethod

dara/core/internal/cache_store/cache_store.py

@@ -6,7 +6,6 @@ from dara.core.base_definitions import (
     LruCachePolicy,
     MostRecentCachePolicy,
     PendingTask,
-    PendingValue,
     TTLCachePolicy,
 )
 from dara.core.internal.cache_store.base_impl import CacheStoreImpl, PolicyT
@@ -23,7 +22,7 @@ def cache_impl_for_policy(policy: PolicyT) -> CacheStoreImpl[PolicyT]:
     """
     impl: Optional[CacheStoreImpl] = None
 
-    if isinstance(policy, LruCachePolicy) or isinstance(policy, MostRecentCachePolicy):
+    if isinstance(policy, (LruCachePolicy, MostRecentCachePolicy)):
         impl = LRUCache(policy)
     elif isinstance(policy, TTLCachePolicy):
         impl = TTLCache(policy)
@@ -62,21 +61,24 @@ class CacheScopeStore(Generic[PolicyT]):
 
         return await cache.delete(key)
 
-    async def get(self, key: str, unpin: bool = False) -> Optional[Any]:
+    async def get(self, key: str, unpin: bool = False, raise_for_missing: 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)
+        return await cache.get(key, unpin=unpin, raise_for_missing=raise_for_missing)
 
     async def set(self, key: str, value: Any, pin: bool = False):
         """
@@ -150,21 +152,30 @@ class CacheStore:
 
         return prev_entry
 
-    async def get(self, registry_entry: CachedRegistryEntry, key: str, unpin: bool = False) -> Optional[Any]:
+    async def get(
+        self,
+        registry_entry: CachedRegistryEntry,
+        key: str,
+        unpin: bool = False,
+        raise_for_missing: 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)
+        return await registry_store.get(key, unpin=unpin, raise_for_missing=raise_for_missing)
 
     async def get_or_wait(self, registry_entry: CachedRegistryEntry, key: str):
         """
@@ -177,9 +188,6 @@ 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()
 
@@ -190,7 +198,6 @@ class CacheStore:
         registry_entry: CachedRegistryEntry,
         key: str,
         value: Any,
-        error: Optional[Exception] = None,
         pin: bool = False,
     ):
         """
@@ -213,12 +220,11 @@ class CacheStore:
 
         prev_value = await registry_store.get(key)
 
-        # 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)
+        # 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)
 
         # Update size
         self._update_size(prev_value, value)
@@ -228,15 +234,6 @@ 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,18 +42,21 @@ class KeepAllCache(CacheStoreImpl[KeepAllCachePolicy]):
             del self.cache[key]
             return entry
 
-    async def get(self, key: str, unpin: bool = False) -> Optional[Any]:
+    async def get(self, key: str, unpin: bool = False, raise_for_missing: 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,12 +88,13 @@ class LRUCache(CacheStoreImpl[LruCachePolicy]):
             self.cache.pop(key, None)
             return node.value
 
-    async def get(self, key: str, unpin: bool = False) -> Optional[Any]:
+    async def get(self, key: str, unpin: bool = False, raise_for_missing: 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:
@@ -103,6 +104,9 @@ 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,12 +52,13 @@ 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) -> Any:
+    async def get(self, key: str, unpin: bool = False, raise_for_missing: 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:
@@ -75,6 +76,8 @@ 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,36 +20,25 @@ 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 DataVariable, DerivedDataVariable, DerivedVariable
-from dara.core.interactivity.filtering import FilterQuery
+from dara.core.interactivity import DerivedVariable
+from dara.core.interactivity.server_variable import ServerVariable
 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: bool
+    force_key: Optional[str]
 
 
-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']
+class ResolvedServerVariable(TypedDict):
+    type: Literal['server']
     uid: str
+    sequence_number: int
 
 
 class ResolvedSwitchVariable(TypedDict):
@@ -64,21 +53,47 @@ 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_derived_data_variable(obj: Any) -> TypeGuard[ResolvedDerivedDataVariable]:
-    return isinstance(obj, dict) and 'uid' in obj and obj.get('type') == 'derived-data'
-
-
-def is_resolved_data_variable(obj: Any) -> TypeGuard[ResolvedDataVariable]:
-    return isinstance(obj, dict) and 'uid' in obj and obj.get('type') == 'data'
+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_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
+
+    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
+
+
 async def resolve_dependency(
     entry: Union[
-        ResolvedDerivedDataVariable, ResolvedDataVariable, ResolvedDerivedVariable, ResolvedSwitchVariable, Any
+        ResolvedDerivedVariable,
+        ResolvedSwitchVariable,
+        Any,
     ],
     store: CacheStore,
     task_mgr: TaskManager,
@@ -91,14 +106,11 @@ 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_data_variable(entry):
-        return await _resolve_data_var(entry, store)
+    if is_resolved_server_variable(entry):
+        return await _resolve_server_var(entry)
 
     if is_resolved_switch_variable(entry):
         return await _resolve_switch_var(entry, store, task_mgr)
@@ -106,34 +118,10 @@ 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
@@ -149,25 +137,27 @@ 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, store, task_mgr, input_values, derived_variable_entry.get('force', False)
+        var_entry=var,
+        store=store,
+        task_mgr=task_mgr,
+        args=input_values,
+        force_key=derived_variable_entry.get('force_key'),
     )
     return result['value']
 
 
-async def _resolve_data_var(data_variable_entry: ResolvedDataVariable, store: CacheStore):
+async def _resolve_server_var(resolved_server_variable: ResolvedServerVariable) -> Any:
     """
-    Resolve a data variable from the registry and get it's new value based on the dynamic variable mapping passed
-    in.
+    Resolve a server variable.
 
-    :param data_variable_entry: data var entry
+    :param server_variable_entry: server var entry
     :param store: the store instance to use for caching
     """
-    from dara.core.internal.registries import data_variable_registry, utils_registry
+    from dara.core.internal.registries import server_variable_registry, utils_registry
 
     registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
-    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)
+    server_var_entry = await registry_mgr.get(server_variable_registry, resolved_server_variable['uid'])
+    return await ServerVariable.get_value(server_var_entry)
 
 
 def _normalize_lookup_key(value: Any) -> str:
@@ -228,7 +218,11 @@ 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,22 +21,26 @@ 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():
+def print_stacktrace(err: Optional[BaseException] = None) -> str:
     """
     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)   # pylint:disable=bad-str-strip-call
+        stackstr += '  ' + traceback.format_exc().lstrip(trc)
     else:
         stackstr += '   Exception'
 
@@ -52,14 +56,17 @@ def handle_system_exit(error_msg: str):
     try:
         yield
     except SystemExit as e:
-        raise InterruptedError(error_msg).with_traceback(e.__traceback__)
+        raise InterruptedError(error_msg) from e
 
 
-def get_error_for_channel() -> dict:
+def get_error_for_channel(err: Optional[BaseException] = None) -> dict:
     """
     Get error from current stacktrace to send to the client
     """
-    return {'error': print_stacktrace(), 'time': str(datetime.now())}
+    return {
+        'error': print_stacktrace(err),
+        'time': str(datetime.now()),
+    }
 
 
 async def send_error_for_session(ws_mgr: WebsocketManager, session_id: str):

dara/core/internal/download.py

@@ -18,7 +18,9 @@ limitations under the License.
 from __future__ import annotations
 
 import os
-from typing import Awaitable, Callable, Optional, Tuple
+from collections.abc import Awaitable
+from contextvars import ContextVar
+from typing import Callable, Optional, Tuple
 from uuid import uuid4
 
 import anyio
@@ -37,13 +39,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]]:
@@ -72,6 +74,13 @@ 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.
@@ -87,7 +96,7 @@ async def generate_download_code(file_path: str, cleanup_file: bool) -> str:
     user = USER.get()
 
     # Unique download id
-    uid = str(uuid4())
+    uid = override(file_path) if (override := GENERATE_CODE_OVERRIDE.get()) else str(uuid4())
 
     # Put it in the store under the registry entry with TTL configured
     await store.set(