tksheet 7.4.3__py3-none-any.whl → 7.4.4__py3-none-any.whl

tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.4.3"
+__version__ = "7.4.4"
 
 from .colors import (
     color_map,
@@ -93,7 +93,7 @@ from .other_classes import (
 from .row_index import RowIndex
 from .sheet import Dropdown, Sheet
 from .sheet_options import new_sheet_options
-from .sorting import natural_sort_key
+from .sorting import fast_sort_key, natural_sort_key, version_sort_key
 from .text_editor import (
     TextEditor,
     TextEditorTkText,

tksheet/column_headers.py

@@ -874,6 +874,8 @@ class ColumnHeaders(tk.Canvas):
             columns = list(range(0, len(self.MT.col_positions) - 1))
         event_data = self.MT.new_event_dict("edit_table")
         try_binding(self.MT.extra_begin_sort_cells_func, event_data)
+        if key is None:
+            key = self.PAR.ops.sort_key
         for c in columns:
             datacn = self.MT.datacn(c)
             for r, val in enumerate(
@@ -923,6 +925,8 @@ class ColumnHeaders(tk.Canvas):
                 return event_data
             column = self.MT.selected.column
         if try_binding(self.ch_extra_begin_sort_rows_func, event_data, "begin_move_rows"):
+            if key is None:
+                key = self.PAR.ops.sort_key
             disp_new_idxs, disp_row_ctr = {}, 0
             if self.ops.treeview:
                 new_nodes_order, data_new_idxs = sort_tree_view(
@@ -2239,16 +2243,17 @@ class ColumnHeaders(tk.Canvas):
                 self.MT._headers[datacn] = value
 
     def input_valid_for_cell(self, datacn: int, value: object, check_readonly: bool = True) -> bool:
-        if check_readonly and self.get_cell_kwargs(datacn, key="readonly"):
+        kwargs = self.get_cell_kwargs(datacn, key=None)
+        if check_readonly and "readonly" in kwargs:
             return False
-        if self.get_cell_kwargs(datacn, key="checkbox"):
+        elif "checkbox" in kwargs:
             return is_bool_like(value)
-        if self.cell_equal_to(datacn, value):
+        elif self.cell_equal_to(datacn, value):
             return False
-        kwargs = self.get_cell_kwargs(datacn, key="dropdown")
-        if kwargs and kwargs["validate_input"] and value not in kwargs["values"]:
+        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and value not in kwargs["values"]:
             return False
-        return True
+        else:
+            return True
 
     def cell_equal_to(self, datacn: int, value: object) -> bool:
         self.fix_header(datacn)
@@ -2303,12 +2308,13 @@ class ColumnHeaders(tk.Canvas):
         return value
 
     def get_value_for_empty_cell(self, datacn: int, c_ops: bool = True) -> object:
-        if self.get_cell_kwargs(datacn, key="checkbox", cell=c_ops):
+        kwargs = self.get_cell_kwargs(datacn, key=None, cell=c_ops)
+        if "checkbox" in kwargs:
             return False
-        kwargs = self.get_cell_kwargs(datacn, key="dropdown", cell=c_ops)
-        if kwargs and kwargs["validate_input"] and kwargs["values"]:
+        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and kwargs["values"]:
             return kwargs["values"][0]
-        return ""
+        else:
+            return ""
 
     def get_empty_header_seq(self, end: int, start: int = 0, c_ops: bool = True) -> list[object]:
         return [self.get_value_for_empty_cell(datacn, c_ops=c_ops) for datacn in range(start, end)]
@@ -2376,7 +2382,8 @@ class ColumnHeaders(tk.Canvas):
         if redraw:
             self.MT.refresh()
 
-    def get_cell_kwargs(self, datacn: int, key: Hashable = "dropdown", cell: bool = True) -> dict:
-        if cell and datacn in self.cell_options and key in self.cell_options[datacn]:
-            return self.cell_options[datacn][key]
-        return {}
+    def get_cell_kwargs(self, datacn: int, key: Hashable | None = "dropdown", cell: bool = True) -> dict:
+        if cell and datacn in self.cell_options:
+            return self.cell_options[datacn] if key is None else self.cell_options[datacn].get(key, {})
+        else:
+            return {}

tksheet/functions.py

@@ -15,7 +15,7 @@ from typing import Literal
 from .colors import color_map
 from .constants import align_value_error, symbols_set
 from .formatters import to_bool
-from .other_classes import Box_nt, DotDict, EventDataDict, Highlight, Loc, Span
+from .other_classes import DotDict, EventDataDict, Highlight, Loc, Span
 from .tksheet_types import AnyIter
 
 unpickle_obj = pickle.loads
@@ -279,10 +279,6 @@ def float_to_int(f: int | float) -> int | float:
     return int(f)
 
 
-def selection_box_tup_to_dict(box: tuple) -> dict:
-    return {Box_nt(*box[:-1]): box[-1]}
-
-
 def event_dict(
     name: str = None,
     sheet: object = None,
@@ -334,9 +330,7 @@ def event_dict(
         ),
         named_spans=DotDict() if named_spans is None else named_spans,
         options=DotDict(),
-        selection_boxes=(
-            {} if boxes is None else selection_box_tup_to_dict(boxes) if isinstance(boxes, tuple) else boxes
-        ),
+        selection_boxes={} if boxes is None else boxes,
         selected=tuple() if selected is None else selected,
         being_selected=tuple() if being_selected is None else being_selected,
         data=[] if data is None else data,
@@ -753,6 +747,17 @@ def move_elements_by_mapping(
     return [seq[old_idxs[i]] if i in old_idxs else next(remaining_values) for i in range(len(seq))]
 
 
+def move_elements_by_mapping_gen(
+    seq: list[object],
+    new_idxs: dict[int, int],
+    old_idxs: dict[int, int] | None = None,
+) -> Generator[object]:
+    if old_idxs is None:
+        old_idxs = dict(zip(new_idxs.values(), new_idxs))
+    remaining_values = (e for i, e in enumerate(seq) if i not in new_idxs)
+    return (seq[old_idxs[i]] if i in old_idxs else next(remaining_values) for i in range(len(seq)))
+
+
 def move_elements_to(
     seq: list[object],
     move_to: int,
@@ -770,10 +775,12 @@ def move_elements_to(
 
 def get_new_indexes(
     move_to: int,
-    to_move: list[int],
+    to_move: AnyIter[int],
     get_inverse: bool = False,
 ) -> tuple[dict]:
     """
+    move_to: A positive int, could possibly be the same as an element of to_move
+    to_move: A sorted list[int], ints always positive and unique, list never empty.
     returns {old idx: new idx, ...}
     """
     offset = sum(1 for i in to_move if i < move_to)
@@ -789,6 +796,11 @@ def insert_items(
     to_insert: dict[int, object],
     seq_len_func: Callable | None = None,
 ) -> list[object]:
+    """
+    seq: list[object]
+    to_insert: keys are ints sorted in reverse, representing list indexes to insert items.
+               Values are any object, e.g. {1: 200, 0: 200}
+    """
     if to_insert:
         if seq_len_func and next(iter(to_insert)) >= len(seq) + len(to_insert):
             seq_len_func(next(iter(to_insert)) - len(to_insert))
@@ -876,24 +888,12 @@ def rounded_box_coords(
     )
 
 
-def diff_list(seq: list[float]) -> list[int]:
-    return [
-        int(b - a)
-        for a, b in zip(
-            seq,
-            islice(seq, 1, None),
-        )
-    ]
-
-
 def diff_gen(seq: list[float]) -> Generator[int]:
-    return (
-        int(b - a)
-        for a, b in zip(
-            seq,
-            islice(seq, 1, None),
-        )
-    )
+    it = iter(seq)
+    a = next(it)
+    for b in it:
+        yield int(b - a)
+        a = b
 
 
 def gen_coords(

tksheet/main_table.py

@@ -50,7 +50,6 @@ from .functions import (
     consecutive_ranges,
     data_to_displayed_idxs,
     diff_gen,
-    diff_list,
     down_cell_within_box,
     event_dict,
     event_has_char_key,
@@ -72,6 +71,7 @@ from .functions import (
     mod_span,
     mod_span_widget,
     move_elements_by_mapping,
+    move_elements_by_mapping_gen,
     new_tk_event,
     next_cell,
     push_n,
@@ -932,19 +932,21 @@ class MainTable(tk.Canvas):
     def sort_boxes(
         self,
         event: tk.Event | None = None,
-        boxes: AnyIter[int, int, int, int] | None = None,
+        boxes: dict[tuple[int, int, int, int], Literal["cells", "rows", "columns"]] | None = None,
         reverse: bool = False,
         row_wise: bool = False,
         validation: bool = True,
         key: Callable | None = None,
         undo: bool = True,
     ) -> EventDataDict:
-        if boxes is None:
+        if not boxes:
             boxes = self.get_boxes()
         if not boxes:
-            boxes = [(0, 0, len(self.row_positions) - 1, len(self.col_positions) - 1)]
+            boxes = {Box_nt(0, 0, len(self.row_positions) - 1, len(self.col_positions) - 1): "cells"}
         event_data = self.new_event_dict("edit_table", boxes=boxes)
         try_binding(self.extra_begin_sort_cells_func, event_data)
+        if key is None:
+            key = self.PAR.ops.sort_key
         for r1, c1, r2, c2 in boxes:
             data = sort_selection(
                 [[self.get_cell_data(self.datarn(r), self.datacn(c)) for c in range(c1, c2)] for r in range(r1, r2)],
@@ -1287,26 +1289,36 @@ 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(move_to=move_to, to_move=to_move)
+            disp_new_idxs = get_new_indexes(
+                move_to=move_to,
+                to_move=to_move,
+            )
+            data_new_idxs = dict(disp_new_idxs)
         else:
             disp_new_idxs = {}
+            data_new_idxs = get_new_indexes(
+                move_to=move_to,
+                to_move=to_move,
+            )
         # at_least_cols should not be len in this case as move_to can be len
         fix_len = (move_to - 1) if move_to else move_to
         if not self.all_columns_displayed and not data_indexes:
             fix_len = self.datacn(fix_len)
         totalcols = self.equalize_data_row_lengths(at_least_cols=fix_len)
-        data_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
         if not self.all_columns_displayed and not data_indexes:
-            data_new_idxs = dict(
-                zip(
-                    move_elements_by_mapping(
+            keep = set(map(self.datacn, to_move))
+            data_new_idxs = {
+                k: v
+                for k, v in zip(
+                    move_elements_by_mapping_gen(
                         self.displayed_columns,
                         data_new_idxs,
                         dict(zip(data_new_idxs.values(), data_new_idxs)),
                     ),
                     self.displayed_columns,
-                ),
-            )
+                )
+                if k in keep
+            }
         return data_new_idxs, dict(zip(data_new_idxs.values(), data_new_idxs)), totalcols, disp_new_idxs
 
     def move_columns_adjust_options_dict(
@@ -1338,7 +1350,7 @@ class MainTable(tk.Canvas):
 
         if move_widths and disp_new_idxs:
             self.set_col_positions(
-                itr=move_elements_by_mapping(
+                itr=move_elements_by_mapping_gen(
                     self.get_column_widths(),
                     disp_new_idxs,
                     dict(
@@ -1537,7 +1549,7 @@ class MainTable(tk.Canvas):
             data_new_idxs = {
                 k: v
                 for k, v in zip(
-                    move_elements_by_mapping(
+                    move_elements_by_mapping_gen(
                         self.displayed_rows,
                         data_new_idxs,
                         dict(zip(data_new_idxs.values(), data_new_idxs)),
@@ -1732,7 +1744,7 @@ class MainTable(tk.Canvas):
 
         if move_heights and disp_new_idxs:
             self.set_row_positions(
-                itr=move_elements_by_mapping(
+                itr=move_elements_by_mapping_gen(
                     self.get_row_heights(),
                     disp_new_idxs,
                     dict(
@@ -1788,7 +1800,7 @@ class MainTable(tk.Canvas):
             old_idxs = dict(zip(new_idxs.values(), new_idxs))
         return dict(
             zip(
-                move_elements_by_mapping(tuple(range(max_idx + 1)), new_idxs, old_idxs),
+                move_elements_by_mapping_gen(tuple(range(max_idx + 1)), new_idxs, old_idxs),
                 range(max_idx + 1),
             )
         )
@@ -4489,10 +4501,10 @@ class MainTable(tk.Canvas):
             self.set_row_positions(itr=(h for i, h in enumerate(self.gen_row_heights()) if i not in idxs))
 
     def get_column_widths(self) -> list[int]:
-        return diff_list(self.col_positions)
+        return list(diff_gen(self.col_positions))
 
     def get_row_heights(self) -> list[int]:
-        return diff_list(self.row_positions)
+        return list(diff_gen(self.row_positions))
 
     def gen_column_widths(self) -> Generator[int]:
         return diff_gen(self.col_positions)
@@ -7893,26 +7905,20 @@ class MainTable(tk.Canvas):
                     self.data[datarn][datacn] = value
 
     def get_value_for_empty_cell(self, datarn: int, datacn: int, r_ops: bool = True, c_ops: bool = True) -> object:
-        if self.get_cell_kwargs(
-            datarn,
-            datacn,
-            key="checkbox",
-            cell=r_ops and c_ops,
-            row=r_ops,
-            column=c_ops,
-        ):
-            return False
         kwargs = self.get_cell_kwargs(
             datarn,
             datacn,
-            key="dropdown",
+            key=None,
             cell=r_ops and c_ops,
             row=r_ops,
             column=c_ops,
         )
-        if kwargs and kwargs["validate_input"] and kwargs["values"]:
+        if "checkbox" in kwargs:
+            return False
+        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and kwargs["values"]:
             return kwargs["values"][0]
-        return ""
+        else:
+            return ""
 
     def get_empty_row_seq(
         self,
@@ -8072,18 +8078,21 @@ class MainTable(tk.Canvas):
         check_readonly: bool = True,
         ignore_empty: bool = False,
     ) -> bool:
-        if check_readonly and self.get_cell_kwargs(datarn, datacn, key="readonly"):
+        kwargs = self.get_cell_kwargs(datarn, datacn, key=None)
+        if check_readonly and "readonly" in kwargs:
             return False
-        if self.get_cell_kwargs(datarn, datacn, key="format"):
+        elif "format" in kwargs:
             return True
-        if self.cell_equal_to(datarn, datacn, value, ignore_empty=ignore_empty):
+        elif self.cell_equal_to(datarn, datacn, value, ignore_empty=ignore_empty):
             return False
-        kwargs = self.get_cell_kwargs(datarn, datacn, key="dropdown")
-        if kwargs and kwargs["validate_input"] and value not in kwargs["values"]:
+        elif (
+            (dropdown := kwargs.get("dropdown", {})) and dropdown["validate_input"] and value not in dropdown["values"]
+        ):
             return False
-        if self.get_cell_kwargs(datarn, datacn, key="checkbox"):
+        elif "checkbox" in kwargs:
             return is_bool_like(value)
-        return True
+        else:
+            return True
 
     def cell_equal_to(self, datarn: int, datacn: int, value: object, ignore_empty: bool = False, **kwargs) -> bool:
         v = self.get_cell_data(datarn, datacn)
@@ -8118,18 +8127,21 @@ class MainTable(tk.Canvas):
         self,
         datarn: int,
         datacn: int,
-        key: Hashable = "format",
+        key: Hashable | None = "format",
         cell: bool = True,
         row: bool = True,
         column: bool = True,
     ) -> dict:
-        if cell and (datarn, datacn) in self.cell_options and key in self.cell_options[(datarn, datacn)]:
-            return self.cell_options[(datarn, datacn)][key]
-        if row and datarn in self.row_options and key in self.row_options[datarn]:
-            return self.row_options[datarn][key]
-        if column and datacn in self.col_options and key in self.col_options[datacn]:
-            return self.col_options[datacn][key]
-        return {}
+        if cell and (datarn, datacn) in self.cell_options:
+            return (
+                self.cell_options[(datarn, datacn)] if key is None else self.cell_options[(datarn, datacn)].get(key, {})
+            )
+        elif row and datarn in self.row_options:
+            return self.row_options[datarn] if key is None else self.row_options[datarn].get(key, {})
+        elif column and datacn in self.col_options:
+            return self.col_options[datacn] if key is None else self.col_options[datacn].get(key, {})
+        else:
+            return {}
 
     def datacn(self, c: int) -> int:
         return c if self.all_columns_displayed else self.displayed_columns[c]

tksheet/row_index.py

@@ -900,6 +900,8 @@ class RowIndex(tk.Canvas):
             rows = list(range(0, len(self.MT.row_positions) - 1))
         event_data = self.MT.new_event_dict("edit_table")
         try_binding(self.MT.extra_begin_sort_cells_func, event_data)
+        if key is None:
+            key = self.PAR.ops.sort_key
         for r in rows:
             datarn = self.MT.datarn(r)
             for c, val in enumerate(sort_row(self.MT.data[datarn], reverse=reverse, key=key)):
@@ -943,6 +945,8 @@ class RowIndex(tk.Canvas):
                 return event_data
             row = self.MT.selected.row
         if try_binding(self.ri_extra_begin_sort_cols_func, event_data, "begin_move_columns"):
+            if key is None:
+                key = self.PAR.ops.sort_key
             sorted_indices, data_new_idxs = sort_columns_by_row(self.MT.data, row=row, reverse=reverse, key=key)
             disp_new_idxs = {}
             if self.MT.all_columns_displayed:
@@ -2424,16 +2428,17 @@ class RowIndex(tk.Canvas):
                 self.MT._row_index[datarn] = value
 
     def input_valid_for_cell(self, datarn: int, value: object, check_readonly: bool = True) -> bool:
-        if check_readonly and self.get_cell_kwargs(datarn, key="readonly"):
+        kwargs = self.get_cell_kwargs(datarn, key=None)
+        if check_readonly and "readonly" in kwargs:
             return False
-        if self.get_cell_kwargs(datarn, key="checkbox"):
+        elif "checkbox" in kwargs:
             return is_bool_like(value)
-        if self.cell_equal_to(datarn, value):
+        elif self.cell_equal_to(datarn, value):
             return False
-        kwargs = self.get_cell_kwargs(datarn, key="dropdown")
-        if kwargs and kwargs["validate_input"] and value not in kwargs["values"]:
+        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and value not in kwargs["values"]:
             return False
-        return True
+        else:
+            return True
 
     def cell_equal_to(self, datarn: int, value: object) -> bool:
         self.fix_index(datarn)
@@ -2495,12 +2500,13 @@ class RowIndex(tk.Canvas):
         if self.ops.treeview:
             iid = self.new_iid()
             return Node(text=iid, iid=iid, parent=self.get_row_parent(datarn))
-        if self.get_cell_kwargs(datarn, key="checkbox", cell=r_ops):
+        kwargs = self.get_cell_kwargs(datarn, key=None, cell=r_ops)
+        if "checkbox" in kwargs:
             return False
-        kwargs = self.get_cell_kwargs(datarn, key="dropdown", cell=r_ops)
-        if kwargs and kwargs["validate_input"] and kwargs["values"]:
+        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and kwargs["values"]:
             return kwargs["values"][0]
-        return ""
+        else:
+            return ""
 
     def get_empty_index_seq(self, end: int, start: int = 0, r_ops: bool = True) -> list[object]:
         return [self.get_value_for_empty_cell(datarn, r_ops=r_ops) for datarn in range(start, end)]
@@ -2567,10 +2573,11 @@ class RowIndex(tk.Canvas):
         if redraw:
             self.MT.refresh()
 
-    def get_cell_kwargs(self, datarn: int, key: Hashable = "dropdown", cell: bool = True) -> dict:
-        if cell and datarn in self.cell_options and key in self.cell_options[datarn]:
-            return self.cell_options[datarn][key]
-        return {}
+    def get_cell_kwargs(self, datarn: int, key: Hashable | None = "dropdown", cell: bool = True) -> dict:
+        if cell and datarn in self.cell_options:
+            return self.cell_options[datarn] if key is None else self.cell_options[datarn].get(key, {})
+        else:
+            return {}
 
     # Treeview Mode
 
@@ -2671,25 +2678,33 @@ class RowIndex(tk.Canvas):
                     new_parent = node_change[1]
                     move_to_index = node_change[2]
                     if new_parent:
-                        move_to_index = (
-                            move_to_index if isinstance(move_to_index, int) else len(self.tree[new_parent].children)
-                        )
-                        move_to_row = self.tree_rns[new_parent] + max(
-                            0, min(move_to_index, len(self.tree[new_parent].children))
-                        )
+                        if isinstance(move_to_index, int):
+                            move_to_index = min(move_to_index, len(self.tree[new_parent].children))
+                        else:
+                            move_to_index = len(self.tree[new_parent].children)
+                        move_to_row = self.tree_rns[new_parent]
+                        if new_parent == self.tree[item].parent:
+                            move_to_index += 1
+                        for i, ciid in enumerate(self.tree[new_parent].children):
+                            if i == move_to_index:
+                                break
+                            move_to_row += sum(1 for _ in self.get_iid_descendants(ciid)) + 1
+                        insert_row = move_to_row + 1
                     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
                         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
-                    insert_row = move_to_row + 1
                     disp_insert_row = None
 
                 else:
@@ -2733,10 +2748,10 @@ class RowIndex(tk.Canvas):
                 event_data["moved"]["rows"]["displayed"] = {}
                 if new_loc_is_displayed:
                     if disp_insert_row is None:
-                        if new_parent == self.tree[item].parent:
+                        if new_parent or insert_row > move_to_row:
                             disp_insert_row = self.MT.disprn(self.tree_rns[move_to_iid]) + 1
                         else:
-                            disp_insert_row = self.MT.disprn(self.tree_rns[move_to_iid]) + 1
+                            disp_insert_row = self.MT.disprn(self.tree_rns[move_to_iid])
                     if (disp_from_row := self.MT.try_disprn(self.tree_rns[item])) is not None:
                         event_data["moved"]["rows"]["displayed"] = {disp_from_row: disp_insert_row}
                     else:
@@ -2756,7 +2771,6 @@ class RowIndex(tk.Canvas):
                             index=move_to_index,
                         )
                         move_to_index += 1
-
                     event_data["moved"]["rows"]["data"] = get_new_indexes(
                         insert_row,
                         event_data["moved"]["rows"]["data"],
@@ -2782,7 +2796,6 @@ class RowIndex(tk.Canvas):
         if not undo_modification and data_new_idxs:
             if new_parent and (not self.PAR.item_displayed(new_parent) or new_parent not in self.tree_open_ids):
                 self.PAR.hide_rows(set(data_new_idxs.values()), data_indexes=True)
-
             if new_loc_is_displayed:
                 self.PAR.show_rows(
                     (r for r in data_new_idxs.values() if self.ancestors_all_open(self.MT._row_index[r].iid))
@@ -2959,9 +2972,7 @@ class RowIndex(tk.Canvas):
     def move_pid_causes_recursive_loop(self, to_move_iid: str, move_to_parent: str) -> bool:
         # if the parent the item is being moved under is one of the item's descendants
         # then it is a recursive loop
-        return to_move_iid == move_to_parent or any(
-            move_to_parent == diid for diid in self.get_iid_descendants(to_move_iid)
-        )
+        return any(move_to_parent == diid for diid in self.get_iid_descendants(to_move_iid))
 
     def tree_build(
         self,

tksheet/sheet.py

@@ -54,6 +54,7 @@ from .functions import (
 )
 from .main_table import MainTable
 from .other_classes import (
+    Box_nt,
     DotDict,
     EventDataDict,
     FontTuple,
@@ -66,6 +67,7 @@ from .other_classes import (
 )
 from .row_index import RowIndex
 from .sheet_options import new_sheet_options
+from .sorting import fast_sort_key, natural_sort_key, version_sort_key  # noqa: F401
 from .themes import (
     theme_black,
     theme_dark,
@@ -187,6 +189,7 @@ class Sheet(tk.Frame):
         table_wrap: Literal["", "w", "c"] = "c",
         index_wrap: Literal["", "w", "c"] = "c",
         header_wrap: Literal["", "w", "c"] = "c",
+        sort_key: Callable = natural_sort_key,
         # colors
         outline_thickness: int = 0,
         theme: str = "light blue",
@@ -2586,7 +2589,7 @@ class Sheet(tk.Frame):
 
     def sort(
         self,
-        boxes: AnyIter[Sequence[int, int, int, int]] | Span | None = None,
+        *box: CreateSpanTypes,
         reverse: bool = False,
         row_wise: bool = False,
         validation: bool = True,
@@ -2599,17 +2602,11 @@ class Sheet(tk.Frame):
         This method sorts the data within one or multiple box regions defined by their coordinates. Each box's columns are sorted independently.
 
         Args:
-            boxes (AnyIter[Sequence[int, int, int, int]] | Span | None): An iterable of box coordinates. Each box is defined by:
-                - From Row (inclusive)
-                - From Column (inclusive)
-                - Up To Row (exclusive)
-                - Up To Column (exclusive)
-                If None, it will sort the currently selected boxes or the entire table.
-                If Span, it will use the span coordinates.
+            boxes (CreateSpanTypes): A type that can create a Span.
 
             reverse (bool): If True, sorts in descending order. Default is False (ascending).
 
-            row_wise (bool): if True sorts cells row-wise. Default is column-wise
+            row_wise (bool): if True sorts cells row-wise. Default is column-wise.
 
             validation (bool): If True, checks if the new cell values are valid according to any restrictions
                 (e.g., dropdown validations) before applying the sort. Default is True.
@@ -2626,19 +2623,21 @@ class Sheet(tk.Frame):
             ValueError: If the input boxes are not in the expected format or if the data cannot be sorted.
 
         Note:
-            - Sorting is performed column-wise within each box.
             - If validation is enabled, any cell content that fails validation will not be updated.
             - Any cell options attached to cells will not be moved. Event data can be used to re-locate them.
         """
-        if isinstance(boxes, Span):
-            boxes = [boxes.coords]
         return self.MT.sort_boxes(
-            boxes=boxes, reverse=reverse, row_wise=row_wise, validation=validation, key=key, undo=undo
+            boxes={Box_nt(*self.span_from_key(*box).coords): "cells"},
+            reverse=reverse,
+            row_wise=row_wise,
+            validation=validation,
+            key=key,
+            undo=undo,
         )
 
     def sort_rows(
         self,
-        rows: AnyIter[int] | Span | None = None,
+        rows: AnyIter[int] | Span | int | None = None,
         reverse: bool = False,
         validation: bool = True,
         key: Callable | None = None,
@@ -2646,11 +2645,13 @@ class Sheet(tk.Frame):
     ) -> EventDataDict:
         if isinstance(rows, Span):
             rows = rows.rows
+        elif isinstance(rows, int):
+            rows = (rows,)
         return self.RI._sort_rows(rows=rows, reverse=reverse, validation=validation, key=key, undo=undo)
 
     def sort_columns(
         self,
-        columns: AnyIter[int] | Span | None = None,
+        columns: AnyIter[int] | Span | int | None = None,
         reverse: bool = False,
         validation: bool = True,
         key: Callable | None = None,
@@ -2658,6 +2659,8 @@ class Sheet(tk.Frame):
     ) -> EventDataDict:
         if isinstance(columns, Span):
             columns = columns.columns
+        elif isinstance(columns, int):
+            columns = (columns,)
         return self.CH._sort_columns(columns=columns, reverse=reverse, validation=validation, key=key, undo=undo)
 
     def sort_rows_by_column(
@@ -4662,24 +4665,14 @@ class Sheet(tk.Frame):
         Also retrieves any row or column options
         impacting that cell
         """
-        if isinstance(column, str):
-            column = alpha2idx(column)
-        if key is not None:
-            return self.MT.get_cell_kwargs(
-                datarn=row,
-                datacn=column,
-                key=key,
-                cell=cellops,
-                row=rowops,
-                column=columnops,
-            )
-        if cellops and (row, column) in self.MT.cell_options:
-            return self.MT.cell_options[(row, column)]
-        if rowops and row in self.MT.row_options:
-            return self.MT.row_options[row]
-        if columnops and column in self.MT.col_options:
-            return self.MT.col_options[column]
-        return {}
+        return self.MT.get_cell_kwargs(
+            datarn=row,
+            datacn=alpha2idx(column) if isinstance(column, str) else column,
+            key=key,
+            cell=cellops,
+            row=rowops,
+            column=columnops,
+        )
 
     def index_props(
         self,
@@ -4690,12 +4683,10 @@ class Sheet(tk.Frame):
         Retrieve options (properties - props)
         from a cell in the index
         """
-        if key is not None:
-            return self.RI.get_cell_kwargs(
-                datarn=row,
-                key=key,
-            )
-        return self.RI.cell_options[row] if row in self.RI.cell_options else {}
+        return self.RI.get_cell_kwargs(
+            datarn=row,
+            key=key,
+        )
 
     def header_props(
         self,
@@ -4706,14 +4697,10 @@ class Sheet(tk.Frame):
         Retrieve options (properties - props)
         from a cell in the header
         """
-        if isinstance(column, str):
-            column = alpha2idx(column)
-        if key is not None:
-            return self.CH.get_cell_kwargs(
-                datacn=column,
-                key=key,
-            )
-        return self.CH.cell_options[column] if column in self.CH.cell_options else {}
+        return self.CH.get_cell_kwargs(
+            datacn=alpha2idx(column) if isinstance(column, str) else column,
+            key=key,
+        )
 
     def get_cell_options(
         self,

tksheet/sheet_options.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from .constants import USER_OS, ctrl_key
 from .other_classes import DotDict, FontTuple
+from .sorting import fast_sort_key, natural_sort_key, version_sort_key  # noqa: F401
 from .themes import theme_light_blue
 
 
@@ -255,5 +256,6 @@ def new_sheet_options() -> DotDict:
             "max_row_height": float("inf"),
             "max_index_width": float("inf"),
             "show_top_left": None,
+            "sort_key": natural_sort_key,
         }
     )

tksheet/sorting.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 from collections.abc import Callable, Generator, Iterable, Iterator
 from datetime import datetime
 from pathlib import Path
-from re import finditer
+from re import split
 
 AnyIter = Iterable | Iterator
 
 # Possible date formats to try for the entire string
-date_formats = [
+date_formats = (
     # Common formats
     "%d/%m/%Y",  # Day/Month/Year
     "%m/%d/%Y",  # Month/Day/Year (US format)
@@ -24,7 +24,8 @@ date_formats = [
     "%m,%d,%Y",  # Month,Day,Year
     "%Y,%m,%d",  # Year,Month,Day
     "%d %m %Y",  # Day Month Year (with space)
-    "%m %d %Y",  # Month Day Year
+    "%m %d %Y",  # Month Day Year (with space)
+    "%Y %d %m",  # Year Month Day (with space)
     # With month names
     "%d %b %Y",  # Day Abbreviated Month Year
     "%b %d, %Y",  # Abbreviated Month Day, Year
@@ -42,59 +43,228 @@ date_formats = [
     "%d/%m/%y %H:%M",  # Day/Month/Year Hour:Minute
     "%m/%d/%y %H:%M",  # Month/Day/Year Hour:Minute
     "%Y-%m-%d %H:%M:%S",  # Year-Month-Day Hour:Minute:Second
-]
+)
 
 
-def natural_sort_key(item: object) -> tuple[int, ...]:
+def _string_fallback(item: str) -> tuple[int, ...]:
+    """
+    In order to have reasonable file path sorting:
+    - Split by path separators
+    - Determine depth, more separators more depth
+    - Deal with every dir by splitting by digits
+    - Deal with file name by splitting by digits
+    """
+    components = split(r"[/\\]", item)
+    if components[-1]:
+        return (
+            5,
+            len(components),
+            tuple(int(e) if e.isdigit() else e.lower() for comp in components[:-1] for e in split(r"(\d+)", comp) if e),
+            tuple(int(e) if e.isdigit() else e.lower() for e in split(r"(\d+)", components[-1])),
+        )
+    else:
+        return (
+            5,
+            len(components),
+            tuple(int(e) if e.isdigit() else e.lower() for comp in components[:-1] for e in split(r"(\d+)", comp) if e),
+            tuple(),
+        )
+
+
+def version_sort_key(item: object) -> tuple[int, ...]:
     """
     A key for natural sorting of various Python types.
 
+    - Won't convert strings to floats
+    - Will sort string version numbers
+
     0. None
-    1. bool
-    2. int, float
-    3. datetime
-    4. empty strings
-    5. strings (including paths as POSIX strings)
-    6. unknown objects with __str__
-    7. unknown objects
+    1. Empty strings
+    2. bool
+    3. int, float
+    4. datetime (inc. strings that are dates)
+    5. strings (including string file paths and paths as POSIX strings) & unknown objects with __str__
+    6. unknown objects
     """
-    if item is None:
+    if isinstance(item, str):
+        if item:
+            for date_format in date_formats:
+                try:
+                    return (4, datetime.strptime(item, date_format).timestamp())
+                except ValueError:
+                    continue
+            # the same as _string_fallback
+            components = split(r"[/\\]", item)
+            if components[-1]:
+                return (
+                    5,
+                    len(components),
+                    tuple(
+                        int(e) if e.isdigit() else e.lower()
+                        for comp in components[:-1]
+                        for e in split(r"(\d+)", comp)
+                        if e
+                    ),
+                    tuple(int(e) if e.isdigit() else e.lower() for e in split(r"(\d+)", components[-1])),
+                )
+            else:
+                return (
+                    5,
+                    len(components),
+                    tuple(
+                        int(e) if e.isdigit() else e.lower()
+                        for comp in components[:-1]
+                        for e in split(r"(\d+)", comp)
+                        if e
+                    ),
+                    tuple(),
+                )
+        else:
+            return (1, item)
+
+    elif item is None:
         return (0,)
 
     elif isinstance(item, bool):
-        return (1, item)
+        return (2, item)
 
     elif isinstance(item, (int, float)):
-        return (2, item)
+        return (3, item)
 
     elif isinstance(item, datetime):
-        return (3, item.timestamp())
+        return (4, item.timestamp())
 
-    elif isinstance(item, str):
-        if not item:
-            return (4, item)
+    elif isinstance(item, Path):
+        return _string_fallback(item.as_posix())
+
+    else:
+        try:
+            return _string_fallback(f"{item}")
+        except Exception:
+            return (6, item)
+
+
+def natural_sort_key(item: object) -> tuple[int, ...]:
+    """
+    A key for natural sorting of various Python types.
+
+    - Won't sort string version numbers
+    - Will convert strings to floats
+    - Will sort strings that are file paths
+
+    0. None
+    1. Empty strings
+    2. bool
+    3. int, float (inc. strings that are numbers)
+    4. datetime (inc. strings that are dates)
+    5. strings (including string file paths and paths as POSIX strings) & unknown objects with __str__
+    6. unknown objects
+    """
+    if isinstance(item, str):
+        if item:
+            for date_format in date_formats:
+                try:
+                    return (4, datetime.strptime(item, date_format).timestamp())
+                except ValueError:
+                    continue
 
-        for date_format in date_formats:
             try:
-                return (3, datetime.strptime(item, date_format).timestamp())
+                return (3, float(item))
             except ValueError:
-                continue
+                # the same as _string_fallback
+                components = split(r"[/\\]", item)
+                if components[-1]:
+                    return (
+                        5,
+                        len(components),
+                        tuple(
+                            int(e) if e.isdigit() else e.lower()
+                            for comp in components[:-1]
+                            for e in split(r"(\d+)", comp)
+                            if e
+                        ),
+                        tuple(int(e) if e.isdigit() else e.lower() for e in split(r"(\d+)", components[-1])),
+                    )
+                else:
+                    return (
+                        5,
+                        len(components),
+                        tuple(
+                            int(e) if e.isdigit() else e.lower()
+                            for comp in components[:-1]
+                            for e in split(r"(\d+)", comp)
+                            if e
+                        ),
+                        tuple(),
+                    )
+        else:
+            return (1, item)
+
+    elif item is None:
+        return (0,)
+
+    elif isinstance(item, bool):
+        return (2, item)
+
+    elif isinstance(item, (int, float)):
+        return (3, item)
+
+    elif isinstance(item, datetime):
+        return (4, item.timestamp())
+
+    elif isinstance(item, Path):
+        return _string_fallback(item.as_posix())
+
+    else:
         try:
-            return (2, float(item))
+            return _string_fallback(f"{item}")
         except Exception:
-            pass
+            return (6, item)
+
+
+def fast_sort_key(item: object) -> tuple[int, ...]:
+    """
+    A faster key for natural sorting of various Python types.
+
+    - Won't sort strings that are dates very well
+    - Won't convert strings to floats
+    - Won't sort string file paths very well
+    - Will do ok with string version numbers
 
-        return (5, item.lower(), tuple(int(match.group()) for match in finditer(r"\d+", item)))
+    0. None
+    1. Empty strings
+    2. bool
+    3. int, float
+    4. datetime
+    5. strings (including paths as POSIX strings) & unknown objects with __str__
+    6. unknown objects
+    """
+    if isinstance(item, str):
+        if item:
+            return (5, tuple(int(e) if e.isdigit() else e.lower() for e in split(r"(\d+)", item)))
+        else:
+            return (1, item)
+
+    elif item is None:
+        return (0,)
+
+    elif isinstance(item, bool):
+        return (2, item)
+
+    elif isinstance(item, (int, float)):
+        return (3, item)
+
+    elif isinstance(item, datetime):
+        return (4, item.timestamp())
 
     elif isinstance(item, Path):
-        posix_str = item.as_posix()
-        return (5, posix_str.lower(), tuple(int(match.group()) for match in finditer(r"\d+", posix_str)))
+        return _string_fallback(item.as_posix())
 
     else:
         try:
-            return (6, f"{item}".lower())
+            return _string_fallback(f"{item}")
         except Exception:
-            return (7, item)
+            return (6, item)
 
 
 def sort_selection(
@@ -247,14 +417,15 @@ def sort_tree_view(
     _row_index: list[object],
     tree_rns: dict[str, int],
     tree: dict[str, object],
-    key: Callable = natural_sort_key,
+    key: Callable | None = None,
     reverse: bool = False,
 ) -> tuple[list[object], dict[int, int]]:
     if not _row_index or not tree_rns or not tree:
         return [], {}
 
     if key is None:
-        key = natural_sort_key
+        # prefer version_sort_key for iid names
+        key = version_sort_key
 
     # Create the index map and sorted nodes list
     mapping = {}
@@ -281,38 +452,80 @@ def sort_tree_view(
     return sorted_nodes, mapping
 
 
-# def test_natural_sort_key():
-#     test_items = [
-#         None,
-#         False,
-#         True,
-#         5,
-#         3.14,
-#         datetime(2023, 1, 1),
-#         "abc123",
-#         "123abc",
-#         "abc123def",
-#         "998zzz",
-#         "10-01-2023",
-#         "01-10-2023",
-#         "fi1le_0.txt",
-#         "file_2.txt",
-#         "file_10.txt",
-#         "file_1.txt",
-#         "path/to/file_2.txt",
-#         "path/to/file_10.txt",
-#         "path/to/file_1.txt",
-#         "/another/path/file_2.log",
-#         "/another/path/file_10.log",
-#         "/another/path/file_1.log",
-#         "C:\\Windows\\System32\\file_2.dll",
-#         "C:\\Windows\\System32\\file_10.dll",
-#         "C:\\Windows\\System32\\file_1.dll",
-#     ]
-#     print("Sort objects:", [natural_sort_key(e) for e in test_items])
-#     sorted_items = sorted(test_items, key=natural_sort_key)
-#     print("\nNatural Sort Order:", sorted_items)
-
-
 # if __name__ == "__main__":
-#     test_natural_sort_key()
+#     test_cases = {
+#         "Filenames": ["file10.txt", "file2.txt", "file1.txt"],
+#         "Versions": ["1.10", "1.2", "1.9", "1.21"],
+#         "Mixed": ["z1.doc", "z10.doc", "z2.doc", "z100.doc"],
+#         "Paths": [
+#             "/folder/file.txt",
+#             "/folder/file (1).txt",
+#             "/folder (1)/file.txt",
+#             "/folder (10)/file.txt",
+#             "/dir/subdir/file1.txt",
+#             "/dir/subdir/file10.txt",
+#             "/dir/subdir/file2.txt",
+#             "/dir/file.txt",
+#             "/dir/sub/file123.txt",
+#             "/dir/sub/file12.txt",
+#             # New challenging cases
+#             "/a/file.txt",
+#             "/a/file1.txt",
+#             "/a/b/file.txt",
+#             "/a/b/file1.txt",
+#             "/x/file-v1.2.txt",
+#             "/x/file-v1.10.txt",
+#             # My own new challenging cases
+#             "/a/zzzzz.txt",
+#             "/a/b/a.txt",
+#         ],
+#         "Case": ["Apple", "banana", "Corn", "apple", "Banana", "corn"],
+#         "Leading Zeros": ["001", "010", "009", "100"],
+#         "Complex": ["x-1-y-10", "x-1-y-2", "x-2-y-1", "x-10-y-1"],
+#         "Lengths": ["2 ft 9 in", "2 ft 10 in", "10 ft 1 in", "10 ft 2 in"],
+#         "Floats": [
+#             "1.5",
+#             "1.25",
+#             "1.025",
+#             "10.5",
+#             "-10.2",
+#             "-2.5",
+#             "5.7",
+#             "-1.25",
+#             "0.0",
+#             "1.5e3",
+#             "2.5e2",
+#             "1.23e4",
+#             "1e-2",
+#             "file1.2.txt",
+#             "file1.5.txt",
+#             "file1.10.txt",
+#         ],
+#         "Strings": [
+#             "123abc",
+#             "abc123",
+#             "123abc456",
+#             "abc123def",
+#         ],
+#     }
+
+#     print("FAST SORT KEY:")
+
+#     for name, data in test_cases.items():
+#         sorted1 = sorted(data, key=fast_sort_key)
+#         print(f"\n{name}:")
+#         print(sorted1)
+
+#     print("\nNATURAL SORT KEY:")
+
+#     for name, data in test_cases.items():
+#         sorted1 = sorted(data, key=natural_sort_key)
+#         print(f"\n{name}:")
+#         print(sorted1)
+
+#     print("\nVERSION SORT KEY:")
+
+#     for name, data in test_cases.items():
+#         sorted1 = sorted(data, key=version_sort_key)
+#         print(f"\n{name}:")
+#         print(sorted1)

{tksheet-7.4.3.dist-info → tksheet-7.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tksheet
-Version: 7.4.3
+Version: 7.4.4
 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.4.dist-info/RECORD

@@ -0,0 +1,22 @@
+tksheet/__init__.py,sha256=DJduXwiEFlPhe0uDqKUZCRGgf9pB-aubUvC_sXCpVp8,2313
+tksheet/colors.py,sha256=dHhmdFuQDlwohDHsAfT9VdrKoSl_R33L72a3HCin5zo,51591
+tksheet/column_headers.py,sha256=Dq3GqcUvBpereMdOTU3OqkfSkCb8nSUM18uHF2Vsrqo,103442
+tksheet/constants.py,sha256=PkvAtdYXSOiOO5zuxqrObvGIVV2sEE0enN8YLhI8zCc,3922
+tksheet/find_window.py,sha256=JfkgpGluSng3bKMBneDNQg-AJmBcmCW7JIhtYbSUZaE,8036
+tksheet/formatters.py,sha256=21ZkMaDIJNUtjvtlAbPl8Y19I9nDxue-JJegw6hblz8,10551
+tksheet/functions.py,sha256=KQe1AncAiVUxvcq9GAJ8TBXKaSAxk5-VDHDY6hHApLk,53183
+tksheet/main_table.py,sha256=jWG9Of249O-bPujDG1umoXZUndM6wIsx8lqNWPqVTz4,358190
+tksheet/other_classes.py,sha256=ADybikLipEG4NABXx8bGVAovJJhWcomQOWTorzS1CPU,16581
+tksheet/row_index.py,sha256=NUpv_cpGDKO_tF4tICcK2BaW1Z0-w8sdE9NYVyHNHO8,133849
+tksheet/sheet.py,sha256=s_9jyRok7AGanMZ9NzQYjkFxlwavjEMSBnOEN3uoJoQ,283724
+tksheet/sheet_options.py,sha256=A_cJEc6XirLO8YrWQHfb10lK2VhGbz28_3XgrKx3TfM,9753
+tksheet/sorting.py,sha256=xBSh_b7QyRRDzwqmKMPEevCZY1KpmMbyA6kl0yvcK6U,16887
+tksheet/text_editor.py,sha256=ZLVF-0WxDin5qUAJ5r7dmsdwvhyEoxw0PlPvi_AGNPE,7328
+tksheet/themes.py,sha256=AoNAxibnQi04MN0Zpbn9-kyDnkiiV8TDNWP9FYjpuf0,18473
+tksheet/tksheet_types.py,sha256=8JQVlA6N9jEZTEAytbcyuhOGuNE4fUPxYhTqoidxEE0,588
+tksheet/top_left_rectangle.py,sha256=KhTT-rBUwQTgaHjSwL83cL5_71k2L1B7gxkSxZlTSK8,8598
+tksheet-7.4.4.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
+tksheet-7.4.4.dist-info/METADATA,sha256=F4df5FisLoL6dkzwUbayE2Djt0fgD1bibXlVOFLaoDM,7839
+tksheet-7.4.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+tksheet-7.4.4.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
+tksheet-7.4.4.dist-info/RECORD,,

tksheet-7.4.3.dist-info/RECORD

@@ -1,22 +0,0 @@
-tksheet/__init__.py,sha256=6xbeTomYvgJaGjRKmHAS1YW24Tmc5ZcR7_YmeyJvDnY,2280
-tksheet/colors.py,sha256=dHhmdFuQDlwohDHsAfT9VdrKoSl_R33L72a3HCin5zo,51591
-tksheet/column_headers.py,sha256=ZfHLhXEKe8M9ggf3nzg252DBVH_NRtQichtTF7pisIc,103245
-tksheet/constants.py,sha256=PkvAtdYXSOiOO5zuxqrObvGIVV2sEE0enN8YLhI8zCc,3922
-tksheet/find_window.py,sha256=JfkgpGluSng3bKMBneDNQg-AJmBcmCW7JIhtYbSUZaE,8036
-tksheet/formatters.py,sha256=21ZkMaDIJNUtjvtlAbPl8Y19I9nDxue-JJegw6hblz8,10551
-tksheet/functions.py,sha256=BDCCKdOUF9FRDq9GF7HmRXaZ22PYRDySlo6WLvyZtVA,52806
-tksheet/main_table.py,sha256=ChMaI_t5rDwfc5pStG5pxKhqWwKnauJGxa_hoTXq478,357778
-tksheet/other_classes.py,sha256=ADybikLipEG4NABXx8bGVAovJJhWcomQOWTorzS1CPU,16581
-tksheet/row_index.py,sha256=R6tCsfXnPbblnSU1tvse_fCjx2DG0U-vx-XaiAPdZs0,133195
-tksheet/sheet.py,sha256=6hHI_W0rmuV6l2C2jd3fa9pgnNx3kW9k6rY0qqEq-Wg,284585
-tksheet/sheet_options.py,sha256=7q5T55sZe_elA3MCP0VnbX_f0Euo425aw4uSoPXteoA,9624
-tksheet/sorting.py,sha256=qLusdRmqDUBkcEgK3WcYbFjIJmXNBoDhR-D2yrWC-BI,9895
-tksheet/text_editor.py,sha256=ZLVF-0WxDin5qUAJ5r7dmsdwvhyEoxw0PlPvi_AGNPE,7328
-tksheet/themes.py,sha256=AoNAxibnQi04MN0Zpbn9-kyDnkiiV8TDNWP9FYjpuf0,18473
-tksheet/tksheet_types.py,sha256=8JQVlA6N9jEZTEAytbcyuhOGuNE4fUPxYhTqoidxEE0,588
-tksheet/top_left_rectangle.py,sha256=KhTT-rBUwQTgaHjSwL83cL5_71k2L1B7gxkSxZlTSK8,8598
-tksheet-7.4.3.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
-tksheet-7.4.3.dist-info/METADATA,sha256=36JytEf6SmrgwlyWLnvv1SLYumrDvxH4wDERw-cxTXE,7839
-tksheet-7.4.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-tksheet-7.4.3.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
-tksheet-7.4.3.dist-info/RECORD,,