tksheet 7.4.6__tar.gz → 7.4.7__tar.gz

{tksheet-7.4.6/tksheet.egg-info → tksheet-7.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tksheet
-Version: 7.4.6
+Version: 7.4.7
 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.4.6 → tksheet-7.4.7}/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.4.6"
+version = "7.4.7"
 authors = [{ name = "ragardner", email = "github@ragardner.simplelogin.com" }]
 requires-python = ">=3.8"
 license = {file = "LICENSE.txt"}

{tksheet-7.4.6 → tksheet-7.4.7}/tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.4.6"
+__version__ = "7.4.7"
 
 from .colors import (
     color_map,
@@ -73,6 +73,7 @@ from .functions import (
     move_elements_to,
     new_tk_event,
     num2alpha,
+    push_n,
     rounded_box_coords,
     span_dict,
     tksheet_type_error,

{tksheet-7.4.6 → tksheet-7.4.7}/tksheet/functions.py

@@ -20,6 +20,7 @@ from .tksheet_types import AnyIter
 
 unpickle_obj = pickle.loads
 lines_re = re.compile(r"[^\n]+")
+ORD_A = ord("A")
 
 
 def wrap_text(
@@ -517,9 +518,8 @@ def force_bool(o: Any) -> bool:
 def alpha2idx(a: str) -> int | None:
     try:
         n = 0
-        orda = ord("A")
         for c in a.upper():
-            n = n * 26 + ord(c) - orda + 1
+            n = n * 26 + ord(c) - ORD_A + 1
         return n - 1
     except Exception:
         return None
@@ -1108,6 +1108,37 @@ def coords_to_span(
     )
 
 
+PATTERN_ROW = re.compile(r"^(\d+)$")  # "1"
+PATTERN_COL = re.compile(r"^([A-Z]+)$")  # "A"
+PATTERN_CELL = re.compile(r"^([A-Z]+)(\d+)$")  # "A1"
+PATTERN_RANGE = re.compile(r"^([A-Z]+)(\d+):([A-Z]+)(\d+)$")  # "A1:B2"
+PATTERN_ROW_RANGE = re.compile(r"^(\d+):(\d+)$")  # "1:2"
+PATTERN_ROW_START = re.compile(r"^(\d+):$")  # "2:"
+PATTERN_ROW_END = re.compile(r"^:(\d+)$")  # ":2"
+PATTERN_COL_RANGE = re.compile(r"^([A-Z]+):([A-Z]+)$")  # "A:B"
+PATTERN_COL_START = re.compile(r"^([A-Z]+):$")  # "A:"
+PATTERN_COL_END = re.compile(r"^:([A-Z]+)$")  # ":B"
+PATTERN_CELL_START = re.compile(r"^([A-Z]+)(\d+):$")  # "A1:"
+PATTERN_CELL_END = re.compile(r"^:([A-Z]+)(\d+)$")  # ":B1"
+PATTERN_CELL_COL = re.compile(r"^([A-Z]+)(\d+):([A-Z]+)$")  # "A1:B"
+PATTERN_CELL_ROW = re.compile(r"^([A-Z]+)(\d+):(\d+)$")  # "A1:2"
+PATTERN_ALL = re.compile(r"^:$")  # ":"
+
+
+def span_a2i(a: str) -> int | None:
+    n = 0
+    for c in a:
+        n = n * 26 + ord(c) - ORD_A + 1
+    return n - 1
+
+
+def span_a2n(a: str) -> int | None:
+    n = 0
+    for c in a:
+        n = n * 26 + ord(c) - ORD_A + 1
+    return n
+
+
 def key_to_span(
     key: (
         str
@@ -1120,76 +1151,32 @@ def key_to_span(
     spans: dict[str, Span],
     widget: Any = None,
 ) -> Span:
+    """
+    Convert various input types to a Span object representing a 2D range.
+
+    Args:
+        key: The input to convert (str, int, slice, sequence, or None).
+        spans: A dictionary of named spans (e.g., {"<name>": Span(...)}).
+        widget: Optional widget context for span creation.
+
+    Returns:
+        A Span object or an error message string if the key is invalid.
+    """
+    # Handle Span object directly
     if isinstance(key, Span):
         return key
+
+    # Handle None as full span
     elif key is None:
-        key = (None, None, None, None)
+        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)):
-        return f"Key type must be either str, int, list, tuple or slice, not '{type(key)}'."
+        return f"Key type must be either str, int, list, tuple or slice, not '{type(key).__name__}'."
+
     try:
-        if isinstance(key, (list, tuple)):
-            if isinstance(key[0], int) or key[0] is None:
-                if len(key) == 2:
-                    """
-                    (int | None, int | None) -
-                    (0, 0) - row 0, column 0 - the first cell
-                    (0, None) - row 0, all columns
-                    (None, 0) - column 0, all rows
-                    """
-                    return span_dict(
-                        from_r=key[0] if isinstance(key[0], int) else 0,
-                        from_c=key[1] if isinstance(key[1], int) else 0,
-                        upto_r=(key[0] + 1) if isinstance(key[0], int) else None,
-                        upto_c=(key[1] + 1) if isinstance(key[1], int) else None,
-                        widget=widget,
-                    )
-
-                elif len(key) == 4:
-                    """
-                    (int | None, int | None, int | None, int | None) -
-                    (from row,  from column, up to row, up to column)
-                    """
-                    return coords_to_span(
-                        widget=widget,
-                        from_r=key[0],
-                        from_c=key[1],
-                        upto_r=key[2],
-                        upto_c=key[3],
-                    )
-                    # return span_dict(
-                    #     from_r=key[0] if isinstance(key[0], int) else 0,
-                    #     from_c=key[1] if isinstance(key[1], int) else 0,
-                    #     upto_r=key[2] if isinstance(key[2], int) else None,
-                    #     upto_c=key[3] if isinstance(key[3], int) else None,
-                    #     widget=widget,
-                    # )
-
-            elif isinstance(key[0], (list, tuple)):
-                """
-                ((int | None, int | None), (int | None, int | None))
-
-                First Sequence is start row and column
-                Second Sequence is up to but not including row and column
-                """
-                return coords_to_span(
-                    widget=widget,
-                    from_r=key[0][0],
-                    from_c=key[0][1],
-                    upto_r=key[1][0],
-                    upto_c=key[1][1],
-                )
-                # return span_dict(
-                #     from_r=key[0][0] if isinstance(key[0][0], int) else 0,
-                #     from_c=key[0][1] if isinstance(key[0][1], int) else 0,
-                #     upto_r=key[1][0],
-                #     upto_c=key[1][1],
-                #     widget=widget,
-                # )
-
-        elif isinstance(key, int):
-            """
-            [int] - Whole row at that index
-            """
+        # Integer key: whole row
+        if isinstance(key, int):
             return span_dict(
                 from_r=key,
                 from_c=None,
@@ -1198,29 +1185,8 @@ def key_to_span(
                 widget=widget,
             )
 
+        # Slice key: row range
         elif isinstance(key, slice):
-            """
-            [slice]
-            """
-            """
-            [:] - All rows
-            """
-            if key.start is None and key.stop is None:
-                """
-                [:]
-                """
-                return span_dict(
-                    from_r=0,
-                    from_c=None,
-                    upto_r=None,
-                    upto_c=None,
-                    widget=widget,
-                )
-            """
-            [1:3] - Rows 1, 2
-            [:2] - Rows up to but not including 2
-            [2:] - Rows starting from and including 2
-            """
             start = 0 if key.start is None else key.start
             return span_dict(
                 from_r=start,
@@ -1230,251 +1196,187 @@ def key_to_span(
                 widget=widget,
             )
 
+        # 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 len(key) == 4:
+                # Full span coordinates: (from_r, from_c, upto_r, upto_c)
+                return coords_to_span(
+                    widget=widget,
+                    from_r=key[0],
+                    from_c=key[1],
+                    upto_r=key[2],
+                    upto_c=key[3],
+                )
+            elif len(key) == 2 and all(isinstance(k, (list, tuple)) for k in key):
+                # Start and end points: ((from_r, from_c), (upto_r, upto_c))
+                return coords_to_span(
+                    widget=widget,
+                    from_r=key[0][0],
+                    from_c=key[0][1],
+                    upto_r=key[1][0],
+                    upto_c=key[1][1],
+                )
+
+        # String key: parse various span formats
         elif isinstance(key, str):
             if not key:
-                key = ":"
-
-            if key.startswith("<") and key.endswith(">"):
-                if (key := key[1:-1]) in spans:
-                    """
-                    ["<name>"] - Surrounded by "<" ">" cells from a named range
-                    """
-                    return spans[key]
-                return f"'{key}' not in named spans."
-
-            key = key.upper()
-
-            if key.isdigit():
-                """
-                ["1"] - Row 0
-                """
+                # Empty string treated as full span
                 return span_dict(
-                    from_r=int(key) - 1,
+                    from_r=0,
                     from_c=None,
-                    upto_r=int(key),
+                    upto_r=None,
                     upto_c=None,
                     widget=widget,
                 )
+            elif key.startswith("<") and key.endswith(">"):
+                name = key[1:-1]
+                return spans.get(name, f"'{name}' not in named spans.")
 
-            if key.isalpha():
-                """
-                ["A"] - Column 0
-                """
+            key = key.upper()  # Case-insensitive parsing
+
+            # Match string against precompiled patterns
+            if m := PATTERN_ROW.match(key):
+                return span_dict(
+                    from_r=int(m[1]) - 1,
+                    from_c=None,
+                    upto_r=int(m[1]),
+                    upto_c=None,
+                    widget=widget,
+                )
+            elif m := PATTERN_COL.match(key):
                 return span_dict(
                     from_r=None,
-                    from_c=alpha2idx(key),
+                    from_c=span_a2i(m[1]),
                     upto_r=None,
-                    upto_c=alpha2idx(key) + 1,
+                    upto_c=span_a2n(m[1]),
                     widget=widget,
                 )
-
-            splitk = key.split(":")
-            if len(splitk) > 2:
-                return f"'{key}' could not be converted to span."
-
-            if len(splitk) == 1 and not splitk[0].isdigit() and not splitk[0].isalpha() and not splitk[0][0].isdigit():
-                """
-                ["A1"] - Cell (0, 0)
-                """
-                keys_digits = re.search(r"\d", splitk[0])
-                if keys_digits:
-                    digits_start = keys_digits.start()
-                    if not digits_start:
-                        return f"'{key}' could not be converted to span."
-                    if digits_start:
-                        key_row = splitk[0][digits_start:]
-                        key_column = splitk[0][:digits_start]
-                        return span_dict(
-                            from_r=int(key_row) - 1,
-                            from_c=alpha2idx(key_column),
-                            upto_r=int(key_row),
-                            upto_c=alpha2idx(key_column) + 1,
-                            widget=widget,
-                        )
-
-            if not splitk[0] and not splitk[1]:
-                """
-                [":"] - All rows
-                """
+            elif m := PATTERN_CELL.match(key):
+                c = span_a2i(m[1])
+                r = int(m[2]) - 1
                 return span_dict(
-                    from_r=0,
-                    from_c=None,
-                    upto_r=None,
-                    upto_c=None,
+                    from_r=r,
+                    from_c=c,
+                    upto_r=r + 1,
+                    upto_c=c + 1,
                     widget=widget,
                 )
-
-            if splitk[0].isdigit() and not splitk[1]:
-                """
-                ["2:"] - Rows starting from and including 1
-                """
+            elif m := PATTERN_RANGE.match(key):
+                return span_dict(
+                    from_r=int(m[2]) - 1,
+                    from_c=span_a2i(m[1]),
+                    upto_r=int(m[4]),
+                    upto_c=span_a2n(m[3]),
+                    widget=widget,
+                )
+            elif m := PATTERN_ROW_RANGE.match(key):
                 return span_dict(
-                    from_r=int(splitk[0]) - 1,
+                    from_r=int(m[1]) - 1,
                     from_c=None,
-                    upto_r=None,
+                    upto_r=int(m[2]),
                     upto_c=None,
                     widget=widget,
                 )
-
-            if splitk[1].isdigit() and not splitk[0]:
-                """
-                [":2"] - Rows up to and including 1
-                """
+            elif m := PATTERN_ROW_START.match(key):
                 return span_dict(
-                    from_r=0,
+                    from_r=int(m[1]) - 1,
                     from_c=None,
-                    upto_r=int(splitk[1]),
+                    upto_r=None,
                     upto_c=None,
                     widget=widget,
                 )
-
-            if splitk[0].isdigit() and splitk[1].isdigit():
-                """
-                ["1:2"] - Rows 0, 1
-                """
+            elif m := PATTERN_ROW_END.match(key):
                 return span_dict(
-                    from_r=int(splitk[0]) - 1,
+                    from_r=0,
                     from_c=None,
-                    upto_r=int(splitk[1]),
+                    upto_r=int(m[1]),
                     upto_c=None,
                     widget=widget,
                 )
-
-            if splitk[0].isalpha() and not splitk[1]:
-                """
-                ["B:"] - Columns starting from and including 2
-                """
+            elif m := PATTERN_COL_RANGE.match(key):
                 return span_dict(
                     from_r=None,
-                    from_c=alpha2idx(splitk[0]),
+                    from_c=span_a2i(m[1]),
                     upto_r=None,
-                    upto_c=None,
+                    upto_c=span_a2n(m[2]),
                     widget=widget,
                 )
-
-            if splitk[1].isalpha() and not splitk[0]:
-                """
-                [":B"] - Columns up to and including 2
-                """
+            elif m := PATTERN_COL_START.match(key):
                 return span_dict(
                     from_r=None,
-                    from_c=0,
+                    from_c=span_a2i(m[1]),
                     upto_r=None,
-                    upto_c=alpha2idx(splitk[1]) + 1,
+                    upto_c=None,
                     widget=widget,
                 )
-
-            if splitk[0].isalpha() and splitk[1].isalpha():
-                """
-                ["A:B"] - Columns 0, 1
-                """
+            elif m := PATTERN_COL_END.match(key):
                 return span_dict(
                     from_r=None,
-                    from_c=alpha2idx(splitk[0]),
+                    from_c=0,
                     upto_r=None,
-                    upto_c=alpha2idx(splitk[1]) + 1,
+                    upto_c=span_a2n(m[1]),
                     widget=widget,
                 )
-
-            m1 = re.search(r"\d", splitk[0])
-            m2 = re.search(r"\d", splitk[1])
-            m1start = m1.start() if m1 else None
-            m2start = m2.start() if m2 else None
-            if m1start and m2start:
-                """
-                ["A1:B1"] - Cells (0, 0), (0, 1)
-                """
-                c1 = splitk[0][:m1start]
-                r1 = splitk[0][m1start:]
-                c2 = splitk[1][:m2start]
-                r2 = splitk[1][m2start:]
+            elif m := PATTERN_CELL_START.match(key):
                 return span_dict(
-                    from_r=int(r1) - 1,
-                    from_c=alpha2idx(c1),
-                    upto_r=int(r2),
-                    upto_c=alpha2idx(c2) + 1,
+                    from_r=int(m[2]) - 1,
+                    from_c=span_a2i(m[1]),
+                    upto_r=None,
+                    upto_c=None,
                     widget=widget,
                 )
-
-            if not splitk[0] and m2start:
-                """
-                [":B1"] - Cells (0, 0), (0, 1)
-                """
-                c2 = splitk[1][:m2start]
-                r2 = splitk[1][m2start:]
+            elif m := PATTERN_CELL_END.match(key):
                 return span_dict(
                     from_r=0,
                     from_c=0,
-                    upto_r=int(r2),
-                    upto_c=alpha2idx(c2) + 1,
+                    upto_r=int(m[2]),
+                    upto_c=span_a2n(m[1]),
                     widget=widget,
                 )
-
-            if not splitk[1] and m1start:
-                """
-                ["A1:"] - Cells starting from and including (0, 0)
-                """
-                c1 = splitk[0][:m1start]
-                r1 = splitk[0][m1start:]
+            elif m := PATTERN_CELL_COL.match(key):
                 return span_dict(
-                    from_r=int(r1) - 1,
-                    from_c=alpha2idx(c1),
+                    from_r=int(m[2]) - 1,
+                    from_c=span_a2i(m[1]),
                     upto_r=None,
-                    upto_c=None,
+                    upto_c=span_a2n(m[3]),
                     widget=widget,
                 )
-
-            if m1start and splitk[1].isalpha():
-                """
-                ["A1:B"] - All the cells starting from (0, 0)
-                        expanding out to include column 1
-                        but not including cells beyond column
-                        1 and expanding down to include all rows
-                    A   B   C   D
-                1   x   x
-                2   x   x
-                3   x   x
-                4   x   x
-                ...
-                """
-                c1 = splitk[0][:m1start]
-                r1 = splitk[0][m1start:]
+            elif m := PATTERN_CELL_ROW.match(key):
                 return span_dict(
-                    from_r=int(r1) - 1,
-                    from_c=alpha2idx(c1),
-                    upto_r=None,
-                    upto_c=alpha2idx(splitk[1]) + 1,
+                    from_r=int(m[2]) - 1,
+                    from_c=span_a2i(m[1]),
+                    upto_r=int(m[3]),
+                    upto_c=None,
                     widget=widget,
                 )
-
-            if m1start and splitk[1].isdigit():
-                """
-                ["A1:2"] - All the cells starting from (0, 0)
-                        expanding down to include row 1
-                        but not including cells beyond row
-                        1 and expanding out to include all
-                        columns
-                    A   B   C   D
-                1   x   x   x   x
-                2   x   x   x   x
-                3
-                4
-                ...
-                """
-                c1 = splitk[0][:m1start]
-                r1 = splitk[0][m1start:]
+            elif PATTERN_ALL.match(key):
                 return span_dict(
-                    from_r=int(r1) - 1,
-                    from_c=alpha2idx(c1),
-                    upto_r=int(splitk[1]),
+                    from_r=0,
+                    from_c=None,
+                    upto_r=None,
                     upto_c=None,
                     widget=widget,
                 )
+            else:
+                return f"'{key}' could not be converted to span."
 
     except ValueError as error:
         return f"Error, '{key}' could not be converted to span: {error}"
-    else:
-        return f"'{key}' could not be converted to span."
 
 
 def span_is_cell(span: Span) -> bool:

{tksheet-7.4.6 → tksheet-7.4.7}/tksheet/main_table.py

@@ -555,16 +555,31 @@ class MainTable(tk.Canvas):
         return coords
 
     def find_match(self, find: str, r: int, c: int) -> bool:
-        return (
-            not find
-            and (not self.get_valid_cell_data_as_str(r, c, True).lower() or not f"{self.get_cell_data(r, c)}".lower())
-        ) or (
-            find
-            and (
-                find in self.get_valid_cell_data_as_str(r, c, True).lower()
-                or find in f"{self.get_cell_data(r, c)}".lower()
-            )
-        )
+        try:
+            value = self.data[r][c]
+        except Exception:
+            value = ""
+        kwargs = self.get_cell_kwargs(r, c, key=None)
+        if kwargs:
+            if "dropdown" in kwargs:
+                kwargs = kwargs["dropdown"]
+                if kwargs["text"] is not None and find in str(kwargs["text"]).lower():
+                    return True
+            elif "checkbox" in kwargs:
+                kwargs = kwargs["checkbox"]
+                if find in str(kwargs["text"]).lower() or (not find and find in "False"):
+                    return True
+            elif "format" in kwargs:
+                if kwargs["formatter"] is None:
+                    if find in data_to_str(value, **kwargs).lower():
+                        return True
+                # assumed given formatter class has __str__() or value attribute
+                elif find in str(value).lower() or find in str(value.value).lower():
+                    return True
+        if value is None:
+            return find == ""
+        else:
+            return find in str(value).lower()
 
     def find_within_match(self, find: str, r: int, c: int) -> bool:
         if not self.all_rows_displayed:
@@ -669,9 +684,9 @@ class MainTable(tk.Canvas):
                     reverse=reverse,
                 )
                 if (
-                    (self.all_rows_displayed or bisect_in(self.displayed_rows, r))
+                    self.find_match(find, r, c)
+                    and (self.all_rows_displayed or bisect_in(self.displayed_rows, r))
                     and (self.all_columns_displayed or bisect_in(self.displayed_columns, c))
-                    and self.find_match(find, r, c)
                 )
             ),
             None,
@@ -2039,8 +2054,10 @@ class MainTable(tk.Canvas):
         redraw: bool = True,
         r_pc: float = 0.0,
         c_pc: float = 0.0,
+        index: bool = True,
     ) -> bool:
-        need_redraw = False
+        need_y_redraw = False
+        need_x_redraw = False
         vis_info = self.cell_visibility_info(r, c)
         yvis, xvis = vis_info["yvis"], vis_info["xvis"]
         top_left_x, top_left_y, bottom_right_x, bottom_right_y = vis_info["visible_region"]
@@ -2067,7 +2084,7 @@ class MainTable(tk.Canvas):
                         y - 1 if y > 1 else y,
                     ]
                     self.set_yviews(*args, redraw=False)
-                    need_redraw = True
+                    need_y_redraw = True
             else:
                 if r is not None and not keep_yscroll:
                     y = max(
@@ -2079,7 +2096,7 @@ class MainTable(tk.Canvas):
                         y - 1 if y > 1 else y,
                     ]
                     self.set_yviews(*args, redraw=False)
-                    need_redraw = True
+                    need_y_redraw = True
         # x scroll
         if not check_cell_visibility or (check_cell_visibility and not xvis) and len(self.col_positions) > 1:
             if bottom_right_corner is None:
@@ -2102,7 +2119,7 @@ class MainTable(tk.Canvas):
                         x - 1 if x > 1 else x,
                     ]
                     self.set_xviews(*args, redraw=False)
-                    need_redraw = True
+                    need_x_redraw = True
             else:
                 if c is not None and not keep_xscroll:
                     x = max(
@@ -2114,8 +2131,22 @@ class MainTable(tk.Canvas):
                         x - 1 if x > 1 else x,
                     ]
                     self.set_xviews(*args, redraw=False)
-                    need_redraw = True
-        if redraw and need_redraw:
+                    need_x_redraw = True
+            # the index may have resized after scrolling making x calculation wrong
+            if need_x_redraw and index and self.PAR.ops.auto_resize_row_index and self.show_index:
+                self.main_table_redraw_grid_and_text(redraw_header=False, redraw_row_index=False, redraw_table=False)
+                self.see(
+                    r=r,
+                    c=c,
+                    keep_yscroll=keep_yscroll,
+                    keep_xscroll=keep_xscroll,
+                    check_cell_visibility=check_cell_visibility,
+                    redraw=redraw,
+                    r_pc=r_pc,
+                    c_pc=c_pc,
+                    index=False,
+                )
+        if redraw and (need_y_redraw or need_x_redraw):
             self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
             return True
         return False
@@ -2534,7 +2565,7 @@ class MainTable(tk.Canvas):
             ):
                 self.select_cell(r - 1, c, redraw=True)
 
-    def arrowkey_LEFT(self, event: Any = None) -> None:
+    def arrowkey_LEFT(self, event: Any = None) -> Literal["break"]:
         if not self.selected:
             return
         r = self.selected.row
@@ -2550,6 +2581,7 @@ class MainTable(tk.Canvas):
                 self.single_selection_enabled or self.toggle_selection_enabled
             ):
                 self.select_cell(r, c - 1, redraw=True)
+        return "break"
 
     def arrowkey_DOWN(self, event: Any = None) -> None:
         if not self.selected:
@@ -5572,8 +5604,7 @@ class MainTable(tk.Canvas):
 
     def total_data_cols(self, include_header: bool = True) -> int:
         h_total = len(self._headers) if include_header and isinstance(self._headers, (list, tuple)) else 0
-        # map() for some reason is 15% faster than max(key=len) using python 3.11 windows 11
-        d_total = max(map(len, self.data), default=0)
+        d_total = max(map(len, self.data), default=0)  # max(map(len, )) is faster
         return max(h_total, d_total)
 
     def total_data_rows(self, include_index: bool = True) -> int:
@@ -6115,7 +6146,7 @@ class MainTable(tk.Canvas):
 
         # check if auto resizing row index
         changed_w = False
-        if self.PAR.ops.auto_resize_row_index and redraw_row_index and self.show_index:
+        if self.PAR.ops.auto_resize_row_index and self.show_index:
             changed_w = self.RI.auto_set_index_width(
                 end_row=grid_end_row,
                 only_rows=map(self.datarn, range(text_start_row, text_end_row)),
@@ -7653,12 +7684,12 @@ class MainTable(tk.Canvas):
         self.focus_set()
         return closed_dd_coords
 
-    def mouseclick_outside_editor_or_dropdown_all_canvases(self):
+    def mouseclick_outside_editor_or_dropdown_all_canvases(self) -> tuple[int, int] | None:
         self.CH.mouseclick_outside_editor_or_dropdown()
         self.RI.mouseclick_outside_editor_or_dropdown()
         return self.mouseclick_outside_editor_or_dropdown()
 
-    def hide_dropdown_editor_all_canvases(self):
+    def hide_dropdown_editor_all_canvases(self) -> None:
         self.hide_text_editor_and_dropdown(redraw=False)
         self.RI.hide_text_editor_and_dropdown(redraw=False)
         self.CH.hide_text_editor_and_dropdown(redraw=False)

{tksheet-7.4.6 → tksheet-7.4.7}/tksheet/sheet.py

@@ -5238,14 +5238,6 @@ class Sheet(tk.Frame):
         """
         if item not in self.RI.tree:
             raise ValueError(f"Item '{item}' does not exist.")
-        if isinstance(iid, str):
-            if iid in self.RI.tree:
-                raise ValueError(f"Cannot rename '{iid}', it already exists.")
-            self.RI.tree[item].iid = iid
-            self.RI.tree[iid] = self.RI.tree.pop(item)
-            self.RI.tree_rns[iid] = self.RI.tree_rns.pop(item)
-            if iid in self.RI.tree_open_ids:
-                self.RI.tree_open_ids[iid] = self.RI.tree_open_ids.pop(item)
         if isinstance(text, str):
             self.RI.tree[item].text = text
         if isinstance(values, list):
@@ -5273,6 +5265,21 @@ class Sheet(tk.Frame):
                         )
             else:
                 self.RI.tree_open_ids.discard(item)
+        if isinstance(iid, str):
+            if iid in self.RI.tree:
+                raise ValueError(f"Cannot rename '{iid}', it already exists.")
+            for ciid in self.RI.tree[item].children:
+                self.RI.tree[ciid].parent = iid
+            if self.RI.tree[item].parent:
+                parent_node = self.RI.parent_node(item)
+                item_index = parent_node.children.index(item)
+                parent_node.children[item_index] = iid
+            self.RI.tree[item].iid = iid
+            self.RI.tree[iid] = self.RI.tree.pop(item)
+            self.RI.tree_rns[iid] = self.RI.tree_rns.pop(item)
+            if item in self.RI.tree_open_ids:
+                self.RI.tree_open_ids.discard(item)
+                self.RI.tree_open_ids.add(iid)
         get = not (isinstance(iid, str) or isinstance(text, str) or isinstance(values, list) or isinstance(open_, bool))
         self.set_refresh_timer(redraw=not get and redraw)
         if get:

{tksheet-7.4.6 → tksheet-7.4.7}/tksheet/sheet_options.py

@@ -144,7 +144,9 @@ def new_sheet_options() -> DotDict:
             "row_start_bindings": [
                 "<Command-Left>",
                 "<Home>",
-            ],
+            ]
+            if USER_OS == "darwin"
+            else ["<Home>"],
             "table_start_bindings": [
                 f"<{ctrl_key}-Home>",
             ],

{tksheet-7.4.6 → tksheet-7.4.7/tksheet.egg-info}/PKG-INFO

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