def test_isna_isnull(self, isna_f):
assert not isna_f(1.0)
assert isna_f(None)
assert isna_f(np.NaN)
assert float("nan")
assert not isna_f(np.inf)
assert not isna_f(-np.inf)
# type
assert not isna_f(type(pd.Series(dtype=object)))
assert not isna_f(type(pd.Series(dtype=np.float64)))
assert not isna_f(type(pd.DataFrame()))
# series
for s in [
tm.makeFloatSeries(),
tm.makeStringSeries(),
tm.makeObjectSeries(),
tm.makeTimeSeries(),
tm.makePeriodSeries(),
]:
assert isinstance(isna_f(s), Series)
# frame
for df in [
tm.makeTimeDataFrame(),
tm.makePeriodFrame(),
tm.makeMixedDataFrame(),
]:
result = isna_f(df)
expected = df.apply(isna_f)
tm.assert_frame_equal(result, expected)
def test_tabulator_constant_scalar_filter_on_multi_index_client_side(
document, comm):
df = makeMixedDataFrame()
table = Tabulator(df.set_index(['A', 'C']))
model = table.get_root(document, comm)
table.filters = [{
'field': 'A',
'type': '=',
'value': 2
}, {
'field': 'C',
'type': '=',
'value': 'foo3'
}]
expected = {
'index':
np.array([0]),
'A':
np.array([2]),
'C':
np.array(['foo3']),
'B':
np.array([0]),
'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_expanded_content():
df = makeMixedDataFrame()
table = Tabulator(df, expanded=[0, 1], row_content=lambda r: r.A)
model = table.get_root()
assert len(model.children) == 2
assert 0 in model.children
row0 = model.children[0]
assert row0.text == "<pre>0.0</pre>"
assert 1 in model.children
row1 = model.children[1]
assert row1.text == "<pre>1.0</pre>"
table.expanded = [1, 2]
assert 0 not in model.children
assert 1 in model.children
assert row1 is model.children[1]
assert 2 in model.children
row2 = model.children[2]
assert row2.text == "<pre>2.0</pre>"
def test_tabulator_patch_ranges(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df)
model = table.get_root(document, comm)
table.patch({
'A': [(slice(0, 5), [5, 4, 3, 2, 1])],
'C': [(slice(0, 3), ['foo3', 'foo2', 'foo1'])]
})
expected = {
'index':
np.array([0, 1, 2, 3, 4]),
'A':
np.array([5, 4, 3, 2, 1]),
'B':
np.array([0, 1, 0, 1, 0]),
'C':
np.array(['foo3', 'foo2', 'foo1', 'foo4', 'foo5']),
'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'
],
dtype='datetime64[ns]')
}
for col, values in model.source.data.items():
np.testing.assert_array_equal(values, expected[col])
def test_tabulator_config_editor_string(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df, editors={'B': 'select'})
model = table.get_root(document, comm)
assert model.configuration['columns'][2] == {'field': 'B', 'editor': 'select'}
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_paginated_sorted_selection(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df, pagination='remote', page_size=2)
table.sorters = [{'field': 'A', 'dir': 'dec'}]
model = table.get_root(document, comm)
table.selection = [3]
assert model.source.selected.indices == [1]
table.selection = [0, 1]
assert model.source.selected.indices == []
table.selection = [3, 4]
assert model.source.selected.indices == [1, 0]
table.selection = []
assert model.source.selected.indices == []
table._process_events({'indices': [0, 1]})
assert table.selection == [4, 3]
table._process_events({'indices': [1]})
assert table.selection == [3]
table.sorters = [{'field': 'A', 'dir': 'asc'}]
table._process_events({'indices': [1]})
assert table.selection == [1]
def test_tabulator_widget_scalar_filter(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df)
model = table.get_root(document, comm)
widget = TextInput(value='foo3')
table.add_filter(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]')
}
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]')
}
for col, values in model.source.data.items():
np.testing.assert_array_equal(values, expected[col])
def test_tabulator_config_formatter_string(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df, formatters={'B': 'tickCross'})
model = table.get_root(document, comm)
assert model.configuration['columns'][2] == {'field': 'B', 'formatter': 'tickCross'}
def test_tabulator_stream_series_paginated_follow(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df, pagination='remote', page_size=2)
model = table.get_root(document, comm)
stream_value = pd.Series({
'A': 5,
'B': 1,
'C': 'foo6',
'D': dt.datetime(2009, 1, 8)
})
table.stream(stream_value, follow=True)
assert table.page == 3
assert len(table.value) == 6
expected = {
'index':
np.array([4, 5]),
'A':
np.array([4, 5]),
'B':
np.array([0, 1]),
'C':
np.array(['foo5', 'foo6']),
'D':
np.array(
['2009-01-07T00:00:00.000000000', '2009-01-08T00:00:00.000000000'],
dtype='datetime64[ns]')
}
for col, values in model.source.data.items():
np.testing.assert_array_equal(values, expected[col])
def test_tabulator_stream_series(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)})
table.stream(stream_value)
assert len(table.value) == 6
expected = {
'index': np.array([0, 1, 2, 3, 4, 5]),
'A': np.array([0, 1, 2, 3, 4, 5]),
'B': np.array([0, 1, 0, 1, 0, 1]),
'C': np.array(['foo1', 'foo2', 'foo3', 'foo4', 'foo5', 'foo6']),
'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'],
dtype='datetime64[ns]')
}
for col, values in model.source.data.items():
np.testing.assert_array_equal(values, expected[col])
def test_tabulator_styling(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df)
def high_red(value):
return 'color: red' if value > 2 else 'color: black'
table.style.applymap(high_red, subset=['A'])
model = table.get_root(document, comm)
assert model.styles == {
0: {
1: ['color: black']
},
1: {
1: ['color: black']
},
2: {
1: ['color: black']
},
3: {
1: ['color: red']
},
4: {
1: ['color: red']
}
}
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_groups(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df, groups={'Number': ['A', 'B'], 'Other': ['C', 'D']})
model = table.get_root(document, comm)
assert model.configuration['columns'] == [{
'field': 'index'
}, {
'title':
'Number',
'columns': [{
'field': 'A'
}, {
'field': 'B'
}]
}, {
'title':
'Other',
'columns': [{
'field': 'C'
}, {
'field': 'D'
}]
}]
def test_tabulator_dataframe_replace_data(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df)
model = table.get_root(document, comm)
table.value = makeCustomDataframe(2, 2)
assert len(model.columns) == 3
c1, c2, c3 = model.columns
assert c1.field == 'R0'
assert c2.field == 'C_l0_g0'
assert c3.field == 'C_l0_g1'
assert model.configuration == {
'columns': [{
'field': 'R0'
}, {
'field': 'C_l0_g0'
}, {
'field': 'C_l0_g1'
}],
'selectable': True
}
expected = {
'C_l0_g0': np.array(['R0C0', 'R1C0'], dtype=object),
'C_l0_g1': np.array(['R0C1', 'R1C1'], dtype=object),
'R0': np.array(['R_l0_g0', 'R_l0_g1'], dtype=object)
}
for col, values in model.source.data.items():
np.testing.assert_array_equal(values, expected[col])
def test_tabulator_patch_scalars(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df)
model = table.get_root(document, comm)
table.patch({'A': [(0, 2), (4, 1)], 'C': [(0, 'foo0')]})
expected = {
'index':
np.array([0, 1, 2, 3, 4]),
'A':
np.array([2, 1, 2, 3, 1]),
'B':
np.array([0, 1, 0, 1, 0]),
'C':
np.array(['foo0', 'foo2', 'foo3', 'foo4', 'foo5']),
'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'
],
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_selectable_rows(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df, selectable_rows=lambda df: list(df[df.A>2].index.values))
model = table.get_root(document, comm)
assert model.selectable_rows == [3, 4]
def test_tabulator_frozen_rows(document, comm):
df = makeMixedDataFrame()
table = Tabulator(df, frozen_rows=[0, -1])
model = table.get_root(document, comm)
assert model.frozen_rows == [0, 4]
table.frozen_rows = [1, -2]
assert model.frozen_rows == [1, 3]
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_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]')
}
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]')
}
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]')
}
for col, values in model.source.data.items():
np.testing.assert_array_equal(values, expected[col])
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_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_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_to_hdf_with_min_itemsize(setup_path):
with ensure_clean_path(setup_path) as path:
# min_itemsize in index with to_hdf (GH 10381)
df = tm.makeMixedDataFrame().set_index("C")
df.to_hdf(path, "ss3", format="table", min_itemsize={"index": 6})
# just make sure there is a longer string:
df2 = df.copy().reset_index().assign(C="longer").set_index("C")
df2.to_hdf(path, "ss3", append=True, format="table")
tm.assert_frame_equal(pd.read_hdf(path, "ss3"), pd.concat([df, df2]))
# same as above, with a Series
df["B"].to_hdf(path, "ss4", format="table", min_itemsize={"index": 6})
df2["B"].to_hdf(path, "ss4", append=True, format="table")
tm.assert_series_equal(pd.read_hdf(path, "ss4"), pd.concat([df["B"], df2["B"]]))
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_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]
