dara-core 1.19.1__py3-none-any.whl → 1.20.0__py3-none-any.whl

dara/core/interactivity/switch_variable.py

@@ -21,11 +21,11 @@ from typing import Any, Dict, Optional, Union
 
 from pydantic import SerializerFunctionWrapHandler, field_validator, model_serializer
 
+from dara.core.interactivity.client_variable import ClientVariable
 from dara.core.interactivity.condition import Condition
-from dara.core.interactivity.non_data_variable import NonDataVariable
 
 
-class SwitchVariable(NonDataVariable):
+class SwitchVariable(ClientVariable):
     """
     A SwitchVariable represents a conditional value that switches between
     different values based on a condition or variable value.
@@ -222,15 +222,15 @@ class SwitchVariable(NonDataVariable):
         - Other values use standard string conversion to match JavaScript's String() behavior
     """
 
-    value: Optional[Union[Condition, NonDataVariable, Any]] = None
+    value: Optional[Union[Condition, ClientVariable, Any]] = None
     # must be typed as any, otherwise pydantic is trying to instantiate the variables incorrectly
     value_map: Optional[Any] = None
     default: Optional[Any] = None
 
     def __init__(
         self,
-        value: Union[Condition, NonDataVariable, Any],
-        value_map: Dict[Any, Any] | NonDataVariable,
+        value: Union[Condition, ClientVariable, Any],
+        value_map: Dict[Any, Any] | ClientVariable,
         default: Optional[Any] = None,
         uid: Optional[str] = None,
     ):
@@ -253,26 +253,26 @@ class SwitchVariable(NonDataVariable):
     @classmethod
     def validate_value_map(cls, v):
         """
-        Validate that value_map is either a dict or a NonDataVariable.
+        Validate that value_map is either a dict or a ClientVariable.
 
         :param v: The value to validate
         :return: The validated value
-        :raises ValueError: If value_map is not a dict or NonDataVariable
+        :raises ValueError: If value_map is not a dict or ClientVariable
         """
         if v is None:
             return v
         if isinstance(v, dict):
             return v
-        if isinstance(v, NonDataVariable):
+        if isinstance(v, ClientVariable):
             return v
-        raise ValueError(f'value_map must be a dict or NonDataVariable, got {type(v)}')
+        raise ValueError(f'value_map must be a dict or ClientVariable, got {type(v)}')
 
     @classmethod
     def when(
         cls,
-        condition: Union[Condition, NonDataVariable, Any],
-        true_value: Union[Any, NonDataVariable],
-        false_value: Union[Any, NonDataVariable],
+        condition: Union[Condition, ClientVariable, Any],
+        true_value: Union[Any, ClientVariable],
+        false_value: Union[Any, ClientVariable],
         uid: Optional[str] = None,
     ) -> SwitchVariable:
         """
@@ -346,9 +346,9 @@ class SwitchVariable(NonDataVariable):
     @classmethod
     def match(
         cls,
-        value: Union[NonDataVariable, Any],
-        mapping: Union[Dict[Any, Any], NonDataVariable],
-        default: Optional[Union[Any, NonDataVariable]] = None,
+        value: Union[ClientVariable, Any],
+        mapping: Union[Dict[Any, Any], ClientVariable],
+        default: Optional[Union[Any, ClientVariable]] = None,
         uid: Optional[str] = None,
     ) -> SwitchVariable:
         """

dara/core/interactivity/tabular_variable.py

@@ -0,0 +1,94 @@
+"""
+Copyright 2023 Impulse Innovations Limited
+
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+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.
+"""
+
+import io
+import os
+from typing import Literal, Optional, TypedDict, Union, cast
+
+import pandas
+from fastapi import UploadFile
+
+from dara.core.base_definitions import UploadResolverDef
+from dara.core.internal.registry_lookup import RegistryLookup
+from dara.core.internal.utils import run_user_handler
+
+
+class FieldType(TypedDict):
+    name: Union[str, tuple[str, ...]]
+    type: Literal['integer', 'number', 'boolean', 'datetime', 'duration', 'any', 'str']
+
+
+class DataFrameSchema(TypedDict):
+    fields: list[FieldType]
+    primaryKey: list[str]
+
+
+async def upload(data: UploadFile, data_uid: Optional[str] = None, resolver_id: Optional[str] = None):
+    """
+    Handler for uploading data.
+
+    :param data: the file to upload
+    :param data_uid: optional uid of the data variable to upload to
+    :param resolver_id: optional id of the upload resolver to use, falls back to default handlers for csv/xlsx
+    """
+    from dara.core.interactivity.server_variable import ServerVariable
+    from dara.core.internal.registries import (
+        server_variable_registry,
+        upload_resolver_registry,
+        utils_registry,
+    )
+
+    registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
+
+    if data.filename is None:
+        raise ValueError('Filename not provided')
+
+    variable_entry = None
+
+    _name, file_type = os.path.splitext(data.filename)
+
+    if data_uid is not None:
+        try:
+            variable_entry = await registry_mgr.get(server_variable_registry, data_uid)
+        except KeyError as e:
+            raise ValueError(f'Data Variable {data_uid} does not exist') from e
+
+    content = cast(bytes, await data.read())
+
+    resolver = None
+
+    # If Id is provided, lookup the definition from registry
+    if resolver_id is not None:
+        resolver_def: UploadResolverDef = await registry_mgr.get(upload_resolver_registry, resolver_id)
+        resolver = resolver_def.resolver
+
+    if resolver:
+        content = await run_user_handler(handler=resolver, args=(content, data.filename))
+    # If resolver is not provided, follow roughly the cl_dataset_parser logic
+    elif file_type == '.xlsx':
+        file_object_xlsx = io.BytesIO(content)
+        content = pandas.read_excel(file_object_xlsx, index_col=None)
+        content.columns = content.columns.str.replace('Unnamed: *', 'column_', regex=True)  # type: ignore
+    else:
+        # default to csv
+        file_object_csv = io.StringIO(content.decode('utf-8'))
+        content = pandas.read_csv(file_object_csv, index_col=0)
+        content.columns = content.columns.str.replace('Unnamed: *', 'column_', regex=True)  # type: ignore
+
+    # If a server variable is provided, update it with the new content
+    if variable_entry:
+        await ServerVariable.write_value(variable_entry, content)

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/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
@@ -189,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()
 
@@ -202,7 +198,6 @@ class CacheStore:
         registry_entry: CachedRegistryEntry,
         key: str,
         value: Any,
-        error: Optional[Exception] = None,
         pin: bool = False,
     ):
         """
@@ -225,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)
@@ -240,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/dependency_resolution.py

@@ -20,10 +20,9 @@ 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
@@ -36,18 +35,10 @@ class ResolvedDerivedVariable(TypedDict):
     force_key: Optional[str]
 
 
-class ResolvedDerivedDataVariable(TypedDict):
-    type: Literal['derived-data']
-    uid: str
-    values: List[Any]
-    filters: Optional[Union[FilterQuery, dict]]
-    force_key: Optional[str]
-
-
-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):
@@ -62,20 +53,24 @@ 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
@@ -84,6 +79,8 @@ def clean_force_key(value: Any) -> Any:
         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()}
@@ -94,8 +91,6 @@ def clean_force_key(value: Any) -> Any:
 
 async def resolve_dependency(
     entry: Union[
-        ResolvedDerivedDataVariable,
-        ResolvedDataVariable,
         ResolvedDerivedVariable,
         ResolvedSwitchVariable,
         Any,
@@ -111,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)
@@ -126,38 +118,6 @@ 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_entry=data_var,
-        dv_entry=dv_var,
-        store=store,
-        task_mgr=task_mgr,
-        args=input_values,
-        filters=entry.get('filters', None),
-        force_key=entry.get('force_key'),
-    )
-    return remove_index(result)
-
-
 async def _resolve_derived_var(
     derived_variable_entry: ResolvedDerivedVariable,
     store: CacheStore,
@@ -186,20 +146,18 @@ async def _resolve_derived_var(
     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:

dara/core/internal/devtools.py

@@ -21,15 +21,19 @@ 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]
 
@@ -55,11 +59,14 @@ def handle_system_exit(error_msg: str):
         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/execute_action.py

@@ -143,11 +143,15 @@ async def execute_action(
     if values is not None:
         annotations = action.__annotations__
 
-        for key, value in values.items():
+        async def _resolve_kwarg(val: Any, key: str):
             typ = annotations.get(key)
-            val = await resolve_dependency(value, store, task_mgr)
+            val = await resolve_dependency(val, 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}
 
@@ -171,9 +175,11 @@ 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
-        return MetaTask(
+        meta_task = 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/multi_resource_lock.py

@@ -0,0 +1,70 @@
+from collections import Counter
+from contextlib import asynccontextmanager
+
+import anyio
+
+
+class MultiResourceLock:
+    """
+    A class that manages multiple named locks for concurrent access to shared resources.
+
+    This class allows for acquiring and releasing locks on named resources, ensuring
+    that only one task can access a specific resource at a time. It automatically
+    creates locks for new resources and cleans them up when they're no longer in use.
+
+    :reentrant:
+        If True a task can acquire the same resource more than once; every
+        subsequent acquire of an already-held lock is a no-op.  If False the
+        second attempt raises ``RuntimeError``.
+    """
+
+    def __init__(self):
+        self._locks: dict[str, anyio.Lock] = {}
+        self._waiters = Counter[str]()
+        self._cleanup_lock = anyio.Lock()
+
+    def is_locked(self, resource_name: str) -> bool:
+        """
+        Check if a lock for the specified resource is currently held.
+
+        :param resource_name (str): The name of the resource to check.
+        :return: True if the lock is held, False otherwise.
+        """
+        return resource_name in self._locks and self._locks[resource_name].locked()
+
+    @asynccontextmanager
+    async def acquire(self, resource_name: str):
+        """
+        Acquire a lock for the specified resource.
+
+        This method is an async context manager that acquires a lock for the given
+        resource name. If the lock doesn't exist, it creates one. It also keeps
+        track of waiters to ensure proper cleanup when the resource is no longer in use.
+
+        :param resource_name (str): The name of the resource to lock.
+
+        Usage:
+        ```python
+        async with multi_lock.acquire_lock("resource_a"):
+            # Critical section for "resource_a"
+            ...
+        ```
+
+        Note:
+            The lock is automatically released when exiting the context manager.
+        """
+
+        async with self._cleanup_lock:
+            if resource_name not in self._locks:
+                self._locks[resource_name] = anyio.Lock()
+            self._waiters[resource_name] += 1
+
+        try:
+            async with self._locks[resource_name]:
+                yield
+        finally:
+            async with self._cleanup_lock:
+                self._waiters[resource_name] -= 1
+                if self._waiters[resource_name] <= 0:
+                    del self._waiters[resource_name]
+                    del self._locks[resource_name]

dara/core/internal/normalization.py

@@ -31,7 +31,6 @@ from typing import (
 from typing_extensions import TypedDict, TypeGuard
 
 from dara.core.base_definitions import DaraBaseModel as BaseModel
-from dara.core.internal.hashing import hash_object
 
 JsonLike = Union[Mapping, List]
 
@@ -81,10 +80,6 @@ def _get_identifier(obj: Referrable) -> str:
         nested = ','.join(cast(List[str], obj['nested']))
         identifier = f'{identifier}:{nested}'
 
-    if _is_referrable_with_filters(obj):
-        filter_hash = hash_object(obj['filters'])
-        identifier = f'{identifier}:{filter_hash}'
-
     return identifier