textual-fastdatatable

A performance-focused reimplementation of Textual's DataTable widget, with a pluggable data storage backend.

Textual's built-in DataTable widget is beautiful and powerful, but it can be slow to load large datasets.

Here are some benchmarks on my relatively weak laptop. For each benchmark, we initialize a Textual App that loads a dataset from a parquet file and mounts a data table; it then scrolls around the table (10 pagedowns and 15 right arrows).

For the built-in table and the others marked "from Records", the data is loaded into memory before the timer is started; for the "Arrow from Parquet" back-end, the timer is started immediately.

The times in each column represent the time to the first paint of the table, and the time after scrolling is completed (we wait until the table is fully rendered after each scroll):

NB: FastDataTable currently does not support rows with a height of more than one line. See below for more limitations, relative to the built-in DataTable.

Installation

pip install textual-fastdatatable

Usage

If you already have data in Apache Arrow or another common table format:

from textual_fastdatatable import DataTable
data_table = DataTable(data = my_data)

The currently supported types are:

AutoBackendType = Union[
    pa.Table,
    pa.RecordBatch,
    Path, # to parquet only
    str, # path to parquet only
    Sequence[Iterable[Any]],
    Mapping[str, Sequence[Any]],
]

To override the column labels and widths supplied by the backend:

from textual_fastdatatable import DataTable
data_table = DataTable(data = my_data, column_labels=["Supports", "[red]Console[/]", "Markup!"], column_widths=[10, 5, None])

You can also pass in a backend manually (if you want more control or want to plug in your own).

from textual_fastdatatable import ArrowBackend, DataTable, create_backend
backend = create_backend(my_data)
backend = ArrowBackend(my_arrow_table)
# from python dictionary in the form key: col_values
backend = ArrowBackend.from_pydict(
    {
        "col one": [1, 2, 3 ,4],
        "col two": ["a", "b", "c", "d"],
    }
)
# from a list of tuples or another sequence of iterables
backend = ArrowBackend.from_records(
    [
        ("col one", "col two"),
        (1, "a"),
        (2, "b"),
        (3, "c"),
        (4, "d"),
    ]
)
# from a path to a Parquet file:
backend = ArrowBackend.from_parquet("path/to/file.parquet")

Limitations and Caveats

The DataTable does not currently support rows with a height of more than one line. Only the first line of each row will be displayed.

The DataTable does not currently support row labels.

The ArrowBackend is optimized to be fast for large, immutable datasets. Mutating the data, especially adding or removing rows, may be slow.

The ArrowBackend cannot be initialized without data, however, the DataTable can (either with or without column_labels).

The ArrowBackend cannot store arbitrary Python objects or Rich Renderables as values. It may widen types to strings unnecessarily.

Additional Features

Copying Data from the Table

ctrl+c will post a SelectionCopied message with a list of tuples of the values selected by the cursor. To use, initialize with cursor_type=range from an app that does NOT inherit bindings.

from textual.app import App, ComposeResult

from textual_fastdatatable import ArrowBackend, DataTable

class TableApp(App, inherit_bindings=False):
    BINDINGS = [("ctrl+q", "quit", "Quit")]

    def compose(self) -> ComposeResult:
        backend = ArrowBackend.from_parquet("./tests/data/lap_times_538121.parquet")
        yield DataTable(backend=backend, cursor_type="range")

if __name__ == "__main__":
    app = TableApp()
    app.run()

Truncating long values

The DataTable will automatically calculate column widths; if you set a max_column_content_width at initialization, it will truncate any long values at that width; the full value will be visible on hover in a tooltip (and the full value will always be copied to the clipboard).