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_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]').astype(np.int64) / 10e5
    }
    for col, values in model.source.data.items():
        np.testing.assert_array_equal(values, expected[col])
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]').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_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_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,
        'dataTree': False
    }
    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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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(document, comm):
    df = makeMixedDataFrame()
    table = Tabulator(df)

    model = table.get_root(document, comm)

    table.add_filter('foo3', '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])