tksheet 7.4.3__py3-none-any.whl → 7.4.5__py3-none-any.whl

tksheet/other_classes.py

@@ -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_
@@ -189,11 +187,13 @@ class Span(dict):
 
     def format(
         self,
-        formatter_options: dict = {},
+        formatter_options: dict | None = None,
         formatter_class: object = 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,9 +232,9 @@ class Span(dict):
 
     def dropdown(
         self,
-        values: list = [],
+        values: list[object] | None = None,
         edit_data: bool = True,
-        set_values: dict[tuple[int, int], object] = {},
+        set_values: dict[tuple[int, int], object] | None = None,
         set_value: object = None,
         state: str = "normal",
         redraw: bool = True,
@@ -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,
@@ -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

tksheet/row_index.py

@@ -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
@@ -249,28 +249,32 @@ class RowIndex(tk.Canvas):
     def shift_b1_press(self, event: object) -> 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:
@@ -354,12 +358,11 @@ 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)
@@ -900,6 +903,8 @@ class RowIndex(tk.Canvas):
             rows = list(range(0, len(self.MT.row_positions) - 1))
         event_data = self.MT.new_event_dict("edit_table")
         try_binding(self.MT.extra_begin_sort_cells_func, event_data)
+        if key is None:
+            key = self.PAR.ops.sort_key
         for r in rows:
             datarn = self.MT.datarn(r)
             for c, val in enumerate(sort_row(self.MT.data[datarn], reverse=reverse, key=key)):
@@ -943,6 +948,8 @@ class RowIndex(tk.Canvas):
                 return event_data
             row = self.MT.selected.row
         if try_binding(self.ri_extra_begin_sort_cols_func, event_data, "begin_move_columns"):
+            if key is None:
+                key = self.PAR.ops.sort_key
             sorted_indices, data_new_idxs = sort_columns_by_row(self.MT.data, row=row, reverse=reverse, key=key)
             disp_new_idxs = {}
             if self.MT.all_columns_displayed:
@@ -1227,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
@@ -1241,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)
@@ -1637,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)
@@ -1979,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]
@@ -2424,16 +2430,18 @@ class RowIndex(tk.Canvas):
                 self.MT._row_index[datarn] = value
 
     def input_valid_for_cell(self, datarn: int, value: object, check_readonly: bool = True) -> bool:
-        if check_readonly and self.get_cell_kwargs(datarn, key="readonly"):
+        kwargs = self.get_cell_kwargs(datarn, key=None)
+        if check_readonly and "readonly" in kwargs:
             return False
-        if self.get_cell_kwargs(datarn, key="checkbox"):
+        elif "checkbox" in kwargs:
             return is_bool_like(value)
-        if self.cell_equal_to(datarn, value):
-            return False
-        kwargs = self.get_cell_kwargs(datarn, key="dropdown")
-        if kwargs and kwargs["validate_input"] and value not in kwargs["values"]:
-            return False
-        return True
+        else:
+            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:
         self.fix_index(datarn)
@@ -2495,12 +2503,13 @@ class RowIndex(tk.Canvas):
         if self.ops.treeview:
             iid = self.new_iid()
             return Node(text=iid, iid=iid, parent=self.get_row_parent(datarn))
-        if self.get_cell_kwargs(datarn, key="checkbox", cell=r_ops):
+        kwargs = self.get_cell_kwargs(datarn, key=None, cell=r_ops)
+        if "checkbox" in kwargs:
             return False
-        kwargs = self.get_cell_kwargs(datarn, key="dropdown", cell=r_ops)
-        if kwargs and kwargs["validate_input"] and kwargs["values"]:
+        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and kwargs["values"]:
             return kwargs["values"][0]
-        return ""
+        else:
+            return ""
 
     def get_empty_index_seq(self, end: int, start: int = 0, r_ops: bool = True) -> list[object]:
         return [self.get_value_for_empty_cell(datarn, r_ops=r_ops) for datarn in range(start, end)]
@@ -2567,10 +2576,11 @@ class RowIndex(tk.Canvas):
         if redraw:
             self.MT.refresh()
 
-    def get_cell_kwargs(self, datarn: int, key: Hashable = "dropdown", cell: bool = True) -> dict:
-        if cell and datarn in self.cell_options and key in self.cell_options[datarn]:
-            return self.cell_options[datarn][key]
-        return {}
+    def get_cell_kwargs(self, datarn: int, key: Hashable | None = "dropdown", cell: bool = True) -> dict:
+        if cell and datarn in self.cell_options:
+            return self.cell_options[datarn] if key is None else self.cell_options[datarn].get(key, {})
+        else:
+            return {}
 
     # Treeview Mode
 
@@ -2671,29 +2681,35 @@ class RowIndex(tk.Canvas):
                     new_parent = node_change[1]
                     move_to_index = node_change[2]
                     if new_parent:
-                        move_to_index = (
-                            move_to_index if isinstance(move_to_index, int) else len(self.tree[new_parent].children)
-                        )
-                        move_to_row = self.tree_rns[new_parent] + max(
-                            0, min(move_to_index, len(self.tree[new_parent].children))
+                        if isinstance(move_to_index, int):
+                            move_to_index = min(move_to_index, len(self.tree[new_parent].children))
+                        else:
+                            move_to_index = len(self.tree[new_parent].children)
+                        move_to_row = self.tree_rns[new_parent]
+                        _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())
                         if move_to_index is None:
                             move_to_row = self.PAR.top_index_row(num_top_nodes - 1)
                             move_to_index = num_top_nodes
+                            insert_row = move_to_row
                         else:
                             move_to_row = self.PAR.top_index_row(move_to_index)
+                            insert_row = move_to_row
                             if move_to_row is None:
                                 move_to_row = self.PAR.top_index_row(num_top_nodes - 1)
                                 move_to_index = num_top_nodes
+                                insert_row = move_to_row + 1
 
                     move_to_iid = self.MT._row_index[move_to_row].iid
-                    insert_row = move_to_row + 1
                     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
@@ -2715,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)
@@ -2733,14 +2746,14 @@ class RowIndex(tk.Canvas):
                 event_data["moved"]["rows"]["displayed"] = {}
                 if new_loc_is_displayed:
                     if disp_insert_row is None:
-                        if new_parent == self.tree[item].parent:
+                        if new_parent or insert_row > move_to_row:
                             disp_insert_row = self.MT.disprn(self.tree_rns[move_to_iid]) + 1
                         else:
-                            disp_insert_row = self.MT.disprn(self.tree_rns[move_to_iid]) + 1
+                            disp_insert_row = self.MT.disprn(self.tree_rns[move_to_iid])
                     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"] = {}
@@ -2756,7 +2769,6 @@ class RowIndex(tk.Canvas):
                             index=move_to_index,
                         )
                         move_to_index += 1
-
                     event_data["moved"]["rows"]["data"] = get_new_indexes(
                         insert_row,
                         event_data["moved"]["rows"]["data"],
@@ -2764,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(
@@ -2782,7 +2794,6 @@ class RowIndex(tk.Canvas):
         if not undo_modification and data_new_idxs:
             if new_parent and (not self.PAR.item_displayed(new_parent) or new_parent not in self.tree_open_ids):
                 self.PAR.hide_rows(set(data_new_idxs.values()), data_indexes=True)
-
             if new_loc_is_displayed:
                 self.PAR.show_rows(
                     (r for r in data_new_idxs.values() if self.ancestors_all_open(self.MT._row_index[r].iid))
@@ -2835,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
@@ -2894,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:
@@ -2959,9 +2994,7 @@ class RowIndex(tk.Canvas):
     def move_pid_causes_recursive_loop(self, to_move_iid: str, move_to_parent: str) -> bool:
         # if the parent the item is being moved under is one of the item's descendants
         # then it is a recursive loop
-        return to_move_iid == move_to_parent or any(
-            move_to_parent == diid for diid in self.get_iid_descendants(to_move_iid)
-        )
+        return any(move_to_parent == diid for diid in self.get_iid_descendants(to_move_iid))
 
     def tree_build(
         self,
@@ -3075,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,
             )