def test_tabulator_patch_event():
df = makeMixedDataFrame()
table = Tabulator(df)
values = []
table.on_edit(lambda e: values.append((e.column, e.row, e.value)))
for col in df.columns:
for row in range(len(df)):
event = TableEditEvent(model=None, column=col, row=row)
table._process_event(event)
assert values[-1] == (col, row, df[col].iloc[row])
def test_tabulator_empty_table(document, comm):
value_df = makeMixedDataFrame()
empty_df = pd.DataFrame([], columns=value_df.columns)
table = Tabulator(empty_df)
table.get_root(document, comm)
assert table.value.shape == empty_df.shape
table.stream(value_df, follow=True)
assert table.value.shape == value_df.shape
def test_tabulator_download_menu_default():
df = makeMixedDataFrame()
table = Tabulator(df)
filename, button = table.download_menu()
assert isinstance(filename, TextInput)
assert isinstance(button, Button)
assert filename.value == 'table.csv'
assert filename.name == 'Filename'
assert button.name == 'Download'
def test_tabulator_pagination_selection(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df, pagination='remote', page_size=2)
model = table.get_root(document, comm)
table.selection = [2, 3]
assert model.source.selected.indices == []
table.page = 2
assert model.source.selected.indices == [0, 1]
def test_tabulator_config_editor_dict(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df, editors={'B': {'type': 'select', 'values': True}})
model = table.get_root(document, comm)
assert model.configuration['columns'][2] == {
'field': 'B',
'editor': 'select',
'editorParams': {
'values': True
}
}
def test_tabulator_index_column(document, comm):
df = pd.DataFrame(
{
'int': [1, 2, 3],
'float': [3.14, 6.28, 9.42],
'index': ['A', 'B', 'C'],
},
index=[1, 2, 3])
table = Tabulator(value=df)
model = table.get_root(document, comm=comm)
assert np.array_equal(model.source.data['level_0'], np.array([1, 2, 3]))
assert model.columns[0].field == 'level_0'
assert model.columns[0].title == ''
def test_tabulator_pagination_selectable_rows(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df,
pagination='remote',
page_size=3,
selectable_rows=lambda df: list(df.index.values[::2]))
model = table.get_root(document, comm)
print(table._processed)
assert model.selectable_rows == [0, 2]
table.page = 2
assert model.selectable_rows == [3]
def test_tabulator_expanded_content_pagination():
df = makeMixedDataFrame()
table = Tabulator(df,
expanded=[0, 1],
row_content=lambda r: r.A,
pagination='remote',
page_size=2)
model = table.get_root()
assert len(model.children) == 2
table.page = 2
assert len(model.children) == 0
def test_tabulator_config_formatter_dict(document, comm):
df = makeMixedDataFrame()
table = Tabulator(
df, formatters={'B': {
'type': 'tickCross',
'tristate': True
}})
model = table.get_root(document, comm)
assert model.configuration['columns'][2] == {
'field': 'B',
'formatter': 'tickCross',
'formatterParams': {
'tristate': True
}
}
def test_tabulator_function_filter(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df)
model = table.get_root(document, comm)
widget = TextInput(value='foo3')
def filter_c(df, value):
return df[df.C.str.contains(value)]
table.add_filter(bind(filter_c, value=widget), 'C')
expected = {
'index':
np.array([2]),
'A':
np.array([2]),
'B':
np.array([0]),
'C':
np.array(['foo3']),
'D':
np.array(['2009-01-05T00:00:00.000000000'],
dtype='datetime64[ns]').astype(np.int64) / 10e5
}
for col, values in model.source.data.items():
np.testing.assert_array_equal(values, expected[col])
widget.value = 'foo1'
expected = {
'index':
np.array([0]),
'A':
np.array([0]),
'B':
np.array([0]),
'C':
np.array(['foo1']),
'D':
np.array(['2009-01-01T00:00:00.000000000'],
dtype='datetime64[ns]').astype(np.int64) / 10e5
}
for col, values in model.source.data.items():
np.testing.assert_array_equal(values, expected[col])
def test_tabulator_selected_and_filtered_dataframe(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df, selection=list(range(len(df))))
pd.testing.assert_frame_equal(table.selected_dataframe, df)
table.add_filter('foo3', 'C')
pd.testing.assert_frame_equal(table.selected_dataframe,
df[df["C"] == "foo3"])
table.remove_filter('foo3')
table.selection = [0, 1, 2]
table.add_filter('foo3', 'C')
assert table.selection == [0]
def test_tabulator_frozen_cols(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df, frozen_columns=['index'])
model = table.get_root(document, comm)
assert model.configuration['columns'] == [{
'field': 'index',
'frozen': True
}, {
'field': 'A'
}, {
'field': 'B'
}, {
'field': 'C'
}, {
'field': 'D'
}]
def test_tabulator_config_defaults(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df)
model = table.get_root(document, comm)
assert model.configuration['columns'] == [{
'field': 'index'
}, {
'field': 'A'
}, {
'field': 'B'
}, {
'field': 'C'
}, {
'field': 'D'
}]
assert model.configuration['selectable'] == True
def test_tabulator_download_menu_custom_kwargs():
df = makeMixedDataFrame()
table = Tabulator(df)
filename, button = table.download_menu(
text_kwargs={
'name': 'Enter filename',
'value': 'file.csv'
},
button_kwargs={'name': 'Download table'},
)
assert isinstance(filename, TextInput)
assert isinstance(button, Button)
assert filename.value == 'file.csv'
assert filename.name == 'Enter filename'
assert button.name == 'Download table'
def test_tabulator_numeric_groups(document, comm):
df = pd.DataFrame(np.random.rand(10, 3))
table = Tabulator(df, groups={'Number': [0, 1]})
model = table.get_root(document, comm)
assert model.configuration['columns'] == [{
'field': 'index'
}, {
'title':
'Number',
'columns': [{
'field': '0'
}, {
'field': '1'
}]
}, {
'field': '2'
}]
def test_tabulator_expanded_content_embed():
df = makeMixedDataFrame()
table = Tabulator(df, embed_content=True, row_content=lambda r: r.A)
model = table.get_root()
assert len(model.children) == len(df)
for i, r in df.iterrows():
assert i in model.children
row = model.children[i]
assert row.text == f"<pre>{r.A}</pre>"
table.row_content = lambda r: r.A + 1
for i, r in df.iterrows():
assert i in model.children
row = model.children[i]
assert row.text == f"<pre>{r.A+1}</pre>"
def test_tabulator_multi_index(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df.set_index(['A', 'C']))
model = table.get_root()
assert model.configuration['columns'] == [{
'field': 'A'
}, {
'field': 'C'
}, {
'field': 'B'
}, {
'field': 'D'
}]
assert np.array_equal(model.source.data['A'],
np.array([0., 1., 2., 3., 4.]))
assert np.array_equal(model.source.data['C'],
np.array(['foo1', 'foo2', 'foo3', 'foo4', 'foo5']))
def test_tabulator_header_filters_column_config_select(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df, header_filters={'C': 'select'})
model = table.get_root(document, comm)
assert model.configuration['columns'] == [{
'field': 'index'
}, {
'field': 'A'
}, {
'field': 'B'
}, {
'field': 'C',
'headerFilter': 'select',
'headerFilterParams': {
'values': True
}
}, {
'field': 'D'
}]
assert model.configuration['selectable'] == True
def test_tabulator_header_filters_config_boolean(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df, header_filters=True)
model = table.get_root(document, comm)
assert model.configuration['columns'] == [{
'field': 'index',
'headerFilter': 'number'
}, {
'field': 'A',
'headerFilter': True
}, {
'field': 'B',
'headerFilter': True
}, {
'field': 'C',
'headerFilter': True
}, {
'field': 'D',
'headerFilter': True
}]
def test_tabulator_stream_dataframe_selectable_rows(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df,
selectable_rows=lambda df: list(range(0, len(df), 2)))
model = table.get_root(document, comm)
assert model.selectable_rows == [0, 2, 4]
stream_value = pd.DataFrame({
'A': [5, 6],
'B': [1, 0],
'C': ['foo6', 'foo7'],
'D': [dt.datetime(2009, 1, 8),
dt.datetime(2009, 1, 9)]
})
table.stream(stream_value)
print(len(table._processed))
assert model.selectable_rows == [0, 2, 4, 6]
def test_tabulator_stream_dataframe(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df)
model = table.get_root(document, comm)
stream_value = pd.DataFrame({
'A': [5, 6],
'B': [1, 0],
'C': ['foo6', 'foo7'],
'D': [dt.datetime(2009, 1, 8),
dt.datetime(2009, 1, 9)]
})
table.stream(stream_value)
assert len(table.value) == 7
expected = {
'index':
np.array([0, 1, 2, 3, 4, 5, 6]),
'A':
np.array([0, 1, 2, 3, 4, 5, 6]),
'B':
np.array([0, 1, 0, 1, 0, 1, 0]),
'C':
np.array(['foo1', 'foo2', 'foo3', 'foo4', 'foo5', 'foo6', 'foo7']),
'D':
np.array([
'2009-01-01T00:00:00.000000000', '2009-01-02T00:00:00.000000000',
'2009-01-05T00:00:00.000000000', '2009-01-06T00:00:00.000000000',
'2009-01-07T00:00:00.000000000', '2009-01-08T00:00:00.000000000',
'2009-01-09T00:00:00.000000000'
],
dtype='datetime64[ns]').astype(np.int64) / 10e5
}
for col, values in model.source.data.items():
np.testing.assert_array_equal(values, expected[col])
def test_tabulator_constant_scalar_filter_on_index_client_side(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df)
model = table.get_root(document, comm)
table.filters = [{'field': 'index', 'type': '=', 'value': 2}]
expected = {
'index':
np.array([2]),
'A':
np.array([2]),
'B':
np.array([0]),
'C':
np.array(['foo3']),
'D':
np.array(['2009-01-05T00:00:00.000000000'],
dtype='datetime64[ns]').astype(np.int64) / 10e5
}
for col, values in model.source.data.items():
np.testing.assert_array_equal(values, expected[col])
def test_tabulator_stream_df_rollover(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df)
model = table.get_root(document, comm)
stream_value = pd.Series({
'A': 5,
'B': 1,
'C': 'foo6',
'D': dt.datetime(2009, 1, 8)
}).to_frame().T
table.stream(stream_value, rollover=5)
assert len(table.value) == 5
expected = {
'index':
np.array([1, 2, 3, 4, 5]),
'A':
np.array([1, 2, 3, 4, 5]),
'B':
np.array([1, 0, 1, 0, 1]),
'C':
np.array(['foo2', 'foo3', 'foo4', 'foo5', 'foo6']),
'D':
np.array([
'2009-01-02T00:00:00.000000000', '2009-01-05T00:00:00.000000000',
'2009-01-06T00:00:00.000000000', '2009-01-07T00:00:00.000000000',
'2009-01-08T00:00:00.000000000'
],
dtype='datetime64[ns]').astype(np.int64) / 10e5
}
for col, values in model.source.data.items():
np.testing.assert_array_equal(values, expected[col])
def test_tabulator_constant_tuple_filter(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df)
model = table.get_root(document, comm)
table.add_filter((2, 3), 'A')
expected = {
'index':
np.array([2, 3]),
'A':
np.array([2, 3]),
'B':
np.array([0, 1]),
'C':
np.array(['foo3', 'foo4']),
'D':
np.array(
['2009-01-05T00:00:00.000000000', '2009-01-06T00:00:00.000000000'],
dtype='datetime64[ns]').astype(np.int64) / 10e5
}
for col, values in model.source.data.items():
np.testing.assert_array_equal(values, expected[col])
def test_tabulator_header_filters_column_config_dict(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df,
header_filters={
'C': {
'type': 'select',
'values': True,
'func': '!=',
'placeholder': 'Not equal'
}
})
model = table.get_root(document, comm)
assert model.configuration['columns'] == [{
'field': 'index'
}, {
'field': 'A'
}, {
'field': 'B'
}, {
'field':
'C',
'headerFilter':
'select',
'headerFilterParams': {
'values': True
},
'headerFilterFunc':
'!=',
'headerFilterPlaceholder':
'Not equal'
}, {
'field': 'D'
}]
assert model.configuration['selectable'] == True
def test_tabulator_selected_dataframe():
df = makeMixedDataFrame()
table = Tabulator(df, selection=[0, 2])
pd.testing.assert_frame_equal(table.selected_dataframe, df.iloc[[0, 2]])
def test_tabulator_pagination(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df, pagination='remote', page_size=2)
model = table.get_root(document, comm)
assert model.max_page == 3
assert model.page_size == 2
assert model.page == 1
expected = {
'index':
np.array([0, 1]),
'A':
np.array([0, 1]),
'B':
np.array([0, 1]),
'C':
np.array(['foo1', 'foo2']),
'D':
np.array(
['2009-01-01T00:00:00.000000000', '2009-01-02T00:00:00.000000000'],
dtype='datetime64[ns]').astype(np.int64) / 10e5
}
for col, values in model.source.data.items():
np.testing.assert_array_equal(values, expected[col])
table.page = 2
expected = {
'index':
np.array([2, 3]),
'A':
np.array([2, 3]),
'B':
np.array([0., 1.]),
'C':
np.array(['foo3', 'foo4']),
'D':
np.array(
['2009-01-05T00:00:00.000000000', '2009-01-06T00:00:00.000000000'],
dtype='datetime64[ns]').astype(np.int64) / 10e5
}
for col, values in model.source.data.items():
np.testing.assert_array_equal(values, expected[col])
table.page_size = 3
table.page = 1
assert model.max_page == 2
expected = {
'index':
np.array([0, 1, 2]),
'A':
np.array([0, 1, 2]),
'B':
np.array([0, 1, 0]),
'C':
np.array(['foo1', 'foo2', 'foo3']),
'D':
np.array([
'2009-01-01T00:00:00.000000000', '2009-01-02T00:00:00.000000000',
'2009-01-05T00:00:00.000000000'
],
dtype='datetime64[ns]').astype(np.int64) / 10e5
}
for col, values in model.source.data.items():
np.testing.assert_array_equal(values, expected[col])