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

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

dara/core/interactivity/actions.py

@@ -55,6 +55,7 @@ from dara.core.base_definitions import (
 )
 from dara.core.base_definitions import DaraBaseModel as BaseModel
 from dara.core.interactivity.data_variable import DataVariable
+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
 from dara.core.internal.utils import run_user_handler
@@ -1456,6 +1457,11 @@ class action:
         dynamic_kwargs: Dict[str, AnyVariable] = {}
         static_kwargs: Dict[str, Any] = {}
         for key, kwarg in all_kwargs.items():
+            if isinstance(kwarg, StateVariable):
+                raise ValueError(
+                    'StateVariable cannot be used as input to actions. '
+                    "StateVariables are internal variables for tracking DerivedVariable ephemeral client state shouldn't be used as action payloads."
+                )
             if isinstance(kwarg, AnyVariable):
                 dynamic_kwargs[key] = kwarg
             else:

dara/core/interactivity/derived_variable.py

@@ -139,6 +139,19 @@ class DerivedVariable(NonDataVariable, Generic[VariableType]):
         if nested is None:
             nested = []
 
+        # Validate that StateVariables are not used as inputs
+        from dara.core.interactivity.state_variable import StateVariable
+
+        for var in variables:
+            if isinstance(var, StateVariable):
+                raise ValueError(
+                    'StateVariable cannot be used as input to DerivedVariable. '
+                    'StateVariables are internal variables for tracking DerivedVariable states '
+                    'and using them as inputs would create complex dependencies that are '
+                    'difficult to debug. Consider using the parent DerivedVariable directly instead,'
+                    ' or use the StateVariable with an If component or SwitchVariable.'
+                )
+
         if cache is not None:
             cache = Cache.Policy.from_arg(cache)
 
@@ -214,6 +227,39 @@ class DerivedVariable(NonDataVariable, Generic[VariableType]):
         assert_no_context('ctx.trigger')
         return TriggerVariable(variable=self, force=force)
 
+    @property
+    def is_loading(self):
+        """
+        Get a StateVariable that tracks the loading state of this DerivedVariable.
+
+        :return: StateVariable that is True when this DerivedVariable is loading, False otherwise
+        """
+        from dara.core.interactivity.state_variable import StateVariable
+
+        return StateVariable(parent_variable=self, property_name='loading')
+
+    @property
+    def has_error(self):
+        """
+        Get a StateVariable that tracks the error state of this DerivedVariable.
+
+        :return: StateVariable that is True when this DerivedVariable has an error, False otherwise
+        """
+        from dara.core.interactivity.state_variable import StateVariable
+
+        return StateVariable(parent_variable=self, property_name='error')
+
+    @property
+    def has_value(self):
+        """
+        Get a StateVariable that tracks whether this DerivedVariable has a resolved value.
+
+        :return: StateVariable that is True when this DerivedVariable has a value, False otherwise
+        """
+        from dara.core.interactivity.state_variable import StateVariable
+
+        return StateVariable(parent_variable=self, property_name='hasValue')
+
     @staticmethod
     def _get_cache_key(*args, uid: str, deps: Optional[List[int]] = None):
         """

dara/core/interactivity/state_variable.py

@@ -0,0 +1,69 @@
+"""
+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 TYPE_CHECKING, Optional
+
+from pydantic import SerializerFunctionWrapHandler, model_serializer
+from typing_extensions import Literal
+
+from dara.core.interactivity.non_data_variable import NonDataVariable
+
+if TYPE_CHECKING:
+    from dara.core.interactivity.derived_variable import DerivedVariable
+
+
+class StateVariable(NonDataVariable):
+    """
+    A StateVariable is an internal variable type used to track client-side state of other variables.
+    It is not meant to be created directly by users, but rather returned by properties like
+    DerivedVariable.is_loading, DerivedVariable.has_error, etc.
+
+    This variable tracks the state of a parent DerivedVariable and maps to specific properties
+    like loading state, error state, etc.
+    """
+
+    parent_variable: 'DerivedVariable'
+    property_name: Literal['loading', 'error', 'hasValue']
+
+    def __init__(
+        self,
+        parent_variable: 'DerivedVariable',
+        property_name: Literal['loading', 'error', 'hasValue'],
+        uid: Optional[str] = None,
+        **kwargs,
+    ):
+        """
+        Initialize a StateVariable.
+
+        :param parent_variable: The DerivedVariable this StateVariable tracks
+        :param property_name: The property name this StateVariable represents ('loading', 'error', etc.)
+        :param uid: Optional unique identifier; if not provided, one is generated
+        """
+        super().__init__(uid=uid, parent_variable=parent_variable, property_name=property_name, **kwargs)
+
+    @model_serializer(mode='wrap')
+    def ser_model(self, nxt: SerializerFunctionWrapHandler) -> dict:
+        parent_dict = nxt(self)
+        return {
+            **parent_dict,
+            '__typename': 'StateVariable',
+            'uid': str(parent_dict['uid']),
+            'parent_variable': self.parent_variable,
+            'property_name': self.property_name,
+        }

dara/core/internal/pool/task_pool.py

@@ -499,11 +499,14 @@ class TaskPool:
             while self.status not in (PoolStatus.ERROR, PoolStatus.STOPPED):
                 await anyio.sleep(0.1)
 
-                self._handle_excess_workers()
-                self._handle_orphaned_workers()
-                self._handle_dead_workers()
-                self._create_workers()
-                await self._process_next_worker_message()
+                try:
+                    self._handle_excess_workers()
+                    self._handle_orphaned_workers()
+                    self._handle_dead_workers()
+                    self._create_workers()
+                    await self._process_next_worker_message()
+                except Exception as e:
+                    dev_logger.error('Error in task pool', e)
         finally:
             self.loop_stopped.set()
 

dara/core/internal/pool/utils.py

@@ -27,6 +27,8 @@ from typing import Any, Callable, Optional, Tuple
 import anyio
 from tblib import Traceback
 
+from dara.core.logging import dev_logger
+
 
 class SubprocessException:
     """
@@ -131,20 +133,23 @@ async def stop_process_async(process: BaseProcess, timeout: float = 3):
     # Terminate and wait for it to shutdown
     process.terminate()
 
-    # mimic process.join() in an async way to not block
-    await wait_while(process.is_alive, timeout)
-
-    # If it's still alive
-    if process.is_alive():
-        try:
-            os.kill(process.pid, signal.SIGKILL)
-            await wait_while(process.is_alive, timeout)
-        except OSError as e:
-            raise RuntimeError(f'Unable to terminate subprocess with PID {process.pid}') from e
-
-    # If it's still alive raise an exception
-    if process.is_alive():
-        raise RuntimeError(f'Unable to terminate subprocess with PID {process.pid}')
+    try:
+        # mimic process.join() in an async way to not block
+        await wait_while(process.is_alive, timeout)
+
+        # If it's still alive
+        if process.is_alive():
+            try:
+                os.kill(process.pid, signal.SIGKILL)
+                await wait_while(process.is_alive, timeout)
+            except OSError as e:
+                raise RuntimeError(f'Unable to terminate subprocess with PID {process.pid}') from e
+
+        # If it's still alive raise an exception
+        if process.is_alive():
+            raise RuntimeError(f'Unable to terminate subprocess with PID {process.pid}')
+    except Exception as e:
+        dev_logger.error('Error stopping process', e)
 
 
 def stop_process(process: BaseProcess, timeout: float = 3):