def test_add_events(self, df_type, add_interaction, reset_event, event_1,
event_2):
bnac = BaseNonAggregate()
bnac.add_interaction = add_interaction
bnac.reset_event = reset_event
bnac.chart = hv.InteractiveDatashader()
df = initialize_df(df_type, {"a": [1, 2, 2], "b": [3, 4, 5]})
dashboard = DashBoard(dataframe=DataFrame.from_dataframe(df))
self.event_1 = None
self.event_2 = None
def t_func(fn):
self.event_1 = fn.__name__
def t_func1(fn):
self.event_2 = fn.__name__
bnac.chart.add_box_select_callback = t_func
bnac.chart.add_lasso_select_callback = t_func1
bnac.add_events(dashboard)
assert self.event_1 == event_1
assert self.event_2 == event_2
def test_calculate_source(self, dashboard):
bsl = BaseStackedLine(x="key", y=["val"])
bsl.chart = hv.InteractiveDatashader()
bsl.initiate_chart(dashboard)
self.result = None
def func1(data):
self.result = data
bsl.format_source_data = func1
bsl.calculate_source(dashboard._cuxfilter_df.data)
assert df_equals(self.result, dashboard._cuxfilter_df.data)
def test_initiate_chart(self, dashboard):
bsl = BaseStackedLine(x="key", y=["val"])
bsl.chart = hv.InteractiveDatashader()
bsl.initiate_chart(dashboard)
if isinstance(dashboard._cuxfilter_df.data, dask_cudf.DataFrame):
# incase base dataframe is a dask.dataframe
bsl.x_range = dd.compute(*bsl.x_range)
bsl.y_range = dd.compute(*bsl.y_range)
assert bsl.x_range == (0, 4)
assert bsl.y_range == (10, 14)
def test_add_reset_event(self, dashboard):
bl = BaseLine(x="key", y="val")
bl.chart = hv.InteractiveDatashader()
self.result = None
def test_func(event, callback):
self.result = callback
bl.add_event = test_func
# test the following function behavior
bl.add_reset_event(dashboard)
assert bl.selected_indices is None
def test_add_events(self, dashboard, event, result):
bl = BaseLine(x="key", y="val")
bl.chart = hv.InteractiveDatashader()
self.result = None
def test_func(cls):
self.result = "func_Called"
bl.add_reset_event = test_func
bl.reset_event = event
# test the following function behavior
bl.add_events(dashboard)
assert self.result == result
def test_add_events(self, df_type, add_interaction, reset_event, event_1):
bsl = BaseStackedLine("a", ["b"])
bsl.chart = hv.InteractiveDatashader()
bsl.add_interaction = add_interaction
bsl.reset_event = reset_event
df = initialize_df(df_type, {"a": [1, 2, 2], "b": [3, 4, 5]})
dashboard = cuxfilter.dashboard.DashBoard(
dataframe=cuxfilter.DataFrame.from_dataframe(df))
self.event_1 = None
self.event_2 = None
def t_func(fn):
self.event_1 = fn.__name__
bsl.chart.add_box_select_callback = t_func
bsl.add_events(dashboard)
assert self.event_1 == event_1
def test_add_reset_event(self, df_type):
bnac = BaseNonAggregate()
bnac.chart_type = "test"
bnac.x = "a"
bnac.x_range = (0, 2)
bnac.y_range = (3, 5)
bnac.chart = hv.InteractiveDatashader()
df = initialize_df(df_type, {"a": [1, 2, 2], "b": [3, 4, 5]})
dashboard = DashBoard(dataframe=DataFrame.from_dataframe(df))
dashboard._active_view = bnac
def t_func1(event, fn):
fn("event")
bnac.add_event = t_func1
bnac.add_reset_event(dashboard)
assert bnac.selected_indices is None
def test_add_reset_event(self, df_type):
bsl = BaseStackedLine("a", ["b"])
bsl.chart_type = "stacked_lines"
bsl.chart = hv.InteractiveDatashader()
bsl.x_range = (0, 2)
bsl.y_range = (3, 5)
df = initialize_df(df_type, {"a": [1, 2, 2], "b": [3, 4, 5]})
dashboard = cuxfilter.dashboard.DashBoard(
dataframe=cuxfilter.DataFrame.from_dataframe(df))
dashboard._active_view = bsl
def t_func1(event, fn):
fn("event")
bsl.add_event = t_func1
bsl.add_reset_event(dashboard)
assert (f"x_{'_'.join(['y'])}_stacked_lines_{bsl.title}"
not in dashboard._query_str_dict)
def test_compute_query_dict(self, dashboard, x_range, y_range, query,
local_dict):
bl = BaseLine(x="x", y="y", title="custom_title")
bl.chart_type = "non_aggregate_line"
bl.box_selected_range = local_dict
bl.chart = hv.InteractiveDatashader()
bl.x_range = x_range
bl.y_range = y_range
dashboard.add_charts([bl])
# test the following function behavior
bl.compute_query_dict(
dashboard._query_str_dict,
dashboard._query_local_variables_dict,
)
assert (
dashboard._query_str_dict["x_y_non_aggregate_line_custom_title"] ==
query)
for key in local_dict:
assert (
dashboard._query_local_variables_dict[key] == local_dict[key])
def test_add_reset_event(self, df_type):
bg = BaseGraph()
bg.edges = None
bg.chart_type = "test"
bg.x = "a"
bg.x_range = (0, 2)
bg.y_range = (3, 5)
bg.chart = hv.InteractiveDatashader()
df = initialize_df(df_type, {"a": [1, 2, 2], "b": [3, 4, 5]})
dashboard = DashBoard(dataframe=DataFrame.from_dataframe(df))
dashboard._active_view = bg
def t_func1(event, fn):
fn("event")
def reload_fn(data, edges=None, patch_update=False):
pass
bg.add_event = t_func1
bg.reload_chart = reload_fn
bg.add_reset_event(dashboard)
assert bg.selected_indices is None