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

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,