def test_add_sidebar(self):
dashboard = self.cux_df.dashboard(charts=[], title="test_title")
dashboard1 = self.cux_df.dashboard(charts=[], title="test_title")
bac = bokeh.bar("key")
for _ in range(3):
bac = bokeh.bar("key")
bac.chart_type = "chart_" + str(_ + 1)
dashboard.add_charts(sidebar=[bac])
for _ in range(3):
dashboard1.add_charts(
sidebar=[panel_widgets.card(title=f"test{_}")]
)
assert len(dashboard._charts) == 0
assert len(dashboard._sidebar) == 1
assert list(dashboard._sidebar.keys()) == [self._datasize_title]
assert len(dashboard1._charts) == 0
assert len(dashboard1._sidebar) == 4
assert list(dashboard1._sidebar.keys()) == [
self._datasize_title,
"test0_card",
"test1_card",
"test2_card",
]
def test_add_charts(self):
dashboard = self.cux_df.dashboard(charts=[], title="test_title")
bac = bokeh.bar("key")
for _ in range(3):
bac = bokeh.bar("key")
bac.chart_type = "chart_" + str(_ + 1)
dashboard.add_charts(charts=[bac])
assert list(dashboard._charts.keys()) == [
f"key_count_chart_1_{bac.title}",
f"key_count_chart_2_{bac.title}",
f"key_count_chart_3_{bac.title}",
]
def test_add_charts(self):
bac = bokeh.bar("key")
bac.chart_type = "chart_1"
for _ in range(3):
bac = bokeh.bar("key")
bac.chart_type = "chart_" + str(_ + 1)
self.dashboard.add_charts([bac])
assert list(self.dashboard._charts.keys()) == [
"_datasize_indicator",
"key_chart_1",
"key_chart_2",
"key_chart_3",
]
def test_reset_current_view(self):
df = cudf.DataFrame({
"key": [0, 1, 2, 3, 4],
"val": [float(i + 10) for i in range(5)]
})
cux_df = cuxfilter.DataFrame.from_dataframe(df)
bac = bokeh.line("key", "val")
bac1 = bokeh.bar("val")
dashboard = cux_df.dashboard(
charts=[bac, bac1],
title="test_title",
layout=cuxfilter.layouts.double_feature,
)
dashboard._active_view = bac.name
dashboard._calc_data_tiles()
dashboard._query_datatiles_by_range(query_tuple=(1, 2))
bac.filter_widget.value = (1, 2)
# reset active view
dashboard._reset_current_view(new_active_view=bac1)
assert dashboard._active_view == bac1.name
assert dashboard._query_str_dict == {"key_line": "1<=key<=2"}
assert dashboard._charts[bac.name].datatile_loaded_state is False
assert bac1.name not in dashboard._query_str_dict
assert dashboard._data.equals(
df.query(dashboard._query_str_dict["key_line"]))
def test_reset_current_view(self):
df = cudf.DataFrame(
{"key": [0, 1, 2, 3, 4], "val": [float(i + 10) for i in range(5)]}
)
cux_df = cuxfilter.DataFrame.from_dataframe(df)
bac = bokeh.line("key", "val", aggregate_fn="mean")
bac1 = bokeh.bar("val")
dashboard = cux_df.dashboard(
charts=[bac, bac1],
title="test_title",
layout=cuxfilter.layouts.double_feature,
)
dashboard._active_view = bac
dashboard._calc_data_tiles()
dashboard._query_datatiles_by_range(query_tuple=(1, 2))
bac.filter_widget.value = (1, 2)
# reset active view
dashboard._reset_current_view(new_active_view=bac1)
assert dashboard._active_view == bac1
assert dashboard._query_str_dict == {
f"key_mean_line_{bac.title}": "@key_min <= key <= @key_max"
}
assert dashboard._query_local_variables_dict == {
"key_min": 1,
"key_max": 2,
}
assert dashboard._charts[bac.name].datatile_loaded_state is False
assert bac1.name not in dashboard._query_str_dict
def test_calc_data_tiles(self, active_view, passive_view, result):
df = cudf.DataFrame(
{"key": [0, 1, 2, 3, 4], "val": [float(i + 10) for i in range(5)]}
)
cux_df = cuxfilter.DataFrame.from_dataframe(df)
bac = bokeh.line("key", "val")
bac.use_data_tiles = False
bac1 = bokeh.bar("val")
dashboard = cux_df.dashboard(
charts=[bac, bac1],
title="test_title",
layout=cuxfilter.layouts.double_feature,
)
dashboard._active_view = active_view
dashboard._calc_data_tiles()
if result is None:
assert dashboard._data_tiles[passive_view] is result
else:
assert dashboard._data_tiles[passive_view].equals(result)
assert (
dashboard._charts[dashboard._active_view].datatile_loaded_state
is True
)
def test_export(self, active_view, result):
bac = bokeh.bar("key")
bac.chart_type = "chart_1"
self.dashboard.add_charts([bac])
self.dashboard._query_str_dict = {"key_chart_1": "0<=key<=3"}
self.dashboard._active_view = active_view
assert self.dashboard.export().to_string() == result
def test_export(self, active_view, result):
dashboard = self.cux_df.dashboard(charts=[], title="test_title")
bac = bokeh.bar("key")
bac.chart_type = "chart_1"
dashboard.add_charts([bac])
bac.filter_widget.value = (0, 3)
dashboard._active_view = active_view
assert dashboard.export().to_string() == result
def test_calc_data_tile(self, chart_type, result):
def f1(data):
return "1-d function"
def f2(data):
return "2-d function"
bac1 = bokeh.bar("val")
bac1.chart_type = chart_type
data_tile = DataTile(active_chart=self.bac, passive_chart=bac1)
data_tile._calc_1d_data_tile = f1
data_tile._calc_2d_data_tile = f2
assert data_tile.calc_data_tile(data=cudf.DataFrame()) == result
def test_query_datatiles_by_range(self, query_tuple, result):
df = cudf.DataFrame(
{"key": [0, 1, 2, 3, 4], "val": [float(i + 10) for i in range(5)]}
)
cux_df = cuxfilter.DataFrame.from_dataframe(df)
bac = bokeh.line("key", "val")
bac1 = bokeh.bar("val")
dashboard = cux_df.dashboard(
charts=[bac, bac1],
title="test_title",
layout=cuxfilter.layouts.double_feature,
)
dashboard._active_view = bac
dashboard._calc_data_tiles()
dashboard._query_datatiles_by_range(query_tuple=query_tuple)
assert all(bac1.source.data["top"] == result)
def test_query_datatiles_by_indices(self, old_indices, new_indices,
prev_result, result):
df = cudf.DataFrame({
"key": [0, 1, 2, 3, 4],
"val": [float(i + 10) for i in range(5)]
})
cux_df = cuxfilter.DataFrame.from_dataframe(df)
bac = bokeh.line("key", "val")
bac1 = bokeh.bar("val")
dashboard = cux_df.dashboard(
charts=[bac, bac1],
title="test_title",
layout=cuxfilter.layouts.double_feature,
)
dashboard._active_view = bac.name
dashboard._calc_data_tiles(cumsum=False)
bac1.source.data["top"] = np.array(prev_result)
dashboard._query_datatiles_by_indices(old_indices=old_indices,
new_indices=new_indices)
assert all(bac1.source.data["top"] == result)
class TestDataTile:
bac = bokeh.line("key", "val")
bac1 = bokeh.bar("val")
df = cudf.DataFrame({
"key": [0, 1, 2, 3, 4],
"val": [float(i + 10) for i in range(5)]
})
cux_df = cuxfilter.DataFrame.from_dataframe(df)
dashboard = cux_df.dashboard(
charts=[bac, bac1],
title="test_title",
layout=cuxfilter.layouts.double_feature,
)
def test_variables(self):
data_tile = DataTile(active_chart=self.bac, passive_chart=self.bac1)
assert data_tile.dtype == "pandas"
assert data_tile.cumsum is True
assert data_tile.active_chart == self.bac
assert data_tile.passive_chart == self.bac1
assert data_tile.dimensions == int(2)
@pytest.mark.parametrize(
"chart_type, result",
[("datasize_indicator", "1-d function"), ("bar", "2-d function")],
)
def test_calc_data_tile(self, chart_type, result):
def f1(data):
return "1-d function"
def f2(data):
return "2-d function"
bac1 = bokeh.bar("val")
bac1.chart_type = chart_type
data_tile = DataTile(active_chart=self.bac, passive_chart=bac1)
data_tile._calc_1d_data_tile = f1
data_tile._calc_2d_data_tile = f2
assert data_tile.calc_data_tile(data=cudf.DataFrame()) == result
def test_calc_1d_data_tile(self):
datasize_chart = cuxfilter.charts.panel_widgets.data_size_indicator()
data_tile = DataTile(active_chart=self.bac,
passive_chart=datasize_chart)
result = pd.DataFrame({0: {0: 1.0, 1: 2.0, 2: 3.0, 3: 4.0, 4: 5.0}})
assert data_tile._calc_1d_data_tile(self.df).equals(result)
def test_calc_2d_data_tile(self):
data_tile = DataTile(active_chart=self.bac, passive_chart=self.bac1)
result = pd.DataFrame({
0: {
0: 1.0,
1: 0.0,
2: 0.0,
3: 0.0,
4: 0.0
},
1: {
0: 1.0,
1: 1.0,
2: 0.0,
3: 0.0,
4: 0.0
},
2: {
0: 1.0,
1: 1.0,
2: 1.0,
3: 0.0,
4: 0.0
},
3: {
0: 1.0,
1: 1.0,
2: 1.0,
3: 1.0,
4: 0.0
},
4: {
0: 1.0,
1: 1.0,
2: 1.0,
3: 1.0,
4: 1.0
},
})
assert data_tile._calc_2d_data_tile(self.df).equals(result)
