tksheet 7.4.4__py3-none-any.whl → 7.4.6__py3-none-any.whl

tksheet/other_classes.py

@@ -5,7 +5,7 @@ import tkinter as tk
 from collections import namedtuple
 from collections.abc import Callable, Hashable, Iterator
 from functools import partial
-from typing import Literal
+from typing import Any, Literal
 
 pickle_obj = partial(pickle.dumps, protocol=pickle.HIGHEST_PROTOCOL)
 
@@ -105,9 +105,7 @@ class SpanRange:
         return reversed(range(self.from_, self.upto_))
 
     def __contains__(self, n: int) -> bool:
-        if n >= self.from_ and n < self.upto_:
-            return True
-        return False
+        return n >= self.from_ and n < self.upto_
 
     def __eq__(self, v: SpanRange) -> bool:
         return self.from_ == v.from_ and self.upto_ == v.upto_
@@ -133,7 +131,7 @@ class DotDict(dict):
     def __setstate__(self, state: DotDict) -> None:
         self.update(state)
 
-    def __setitem__(self, key: Hashable, item: object) -> None:
+    def __setitem__(self, key: Hashable, item: Any) -> None:
         if type(item) is dict:  # noqa: E721
             super().__setitem__(key, DotDict(item))
         else:
@@ -167,13 +165,13 @@ class Span(dict):
     def __setstate__(self, state: Span) -> None:
         self.update(state)
 
-    def __getitem__(self, key: Hashable) -> object:
+    def __getitem__(self, key: Hashable) -> Any:
         if key == "data" or key == "value":
             return self["widget"].get_data(self)
         else:
             return super().__getitem__(key)
 
-    def __setitem__(self, key: Hashable, item: object) -> None:
+    def __setitem__(self, key: Hashable, item: Any) -> None:
         if key == "data" or key == "value":
             self["widget"].set_data(self, data=item)
         elif key == "bg":
@@ -189,11 +187,13 @@ class Span(dict):
 
     def format(
         self,
-        formatter_options: dict = {},
-        formatter_class: object = None,
+        formatter_options: dict | None = None,
+        formatter_class: Any = None,
         redraw: bool = True,
         **kwargs,
     ) -> Span:
+        if formatter_options is None:
+            formatter_options = {}
         return self["widget"].format(
             self,
             formatter_options={"formatter": formatter_class, **formatter_options, **kwargs},
@@ -232,10 +232,10 @@ class Span(dict):
 
     def dropdown(
         self,
-        values: list = [],
+        values: list[Any] | None = None,
         edit_data: bool = True,
-        set_values: dict[tuple[int, int], object] = {},
-        set_value: object = None,
+        set_values: dict[tuple[int, int], Any] | None = None,
+        set_value: Any = None,
         state: str = "normal",
         redraw: bool = True,
         selection_function: Callable | None = None,
@@ -246,9 +246,9 @@ class Span(dict):
     ) -> Span:
         return self["widget"].dropdown(
             self,
-            values=values,
+            values=[] if values is None else values,
             edit_data=edit_data,
-            set_values=set_values,
+            set_values={} if set_values is None else set_values,
             set_value=set_value,
             state=state,
             redraw=redraw,
@@ -327,7 +327,7 @@ class Span(dict):
         convert: Callable | None = None,
         undo: bool | None = None,
         emit_event: bool | None = None,
-        widget: object = None,
+        widget: Any = None,
         expand: str | None = None,
         formatter_options: dict | None = None,
         **kwargs,
@@ -406,19 +406,13 @@ class Span(dict):
     @property
     def rows(self) -> SpanRange:
         rng_from_r = 0 if self["from_r"] is None else self["from_r"]
-        if self["upto_r"] is None:
-            rng_upto_r = self["widget"].total_rows()
-        else:
-            rng_upto_r = self["upto_r"]
+        rng_upto_r = self["widget"].total_rows() if self["upto_r"] is None else self["upto_r"]
         return SpanRange(rng_from_r, rng_upto_r)
 
     @property
     def columns(self) -> SpanRange:
         rng_from_c = 0 if self["from_c"] is None else self["from_c"]
-        if self["upto_c"] is None:
-            rng_upto_c = self["widget"].total_columns()
-        else:
-            rng_upto_c = self["upto_c"]
+        rng_upto_c = self["widget"].total_columns() if self["upto_c"] is None else self["upto_c"]
         return SpanRange(rng_from_c, rng_upto_c)
 
     @property
@@ -510,7 +504,7 @@ class EditorStorageBase(StorageBase):
         self.highlight_from(index, line, column)
 
     @property
-    def tktext(self) -> object:
+    def tktext(self) -> Any:
         if self.window:
             return self.window.tktext
         return self.window
@@ -543,7 +537,7 @@ class ProgressBar:
     def __len__(self):
         return 2
 
-    def __getitem__(self, key: Hashable) -> object:
+    def __getitem__(self, key: Hashable) -> Any:
         if key == 0:
             return self.bg
         elif key == 1:

tksheet/row_index.py

@@ -7,7 +7,7 @@ from functools import partial
 from itertools import chain, cycle, islice, repeat
 from math import ceil, floor
 from operator import itemgetter
-from typing import Literal
+from typing import Any, Literal
 
 from .colors import color_map
 from .constants import (
@@ -91,7 +91,7 @@ class RowIndex(tk.Canvas):
         self.rc_delete_row_enabled = False
         self.edit_cell_enabled = False
         self.visible_row_dividers = {}
-        self.row_width_resize_bbox = tuple()
+        self.row_width_resize_bbox = ()
         self.rsz_w = None
         self.rsz_h = None
         self.currently_resizing_width = False
@@ -160,7 +160,7 @@ class RowIndex(tk.Canvas):
             self.MT.recreate_all_selection_boxes()
         self.current_width = new_width
 
-    def rc(self, event: object) -> None:
+    def rc(self, event: Any) -> None:
         self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
         self.focus_set()
         popup_menu = None
@@ -187,7 +187,7 @@ class RowIndex(tk.Canvas):
             self.popup_menu_loc = r
             popup_menu.tk_popup(event.x_root, event.y_root)
 
-    def ctrl_b1_press(self, event: object) -> None:
+    def ctrl_b1_press(self, event: Any) -> None:
         self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
         if (
             (self.drag_and_drop_enabled or self.row_selection_enabled)
@@ -210,7 +210,7 @@ class RowIndex(tk.Canvas):
         elif not self.MT.ctrl_select_enabled:
             self.b1_press(event)
 
-    def ctrl_shift_b1_press(self, event: object) -> None:
+    def ctrl_shift_b1_press(self, event: Any) -> None:
         self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
         y = event.y
         r = self.MT.identify_row(y=y)
@@ -246,31 +246,35 @@ class RowIndex(tk.Canvas):
         elif not self.MT.ctrl_select_enabled:
             self.shift_b1_press(event)
 
-    def shift_b1_press(self, event: object) -> None:
+    def shift_b1_press(self, event: Any) -> None:
         self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
         r = self.MT.identify_row(y=event.y)
-        if (self.drag_and_drop_enabled or self.row_selection_enabled) and self.rsz_h is None and self.rsz_w is None:
-            if r < len(self.MT.row_positions) - 1:
-                r_selected = self.MT.row_selected(r)
-                if not r_selected and self.row_selection_enabled:
-                    if self.MT.selected and self.MT.selected.type_ == "rows":
-                        r_to_sel, c_to_sel = self.MT.selected.row, self.MT.selected.column
-                        self.MT.deselect("all", redraw=False)
-                        self.being_drawn_item = self.MT.create_selection_box(
-                            *self.get_shift_select_box(r, r_to_sel), "rows"
-                        )
-                        self.MT.set_currently_selected(r_to_sel, c_to_sel, self.being_drawn_item)
-                    else:
-                        self.being_drawn_item = self.select_row(r, run_binding_func=False)
-                    self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
-                    sel_event = self.MT.get_select_event(being_drawn_item=self.being_drawn_item)
-                    try_binding(self.shift_selection_binding_func, sel_event)
-                    self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
-                elif r_selected:
-                    self.dragged_row = DraggedRowColumn(
-                        dragged=r,
-                        to_move=sorted(self.MT.get_selected_rows()),
+        if (
+            (self.drag_and_drop_enabled or self.row_selection_enabled)
+            and self.rsz_h is None
+            and self.rsz_w is None
+            and r < len(self.MT.row_positions) - 1
+        ):
+            r_selected = self.MT.row_selected(r)
+            if not r_selected and self.row_selection_enabled:
+                if self.MT.selected and self.MT.selected.type_ == "rows":
+                    r_to_sel, c_to_sel = self.MT.selected.row, self.MT.selected.column
+                    self.MT.deselect("all", redraw=False)
+                    self.being_drawn_item = self.MT.create_selection_box(
+                        *self.get_shift_select_box(r, r_to_sel), "rows"
                     )
+                    self.MT.set_currently_selected(r_to_sel, c_to_sel, self.being_drawn_item)
+                else:
+                    self.being_drawn_item = self.select_row(r, run_binding_func=False)
+                self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
+                sel_event = self.MT.get_select_event(being_drawn_item=self.being_drawn_item)
+                try_binding(self.shift_selection_binding_func, sel_event)
+                self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
+            elif r_selected:
+                self.dragged_row = DraggedRowColumn(
+                    dragged=r,
+                    to_move=sorted(self.MT.get_selected_rows()),
+                )
 
     def get_shift_select_box(self, r: int, min_r: int) -> tuple[int, int, int, int, str]:
         if r >= min_r:
@@ -313,7 +317,7 @@ class RowIndex(tk.Canvas):
             if x >= x1 and y >= y1 and x <= x2 and y <= y2:
                 return r
 
-    def mouse_motion(self, event: object) -> None:
+    def mouse_motion(self, event: Any) -> None:
         if not self.currently_resizing_height and not self.currently_resizing_width:
             x = self.canvasx(event.x)
             y = self.canvasy(event.y)
@@ -354,17 +358,16 @@ class RowIndex(tk.Canvas):
                         self.rsz_w = None
                 except Exception:
                     self.rsz_w = None
-            if not mouse_over_resize:
-                if self.MT.row_selected(self.MT.identify_row(event, allow_end=False)):
-                    mouse_over_selected = True
-                    if self.MT.current_cursor != "hand2":
-                        self.config(cursor="hand2")
-                        self.MT.current_cursor = "hand2"
+            if not mouse_over_resize and self.MT.row_selected(self.MT.identify_row(event, allow_end=False)):
+                mouse_over_selected = True
+                if self.MT.current_cursor != "hand2":
+                    self.config(cursor="hand2")
+                    self.MT.current_cursor = "hand2"
             if not mouse_over_resize and not mouse_over_selected:
                 self.MT.reset_mouse_motion_creations()
         try_binding(self.extra_motion_func, event)
 
-    def double_b1(self, event: object):
+    def double_b1(self, event: Any):
         self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
         self.focus_set()
         if (
@@ -410,7 +413,7 @@ class RowIndex(tk.Canvas):
         self.mouse_motion(event)
         try_binding(self.extra_double_b1_func, event)
 
-    def b1_press(self, event: object):
+    def b1_press(self, event: Any):
         self.MT.unbind("<MouseWheel>")
         self.focus_set()
         self.closed_dropdown = self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
@@ -479,7 +482,7 @@ class RowIndex(tk.Canvas):
                         self.toggle_select_row(r, redraw=True)
         try_binding(self.extra_b1_press_func, event)
 
-    def b1_motion(self, event: object):
+    def b1_motion(self, event: Any):
         x1, y1, x2, y2 = self.MT.get_canvas_visible_area()
         if self.height_resizing_enabled and self.rsz_h is not None and self.currently_resizing_height:
             y = self.canvasy(event.y)
@@ -578,7 +581,7 @@ class RowIndex(tk.Canvas):
         elif end_row < start_row:
             return end_row, 0, start_row + 1, len(self.MT.col_positions) - 1, "rows"
 
-    def ctrl_b1_motion(self, event: object) -> None:
+    def ctrl_b1_motion(self, event: Any) -> None:
         x1, y1, x2, y2 = self.MT.get_canvas_visible_area()
         if (
             self.drag_and_drop_enabled
@@ -632,7 +635,7 @@ class RowIndex(tk.Canvas):
         elif not self.MT.ctrl_select_enabled:
             self.b1_motion(event)
 
-    def drag_and_drop_motion(self, event: object) -> float:
+    def drag_and_drop_motion(self, event: Any) -> float:
         y = event.y
         hend = self.winfo_height()
         ycheck = self.yview()
@@ -700,7 +703,7 @@ class RowIndex(tk.Canvas):
         if ctrl_lines:
             self.MT.delete_ctrl_outlines()
 
-    def scroll_if_event_offscreen(self, event: object) -> bool:
+    def scroll_if_event_offscreen(self, event: Any) -> bool:
         ycheck = self.yview()
         need_redraw = False
         if event.y > self.winfo_height() and len(ycheck) > 1 and ycheck[1] < 1:
@@ -730,14 +733,14 @@ class RowIndex(tk.Canvas):
         if len(ycheck) > 1 and ycheck[1] > 1:
             self.MT.set_yviews("moveto", 1)
 
-    def event_over_dropdown(self, r: int, datarn: int, event: object, canvasy: float) -> bool:
+    def event_over_dropdown(self, r: int, datarn: int, event: Any, canvasy: float) -> bool:
         return (
             canvasy < self.MT.row_positions[r] + self.MT.index_txt_height
             and self.get_cell_kwargs(datarn, key="dropdown")
             and event.x > self.current_width - self.MT.index_txt_height - 4
         )
 
-    def event_over_checkbox(self, r: int, datarn: int, event: object, canvasy: float) -> bool:
+    def event_over_checkbox(self, r: int, datarn: int, event: Any, canvasy: float) -> bool:
         return (
             canvasy < self.MT.row_positions[r] + self.MT.index_txt_height
             and self.get_cell_kwargs(datarn, key="checkbox")
@@ -774,7 +777,7 @@ class RowIndex(tk.Canvas):
                 )
             )
 
-    def b1_release(self, event: object) -> None:
+    def b1_release(self, event: Any) -> None:
         to_hide = self.being_drawn_item
         if self.being_drawn_item is not None and (to_sel := self.MT.coords_and_type(self.being_drawn_item)):
             r_to_sel, c_to_sel = self.MT.selected.row, self.MT.selected.column
@@ -1231,7 +1234,7 @@ class RowIndex(tk.Canvas):
     def set_width_of_index_to_text(
         self,
         text: None | str = None,
-        only_rows: list = [],
+        only_rows: list[int] | None = None,
     ) -> int:
         self.fix_index()
         w = self.ops.default_row_index_width
@@ -1245,7 +1248,7 @@ class RowIndex(tk.Canvas):
             if (tw := b[2] - b[0] + 10) > w:
                 w = tw
         elif text is None:
-            w = self.get_index_text_width(only_rows=only_rows)
+            w = self.get_index_text_width(only_rows=[] if only_rows is None else only_rows)
         if w > self.ops.max_index_width:
             w = int(self.ops.max_index_width)
         self.set_width(w, set_TL=True)
@@ -1641,9 +1644,8 @@ class RowIndex(tk.Canvas):
         row_pos_exists: bool,
         set_scrollregion: bool,
     ) -> bool:
-        if set_scrollregion:
-            if not self.configure_scrollregion(last_row_line_pos=last_row_line_pos):
-                return False
+        if set_scrollregion and not self.configure_scrollregion(last_row_line_pos=last_row_line_pos):
+            return False
         self.hidd_text.update(self.disp_text)
         self.disp_text = {}
         self.hidd_high.update(self.disp_high)
@@ -1910,7 +1912,7 @@ class RowIndex(tk.Canvas):
                     d[box.type_ if box.type_ != "columns" else "cells"].add(r)
         return d
 
-    def open_cell(self, event: object = None, ignore_existing_editor: bool = False) -> None:
+    def open_cell(self, event: Any = None, ignore_existing_editor: bool = False) -> None:
         if not self.MT.anything_selected() or (not ignore_existing_editor and self.text_editor.open):
             return
         if not self.MT.selected:
@@ -1940,7 +1942,7 @@ class RowIndex(tk.Canvas):
     # r is displayed row
     def open_text_editor(
         self,
-        event: object = None,
+        event: Any = None,
         r: int = 0,
         text: None | str = None,
         state: str = "normal",
@@ -1983,7 +1985,7 @@ class RowIndex(tk.Canvas):
             self.text_editor.set_text(self.text_editor.get() + "" if not isinstance(text, str) else text)
             return False
         self.hide_text_editor()
-        if not self.MT.see(r=r, c=0, keep_yscroll=True, check_cell_visibility=True):
+        if not self.MT.see(r, 0, keep_yscroll=True):
             self.MT.main_table_redraw_grid_and_text(True, True)
         x = 0
         y = self.MT.row_positions[r]
@@ -2033,7 +2035,7 @@ class RowIndex(tk.Canvas):
             self.text_editor.tktext.bind(key, func)
         return True
 
-    def text_editor_newline_binding(self, event: object = None, check_lines: bool = True) -> None:
+    def text_editor_newline_binding(self, event: Any = None, check_lines: bool = True) -> None:
         if not self.height_resizing_enabled:
             return
         curr_height = self.text_editor.window.winfo_height()
@@ -2230,7 +2232,7 @@ class RowIndex(tk.Canvas):
         self.text_editor.autocomplete(self.dropdown.window.search_and_see(event_data))
         return "break"
 
-    def open_dropdown_window(self, r: int, event: object = None) -> None:
+    def open_dropdown_window(self, r: int, event: Any = None) -> None:
         self.hide_text_editor()
         kwargs = self.get_cell_kwargs(self.MT.datarn(r), key="dropdown")
         if kwargs["state"] == "disabled":
@@ -2308,7 +2310,7 @@ class RowIndex(tk.Canvas):
     def close_dropdown_window(
         self,
         r: int | None = None,
-        selection: object = None,
+        selection: Any = None,
         redraw: bool = True,
     ) -> None:
         if r is not None and selection is not None:
@@ -2415,7 +2417,7 @@ class RowIndex(tk.Canvas):
             self.MT.sheet_modified(event_data)
         return edited
 
-    def set_cell_data(self, datarn: int | None = None, value: object = "") -> None:
+    def set_cell_data(self, datarn: int | None = None, value: Any = "") -> None:
         if isinstance(self.MT._row_index, int):
             self.MT.set_cell_data(datarn=datarn, datacn=self.MT._row_index, value=value)
         else:
@@ -2427,20 +2429,21 @@ class RowIndex(tk.Canvas):
             else:
                 self.MT._row_index[datarn] = value
 
-    def input_valid_for_cell(self, datarn: int, value: object, check_readonly: bool = True) -> bool:
+    def input_valid_for_cell(self, datarn: int, value: Any, check_readonly: bool = True) -> bool:
         kwargs = self.get_cell_kwargs(datarn, key=None)
         if check_readonly and "readonly" in kwargs:
             return False
         elif "checkbox" in kwargs:
             return is_bool_like(value)
-        elif self.cell_equal_to(datarn, value):
-            return False
-        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and value not in kwargs["values"]:
-            return False
         else:
-            return True
+            return not (
+                self.cell_equal_to(datarn, value)
+                or (kwargs := kwargs.get("dropdown", {}))
+                and kwargs["validate_input"]
+                and value not in kwargs["values"]
+            )
 
-    def cell_equal_to(self, datarn: int, value: object) -> bool:
+    def cell_equal_to(self, datarn: int, value: Any) -> bool:
         self.fix_index(datarn)
         if isinstance(self.MT._row_index, list):
             return self.MT._row_index[datarn] == value
@@ -2453,7 +2456,7 @@ class RowIndex(tk.Canvas):
         get_displayed: bool = False,
         none_to_empty_str: bool = False,
         redirect_int: bool = False,
-    ) -> object:
+    ) -> Any:
         if get_displayed:
             return self.get_valid_cell_data_as_str(datarn, fix=False)
         if redirect_int and isinstance(self.MT._row_index, int):  # internal use
@@ -2496,7 +2499,7 @@ class RowIndex(tk.Canvas):
             value = get_n2a(datarn, self.ops.default_row_index)
         return value
 
-    def get_value_for_empty_cell(self, datarn: int, r_ops: bool = True) -> object:
+    def get_value_for_empty_cell(self, datarn: int, r_ops: bool = True) -> Any:
         if self.ops.treeview:
             iid = self.new_iid()
             return Node(text=iid, iid=iid, parent=self.get_row_parent(datarn))
@@ -2508,7 +2511,7 @@ class RowIndex(tk.Canvas):
         else:
             return ""
 
-    def get_empty_index_seq(self, end: int, start: int = 0, r_ops: bool = True) -> list[object]:
+    def get_empty_index_seq(self, end: int, start: int = 0, r_ops: bool = True) -> list[Any]:
         return [self.get_value_for_empty_cell(datarn, r_ops=r_ops) for datarn in range(start, end)]
 
     def fix_index(self, datarn: int | None = None) -> None:
@@ -2683,12 +2686,10 @@ class RowIndex(tk.Canvas):
                         else:
                             move_to_index = len(self.tree[new_parent].children)
                         move_to_row = self.tree_rns[new_parent]
-                        if new_parent == self.tree[item].parent:
-                            move_to_index += 1
-                        for i, ciid in enumerate(self.tree[new_parent].children):
-                            if i == move_to_index:
-                                break
-                            move_to_row += sum(1 for _ in self.get_iid_descendants(ciid)) + 1
+                        _find = move_to_index + 1 if new_parent == self.tree[item].parent else move_to_index
+                        move_to_row += _find + sum(
+                            self.num_descendants(cid) for cid in islice(self.tree[new_parent].children, _find)
+                        )
                         insert_row = move_to_row + 1
                     else:
                         num_top_nodes = sum(1 for _ in self.gen_top_nodes())
@@ -2708,7 +2709,7 @@ class RowIndex(tk.Canvas):
                     disp_insert_row = None
 
                 else:
-                    iids = set(self.MT._row_index[r].iid for r in event_data["moved"]["rows"]["data"])
+                    iids = {self.MT._row_index[r].iid for r in event_data["moved"]["rows"]["data"]}
                     iids_descendants = {iid: set(self.get_iid_descendants(iid)) for iid in iids}
 
                     # remove descendants in iids to move
@@ -2730,10 +2731,7 @@ class RowIndex(tk.Canvas):
                         # max_from = max(event_data.moved.rows)
                         min_to = min(event_data["moved"]["rows"]["data"].values())
                         max_to = max(event_data["moved"]["rows"]["data"].values())
-                        if min_from <= min_to:
-                            insert_row = max_to
-                        else:
-                            insert_row = min_to
+                        insert_row = max_to if min_from <= min_to else min_to
                         move_to_iid = self.MT._row_index[insert_row].iid
 
                     move_to_index = self.PAR.index(move_to_iid)
@@ -2755,7 +2753,7 @@ class RowIndex(tk.Canvas):
                     if (disp_from_row := self.MT.try_disprn(self.tree_rns[item])) is not None:
                         event_data["moved"]["rows"]["displayed"] = {disp_from_row: disp_insert_row}
                     else:
-                        event_data["moved"]["rows"]["displayed"] = {tuple(): disp_insert_row}
+                        event_data["moved"]["rows"]["displayed"] = {(): disp_insert_row}
 
                 if any(self.move_pid_causes_recursive_loop(self.MT._row_index[r].iid, new_parent) for r in moved_rows):
                     event_data["moved"]["rows"] = {}
@@ -2778,8 +2776,8 @@ class RowIndex(tk.Canvas):
                     data_new_idxs = event_data["moved"]["rows"]["data"]
                     data_old_idxs = dict(zip(data_new_idxs.values(), data_new_idxs))
 
-                    if tuple() in event_data["moved"]["rows"]["displayed"]:
-                        del event_data["moved"]["rows"]["displayed"][tuple()]
+                    if () in event_data["moved"]["rows"]["displayed"]:
+                        del event_data["moved"]["rows"]["displayed"][()]
 
                     if event_data["moved"]["rows"]["displayed"]:
                         event_data["moved"]["rows"]["displayed"] = get_new_indexes(
@@ -2848,7 +2846,7 @@ class RowIndex(tk.Canvas):
         row_ctr = next(reversed(mapping.values())) + 1
 
         if disp_mapping := event_data["moved"]["rows"]["displayed"]:
-            if tuple() in disp_mapping:
+            if () in disp_mapping:
                 disp_row_ctr = next(reversed(disp_mapping.values()))
             else:
                 disp_row_ctr = next(reversed(disp_mapping.values())) + 1
@@ -2907,24 +2905,48 @@ class RowIndex(tk.Canvas):
 
     def ancestors_all_open(self, iid: str, stop_at: str = "") -> bool:
         if stop_at:
-            for iid in self.get_iid_ancestors(iid):
-                if iid == stop_at:
+            for i in self.get_iid_ancestors(iid):
+                if i == stop_at:
                     return True
-                elif iid not in self.tree_open_ids:
+                elif i not in self.tree_open_ids:
                     return False
             return True
         return all(map(self.tree_open_ids.__contains__, self.get_iid_ancestors(iid)))
 
     def get_iid_ancestors(self, iid: str) -> Generator[str]:
-        if self.tree[iid].parent:
-            yield self.tree[iid].parent
-            yield from self.get_iid_ancestors(self.tree[iid].parent)
+        current_iid = iid
+        while self.tree[current_iid].parent:
+            parent_iid = self.tree[current_iid].parent
+            yield parent_iid
+            current_iid = parent_iid
 
     def get_iid_descendants(self, iid: str, check_open: bool = False) -> Generator[str]:
-        for ciid in self.tree[iid].children:
-            yield ciid
-            if self.tree[ciid].children and (not check_open or ciid in self.tree_open_ids):
-                yield from self.get_iid_descendants(ciid, check_open)
+        tree = self.tree
+        stack = [iter(tree[iid].children)]
+        while stack:
+            top_iterator = stack[-1]
+            try:
+                ciid = next(top_iterator)
+                yield ciid
+                if tree[ciid].children and (not check_open or ciid in self.tree_open_ids):
+                    stack.append(iter(tree[ciid].children))
+            except StopIteration:
+                stack.pop()
+
+    def num_descendants(self, iid: str) -> int:
+        tree = self.tree
+        stack = [iter(tree[iid].children)]
+        num = 0
+        while stack:
+            top_iterator = stack[-1]
+            try:
+                ciid = next(top_iterator)
+                num += 1
+                if tree[ciid].children:
+                    stack.append(iter(tree[ciid].children))
+            except StopIteration:
+                stack.pop()
+        return num
 
     def items_parent(self, iid: str) -> str:
         if self.tree[iid].parent:
@@ -2976,7 +2998,7 @@ class RowIndex(tk.Canvas):
 
     def tree_build(
         self,
-        data: list[list[object]],
+        data: list[list[Any]],
         iid_column: int,
         parent_column: int,
         text_column: None | int | list[str] = None,
@@ -3086,5 +3108,5 @@ class RowIndex(tk.Canvas):
                 {self.tree_rns[iid] for iid in self.PAR.get_children() if self.tree[iid].parent},
                 deselect_all=False,
                 data_indexes=True,
-                row_heights=False if row_heights is False else True,
+                row_heights=row_heights is not False,
             )