tksheet 7.2.4__py3-none-any.whl → 7.2.5__py3-none-any.whl

tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.2.4"
+__version__ = "7.2.5"
 
 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/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/main_table.py

@@ -996,18 +996,15 @@ 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)
+        if not self.all_columns_displayed and not data_indexes:
+            totalcols = self.equalize_data_row_lengths(at_least_cols=self.datacn(move_to) + 1)
+        else:
+            totalcols = self.equalize_data_row_lengths(at_least_cols=move_to + 1)
+        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 +1230,13 @@ 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)
+        self.fix_data_len(self.datarn(move_to) if not self.all_rows_displayed and not data_indexes else move_to)
+        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 +1272,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",
@@ -4373,7 +4361,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 +4505,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 +6366,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/row_index.py

@@ -2488,6 +2488,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/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]:
@@ -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.dist-info → tksheet-7.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.2.4
+Version: 7.2.5
 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.dist-info → tksheet-7.2.5.dist-info}/RECORD

@@ -1,20 +1,20 @@
-tksheet/__init__.py,sha256=BW3Re3N7ZT4N4duPVUyOe9D4v3KgirJH9kck_Mxl3JA,2124
+tksheet/__init__.py,sha256=jxysTI4P2sqhdCWqckgkzFoja_LNIxd-Xbd57GWir6A,2144
 tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
 tksheet/column_headers.py,sha256=PTkKI8OHWn4GzBhPJYU7c8Lz0X52DldV-0J4mPQbjkE,102045
 tksheet/formatters.py,sha256=DXif00aq9DgFpXwkbiqD86KxtDg0Meop51hLY-KcGNQ,10037
-tksheet/functions.py,sha256=rNfDpQRoXZm_Ro-tlF92ox3fi37p71Mio1PGTreM_oc,40835
-tksheet/main_table.py,sha256=VIP-SV3Z9QVH9qVbBth1koI-9PVj6yPQZQ4w_yrVp5U,327474
+tksheet/functions.py,sha256=Ie53z5GWbGoUXUiTf0DtoyOadWFbMFXMFwUjM67vetI,40706
+tksheet/main_table.py,sha256=tC3spF57o_yEc-o5b0USonf25d3dCZT9LS1UFKWfjaU,327559
 tksheet/other_classes.py,sha256=CDN38ZjKxZro9YOS_g0DjMC82-Mi9udedny4wdd90W0,14347
-tksheet/row_index.py,sha256=36e4xgNMwMuvciKLIboKpsiFBrMy_URh7y4OZX8Ygvo,108219
-tksheet/sheet.py,sha256=MWd753gZeFZ4u4w7ZLLSloaIqJg2TNsdvJFvAcxuL-E,270230
+tksheet/row_index.py,sha256=IdmELtqq5siD2dLtCMdP2IkW6XljCVJyBwZo3GFWoOE,108497
+tksheet/sheet.py,sha256=hWNp4E0UtbUbbbBNfTOecfadGWoWrRbxbfcLQEVW7pw,272364
 tksheet/sheet_options.py,sha256=Azo7_-H0e0ssYEoU7Mq_OWy3S-U05rp4_6Q2E2Ffuu8,12262
 tksheet/text_editor.py,sha256=aRm1Y5GfORiEAJthtN1uQ30CT3VoF8mRWvR-SIXPrJU,6548
 tksheet/themes.py,sha256=N9nAj6vcWk4UdcrAakvz2LPbJEJWXdv3j7Om6AnvX5k,14474
 tksheet/top_left_rectangle.py,sha256=o-M6i5NjaJwo60tV-BDP9SbaT1CzQNoPjuoC7p-nb5Q,8436
 tksheet/types.py,sha256=IgoEHMbceKpakcZtanxKaKJ4RdCq7UW6EoEIIz5O59k,340
 tksheet/vars.py,sha256=86ubZZElsnQuC6Lv6bW2lt2NhD9wAp6PxtkK7ufKqq0,3452
-tksheet-7.2.4.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
-tksheet-7.2.4.dist-info/METADATA,sha256=zPj4U-AFwX_X_Vhzq6SlOAk73teNB50Ple_OvTHLvN4,6284
-tksheet-7.2.4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-tksheet-7.2.4.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
-tksheet-7.2.4.dist-info/RECORD,,
+tksheet-7.2.5.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
+tksheet-7.2.5.dist-info/METADATA,sha256=svT0ORmBRA9KUD05sBQFVDLkvLBjFWicOi-pJvnw3HQ,6284
+tksheet-7.2.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+tksheet-7.2.5.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
+tksheet-7.2.5.dist-info/RECORD,,