Understanding show_row_labels of a DataTable

[need47]

I'm trying to understand how the attr show_row_labels works in a DataTable. I have a simple App for viewing a Polars dataframe. As a dataframe could be large, I do lazy loading (100 rows initially and 50 rows later in batch). When building the table, I always include a row label (i.e., 1-indexing row id) via the function _setup_table().

By default, I want to hide the row labels. So I have the following in on_mount():

self.call_later(lambda: setattr(self.table, "show_row_labels", False))

More information can be found below why I chose call_later().

When row labels are requested, I just press the key t to toggle it with the function action_toggle_row_labels():

def action_toggle_row_labels(self):
    self.table.show_row_labels = not self.table.show_row_labels

So far so good. I was able to load the table and see the row labels with the key t.

Then I added a key binding r to restore to its initial state (e.g., after some manipulations like dropping a column):

def on_key(self, event):
    if event.key == "r":
        # Restore original display
        self._setup_table()
        # Hide labels by default after initial load
        self.call_later(lambda: setattr(self.table, "show_row_labels", False))

This is basically the same as what's in on_mount(). So after restoring to initial state with the key r, I pressed t and I got:

The row labels seem to be empty.

However, as I kept on going down (either via the Down key, PageDown key, or mouse scroll), the row labels show up (even for those before the 100th row) when the table went past the 100 rows:

I had a similar observation before with the following on_mount() function:

def on_mount(self) -> None:
    self._setup_table()
    # self.call_later(lambda: setattr(self.table, "show_row_labels", False))

    # this doesn't work
    self.table.show_row_labels = False

After loading the table initially, I got empty row labels when pressing t. If I continued to go down, the rows labels came back. That's why I used call_later() at last. But I couldn't get it work with table restoring.

Please help me understand show_row_labels better or if there is an alternative solution. Thanks in advance.

Full code can be found here. See simplified code below:

# Pagination settings
INITIAL_BATCH_SIZE = 100  # Load this many rows initially
BATCH_SIZE = 50  # Load this many rows when scrolling


class DataFrameViewer(App):
    """A Textual app to view dataframe interactively."""

    BINDINGS = [
        ("t", "toggle_row_labels", "Toggle Row Labels"),
    ]

    def __init__(self, df: pl.DataFrame):
        super().__init__()
        self.dataframe = df  # Original dataframe
        self.df = df  # Internal dataframe
        self.loaded_rows = 0  # Track how many rows are currently loaded
        self.total_rows = len(df)

    def compose(self) -> ComposeResult:
        """Create child widgets for the app."""
        self.table = DataTable(zebra_stripes=True)
        yield self.table

    def on_mount(self) -> None:
        """Set up the DataTable when app starts."""
        self._setup_table()
        # Hide labels by default after initial load
        self.call_later(lambda: setattr(self.table, "show_row_labels", False))

    def on_key(self, event) -> None:
        """Handle key events."""
        if event.key == "r":
            # Restore original display
            self._setup_table()
            # Hide labels by default after initial load
            # self.call_later(lambda: setattr(self.table, "show_row_labels", False))
            self.log(f"{self.table.show_row_labels = }")

            self.notify("Restored original display", title="Reset")

    def action_toggle_row_labels(self) -> None:
        """Toggle row labels visibility using CSS property."""
        self.table.show_row_labels = not self.table.show_row_labels

    def _setup_table(self) -> None:
        """Setup the table for display."""
        # Reset to original dataframe
        self.df = self.dataframe
        self.loaded_rows = 0
        self.total_rows = len(self.dataframe)

        self._setup_columns()
        self._load_rows(INITIAL_BATCH_SIZE)

    def _setup_columns(self) -> None:
        """Clear table and setup columns.

        Args:
            visible_columns: List of column names to display. If None, all columns are visible.
        """

        self.table.clear(columns=True)
        self.loaded_rows = 0

        # Add columns with justified headers (only visible columns)
        for col, dtype in zip(self.df.columns, self.df.dtypes):
            if col not in self.visible_columns:
                continue
            style_config = STYLES.get(str(dtype), {"style": "green", "justify": "left"})
            self.table.add_column(Text(col, justify=style_config["justify"]), key=col)

        self.table.cursor_type = "cell"
        self.table.focus()

    def _load_rows(self, count: int) -> None:
        """Load a batch of rows into the table."""
        start_idx = self.loaded_rows
        if start_idx >= self.total_rows:
            return

        end_idx = min(start_idx + count, self.total_rows)
        df_slice = self.df.slice(start_idx, end_idx - start_idx)

        for row_idx, row in enumerate(df_slice.rows(), start_idx):
            vals, dtypes = [], []
            for val, col, dtype in zip(row, self.df.columns, self.df.dtypes):
                if col not in self.visible_columns:
                    continue
                vals.append(val)
                dtypes.append(dtype)
            formatted_row = _format_row(vals, dtypes)
            # Always add labels so they can be shown/hidden via CSS
            self.table.add_row(*formatted_row, label=str(row_idx + 1))

        self.loaded_rows = end_idx

        if count != INITIAL_BATCH_SIZE:
            self.notify(
                f"Loaded {self.loaded_rows}/{self.total_rows} rows", title="Load"
            )

    ```


## Versions

| Name    | Value  |
|---------|--------|
| Textual | 6.3.0  |
| Rich    | 14.2.0 |

## Python

| Name           | Value                                                   |
|----------------|---------------------------------------------------------|
| Version        | 3.14.0                                                  |
| Implementation | CPython                                                 |
| Compiler       | Clang 20.1.4                                            |
| Executable     | /Users/tjcheng/Coding/dataframe-viewer/.venv/bin/python |

## Operating System

| Name    | Value                                                                                                   |
|---------|---------------------------------------------------------------------------------------------------------|
| System  | Darwin                                                                                                  |
| Release | 24.6.0                                                                                                  |
| Version | Darwin Kernel Version 24.6.0: Mon Jul 14 11:30:40 PDT 2025; root:xnu-11417.140.69~1/RELEASE_ARM64_T8132 |

## Terminal

| Name                 | Value         |
|----------------------|---------------|
| Terminal Application | tmux (3.5a)   |
| TERM                 | tmux-256color |
| COLORTERM            | *Not set*     |
| FORCE_COLOR          | *Not set*     |
| NO_COLOR             | *Not set*     |

## Rich Console options

| Name           | Value                |
|----------------|----------------------|
| size           | width=210, height=57 |
| legacy_windows | False                |
| min_width      | 1                    |
| max_width      | 210                  |
| is_terminal    | True                 |
| encoding       | utf-8                |
| max_height     | 57                   |
| justify        | None                 |
| overflow       | None                 |
| no_wrap        | False                |
| highlight      | None                 |
| markup         | None                 |
| height         | None                 |

[github-actions]

Thank you for your issue. Give us a little time to review it.

PS. You might want to check the FAQ if you haven't done so already.

This project is developed and maintained by Will McGugan. Consider sponsoring Will's work on this project (and others).

This is an automated reply, generated by FAQtory

[TomJGooding]

I'm sure you checked this already, but the watch method for show_row_labels isn't too complicated:

textual/src/textual/widgets/_data_table.py

Lines 1155 to 1161 in 3427dba

	def watch_show_row_labels(self, show: bool) -> None:
	width, height = self.virtual_size
	column_width = self._label_column.get_render_width(self)
	width_change = column_width if show else -column_width
	self.virtual_size = Size(width + width_change, height)
	self._scroll_cursor_into_view()
	self._clear_caches()

Could you try reducing your code to an MRE, so anyone can just copy, paste and run the code?

[need47]

@TomJGooding Thanks for the suggestion. I've prepared a MRE main_mre.py and a test CSV file mre.csv.

To run (polars package must be installed first):

python main_mre.py mre.csv

Steps:

1. Run the above command. (Table shows up. Row label are hidden by default)
2. Press 't' to toggle row labels. (OK, row labels show up)
3. Press 'r' to restore or reload table (Table shows up. Row labels are hidden by default)
4. Press 't' to toggle row labels. (Row label column shows up. But the labels are empty)

Please help check. I will explore on my end too. Thanks a lot.

[TomJGooding]

Thanks, based on your example I've reduced this down to a simple MRE without polars or any special formatting:

from textual.app import App, ComposeResult
from textual.widgets import DataTable, Footer

ROWS = [
    ("lane", "swimmer", "country", "time"),
    (4, "Joseph Schooling", "Singapore", 50.39),
    (2, "Michael Phelps", "United States", 51.14),
    (5, "Chad le Clos", "South Africa", 51.14),
    (6, "László Cseh", "Hungary", 51.14),
    (3, "Li Zhuhao", "China", 51.26),
    (8, "Mehdy Metella", "France", 51.58),
    (7, "Tom Shields", "United States", 51.73),
    (1, "Aleksandr Sadovnikov", "Russia", 51.84),
    (10, "Darren Burns", "Scotland", 51.84),
]


class DataFrameViewer(App):
    BINDINGS = [
        ("q", "quit", "Quit"),
        ("t", "toggle_row_labels", "Toggle Row Labels"),
        ("r", "setup_table", "Reset Table"),
    ]

    def compose(self) -> ComposeResult:
        yield DataTable()
        yield Footer()

    def on_mount(self) -> None:
        self.action_setup_table()

    def action_toggle_row_labels(self) -> None:
        table = self.query_one(DataTable)
        table.show_row_labels = not table.show_row_labels

    def action_setup_table(self) -> None:
        table = self.query_one(DataTable)

        table.clear(columns=True)

        # Hide labels by default after initial load
        # table.show_row_labels = False
        self.call_later(lambda: setattr(table, "show_row_labels", False))

        for col in ROWS[0]:
            table.add_column(str(col))

        for row_idx, row in enumerate(ROWS[1:]):
            rid = str(row_idx + 1)
            table.add_row(*row, label=rid)


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

[need47]

Yeah, this is much simpler. Thanks. I just checked. The row labels are still missing or empty after a reset. It is confusing to me because when you toggle, the reactive show_row_labels does change and I always include the labels when set up the rows.

[TomJGooding]

From some quick debugging, I think the problem is that Column.content_width for the labels is zero if the rows are added while show_row_labels=False.

If you comment out the line in my example to automatically hide the row labels:

1. When the app starts, the row labels are displayed correctly
2. Press t to hide the labels then r to reload the table.
3. After pressing t to show the labels again, they display as empty.
4. But now if you reload the table by pressing r, the labels display as expected.

This is the action I also added to help debugging:

    def action_debug_label_column(self) -> None:
        table = self.query_one(DataTable)
        content_width = table._label_column.content_width

        self.notify(f"{content_width=}", title="Label column")