tksheet 7.2.4__tar.gz → 7.2.6__tar.gz

{tksheet-7.2.4/tksheet.egg-info → tksheet-7.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.2.4
+Version: 7.2.6
 Summary: Tkinter table / sheet widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors

{tksheet-7.2.4 → tksheet-7.2.6}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "tksheet"
 description = "Tkinter table / sheet widget"
 readme = "README.md"
-version = "7.2.4"
+version = "7.2.6"
 authors = [{ name = "ragardner", email = "github@ragardner.simplelogin.com" }]
 requires-python = ">=3.8"
 license = {file = "LICENSE.txt"}

{tksheet-7.2.4 → tksheet-7.2.6}/tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.2.4"
+__version__ = "7.2.6"
 
 from .colors import (
     color_map,
@@ -53,6 +53,7 @@ from .functions import (
     get_new_indexes,
     get_seq_without_gaps_at_index,
     insert_items,
+    is_contiguous,
     is_iterable,
     move_elements_by_mapping,
     move_elements_to,

{tksheet-7.2.4 → tksheet-7.2.6}/tksheet/column_headers.py

@@ -847,8 +847,10 @@ class ColumnHeaders(tk.Canvas):
                     and is_contiguous(self.dragged_col.to_move)
                 )
             ):
-                if c >= len(self.MT.col_positions) - 1:
-                    c -= 1
+                if c > self.dragged_col.to_move[-1]:
+                    c += 1
+                if c > len(self.MT.col_positions) - 1:
+                    c = len(self.MT.col_positions) - 1
                 event_data = event_dict(
                     name="move_columns",
                     sheet=self.PAR.name,
@@ -1010,7 +1012,9 @@ class ColumnHeaders(tk.Canvas):
         txt = self.get_valid_cell_data_as_str(datacn, fix=False)
         if txt:
             self.MT.txt_measure_canvas.itemconfig(
-                self.MT.txt_measure_canvas_text, text=txt, font=self.PAR.ops.header_font
+                self.MT.txt_measure_canvas_text,
+                text=txt,
+                font=self.PAR.ops.header_font,
             )
             b = self.MT.txt_measure_canvas.bbox(self.MT.txt_measure_canvas_text)
             w = b[2] - b[0] + 7

{tksheet-7.2.4 → tksheet-7.2.6}/tksheet/functions.py

@@ -412,8 +412,8 @@ def consecutive_ranges(seq: Sequence[int]) -> Generator[tuple[int, int]]:
             yield seq[start], seq[-1] + 1
 
 
-def is_contiguous(seq: list[int]) -> bool:
-    itr = iter(seq)
+def is_contiguous(iterable: Iterator[int]) -> bool:
+    itr = iter(iterable)
     prev = next(itr)
     return all(i == (prev := prev + 1) for i in itr)
 
@@ -485,7 +485,6 @@ def move_elements_to(
     return move_elements_by_mapping(
         seq,
         *get_new_indexes(
-            len(seq),
             move_to,
             to_move,
             get_inverse=True,
@@ -494,19 +493,15 @@ def move_elements_to(
 
 
 def get_new_indexes(
-    seqlen: int,
     move_to: int,
     to_move: list[int],
-    keep_len: bool = True,
     get_inverse: bool = False,
 ) -> tuple[dict]:
-    # returns
-    # {old idx: new idx, ...}
-    offset = len(to_move) - 1
-    if move_to <= to_move[0]:
-        new_idxs = range(move_to, move_to + len(to_move))
-    else:
-        new_idxs = range(move_to - offset, move_to - offset + len(to_move))
+    """
+    returns {old idx: new idx, ...}
+    """
+    offset = sum(1 for i in to_move if i < move_to)
+    new_idxs = range(move_to - offset, move_to - offset + len(to_move))
     new_idxs = {old: new for old, new in zip(to_move, new_idxs)}
     if get_inverse:
         return new_idxs, dict(zip(new_idxs.values(), new_idxs))

{tksheet-7.2.4 → tksheet-7.2.6}/tksheet/main_table.py

@@ -996,18 +996,16 @@ class MainTable(tk.Canvas):
         data_indexes: bool = False,
     ) -> tuple[dict[int, int], dict[int, int], int, dict[int, int]]:
         if not data_indexes or self.all_columns_displayed:
-            disp_new_idxs = get_new_indexes(
-                seqlen=len(self.col_positions) - 1,
-                move_to=move_to,
-                to_move=to_move,
-            )
+            disp_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
         else:
             disp_new_idxs = {}
-        totalcols = self.equalize_data_row_lengths(at_least_cols=move_to + 1)
-        if self.all_columns_displayed or data_indexes:
-            data_new_idxs = get_new_indexes(seqlen=totalcols, move_to=move_to, to_move=to_move)
-        elif not self.all_columns_displayed and not data_indexes:
-            data_new_idxs = get_new_indexes(seqlen=len(self.displayed_columns), move_to=move_to, to_move=to_move)
+        # at_least_cols should not be len in this case as move_to can be len
+        if not self.all_columns_displayed and not data_indexes:
+            totalcols = self.equalize_data_row_lengths(at_least_cols=self.datacn(move_to))
+        else:
+            totalcols = self.equalize_data_row_lengths(at_least_cols=move_to)
+        data_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
+        if not self.all_columns_displayed and not data_indexes:
             moved = {self.displayed_columns[i] for i in to_move}
             data_new_idxs = dict(
                 filter(
@@ -1233,22 +1231,18 @@ class MainTable(tk.Canvas):
         data_indexes: bool = False,
     ) -> tuple[dict[int, int], dict[int, int], int, dict[int, int]]:
         if not data_indexes or self.all_rows_displayed:
-            disp_new_idxs = get_new_indexes(
-                seqlen=len(self.row_positions) - 1,
-                move_to=move_to,
-                to_move=to_move,
-            )
+            disp_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
         else:
             disp_new_idxs = {}
-        self.fix_data_len(move_to)
-        totalrows = max(
-            self.total_data_rows(),
-            len(self.row_positions) - 1,
-        )
-        if self.all_rows_displayed or data_indexes:
-            data_new_idxs = get_new_indexes(seqlen=totalrows, move_to=move_to, to_move=to_move)
-        elif not self.all_rows_displayed and not data_indexes:
-            data_new_idxs = get_new_indexes(seqlen=len(self.displayed_rows), move_to=move_to, to_move=to_move)
+        # move_to can be len and fix_data_len() takes index so - 1
+        if not self.all_rows_displayed and not data_indexes:
+            fix_len = self.datarn(move_to) - 1
+        else:
+            fix_len = move_to - 1
+        self.fix_data_len(fix_len)
+        totalrows = max(self.total_data_rows(), len(self.row_positions) - 1)
+        data_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
+        if not self.all_rows_displayed and not data_indexes:
             moved = {self.displayed_rows[i] for i in to_move}
             data_new_idxs = dict(
                 filter(
@@ -1284,7 +1278,7 @@ class MainTable(tk.Canvas):
                 len(self.row_positions) - 1,
                 max(data_new_idxs.values(), default=0),
             )
-            self.fix_data_len(totalrows)
+            self.fix_data_len(totalrows - 1)
         if event_data is None:
             event_data = event_dict(
                 name="move_rows",
@@ -3703,10 +3697,9 @@ class MainTable(tk.Canvas):
             else:
                 return False
 
-    def set_all_cell_sizes_to_text(self, w: int | None = None, slim: bool = False) -> tuple[list[float], list[float]]:
+    def set_all_cell_sizes_to_text(self, width: int | None = None, slim: bool = False) -> tuple[list[float], list[float]]:
         min_column_width = int(self.min_column_width)
         min_rh = int(self.min_row_height)
-        w = min_column_width if w is None else w
         h = min_rh
         rhs = defaultdict(lambda: int(min_rh))
         cws = []
@@ -3736,6 +3729,7 @@ class MainTable(tk.Canvas):
                     rhs[datarn] = h
         added_w_space = 1 if slim else 7
         for datacn in itercols:
+            w = min_column_width if width is None else width
             if (hw := self.CH.get_cell_dimensions(datacn)[0]) > w:
                 w = hw
             else:
@@ -4373,7 +4367,7 @@ class MainTable(tk.Canvas):
                 create_ops=create_ops,
             )
         if create_selections:
-            self.deselect("all")
+            self.deselect("all", redraw=False)
             for boxst, boxend in consecutive_ranges(tuple(reversed(column_widths))):
                 self.create_selection_box(
                     0,
@@ -4517,7 +4511,7 @@ class MainTable(tk.Canvas):
                 create_ops=create_ops,
             )
         if create_selections:
-            self.deselect("all")
+            self.deselect("all", redraw=False)
             for boxst, boxend in consecutive_ranges(tuple(reversed(row_heights))):
                 self.create_selection_box(
                     boxst,
@@ -6378,6 +6372,18 @@ class MainTable(tk.Canvas):
             for c in range(box.coords.from_c, box.coords.upto_c)
         }
 
+    def gen_selected_cells(
+        self,
+        get_rows: bool = False,
+        get_cols: bool = False,
+    ) -> Generator[tuple[int, int]]:
+        yield from (
+            (r, c)
+            for item, box in self.get_selection_items(rows=get_rows, columns=get_cols)
+            for r in range(box.coords.from_r, box.coords.upto_r)
+            for c in range(box.coords.from_c, box.coords.upto_c)
+        )
+
     def get_all_selection_boxes(self) -> tuple[tuple[int, int, int, int]]:
         return tuple(box.coords for item, box in self.get_selection_items())
 

{tksheet-7.2.4 → tksheet-7.2.6}/tksheet/row_index.py

@@ -846,8 +846,10 @@ class RowIndex(tk.Canvas):
                     and is_contiguous(self.dragged_row.to_move)
                 )
             ):
-                if r >= len(self.MT.row_positions) - 1:
-                    r -= 1
+                if r > self.dragged_row.to_move[-1]:
+                    r += 1
+                if r > len(self.MT.row_positions) - 1:
+                    r = len(self.MT.row_positions) - 1
                 event_data = event_dict(
                     name="move_rows",
                     sheet=self.PAR.name,
@@ -2488,6 +2490,14 @@ class RowIndex(tk.Canvas):
             ):
                 yield from self.get_iid_descendants(cnode.iid, check_open)
 
+    def items_parent(self, iid: str) -> str:
+        if self.tree[iid].parent:
+            return self.tree[iid].parent.iid
+        return ""
+
+    def gen_top_nodes(self) -> Generator[Node]:
+        yield from (node for node in self.MT._row_index if node.parent == "")
+
     def get_treeview_indent(self, iid: str) -> int:
         if isinstance(self.PAR.ops.treeview_indent, str):
             indent = self.MT.index_txt_width * int(self.PAR.ops.treeview_indent)

{tksheet-7.2.4 → tksheet-7.2.6}/tksheet/sheet.py

@@ -19,6 +19,7 @@ from .column_headers import ColumnHeaders
 from .functions import (
     add_highlight,
     add_to_options,
+    consecutive_ranges,
     convert_align,
     data_to_displayed_idxs,
     del_from_options,
@@ -2440,23 +2441,29 @@ class Sheet(tk.Frame):
             include_header=include_header,
         )
 
-    def full_move_rows_idxs(self, data_idxs: dict[int, int]) -> dict[int, int]:
+    def full_move_rows_idxs(self, data_idxs: dict[int, int], max_idx: int | None = None) -> dict[int, int]:
         """
         Converts the dict provided by moving rows event data
         Under the keys ['moved']['rows']['data']
         Into a dict of {old index: new index} for every row
         Includes row numbers in cell options, spans, etc.
         """
-        return self.MT.get_full_new_idxs(self.MT.get_max_row_idx(), data_idxs)
+        return self.MT.get_full_new_idxs(
+            self.MT.get_max_row_idx() if max_idx is None else max_idx,
+            data_idxs,
+        )
 
-    def full_move_columns_idxs(self, data_idxs: dict[int, int]) -> dict[int, int]:
+    def full_move_columns_idxs(self, data_idxs: dict[int, int], max_idx: int | None = None) -> dict[int, int]:
         """
         Converts the dict provided by moving columns event data
         Under the keys ['moved']['columns']['data']
         Into a dict of {old index: new index} for every column
         Includes column numbers in cell options, spans, etc.
         """
-        return self.MT.get_full_new_idxs(self.MT.get_max_column_idx(), data_idxs)
+        return self.MT.get_full_new_idxs(
+            self.MT.get_max_column_idx() if max_idx is None else max_idx,
+            data_idxs,
+        )
 
     # Highlighting Cells
 
@@ -3005,8 +3012,8 @@ class Sheet(tk.Frame):
                 box=selected[3],
             )
         else:
-            self.MT.deselect()
-        return self
+            self.MT.deselect(redraw=False)
+        return self.set_refresh_timer()
 
     def get_selected_rows(
         self,
@@ -3053,6 +3060,13 @@ class Sheet(tk.Frame):
             )
         return self.MT.get_selected_cells(get_rows=get_rows, get_cols=get_columns)
 
+    def gen_selected_cells(
+        self,
+        get_rows: bool = False,
+        get_columns: bool = False,
+    ) -> Generator[tuple[int, int]]:
+        yield from self.MT.gen_selected_cells(get_rows=get_rows, get_cols=get_columns)
+
     def get_all_selection_boxes(self) -> tuple[tuple[int, int, int, int]]:
         return self.MT.get_all_selection_boxes()
 
@@ -3065,11 +3079,11 @@ class Sheet(tk.Frame):
 
     @boxes.setter
     def boxes(self, boxes: Sequence[tuple[tuple[int, int, int, int], str]]) -> Sheet:
-        self.MT.deselect()
+        self.MT.deselect(redraw=False)
         self.MT.reselect_from_get_boxes(
             boxes={box[0] if isinstance(box[0], tuple) else tuple(box[0]): box[1] for box in boxes}
         )
-        return self
+        return self.set_refresh_timer()
 
     @property
     def canvas_boxes(self) -> dict[int, SelectionBox]:
@@ -3348,7 +3362,7 @@ class Sheet(tk.Frame):
         width: int | None = None,
         slim: bool = False,
     ) -> tuple[list[float], list[float]]:
-        self.MT.set_all_cell_sizes_to_text(w=width, slim=slim)
+        self.MT.set_all_cell_sizes_to_text(width=width, slim=slim)
         self.set_refresh_timer(redraw)
         return self.MT.row_positions, self.MT.col_positions
 
@@ -4700,6 +4714,7 @@ class Sheet(tk.Frame):
             create_selections=False,
             fill=False,
             push_ops=push_ops,
+            redraw=False,
         )
         self.MT.all_rows_displayed = False
         self.MT.displayed_rows = list(range(len(self.MT._row_index)))
@@ -4740,9 +4755,8 @@ class Sheet(tk.Frame):
         open_ids = set(filter(self.exists, map(str.lower, open_ids)))
         self.RI.tree_open_ids = set()
         if open_ids:
-            to_open = self._tree_open(open_ids)
             self.show_rows(
-                rows=to_open,
+                rows=self._tree_open(open_ids),
                 redraw=False,
                 deselect_all=False,
             )
@@ -4991,13 +5005,11 @@ class Sheet(tk.Frame):
             self.move(iid, parent)
         return self
 
-    def find_rn_at_top_index(self, index: int) -> int:
-        wo_par = 0
-        for rn, n in enumerate(self.MT._row_index):
-            if not n.parent:
-                if wo_par == index:
-                    return rn
-                wo_par += 1
+    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)
+        except Exception:
+            return None
 
     def move(self, item: str, parent: str, index: int | None = None) -> Sheet:
         """
@@ -5020,8 +5032,6 @@ class Sheet(tk.Frame):
                     index = len(parent_node.children) - 1
                 item_r = self.RI.tree_rns[item]
                 new_r = self.RI.tree_rns[parent_node.children[index].iid]
-                if item_node not in parent_node.children:
-                    new_r += 1
                 new_r_desc = sum(1 for _ in self.RI.get_iid_descendants(parent_node.children[index].iid))
                 item_desc = sum(1 for _ in self.RI.get_iid_descendants(item))
                 if item_r < new_r:
@@ -5029,6 +5039,8 @@ class Sheet(tk.Frame):
                 else:
                     r_ctr = new_r
             else:
+                if index is None:
+                    index = 0
                 r_ctr = self.RI.tree_rns[parent_node.iid] + 1
             mapping[item_r] = r_ctr
             if parent in self.RI.tree_open_ids and self.item_displayed(parent):
@@ -5039,11 +5051,19 @@ class Sheet(tk.Frame):
                 if to_show and self.RI.ancestors_all_open(did, item_node.parent):
                     to_show.append(r_ctr)
                 r_ctr += 1
-            self.RI.remove_node_from_parents_children(item_node)
-            item_node.parent = parent_node
-            parent_node.children.append(item_node)
+            if parent == self.RI.items_parent(item):
+                pop_index = parent_node.children.index(item_node)
+                parent_node.children.insert(index, parent_node.children.pop(pop_index))
+            else:
+                self.RI.remove_node_from_parents_children(item_node)
+                item_node.parent = parent_node
+                parent_node.children.insert(index, item_node)
         else:
-            new_r = self.find_rn_at_top_index((sum(1 for _ in self.get_children("")) - 1) if index is None else index)
+            if index is None:
+                new_r = self.top_index_row((sum(1 for _ in self.RI.gen_top_nodes()) - 1))
+            else:
+                if (new_r := self.top_index_row(index)) is None:
+                    new_r = self.top_index_row((sum(1 for _ in self.RI.gen_top_nodes()) - 1))
             item_r = self.RI.tree_rns[item]
             if item_r < new_r:
                 par_desc = sum(1 for _ in self.RI.get_iid_descendants(self.rowitem(new_r, data_index=True)))
@@ -5086,7 +5106,7 @@ class Sheet(tk.Frame):
         if (item := item.lower()) not in self.RI.tree:
             raise ValueError(f"Item '{item}' does not exist.")
         if not self.RI.tree[item].parent:
-            return sorted(self.RI.tree_rns[iid] for iid in self.get_children("")).index(self.RI.tree_rns[item])
+            return next(index for index, node in enumerate(self.RI.gen_top_nodes()) if node == self.RI.tree[item])
         return self.RI.tree[item].parent.children.index(self.RI.tree[item])
 
     def item_displayed(self, item: str) -> bool:
@@ -5098,7 +5118,7 @@ class Sheet(tk.Frame):
             raise ValueError(f"Item '{item}' does not exist.")
         return self.RI.tree_rns[item] in self.MT.displayed_rows
 
-    def display_item(self, item: str) -> Sheet:
+    def display_item(self, item: str, redraw=False) -> Sheet:
         """
         Ensure that item is displayed in the tree
         - Opens all of an item's ancestors
@@ -5109,16 +5129,22 @@ class Sheet(tk.Frame):
             raise ValueError(f"Item '{item}' does not exist.")
         if self.RI.tree[item].parent:
             for iid in self.RI.get_iid_ancestors(item):
-                self.item(iid, open_=True)
+                self.item(iid, open_=True, redraw=False)
+        return self.set_refresh_timer(redraw)
 
-    def scroll_to_item(self, item: str) -> Sheet:
+    def scroll_to_item(self, item: str, redraw=False) -> Sheet:
         """
         Scrolls to an item and ensures that it is displayed
         """
         if (item := item.lower()) not in self.RI.tree:
             raise ValueError(f"Item '{item}' does not exist.")
-        self.display_item(item)
-        self.see(row=bisect_left(self.MT.displayed_rows, self.RI.tree_rns[item]), keep_xscroll=True)
+        self.display_item(item, redraw=False)
+        self.see(
+            row=bisect_left(self.MT.displayed_rows, self.RI.tree_rns[item]),
+            keep_xscroll=True,
+            redraw=False,
+        )
+        return self.set_refresh_timer(redraw)
 
     def selection(self, cells: bool = False) -> list[str]:
         """
@@ -5129,45 +5155,68 @@ class Sheet(tk.Frame):
             for rn in self.get_selected_rows(get_cells_as_rows=cells)
         ]
 
-    def selection_set(self, *items) -> Sheet:
+    def selection_set(self, *items, redraw: bool = True) -> Sheet:
         if any(item.lower() in self.RI.tree for item in unpack(items)):
-            self.deselect()
-            self.selection_add(*items)
-        return self
+            self.deselect(redraw=False)
+            self.selection_add(*items, redraw=False)
+        return self.set_refresh_timer(redraw)
 
-    def selection_add(self, *items) -> Sheet:
+    def selection_add(self, *items, redraw: bool = True) -> Sheet:
+        to_open = []
+        quick_displayed_check = set(self.MT.displayed_rows)
         for item in unpack(items):
-            if (item := item.lower()) not in self.RI.tree:
-                continue
-            if not self.item_displayed(item):
-                self.display_item(item)
-            self.add_row_selection(bisect_left(self.MT.displayed_rows, self.RI.tree_rns[item]))
-        return self
+            if self.RI.tree_rns[(item := item.lower())] not in quick_displayed_check and self.RI.tree[item].parent:
+                to_open.extend(list(self.RI.get_iid_ancestors(item)))
+        if to_open:
+            self.show_rows(
+                rows=self._tree_open(to_open),
+                redraw=False,
+                deselect_all=False,
+            )
+        for startr, endr in consecutive_ranges(
+            sorted(
+                bisect_left(
+                    self.MT.displayed_rows,
+                    self.RI.tree_rns[item.lower()],
+                )
+                for item in unpack(items)
+            )
+        ):
+            self.MT.create_selection_box(
+                startr,
+                0,
+                endr,
+                len(self.MT.col_positions) - 1,
+                "rows",
+                set_current=True,
+                ext=True,
+            )
+        self.MT.run_selection_binding("rows")
+        return self.set_refresh_timer(redraw)
 
-    def selection_remove(self, *items) -> Sheet:
+    def selection_remove(self, *items, redraw: bool = True) -> Sheet:
         for item in unpack(items):
             if (item := item.lower()) not in self.RI.tree:
                 continue
             try:
-                self.deselect(bisect_left(self.MT.displayed_rows, self.RI.tree_rns[item]))
+                self.deselect(bisect_left(self.MT.displayed_rows, self.RI.tree_rns[item]), redraw=False)
             except Exception:
                 continue
-        return self
+        return self.set_refresh_timer(redraw)
 
-    def selection_toggle(self, *items) -> Sheet:
+    def selection_toggle(self, *items, redraw: bool = True) -> Sheet:
         selected = set(self.MT._row_index[self.displayed_row_to_data(rn)].iid for rn in self.get_selected_rows())
         add = []
         remove = []
         for item in unpack(items):
-            if (item := item.lower()) not in self.RI.tree:
-                continue
-            if item in selected:
-                remove.append(item)
-            else:
-                add.append(item)
-        self.selection_remove(*remove)
-        self.selection_add(*add)
-        return self
+            if (item := item.lower()) in self.RI.tree:
+                if item in selected:
+                    remove.append(item)
+                else:
+                    add.append(item)
+        self.selection_remove(*remove, redraw=False)
+        self.selection_add(*add, redraw=False)
+        return self.set_refresh_timer(redraw)
 
     # Functions not in docs
 

{tksheet-7.2.4 → tksheet-7.2.6/tksheet.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.2.4
+Version: 7.2.6
 Summary: Tkinter table / sheet widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors