Skip to main content

derived_data_variable

DerivedDataVariable

from dara.core.interactivity.derived_data_variable import DerivedDataVariable

class DerivedDataVariable(AnyDataVariable, DerivedVariable)

DerivedDataVariable represents a variable designed to hold datasets computed by a resolver function like a normal DerivedVariable.

Note: the resolver function must return a DataFrame.

Attributes

  • uid: str
  • filters: Optional[FilterQuery]
  • variables: List[AnyVariable]
  • polling_interval: Optional[int]
  • deps: Optional[List[AnyVariable]]

Methods

__init__

def __init__(func: Union[
Callable[..., Union[DataFrame, None]],
Callable[..., Coroutine[Any, Any, Union[DataFrame, None]]],
],
variables: List[AnyVariable],
cache: CacheArgType = Cache.Type.GLOBAL,
run_as_task: bool = False,
polling_interval: Optional[int] = None,
deps: Optional[List[AnyVariable]] = None,
uid: Optional[str] = None) -> None

DerivedDataVariable represents a variable designed to hold datasets computed

by a resolver function like a normal DerivedVariable.

Note: the resolver function must return a DataFrame.

Arguments:

  • func: the function to derive a new value from the input variables. Must return a DataFrame
  • variables: a set of input variables that will be passed to the deriving function
  • default: the initial value for the variable, defaults to None
  • cache: whether to cache the result, defaults to global caching. Other options are to cache per user session, or per user
  • run_as_task: whether to run the calculation in a separate process, recommended for any CPU intensive tasks, defaults to False
  • polling_interval: an optional polling interval for the DerivedVariable. Setting this will cause the component to poll the backend and refresh itself every n seconds.
  • deps: an optional array of variables, specifying which dependant variables changing should trigger a recalculation of the derived variable
  • deps = None - func is ran everytime (default behaviour),
  • deps = [] - func is ran once on initial startup,
  • deps = [var1, var2] - func is ran whenever one of these vars changes
  • uid: the unique identifier for this variable; if not provided a random one is generated

get_value

@classmethod
async def get_value(cls,
var_entry: DerivedVariableRegistryEntry,
store: CacheStore,
task_mgr: TaskManager,
args: List[Any],
force: bool = False) -> DerivedVariableResult

Update the underlying derived variable.

Wrapper around DerivedVariable.get_value which does not return the value (returns True instead).

Arguments:

  • var: the registry entry for the underlying derived variable
  • store: the store instance to check for cached values
  • task_mgr: task manager instance
  • args: the arguments to call the underlying function with
  • force: whether to ignore cache

get_data

@classmethod
async def get_data(
cls,
dv_entry: DerivedVariableRegistryEntry,
data_entry: DataVariableRegistryEntry,
cache_key: str,
store: CacheStore,
filters: Optional[Union[FilterQuery, dict]] = None,
pagination: Optional[Pagination] = None,
format_for_display: bool = False) -> Union[BaseTask, DataFrame, None]

Get the filtered data from the underlying derived variable stored under the specified cache_key.

Arguments:

  • var_entry: the registry entry for the data variable
  • cache_key: cache_key of the underlying DerivedVariable
  • store: the store instance to check for cached values
  • filters: the filters to apply to the data
  • pagination: the pagination to apply to the data

get_total_count

@classmethod
async def get_total_count(cls, data_entry: DataVariableRegistryEntry,
store: CacheStore, cache_key: str,
filters: Optional[FilterQuery])

Get total count of the derived data variable.

get_schema

@classmethod
async def get_schema(cls, derived_entry: DerivedVariableRegistryEntry,
store: CacheStore, cache_key: str)

Get the schema of the derived data variable.

resolve_value

@classmethod
async def resolve_value(cls,
data_entry: DataVariableRegistryEntry,
dv_entry: DerivedVariableRegistryEntry,
store: CacheStore,
task_mgr: TaskManager,
args: List[Any],
force: bool,
filters: Optional[Union[FilterQuery, dict]] = None)

Helper method to resolve the filtered value of a derived data variable.

Under the hood runs the underlying DerivedVariable, starts its task if required, and then filters the result.

Arguments:

  • data_entry: the registry entry for the data variable
  • dv_entry: the registry entry for the underlying derived variable
  • store: the store instance to check for cached values
  • task_mgr: task manager instance
  • args: the arguments to call the underlying function with
  • force: whether to ignore cache
  • filters: the filters to apply to the data
  • pagination: the pagination to apply to the data