tksheet 7.4.4__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)
@@ -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)
@@ -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]
@@ -2433,12 +2435,13 @@ class RowIndex(tk.Canvas):
             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:
         self.fix_index(datarn)
@@ -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:
@@ -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,
             )