devboard ¤

Methods:

• check –

  Uncheck the checkbox.

• toggle –

  Toggle the checkbox.

• uncheck –

  Uncheck the checkbox.

Attributes:

• checked (bool) –

  Whether the checkbox is checked.

checked: bool = False

check() -> None

48
49
50

def check(self) -> None:
    """Uncheck the checkbox."""
    self.checked = True

toggle() -> bool

56
57
58
59

def toggle(self) -> bool:
    """Toggle the checkbox."""
    self.checked = not self.checked
    return self.checked

uncheck() -> None

52
53
54

def uncheck(self) -> None:
    """Uncheck the checkbox."""
    self.checked = False

Methods:

• action_apply –

  Apply an action to selected rows.

• apply –

  Apply action on given row.

• compose –

  Compose column widgets.

• list_projects –

  List projects for this column.

• modal –

  Push a modal.

• notify_error –

  Notify error.

• notify_info –

  Notify information.

• notify_success –

  Notify success.

• notify_warning –

  Notify warning.

• populate_rows –

  Populate rows for this column.

• update –

  Update the column (ask the app to recompute its data).

Attributes:

• DEFAULT_CLASSES –

  Textual CSS classes.

• HEADERS (tuple[str, ...]) –

  The data table headers.

• THREADED (bool) –

  Whether actions of this column should run in the background.

• TITLE (str) –

  The title of the column.

• app (App) –

  Textual application.

• table (DataTable) –

  Data table.

DEFAULT_CLASSES = 'box'

HEADERS: tuple[str, ...] = ()

THREADED: bool = True

TITLE: str = ''

app: App

table: DataTable

action_apply(action: str = 'default') -> None

80
81
82
83
84
85
86
87
88
89
90

def action_apply(self, action: str = "default") -> None:
    """Apply an action to selected rows."""
    selected_rows = [cast("Row", row) for row in self.table.selected_rows]
    if not selected_rows:
        selected_rows.append(cast("Row", self.table.current_row))
    if self.THREADED:
        for row in selected_rows:
            self.run_worker(partial(self.apply, action=action, row=row), thread=True)
    else:
        for row in selected_rows:
            self.apply(action=action, row=row)

apply(action: str, row: Row) -> None

156
157
158

def apply(self, action: str, row: Row) -> None:  # noqa: ARG002
    """Apply action on given row."""
    return

compose() -> ComposeResult

72
73
74
75

def compose(self) -> ComposeResult:
    """Compose column widgets."""
    yield Static("▶ " + self.TITLE, classes="column-title")
    yield DataTable(id="table")

list_projects() -> Iterable[Project]

147
148
149

def list_projects(self) -> Iterable[Project]:
    """List projects for this column."""
    return ()

modal(text: str) -> None

68
69
70

def modal(self, text: str) -> None:
    """Push a modal."""
    self.app.push_screen(Modal(text=text))

notify_error(message: str, timeout: float = 3.0) -> None

40
41
42

def notify_error(self, message: str, timeout: float = 3.0) -> None:
    """Notify error."""
    self.app.notify(f"[b red]ERROR[/]  {message}", severity="error", timeout=timeout)

notify_info(message: str, timeout: float = 3.0) -> None

28
29
30

def notify_info(self, message: str, timeout: float = 3.0) -> None:
    """Notify information."""
    self.app.notify(f"[b blue]INFO[/]  {message}", severity="information", timeout=timeout)

notify_success(message: str, timeout: float = 3.0) -> None

32
33
34

def notify_success(self, message: str, timeout: float = 3.0) -> None:
    """Notify success."""
    self.app.notify(f"[b green]SUCCESS[/]  {message}", severity="information", timeout=timeout)

notify_warning(message: str, timeout: float = 3.0) -> None

36
37
38

def notify_warning(self, message: str, timeout: float = 3.0) -> None:
    """Notify warning."""
    self.app.notify(f"[b yellow]WARNING[/]  {message}", severity="warning", timeout=timeout)

populate_rows(project: Project) -> list[tuple[Any, ...]]

151
152
153
154

@staticmethod
def populate_rows(project: Project) -> list[tuple[Any, ...]]:  # noqa: ARG004
    """Populate rows for this column."""
    return []

update() -> None

100
101
102
103
104

def update(self) -> None:
    """Update the column (ask the app to recompute its data)."""
    scan = getattr(self.app, "scan", None)
    if scan is not None:
        scan([self])

Methods:

• action_reverse_select –

  Reverse selection.

• action_toggle_select_all –

  Toggle-select all rows.

• action_toggle_select_down –

  Toggle selection down.

• action_toggle_select_row –

  Toggle-select current row.

• action_toggle_select_up –

  Toggle selection up.

• add_rows –

  Add rows.

• clear –

  Clear rows and optionally columns.

• force_refresh –

  Force refresh table.

Attributes:

• BINDINGS (ClassVar) –

  Key bindings for selecting rows.

• ROW –

  The class to instantiate rows.

• current_row (SelectableRow) –

  Currently selected row.

• selectable_rows (Iterator[SelectableRow]) –

  Rows, as selectable ones.

• selected_rows (Iterator[SelectableRow]) –

  Selected rows.

BINDINGS: ClassVar = [
    Binding(
        "space",
        "toggle_select_row",
        "Toggle select",
        show=False,
    ),
    Binding(
        "ctrl+a, *",
        "toggle_select_all",
        "Toggle select all",
        show=False,
    ),
    Binding(
        "exclamation_mark",
        "reverse_select",
        "Reverse select",
        show=False,
    ),
    Binding(
        "shift+up",
        "toggle_select_up",
        "Expand select up",
        show=False,
    ),
    Binding(
        "shift+down",
        "toggle_select_down",
        "Expand select down",
        show=False,
    ),
]

ROW = Row

current_row: SelectableRow

selectable_rows: Iterator[SelectableRow]

selected_rows: Iterator[SelectableRow]

action_reverse_select() -> None

189
190
191
192
193

def action_reverse_select(self) -> None:
    """Reverse selection."""
    for row in self.selectable_rows:
        row.toggle_select()
    self.force_refresh()

action_toggle_select_all() -> None

178
179
180
181
182
183
184
185
186
187

def action_toggle_select_all(self) -> None:
    """Toggle-select all rows."""
    rows = list(self.selectable_rows)
    if all(row.selected for row in rows):
        for row in rows:
            row.unselect()
    else:
        for row in rows:
            row.select()
    self.force_refresh()

action_toggle_select_down() -> None

207
208
209
210
211
212
213
214
215
216
217

def action_toggle_select_down(self) -> None:
    """Toggle selection down."""
    try:
        row = self.current_row
        next_row = row.next
    except CellDoesNotExist:
        pass
    else:
        next_row.toggle_select()
        self.move_cursor(row=next_row.index)
        self.force_refresh()

action_toggle_select_row() -> None

169
170
171
172
173
174
175
176

def action_toggle_select_row(self) -> None:
    """Toggle-select current row."""
    try:
        row = self.current_row
    except CellDoesNotExist:
        return
    row.toggle_select()
    self.force_refresh()

action_toggle_select_up() -> None

195
196
197
198
199
200
201
202
203
204
205

def action_toggle_select_up(self) -> None:
    """Toggle selection up."""
    try:
        row = self.current_row
        previous_row = row.previous
    except CellDoesNotExist:
        pass
    else:
        previous_row.toggle_select()
        self.move_cursor(row=previous_row.index)
        self.force_refresh()

add_rows(rows: Iterable[Iterable]) -> list[RowKey]

149
150
151
152
153
154

def add_rows(self, rows: Iterable[Iterable]) -> list[RowKey]:
    """Add rows.

    Automatically insert a column with checkboxes in position 0.
    """
    return super().add_rows((Checkbox(), *row) for row in rows)

clear(columns: bool = True) -> SelectableRowsDataTable

156
157
158
159
160
161
162
163
164

def clear(self, columns: bool = True) -> SelectableRowsDataTable:  # noqa: FBT001,FBT002
    """Clear rows and optionally columns.

    When clearing columns, automatically re-add a column for checkboxes.
    """
    super().clear(columns)
    if columns:
        self.add_column("", key="checkbox")
    return self

force_refresh() -> None

222
223
224
225
226
227

def force_refresh(self) -> None:
    """Force refresh table."""
    # HACK: Without such increment, the table is refreshed
    # only when focus changes to another column.
    self._update_count += 1
    self.refresh()

Methods:

• action_exit –

  Exit application.

• action_refresh –

  Refresh all columns.

• action_show_help –

  Show help.

• compose –

  Compose the layout.

• fetch_all –

  Run git fetch in all projects, in background.

• modal –

  Push a modal.

• on_mount –

  Populate columns, then run background tasks.

• scan –

  Recompute columns data in the background.

Attributes:

• BINDINGS (ClassVar) –

  Application key bindings.

• CSS_PATH –

  Path to the CSS file.

• app (App) –

  Textual application.

 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101

def __init__(
    self,
    *args: Any,
    board: str | Path | None = None,
    background_tasks: bool = True,
    workers: int | None = None,
    **kwargs: Any,
) -> None:
    """Initialize the app.

    Parameters:
        board: The board to display (name or file path).
        background_tasks: Whether to fetch repositories in the background after the initial scan.
            Disabling this also disables the on-disk cache (useful for tests and screenshots).
        workers: How many projects to scan concurrently. Overrides the `workers` config setting.
    """
    super().__init__(*args, **kwargs)
    self._board: str | Path | None = board
    self._board_key: str = str(board)
    self._config_file: Path = Path(user_config_dir(), "devboard", "config.toml")
    self._background_tasks: bool = background_tasks
    self._scan_workers: int | None = workers
    self._scanning: bool = False

BINDINGS: ClassVar = [
    Binding("F5, ctrl+r", "refresh", "Refresh"),
    Binding("question_mark", "show_help", "Help"),
    Binding(
        "ctrl+q, q, escape", "exit", "Exit", key_display="Q"
    ),
]

CSS_PATH = Path(__file__).parent / 'devboard.tcss'

app: App

action_exit() -> None

133
134
135
136

def action_exit(self) -> None:
    """Exit application."""
    self.workers.cancel_all()
    self.exit()

action_refresh() -> None

129
130
131

def action_refresh(self) -> None:
    """Refresh all columns."""
    self.scan()

action_show_help() -> None

119
120
121
122
123
124
125
126
127

def action_show_help(self) -> None:
    """Show help."""
    lines = ["# Main keys\n\n"]
    lines.extend(self._bindings_help(Devboard))
    lines.extend(self._bindings_help(DataTable, search_up=True))
    for column in self.query(Column):
        lines.append(f"\n\n# {column.__class__.TITLE}\n\n")
        lines.extend(self._bindings_help(column.__class__))
    self.push_screen(Modal(text=Markdown("\n".join(lines))))

compose() -> ComposeResult

103
104
105
106
107
108
109
110

def compose(self) -> ComposeResult:
    """Compose the layout."""
    for column in self._load_columns():
        if isinstance(column, Column):
            yield column
        else:
            yield column()
    yield Footer()

fetch_all() -> None

160
161
162
163
164
165
166

@work(thread=True)
def fetch_all(self) -> None:
    """Run `git fetch` in all projects, in background."""
    projects: set[Project] = set()
    for column in self.query(Column):
        projects |= set(column.list_projects())
    self._fetch_projects(projects)

modal(text: str) -> None

68
69
70

def modal(self, text: str) -> None:
    """Push a modal."""
    self.app.push_screen(Modal(text=text))

on_mount() -> None

112
113
114

def on_mount(self) -> None:
    """Populate columns, then run background tasks."""
    self.scan(initial=True)

scan(
    columns: Iterable[Column] | None = None,
    *,
    initial: bool = False,
) -> None

141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

def scan(self, columns: Iterable[Column] | None = None, *, initial: bool = False) -> None:
    """Recompute columns data in the background.

    A single scan feeds all columns: each project is read once,
    by a small pool of threads, and the resulting rows are dispatched
    to every column as they arrive.

    Parameters:
        columns: The columns to update (all of them by default).
        initial: Whether this is the initial scan at startup, which additionally
            displays cached data, saves fresh data to the cache, and triggers
            the background fetch when these features are enabled.
    """
    if self._scanning:
        return
    self._scanning = True
    column_list = list(columns) if columns is not None else list(self.query(Column))
    self.run_worker(partial(self._scan, column_list, initial=initial), thread=True)

Methods:

• compose –

  Screen composition.

• on_key –

  Dismiss on any unbound key.

Attributes:

• text –

  Text content.

36
37
38
39
40
41
42
43

def __init__(self, *args: Any, text: Any, **kwargs: Any) -> None:
    """Initialize the screen."""
    super().__init__(*args, **kwargs)
    if isinstance(text, str):
        self.text = Text.from_ansi(text)
        """Text content."""
    else:
        self.text = text

text = Text.from_ansi(text)

compose() -> ComposeResult

45
46
47

def compose(self) -> ComposeResult:
    """Screen composition."""
    yield VerticalScroll(Static(self.text), id="modal-contents")

on_key(event: Key) -> None

49
50
51
52
53
54
55
56
57
58
59

def on_key(self, event: Key) -> None:
    """Dismiss on any unbound key."""
    active_bindings = getattr(self.app, "active_bindings", None)
    if active_bindings is None:  # Textual < 1.0.
        legacy_binding_chain = getattr(self.app, "_modal_binding_chain")  # noqa: B009
        is_bound = any(bindings.keys.get(event.key) for _, bindings in legacy_binding_chain)
    else:
        is_bound = event.key in active_bindings
    if not is_bound:
        event.stop()
        self.dismiss()

Methods:

• modal –

  Push a modal.

Attributes:

• app (App) –

  Textual application.

app: App

modal(text: str) -> None

68
69
70

def modal(self, text: str) -> None:
    """Push a modal."""
    self.app.push_screen(Modal(text=text))

Methods:

• notify_error –

  Notify error.

• notify_info –

  Notify information.

• notify_success –

  Notify success.

• notify_warning –

  Notify warning.

Attributes:

• app (App) –

  Textual application.

app: App

notify_error(message: str, timeout: float = 3.0) -> None

40
41
42

def notify_error(self, message: str, timeout: float = 3.0) -> None:
    """Notify error."""
    self.app.notify(f"[b red]ERROR[/]  {message}", severity="error", timeout=timeout)

notify_info(message: str, timeout: float = 3.0) -> None

28
29
30

def notify_info(self, message: str, timeout: float = 3.0) -> None:
    """Notify information."""
    self.app.notify(f"[b blue]INFO[/]  {message}", severity="information", timeout=timeout)

notify_success(message: str, timeout: float = 3.0) -> None

32
33
34

def notify_success(self, message: str, timeout: float = 3.0) -> None:
    """Notify success."""
    self.app.notify(f"[b green]SUCCESS[/]  {message}", severity="information", timeout=timeout)

notify_warning(message: str, timeout: float = 3.0) -> None

36
37
38

def notify_warning(self, message: str, timeout: float = 3.0) -> None:
    """Notify warning."""
    self.app.notify(f"[b yellow]WARNING[/]  {message}", severity="warning", timeout=timeout)

Methods:

• __lt__ –

  Ordering is based on the project name.

• checkout –

  Checkout branch, restore previous one when exiting.

• delete –

  Delete branch.

• fetch –

  Fetch.

• lock –

  Lock project.

• pull –

  Pull branch.

• push –

  Push branch.

• unlock –

  Unlock project.

• unpulled –

  Number of unpulled commits (compared to the branch upstream), per branch.

• unpushed –

  Number of unpushed commits (compared to the branch upstream), per branch.

• unreleased –

  List unreleased commits (commits since the latest tag reachable from the branch).

Attributes:

• DEFAULT_BRANCHES (tuple[str, ...]) –

  Name of common default branches. Mainly useful to compute unreleased commits.

• LOCKS (dict[Project, Lock]) –

  Locks for projects, to avoid concurrent operations.

• branch (Head) –

  Currently checked out branch.

• default_branch (str) –

  Default branch (or main branch), as checked out when cloning.

• is_dirty (bool) –

  Whether the project is in a "dirty" state (uncommitted modifications).

• latest_tag (TagReference) –

  Latest tag (by creation date).

• name (str) –

  Name of the project.

• path (Path) –

  Path of the project on the file-system.

• repo (Repo) –

  GitPython's Repo object (cached per instance).

• status (Status) –

  Status of the project.

• status_line (str) –

  Status of the project, as a string.

67
68
69

def __init__(self, path: Path) -> None:
    self.path: Path = path
    """Path of the project on the file-system."""

DEFAULT_BRANCHES: tuple[str, ...] = ('main', 'master')

LOCKS: dict[Project, Lock] = defaultdict(Lock)

branch: Head

default_branch: str

is_dirty: bool

latest_tag: TagReference

name: str

path: Path = path

repo: Repo

status: Status

status_line: str

__lt__(other: object) -> bool

74
75
76
77
78
79
80
81

def __lt__(self, other: object) -> bool:
    """Ordering is based on the project name.

    Total ordering is implemented on projects so they can be sorted in the application tables.
    """
    if not isinstance(other, Project):
        return NotImplemented
    return self.name < other.name

checkout(branch: str | None) -> Iterator[None]

196
197
198
199
200
201
202
203
204
205
206
207
208
209
210

@contextmanager
def checkout(self, branch: str | None) -> Iterator[None]:
    """Checkout branch, restore previous one when exiting."""
    if not branch:
        yield
        return
    current = self.branch
    if branch == current:
        yield
        return
    self.repo.branches[branch].checkout()
    try:
        yield
    finally:
        current.checkout()

delete(branch: str) -> None

222
223
224

def delete(self, branch: str) -> None:
    """Delete branch."""
    self.repo.delete_head(branch, force=True)

fetch() -> None

244
245
246
247
248
249

def fetch(self) -> None:
    """Fetch."""
    with suppress(AttributeError, GitCommandError):
        self.repo.remotes.origin.fetch()
    with suppress(AttributeError, GitCommandError):
        self.repo.remotes.upstream.fetch()

lock() -> bool

263
264
265

def lock(self) -> bool:
    """Lock project."""
    return self.LOCKS[self].acquire(blocking=False)

pull(branch: str | None = None) -> None

212
213
214
215

def pull(self, branch: str | None = None) -> None:
    """Pull branch."""
    with self.checkout(branch):
        self.repo.remotes.origin.pull()

push(branch: str | None = None) -> None

217
218
219
220

def push(self, branch: str | None = None) -> None:
    """Push branch."""
    with self.checkout(branch):
        self.repo.remotes.origin.push()

unlock() -> None

267
268
269

def unlock(self) -> None:
    """Unlock project."""
    self.LOCKS[self].release()

unpulled() -> dict[str, int]

173
174
175

def unpulled(self) -> dict[str, int]:
    """Number of unpulled commits (compared to the branch upstream), per branch."""
    return {branch: behind for branch, (_, behind) in self._tracking.items()}

unpushed() -> dict[str, int]

169
170
171

def unpushed(self) -> dict[str, int]:
    """Number of unpushed commits (compared to the branch upstream), per branch."""
    return {branch: ahead for branch, (ahead, _) in self._tracking.items()}

unreleased(branch: str | None = None) -> list[Commit]

226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242

def unreleased(self, branch: str | None = None) -> list[Commit]:
    """List unreleased commits (commits since the latest tag reachable from the branch)."""
    if branch is None:
        try:
            branch = self.default_branch
        except ValueError:
            return []
    try:
        latest_tag = self.repo.git.describe(branch, tags=True, abbrev=0)
    except GitCommandError:
        rev = branch  # No tag reachable: everything is unreleased.
    else:
        rev = f"{latest_tag}..{branch}"
    try:
        return list(self.repo.iter_commits(rev))
    except GitCommandError:
        return []

Methods:

• remove –

  Remove row from the table.

• select –

  Select this row.

• toggle_select –

  Toggle-select this row.

• unselect –

  Unselect this row.

Attributes:

• app (App) –

  Textual application.

• checkbox (Checkbox) –

  Row checkbox.

• data (list) –

  Row data (without checkbox).

• index (int) –

  Row index.

• key (RowKey) –

  The row key.

• next (SelectableRow) –

  Next row (down).

• previous (SelectableRow) –

  Previous row (up).

• project (Project) –

  Devboard project.

• selected (bool) –

  Whether this row is selected.

• table (SelectableRowsDataTable) –

  The data table containing this row.

app: App

checkbox: Checkbox

data: list

index: int

key: RowKey

next: SelectableRow

previous: SelectableRow

project: Project

selected: bool

table: SelectableRowsDataTable

remove() -> None

112
113
114

def remove(self) -> None:
    """Remove row from the table."""
    self.table.remove_row(self.key)

select() -> None

95
96
97

def select(self) -> None:
    """Select this row."""
    self.checkbox.check()

toggle_select() -> bool

103
104
105

def toggle_select(self) -> bool:
    """Toggle-select this row."""
    return self.checkbox.toggle()

unselect() -> None

 99
100
101

def unselect(self) -> None:
    """Unselect this row."""
    self.checkbox.uncheck()

Methods:

• remove –

  Remove row from the table.

• select –

  Select this row.

• toggle_select –

  Toggle-select this row.

• unselect –

  Unselect this row.

Attributes:

• app (App) –

  Textual application.

• checkbox (Checkbox) –

  Row checkbox.

• data (list) –

  Row data (without checkbox).

• index (int) –

  Row index.

• key (RowKey) –

  The row key.

• next (SelectableRow) –

  Next row (down).

• previous (SelectableRow) –

  Previous row (up).

• selected (bool) –

  Whether this row is selected.

• table (SelectableRowsDataTable) –

  The data table containing this row.

app: App

checkbox: Checkbox

data: list

index: int

key: RowKey

next: SelectableRow

previous: SelectableRow

selected: bool

table: SelectableRowsDataTable

remove() -> None

112
113
114

def remove(self) -> None:
    """Remove row from the table."""
    self.table.remove_row(self.key)

select() -> None

95
96
97

def select(self) -> None:
    """Select this row."""
    self.checkbox.check()

toggle_select() -> bool

103
104
105

def toggle_select(self) -> bool:
    """Toggle-select this row."""
    return self.checkbox.toggle()

unselect() -> None

 99
100
101

def unselect(self) -> None:
    """Unselect this row."""
    self.checkbox.uncheck()

Methods:

• action_reverse_select –

  Reverse selection.

• action_toggle_select_all –

  Toggle-select all rows.

• action_toggle_select_down –

  Toggle selection down.

• action_toggle_select_row –

  Toggle-select current row.

• action_toggle_select_up –

  Toggle selection up.

• add_rows –

  Add rows.

• clear –

  Clear rows and optionally columns.

• force_refresh –

  Force refresh table.

Attributes:

• BINDINGS (ClassVar) –

  Key bindings for selecting rows.

• ROW –

  The class to instantiate selectable rows.

• current_row (SelectableRow) –

  Currently selected row.

• selectable_rows (Iterator[SelectableRow]) –

  Rows, as selectable ones.

• selected_rows (Iterator[SelectableRow]) –

  Selected rows.

BINDINGS: ClassVar = [
    Binding(
        "space",
        "toggle_select_row",
        "Toggle select",
        show=False,
    ),
    Binding(
        "ctrl+a, *",
        "toggle_select_all",
        "Toggle select all",
        show=False,
    ),
    Binding(
        "exclamation_mark",
        "reverse_select",
        "Reverse select",
        show=False,
    ),
    Binding(
        "shift+up",
        "toggle_select_up",
        "Expand select up",
        show=False,
    ),
    Binding(
        "shift+down",
        "toggle_select_down",
        "Expand select down",
        show=False,
    ),
]

ROW = SelectableRow

current_row: SelectableRow

selectable_rows: Iterator[SelectableRow]

selected_rows: Iterator[SelectableRow]

action_reverse_select() -> None

189
190
191
192
193

def action_reverse_select(self) -> None:
    """Reverse selection."""
    for row in self.selectable_rows:
        row.toggle_select()
    self.force_refresh()

action_toggle_select_all() -> None

178
179
180
181
182
183
184
185
186
187

def action_toggle_select_all(self) -> None:
    """Toggle-select all rows."""
    rows = list(self.selectable_rows)
    if all(row.selected for row in rows):
        for row in rows:
            row.unselect()
    else:
        for row in rows:
            row.select()
    self.force_refresh()

action_toggle_select_down() -> None

207
208
209
210
211
212
213
214
215
216
217

def action_toggle_select_down(self) -> None:
    """Toggle selection down."""
    try:
        row = self.current_row
        next_row = row.next
    except CellDoesNotExist:
        pass
    else:
        next_row.toggle_select()
        self.move_cursor(row=next_row.index)
        self.force_refresh()

action_toggle_select_row() -> None

169
170
171
172
173
174
175
176

def action_toggle_select_row(self) -> None:
    """Toggle-select current row."""
    try:
        row = self.current_row
    except CellDoesNotExist:
        return
    row.toggle_select()
    self.force_refresh()

action_toggle_select_up() -> None

195
196
197
198
199
200
201
202
203
204
205

def action_toggle_select_up(self) -> None:
    """Toggle selection up."""
    try:
        row = self.current_row
        previous_row = row.previous
    except CellDoesNotExist:
        pass
    else:
        previous_row.toggle_select()
        self.move_cursor(row=previous_row.index)
        self.force_refresh()

add_rows(rows: Iterable[Iterable]) -> list[RowKey]

149
150
151
152
153
154

def add_rows(self, rows: Iterable[Iterable]) -> list[RowKey]:
    """Add rows.

    Automatically insert a column with checkboxes in position 0.
    """
    return super().add_rows((Checkbox(), *row) for row in rows)

clear(columns: bool = True) -> SelectableRowsDataTable

156
157
158
159
160
161
162
163
164

def clear(self, columns: bool = True) -> SelectableRowsDataTable:  # noqa: FBT001,FBT002
    """Clear rows and optionally columns.

    When clearing columns, automatically re-add a column for checkboxes.
    """
    super().clear(columns)
    if columns:
        self.add_column("", key="checkbox")
    return self

force_refresh() -> None

222
223
224
225
226
227

def force_refresh(self) -> None:
    """Force refresh table."""
    # HACK: Without such increment, the table is refreshed
    # only when focus changes to another column.
    self._update_count += 1
    self.refresh()