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

dara/core/__init__.py

@@ -41,6 +41,7 @@ __all__ = [
     'DerivedVariable',
     'DerivedDataVariable',
     'DataVariable',
+    'ServerVariable',
     'UrlVariable',
     'Cache',
     'CacheType',

dara/core/auth/basic.py

@@ -25,7 +25,6 @@ from dara.core.auth.definitions import (
     EXPIRED_TOKEN_ERROR,
     INVALID_CREDENTIALS_ERROR,
     INVALID_TOKEN_ERROR,
-    JWT_ALGO,
     SESSION_ID,
     USER,
     AuthError,
@@ -35,7 +34,6 @@ from dara.core.auth.definitions import (
     UserData,
 )
 from dara.core.auth.utils import decode_token, sign_jwt
-from dara.core.internal.settings import get_settings
 
 DefaultAuthLogin = AuthComponent(js_module='@darajs/core', py_module='dara.core', js_name='DefaultAuthLogin')
 
@@ -69,7 +67,7 @@ class BaseBasicAuthConfig(BaseAuthConfig):
 
         return {
             'token': sign_jwt(
-                identity_id=None,
+                identity_id=body.username,
                 identity_name=body.username,
                 identity_email=None,
                 groups=[],
@@ -87,6 +85,7 @@ class BaseBasicAuthConfig(BaseAuthConfig):
             SESSION_ID.set(decoded.session_id)
             USER.set(
                 UserData(
+                    identity_id=decoded.identity_name,
                     identity_name=decoded.identity_name,
                 )
             )
@@ -127,7 +126,7 @@ class DefaultAuthConfig(BaseAuthConfig):
 
         In default auth a new token is returned every time.
         """
-        token = sign_jwt(identity_id=None, identity_name='user', identity_email=None, groups=[])
+        token = sign_jwt(identity_id='user', identity_name='user', identity_email=None, groups=[])
         return {'token': token}
 
     def verify_token(self, token: str) -> TokenData:
@@ -139,9 +138,16 @@ class DefaultAuthConfig(BaseAuthConfig):
         :param token: the token to verify
         """
         try:
-            decoded = jwt.decode(token, get_settings().jwt_secret, algorithms=[JWT_ALGO])
-            SESSION_ID.set(decoded.get('session_id'))
-            return TokenData.parse_obj(decoded)
+            decoded = decode_token(token)
+            SESSION_ID.set(decoded.session_id)
+            # Implicit auth assumes used by one user so all users are the same
+            USER.set(
+                UserData(
+                    identity_id=decoded.identity_id,
+                    identity_name=decoded.identity_id,
+                )
+            )
+            return decoded
         except jwt.ExpiredSignatureError as e:
             raise AuthError(EXPIRED_TOKEN_ERROR, 401) from e
         except jwt.DecodeError as e:

dara/core/auth/definitions.py

@@ -39,7 +39,7 @@ class TokenData(BaseModel):
 
     session_id: str
     exp: Union[float, int, datetime]
-    identity_id: Optional[str] = None
+    identity_id: str
     identity_name: str
     identity_email: Optional[str] = None
     id_token: Optional[str] = None
@@ -56,7 +56,7 @@ class UserData(BaseModel):
     :param groups: list of groups user belongs to
     """
 
-    identity_id: Optional[str] = None
+    identity_id: str
     identity_name: str
     identity_email: Optional[str] = None
     groups: Optional[List[str]] = []

dara/core/auth/utils.py

@@ -51,7 +51,7 @@ def decode_token(token: str, **kwargs) -> TokenData:
 
 
 def sign_jwt(
-    identity_id: Optional[str],
+    identity_id: str,
     identity_name: str,
     identity_email: Optional[str],
     groups: List[str],

dara/core/base_definitions.py

@@ -304,6 +304,12 @@ class CachedRegistryEntry(BaseModel):
         return f'{self.__class__.__name__}(cache={self.cache}, uid={self.uid})'
 
 
+class NonTabularDataError(Exception):
+    """
+    Raised when trying to interpret a non-tabular variable as tabular
+    """
+
+
 class BaseTaskMessage(BaseModel):
     task_id: str
 
@@ -407,7 +413,7 @@ class PendingTask(BaseTask):
             self.cancel_scope.cancel()
         await self.task_def.cancel()
 
-        self.error = Exception('Task was cancelled')
+        self.error = anyio.get_cancelled_exc_class()()
         self.event.set()
 
     def add_subscriber(self):
@@ -432,47 +438,6 @@ class PendingTask(BaseTask):
         return self.result
 
 
-class PendingValue:
-    """
-    An internal class that's used to represent a pending value. Holds a future object that can be awaited by
-    multiple consumers.
-    """
-
-    def __init__(self):
-        self.event = anyio.Event()
-        self._value = None
-        self._error = None
-
-    async def wait(self):
-        """
-        Wait for the underlying event to be set
-        """
-        # Waiting in chunks as otherwise Jupyter blocks the event loop
-        while not self.event.is_set():
-            await anyio.sleep(0.01)
-        if self._error:
-            raise self._error
-        return self._value
-
-    def resolve(self, value: Any):
-        """
-        Resolve the pending state and send values to the waiting code
-
-        :param value: the value to resolve as the result
-        """
-        self._value = value
-        self.event.set()
-
-    def error(self, exc: Exception):
-        """
-        Resolve the pending state with an error and send it to the waiting code
-
-        :param exc: exception to resolve as the result
-        """
-        self._error = exc
-        self.event.set()
-
-
 class AnnotatedAction(BaseModel):
     """
     Represents a single call to an @action-annotated action.

dara/core/data_utils.py

@@ -25,10 +25,9 @@ from pandas import DataFrame
 from dara.core.base_definitions import CacheType
 from dara.core.base_definitions import DaraBaseModel as BaseModel
 from dara.core.interactivity import (
-    DerivedDataVariable,
+    ClientVariable,
     DerivedVariable,
     DownloadContent,
-    NonDataVariable,
     SideEffect,
     Variable,
 )
@@ -172,7 +171,7 @@ class DataFactory(BaseModel):
 
     def list_datasets_var(
         self,
-        cache: Union[CacheType, NonDataVariable] = CacheType.GLOBAL,
+        cache: Union[CacheType, ClientVariable] = CacheType.GLOBAL,
         polling_interval: Optional[int] = None,
     ) -> DerivedVariable[List[str]]:
         """
@@ -181,7 +180,7 @@ class DataFactory(BaseModel):
         :param cache: cache type to get the list of datasets for
         :param polling_interval: optional polling_interval in seconds for the derived variable
         """
-        cache_var = cache if isinstance(cache, NonDataVariable) else Variable(cache)
+        cache_var = cache if isinstance(cache, ClientVariable) else Variable(cache)
 
         return DerivedVariable(
             lambda cache_val: self.file_store.list_files(cache_val or CacheType.GLOBAL),
@@ -289,21 +288,21 @@ class DataFactory(BaseModel):
 
     def read_dataset_var(
         self,
-        name: Union[str, NonDataVariable],
-        cache: Union[CacheType, NonDataVariable] = CacheType.GLOBAL,
+        name: Union[str, ClientVariable],
+        cache: Union[CacheType, ClientVariable] = CacheType.GLOBAL,
         polling_interval: Optional[int] = None,
-    ) -> DerivedDataVariable:
+    ) -> DerivedVariable:
         """
-        Create a DerivedDataVariable which reads a specific dataset from disk
+        Create a DerivedVariable which reads a specific dataset from disk
 
         :param name: name of the dataset
         :param cache: cache to get the dataset for
         :param polling_interval: optional polling interval in seconds for the derived variable
         """
-        name_var = name if isinstance(name, NonDataVariable) else Variable(name)
-        cache_var = cache if isinstance(cache, NonDataVariable) else Variable(cache)
+        name_var = name if isinstance(name, ClientVariable) else Variable(name)
+        cache_var = cache if isinstance(cache, ClientVariable) else Variable(cache)
 
-        return DerivedDataVariable(
+        return DerivedVariable(
             self.read_dataset,
             variables=[name_var, cache_var],
             cache=CacheType.SESSION,
@@ -320,7 +319,7 @@ class DataFactory(BaseModel):
         self.file_store.delete_file(cache, name)
 
     def delete_dataset_action(
-        self, name: Union[str, NonDataVariable], cache: Union[CacheType, NonDataVariable] = CacheType.GLOBAL
+        self, name: Union[str, ClientVariable], cache: Union[CacheType, ClientVariable] = CacheType.GLOBAL
     ):
         """
         Get a SideEffect action which deletes a given dataset
@@ -328,13 +327,13 @@ class DataFactory(BaseModel):
         :param name: name of the dataset
         :param cache: cache to remove the daatset for
         """
-        name_var = name if isinstance(name, NonDataVariable) else Variable(name)
-        cache_var = cache if isinstance(cache, NonDataVariable) else Variable(cache)
+        name_var = name if isinstance(name, ClientVariable) else Variable(name)
+        cache_var = cache if isinstance(cache, ClientVariable) else Variable(cache)
 
         return SideEffect(lambda ctx: self.delete_dataset(ctx.extras[0], ctx.extras[1]), extras=[name_var, cache_var])
 
     def download_dataset_action(
-        self, name: Union[str, NonDataVariable], cache: Union[CacheType, NonDataVariable] = CacheType.GLOBAL
+        self, name: Union[str, ClientVariable], cache: Union[CacheType, ClientVariable] = CacheType.GLOBAL
     ):
         """
         Get a DownloadContent action which downloads a dataset with a given name as a .csv
@@ -342,8 +341,8 @@ class DataFactory(BaseModel):
         :param name: name of the dataset to download
         :param cache: cache to download dataset for
         """
-        name_var = name if isinstance(name, NonDataVariable) else Variable(name)
-        cache_var = cache if isinstance(cache, NonDataVariable) else Variable(cache)
+        name_var = name if isinstance(name, ClientVariable) else Variable(name)
+        cache_var = cache if isinstance(cache, ClientVariable) else Variable(cache)
 
         def _resolver(ctx: DownloadContent.Ctx):  # type: ignore
             ds_name, sel_cache = ctx.extras  # type: ignore

dara/core/definitions.py

@@ -84,22 +84,22 @@ class ErrorHandlingConfig(BaseModel):
     raw_css: Optional[Any] = None
     """
     Raw styling to apply to the displayed error boundary.
-    Accepts a CSSProperties, dict, str, or NonDataVariable.
+    Accepts a CSSProperties, dict, str, or ClientVariable.
     """
 
     @field_validator('raw_css', mode='before')
     @classmethod
     def validate_raw_css(cls, value):
-        from dara.core.interactivity.non_data_variable import NonDataVariable
+        from dara.core.interactivity.client_variable import ClientVariable
 
         if value is None:
             return None
-        if isinstance(value, (str, NonDataVariable, CSSProperties)):
+        if isinstance(value, (str, ClientVariable, CSSProperties)):
             return value
         if isinstance(value, dict):
             return {_kebab_to_camel(k): v for k, v in value.items()}
 
-        raise ValueError(f'raw_css must be a CSSProperties, dict, str, None or NonDataVariable, got {type(value)}')
+        raise ValueError(f'raw_css must be a CSSProperties, dict, str, None or ClientVariable, got {type(value)}')
 
     def model_dump(self, *args, **kwargs):
         result = super().model_dump(*args, **kwargs)
@@ -145,7 +145,7 @@ class ComponentInstance(BaseModel):
     """
     Raw styling to apply to the component.
     Can be an dict/CSSProperties instance representing the `styles` tag, a string injected directly into the CSS of the wrapping component,
-    or a NonDataVariable resoling to either of the above.
+    or a ClientVariable resoling to either of the above.
 
     ```python
 
@@ -216,7 +216,7 @@ class ComponentInstance(BaseModel):
     @field_validator('raw_css', mode='before')
     @classmethod
     def parse_css(cls, css: Optional[Any]):
-        from dara.core.interactivity.non_data_variable import NonDataVariable
+        from dara.core.interactivity.client_variable import ClientVariable
 
         if css is None:
             return None
@@ -225,10 +225,10 @@ class ComponentInstance(BaseModel):
         if isinstance(css, dict):
             return {_kebab_to_camel(k): v for k, v in css.items()}
 
-        if isinstance(css, (NonDataVariable, CSSProperties, str)):
+        if isinstance(css, (ClientVariable, CSSProperties, str)):
             return css
 
-        raise ValueError(f'raw_css must be a CSSProperties, dict, str, None or NonDataVariable, got {type(css)}')
+        raise ValueError(f'raw_css must be a CSSProperties, dict, str, None or ClientVariable, got {type(css)}')
 
     @classmethod
     def isinstance(cls, obj: Any) -> bool:

dara/core/interactivity/__init__.py

@@ -36,12 +36,14 @@ from dara.core.interactivity.actions import (
 )
 from dara.core.interactivity.any_data_variable import AnyDataVariable
 from dara.core.interactivity.any_variable import AnyVariable
+from dara.core.interactivity.client_variable import ClientVariable
 from dara.core.interactivity.condition import Condition, Operator
 from dara.core.interactivity.data_variable import DataVariable
 from dara.core.interactivity.derived_data_variable import DerivedDataVariable
 from dara.core.interactivity.derived_variable import DerivedVariable
 from dara.core.interactivity.non_data_variable import NonDataVariable
 from dara.core.interactivity.plain_variable import Variable
+from dara.core.interactivity.server_variable import ServerVariable
 from dara.core.interactivity.state_variable import StateVariable
 from dara.core.interactivity.switch_variable import SwitchVariable
 from dara.core.interactivity.url_variable import UrlVariable
@@ -51,6 +53,7 @@ __all__ = [
     'ActionCtx',
     'AnyVariable',
     'AnyDataVariable',
+    'ClientVariable',
     'DataVariable',
     'NonDataVariable',
     'Variable',
@@ -69,6 +72,7 @@ __all__ = [
     'TriggerVariable',
     'UpdateVariable',
     'UpdateVariableImpl',
+    'ServerVariable',
     'SideEffect',
     'Condition',
     'Operator',

dara/core/interactivity/actions.py

@@ -44,7 +44,7 @@ import anyio
 from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
 from pandas import DataFrame
 from pydantic import ConfigDict
-from typing_extensions import deprecated
+from typing_extensions import TypeAlias, deprecated
 
 from dara.core.base_definitions import (
     ActionDef,
@@ -54,7 +54,7 @@ from dara.core.base_definitions import (
     TaskProgressUpdate,
 )
 from dara.core.base_definitions import DaraBaseModel as BaseModel
-from dara.core.interactivity.data_variable import DataVariable
+from dara.core.interactivity.server_variable import ServerVariable
 from dara.core.interactivity.state_variable import StateVariable
 from dara.core.internal.download import generate_download_code
 from dara.core.internal.registry_lookup import RegistryLookup
@@ -65,10 +65,8 @@ if TYPE_CHECKING:
     from dara.core.interactivity import (
         AnyVariable,
         DerivedVariable,
-        UrlVariable,
         Variable,
     )
-    from dara.core.internal.cache_store import CacheStore
 
 
 class ActionInputs(BaseModel):
@@ -126,7 +124,7 @@ class UpdateVariableImpl(ActionImpl):
 
     py_name = 'UpdateVariable'
 
-    variable: Union[Variable, UrlVariable, DataVariable]
+    variable: Union[Variable, ServerVariable]
     value: Any
 
     INPUT: ClassVar[str] = '__dara_input__'
@@ -136,19 +134,18 @@ class UpdateVariableImpl(ActionImpl):
     """Special value for `value` that will toggle the variable value"""
 
     async def execute(self, ctx: ActionCtx) -> Any:
-        if isinstance(self.variable, DataVariable):
+        if isinstance(self.variable, ServerVariable):
             # Update on the backend
             from dara.core.internal.registries import (
-                data_variable_registry,
+                server_variable_registry,
                 utils_registry,
             )
 
-            store: CacheStore = utils_registry.get('Store')
             registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
 
-            var_entry = await registry_mgr.get(data_variable_registry, self.variable.uid)
-            DataVariable.update_value(var_entry, store, self.value)
-            # Don't notify frontend explicitly, all clients will be notified by update_value above
+            var_entry = await registry_mgr.get(server_variable_registry, self.variable.uid)
+            await ServerVariable.write_value(var_entry, self.value)
+            # Don't notify frontend explicitly, all clients will be notified by write_value above
             return None
 
         # for non-data variables just ping frontend with the new value
@@ -173,7 +170,7 @@ class UpdateVariable(AnnotatedAction):
     @deprecated: Passing in resolvers is deprecated, use `ctx.update` in an `@action` or `UpdateVariableImpl` instead.
     `UpdateVariableImpl` will be renamed to `UpdateVariable` in Dara 2.0.
 
-    The UpdateVariable action can be passed to any `ComponentInstance` prop accepting an action and trigger the update of a Variable, UrlVariable or DataVariable.
+    The UpdateVariable action can be passed to any `ComponentInstance` prop accepting an action and trigger the update of a Variable or ServerVariable.
     The resolver function takes a Context param which will feed the `inputs`: `old` and `new` as well as any `extras` passed through.
 
     Below an example of how a resolver might look:
@@ -241,13 +238,13 @@ class UpdateVariable(AnnotatedAction):
 
     Ctx: ClassVar[type[UpdateVariableContext]] = UpdateVariableContext
 
-    variable: Union[Variable, DataVariable, UrlVariable]
+    variable: Union[Variable, ServerVariable]
     extras: Optional[List[AnyVariable]]
 
     def __init__(
         self,
         resolver: Callable[[UpdateVariableContext], Any],
-        variable: Union[Variable, DataVariable, UrlVariable],
+        variable: Union[Variable, ServerVariable],
         extras: Optional[List[AnyVariable]] = None,
     ):
         """
@@ -629,13 +626,13 @@ def DownloadContent(
 
     ```python
 
-    from dara.core import action, ConfigurationBuilder, DataVariable, DownloadContent
+    from dara.core import action, ConfigurationBuilder, ServerVariable, DownloadContent
     from dara.components.components import Button, Stack
 
 
     # generate data, alternatively you could load it from a file
     df = pandas.DataFrame(data={'x': [1, 2, 3], 'y':[4, 5, 6]})
-    my_var = DataVariable(df)
+    my_var = ServerVariable(df)
 
     config = ConfigurationBuilder()
 
@@ -827,12 +824,12 @@ class ActionCtx:
         self._on_action = _on_action
 
     @overload
-    async def update(self, variable: DataVariable, value: Optional[DataFrame]): ...
+    async def update(self, variable: ServerVariable, value: Optional[DataFrame]): ...
 
     @overload
-    async def update(self, variable: Union[Variable[VariableT], UrlVariable[VariableT]], value: VariableT): ...
+    async def update(self, variable: Variable[VariableT], value: VariableT): ...
 
-    async def update(self, variable: Union[Variable, UrlVariable, DataVariable], value: Any):
+    async def update(self, variable: Union[Variable, ServerVariable], value: Any):
         """
         Update a given variable to provided value.
 
@@ -1115,12 +1112,12 @@ class ActionCtx:
 
         ```python
 
-        from dara.core import action, ConfigurationBuilder, DataVariable
+        from dara.core import action, ConfigurationBuilder, ServerVariable
         from dara.components.components import Button, Stack
 
         # generate data, alternatively you could load it from a file
         df = pandas.DataFrame(data={'x': [1, 2, 3], 'y':[4, 5, 6]})
-        my_var = DataVariable(df)
+        my_var = ServerVariable(df)
 
         config = ConfigurationBuilder()
 
@@ -1246,6 +1243,7 @@ class ActionCtx:
         task_mgr: TaskManager = utils_registry.get('TaskManager')
 
         task = Task(func=func, args=args, kwargs=kwargs, on_progress=on_progress)
+        task_mgr.register_task(task)
         pending_task = await task_mgr.run_task(task)
         return await pending_task.value()
 
@@ -1330,7 +1328,7 @@ class action:
     ```
     """
 
-    Ctx: ClassVar[type[ActionCtx]] = ActionCtx
+    Ctx: TypeAlias = ActionCtx
 
     def __init__(self, func: Callable[..., Any]):
         from dara.core.internal.execute_action import execute_action

dara/core/interactivity/any_data_variable.py

@@ -1,139 +1,11 @@
-"""
-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 abc
-import io
-import os
-from collections.abc import Awaitable
-from typing import Any, Callable, Literal, Optional, TypedDict, Union, cast
-
-import pandas
-from fastapi import UploadFile
-from pydantic import ConfigDict
+from typing_extensions import TypeAlias
 
-from dara.core.base_definitions import CachedRegistryEntry, UploadResolverDef
 from dara.core.interactivity.any_variable import AnyVariable
-from dara.core.interactivity.filtering import FilterQuery
-from dara.core.internal.cache_store.cache_store import CacheStore
-from dara.core.internal.registry_lookup import RegistryLookup
-from dara.core.internal.utils import run_user_handler
-
-
-class AnyDataVariable(AnyVariable, abc.ABC):
-    """
-    AnyDataVariable represents any variable that is specifically designed to hold datasets (i.e. DataVariable, DerivedDataVariable)
-
-    :param uid: the unique identifier for this variable; if not provided a random one is generated
-    :param filters: a dictionary of filters to apply to the data
-    """
-
-    uid: str
-    filters: Optional[FilterQuery] = None
-
-    def __init__(self, uid: Optional[str] = None, **kwargs) -> None:
-        super().__init__(uid=uid, **kwargs)
-
-    def filter(self, filters: FilterQuery):
-        return self.copy(update={'filters': filters}, deep=True)
-
-
-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]
-
 
-class DataVariableRegistryEntry(CachedRegistryEntry):
-    """
-    Registry entry for DataVariable.
-    """
+# re-export for backwards compatibility
+from .tabular_variable import *  # noqa: F403
 
-    type: Literal['plain', 'derived']
-    get_data: Callable[..., Awaitable[Any]]
-    """Handler to get the data from the data variable. Defaults to DataVariable.get_value for type=plain, and DerivedDataVariable.get_data for type=derived"""
-
-    get_total_count: Callable[..., Awaitable[int]]
-    """Handler to get the total number of rows in the data variable. Defaults to DataVariable.get_total_count for type=plain, and DerivedDataVariable.get_total_count for type=derived"""
-
-    get_schema: Callable[..., Awaitable[DataFrameSchema]]
-    """Handler to get the schema for data variable. Defaults to DataVariable.get_schema for type=plain, and DerivedDataVariable.get_schema for type=derived"""
-    model_config = ConfigDict(extra='forbid', arbitrary_types_allowed=True)
-
-
-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.data_variable import DataVariable
-    from dara.core.internal.registries import (
-        data_variable_registry,
-        upload_resolver_registry,
-        utils_registry,
-    )
-
-    store: CacheStore = utils_registry.get('Store')
-    registry_mgr: RegistryLookup = utils_registry.get('RegistryLookup')
-
-    if data.filename is None:
-        raise ValueError('Filename not provided')
-
-    variable = None
-
-    _name, file_type = os.path.splitext(data.filename)
-
-    if data_uid is not None:
-        try:
-            variable = await registry_mgr.get(data_variable_registry, data_uid)
-        except KeyError as e:
-            raise ValueError(f'Data Variable {data_uid} does not exist') from e
-
-        if variable.type == 'derived':
-            raise ValueError('Cannot upload data to DerivedDataVariable')
-
-    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 data variable is provided, update it with the new content
-    if variable:
-        DataVariable.update_value(variable, store, content)
+AnyDataVariable: TypeAlias = AnyVariable
+"""
+Deprecated alias. Tabular variables are now DerivedVariable or ServerVariable
+"""

dara/core/interactivity/any_variable.py

@@ -111,7 +111,7 @@ async def get_current_value(variable: dict, timeout: float = 3, raw: bool = Fals
         user_identity = None
 
         if current_user is not None:
-            user_identity = current_user.identity_id or current_user.identity_name
+            user_identity = current_user.identity_id
         elif isinstance(auth_config, BasicAuthConfig):
             # basic auth - assume it's the single existing user
             user_identity = list(auth_config.users.keys())[0]