tksheet 7.5.3__tar.gz → 7.5.5__tar.gz

{tksheet-7.5.3/tksheet.egg-info → tksheet-7.5.5}/PKG-INFO

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

{tksheet-7.5.3 → tksheet-7.5.5}/pyproject.toml

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

{tksheet-7.5.3 → tksheet-7.5.5}/tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.5.3"
+__version__ = "7.5.5"
 
 from .colors import (
     color_map,

{tksheet-7.5.3 → tksheet-7.5.5}/tksheet/functions.py

@@ -765,6 +765,14 @@ def add_to_displayed(displayed: list[int], to_add: Iterable[int]) -> list[int]:
     return displayed
 
 
+def push_displayed(displayed: list[int], to_add: Iterable[int]) -> list[int]:
+    # assumes to_add is sorted
+    for i in to_add:
+        ins = bisect_left(displayed, i)
+        displayed[ins:] = [e + 1 for e in islice(displayed, ins, None)]
+    return displayed
+
+
 def move_elements_by_mapping(
     seq: list[Any],
     new_idxs: dict[int, int],
@@ -853,18 +861,6 @@ def insert_items(
     return seq
 
 
-def del_placeholder_dict_key(
-    d: dict[Hashable, Any],
-    k: Hashable,
-    v: Any,
-    p: tuple = (),
-) -> dict[Hashable, Any]:
-    if p in d:
-        del d[p]
-    d[k] = v
-    return d
-
-
 def data_to_displayed_idxs(
     to_convert: list[int],
     displayed: list[int],
@@ -1207,14 +1203,14 @@ PATTERN_ALL = re.compile(r"^:$")  # ":"
 
 def span_a2i(a: str) -> int | None:
     n = 0
-    for c in a:
+    for c in a.upper():
         n = n * 26 + ord(c) - ORD_A + 1
     return n - 1
 
 
 def span_a2n(a: str) -> int | None:
     n = 0
-    for c in a:
+    for c in a.upper():
         n = n * 26 + ord(c) - ORD_A + 1
     return n
 
@@ -1251,7 +1247,7 @@ def key_to_span(
         return coords_to_span(widget=widget, from_r=None, from_c=None, upto_r=None, upto_c=None)
 
     # Validate input type
-    elif not isinstance(key, (str, int, slice, list, tuple)):
+    elif not isinstance(key, (str, int, slice, tuple, list)):
         return f"Key type must be either str, int, list, tuple or slice, not '{type(key).__name__}'."
 
     try:
@@ -1277,22 +1273,34 @@ def key_to_span(
             )
 
         # Sequence key: various span formats
-        elif isinstance(key, (list, tuple)):
-            if (
-                len(key) == 2
-                and (isinstance(key[0], int) or key[0] is None)
-                and (isinstance(key[1], int) or key[1] is None)
-            ):
-                # Single cell or partial span: (row, col)
-                r_int = isinstance(key[0], int)
-                c_int = isinstance(key[1], int)
-                return span_dict(
-                    from_r=key[0] if r_int else 0,
-                    from_c=key[1] if c_int else 0,
-                    upto_r=key[0] + 1 if r_int else None,
-                    upto_c=key[1] + 1 if c_int else None,
-                    widget=widget,
-                )
+        elif isinstance(key, (tuple, list)):
+            if len(key) == 2:
+                if (isinstance(key[0], int) or key[0] is None) and (isinstance(key[1], int) or key[1] is None):
+                    # Single cell or partial span: (row, col)
+                    r_int = isinstance(key[0], int)
+                    c_int = isinstance(key[1], int)
+                    return span_dict(
+                        from_r=key[0] if r_int else 0,
+                        from_c=key[1] if c_int else 0,
+                        upto_r=key[0] + 1 if r_int else None,
+                        upto_c=key[1] + 1 if c_int else None,
+                        widget=widget,
+                    )
+
+                elif isinstance(key[0], int) and isinstance(key[1], str):
+                    # Single cell with column letter: (row 0, col A)
+                    c_int = span_a2i(key[1])
+                    return span_dict(
+                        from_r=key[0],
+                        from_c=c_int,
+                        upto_r=key[0] + 1,
+                        upto_c=c_int + 1,
+                        widget=widget,
+                    )
+
+                else:
+                    return f"'{key}' could not be converted to span."
+
             elif len(key) == 4:
                 # Full span coordinates: (from_r, from_c, upto_r, upto_c)
                 return coords_to_span(
@@ -1302,7 +1310,7 @@ def key_to_span(
                     upto_r=key[2],
                     upto_c=key[3],
                 )
-            elif len(key) == 2 and all(isinstance(k, (list, tuple)) for k in key):
+            elif len(key) == 2 and all(isinstance(k, (tuple, list)) for k in key):
                 # Start and end points: ((from_r, from_c), (upto_r, upto_c))
                 return coords_to_span(
                     widget=widget,
@@ -1339,11 +1347,12 @@ def key_to_span(
                     widget=widget,
                 )
             elif m := PATTERN_COL.match(key):
+                c_int = span_a2i(m[1])
                 return span_dict(
                     from_r=None,
-                    from_c=span_a2i(m[1]),
+                    from_c=c_int,
                     upto_r=None,
-                    upto_c=span_a2n(m[1]),
+                    upto_c=c_int + 1,
                     widget=widget,
                 )
             elif m := PATTERN_CELL.match(key):

{tksheet-7.5.3 → tksheet-7.5.5}/tksheet/main_table.py

@@ -1967,6 +1967,7 @@ class MainTable(tk.Canvas):
                     )
             else:
                 self.recreate_all_selection_boxes()
+
         return data_new_idxs, disp_new_idxs, event_data
 
     def get_max_row_idx(self, maxidx: int | None = None) -> int:
@@ -2117,6 +2118,7 @@ class MainTable(tk.Canvas):
         event_data["selection_boxes"] = modification["selection_boxes"]
         event_data["selected"] = modification["selected"]
         saved_cells = False
+
         if modification["added"]["rows"] or modification["added"]["columns"]:
             event_data = self.save_cells_using_modification(modification, event_data)
             saved_cells = True
@@ -5629,12 +5631,8 @@ class MainTable(tk.Canvas):
         return {
             "row_positions": list(self.row_positions),
             "col_positions": list(self.col_positions),
-            "displayed_rows": int(self.displayed_rows)
-            if isinstance(self.displayed_rows, int)
-            else list(self.displayed_rows),
-            "displayed_columns": int(self.displayed_columns)
-            if isinstance(self.displayed_columns, int)
-            else list(self.displayed_columns),
+            "displayed_rows": list(self.displayed_rows),
+            "displayed_columns": list(self.displayed_columns),
             "all_rows_displayed": bool(self.all_rows_displayed),
             "saved_row_heights": dict(self.saved_row_heights),
             "saved_column_widths": dict(self.saved_column_widths),

{tksheet-7.5.3 → tksheet-7.5.5}/tksheet/other_classes.py

@@ -481,10 +481,10 @@ class Node:
         parent: str = "",
         children: list[str] | None = None,
     ) -> None:
-        self.text = text
-        self.iid = iid
-        self.parent = parent
-        self.children = children if children else []
+        self.text: str = text
+        self.iid: str = iid
+        self.parent: str = parent
+        self.children: list[str] = children if children else []
 
 
 class StorageBase:

{tksheet-7.5.3 → tksheet-7.5.5}/tksheet/row_index.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import tkinter as tk
 from collections import defaultdict
 from collections.abc import Callable, Generator, Hashable, Iterator, Sequence
-from contextlib import suppress
 from functools import partial
 from itertools import islice, repeat
 from math import ceil
@@ -22,7 +21,6 @@ from .formatters import is_bool_like, try_to_bool
 from .functions import (
     add_to_displayed,
     consecutive_ranges,
-    del_placeholder_dict_key,
     event_dict,
     event_has_char_key,
     event_opens_dropdown_or_checkbox,
@@ -34,6 +32,7 @@ from .functions import (
     mod_event_val,
     new_tk_event,
     num2alpha,
+    push_displayed,
     rounded_box_coords,
     stored_event_dict,
     try_b_index,
@@ -839,7 +838,7 @@ class RowIndex(tk.Canvas):
                         move_heights=self.ops.row_drag_and_drop_perform,
                         event_data=event_data,
                     )
-                    if data_new_idxs and disp_new_idxs:
+                    if data_new_idxs:
                         event_data["moved"]["rows"] = {
                             "data": data_new_idxs,
                             "displayed": disp_new_idxs,
@@ -2634,13 +2633,17 @@ class RowIndex(tk.Canvas):
 
             # handle displaying the new rows
             event_data["added"]["rows"]["row_heights"] = {}
+            # parent exists and it's displayed and it's open
             if parent and self.PAR.item_displayed(parent) and parent in self.tree_open_ids:
                 self.MT.displayed_rows = add_to_displayed(self.MT.displayed_rows, event_data["added"]["rows"]["index"])
                 disp_idx = self.MT.disprn(self.rns[a_node.iid])  # first node, they're contiguous because not undo
                 h = self.MT.get_default_row_height()
                 for i in range(len(event_data["added"]["rows"]["index"])):
                     event_data["added"]["rows"]["row_heights"][disp_idx + i] = h
-
+            # parent exists and either it's not displayed or not open
+            elif parent:
+                self.MT.displayed_rows = push_displayed(self.MT.displayed_rows, event_data["added"]["rows"]["index"])
+            # no parent, top level
             elif not parent:
                 self.MT.displayed_rows = add_to_displayed(self.MT.displayed_rows, event_data["added"]["rows"]["index"])
                 h = self.MT.get_default_row_height()
@@ -2675,34 +2678,38 @@ class RowIndex(tk.Canvas):
                     moved_rows = [self.rns[item]]
                     new_parent = node_change[1]
                     move_to_index = node_change[2]
+                    # new parent exists
                     if new_parent:
+                        new_par_cn = self.iid_children(new_parent)
+                        # determine index
                         if isinstance(move_to_index, int):
-                            move_to_index = min(move_to_index, len(self.iid_children(new_parent)))
+                            move_to_index = min(move_to_index, len(new_par_cn))
                         else:
-                            move_to_index = len(self.iid_children(new_parent))
-                        move_to_row = self.rns[new_parent]
-                        _find = move_to_index + 1 if new_parent == self.iid_parent(item) else move_to_index
-                        move_to_row += _find + sum(
-                            self.num_descendants(cid) for cid in islice(self.iid_children(new_parent), _find)
-                        )
-                        insert_row = move_to_row + 1
+                            move_to_index = len(new_par_cn)
+                        # determine insert row
+                        if not new_par_cn:
+                            insert_row = self.rns[new_parent] + 1
+                        elif move_to_index >= len(new_par_cn):
+                            insert_row = self.rns[new_par_cn[-1]] + self.num_descendants(new_par_cn[-1]) + 1
+                        elif new_parent == self.iid_parent(item):
+                            if move_to_index <= self.PAR.index(item):
+                                # Insert before the sibling at move_to_index
+                                insert_row = self.rns[new_par_cn[move_to_index]]
+                            else:
+                                # Insert after the sibling at move_to_index
+                                insert_row = self.rns[new_par_cn[move_to_index]]
+                                insert_row += 1 + self.num_descendants(new_par_cn[move_to_index])
+                        else:
+                            insert_row = self.rns[new_par_cn[move_to_index]]
+                    # no new parent
                     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
+                        # determine index
+                        if isinstance(move_to_index, int):
+                            move_to_index = min(move_to_index, sum(1 for _ in self.gen_top_nodes()))
                         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
-                    disp_insert_row = None
-
+                            move_to_index = sum(1 for _ in self.gen_top_nodes())
+                        # determine insert row
+                        insert_row = self.PAR._get_id_insert_row(move_to_index, new_parent)
                 else:
                     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}
@@ -2713,21 +2720,18 @@ class RowIndex(tk.Canvas):
                     item = self.MT._row_index[moved_rows[0]].iid
 
                     if isinstance(event_data.value, int):
-                        disp_insert_row = event_data.value
-                        if disp_insert_row >= len(self.MT.displayed_rows):
+                        if event_data.value >= len(self.MT.displayed_rows):
                             insert_row = len(self.MT._row_index)
                         else:
-                            insert_row = self.MT.datarn(disp_insert_row)
+                            insert_row = self.MT.datarn(event_data.value)
                         move_to_iid = self.MT._row_index[min(insert_row, len(self.MT._row_index) - 1)].iid
 
                     else:
-                        disp_insert_row = None
                         min_from = min(event_data["moved"]["rows"]["data"])
                         # 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())
                         insert_row = max_to if min_from <= min_to else min_to
-                        move_to_row = insert_row
                         move_to_iid = self.MT._row_index[insert_row].iid
 
                     move_to_index = self.PAR.index(move_to_iid)
@@ -2738,19 +2742,7 @@ class RowIndex(tk.Canvas):
                 new_loc_is_displayed = not new_parent or (
                     new_parent and new_parent in self.tree_open_ids and self.PAR.item_displayed(new_parent)
                 )
-                # deal with displayed mapping
                 event_data["moved"]["rows"]["displayed"] = {}
-                with suppress(Exception):
-                    if new_loc_is_displayed:
-                        if disp_insert_row is None:
-                            if new_parent or insert_row > move_to_row:
-                                disp_insert_row = self.MT.disprn(self.rns[move_to_iid]) + 1
-                            else:
-                                disp_insert_row = self.MT.disprn(self.rns[move_to_iid])
-                        if (disp_from_row := self.MT.try_disprn(self.rns[item])) is not None:
-                            event_data["moved"]["rows"]["displayed"] = {disp_from_row: disp_insert_row}
-                        else:
-                            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"] = {}
@@ -2772,15 +2764,6 @@ class RowIndex(tk.Canvas):
                     )
                     data_new_idxs = event_data["moved"]["rows"]["data"]
                     data_old_idxs = {v: k for k, v in data_new_idxs.items()}
-
-                    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(
-                            disp_insert_row,
-                            event_data["moved"]["rows"]["displayed"],
-                        )
                     disp_new_idxs = event_data["moved"]["rows"]["displayed"]
 
         if data_new_idxs:
@@ -2817,8 +2800,7 @@ class RowIndex(tk.Canvas):
             # its the same parent, we're just moving index
             if parent == item_node.parent:
                 event_data = self.copy_nodes((item, parent), event_data)
-                pop_index = parent_node.children.index(item)
-                parent_node.children.insert(index, parent_node.children.pop(pop_index))
+                parent_node.children.insert(index, parent_node.children.pop(parent_node.children.index(item)))
 
             else:
                 if item_node.parent:
@@ -2842,29 +2824,16 @@ class RowIndex(tk.Canvas):
         mapping = event_data["moved"]["rows"]["data"]
         row_ctr = next(reversed(mapping.values())) + 1
 
-        if disp_mapping := event_data["moved"]["rows"]["displayed"]:
-            if () in disp_mapping:
-                disp_row_ctr = next(reversed(disp_mapping.values()))
-            else:
-                disp_row_ctr = next(reversed(disp_mapping.values())) + 1
-
         rn = self.rns[item]
         if rn not in mapping:
             mapping[rn] = row_ctr
             row_ctr += 1
-            if disp_mapping and (disp_from := self.MT.try_disprn(rn)) is not None:
-                disp_mapping = del_placeholder_dict_key(disp_mapping, disp_from, disp_row_ctr)
-                disp_row_ctr += 1
 
         for did in self.get_iid_descendants(item):
             mapping[self.rns[did]] = row_ctr
             row_ctr += 1
-            if disp_mapping and (disp_from := self.MT.try_disprn(self.rns[did])) is not None:
-                disp_mapping = del_placeholder_dict_key(disp_mapping, disp_from, disp_row_ctr)
-                disp_row_ctr += 1
 
         event_data["moved"]["rows"]["data"] = mapping
-        event_data["moved"]["rows"]["displayed"] = disp_mapping
 
         return event_data
 
@@ -2872,21 +2841,11 @@ class RowIndex(tk.Canvas):
         for iid, node in event_data["treeview"]["nodes"].items():
             self.MT._row_index[self.rns[iid]] = node
 
-    def copy_node(self, item: str) -> Node:
-        n = self.iid_node(item)
-        return Node(
-            text=n.text,
-            iid=n.iid,
-            parent=n.parent,
-            children=n.children.copy(),
-        )
-
     def copy_nodes(self, items: Iterator[str], event_data: EventDataDict) -> EventDataDict:
-        nodes = event_data["treeview"]["nodes"]
         for iid in items:
-            if iid not in nodes:
+            if iid not in event_data["treeview"]["nodes"]:
                 n = self.iid_node(iid)
-                nodes[iid] = Node(
+                event_data["treeview"]["nodes"][iid] = Node(
                     text=n.text,
                     iid=n.iid,
                     parent=n.parent,

{tksheet-7.5.3 → tksheet-7.5.5}/tksheet/sheet.py

@@ -4744,26 +4744,31 @@ class Sheet(tk.Frame):
             self.hide_rows(datarn, deselect_all=False, data_indexes=True)
         return iid
 
-    def _get_id_insert_row(self, index: int, parent: str) -> int:
+    def _get_id_insert_row(self, index: int | None, parent: str) -> int:
         if parent:
+            chn = self.RI.iid_children(parent)
             if isinstance(index, int):
-                index = min(index, len(self.RI.iid_children(parent)))
-                datarn = (
-                    self.RI.rns[parent]
-                    + index
-                    + 1
-                    + sum(self.RI.num_descendants(cid) for cid in islice(self.get_children(parent), index))
-                )
+                index = min(index, len(chn))
+                if index == 0:
+                    return self.RI.rns[parent] + 1
+                else:
+                    prev_chld = chn[index - 1]
+                    return self.RI.rns[prev_chld] + self.RI.num_descendants(prev_chld) + 1
             else:
-                datarn = self.RI.rns[parent] + self.RI.num_descendants(parent) + 1
+                if chn:
+                    last_chld = chn[-1]
+                    last_chld_rn = self.RI.rns[last_chld]
+                    return last_chld_rn + self.RI.num_descendants(last_chld) + 1
+                else:
+                    return self.RI.rns[parent] + 1
         else:
             if isinstance(index, int):
-                datarn = index
-                if index and (datarn := self.top_index_row(datarn)) is None:
-                    datarn = len(self.MT._row_index)
+                if index == 0:
+                    return 0
+                datarn = self.top_index_row(index)
+                return len(self.MT._row_index) if datarn is None else datarn
             else:
-                datarn = len(self.MT._row_index)
-        return datarn
+                return len(self.MT._row_index)
 
     def bulk_insert(
         self,
@@ -4792,6 +4797,8 @@ class Sheet(tk.Frame):
         rns_to_add = {}
         for rn, r in enumerate(data, start=datarn):
             iid = self.RI.new_iid() if iid_column is None else r[iid_column]
+            if iid in self.RI.rns:
+                raise ValueError(f"iid '{iid}' already exists.")
             new_node = Node(
                 r[text_column] if isinstance(text_column, int) else text_column if isinstance(text_column, str) else "",
                 iid,
@@ -4995,11 +5002,24 @@ class Sheet(tk.Frame):
             raise ValueError(f"Item '{item}' does not exist.")
         return self.RI.iid_parent(item)
 
-    def index(self, item: str) -> int:
+    def index(self, item: str, safety: bool = False) -> int:
+        """
+        Finds the index of an item amongst it's siblings in the
+        treeview.
+
+        'safety' is only necessary when the internal row number dict
+        is not able to provide row numbers, e.g. when modifying the
+        tree and before the action is complete.
+
+        When 'True' the fn uses list.index() instead.
+        """
         if item not in self.RI.rns:
             raise ValueError(f"Item '{item}' does not exist.")
-        elif self.RI.iid_parent(item):
-            return self.RI.parent_node(item).children.index(item)
+        elif par := self.RI.iid_parent(item):
+            if not safety:
+                return self.RI.rns[item] - self.RI.rns[par] - 1
+            else:
+                return self.RI.parent_node(item).children.index(item)
         else:
             return next(index for index, iid in enumerate(self.get_children("")) if iid == item)
 
@@ -6349,20 +6369,14 @@ class Sheet(tk.Frame):
             **{k: v["dropdown"] for k, v in self.MT.row_options.items() if "dropdown" in v},
             **{k: v["dropdown"] for k, v in self.MT.col_options.items() if "dropdown" in v},
         }
-        if "dropdown" in self.MT.options:
-            return {**d, "dropdown": self.MT.options["dropdown"]}
         return d
 
     def get_header_dropdowns(self) -> dict:
         d = {k: v["dropdown"] for k, v in self.CH.cell_options.items() if "dropdown" in v}
-        if "dropdown" in self.CH.options:
-            return {**d, "dropdown": self.CH.options["dropdown"]}
         return d
 
     def get_index_dropdowns(self) -> dict:
         d = {k: v["dropdown"] for k, v in self.RI.cell_options.items() if "dropdown" in v}
-        if "dropdown" in self.RI.options:
-            return {**d, "dropdown": self.RI.options["dropdown"]}
         return d
 
     def set_dropdown_values(

{tksheet-7.5.3 → tksheet-7.5.5/tksheet.egg-info}/PKG-INFO

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