dara-core 1.16.23__py3-none-any.whl → 1.17.0__py3-none-any.whl

dara/core/base_definitions.py

@@ -428,6 +428,15 @@ class PendingTask(BaseTask):
         """
         self.subscribers -= 1
 
+    async def value(self):
+        """
+        Wait for the task to complete and return the result
+        """
+        await self.event.wait()
+        if self.error:
+            raise self.error
+        return self.result
+
 
 class PendingValue:
     """

dara/core/interactivity/__init__.py

@@ -42,6 +42,7 @@ 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.switch_variable import SwitchVariable
 from dara.core.interactivity.url_variable import UrlVariable
 
 __all__ = [
@@ -52,6 +53,7 @@ __all__ = [
     'DataVariable',
     'NonDataVariable',
     'Variable',
+    'SwitchVariable',
     'DerivedVariable',
     'DerivedDataVariable',
     'UrlVariable',

dara/core/interactivity/actions.py

@@ -1247,15 +1247,7 @@ class ActionCtx:
 
         task = Task(func=func, args=args, kwargs=kwargs, on_progress=on_progress)
         pending_task = await task_mgr.run_task(task)
-
-        # Run until completion
-        await pending_task.event.wait()
-
-        # Raise exception if there was one
-        if pending_task.error:
-            raise pending_task.error
-
-        return pending_task.result
+        return await pending_task.value()
 
     async def execute_action(self, action: ActionImpl):
         """

dara/core/interactivity/condition.py

@@ -20,6 +20,8 @@ from __future__ import annotations
 from enum import Enum
 from typing import TYPE_CHECKING, ClassVar, Union
 
+from pydantic import SerializerFunctionWrapHandler, model_serializer
+
 from dara.core.base_definitions import DaraBaseModel as BaseModel
 
 # Type-only imports
@@ -46,3 +48,9 @@ class Condition(BaseModel):
     variable: AnyVariable
 
     Operator: ClassVar[OperatorType] = Operator
+
+    @model_serializer(mode='wrap')
+    def ser_model(self, nxt: SerializerFunctionWrapHandler) -> dict:
+        parent_dict = nxt(self)
+
+        return {**parent_dict, '__typename': 'Condition'}

dara/core/interactivity/plain_variable.py

@@ -37,20 +37,6 @@ from dara.core.internal.utils import call_async
 from dara.core.logging import dev_logger
 from dara.core.persistence import PersistenceStore
 
-
-def _is_subclass_safe(value: type, base: type) -> bool:
-    """
-    Check if a class is a subclass of another class. Returns False if the value is not a class.
-
-    :param value: the class to check
-    :param base: the class to check against
-    """
-    try:
-        return issubclass(value, base)
-    except TypeError:
-        return False
-
-
 VARIABLE_INIT_OVERRIDE = ContextVar[Optional[Callable[[dict], dict]]]('VARIABLE_INIT_OVERRIDE', default=None)
 
 VariableType = TypeVar('VariableType')

dara/core/interactivity/switch_variable.py

@@ -0,0 +1,416 @@
+"""
+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.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional, Union
+
+from pydantic import SerializerFunctionWrapHandler, field_validator, model_serializer
+
+from dara.core.interactivity.condition import Condition
+from dara.core.interactivity.non_data_variable import NonDataVariable
+
+
+class SwitchVariable(NonDataVariable):
+    """
+    A SwitchVariable represents a conditional value that switches between
+    different values based on a condition or variable value.
+
+    SwitchVariable provides a clean way to create conditional logic in your
+    application by mapping input values or conditions to output values. It
+    supports boolean conditions, value mappings, and default fallbacks.
+
+    There are three main patterns for creating SwitchVariables:
+
+    1. **Boolean Conditions**: Switch between two values based on a true/false condition
+    2. **Value Mapping**: Map specific input values to corresponding output values
+    3. **Mixed Usage**: Combine conditions and mappings with default fallbacks
+
+    Examples:
+        Basic boolean switching:
+
+        ```python
+        from dara.core import ConfigurationBuilder, Variable, SwitchVariable
+        from dara.components import Stack, Text, Button, Card
+
+        config = ConfigurationBuilder()
+        is_admin = Variable(default=False)
+
+        # Show different UI based on admin status
+        ui_mode = SwitchVariable.when(
+            condition=is_admin,
+            true_value='Admin Panel',
+            false_value='User Panel'
+        )
+
+        # Complete component usage
+        page_content = Card(
+            Stack(
+                Text('Current Mode:'),
+                Text(text=ui_mode),
+                Button('Toggle Admin', onclick=is_admin.toggle())
+            ),
+            title='Admin Panel Demo'
+        )
+
+        config.add_page('Admin Demo', content=page_content)
+        ```
+
+        Value mapping with defaults:
+
+        ```python
+        from dara.core import ConfigurationBuilder, Variable, SwitchVariable
+        from dara.components import Stack, Text, Select, Item, Card
+
+        config = ConfigurationBuilder()
+        user_role = Variable(default='guest')
+
+        # Map user roles to permission levels
+        permissions = SwitchVariable.match(
+            value=user_role,
+            mapping={
+                'admin': 'Full Access',
+                'editor': 'Write Access',
+                'viewer': 'Read Access'
+            },
+            default='No Access'  # for unknown roles
+        )
+
+        # Complete component usage
+        page_content = Card(
+            Stack(
+                Text('Select Role:'),
+                Select(
+                    value=user_role,
+                    items=[
+                        Item(label='Guest', value='guest'),
+                        Item(label='Viewer', value='viewer'),
+                        Item(label='Editor', value='editor'),
+                        Item(label='Admin', value='admin')
+                    ]
+                ),
+                Text('Permissions:'),
+                Text(text=permissions)
+            ),
+            title='Role Permissions'
+        )
+
+        config.add_page('Permissions Demo', content=page_content)
+        ```
+
+        Complex conditions:
+
+        ```python
+        from dara.core import Variable, SwitchVariable
+        from dara.components import Stack, Text, Input, Card
+
+        score = Variable(default=85)
+
+        # Grade based on score ranges
+        grade = SwitchVariable.when(
+            condition=score >= 90,
+            true_value='A Grade',
+            false_value='B Grade'
+        )
+
+        # Complete component usage
+        grade_component = Card(
+            Stack(
+                Text('Enter Score:'),
+                Input(value=score, type='number'),
+                Text('Grade (>=90 = A, <90 = B):'),
+                Text(text=grade)
+            ),
+            title='Grade Calculator'
+        )
+        ```
+
+        Switching on computed conditions:
+
+        ```python
+        from dara.core import Variable, SwitchVariable
+        from dara.components import Stack, Text, Input, Card
+
+        temperature = Variable(default=20)
+
+        # Weather advice based on temperature
+        advice = SwitchVariable.when(
+            condition=temperature > 25,
+            true_value='Wear light clothes - it\'s warm!',
+            false_value='Wear warm clothes - it\'s cool!'
+        )
+
+        # Complete component usage
+        weather_app = Card(
+            Stack(
+                Text('Temperature (°C):'),
+                Input(value=temperature, type='number'),
+                Text('Advice:'),
+                Text(text=advice)
+            ),
+            title='Weather Advisor'
+        )
+        ```
+
+        Using with other variables:
+
+        ```python
+        from dara.core import Variable, SwitchVariable
+        from dara.components import Stack, Text, Select, Item, Card
+
+        user_preference = Variable(default='auto')
+        mapping_variable = Variable({
+            'auto': 'System Theme',
+            'light': 'Light Theme',
+            'dark': 'Dark Theme'
+        })
+
+        # Theme selection with user preference override
+        active_theme = SwitchVariable.match(
+            value=user_preference,
+            mapping=mapping_variable,
+            default='Default Theme'
+        )
+
+        # Complete component usage
+        theme_selector = Card(
+            Stack(
+                Text('Theme Preference:'),
+                Select(
+                    value=user_preference,
+                    items=[
+                        Item(label='Auto', value='auto'),
+                        Item(label='Light', value='light'),
+                        Item(label='Dark', value='dark')
+                    ]
+                ),
+                Text('Active Theme:'),
+                Text(text=active_theme)
+            ),
+            title='Theme Selector'
+        )
+        ```
+
+    Note:
+        - Value can be a condition, raw value, or variable
+        - Value map can be a variable or a dict
+        - Default can be a variable or a raw value
+        - The switch evaluation happens reactively when underlying variables change
+        - Default values are only used in mapping scenarios when the switch value
+          doesn't match any key in the mapping
+
+    Key Serialization:
+        When using mappings with SwitchVariable, be aware that JavaScript object keys
+        are always strings. The system automatically converts lookup keys to strings:
+        - Python: {True: 'admin', False: 'user'}
+        - JavaScript: {"true": "admin", "false": "user"}
+        - Boolean values are converted to lowercase strings ("true"/"false")
+        - Other values use standard string conversion to match JavaScript's String() behavior
+    """
+
+    value: Optional[Union[Condition, NonDataVariable, 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,
+        default: Optional[Any] = None,
+        uid: Optional[str] = None,
+    ):
+        """
+        Create a SwitchVariable with a mapping of values.
+
+        :param value: Variable, condition, or value to switch on
+        :param value_map: Dict mapping switch values to return values
+        :param default: Default value when switch value not in mapping
+        :param uid: Unique identifier for this variable
+        """
+        super().__init__(
+            uid=uid,
+            value=value,
+            value_map=value_map,
+            default=default,
+        )
+
+    @field_validator('value_map')
+    @classmethod
+    def validate_value_map(cls, v):
+        """
+        Validate that value_map is either a dict or a NonDataVariable.
+
+        :param v: The value to validate
+        :return: The validated value
+        :raises ValueError: If value_map is not a dict or NonDataVariable
+        """
+        if v is None:
+            return v
+        if isinstance(v, dict):
+            return v
+        if isinstance(v, NonDataVariable):
+            return v
+        raise ValueError(f'value_map must be a dict or NonDataVariable, got {type(v)}')
+
+    @classmethod
+    def when(
+        cls,
+        condition: Union[Condition, NonDataVariable, Any],
+        true_value: Union[Any, NonDataVariable],
+        false_value: Union[Any, NonDataVariable],
+        uid: Optional[str] = None,
+    ) -> 'SwitchVariable':
+        """
+        Create a SwitchVariable for boolean conditions.
+
+        This is the most common pattern for simple if/else logic. The condition
+        is evaluated and returns true_value if truthy, false_value otherwise.
+
+        :param condition: Condition to evaluate (Variable, Condition object, or any value)
+        :param true_value: Value to return when condition evaluates to True
+        :param false_value: Value to return when condition evaluates to False
+        :param uid: Unique identifier for this variable
+        :return: SwitchVariable configured for boolean switching
+
+        Example with variable condition:
+            ```python
+            from dara.core import Variable, SwitchVariable
+            from dara.components import Stack, Text, Button
+
+            is_loading = Variable(default=True)
+
+            # Show spinner while loading, content when done
+            display = SwitchVariable.when(
+                condition=is_loading,
+                true_value='Loading...',
+                false_value='Content loaded!'
+            )
+
+            # Use in a complete component
+            page_content = Stack(
+                Text(text=display),
+                Button(
+                    text='Toggle Loading',
+                    onclick=is_loading.toggle()
+                )
+            )
+            ```
+
+            Example with a condition object:
+
+            ```python
+            from dara.core import Variable, SwitchVariable
+            from dara.components import Stack, Text, Input, Card
+
+            # Temperature-based clothing advice
+            temperature = Variable(default=20)
+            advice = SwitchVariable.when(
+                condition=temperature > 25,
+                true_value='Wear light clothes - it\'s warm!',
+                false_value='Wear warm clothes - it\'s cool!'
+            )
+
+            # Complete weather advice component
+            weather_component = Card(
+                Stack(
+                    Text('Enter temperature (°C):'),
+                    Input(value=temperature, type='number'),
+                    Text('Advice:'),
+                    Text(text=advice)
+                ),
+                title='Weather Advice'
+            )
+            ```
+        """
+        return cls(
+            value=condition,
+            value_map={True: true_value, False: false_value},
+            uid=uid,
+        )
+
+    @classmethod
+    def match(
+        cls,
+        value: Union[NonDataVariable, Any],
+        mapping: Union[Dict[Any, Any], NonDataVariable],
+        default: Optional[Union[Any, NonDataVariable]] = None,
+        uid: Optional[str] = None,
+    ) -> 'SwitchVariable':
+        """
+        Create a SwitchVariable with a custom mapping.
+
+        This pattern is useful when you have multiple specific values to map to
+        different outputs, similar to a switch statement in other languages.
+
+        :param value: Variable or value to switch on
+        :param mapping: Dict mapping switch values to return values
+        :param default: Default value when switch value not found in mapping
+        :param uid: Unique identifier for this variable
+        :return: SwitchVariable configured with the provided mapping
+
+        Example:
+            ```python
+            from dara.core import Variable, SwitchVariable
+            from dara.components import Stack, Text, Select, Item
+
+            status = Variable(default='pending')
+
+            # Map status codes to user-friendly messages
+            message = SwitchVariable.match(
+                value=status,
+                mapping={
+                    'pending': 'Please wait...',
+                    'success': 'Operation completed!',
+                    'error': 'Something went wrong',
+                    'cancelled': 'Operation was cancelled'
+                },
+                default='Unknown status'
+            )
+
+            # Use in a complete component
+            page_content = Stack(
+                Select(
+                    value=status,
+                    items=[
+                        Item(label='Pending', value='pending'),
+                        Item(label='Success', value='success'),
+                        Item(label='Error', value='error'),
+                        Item(label='Cancelled', value='cancelled')
+                    ]
+                ),
+                Text(text=message)
+            )
+            ```
+        """
+        return cls(
+            value=value,
+            value_map=mapping,
+            default=default,
+            uid=uid,
+        )
+
+    @model_serializer(mode='wrap')
+    def ser_model(self, nxt: SerializerFunctionWrapHandler) -> dict:
+        """
+        Serialize the SwitchVariable model with additional metadata.
+
+        :param nxt: The next serializer function in the chain
+        :return: Serialized dictionary with __typename and uid fields
+        """
+        parent_dict = nxt(self)
+        return {**parent_dict, '__typename': 'SwitchVariable', 'uid': str(parent_dict['uid'])}

dara/core/internal/dependency_resolution.py

@@ -19,12 +19,14 @@ 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.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):
@@ -50,6 +52,14 @@ class ResolvedDataVariable(TypedDict):
     uid: str
 
 
+class ResolvedSwitchVariable(TypedDict):
+    type: Literal['switch']
+    uid: str
+    value: Any
+    value_map: Any
+    default: Any
+
+
 def is_resolved_derived_variable(obj: Any) -> TypeGuard[ResolvedDerivedVariable]:
     return isinstance(obj, dict) and 'uid' in obj and obj.get('type') == 'derived'
 
@@ -62,8 +72,14 @@ 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_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[ResolvedDerivedDataVariable, ResolvedDataVariable, ResolvedDerivedVariable, Any],
+    entry: Union[
+        ResolvedDerivedDataVariable, ResolvedDataVariable, ResolvedDerivedVariable, ResolvedSwitchVariable, Any
+    ],
     store: CacheStore,
     task_mgr: TaskManager,
 ):
@@ -84,6 +100,9 @@ async def resolve_dependency(
     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)
+
     return entry
 
 
@@ -149,3 +168,121 @@ async def _resolve_data_var(data_variable_entry: ResolvedDataVariable, store: Ca
     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:
+    """
+    Normalize a value to a string key that matches JavaScript object key serialization.
+    This ensures consistent lookup between Python backend and JavaScript frontend.
+
+    JavaScript's String() conversion rules:
+    - String(true) -> "true", String(false) -> "false"
+    - String(null) -> "null", String(undefined) -> "undefined"
+    - Numbers and other types are converted to their string representation
+
+    :param value: The value to normalize as a lookup key
+    :return: String representation suitable for object key lookup
+    """
+    if isinstance(value, bool):
+        # JavaScript String(true) -> "true", String(false) -> "false"
+        return str(value).lower()
+    elif value is None:
+        # JavaScript String(null) -> "null"
+        return 'null'
+    else:
+        # For numbers, strings, and other types, use standard string conversion
+        return str(value)
+
+
+def _evaluate_condition(condition: dict) -> bool:
+    """
+    Evaluate a condition object and return the boolean result.
+
+    :param condition: condition dict with 'variable', 'operator', and 'other' keys
+    :return: boolean result of the condition evaluation
+    """
+    variable_value = condition['variable']
+    operator = condition['operator']
+    other_value = condition['other']
+
+    if operator == 'equal':
+        return variable_value == other_value
+    elif operator == 'truthy':
+        return bool(variable_value)
+    elif operator == 'not_equal':
+        return variable_value != other_value
+    else:
+        # strictly numeric comparisons, ensure they're numbers just in case
+        val_a = float(variable_value)
+        val_b = float(other_value)
+
+        if operator == 'greater_than':
+            return val_a > val_b
+        elif operator == 'greater_equal':
+            return val_a >= val_b
+        elif operator == 'less_than':
+            return val_a < val_b
+        elif operator == 'less_equal':
+            return val_a <= val_b
+        else:
+            raise ValueError(f'Unknown condition operator: {operator}')
+
+
+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.
+
+    :param switch_variable_entry: switch variable entry
+    :param store: store instance to use for caching
+    :param task_mgr: task manager instance
+    """
+
+    async def _resolve_maybe_task(value: Any) -> Any:
+        if isinstance(value, BaseTask):
+            task_result = await task_mgr.run_task(value)
+            if isinstance(task_result, PendingTask):
+                return await task_result.value()
+            return task_result
+        return value
+
+    # resolve the constituent parts
+    resolved_value = await resolve_dependency(switch_variable_entry.get('value'), store, task_mgr)
+    resolved_value = await _resolve_maybe_task(resolved_value)
+
+    resolved_value_map = await resolve_dependency(switch_variable_entry.get('value_map'), store, task_mgr)
+    resolved_value_map = await _resolve_maybe_task(resolved_value_map)
+
+    resolved_default = await resolve_dependency(switch_variable_entry.get('default'), store, task_mgr)
+    resolved_default = await _resolve_maybe_task(resolved_default)
+
+    # The frontend should have already evaluated conditions and sent the resolved value
+    # For switch variables, we just need to look up the value in the mapping
+    if isinstance(resolved_value_map, dict):
+        # value could be a condition object
+        if isinstance(resolved_value, dict) and resolved_value.get('__typename') == 'Condition':
+            # Evaluate the condition and use the boolean result as the lookup key
+            try:
+                # First, resolve any nested dependencies in the condition's 'other' field
+                condition_copy = resolved_value.copy()
+                condition_copy['other'] = await resolve_dependency(condition_copy.get('other'), store, task_mgr)
+                condition_copy['other'] = await _resolve_maybe_task(condition_copy['other'])
+
+                # Also resolve the variable field in case it's a dependency
+                condition_copy['variable'] = await resolve_dependency(condition_copy.get('variable'), store, task_mgr)
+                condition_copy['variable'] = await _resolve_maybe_task(condition_copy['variable'])
+
+                # Evaluate the condition
+                resolved_value = _evaluate_condition(condition_copy)
+            except Exception as e:
+                # If condition evaluation fails, log and use default
+                dev_logger.error('Error evaluating condition', error=e)
+                return resolved_default
+
+        # Normalize the lookup key to match JavaScript object key serialization
+        resolved_value = _normalize_lookup_key(resolved_value)
+
+        # Try to get the value from the mapping, fall back to default
+        return resolved_value_map.get(resolved_value, resolved_default)
+
+    # If value_map is not a dict (shouldn't happen in normal cases), return default
+    return resolved_default

dara/core/main.py

@@ -314,6 +314,9 @@ def _start_application(config: Configuration):
                     template_registry.register(name, renderer(config))
 
     except Exception as e:
+        import traceback
+
+        traceback.print_exc()
         dev_logger.error(
             'Something went wrong when building application template, there is most likely an issue in the application logic',
             e,

dara/core/umd/dara.core.umd.js

@@ -50158,6 +50158,9 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
   function isLoopVariable(variable) {
     return variable && typeof variable == "object" && variable.hasOwnProperty("uid") && variable.hasOwnProperty("__typename") && variable.__typename === "LoopVariable";
   }
+  function isSwitchVariable(variable) {
+    return isVariable(variable) && variable.__typename === "SwitchVariable";
+  }
   function isResolvedDerivedVariable(value) {
     return value && typeof value === "object" && "values" in value && "type" in value && value.type === "derived" && "uid" in value;
   }
@@ -50167,6 +50170,9 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
   function isResolvedDerivedDataVariable(value) {
     return value && typeof value === "object" && "filters" in value && "values" in value && "type" in value && value.type === "derived-data" && "uid" in value;
   }
+  function isResolvedSwitchVariable(value) {
+    return value && typeof value === "object" && "type" in value && value.type === "switch" && "uid" in value && "value_map" in value;
+  }
   function isActionImpl(action) {
     return action && typeof action === "object" && action.__typename === "ActionImpl";
   }
@@ -50174,6 +50180,9 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
     return action && "uid" in action && "definition_uid" in action && "dynamic_kwargs" in action;
   }
   const isPyComponent = (value) => isObject_1(value) && "props" in value && isObject_1(value.props) && "func_name" in value.props && "dynamic_kwargs" in value.props;
+  function isCondition(value) {
+    return value && typeof value === "object" && value.__typename === "Condition";
+  }
   function commonjsRequire(path) {
     throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
   }
@@ -51103,11 +51112,16 @@ You must set sticky: 'left' | 'right' for the '${bugWithUnderColumnsSticky.Heade
           ...lookup,
           ...nestedLookup
         };
-      } else {
+      } else if (isResolvedSwitchVariable(val)) {
         const varDef = def.variables[key];
         const identifier = getIdentifier(varDef);
         lookup[identifier] = val;
         normalizedValues.push({ __ref: identifier });
+      } else {
+        const varDef = def.variables[key];
+        const identifier = getIdentifier(varDef);
+        lookup[identifier] = val === void 0 ? null : val;
+        normalizedValues.push({ __ref: identifier });
       }
     }
     return {
@@ -52935,6 +52949,14 @@ Inferred class string: "${iconClasses}."`
           values: formatDerivedVariableRequest(nestedValues)
         };
       }
+      if (isResolvedSwitchVariable(val)) {
+        return {
+          ...val,
+          value: formatDerivedVariableRequest([val.value])[0],
+          value_map: formatDerivedVariableRequest([val.value_map])[0],
+          default: formatDerivedVariableRequest([val.default])[0]
+        };
+      }
       return val;
     });
   }
@@ -53007,9 +53029,23 @@ Inferred class string: "${iconClasses}."`
         values: resolvedValues
       };
     }
+    if (isResolvedSwitchVariable(value)) {
+      return {
+        ...value,
+        value: resolveValue(value.value, getter),
+        value_map: resolveValue(value.value_map, getter),
+        default: resolveValue(value.default, getter)
+      };
+    }
     if (isResolvedDataVariable(value)) {
       return value;
     }
+    if (isCondition(value)) {
+      return {
+        ...value,
+        variable: resolveValue(value.variable, getter)
+      };
+    }
     if (Recoil_index_2(value)) {
       return getter(value);
     }
@@ -53020,7 +53056,13 @@ Inferred class string: "${iconClasses}."`
       if (deps && !deps.includes(idx)) {
         return [];
       }
-      return isResolvedDerivedVariable(val) || isResolvedDerivedDataVariable(val) ? getDeps(val.values, val.deps).flat() : val;
+      if (isResolvedDerivedVariable(val) || isResolvedDerivedDataVariable(val)) {
+        return getDeps(val.values, val.deps).flat();
+      }
+      if (isResolvedSwitchVariable(val)) {
+        return getDeps([val.value, val.value_map, val.default], [0, 1, 2]).flat();
+      }
+      return val;
     });
   }
   function useTriggerIndex(variable) {
@@ -53365,6 +53407,24 @@ Inferred class string: "${iconClasses}."`
     if (isUrlVariable(variable)) {
       return resolver(getOrRegisterUrlVariable(variable));
     }
+    if (isSwitchVariable(variable)) {
+      let resolvedValue = isVariable(variable.value) ? resolveVariable(variable.value, client, taskContext, extras, resolver) : variable.value;
+      if (isCondition(resolvedValue)) {
+        resolvedValue = {
+          ...resolvedValue,
+          variable: resolveVariable(resolvedValue.variable, client, taskContext, extras, resolver)
+        };
+      }
+      const resolvedValueMap = isVariable(variable.value_map) ? resolveVariable(variable.value_map, client, taskContext, extras, resolver) : variable.value_map;
+      const resolvedDefault = isVariable(variable.default) ? resolveVariable(variable.default, client, taskContext, extras, resolver) : variable.default;
+      return {
+        type: "switch",
+        uid: variable.uid,
+        value: resolvedValue,
+        value_map: resolvedValueMap,
+        default: resolvedDefault
+      };
+    }
     return resolver(getOrRegisterPlainVariable(variable, client, taskContext, extras));
   }
   /*!
@@ -54257,6 +54317,46 @@ Inferred class string: "${iconClasses}."`
   function StoreProviders({ children }) {
     return /* @__PURE__ */ React__namespace.createElement(BackendStoreSync, null, /* @__PURE__ */ React__namespace.createElement(BrowserStoreSync, null, children));
   }
+  function isConditionTrue(operator, value, other) {
+    if (operator === ConditionOperator.EQUAL) {
+      return value === other;
+    }
+    if (operator === ConditionOperator.NOT_EQUAL) {
+      return value !== other;
+    }
+    if (operator === ConditionOperator.GREATER_EQUAL) {
+      return value >= other;
+    }
+    if (operator === ConditionOperator.GREATER_THAN) {
+      return value > other;
+    }
+    if (operator === ConditionOperator.LESS_EQUAL) {
+      return value <= other;
+    }
+    if (operator === ConditionOperator.LESS_THAN) {
+      return value < other;
+    }
+    if (operator === ConditionOperator.TRUTHY) {
+      return !!value;
+    }
+    throw new Error(`Unexpected operator ${String(operator)} passed to conditional (If) component`);
+  }
+  function useConditionOrVariable(arg) {
+    if (isCondition(arg)) {
+      const value = useVariable(arg.variable)[0];
+      const other = useVariable(arg.other)[0];
+      return isConditionTrue(arg.operator, value, other);
+    }
+    return useVariable(arg)[0];
+  }
+  function useSwitchVariable(variable) {
+    var _a;
+    const value = useConditionOrVariable(variable.value);
+    const [valueMap] = useVariable(variable.value_map);
+    const [defaultValue] = useVariable(variable.default);
+    const lookupKey = String(value);
+    return (_a = valueMap[lookupKey]) != null ? _a : defaultValue;
+  }
   function warnUpdateOnDerivedState() {
     console.warn("You tried to call update on variable with derived state, this is a noop and will be ignored.");
   }
@@ -54302,6 +54402,9 @@ Inferred class string: "${iconClasses}."`
       }, [urlValue]);
       return [urlValue, setUrlValue];
     }
+    if (isSwitchVariable(variable)) {
+      return [useSwitchVariable(variable), warnUpdateOnDerivedState];
+    }
     const recoilState = getOrRegisterPlainVariable(variable, wsClient, taskContext, extras);
     if (!isDerivedVariable(variable.default)) {
       const [value, setValue] = Recoil_index_22(recoilState);
@@ -54907,6 +55010,9 @@ Inferred class string: "${iconClasses}."`
       ctx.extras,
       (v2) => ctx.snapshot.getLoadable(v2).getValue()
     );
+    if (isResolvedSwitchVariable(resolved)) {
+      throw new UserError("Switch variables are not supported in this context");
+    }
     if (!shouldFetchVariable || !isDerivedVariable(variable) && !isDataVariable(variable) && !isDerivedDataVariable(variable)) {
       return resolved;
     }
@@ -55257,6 +55363,14 @@ Inferred class string: "${iconClasses}."`
         values: cleanedValues
       };
     }
+    if (isResolvedSwitchVariable(value)) {
+      return {
+        ...value,
+        value: cleanValue(value.value, force),
+        value_map: cleanValue(value.value_map, force),
+        default: cleanValue(value.default, force)
+      };
+    }
     return value;
   }
   function cleanKwargs(kwargs, force) {
@@ -56790,6 +56904,8 @@ Inferred class string: "${iconClasses}."`
         ctx.eventBus.publish("URL_VARIABLE_LOADED", { variable, value: variable.default });
       } else if (isDataVariable(variable))
         ;
+      else if (isSwitchVariable(variable))
+        ;
       else {
         const plainAtom = getOrRegisterPlainVariable(variable, ctx.wsClient, ctx.taskCtx, ctx.extras);
         ctx.reset(plainAtom);
@@ -82580,6 +82696,8 @@ Inferred class string: "${iconClasses}."`
   exports.injectCss = injectCss;
   exports.isActionImpl = isActionImpl;
   exports.isAnnotatedAction = isAnnotatedAction;
+  exports.isCondition = isCondition;
+  exports.isConditionTrue = isConditionTrue;
   exports.isDataVariable = isDataVariable;
   exports.isDerivedDataVariable = isDerivedDataVariable;
   exports.isDerivedVariable = isDerivedVariable;
@@ -82592,6 +82710,8 @@ Inferred class string: "${iconClasses}."`
   exports.isResolvedDataVariable = isResolvedDataVariable;
   exports.isResolvedDerivedDataVariable = isResolvedDerivedDataVariable;
   exports.isResolvedDerivedVariable = isResolvedDerivedVariable;
+  exports.isResolvedSwitchVariable = isResolvedSwitchVariable;
+  exports.isSwitchVariable = isSwitchVariable;
   exports.isTaskResponse = isTaskResponse$1;
   exports.isUrlVariable = isUrlVariable;
   exports.isVariable = isVariable;
@@ -82620,6 +82740,7 @@ Inferred class string: "${iconClasses}."`
   exports.useComponentRegistry = useComponentRegistry;
   exports.useComponentStyles = useComponentStyles;
   exports.useComponents = useComponents;
+  exports.useConditionOrVariable = useConditionOrVariable;
   exports.useConfig = useConfig;
   exports.useDataVariable = useDataVariable;
   exports.useDeferLoadable = useDeferLoadable;
@@ -82632,6 +82753,7 @@ Inferred class string: "${iconClasses}."`
   exports.useRequestExtras = useRequestExtras;
   exports.useSession = useSession;
   exports.useSessionToken = useSessionToken;
+  exports.useSwitchVariable = useSwitchVariable;
   exports.useTaskContext = useTaskContext;
   exports.useTemplate = useTemplate;
   exports.useTriggerIndex = useTriggerIndex;

{dara_core-1.16.23.dist-info → dara_core-1.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dara-core
-Version: 1.16.23
+Version: 1.17.0
 Summary: Dara Framework Core
 Home-page: https://dara.causalens.com/
 License: Apache-2.0
@@ -20,10 +20,10 @@ Requires-Dist: async-asgi-testclient (>=1.4.11,<2.0.0)
 Requires-Dist: certifi (>=2024.7.4)
 Requires-Dist: click (==8.1.3)
 Requires-Dist: colorama (>=0.4.6,<0.5.0)
-Requires-Dist: create-dara-app (==1.16.23)
+Requires-Dist: create-dara-app (==1.17.0)
 Requires-Dist: croniter (>=1.0.15,<3.0.0)
 Requires-Dist: cryptography (>=42.0.4)
-Requires-Dist: dara-components (==1.16.23) ; extra == "all"
+Requires-Dist: dara-components (==1.17.0) ; extra == "all"
 Requires-Dist: exceptiongroup (>=1.1.3,<2.0.0)
 Requires-Dist: fastapi (>=0.115.0,<0.116.0)
 Requires-Dist: fastapi_vite_dara (==0.4.0)
@@ -54,7 +54,7 @@ Description-Content-Type: text/markdown
 
 # Dara Application Framework
 
-<img src="https://github.com/causalens/dara/blob/v1.16.23/img/dara_light.svg?raw=true">
+<img src="https://github.com/causalens/dara/blob/v1.17.0/img/dara_light.svg?raw=true">
 
 ![Master tests](https://github.com/causalens/dara/actions/workflows/tests.yml/badge.svg?branch=master)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://www.apache.org/licenses/LICENSE-2.0)
@@ -99,7 +99,7 @@ source .venv/bin/activate
 dara start
 ```
 
-![Dara App](https://github.com/causalens/dara/blob/v1.16.23/img/components_gallery.png?raw=true)
+![Dara App](https://github.com/causalens/dara/blob/v1.17.0/img/components_gallery.png?raw=true)
 
 Note: `pip` installation uses [PEP 660](https://peps.python.org/pep-0660/) `pyproject.toml`-based editable installs which require `pip >= 21.3` and `setuptools >= 64.0.0`. You can upgrade both with:
 
@@ -116,9 +116,9 @@ Explore some of our favorite apps - a great way of getting started and getting t
 
 | Dara App                                                                                                 | Description                                                                                                                                                                                                       |
 | -------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| ![Large Language Model](https://github.com/causalens/dara/blob/v1.16.23/img/llm.png?raw=true)              | Demonstrates how to use incorporate a LLM chat box into your decision app to understand model insights                                                                                                            |
-| ![Plot Interactivity](https://github.com/causalens/dara/blob/v1.16.23/img/plot_interactivity.png?raw=true) | Demonstrates how to enable the user to interact with plots, trigger actions based on clicks, mouse movements and other interactions with `Bokeh` or `Plotly` plots                                                |
-| ![Graph Editor](https://github.com/causalens/dara/blob/v1.16.23/img/graph_viewer.png?raw=true)             | Demonstrates how to use the `CausalGraphViewer` component to display your graphs or networks, customising the displayed information through colors and tooltips, and updating the page based on user interaction. |
+| ![Large Language Model](https://github.com/causalens/dara/blob/v1.17.0/img/llm.png?raw=true)              | Demonstrates how to use incorporate a LLM chat box into your decision app to understand model insights                                                                                                            |
+| ![Plot Interactivity](https://github.com/causalens/dara/blob/v1.17.0/img/plot_interactivity.png?raw=true) | Demonstrates how to enable the user to interact with plots, trigger actions based on clicks, mouse movements and other interactions with `Bokeh` or `Plotly` plots                                                |
+| ![Graph Editor](https://github.com/causalens/dara/blob/v1.17.0/img/graph_viewer.png?raw=true)             | Demonstrates how to use the `CausalGraphViewer` component to display your graphs or networks, customising the displayed information through colors and tooltips, and updating the page based on user interaction. |
 
 Check out our [App Gallery](https://dara.causalens.com/gallery) for more inspiration!
 
@@ -145,9 +145,9 @@ And the supporting UI packages and tools.
 - `ui-utils` - miscellaneous utility functions
 - `ui-widgets` - widget components
 
-More information on the repository structure can be found in the [CONTRIBUTING.md](https://github.com/causalens/dara/blob/v1.16.23/CONTRIBUTING.md) file.
+More information on the repository structure can be found in the [CONTRIBUTING.md](https://github.com/causalens/dara/blob/v1.17.0/CONTRIBUTING.md) file.
 
 ## License
 
-Dara is open-source and licensed under the [Apache 2.0 License](https://github.com/causalens/dara/blob/v1.16.23/LICENSE).
+Dara is open-source and licensed under the [Apache 2.0 License](https://github.com/causalens/dara/blob/v1.17.0/LICENSE).
 

{dara_core-1.16.23.dist-info → dara_core-1.17.0.dist-info}/RECORD

@@ -6,7 +6,7 @@ dara/core/auth/basic.py,sha256=IMkoC1OeeRmnmjIqPHpybs8zSdbLlNKYLRvj08ajirg,4692
 dara/core/auth/definitions.py,sha256=7SoUBlYQhccop4Rl0XlHjSBjBU41ZbCZHS7Y-fL9g84,3501
 dara/core/auth/routes.py,sha256=1gOe1Z2Vv5MtpW5uvUYvyYWTJ_BDoLRllji1Plk4nss,7180
 dara/core/auth/utils.py,sha256=sFQWbkclDi2842mhauTeLh5g5RsSrzS7AxlKSSnzhYM,7320
-dara/core/base_definitions.py,sha256=6PFJpeHADl518TgkFHrQ7U2442S2RM5fTKkpm6_pAcY,17839
+dara/core/base_definitions.py,sha256=wNYPDUFHHhjE4gH2fm1z2wba04Lrl3-7JDua01j-zCs,18062
 dara/core/cli.py,sha256=hgzy8zrEB_JR2GF_nBBfs9d2I9LmjJt0OQJYOOCc284,8158
 dara/core/configuration.py,sha256=bWD9oL_lqCEq88I2Zr39cPt_8jZIwq5vUAyLFrsmVYQ,22297
 dara/core/css.py,sha256=KWCJTPpx4tTezP9VJO3k-RSVhWwomJr-4USoLz9vNAs,1771
@@ -14,18 +14,19 @@ dara/core/data_utils.py,sha256=5GGz4vk6srLO8HMySiAEk_xZCvmf0SeTTgVi-N4qaKY,12636
 dara/core/defaults.py,sha256=UkjWwIbo8GLyn8RZRoD3cJe174-3wHZYzvMB0hQCnMg,4150
 dara/core/definitions.py,sha256=KmJdLWwurLBRZonPz94N9947cG1jMrs-wzqtof6ubK0,17762
 dara/core/http.py,sha256=LR1Kr5Hca-Z6klNl-M8R8Q1eOfFh3hLrjVS3kVrRsKA,4658
-dara/core/interactivity/__init__.py,sha256=zZp4wO6nHZ_-IzDtlv8D5mjlutn4bckqIiSCaPoCYZw,2326
-dara/core/interactivity/actions.py,sha256=yMw8S11wj4J2HVmDsmedh9D0IZFL9hxw6WGNj7X2f6M,48198
+dara/core/interactivity/__init__.py,sha256=4gD69m5nRf6lefKdNx9K_fRJOqmsAwjALZqKiPtvutk,2415
+dara/core/interactivity/actions.py,sha256=niNMt-IE_YXTtLpYrueTNCT60KelmNCGpUn7-WTVDQ4,48020
 dara/core/interactivity/any_data_variable.py,sha256=1dLLxLuDErRsgaFPSTXxZHvpVucKKty90twQE6N-_NI,5286
 dara/core/interactivity/any_variable.py,sha256=LOGhbDdYffujlRxF4LR9ZuWdai03R-EXuGsTEJAwfo0,13544
-dara/core/interactivity/condition.py,sha256=q_RDDt-DtZEUQL054Mc7zHyJIJIGACljJ2gOFygCHQc,1309
+dara/core/interactivity/condition.py,sha256=69tdxgLqNbU-AlwHTWFdp-hvxGDugNnb_McDrz0mDtE,1575
 dara/core/interactivity/data_variable.py,sha256=pvPOx6SMxHWDxoo5Ea5xqLwrBTrWN68x8lnBiblYSGg,11760
 dara/core/interactivity/derived_data_variable.py,sha256=u2HOts5rtmzK3D1K383YfYYQnb4pHZF3rTu1lfwMpPA,15323
 dara/core/interactivity/derived_variable.py,sha256=x_vdt8hvgubDEISX6GfpR5CS7n2Vxq3oZIkVd8Daiw0,21927
 dara/core/interactivity/filtering.py,sha256=BZsWsQvXPhn6WUoAFpAtgN6hXlGDudPbi4h97Qao2ic,9197
 dara/core/interactivity/loop_variable.py,sha256=EqZX3bMCwKmI2Yu4pQ7TJG9hf3PY2AlAIBLxEzHFbTw,2998
 dara/core/interactivity/non_data_variable.py,sha256=IMH5cNce2O6RUbu4HB_VLT-BBnDnGHr3lp09XU_lWa4,2378
-dara/core/interactivity/plain_variable.py,sha256=yCm-gBoxNiWsJ43KS4Fr7WCPXIOaChn8FCjXh8IWMUA,9592
+dara/core/interactivity/plain_variable.py,sha256=ZIg9LhgfKEY1mfcWwysAXzeMRbVoFF61OYHt_od-9n0,9248
+dara/core/interactivity/switch_variable.py,sha256=mC91kBoZON3JGBczv-YPvA5A6zY0mKqEr_7d3Sa_YMg,14194
 dara/core/interactivity/url_variable.py,sha256=1ZPFHO3gq7ZuATHt4S9x5ijmk4GBVlUv5KJN6DkM49w,4357
 dara/core/internal/__init__.py,sha256=QN0wbG9HPQ_vXh8BO8DnBXeYLIENVTNtRmYzZf1lx7c,577
 dara/core/internal/cache_store/__init__.py,sha256=7JCmQwNIMzfyLZGnsk0BbT1EdDFO_PRZz86E9ATcC6c,139
@@ -36,7 +37,7 @@ dara/core/internal/cache_store/lru.py,sha256=V0KkpsU9oJ_vJ2j7iKFTxxihF1zCxVTvKBf
 dara/core/internal/cache_store/ttl.py,sha256=7zcVYR9a2M5qOTWuhor-TgKBKERPn6qsZsDnoUyazfM,4755
 dara/core/internal/cgroup.py,sha256=o1Qqn5LV3TOPK7lQ0xbQj01zYT1pv-X_edGx8VhFvEw,3218
 dara/core/internal/custom_response.py,sha256=aSPonh8AdRjioTk1MaPwdaJHkO4R4aG_osGAGCIHbtg,1341
-dara/core/internal/dependency_resolution.py,sha256=y0CUop-RNNhwZLbafeqjhNEiTY549mLvDyNMTfvEl2Q,5456
+dara/core/internal/dependency_resolution.py,sha256=YoDPvnEM5HXSJ1asrX8zrgceqj6EM1o5YVSWaFE8zUc,11161
 dara/core/internal/devtools.py,sha256=YmJdYKEqfxrpXFYAM5sJ2wUtUhfvaCMbb9PuDcqFdt4,2441
 dara/core/internal/download.py,sha256=2_fNIWDsV9f0BptTQRhBuIFXOO4th9pcYaIB7lsPcJU,3183
 dara/core/internal/encoder_registry.py,sha256=tq2ka9RjStEFsxTdsWF6kSOU7rycggEq8YfDlzSyzKk,11277
@@ -76,13 +77,13 @@ dara/core/js_tooling/templates/dara.config.json,sha256=RZG_R_xJv_5rYIoz2QZulcG49
 dara/core/js_tooling/templates/vite.config.template.ts,sha256=-_GgbqPAcg_rTL2JsWjqYqZa4w6p2fKa2nyqGnjqj18,888
 dara/core/log_configs/logging.yaml,sha256=YJyD18psAmSVz6587dcEOyoulLuRFFu1g8yMXl1ylM0,706
 dara/core/logging.py,sha256=HiEbksFvlsSunlJd7wZrYrhKzR0Y4il0982rIwg5wOo,13099
-dara/core/main.py,sha256=7bsmIPzjhnJx6RjcOaFTMKfxRBvnx8RjLjsH5xaQMQc,18326
+dara/core/main.py,sha256=LxWLueYonVMnstz8JnpiGACEvB8LXl75JGqfUCnmSEM,18382
 dara/core/metrics/__init__.py,sha256=2UqpWHv-Ie58QLJIHJ9Szfjq8xifAuwy5FYGUIFwWtI,823
 dara/core/metrics/cache.py,sha256=bGXwjO_rSc-FkS3PnPi1mvIZf1x-hvmG113dAUk1g-Y,2616
 dara/core/metrics/runtime.py,sha256=YP-6Dz0GeI9_Yr7bUk_-OqShyFySGH_AKpDO126l6es,1833
 dara/core/metrics/utils.py,sha256=aKaa_hskV3M3h4xOGZYvegDLq_OWOEUlslkQKrrPQiI,2281
 dara/core/persistence.py,sha256=-lnksbGfHwabeRjbJkceoFd0kHfCu4gK2fud8dkeDTg,18538
-dara/core/umd/dara.core.umd.js,sha256=dHJvK0B3dARTocGdCvCuOVZAx4qHwwviYwX4EaxrwT4,4725934
+dara/core/umd/dara.core.umd.js,sha256=M-6KfeAB33xEd0BzlZInksx5Ch0IK6B5cXwSg1E-gPc,4730555
 dara/core/umd/style.css,sha256=YQtQ4veiSktnyONl0CU1iU1kKfcQhreH4iASi1MP7Ak,4095007
 dara/core/visual/__init__.py,sha256=QN0wbG9HPQ_vXh8BO8DnBXeYLIENVTNtRmYzZf1lx7c,577
 dara/core/visual/components/__init__.py,sha256=eg6M2YcH1o-I2H3IqLaD32ExfZcXhKuH5KTM52Ow6RM,2359
@@ -106,8 +107,8 @@ dara/core/visual/themes/__init__.py,sha256=aM4mgoIYo2neBSw5FRzswsht7PUKjLthiHLmF
 dara/core/visual/themes/dark.py,sha256=UQGDooOc8ric73eHs9E0ltYP4UCrwqQ3QxqN_fb4PwY,1942
 dara/core/visual/themes/definitions.py,sha256=nS_gQvOzCt5hTmj74d0_siq_9QWuj6wNuir4VCHy0Dk,2779
 dara/core/visual/themes/light.py,sha256=-Tviq8oEwGbdFULoDOqPuHO0UpAZGsBy8qFi0kAGolQ,1944
-dara_core-1.16.23.dist-info/LICENSE,sha256=r9u1w2RvpLMV6YjuXHIKXRBKzia3fx_roPwboGcLqCc,10944
-dara_core-1.16.23.dist-info/METADATA,sha256=nkpL_PljY5X2YcGsCF4jMTmvKJ8iIcfD2tbrjlsD6Rk,7507
-dara_core-1.16.23.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-dara_core-1.16.23.dist-info/entry_points.txt,sha256=H__D5sNIGuPIhVam0DChNL-To5k8Y7nY7TAFz9Mz6cc,139
-dara_core-1.16.23.dist-info/RECORD,,
+dara_core-1.17.0.dist-info/LICENSE,sha256=r9u1w2RvpLMV6YjuXHIKXRBKzia3fx_roPwboGcLqCc,10944
+dara_core-1.17.0.dist-info/METADATA,sha256=EKazJEN18CnxMiVy52kYaZwHlRCYVDRKse9RQmDpT4U,7497
+dara_core-1.17.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+dara_core-1.17.0.dist-info/entry_points.txt,sha256=H__D5sNIGuPIhVam0DChNL-To5k8Y7nY7TAFz9Mz6cc,139
+dara_core-1.17.0.dist-info/RECORD,,