| from __future__ import annotations | |
| import sys | |
| from dataclasses import dataclass, field | |
| from itertools import chain, zip_longest | |
| from typing import ClassVar, Generic, Iterable, NamedTuple, TypeVar, cast | |
| from rich.console import RenderableType | |
| from rich.padding import Padding | |
| from rich.protocol import is_renderable | |
| from rich.segment import Segment | |
| from rich.style import Style | |
| from rich.text import Text, TextType | |
| from .. import events, messages | |
| from .._cache import LRUCache | |
| from .._profile import timer | |
| from .._segment_tools import line_crop | |
| from .._types import Lines | |
| from ..geometry import Region, Size, Spacing, clamp | |
| from ..reactive import Reactive | |
| from ..render import measure | |
| from ..scroll_view import ScrollView | |
| if sys.version_info >= (3, 8): | |
| from typing import Literal | |
| else: | |
| from typing_extensions import Literal | |
| CursorType = Literal["cell", "row", "column"] | |
| CELL: CursorType = "cell" | |
| CellType = TypeVar("CellType") | |
| def default_cell_formatter(obj: object) -> RenderableType | None: | |
| """Format a cell in to a renderable. | |
| Args: | |
| obj (object): Data for a cell. | |
| Returns: | |
| RenderableType | None: A renderable or None if the object could not be rendered. | |
| """ | |
| if isinstance(obj, str): | |
| return Text.from_markup(obj) | |
| if not is_renderable(obj): | |
| return None | |
| return cast(RenderableType, obj) | |
| class Column: | |
| """Table column.""" | |
| label: Text | |
| width: int = 0 | |
| visible: bool = False | |
| index: int = 0 | |
| content_width: int = 0 | |
| auto_width: bool = False | |
| def render_width(self) -> int: | |
| """Width in cells, required to render a column.""" | |
| # +2 is to account for space padding either side of the cell | |
| if self.auto_width: | |
| return self.content_width + 2 | |
| else: | |
| return self.width + 2 | |
| class Row: | |
| """Table row.""" | |
| index: int | |
| height: int | |
| y: int | |
| cell_renderables: list[RenderableType] = field(default_factory=list) | |
| class Cell: | |
| """Table cell.""" | |
| value: object | |
| class Coord(NamedTuple): | |
| """An object to represent the coordinate of a cell within the data table.""" | |
| row: int | |
| column: int | |
| def left(self) -> Coord: | |
| """Get coordinate to the left.""" | |
| row, column = self | |
| return Coord(row, column - 1) | |
| def right(self) -> Coord: | |
| """Get coordinate to the right.""" | |
| row, column = self | |
| return Coord(row, column + 1) | |
| def up(self) -> Coord: | |
| """Get coordinate above.""" | |
| row, column = self | |
| return Coord(row - 1, column) | |
| def down(self) -> Coord: | |
| """Get coordinate below.""" | |
| row, column = self | |
| return Coord(row + 1, column) | |
| class DataTable(ScrollView, Generic[CellType], can_focus=True): | |
| DEFAULT_CSS = """ | |
| App.-dark DataTable { | |
| background:; | |
| } | |
| DataTable { | |
| background: $surface ; | |
| color: $text; | |
| } | |
| DataTable > .datatable--header { | |
| text-style: bold; | |
| background: $primary; | |
| color: $text; | |
| } | |
| DataTable > .datatable--fixed { | |
| text-style: bold; | |
| background: $primary; | |
| color: $text; | |
| } | |
| DataTable > .datatable--odd-row { | |
| } | |
| DataTable > .datatable--even-row { | |
| background: $primary 10%; | |
| } | |
| DataTable > .datatable--cursor { | |
| background: $secondary; | |
| color: $text; | |
| } | |
| .-dark-mode DataTable > .datatable--even-row { | |
| background: $primary 15%; | |
| } | |
| DataTable > .datatable--highlight { | |
| background: $secondary 20%; | |
| } | |
| """ | |
| COMPONENT_CLASSES: ClassVar[set[str]] = { | |
| "datatable--header", | |
| "datatable--fixed", | |
| "datatable--odd-row", | |
| "datatable--even-row", | |
| "datatable--highlight", | |
| "datatable--cursor", | |
| } | |
| def __init__( | |
| self, | |
| *, | |
| name: str | None = None, | |
| id: str | None = None, | |
| classes: str | None = None, | |
| ) -> None: | |
| super().__init__(name=name, id=id, classes=classes) | |
| self.columns: list[Column] = [] | |
| self.rows: dict[int, Row] = {} | |
| self.data: dict[int, list[CellType]] = {} | |
| self.row_count = 0 | |
| self._y_offsets: list[tuple[int, int]] = [] | |
| self._row_render_cache: LRUCache[ | |
| tuple[int, int, Style, int, int], tuple[Lines, Lines] | |
| ] | |
| self._row_render_cache = LRUCache(1000) | |
| self._cell_render_cache: LRUCache[tuple[int, int, Style, bool, bool], Lines] | |
| self._cell_render_cache = LRUCache(10000) | |
| self._line_cache: LRUCache[ | |
| tuple[int, int, int, int, int, int, Style], list[Segment] | |
| ] | |
| self._line_cache = LRUCache(1000) | |
| self._line_no = 0 | |
| self._require_update_dimensions: bool = False | |
| self._new_rows: set[int] = set() | |
| show_header = Reactive(True) | |
| fixed_rows = Reactive(0) | |
| fixed_columns = Reactive(0) | |
| zebra_stripes = Reactive(False) | |
| header_height = Reactive(1) | |
| show_cursor = Reactive(True) | |
| cursor_type = Reactive(CELL) | |
| cursor_cell: Reactive[Coord] = Reactive(Coord(0, 0), repaint=False) | |
| hover_cell: Reactive[Coord] = Reactive(Coord(0, 0), repaint=False) | |
| def hover_row(self) -> int: | |
| return self.hover_cell.row | |
| def hover_column(self) -> int: | |
| return self.hover_cell.column | |
| def cursor_row(self) -> int: | |
| return self.cursor_cell.row | |
| def cursor_column(self) -> int: | |
| return self.cursor_cell.column | |
| def _clear_caches(self) -> None: | |
| self._row_render_cache.clear() | |
| self._cell_render_cache.clear() | |
| self._line_cache.clear() | |
| self._styles_cache.clear() | |
| def get_row_height(self, row_index: int) -> int: | |
| if row_index == -1: | |
| return self.header_height | |
| return self.rows[row_index].height | |
| async def on_styles_updated(self, message: messages.StylesUpdated) -> None: | |
| self._clear_caches() | |
| self.refresh() | |
| def watch_show_header(self, show_header: bool) -> None: | |
| self._clear_caches() | |
| def watch_fixed_rows(self, fixed_rows: int) -> None: | |
| self._clear_caches() | |
| def watch_zebra_stripes(self, zebra_stripes: bool) -> None: | |
| self._clear_caches() | |
| def watch_hover_cell(self, old: Coord, value: Coord) -> None: | |
| self.refresh_cell(*old) | |
| self.refresh_cell(*value) | |
| def watch_cursor_cell(self, old: Coord, value: Coord) -> None: | |
| self.refresh_cell(*old) | |
| self.refresh_cell(*value) | |
| def validate_cursor_cell(self, value: Coord) -> Coord: | |
| row, column = value | |
| row = clamp(row, 0, self.row_count - 1) | |
| column = clamp(column, self.fixed_columns, len(self.columns) - 1) | |
| return Coord(row, column) | |
| def _update_dimensions(self, new_rows: Iterable[int]) -> None: | |
| """Called to recalculate the virtual (scrollable) size.""" | |
| for row_index in new_rows: | |
| for column, renderable in zip( | |
| self.columns, self._get_row_renderables(row_index) | |
| ): | |
| content_width = measure(self.app.console, renderable, 1) | |
| column.content_width = max(column.content_width, content_width) | |
| total_width = sum(column.render_width for column in self.columns) | |
| header_height = self.header_height if self.show_header else 0 | |
| self.virtual_size = Size( | |
| total_width, | |
| len(self._y_offsets) + header_height, | |
| ) | |
| def _get_cell_region(self, row_index: int, column_index: int) -> Region: | |
| if row_index not in self.rows: | |
| return Region(0, 0, 0, 0) | |
| row = self.rows[row_index] | |
| x = sum(column.render_width for column in self.columns[:column_index]) | |
| width = self.columns[column_index].render_width | |
| height = row.height | |
| y = row.y | |
| if self.show_header: | |
| y += self.header_height | |
| cell_region = Region(x, y, width, height) | |
| return cell_region | |
| def add_columns(self, *labels: TextType) -> None: | |
| """Add a number of columns. | |
| Args: | |
| *labels: Column headers. | |
| """ | |
| for label in labels: | |
| self.add_column(label, width=None) | |
| def add_column(self, label: TextType, *, width: int | None = None) -> None: | |
| """Add a column to the table. | |
| Args: | |
| label (TextType): A str or Text object containing the label (shown top of column). | |
| width (int, optional): Width of the column in cells or None to fit content. Defaults to None. | |
| """ | |
| text_label = Text.from_markup(label) if isinstance(label, str) else label | |
| content_width = measure(self.app.console, text_label, 1) | |
| if width is None: | |
| column = Column( | |
| text_label, | |
| content_width, | |
| index=len(self.columns), | |
| content_width=content_width, | |
| auto_width=True, | |
| ) | |
| else: | |
| column = Column( | |
| text_label, width, content_width=content_width, index=len(self.columns) | |
| ) | |
| self.columns.append(column) | |
| self._require_update_dimensions = True | |
| self.check_idle() | |
| def add_row(self, *cells: CellType, height: int = 1) -> None: | |
| """Add a row. | |
| Args: | |
| *cells: Positional arguments should contain cell data. | |
| height (int, optional): The height of a row (in lines). Defaults to 1. | |
| """ | |
| row_index = self.row_count | |
| self.data[row_index] = list(cells) | |
| self.rows[row_index] = Row(row_index, height, self._line_no) | |
| for line_no in range(height): | |
| self._y_offsets.append((row_index, line_no)) | |
| self.row_count += 1 | |
| self._line_no += height | |
| self._new_rows.add(row_index) | |
| self._require_update_dimensions = True | |
| self.check_idle() | |
| def add_rows(self, rows: Iterable[Iterable[CellType]]) -> None: | |
| """Add a number of rows. | |
| Args: | |
| rows (Iterable[Iterable[CellType]]): Iterable of rows. A row is an iterable of cells. | |
| """ | |
| for row in rows: | |
| self.add_row(*row) | |
| def on_idle(self) -> None: | |
| if self._require_update_dimensions: | |
| self._require_update_dimensions = False | |
| new_rows = self._new_rows.copy() | |
| self._new_rows.clear() | |
| self._update_dimensions(new_rows) | |
| def refresh_cell(self, row_index: int, column_index: int) -> None: | |
| """Refresh a cell. | |
| Args: | |
| row_index (int): Row index. | |
| column_index (int): Column index. | |
| """ | |
| if row_index < 0 or column_index < 0: | |
| return | |
| region = self._get_cell_region(row_index, column_index) | |
| if not self.window_region.overlaps(region): | |
| return | |
| region = region.translate(-self.scroll_offset) | |
| self.refresh(region) | |
| def _get_row_renderables(self, row_index: int) -> list[RenderableType]: | |
| """Get renderables for the given row. | |
| Args: | |
| row_index (int): Index of the row. | |
| Returns: | |
| list[RenderableType]: List of renderables | |
| """ | |
| if row_index == -1: | |
| row = [column.label for column in self.columns] | |
| return row | |
| data = self.data.get(row_index) | |
| empty = Text() | |
| if data is None: | |
| return [empty for _ in self.columns] | |
| else: | |
| return [ | |
| Text() if datum is None else default_cell_formatter(datum) or empty | |
| for datum, _ in zip_longest(data, range(len(self.columns))) | |
| ] | |
| def _render_cell( | |
| self, | |
| row_index: int, | |
| column_index: int, | |
| style: Style, | |
| width: int, | |
| cursor: bool = False, | |
| hover: bool = False, | |
| ) -> Lines: | |
| """Render the given cell. | |
| Args: | |
| row_index (int): Index of the row. | |
| column_index (int): Index of the column. | |
| style (Style): Style to apply. | |
| width (int): Width of the cell. | |
| Returns: | |
| Lines: A list of segments per line. | |
| """ | |
| if hover: | |
| style += self.get_component_styles("datatable--highlight").rich_style | |
| if cursor: | |
| style += self.get_component_styles("datatable--cursor").rich_style | |
| cell_key = (row_index, column_index, style, cursor, hover) | |
| if cell_key not in self._cell_render_cache: | |
| style += Style.from_meta({"row": row_index, "column": column_index}) | |
| height = ( | |
| self.header_height if row_index == -1 else self.rows[row_index].height | |
| ) | |
| cell = self._get_row_renderables(row_index)[column_index] | |
| lines = self.app.console.render_lines( | |
| Padding(cell, (0, 1)), | |
| self.app.console.options.update_dimensions(width, height), | |
| style=style, | |
| ) | |
| self._cell_render_cache[cell_key] = lines | |
| return self._cell_render_cache[cell_key] | |
| def _render_row( | |
| self, | |
| row_index: int, | |
| line_no: int, | |
| base_style: Style, | |
| cursor_column: int = -1, | |
| hover_column: int = -1, | |
| ) -> tuple[Lines, Lines]: | |
| """Render a row in to lines for each cell. | |
| Args: | |
| row_index (int): Index of the row. | |
| line_no (int): Line number (on screen, 0 is top) | |
| base_style (Style): Base style of row. | |
| Returns: | |
| tuple[Lines, Lines]: Lines for fixed cells, and Lines for scrollable cells. | |
| """ | |
| cache_key = (row_index, line_no, base_style, cursor_column, hover_column) | |
| if cache_key in self._row_render_cache: | |
| return self._row_render_cache[cache_key] | |
| render_cell = self._render_cell | |
| if self.fixed_columns: | |
| fixed_style = self.get_component_styles("datatable--fixed").rich_style | |
| fixed_style += Style.from_meta({"fixed": True}) | |
| fixed_row = [ | |
| render_cell(row_index, column.index, fixed_style, column.render_width)[ | |
| line_no | |
| ] | |
| for column in self.columns[: self.fixed_columns] | |
| ] | |
| else: | |
| fixed_row = [] | |
| if row_index == -1: | |
| row_style = self.get_component_styles("datatable--header").rich_style | |
| else: | |
| if self.zebra_stripes: | |
| component_row_style = ( | |
| "datatable--odd-row" if row_index % 2 else "datatable--even-row" | |
| ) | |
| row_style = self.get_component_styles(component_row_style).rich_style | |
| else: | |
| row_style = base_style | |
| scrollable_row = [ | |
| render_cell( | |
| row_index, | |
| column.index, | |
| row_style, | |
| column.render_width, | |
| cursor=cursor_column == column.index, | |
| hover=hover_column == column.index, | |
| )[line_no] | |
| for column in self.columns | |
| ] | |
| row_pair = (fixed_row, scrollable_row) | |
| self._row_render_cache[cache_key] = row_pair | |
| return row_pair | |
| def _get_offsets(self, y: int) -> tuple[int, int]: | |
| """Get row number and line offset for a given line. | |
| Args: | |
| y (int): Y coordinate relative to screen top. | |
| Returns: | |
| tuple[int, int]: Line number and line offset within cell. | |
| """ | |
| if self.show_header: | |
| if y < self.header_height: | |
| return (-1, y) | |
| y -= self.header_height | |
| if y > len(self._y_offsets): | |
| raise LookupError("Y coord {y!r} is greater than total height") | |
| return self._y_offsets[y] | |
| def _render_line( | |
| self, y: int, x1: int, x2: int, base_style: Style | |
| ) -> list[Segment]: | |
| """Render a line in to a list of segments. | |
| Args: | |
| y (int): Y coordinate of line | |
| x1 (int): X start crop. | |
| x2 (int): X end crop (exclusive). | |
| base_style (Style): Style to apply to line. | |
| Returns: | |
| list[Segment]: List of segments for rendering. | |
| """ | |
| width = self.size.width | |
| try: | |
| row_index, line_no = self._get_offsets(y) | |
| except LookupError: | |
| return [Segment(" " * width, base_style)] | |
| cursor_column = ( | |
| self.cursor_column | |
| if (self.show_cursor and self.cursor_row == row_index) | |
| else -1 | |
| ) | |
| hover_column = self.hover_column if (self.hover_row == row_index) else -1 | |
| cache_key = (y, x1, x2, width, cursor_column, hover_column, base_style) | |
| if cache_key in self._line_cache: | |
| return self._line_cache[cache_key] | |
| fixed, scrollable = self._render_row( | |
| row_index, | |
| line_no, | |
| base_style, | |
| cursor_column=cursor_column, | |
| hover_column=hover_column, | |
| ) | |
| fixed_width = sum( | |
| column.render_width for column in self.columns[: self.fixed_columns] | |
| ) | |
| fixed_line: list[Segment] = list(chain.from_iterable(fixed)) if fixed else [] | |
| scrollable_line: list[Segment] = list(chain.from_iterable(scrollable)) | |
| segments = fixed_line + line_crop(scrollable_line, x1 + fixed_width, x2, width) | |
| segments = Segment.adjust_line_length(segments, width, style=base_style) | |
| simplified_segments = list(Segment.simplify(segments)) | |
| self._line_cache[cache_key] = simplified_segments | |
| return segments | |
| def render_line(self, y: int) -> list[Segment]: | |
| width, height = self.size | |
| scroll_x, scroll_y = self.scroll_offset | |
| fixed_top_row_count = sum( | |
| self.get_row_height(row_index) for row_index in range(self.fixed_rows) | |
| ) | |
| if self.show_header: | |
| fixed_top_row_count += self.get_row_height(-1) | |
| style = self.rich_style | |
| if y >= fixed_top_row_count: | |
| y += scroll_y | |
| return self._render_line(y, scroll_x, scroll_x + width, style) | |
| def on_mouse_move(self, event: events.MouseMove): | |
| meta = event.style.meta | |
| if meta: | |
| try: | |
| self.hover_cell = Coord(meta["row"], meta["column"]) | |
| except KeyError: | |
| pass | |
| def _get_cell_border(self) -> Spacing: | |
| top = self.header_height if self.show_header else 0 | |
| top += sum( | |
| self.rows[row_index].height | |
| for row_index in range(self.fixed_rows) | |
| if row_index in self.rows | |
| ) | |
| left = sum(column.render_width for column in self.columns[: self.fixed_columns]) | |
| return Spacing(top, 0, 0, left) | |
| def _scroll_cursor_in_to_view(self, animate: bool = False) -> None: | |
| region = self._get_cell_region(self.cursor_row, self.cursor_column) | |
| spacing = self._get_cell_border() + self.scrollbar_gutter | |
| self.scroll_to_region(region, animate=animate, spacing=spacing) | |
| def on_click(self, event: events.Click) -> None: | |
| meta = self.get_style_at(event.x, event.y).meta | |
| if meta: | |
| self.cursor_cell = Coord(meta["row"], meta["column"]) | |
| self._scroll_cursor_in_to_view() | |
| event.stop() | |
| def key_down(self, event: events.Key): | |
| self.cursor_cell = self.cursor_cell.down() | |
| event.stop() | |
| event.prevent_default() | |
| self._scroll_cursor_in_to_view() | |
| def key_up(self, event: events.Key): | |
| self.cursor_cell = self.cursor_cell.up() | |
| event.stop() | |
| event.prevent_default() | |
| self._scroll_cursor_in_to_view() | |
| def key_right(self, event: events.Key): | |
| self.cursor_cell = self.cursor_cell.right() | |
| event.stop() | |
| event.prevent_default() | |
| self._scroll_cursor_in_to_view(animate=True) | |
| def key_left(self, event: events.Key): | |
| self.cursor_cell = self.cursor_cell.left() | |
| event.stop() | |
| event.prevent_default() | |
| self._scroll_cursor_in_to_view(animate=True) | |