tksheet 7.4.8__py3-none-any.whl → 7.4.10__py3-none-any.whl

tksheet/sheet.py

@@ -87,7 +87,7 @@ from .themes import (
     theme_light_blue,
     theme_light_green,
 )
-from .tksheet_types import AnyIter, Binding, CellPropertyKey, CreateSpanTypes, ExtraBinding
+from .tksheet_types import Binding, CellPropertyKey, CreateSpanTypes, ExtraBinding
 from .top_left_rectangle import TopLeftRectangle
 
 
@@ -543,7 +543,7 @@ class Sheet(tk.Frame):
     def set_header_data(
         self,
         value: Any,
-        c: int | None | AnyIter[int] = None,
+        c: int | None | Iterator[int] = None,
         redraw: bool = True,
     ) -> Sheet:
         if c is None:
@@ -579,7 +579,7 @@ class Sheet(tk.Frame):
     def set_index_data(
         self,
         value: Any,
-        r: int | None | AnyIter[int] = None,
+        r: int | None | Iterator[int] = None,
         redraw: bool = True,
     ) -> Sheet:
         if r is None:
@@ -1048,7 +1048,7 @@ class Sheet(tk.Frame):
     def get_data(self, *key: CreateSpanTypes) -> Any:
         """
         e.g. retrieves entire table as pandas dataframe
-        sheet["A1"].expand().options(pandas.DataFrame).data
+        sheet["A1"].expand().options(convert=pandas.DataFrame).data
 
         must deal with
         - format
@@ -1107,56 +1107,48 @@ class Sheet(tk.Frame):
         """
         span = self.span_from_key(*key)
         rows, cols = self.ranges_from_span(span)
-        tdisp, idisp, hdisp = span.tdisp, span.idisp, span.hdisp
         table, index, header = span.table, span.index, span.header
         fmt_kw = span.kwargs if span.type_ == "format" and span.kwargs else None
-        quick_tdata, quick_idata, quick_hdata = self.MT.get_cell_data, self.RI.get_cell_data, self.CH.get_cell_data
+        t_data = partial(self.MT.get_cell_data, get_displayed=True) if span.tdisp else self.MT.get_cell_data
+        i_data = self.RI.cell_str if span.idisp else self.RI.get_cell_data
+        h_data = self.CH.cell_str if span.hdisp else self.CH.get_cell_data
         res = []
         if span.transposed:
+            # Index row (first row when transposed)
             if index:
-                if index and header:
-                    if table:
-                        res.append([""] + [quick_idata(r, get_displayed=idisp) for r in rows])
-                    else:
-                        res.append([quick_idata(r, get_displayed=idisp) for r in rows])
-                else:
-                    res.append([quick_idata(r, get_displayed=idisp) for r in rows])
+                index_row = [""] if header and table else []
+                index_row.extend(i_data(r) for r in rows)
+                res.append(index_row)
+            # Header and/or table data as columns
             if header:
-                if table:
-                    res.extend(
-                        [quick_hdata(c, get_displayed=hdisp)]
-                        + [quick_tdata(r, c, get_displayed=tdisp, fmt_kw=fmt_kw) for r in rows]
-                        for c in cols
-                    )
-                else:
-                    res.extend([quick_hdata(c, get_displayed=hdisp)] for c in cols)
+                for c in cols:
+                    col = [h_data(c)]
+                    if table:
+                        col.extend(t_data(r, c, fmt_kw=fmt_kw) for r in rows)
+                    res.append(col)
             elif table:
-                res.extend([quick_tdata(r, c, get_displayed=tdisp, fmt_kw=fmt_kw) for r in rows] for c in cols)
-        elif not span.transposed:
+                res.extend([t_data(r, c, fmt_kw=fmt_kw) for r in rows] for c in cols)
+        else:
+            # Header row
             if header:
-                if header and index:
-                    if table:
-                        res.append([""] + [quick_hdata(c, get_displayed=hdisp) for c in cols])
-                    else:
-                        res.append([quick_hdata(c, get_displayed=hdisp) for c in cols])
-                else:
-                    res.append([quick_hdata(c, get_displayed=hdisp) for c in cols])
+                header_row = [""] if index and table else []
+                header_row.extend(h_data(c) for c in cols)
+                res.append(header_row)
+            # Index and/or table data as rows
             if index:
-                if table:
-                    res.extend(
-                        [quick_idata(r, get_displayed=idisp)]
-                        + [quick_tdata(r, c, get_displayed=tdisp, fmt_kw=fmt_kw) for c in cols]
-                        for r in rows
-                    )
-                else:
-                    res.extend([quick_idata(r, get_displayed=idisp)] for r in rows)
+                for r in rows:
+                    row = [i_data(r)]
+                    if table:
+                        row.extend(t_data(r, c, fmt_kw=fmt_kw) for c in cols)
+                    res.append(row)
             elif table:
-                res.extend([quick_tdata(r, c, get_displayed=tdisp, fmt_kw=fmt_kw) for c in cols] for r in rows)
+                res.extend([t_data(r, c, fmt_kw=fmt_kw) for c in cols] for r in rows)
+
         if not span.ndim:
             # it's a cell
             if len(res) == 1 and len(res[0]) == 1:
                 res = res[0][0]
-            # it's a single list
+            # it's a single sublist
             elif len(res) == 1:
                 res = res[0]
             # retrieving a list of index cells or
@@ -1168,11 +1160,12 @@ class Sheet(tk.Frame):
         elif span.ndim == 1:
             # flatten sublists
             res = res[0] if len(res) == 1 and len(res[0]) == 1 else list(chain.from_iterable(res))
-        # if span.ndim == 2 res keeps its current
-        # dimensions as a list of lists
-        if span.convert is not None:
+        # if span.ndim == 2 res keeps its current dimensions as a list of lists
+
+        if span.convert is None:
+            return res
+        else:
             return span.convert(res)
-        return res
 
     def get_total_rows(self, include_index: bool = False) -> int:
         return self.MT.total_data_rows(include_index=include_index)
@@ -1308,6 +1301,7 @@ class Sheet(tk.Frame):
         undo: bool | None = None,
         emit_event: bool | None = None,
         redraw: bool = True,
+        event_data: EventDataDict | None = None,
     ) -> EventDataDict:
         """
         e.g.
@@ -1364,12 +1358,13 @@ class Sheet(tk.Frame):
         fmt_kw = span.kwargs if span.type_ == "format" and span.kwargs else None
         transposed = span.transposed
         maxr, maxc = startr, startc
-        event_data = event_dict(
-            name="edit_table",
-            sheet=self.name,
-            widget=self,
-            selected=self.MT.selected,
-        )
+        if event_data is None:
+            event_data = event_dict(
+                name="edit_table",
+                sheet=self.name,
+                widget=self,
+                selected=self.MT.selected,
+            )
         set_t = self.event_data_set_table_cell
         set_i, set_h = self.event_data_set_index_cell, self.event_data_set_header_cell
         istart = 1 if index else 0
@@ -1540,28 +1535,32 @@ class Sheet(tk.Frame):
                 event_data = set_h(startc, data, event_data)
         # add row/column lines (positions) if required
         if self.MT.all_columns_displayed and maxc >= (ncols := len(self.MT.col_positions) - 1):
+            _, _, widths = self.MT.get_args_for_add_columns(
+                data_ins_col=len(self.MT.col_positions) - 1,
+                displayed_ins_col=len(self.MT.col_positions) - 1,
+                columns=maxc + 1 - ncols,
+                widths=None,
+                headers=False,
+            )
             event_data = self.MT.add_columns(
-                *self.MT.get_args_for_add_columns(
-                    data_ins_col=len(self.MT.col_positions) - 1,
-                    displayed_ins_col=len(self.MT.col_positions) - 1,
-                    numcols=maxc + 1 - ncols,
-                    columns=[],
-                    widths=None,
-                    headers=False,
-                ),
+                columns={},
+                header={},
+                column_widths=widths,
                 event_data=event_data,
                 create_selections=False,
             )
         if self.MT.all_rows_displayed and maxr >= (nrows := len(self.MT.row_positions) - 1):
+            _, _, heights = self.MT.get_args_for_add_rows(
+                data_ins_row=len(self.MT.row_positions) - 1,
+                displayed_ins_row=len(self.MT.row_positions) - 1,
+                rows=maxr + 1 - nrows,
+                heights=None,
+                row_index=False,
+            )
             event_data = self.MT.add_rows(
-                *self.MT.get_args_for_add_rows(
-                    data_ins_row=len(self.MT.row_positions) - 1,
-                    displayed_ins_row=len(self.MT.row_positions) - 1,
-                    numrows=maxr + 1 - nrows,
-                    rows=[],
-                    heights=None,
-                    row_index=False,
-                ),
+                rows={},
+                index={},
+                row_heights=heights,
                 event_data=event_data,
                 create_selections=False,
             )
@@ -1703,7 +1702,7 @@ class Sheet(tk.Frame):
 
     def insert_rows(
         self,
-        rows: list[tuple[Any] | list[Any]] | tuple[tuple[Any] | list[Any]] | int = 1,
+        rows: Iterator[list[Any]] | int = 1,
         idx: str | int | None = None,
         heights: list[int] | tuple[int] | None = None,
         row_index: bool = False,
@@ -1722,34 +1721,10 @@ class Sheet(tk.Frame):
         if isinstance(rows, int):
             if rows < 1:
                 raise ValueError(f"rows arg must be greater than 0, not {rows}")
-            total_cols = self.MT.total_data_cols()
-            if row_index:
-                data = [
-                    [self.RI.get_value_for_empty_cell(idx + i, r_ops=False)]
-                    + self.MT.get_empty_row_seq(
-                        idx + i,
-                        total_cols,
-                        r_ops=False,
-                        c_ops=False,
-                    )
-                    for i in range(rows)
-                ]
-            else:
-                data = [
-                    self.MT.get_empty_row_seq(
-                        idx + i,
-                        total_cols,
-                        r_ops=False,
-                        c_ops=False,
-                    )
-                    for i in range(rows)
-                ]
-        else:
-            data = rows
-        if not isinstance(rows, int) and fill:
+        elif fill:
             total_cols = self.MT.total_data_cols() if total_cols is None else total_cols
             len_check = (total_cols + 1) if row_index else total_cols
-            for rn, r in enumerate(data):
+            for rn, r in enumerate(rows):
                 if len_check > (lnr := len(r)):
                     r += self.MT.get_empty_row_seq(
                         rn,
@@ -1758,14 +1733,11 @@ class Sheet(tk.Frame):
                         r_ops=False,
                         c_ops=False,
                     )
-        numrows = len(data)
-        displayed_ins_idx = idx if self.MT.all_rows_displayed else bisect_left(self.MT.displayed_rows, idx)
         event_data = self.MT.add_rows(
             *self.MT.get_args_for_add_rows(
                 data_ins_row=idx,
-                displayed_ins_row=displayed_ins_idx,
-                numrows=numrows,
-                rows=data,
+                displayed_ins_row=idx if self.MT.all_rows_displayed else bisect_left(self.MT.displayed_rows, idx),
+                rows=rows,
                 heights=heights,
                 row_index=row_index,
             ),
@@ -1784,7 +1756,7 @@ class Sheet(tk.Frame):
 
     def insert_columns(
         self,
-        columns: list[tuple[Any] | list[Any]] | tuple[tuple[Any] | list[Any]] | int = 1,
+        columns: Iterator[list[Any]] | int = 1,
         idx: str | int | None = None,
         widths: list[int] | tuple[int] | None = None,
         headers: bool = False,
@@ -1803,60 +1775,24 @@ class Sheet(tk.Frame):
         if isinstance(columns, int):
             if columns < 1:
                 raise ValueError(f"columns arg must be greater than 0, not {columns}")
-            if headers:
-                data = [
-                    [self.CH.get_value_for_empty_cell(datacn, c_ops=False)]
-                    + [
-                        self.MT.get_value_for_empty_cell(
-                            datarn,
-                            datacn,
-                            r_ops=False,
-                            c_ops=False,
-                        )
-                        for datarn in range(total_rows)
-                    ]
-                    for datacn in range(idx, idx + columns)
-                ]
-            else:
-                data = [
-                    [
+        elif fill:
+            len_check = (total_rows + 1) if headers else total_rows
+            for i, column in enumerate(columns):
+                if (col_len := len(column)) < len_check:
+                    column += [
                         self.MT.get_value_for_empty_cell(
-                            datarn,
-                            datacn,
+                            r,
+                            idx + i,
                             r_ops=False,
                             c_ops=False,
                         )
-                        for datarn in range(total_rows)
+                        for r in range((col_len - 1) if headers else col_len, total_rows)
                     ]
-                    for datacn in range(idx, idx + columns)
-                ]
-            numcols = columns
-        else:
-            data = columns
-            numcols = len(columns)
-            if fill:
-                len_check = (total_rows + 1) if headers else total_rows
-                for i, column in enumerate(data):
-                    if (col_len := len(column)) < len_check:
-                        column += [
-                            self.MT.get_value_for_empty_cell(
-                                r,
-                                idx + i,
-                                r_ops=False,
-                                c_ops=False,
-                            )
-                            for r in range((col_len - 1) if headers else col_len, total_rows)
-                        ]
-        if self.MT.all_columns_displayed:
-            displayed_ins_idx = idx
-        elif not self.MT.all_columns_displayed:
-            displayed_ins_idx = bisect_left(self.MT.displayed_columns, idx)
         event_data = self.MT.add_columns(
             *self.MT.get_args_for_add_columns(
                 data_ins_col=idx,
-                displayed_ins_col=displayed_ins_idx,
-                numcols=numcols,
-                columns=data,
+                displayed_ins_col=idx if self.MT.all_columns_displayed else bisect_left(self.MT.displayed_columns, idx),
+                columns=columns,
                 widths=widths,
                 headers=headers,
             ),
@@ -1874,7 +1810,7 @@ class Sheet(tk.Frame):
 
     def del_rows(
         self,
-        rows: int | AnyIter[int],
+        rows: int | Iterator[int],
         data_indexes: bool = True,
         undo: bool = True,
         emit_event: bool = False,
@@ -1895,7 +1831,7 @@ class Sheet(tk.Frame):
 
     def del_columns(
         self,
-        columns: int | AnyIter[int],
+        columns: int | Iterator[int],
         data_indexes: bool = True,
         undo: bool = True,
         emit_event: bool = False,
@@ -2187,7 +2123,7 @@ class Sheet(tk.Frame):
 
     def sort_rows(
         self,
-        rows: AnyIter[int] | Span | int | None = None,
+        rows: Iterator[int] | Span | int | None = None,
         reverse: bool = False,
         validation: bool = True,
         key: Callable | None = None,
@@ -2201,7 +2137,7 @@ class Sheet(tk.Frame):
 
     def sort_columns(
         self,
-        columns: AnyIter[int] | Span | int | None = None,
+        columns: Iterator[int] | Span | int | None = None,
         reverse: bool = False,
         validation: bool = True,
         key: Callable | None = None,
@@ -2533,13 +2469,13 @@ class Sheet(tk.Frame):
                 self.del_index_cell_options_dropdown_and_checkbox(r)
                 add_to_options(self.RI.cell_options, r, "checkbox", d)
                 if edit_data:
-                    set_idata(r, checked if isinstance(checked, bool) else force_bool(self.get_index_data(r)))
+                    set_idata(r, checked if isinstance(checked, bool) else force_bool(self.RI.get_cell_data(r)))
         if header:
             for c in cols:
                 self.del_header_cell_options_dropdown_and_checkbox(c)
                 add_to_options(self.CH.cell_options, c, "checkbox", d)
                 if edit_data:
-                    set_hdata(c, checked if isinstance(checked, bool) else force_bool(self.get_header_data(c)))
+                    set_hdata(c, checked if isinstance(checked, bool) else force_bool(self.CH.get_cell_data(c)))
         if table:
             if span.kind == "cell":
                 for r in rows:
@@ -3190,8 +3126,8 @@ class Sheet(tk.Frame):
 
     def deselect_any(
         self,
-        rows: AnyIter[int] | int | None,
-        columns: AnyIter[int] | int | None,
+        rows: Iterator[int] | int | None,
+        columns: Iterator[int] | int | None,
         redraw: bool = True,
     ) -> Sheet:
         self.MT.deselect_any(rows=rows, columns=columns, redraw=False)
@@ -3393,7 +3329,7 @@ class Sheet(tk.Frame):
 
     def set_column_widths(
         self,
-        column_widths: AnyIter[float] | None = None,
+        column_widths: Iterator[float] | None = None,
         canvas_positions: bool = False,
         reset: bool = False,
     ) -> Sheet:
@@ -3408,7 +3344,7 @@ class Sheet(tk.Frame):
 
     def set_row_heights(
         self,
-        row_heights: AnyIter[float] | None = None,
+        row_heights: Iterator[float] | None = None,
         canvas_positions: bool = False,
         reset: bool = False,
     ) -> Sheet:
@@ -3455,7 +3391,7 @@ class Sheet(tk.Frame):
 
     delete_row_position = del_row_position
 
-    def del_row_positions(self, idxs: AnyIter[int] | None = None) -> Sheet:
+    def del_row_positions(self, idxs: Iterator[int] | None = None) -> Sheet:
         self.MT.del_row_positions(idxs=idxs)
         self.set_refresh_timer()
         return self
@@ -3466,7 +3402,7 @@ class Sheet(tk.Frame):
 
     delete_column_position = del_column_position
 
-    def del_column_positions(self, idxs: AnyIter[int] | None = None) -> Sheet:
+    def del_column_positions(self, idxs: Iterator[int] | None = None) -> Sheet:
         self.MT.del_col_positions(idxs=idxs)
         self.set_refresh_timer()
         return self
@@ -3743,7 +3679,7 @@ class Sheet(tk.Frame):
 
     def display_columns(
         self,
-        columns: None | Literal["all"] | AnyIter[int] = None,
+        columns: None | Literal["all"] | Iterator[int] = None,
         all_columns_displayed: None | bool = None,
         reset_col_positions: bool = True,
         redraw: bool = False,
@@ -3767,7 +3703,7 @@ class Sheet(tk.Frame):
 
     def hide_columns(
         self,
-        columns: int | set[int] | AnyIter[int],
+        columns: int | set[int] | Iterator[int],
         redraw: bool = True,
         deselect_all: bool = True,
         data_indexes: bool = False,
@@ -3811,7 +3747,7 @@ class Sheet(tk.Frame):
 
     def show_columns(
         self,
-        columns: int | AnyIter[int],
+        columns: int | Iterator[int],
         redraw: bool = True,
         deselect_all: bool = True,
     ) -> Sheet:
@@ -3878,7 +3814,7 @@ class Sheet(tk.Frame):
 
     def display_rows(
         self,
-        rows: None | Literal["all"] | AnyIter[int] = None,
+        rows: None | Literal["all"] | Iterator[int] = None,
         all_rows_displayed: None | bool = None,
         reset_row_positions: bool = True,
         redraw: bool = False,
@@ -3900,7 +3836,7 @@ class Sheet(tk.Frame):
 
     def hide_rows(
         self,
-        rows: int | set[int] | AnyIter[int],
+        rows: int | set[int] | Iterator[int],
         redraw: bool = True,
         deselect_all: bool = True,
         data_indexes: bool = False,
@@ -3946,7 +3882,7 @@ class Sheet(tk.Frame):
 
     def show_rows(
         self,
-        rows: int | AnyIter[int],
+        rows: int | Iterator[int],
         redraw: bool = True,
         deselect_all: bool = True,
     ) -> Sheet:
@@ -4506,7 +4442,7 @@ class Sheet(tk.Frame):
     def tag(
         self,
         *key: CreateSpanTypes,
-        tags: AnyIter[str] | str = "",
+        tags: Iterator[str] | str = "",
     ) -> Sheet:
         span = self.span_from_key(*key)
         rows, cols = self.ranges_from_span(span)
@@ -4551,7 +4487,7 @@ class Sheet(tk.Frame):
 
     def tag_rows(
         self,
-        rows: int | AnyIter[int],
+        rows: int | Iterator[int],
         *tags,
     ) -> Sheet:
         if isinstance(rows, int):
@@ -4564,7 +4500,7 @@ class Sheet(tk.Frame):
 
     def tag_columns(
         self,
-        columns: int | AnyIter[int],
+        columns: int | Iterator[int],
         *tags,
     ) -> Sheet:
         if isinstance(columns, int):
@@ -4578,8 +4514,8 @@ class Sheet(tk.Frame):
     def untag(
         self,
         cell: tuple[int, int] | None = None,
-        rows: int | AnyIter[int] | None = None,
-        columns: int | AnyIter[int] | None = None,
+        rows: int | Iterator[int] | None = None,
+        columns: int | Iterator[int] | None = None,
     ) -> Sheet:
         if isinstance(cell, tuple):
             for tagged in self.MT.tagged_cells.values():
@@ -4639,7 +4575,7 @@ class Sheet(tk.Frame):
         text_column: None | int | list[str] = None,
         push_ops: bool = False,
         row_heights: Sequence[int] | None | False = None,
-        open_ids: AnyIter[str] | None = None,
+        open_ids: Iterator[str] | None = None,
         safety: bool = True,
         ncols: int | None = None,
         lower: bool = False,
@@ -4647,7 +4583,9 @@ class Sheet(tk.Frame):
         include_parent_column: bool = True,
         include_text_column: bool = True,
     ) -> Sheet:
-        self.RI.tree_build(
+        build = self.RI.safe_tree_build if safety else self.RI.tree_build
+        self.reset(cell_options=False, column_widths=False, header=False, redraw=False)
+        build(
             data=data,
             iid_column=iid_column,
             parent_column=parent_column,
@@ -4655,7 +4593,6 @@ class Sheet(tk.Frame):
             push_ops=push_ops,
             row_heights=row_heights,
             open_ids=open_ids,
-            safety=safety,
             ncols=ncols,
             lower=lower,
             include_iid_column=include_iid_column,
@@ -4675,7 +4612,7 @@ class Sheet(tk.Frame):
         """
         return self.RI.tree_open_ids
 
-    def tree_set_open(self, open_ids: AnyIter[str]) -> Sheet:
+    def tree_set_open(self, open_ids: Iterator[str]) -> Sheet:
         """
         Accepts set[str] of iids that are open in the treeview
         Closes everything else
@@ -4702,12 +4639,12 @@ class Sheet(tk.Frame):
         """
         to_open = []
         disp_set = set(self.MT.displayed_rows)
-        tree = self.RI.tree
-        rns = self.RI.tree_rns
+        index = self.MT._row_index
+        rns = self.RI.rns
         open_ids = self.RI.tree_open_ids
         descendants = self.RI.get_iid_descendants
         for item in filter(items.__contains__, self.get_children()):
-            if tree[item].children:
+            if index[rns[item]].children:
                 open_ids.add(item)
                 if rns[item] in disp_set:
                     to_disp = [rns[did] for did in descendants(item, check_open=True)]
@@ -4727,20 +4664,22 @@ class Sheet(tk.Frame):
             deselect_all=False,
         )
 
-    def _tree_close(self, items: AnyIter[str]) -> list[int]:
+    def _tree_close(self, items: Iterator[str]) -> list[int]:
         """
         Only meant for internal use
         """
         to_close = set()
         disp_set = set(self.MT.displayed_rows)
-        quick_rns = self.RI.tree_rns
-        quick_open_ids = self.RI.tree_open_ids
+        index = self.MT._row_index
+        rns = self.RI.rns
+        open_ids = self.RI.tree_open_ids
+        descendants = self.RI.get_iid_descendants
         for item in items:
-            if self.RI.tree[item].children:
-                quick_open_ids.discard(item)
-                if quick_rns[item] in disp_set:
-                    for did in self.RI.get_iid_descendants(item, check_open=True):
-                        to_close.add(quick_rns[did])
+            if index[rns[item]].children:
+                open_ids.discard(item)
+                if rns[item] in disp_set:
+                    for did in descendants(item, check_open=True):
+                        to_close.add(rns[did])
         return to_close
 
     def tree_close(self, *items, redraw: bool = True) -> Sheet:
@@ -4773,11 +4712,11 @@ class Sheet(tk.Frame):
         """
         if not iid:
             iid = self.RI.new_iid()
-        if iid in self.RI.tree:
+        if iid in self.RI.rns:
             raise ValueError(f"iid '{iid}' already exists.")
         if iid == parent:
             raise ValueError(f"iid '{iid}' cannot be equal to parent '{parent}'.")
-        if parent and parent not in self.RI.tree:
+        if parent and parent not in self.RI.rns:
             raise ValueError(f"parent '{parent}' does not exist.")
         if text is None:
             text = iid
@@ -4786,6 +4725,7 @@ class Sheet(tk.Frame):
         self.insert_rows(
             rows=[[new_node] + ([] if values is None else values)],
             idx=datarn,
+            heights=[],
             row_index=True,
             create_selections=create_selections,
             fill=False,
@@ -4800,15 +4740,15 @@ class Sheet(tk.Frame):
     def _get_id_insert_row(self, index: int, parent: str) -> int:
         if parent:
             if isinstance(index, int):
-                index = min(index, len(self.RI.tree[parent].children))
+                index = min(index, len(self.RI.iid_children(parent)))
                 datarn = (
-                    self.RI.tree_rns[parent]
+                    self.RI.rns[parent]
                     + index
                     + 1
                     + sum(self.RI.num_descendants(cid) for cid in islice(self.get_children(parent), index))
                 )
             else:
-                datarn = self.RI.tree_rns[parent] + self.RI.num_descendants(parent) + 1
+                datarn = self.RI.rns[parent] + self.RI.num_descendants(parent) + 1
         else:
             if isinstance(index, int):
                 datarn = index
@@ -4839,7 +4779,7 @@ class Sheet(tk.Frame):
             - Values (int): row numbers
         """
         to_insert = []
-        if parent and parent not in self.RI.tree:
+        if parent and parent not in self.RI.rns:
             raise ValueError(f"parent '{parent}' does not exist.")
         datarn = self._get_id_insert_row(index=index, parent=parent)
         rns_to_add = {}
@@ -4863,6 +4803,7 @@ class Sheet(tk.Frame):
         self.insert_rows(
             rows=to_insert,
             idx=datarn,
+            heights=[],
             row_index=True,
             create_selections=create_selections,
             fill=False,
@@ -4880,6 +4821,8 @@ class Sheet(tk.Frame):
         text: str | None = None,
         values: list | None = None,
         open_: bool | None = None,
+        undo: bool = True,
+        emit_event: bool = True,
         redraw: bool = True,
     ) -> DotDict | Sheet:
         """
@@ -4887,19 +4830,17 @@ class Sheet(tk.Frame):
         If no options are set then returns DotDict of options for item
         Else returns Sheet
         """
-        if item not in self.RI.tree:
+        if item not in self.RI.rns:
             raise ValueError(f"Item '{item}' does not exist.")
-        if isinstance(text, str):
-            self.RI.tree[item].text = text
-        if isinstance(values, list):
-            self.set_data(self.RI.tree_rns[item], data=values)
+        get_only = all(param is None for param in (iid, text, values, open_))
+
         if isinstance(open_, bool):
-            if self.RI.tree[item].children:
+            if self.RI.iid_children(item):
                 if open_:
                     self.RI.tree_open_ids.add(item)
                     if self.item_displayed(item):
                         self.show_rows(
-                            rows=map(self.RI.tree_rns.__getitem__, self.RI.get_iid_descendants(item, check_open=True)),
+                            rows=map(self.RI.rns.__getitem__, self.RI.get_iid_descendants(item, check_open=True)),
                             redraw=False,
                             deselect_all=False,
                         )
@@ -4907,43 +4848,47 @@ class Sheet(tk.Frame):
                     self.RI.tree_open_ids.discard(item)
                     if self.item_displayed(item):
                         self.hide_rows(
-                            rows=set(
-                                map(self.RI.tree_rns.__getitem__, self.RI.get_iid_descendants(item, check_open=True))
-                            ),
+                            rows=set(map(self.RI.rns.__getitem__, self.RI.get_iid_descendants(item, check_open=True))),
                             redraw=False,
                             deselect_all=False,
                             data_indexes=True,
                         )
             else:
                 self.RI.tree_open_ids.discard(item)
+
+        event_data = None if get_only else self.MT.new_event_dict("edit_table", state=True)
+
+        if isinstance(text, str):
+            event_data.cells.index = {self.RI.rns[item]: self.MT._row_index[self.RI.rns[item]].text}
+            self.MT._row_index[self.RI.rns[item]].text = text
+
+        if isinstance(values, list):
+            span = self.span(self.RI.rns[item], undo=False, emit_event=False)
+            event_data = self.set_data(span, data=values, event_data=event_data)
+
         if isinstance(iid, str):
-            if iid in self.RI.tree:
+            if iid in self.RI.rns:
                 raise ValueError(f"Cannot rename '{iid}', it already exists.")
-            for ciid in self.RI.tree[item].children:
-                self.RI.tree[ciid].parent = iid
-            if self.RI.tree[item].parent:
-                parent_node = self.RI.parent_node(item)
-                item_index = parent_node.children.index(item)
-                parent_node.children[item_index] = iid
-            self.RI.tree[item].iid = iid
-            self.RI.tree[iid] = self.RI.tree.pop(item)
-            self.RI.tree_rns[iid] = self.RI.tree_rns.pop(item)
-            if item in self.RI.tree_open_ids:
-                self.RI.tree_open_ids.discard(item)
-                self.RI.tree_open_ids.add(iid)
-        get = not (isinstance(iid, str) or isinstance(text, str) or isinstance(values, list) or isinstance(open_, bool))
-        self.set_refresh_timer(redraw=not get and redraw)
-        if get:
+            event_data = self.RI.rename_iid(old=item, new=iid, event_data=event_data)
+
+        if event_data:
+            if undo and self.MT.undo_enabled:
+                self.MT.undo_stack.append(stored_event_dict(event_data))
+            if emit_event:
+                self.emit_event("<<SheetModified>>", event_data)
+
+        self.set_refresh_timer(redraw=not get_only and redraw)
+        if get_only:
             return DotDict(
-                text=self.RI.tree[item].text,
-                values=self[self.RI.tree_rns[item]].options(ndim=1).data,
+                text=self.MT._row_index[self.RI.rns[item]].text,
+                values=self[self.RI.rns[item]].options(ndim=1).data,
                 open_=item in self.RI.tree_open_ids,
             )
         return self
 
     def itemrow(self, item: str) -> int:
         try:
-            return self.RI.tree_rns[item]
+            return self.RI.rns[item]
         except ValueError as error:
             raise ValueError(f"item '{item}' does not exist.") from error
 
@@ -4957,30 +4902,29 @@ class Sheet(tk.Frame):
 
     def get_children(self, item: None | str = None) -> Generator[str]:
         if item is None:
-            for iid in self.get_children(""):
-                yield iid
-                yield from self.RI.get_iid_descendants(iid)
+            yield from map(attrgetter("iid"), self.MT._row_index)
         elif item == "":
             yield from map(attrgetter("iid"), self.RI.gen_top_nodes())
         else:
-            yield from self.RI.tree[item].children
+            yield from self.RI.iid_children(item)
 
-    def get_iids(self, item: None | str = None) -> Generator[str]:
+    def tree_traverse(self, item: None | str = None) -> Generator[str]:
         if item is None:
-            for n in self.RI.tree.values():
-                if not n.parent:
-                    yield n.iid
-                    yield from self.RI.get_iid_descendants(n.iid)
+            for tiid in map(attrgetter("iid"), self.RI.gen_top_nodes()):
+                yield tiid
+                yield from self.RI.get_iid_descendants(tiid)
         elif item == "":
-            yield from (n.iid for n in self.RI.tree.values() if not n.parent)
+            yield from map(attrgetter("iid"), self.RI.gen_top_nodes())
         else:
-            yield from self.RI.tree[item].children
+            yield from self.RI.iid_children(item)
+
+    get_iids = tree_traverse
 
     def del_items(self, *items, undo: bool = True) -> Sheet:
         """
         Also deletes all descendants of items
         """
-        rows = list(map(self.RI.tree_rns.get, filter(self.exists, unpack(items))))
+        rows = list(map(self.RI.rns.get, filter(self.exists, unpack(items))))
         if rows:
             self.del_rows(rows, data_indexes=True, undo=undo)
         return self.set_refresh_timer(rows)
@@ -4995,7 +4939,7 @@ class Sheet(tk.Frame):
 
     def top_index_row(self, index: int) -> int:
         try:
-            return next(self.RI.tree_rns[n.iid] for i, n in enumerate(self.RI.gen_top_nodes()) if i == index)
+            return next(self.RI.rns[n.iid] for i, n in enumerate(self.RI.gen_top_nodes()) if i == index)
         except Exception:
             return None
 
@@ -5012,9 +4956,9 @@ class Sheet(tk.Frame):
         Moves item to be under parent as child at index
         'parent' can be an empty str which will put the item at top level
         """
-        if item not in self.RI.tree:
+        if item not in self.RI.rns:
             raise ValueError(f"Item '{item}' does not exist.")
-        if parent and parent not in self.RI.tree:
+        if parent and parent not in self.RI.rns:
             raise ValueError(f"Parent '{parent}' does not exist.")
         if self.RI.move_pid_causes_recursive_loop(item, parent):
             raise ValueError(f"Item '{item}' causes recursive loop with parent '{parent}.")
@@ -5039,30 +4983,29 @@ class Sheet(tk.Frame):
     reattach = move
 
     def exists(self, item: str) -> bool:
-        return item in self.RI.tree
+        return item in self.RI.rns
 
     def parent(self, item: str) -> str:
-        if item not in self.RI.tree:
+        if item not in self.RI.rns:
             raise ValueError(f"Item '{item}' does not exist.")
-        return self.RI.tree[item].parent
+        return self.RI.iid_parent(item)
 
     def index(self, item: str) -> int:
-        if item not in self.RI.tree:
+        if item not in self.RI.rns:
             raise ValueError(f"Item '{item}' does not exist.")
-        elif self.RI.tree[item].parent:
+        elif self.RI.iid_parent(item):
             return self.RI.parent_node(item).children.index(item)
         else:
-            find_node = self.RI.tree[item]
-            return next(index for index, node in enumerate(self.RI.gen_top_nodes()) if node == find_node)
+            return next(index for index, iid in enumerate(self.get_children("")) if iid == item)
 
     def item_displayed(self, item: str) -> bool:
         """
         Check if an item (row) is currently displayed on the sheet
         - Does not check if the item is visible to the user
         """
-        if item not in self.RI.tree:
+        if item not in self.RI.rns:
             raise ValueError(f"Item '{item}' does not exist.")
-        return bisect_in(self.MT.displayed_rows, self.RI.tree_rns[item])
+        return bisect_in(self.MT.displayed_rows, self.RI.rns[item])
 
     def display_item(self, item: str, redraw: bool = False) -> Sheet:
         """
@@ -5071,7 +5014,7 @@ class Sheet(tk.Frame):
         - Unlike the ttk treeview 'see' function
           this function does **NOT** scroll to the item
         """
-        if not self.item_displayed(item) and self.RI.tree[item].parent:
+        if not self.item_displayed(item) and self.RI.iid_parent(item):
             self.show_rows(
                 rows=self._tree_open(list(self.RI.get_iid_ancestors(item))),
                 redraw=False,
@@ -5085,7 +5028,7 @@ class Sheet(tk.Frame):
         """
         self.display_item(item, redraw=False)
         self.see(
-            row=bisect_left(self.MT.displayed_rows, self.RI.tree_rns[item]),
+            row=bisect_left(self.MT.displayed_rows, self.RI.rns[item]),
             keep_xscroll=True,
             redraw=False,
         )
@@ -5120,8 +5063,8 @@ class Sheet(tk.Frame):
     def selection_add(self, *items, run_binding: bool = True, redraw: bool = True) -> Sheet:
         to_open = []
         quick_displayed_check = set(self.MT.displayed_rows)
-        for item in filter(self.RI.tree.__contains__, unpack(items)):
-            if self.RI.tree_rns[item] not in quick_displayed_check and self.RI.tree[item].parent:
+        for item in filter(self.RI.rns.__contains__, unpack(items)):
+            if self.RI.rns[item] not in quick_displayed_check and self.RI.iid_parent(item):
                 to_open.extend(list(self.RI.get_iid_ancestors(item)))
         if to_open:
             self.show_rows(
@@ -5133,9 +5076,9 @@ class Sheet(tk.Frame):
             sorted(
                 bisect_left(
                     self.MT.displayed_rows,
-                    self.RI.tree_rns[item],
+                    self.RI.rns[item],
                 )
-                for item in filter(self.RI.tree.__contains__, unpack(items))
+                for item in filter(self.RI.rns.__contains__, unpack(items))
             )
         ):
             self.MT.create_selection_box(
@@ -5153,10 +5096,10 @@ class Sheet(tk.Frame):
 
     def selection_remove(self, *items, redraw: bool = True) -> Sheet:
         for item in unpack(items):
-            if item not in self.RI.tree:
+            if item not in self.RI.rns:
                 continue
             try:
-                self.deselect(bisect_left(self.MT.displayed_rows, self.RI.tree_rns[item]), redraw=False)
+                self.deselect(bisect_left(self.MT.displayed_rows, self.RI.rns[item]), redraw=False)
             except Exception:
                 continue
         return self.set_refresh_timer(redraw)
@@ -5166,7 +5109,7 @@ class Sheet(tk.Frame):
         add = []
         remove = []
         for item in unpack(items):
-            if item in self.RI.tree:
+            if item in self.RI.rns:
                 if item in selected:
                     remove.append(item)
                 else:
@@ -5304,7 +5247,7 @@ class Sheet(tk.Frame):
 
     def get_cell_data(self, r: int, c: int, get_displayed: bool = False) -> Any:
         if get_displayed:
-            return self.MT.get_valid_cell_data_as_str(r, c, get_displayed=True)
+            return self.MT.cell_str(r, c, get_displayed=True)
         else:
             return self.MT.get_cell_data(r, c)
 
@@ -5314,7 +5257,7 @@ class Sheet(tk.Frame):
         get_displayed: bool = False,
         get_index: bool = False,
         get_index_displayed: bool = True,
-        only_columns: int | AnyIter[int] | None = None,
+        only_columns: int | Iterator[int] | None = None,
     ) -> list[Any]:
         if only_columns is not None:
             if isinstance(only_columns, int):
@@ -5323,15 +5266,16 @@ class Sheet(tk.Frame):
                 raise ValueError(tksheet_type_error("only_columns", ["int", "iterable", "None"], only_columns))
         if r >= self.MT.total_data_rows():
             raise IndexError(f"Row #{r} is out of range.")
+
         if r >= len(self.MT.data):
             total_data_cols = self.MT.total_data_cols()
             self.MT.fix_data_len(r, total_data_cols - 1)
+
         iterable = only_columns if only_columns is not None else range(len(self.MT.data[r]))
-        f = partial(self.MT.get_valid_cell_data_as_str, get_displayed=True) if get_displayed else self.MT.get_cell_data
-        if get_index:
-            return [self.get_index_data(r, get_displayed=get_index_displayed)] + [f(r, c) for c in iterable]
-        else:
-            return [f(r, c) for c in iterable]
+        f = partial(self.MT.cell_str, get_displayed=True) if get_displayed else self.MT.get_cell_data
+        row = [self.RI.get_cell_data(r, get_displayed=get_index_displayed)] if get_index else []
+        row.extend(f(r, c) for c in iterable)
+        return row
 
     def get_column_data(
         self,
@@ -5339,7 +5283,7 @@ class Sheet(tk.Frame):
         get_displayed: bool = False,
         get_header: bool = False,
         get_header_displayed: bool = True,
-        only_rows: int | AnyIter[int] | None = None,
+        only_rows: int | Iterator[int] | None = None,
     ) -> list[Any]:
         if only_rows is not None:
             if isinstance(only_rows, int):
@@ -5347,10 +5291,10 @@ class Sheet(tk.Frame):
             elif not is_iterable(only_rows):
                 raise ValueError(tksheet_type_error("only_rows", ["int", "iterable", "None"], only_rows))
         iterable = only_rows if only_rows is not None else range(len(self.MT.data))
-        f = partial(self.MT.get_valid_cell_data_as_str, get_displayed=True) if get_displayed else self.MT.get_cell_data
-        return ([self.get_header_data(c, get_displayed=get_header_displayed)] if get_header else []) + [
-            f(r, c) for r in iterable
-        ]
+        f = partial(self.MT.cell_str, get_displayed=True) if get_displayed else self.MT.get_cell_data
+        col = [self.CH.get_cell_data(c, get_displayed=get_header_displayed)] if get_header else []
+        col.extend(f(r, c) for r in iterable)
+        return col
 
     def get_sheet_data(
         self,
@@ -5359,9 +5303,9 @@ class Sheet(tk.Frame):
         get_index: bool = False,
         get_header_displayed: bool = True,
         get_index_displayed: bool = True,
-        only_rows: AnyIter[int] | int | None = None,
-        only_columns: AnyIter[int] | int | None = None,
-    ) -> list[Any]:
+        only_rows: Iterator[int] | int | None = None,
+        only_columns: Iterator[int] | int | None = None,
+    ) -> list[list[Any]]:
         if only_rows is not None:
             if isinstance(only_rows, int):
                 only_rows = (only_rows,)
@@ -5372,6 +5316,7 @@ class Sheet(tk.Frame):
                 only_columns = (only_columns,)
             elif not is_iterable(only_columns):
                 raise ValueError(tksheet_type_error("only_columns", ["int", "iterable", "None"], only_columns))
+
         if get_header:
             maxlen = len(self.MT._headers) if isinstance(self.MT._headers, (list, tuple)) else 0
             data = []
@@ -5380,15 +5325,19 @@ class Sheet(tk.Frame):
                 if len(r) > maxlen:
                     maxlen = len(r)
                 if get_index:
-                    data.append([self.get_index_data(rn, get_displayed=get_index_displayed)] + r)
+                    row = [self.RI.get_cell_data(rn, get_displayed=get_index_displayed)]
+                    row.extend(r)
+                    data.append(row)
                 else:
                     data.append(r)
             iterable = only_columns if only_columns is not None else range(maxlen)
-            if get_index:
-                return [[""] + [self.get_header_data(cn, get_displayed=get_header_displayed) for cn in iterable]] + data
-            else:
-                return [[self.get_header_data(cn, get_displayed=get_header_displayed) for cn in iterable]] + data
-        elif not get_header:
+            header_row = [""] if get_index else []
+            header_row.extend(self.CH.get_cell_data(cn, get_displayed=get_header_displayed) for cn in iterable)
+            result = [header_row]
+            result.extend(data)
+            return result
+
+        else:
             iterable = only_rows if only_rows is not None else range(len(self.MT.data))
             return [
                 self.get_row_data(
@@ -5408,9 +5357,9 @@ class Sheet(tk.Frame):
         get_index: bool = False,
         get_index_displayed: bool = True,
         get_header_displayed: bool = True,
-        only_rows: int | AnyIter[int] | None = None,
-        only_columns: int | AnyIter[int] | None = None,
-    ) -> Iterator[list[Any]]:
+        only_rows: int | Iterator[int] | None = None,
+        only_columns: int | Iterator[int] | None = None,
+    ) -> Generator[list[Any]]:
         if only_rows is not None:
             if isinstance(only_rows, int):
                 only_rows = (only_rows,)
@@ -5421,11 +5370,13 @@ class Sheet(tk.Frame):
                 only_columns = (only_columns,)
             elif not is_iterable(only_columns):
                 raise ValueError(tksheet_type_error("only_columns", ["int", "iterable", "None"], only_columns))
+
         if get_header:
             iterable = only_columns if only_columns is not None else range(self.MT.total_data_cols())
-            yield ([""] if get_index else []) + [
-                self.get_header_data(c, get_displayed=get_header_displayed) for c in iterable
-            ]
+            header_row = [""] if get_index else []
+            header_row.extend(self.CH.get_cell_data(c, get_displayed=get_header_displayed) for c in iterable)
+            yield header_row
+
         iterable = only_rows if only_rows is not None else range(len(self.MT.data))
         yield from (
             self.get_row_data(
@@ -5666,7 +5617,7 @@ class Sheet(tk.Frame):
 
     def highlight_rows(
         self,
-        rows: AnyIter[int] | int,
+        rows: Iterator[int] | int,
         bg: None | str = None,
         fg: None | str = None,
         highlight_index: bool = True,
@@ -5684,7 +5635,7 @@ class Sheet(tk.Frame):
 
     def highlight_columns(
         self,
-        columns: AnyIter[int] | int,
+        columns: Iterator[int] | int,
         bg: bool | None | str = False,
         fg: bool | None | str = False,
         highlight_header: bool = True,
@@ -5986,7 +5937,7 @@ class Sheet(tk.Frame):
 
     def checkbox_row(
         self,
-        r: AnyIter[int] | int | Literal["all"] = 0,
+        r: Iterator[int] | int | Literal["all"] = 0,
         *args,
         **kwargs,
     ) -> None:
@@ -6011,7 +5962,7 @@ class Sheet(tk.Frame):
 
     def checkbox_column(
         self,
-        c: AnyIter[int] | int | Literal["all"] = 0,
+        c: Iterator[int] | int | Literal["all"] = 0,
         *args,
         **kwargs,
     ) -> None:
@@ -6036,7 +5987,7 @@ class Sheet(tk.Frame):
 
     def create_header_checkbox(
         self,
-        c: AnyIter[int] | int | Literal["all"] = 0,
+        c: Iterator[int] | int | Literal["all"] = 0,
         *args,
         **kwargs,
     ) -> None:
@@ -6059,7 +6010,7 @@ class Sheet(tk.Frame):
 
     def create_index_checkbox(
         self,
-        r: AnyIter[int] | int | Literal["all"] = 0,
+        r: Iterator[int] | int | Literal["all"] = 0,
         *args,
         **kwargs,
     ) -> None:
@@ -6109,7 +6060,7 @@ class Sheet(tk.Frame):
 
     def delete_row_checkbox(
         self,
-        r: AnyIter[int] | int | Literal["all"] = 0,
+        r: Iterator[int] | int | Literal["all"] = 0,
     ) -> None:
         if isinstance(r, str) and r.lower() == "all":
             for r_ in self.MT.row_options:
@@ -6122,7 +6073,7 @@ class Sheet(tk.Frame):
 
     def delete_column_checkbox(
         self,
-        c: AnyIter[int] | int | Literal["all"] = 0,
+        c: Iterator[int] | int | Literal["all"] = 0,
     ) -> None:
         if isinstance(c, str) and c.lower() == "all":
             for c_ in self.MT.col_options:
@@ -6135,7 +6086,7 @@ class Sheet(tk.Frame):
 
     def delete_header_checkbox(
         self,
-        c: AnyIter[int] | int | Literal["all"] = 0,
+        c: Iterator[int] | int | Literal["all"] = 0,
     ) -> None:
         if isinstance(c, str) and c.lower() == "all":
             for c_ in self.CH.cell_options:
@@ -6149,7 +6100,7 @@ class Sheet(tk.Frame):
 
     def delete_index_checkbox(
         self,
-        r: AnyIter[int] | int | Literal["all"] = 0,
+        r: Iterator[int] | int | Literal["all"] = 0,
     ) -> None:
         if isinstance(r, str) and r.lower() == "all":
             for r_ in self.RI.cell_options:
@@ -6239,7 +6190,7 @@ class Sheet(tk.Frame):
 
     def dropdown_row(
         self,
-        r: AnyIter[int] | int | Literal["all"] = 0,
+        r: Iterator[int] | int | Literal["all"] = 0,
         *args,
         **kwargs,
     ) -> Sheet:
@@ -6264,7 +6215,7 @@ class Sheet(tk.Frame):
 
     def dropdown_column(
         self,
-        c: AnyIter[int] | int | Literal["all"] = 0,
+        c: Iterator[int] | int | Literal["all"] = 0,
         *args,
         **kwargs,
     ) -> Sheet:
@@ -6289,7 +6240,7 @@ class Sheet(tk.Frame):
 
     def create_header_dropdown(
         self,
-        c: AnyIter[int] | int | Literal["all"] = 0,
+        c: Iterator[int] | int | Literal["all"] = 0,
         *args,
         **kwargs,
     ) -> Sheet:
@@ -6313,7 +6264,7 @@ class Sheet(tk.Frame):
 
     def create_index_dropdown(
         self,
-        r: AnyIter[int] | int | Literal["all"] = 0,
+        r: Iterator[int] | int | Literal["all"] = 0,
         *args,
         **kwargs,
     ) -> Sheet:
@@ -6364,7 +6315,7 @@ class Sheet(tk.Frame):
 
     def delete_row_dropdown(
         self,
-        r: AnyIter[int] | int | Literal["all"] = "all",
+        r: Iterator[int] | int | Literal["all"] = "all",
     ) -> None:
         if isinstance(r, str) and r.lower() == "all":
             for r_ in self.MT.row_options:
@@ -6378,7 +6329,7 @@ class Sheet(tk.Frame):
 
     def delete_column_dropdown(
         self,
-        c: AnyIter[int] | int | Literal["all"] = "all",
+        c: Iterator[int] | int | Literal["all"] = "all",
     ) -> None:
         if isinstance(c, str) and c.lower() == "all":
             for c_ in self.MT.col_options:
@@ -6390,7 +6341,7 @@ class Sheet(tk.Frame):
             for c_ in c:
                 self.del_column_options_dropdown(datacn=c_)
 
-    def delete_header_dropdown(self, c: AnyIter[int] | int | Literal["all"]) -> None:
+    def delete_header_dropdown(self, c: Iterator[int] | int | Literal["all"]) -> None:
         if isinstance(c, str) and c.lower() == "all":
             for c_ in self.CH.cell_options:
                 if "dropdown" in self.CH.cell_options[c_]:
@@ -6401,7 +6352,7 @@ class Sheet(tk.Frame):
             for c_ in c:
                 self.del_header_cell_options_dropdown(c_)
 
-    def delete_index_dropdown(self, r: AnyIter[int] | int | Literal["all"]) -> None:
+    def delete_index_dropdown(self, r: Iterator[int] | int | Literal["all"]) -> None:
         if isinstance(r, str) and r.lower() == "all":
             for r_ in self.RI.cell_options:
                 if "dropdown" in self.RI.cell_options[r_]:
@@ -6637,7 +6588,7 @@ class Sheet(tk.Frame):
 
     def format_row(
         self,
-        r: AnyIter[int] | int | Literal["all"],
+        r: Iterator[int] | int | Literal["all"],
         formatter_options: dict | None = None,
         formatter_class: Any = None,
         redraw: bool = True,
@@ -6669,7 +6620,7 @@ class Sheet(tk.Frame):
 
     def delete_row_format(
         self,
-        r: AnyIter[int] | int | Literal["all"] = "all",
+        r: Iterator[int] | int | Literal["all"] = "all",
         clear_values: bool = False,
     ) -> Sheet:
         if is_iterable(r):
@@ -6681,7 +6632,7 @@ class Sheet(tk.Frame):
 
     def format_column(
         self,
-        c: AnyIter[int] | int | Literal["all"],
+        c: Iterator[int] | int | Literal["all"],
         formatter_options: dict | None = None,
         formatter_class: Any = None,
         redraw: bool = True,
@@ -6713,7 +6664,7 @@ class Sheet(tk.Frame):
 
     def delete_column_format(
         self,
-        c: AnyIter[int] | int | Literal["all"] = "all",
+        c: Iterator[int] | int | Literal["all"] = "all",
         clear_values: bool = False,
     ) -> Sheet:
         if is_iterable(c):