tksheet 7.1.7__py3-none-any.whl → 7.1.8__py3-none-any.whl

tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.1.7"
+__version__ = "7.1.8"
 
 from .colors import (
     color_map,
@@ -35,13 +35,13 @@ from .functions import (
     alpha2idx,
     alpha2num,
     consecutive_chunks,
+    consecutive_ranges,
     data_to_displayed_idxs,
     displayed_to_data_idxs,
     dropdown_search_function,
     event_dict,
     get_checkbox_dict,
     get_checkbox_kwargs,
-    rounded_box_coords,
     get_dropdown_dict,
     get_dropdown_kwargs,
     get_index_of_gap_in_sorted_integer_seq_forward,
@@ -53,12 +53,10 @@ from .functions import (
     move_elements_by_mapping,
     move_elements_to,
     num2alpha,
+    rounded_box_coords,
     span_dict,
     tksheet_type_error,
 )
-from .listbox import (
-    ListBox,
-)
 from .main_table import MainTable
 from .other_classes import (
     DotDict,

tksheet/column_headers.py

@@ -23,9 +23,9 @@ from .functions import (
     consecutive_ranges,
     ev_stack_dict,
     event_dict,
-    rounded_box_coords,
     get_n2a,
     is_contiguous,
+    rounded_box_coords,
     try_binding,
 )
 from .other_classes import (
@@ -41,6 +41,7 @@ from .vars import (
     USER_OS,
     rc_binding,
     symbols_set,
+    text_editor_to_unbind,
 )
 
 
@@ -942,7 +943,7 @@ class ColumnHeaders(tk.Canvas):
             y1,
             x2,
             y2,
-            radius=9 if self.PAR.ops.rounded_boxes else 0,
+            radius=8 if self.PAR.ops.rounded_boxes else 0,
         )
         if isinstance(iid, int):
             self.coords(iid, coords)
@@ -1663,6 +1664,7 @@ class ColumnHeaders(tk.Canvas):
                         key=extra_func_key,
                         value=text,
                         loc=c,
+                        column=c,
                         boxes=self.MT.get_boxes(),
                         selected=self.MT.selected,
                     )
@@ -1726,12 +1728,14 @@ class ColumnHeaders(tk.Canvas):
             self.text_editor.tktext.focus_set()
             self.text_editor.window.scroll_to_bottom()
         self.text_editor.tktext.bind("<Alt-Return>", lambda _x: self.text_editor_newline_binding(c=c))
+        self.text_editor.tktext.bind("<Alt-KP_Enter>", lambda _x: self.text_editor_newline_binding(c=c))
         if USER_OS == "darwin":
             self.text_editor.tktext.bind("<Option-Return>", lambda _x: self.text_editor_newline_binding(c=c))
         for key, func in self.MT.text_editor_user_bound_keys.items():
             self.text_editor.tktext.bind(key, func)
         self.text_editor.tktext.bind("<Tab>", lambda _x: self.close_text_editor((c, "Tab")))
         self.text_editor.tktext.bind("<Return>", lambda _x: self.close_text_editor((c, "Return")))
+        self.text_editor.tktext.bind("<KP_Enter>", lambda _x: self.close_text_editor((c, "Return")))
         if not dropdown:
             self.text_editor.tktext.bind("<FocusOut>", lambda _x: self.close_text_editor((c, "FocusOut")))
         self.text_editor.tktext.bind("<Escape>", lambda _x: self.close_text_editor((c, "Escape")))
@@ -1827,8 +1831,8 @@ class ColumnHeaders(tk.Canvas):
 
     def hide_text_editor(self, reason: None | str = None) -> None:
         if self.text_editor.open:
-            for b in ("<Alt-Return>", "<Option-Return>", "<Tab>", "<Return>", "<FocusOut>", "<Escape>"):
-                self.text_editor.tktext.unbind(b)
+            for binding in text_editor_to_unbind:
+                self.text_editor.tktext.unbind(binding)
             self.itemconfig(self.text_editor.canvas_id, state="hidden")
             self.text_editor.open = False
         if reason == "Escape":
@@ -1862,6 +1866,7 @@ class ColumnHeaders(tk.Canvas):
             key=editor_info[1] if len(editor_info) >= 2 else "FocusOut",
             value=text_editor_value,
             loc=c,
+            column=c,
             boxes=self.MT.get_boxes(),
             selected=self.MT.selected,
         )
@@ -1970,6 +1975,7 @@ class ColumnHeaders(tk.Canvas):
                         sheet=self.PAR.name,
                         value=self.text_editor.get(),
                         loc=c,
+                        column=c,
                         boxes=self.MT.get_boxes(),
                         selected=self.MT.selected,
                     ),
@@ -2005,6 +2011,7 @@ class ColumnHeaders(tk.Canvas):
                 key="??",
                 value=selection,
                 loc=c,
+                column=c,
                 boxes=self.MT.get_boxes(),
                 selected=self.MT.selected,
             )
@@ -2230,6 +2237,7 @@ class ColumnHeaders(tk.Canvas):
                 key="??",
                 value=value,
                 loc=c,
+                column=c,
                 boxes=self.MT.get_boxes(),
                 selected=self.MT.selected,
             )

tksheet/functions.py

@@ -102,6 +102,8 @@ def event_dict(
     key: None | str = None,
     value: object = None,
     loc: None | int | tuple[int] = None,
+    row: None | int = None,
+    column: None | int = None,
     resized_rows: None | dict = None,
     resized_columns: None | dict = None,
     # resized_index: None, dict] = None,
@@ -147,6 +149,8 @@ def event_dict(
         key="" if key is None else key,
         value=None if value is None else value,
         loc=tuple() if loc is None else loc,
+        row=row,
+        column=column,
         resized=DotDict(
             rows=DotDict() if resized_rows is None else resized_rows,
             columns=DotDict() if resized_columns is None else resized_columns,
@@ -403,8 +407,8 @@ def index_exists(seq: Sequence[object], index: int) -> bool:
 
 def move_elements_by_mapping(
     seq: list[object],
-    new_idxs: dict,
-    old_idxs: dict,
+    new_idxs: dict[int, int],
+    old_idxs: dict[int, int],
 ) -> list[object]:
     # move elements of a list around, displacing
     # other elements based on mapping
@@ -472,8 +476,7 @@ def get_new_indexes(
 
 
 def insert_items(seq: list | tuple, to_insert: dict, seq_len_func: Callable | None = None) -> list:
-    # faster method of inserting many items into a list
-    # using a dict of reverse sorted order of
+    # inserts many items into a list using a dict of reverse sorted order of
     # {index: value, index: value, ...}
     res = []
     extended = 0

tksheet/main_table.py

@@ -26,7 +26,6 @@ from itertools import (
     chain,
     cycle,
     islice,
-    product,
     repeat,
 )
 from math import (
@@ -56,7 +55,6 @@ from .functions import (
     ev_stack_dict,
     event_dict,
     gen_formatted,
-    rounded_box_coords,
     get_new_indexes,
     get_seq_without_gaps_at_index,
     index_exists,
@@ -67,10 +65,11 @@ from .functions import (
     len_to_idx,
     mod_event_val,
     mod_span,
+    mod_span_widget,
     move_elements_by_mapping,
     pickle_obj,
+    rounded_box_coords,
     span_idxs_post_move,
-    mod_span_widget,
     try_binding,
     unpickle_obj,
 )
@@ -82,6 +81,7 @@ from .other_classes import (
     DropdownStorage,
     EventDataDict,
     FontTuple,
+    Loc,
     Selected,
     SelectionBox,
     TextEditorStorage,
@@ -94,6 +94,7 @@ from .vars import (
     ctrl_key,
     rc_binding,
     symbols_set,
+    text_editor_to_unbind,
     val_modifying_options,
 )
 
@@ -675,7 +676,7 @@ class MainTable(tk.Canvas):
         if lastbox_numrows > new_data_numrows and not lastbox_numrows % new_data_numrows:
             nd = []
             for _ in range(int(lastbox_numrows / new_data_numrows)):
-                nd.extend([r.copy() for r in data])
+                nd.extend(r.copy() for r in data)
             data.extend(nd)
             new_data_numrows *= int(lastbox_numrows / new_data_numrows)
 
@@ -971,14 +972,14 @@ class MainTable(tk.Canvas):
                         run_binding=True,
                     )
         if move_data:
-            self.data[:] = [
-                move_elements_by_mapping(
-                    r,
-                    data_new_idxs,
-                    data_old_idxs,
-                )
-                for r in self.data
-            ]
+            self.data = list(
+                map(
+                    move_elements_by_mapping,
+                    self.data,
+                    repeat(data_new_idxs),
+                    repeat(data_old_idxs),
+                ),
+            )
             maxidx = len_to_idx(totalcols)
             self.CH.fix_header(maxidx)
             if isinstance(self._headers, list) and self._headers:
@@ -1195,7 +1196,7 @@ class MainTable(tk.Canvas):
                         run_binding=True,
                     )
         if move_data:
-            self.data[:] = move_elements_by_mapping(
+            self.data = move_elements_by_mapping(
                 self.data,
                 data_new_idxs,
                 data_old_idxs,
@@ -3213,39 +3214,30 @@ class MainTable(tk.Canvas):
             #     continue
 
     def set_xviews(self, *args, move_synced: bool = True, redraw: bool = True) -> None:
+        self.main_table_redraw_grid_and_text(setting_views=True)
+        self.update_idletasks()
         self.xview(*args)
         if self.show_header:
             self.CH.xview(*args)
         if move_synced:
             self.x_move_synced_scrolls(*args)
         self.fix_views()
-        if redraw:
-            self.main_table_redraw_grid_and_text(redraw_header=True if self.show_header else False)
+        self.PAR.set_refresh_timer(redraw)
 
     def set_yviews(self, *args, move_synced: bool = True, redraw: bool = True) -> None:
+        self.main_table_redraw_grid_and_text(setting_views=True)
+        self.update_idletasks()
         self.yview(*args)
         if self.show_index:
             self.RI.yview(*args)
         if move_synced:
             self.y_move_synced_scrolls(*args)
         self.fix_views()
-        if redraw:
-            self.main_table_redraw_grid_and_text(redraw_row_index=True if self.show_index else False)
+        self.PAR.set_refresh_timer(redraw)
 
     def set_view(self, x_args: list[str, float], y_args: list[str, float]) -> None:
-        self.xview(*x_args)
-        if self.show_header:
-            self.CH.xview(*x_args)
-        self.yview(*y_args)
-        if self.show_index:
-            self.RI.yview(*y_args)
-        self.x_move_synced_scrolls(*x_args)
-        self.y_move_synced_scrolls(*y_args)
-        self.fix_views()
-        self.main_table_redraw_grid_and_text(
-            redraw_row_index=True if self.show_index else False,
-            redraw_header=True if self.show_header else False,
-        )
+        self.set_xviews(*x_args)
+        self.set_yviews(*y_args)
 
     def mousewheel(self, event: object) -> None:
         if event.delta < 0 or event.num == 5:
@@ -4893,7 +4885,7 @@ class MainTable(tk.Canvas):
         if total_rows is not None:
             if len(self.data) < total_rows:
                 ncols = self.total_data_cols() if total_columns is None else total_columns
-                self.data.extend([self.get_empty_row_seq(r, ncols) for r in range(total_rows - len(self.data))])
+                self.data.extend(self.get_empty_row_seq(r, ncols) for r in range(total_rows - len(self.data)))
             else:
                 self.data[total_rows:] = []
         if total_columns is not None:
@@ -5193,6 +5185,7 @@ class MainTable(tk.Canvas):
         redraw_header: bool = False,
         redraw_row_index: bool = False,
         redraw_table: bool = True,
+        setting_views: bool = False,
     ) -> bool:
         try:
             can_width = self.winfo_width()
@@ -5286,6 +5279,8 @@ class MainTable(tk.Canvas):
         if scrollregion != self.scrollregion:
             self.configure(scrollregion=scrollregion)
             self.scrollregion = scrollregion
+        if setting_views:
+            return False
         scrollpos_bot = self.canvasy(can_height)
         end_row = bisect_right(self.row_positions, scrollpos_bot)
         if not scrollpos_bot >= self.row_positions[-1]:
@@ -5765,8 +5760,8 @@ class MainTable(tk.Canvas):
         fill, outline = self.get_selected_box_bg_fg(type_=type_)
         x1 = self.col_positions[c] + 1
         y1 = self.row_positions[r] + 1
-        x2 = self.col_positions[c + 1] if index_exists(self.col_positions, c + 1) else self.col_positions[c]
-        y2 = self.row_positions[r + 1] if index_exists(self.row_positions, r + 1) else self.row_positions[r]
+        x2 = self.col_positions[c + 1] if index_exists(self.col_positions, c + 1) else self.col_positions[c] + 1
+        y2 = self.row_positions[r + 1] if index_exists(self.row_positions, r + 1) else self.row_positions[r] + 1
         self.hide_selected()
         if self.PAR.ops.show_selected_cells_border:
             fill = ""
@@ -5809,12 +5804,16 @@ class MainTable(tk.Canvas):
         width: int,
         iid: None | int = None,
     ) -> int:
+        if not self.PAR.ops.rounded_boxes or not x2 - x1 or not y2 - y1:
+            radius = 0
+        else:
+            radius = 8
         coords = rounded_box_coords(
             x1,
             y1,
             x2,
             y2,
-            radius=9 if self.PAR.ops.rounded_boxes else 0,
+            radius=radius,
         )
         if isinstance(iid, int):
             self.itemconfig(iid, fill=fill, outline=outline, state=state, tags=tags, width=width)
@@ -5844,7 +5843,7 @@ class MainTable(tk.Canvas):
             self.itemconfig(item, state="hidden")
 
     def hide_selection_box(self, item: int | None, set_current: bool = True) -> bool:
-        if item is None:
+        if item is None or item is True:
             return
         box = self.selection_boxes.pop(item)
         self.hide_box(box.fill_iid)
@@ -6048,7 +6047,7 @@ class MainTable(tk.Canvas):
             tags="cells" if type_ == "rows" else type_,
             iid=self.selection_boxes[fill_iid].header,
         )
-        if (bd_iid := self.selection_boxes[fill_iid].bd_iid):
+        if bd_iid := self.selection_boxes[fill_iid].bd_iid:
             if self.PAR.ops.show_selected_cells_border:
                 self.display_box(
                     x1,
@@ -6147,168 +6146,62 @@ class MainTable(tk.Canvas):
     def get_selected_rows(
         self,
         get_cells: bool = False,
-        within_range: tuple | None = None,
         get_cells_as_rows: bool = False,
     ) -> set[int] | set[tuple[int, int]]:
-        s = set()
-        if within_range is not None:
-            within_r1 = within_range[0]
-            within_r2 = within_range[1]
         if get_cells:
-            if within_range is None:
-                for item, box in self.get_selection_items(cells=False, columns=False):
-                    r1, c1, r2, c2 = box.coords
-                    s.update(set(product(range(r1, r2), range(0, len(self.col_positions) - 1))))
-                if get_cells_as_rows:
-                    s.update(self.get_selected_cells())
-            else:
-                for item, box in self.get_selection_items(cells=False, columns=False):
-                    r1, c1, r2, c2 = box.coords
-                    if r1 >= within_r1 or r2 <= within_r2:
-                        s.update(
-                            set(
-                                product(
-                                    range(r1 if r1 > within_r1 else within_r1, r2 if r2 < within_r2 else within_r2),
-                                    range(0, len(self.col_positions) - 1),
-                                )
-                            )
-                        )
-                if get_cells_as_rows:
-                    s.update(
-                        self.get_selected_cells(
-                            within_range=(
-                                within_r1,
-                                0,
-                                within_r2,
-                                len(self.col_positions) - 1,
-                            )
-                        )
-                    )
+            s = {
+                (r, c)
+                for item, box in self.get_selection_items(cells=False, columns=False)
+                for r in range(box.coords.from_r, box.coords.upto_r)
+                for c in range(0, len(self.col_positions) - 1)
+            }
+            if get_cells_as_rows:
+                return s | self.get_selected_cells()
         else:
-            if within_range is None:
-                for item, box in self.get_selection_items(cells=False, columns=False):
-                    r1, c1, r2, c2 = box.coords
-                    s.update(set(range(r1, r2)))
-                if get_cells_as_rows:
-                    s.update(set(tup[0] for tup in self.get_selected_cells()))
-            else:
-                for item, box in self.get_selection_items(cells=False, columns=False):
-                    r1, c1, r2, c2 = box.coords
-                    if r1 >= within_r1 or r2 <= within_r2:
-                        s.update(set(range(r1 if r1 > within_r1 else within_r1, r2 if r2 < within_r2 else within_r2)))
-                if get_cells_as_rows:
-                    s.update(
-                        set(
-                            tup[0]
-                            for tup in self.get_selected_cells(
-                                within_range=(
-                                    within_r1,
-                                    0,
-                                    within_r2,
-                                    len(self.col_positions) - 1,
-                                )
-                            )
-                        )
-                    )
+            s = {
+                r
+                for item, box in self.get_selection_items(cells=False, columns=False)
+                for r in range(box.coords.from_r, box.coords.upto_r)
+            }
+            if get_cells_as_rows:
+                return s | set(tup[0] for tup in self.get_selected_cells())
         return s
 
     def get_selected_cols(
         self,
         get_cells: bool = False,
-        within_range: tuple | None = None,
         get_cells_as_cols: bool = False,
     ) -> set[int] | set[tuple[int, int]]:
-        s = set()
-        if within_range is not None:
-            within_c1 = within_range[0]
-            within_c2 = within_range[1]
         if get_cells:
-            if within_range is None:
-                for item, box in self.get_selection_items(cells=False, rows=False):
-                    r1, c1, r2, c2 = box.coords
-                    s.update(set(product(range(c1, c2), range(0, len(self.row_positions) - 1))))
-                if get_cells_as_cols:
-                    s.update(self.get_selected_cells())
-            else:
-                for item, box in self.get_selection_items(cells=False, rows=False):
-                    r1, c1, r2, c2 = box.coords
-                    if c1 >= within_c1 or c2 <= within_c2:
-                        s.update(
-                            set(
-                                product(
-                                    range(c1 if c1 > within_c1 else within_c1, c2 if c2 < within_c2 else within_c2),
-                                    range(0, len(self.row_positions) - 1),
-                                )
-                            )
-                        )
-                if get_cells_as_cols:
-                    s.update(
-                        self.get_selected_cells(
-                            within_range=(
-                                0,
-                                within_c1,
-                                len(self.row_positions) - 1,
-                                within_c2,
-                            )
-                        )
-                    )
+            s = {
+                (r, c)
+                for item, box in self.get_selection_items(cells=False, rows=False)
+                for r in range(0, len(self.row_positions) - 1)
+                for c in range(box.coords.from_c, box.coords.upto_c)
+            }
+            if get_cells_as_cols:
+                return s | self.get_selected_cells()
         else:
-            if within_range is None:
-                for item, box in self.get_selection_items(cells=False, rows=False):
-                    r1, c1, r2, c2 = box.coords
-                    s.update(set(range(c1, c2)))
-                if get_cells_as_cols:
-                    s.update(set(tup[1] for tup in self.get_selected_cells()))
-            else:
-                for item in self.get_selection_items(cells=False, rows=False):
-                    r1, c1, r2, c2 = box.coords
-                    if c1 >= within_c1 or c2 <= within_c2:
-                        s.update(set(range(c1 if c1 > within_c1 else within_c1, c2 if c2 < within_c2 else within_c2)))
-                if get_cells_as_cols:
-                    s.update(
-                        set(
-                            tup[0]
-                            for tup in self.get_selected_cells(
-                                within_range=(
-                                    0,
-                                    within_c1,
-                                    len(self.row_positions) - 1,
-                                    within_c2,
-                                )
-                            )
-                        )
-                    )
+            s = {
+                c
+                for item, box in self.get_selection_items(cells=False, rows=False)
+                for c in range(box.coords.from_c, box.coords.upto_c)
+            }
+            if get_cells_as_cols:
+                return s | set(tup[1] for tup in self.get_selected_cells())
         return s
 
     def get_selected_cells(
         self,
         get_rows: bool = False,
         get_cols: bool = False,
-        within_range: bool = None,
     ) -> set[tuple[int, int]]:
-        s = set()
-        if within_range is not None:
-            within_r1 = within_range[0]
-            within_c1 = within_range[1]
-            within_r2 = within_range[2]
-            within_c2 = within_range[3]
-        if within_range is None:
-            for item, box in self.get_selection_items(rows=get_rows, columns=get_cols):
-                r1, c1, r2, c2 = box.coords
-                s.update(set(product(range(r1, r2), range(c1, c2))))
-        else:
-            for item in self.get_selection_items(rows=get_rows, columns=get_cols):
-                r1, c1, r2, c2 = box.coords
-                if r1 >= within_r1 or c1 >= within_c1 or r2 <= within_r2 or c2 <= within_c2:
-                    s.update(
-                        set(
-                            product(
-                                range(r1 if r1 > within_r1 else within_r1, r2 if r2 < within_r2 else within_r2),
-                                range(c1 if c1 > within_c1 else within_c1, c2 if c2 < within_c2 else within_c2),
-                            )
-                        )
-                    )
-        return s
+        return {
+            (r, c)
+            for item, box in self.get_selection_items(rows=get_rows, columns=get_cols)
+            for r in range(box.coords.from_r, box.coords.upto_r)
+            for c in range(box.coords.from_c, box.coords.upto_c)
+        }
 
     def get_all_selection_boxes(self) -> tuple[tuple[int, int, int, int]]:
         return tuple(box.coords for item, box in self.get_selection_items())
@@ -6469,7 +6362,9 @@ class MainTable(tk.Canvas):
                         sheet=self.PAR.name,
                         key=extra_func_key,
                         value=text,
-                        loc=(r, c),
+                        loc=Loc(r, c),
+                        row=r,
+                        column=c,
                         boxes=self.get_boxes(),
                         selected=self.selected,
                     )
@@ -6532,12 +6427,14 @@ class MainTable(tk.Canvas):
             self.text_editor.tktext.focus_set()
             self.text_editor.window.scroll_to_bottom()
         self.text_editor.tktext.bind("<Alt-Return>", lambda _x: self.text_editor_newline_binding(r, c))
+        self.text_editor.tktext.bind("<Alt-KP_Enter>", lambda _x: self.text_editor_newline_binding(r, c))
         if USER_OS == "darwin":
             self.text_editor.tktext.bind("<Option-Return>", lambda _x: self.text_editor_newline_binding(r, c))
         for key, func in self.text_editor_user_bound_keys.items():
             self.text_editor.tktext.bind(key, func)
         self.text_editor.tktext.bind("<Tab>", lambda _x: self.close_text_editor((r, c, "Tab")))
         self.text_editor.tktext.bind("<Return>", lambda _x: self.close_text_editor((r, c, "Return")))
+        self.text_editor.tktext.bind("<KP_Enter>", lambda _x: self.close_text_editor((r, c, "Return")))
         if not dropdown:
             self.text_editor.tktext.bind("<FocusOut>", lambda _x: self.close_text_editor((r, c, "FocusOut")))
         self.text_editor.tktext.bind("<Escape>", lambda _x: self.close_text_editor((r, c, "Escape")))
@@ -6627,8 +6524,8 @@ class MainTable(tk.Canvas):
 
     def hide_text_editor(self, reason: None | str = None) -> None:
         if self.text_editor.open:
-            for b in ("<Alt-Return>", "<Option-Return>", "<Tab>", "<Return>", "<FocusOut>", "<Escape>"):
-                self.text_editor.tktext.unbind(b)
+            for binding in text_editor_to_unbind:
+                self.text_editor.tktext.unbind(binding)
             self.itemconfig(self.text_editor.canvas_id, state="hidden")
             self.text_editor.open = False
         if reason == "Escape":
@@ -6660,7 +6557,9 @@ class MainTable(tk.Canvas):
             cells_table={(datarn, datacn): text_editor_value},
             key=editor_info[2],
             value=text_editor_value,
-            loc=(r, c),
+            loc=Loc(r, c),
+            row=r,
+            column=c,
             boxes=self.get_boxes(),
             selected=self.selected,
         )
@@ -6911,7 +6810,9 @@ class MainTable(tk.Canvas):
                         name="table_dropdown_modified",
                         sheet=self.PAR.name,
                         value=self.text_editor.get(),
-                        loc=(r, c),
+                        loc=Loc(r, c),
+                        row=r,
+                        column=c,
                         boxes=self.get_boxes(),
                         selected=self.selected,
                     )
@@ -6954,7 +6855,9 @@ class MainTable(tk.Canvas):
                 cells_table={(datarn, datacn): pre_edit_value},
                 key="??",
                 value=selection,
-                loc=(r, c),
+                loc=Loc(r, c),
+                row=r,
+                column=c,
                 boxes=self.get_boxes(),
                 selected=self.selected,
             )
@@ -7042,7 +6945,9 @@ class MainTable(tk.Canvas):
                 cells_table={(datarn, datacn): pre_edit_value},
                 key="??",
                 value=value,
-                loc=(r, c),
+                loc=Loc(r, c),
+                row=r,
+                column=c,
                 boxes=self.get_boxes(),
                 selected=self.selected,
             )
@@ -7161,7 +7066,7 @@ class MainTable(tk.Canvas):
 
     def fix_data_len(self, datarn: int, datacn: int | None = None) -> int:
         ncols = self.total_data_cols() if datacn is None else datacn + 1
-        self.data.extend([self.get_empty_row_seq(rn, end=ncols, start=0) for rn in range(len(self.data), datarn + 1)])
+        self.data.extend(self.get_empty_row_seq(rn, end=ncols, start=0) for rn in range(len(self.data), datarn + 1))
         return len(self.data)
 
     def reapply_formatting(self) -> None:

tksheet/other_classes.py

@@ -17,10 +17,8 @@ Box_t = namedtuple(
     "Box_t",
     "from_r from_c upto_r upto_c type_",
 )
-Box_st = namedtuple(
-    "Box_st",
-    "coords type_"
-)
+Box_st = namedtuple("Box_st", "coords type_")
+Loc = namedtuple("Loc", "row column")
 
 Highlight = namedtuple(
     "Highlight",
@@ -472,4 +470,3 @@ Selected = namedtuple(
         None,
     ),
 )
-

tksheet/row_index.py

@@ -31,10 +31,10 @@ from .functions import (
     consecutive_chunks,
     ev_stack_dict,
     event_dict,
-    rounded_box_coords,
     get_n2a,
     is_contiguous,
     num2alpha,
+    rounded_box_coords,
     try_binding,
 )
 from .other_classes import (
@@ -51,6 +51,7 @@ from .vars import (
     USER_OS,
     rc_binding,
     symbols_set,
+    text_editor_to_unbind,
 )
 
 
@@ -965,7 +966,7 @@ class RowIndex(tk.Canvas):
             y1,
             x2,
             y2,
-            radius=9 if self.PAR.ops.rounded_boxes else 0,
+            radius=8 if self.PAR.ops.rounded_boxes else 0,
         )
         if isinstance(iid, int):
             self.coords(iid, coords)
@@ -1755,6 +1756,7 @@ class RowIndex(tk.Canvas):
                         key=extra_func_key,
                         value=text,
                         loc=r,
+                        row=r,
                         boxes=self.MT.get_boxes(),
                         selected=self.MT.selected,
                     )
@@ -1816,12 +1818,14 @@ class RowIndex(tk.Canvas):
             self.text_editor.tktext.focus_set()
             self.text_editor.window.scroll_to_bottom()
         self.text_editor.tktext.bind("<Alt-Return>", lambda _x: self.text_editor_newline_binding(r=r))
+        self.text_editor.tktext.bind("<Alt-KP_Enter>", lambda _x: self.text_editor_newline_binding(r=r))
         if USER_OS == "darwin":
             self.text_editor.tktext.bind("<Option-Return>", lambda _x: self.text_editor_newline_binding(r=r))
         for key, func in self.MT.text_editor_user_bound_keys.items():
             self.text_editor.tktext.bind(key, func)
         self.text_editor.tktext.bind("<Tab>", lambda _x: self.close_text_editor((r, "Tab")))
         self.text_editor.tktext.bind("<Return>", lambda _x: self.close_text_editor((r, "Return")))
+        self.text_editor.tktext.bind("<KP_Enter>", lambda _x: self.close_text_editor((r, "Return")))
         if not dropdown:
             self.text_editor.tktext.bind("<FocusOut>", lambda _x: self.close_text_editor((r, "FocusOut")))
         self.text_editor.tktext.bind("<Escape>", lambda _x: self.close_text_editor((r, "Escape")))
@@ -1909,8 +1913,8 @@ class RowIndex(tk.Canvas):
 
     def hide_text_editor(self, reason: None | str = None) -> None:
         if self.text_editor.open:
-            for b in ("<Alt-Return>", "<Option-Return>", "<Tab>", "<Return>", "<FocusOut>", "<Escape>"):
-                self.text_editor.tktext.unbind(b)
+            for binding in text_editor_to_unbind:
+                self.text_editor.tktext.unbind(binding)
             self.itemconfig(self.text_editor.canvas_id, state="hidden")
             self.text_editor.open = False
         if reason == "Escape":
@@ -1942,6 +1946,7 @@ class RowIndex(tk.Canvas):
             key=editor_info[1] if len(editor_info) >= 2 else "FocusOut",
             value=text_editor_value,
             loc=r,
+            row=r,
             boxes=self.MT.get_boxes(),
             selected=self.MT.selected,
         )
@@ -2064,6 +2069,7 @@ class RowIndex(tk.Canvas):
                         sheet=self.PAR.name,
                         value=self.text_editor.get(),
                         loc=r,
+                        row=r,
                         boxes=self.MT.get_boxes(),
                         selected=self.MT.selected,
                     ),
@@ -2100,6 +2106,7 @@ class RowIndex(tk.Canvas):
                 key="??",
                 value=selection,
                 loc=r,
+                row=r,
                 boxes=self.MT.get_boxes(),
                 selected=self.MT.selected,
             )
@@ -2322,6 +2329,7 @@ class RowIndex(tk.Canvas):
                 key="??",
                 value=value,
                 loc=r,
+                row=r,
                 boxes=self.MT.get_boxes(),
                 selected=self.MT.selected,
             )

tksheet/sheet.py

@@ -8,7 +8,6 @@ from itertools import accumulate, chain, islice, product
 from timeit import default_timer
 from tkinter import ttk
 from typing import Literal
-from warnings import warn as WARNING
 
 from .column_headers import ColumnHeaders
 from .functions import (
@@ -46,8 +45,8 @@ from .other_classes import (
     FontTuple,
     GeneratedMouseEvent,
     Node,
-    Span,
     Selected,
+    Span,
 )
 from .row_index import RowIndex
 from .sheet_options import (
@@ -272,9 +271,6 @@ class Sheet(tk.Frame):
             highlightbackground=outline_color,
             highlightcolor=outline_color,
         )
-        WARNING(
-            "There have been many changes from tksheet version 6.x.x to version 7.x.x. Please see the changelog for more information."
-        )
         self.ops = new_sheet_options()
         if column_width is not None:
             default_column_width = column_width
@@ -614,7 +610,7 @@ class Sheet(tk.Frame):
         for b, f in iterable:
             b = b.lower()
 
-            if func is not None and b in emitted_events:
+            if f is not None and b in emitted_events:
                 self.bind(b, f)
 
             if b in (
@@ -1357,16 +1353,14 @@ class Sheet(tk.Frame):
             if header:
                 if table:
                     res.extend(
-                        [
-                            [quick_hdata(c, get_displayed=hdisp)]
-                            + [quick_tdata(r, c, get_displayed=tdisp, fmt_kw=fmt_kw) for r in rows]
-                            for c in cols
-                        ]
+                        [quick_hdata(c, get_displayed=hdisp)]
+                        + [quick_tdata(r, c, get_displayed=tdisp, fmt_kw=fmt_kw) for r in rows]
+                        for c in cols
                     )
                 else:
-                    res.extend([[quick_hdata(c, get_displayed=hdisp)] for c in cols])
+                    res.extend([quick_hdata(c, get_displayed=hdisp)] for c in cols)
             elif table:
-                res.extend([[quick_tdata(r, c, get_displayed=tdisp, fmt_kw=fmt_kw) for r in rows] for c in cols])
+                res.extend([quick_tdata(r, c, get_displayed=tdisp, fmt_kw=fmt_kw) for r in rows] for c in cols)
         elif not span.transposed:
             if header:
                 if header and index:
@@ -1379,16 +1373,14 @@ class Sheet(tk.Frame):
             if index:
                 if table:
                     res.extend(
-                        [
-                            [quick_idata(r, get_displayed=idisp)]
-                            + [quick_tdata(r, c, get_displayed=tdisp, fmt_kw=fmt_kw) for c in cols]
-                            for r in rows
-                        ]
+                        [quick_idata(r, get_displayed=idisp)]
+                        + [quick_tdata(r, c, get_displayed=tdisp, fmt_kw=fmt_kw) for c in cols]
+                        for r in rows
                     )
                 else:
-                    res.extend([[quick_idata(r, get_displayed=idisp)] for r in rows])
+                    res.extend([quick_idata(r, get_displayed=idisp)] for r in rows)
             elif table:
-                res.extend([[quick_tdata(r, c, get_displayed=tdisp, fmt_kw=fmt_kw) for c in cols] for r in rows])
+                res.extend([quick_tdata(r, c, get_displayed=tdisp, fmt_kw=fmt_kw) for c in cols] for r in rows)
         if not span.ndim:
             # it's a cell
             if len(res) == 1 and len(res[0]) == 1:
@@ -1521,7 +1513,7 @@ class Sheet(tk.Frame):
         )
 
     @data.setter
-    def data(self, value):
+    def data(self, value: list[list[object]]) -> None:
         self.data_reference(value)
 
     def set_data(
@@ -2850,12 +2842,7 @@ class Sheet(tk.Frame):
         self.set_refresh_timer(redraw)
         return self
 
-    def index_align(
-        self,
-        align: str = None,
-        redraw: bool = True,
-    ) -> str | Sheet:
-        return self.row_index_align(align, redraw)
+    index_align = row_index_align
 
     def align(
         self,
@@ -2913,12 +2900,25 @@ class Sheet(tk.Frame):
     def selected(self) -> tuple[()] | Selected:
         return self.MT.selected
 
+    @selected.setter
+    def selected(self, selected: tuple[()] | Selected) -> Sheet:
+        if selected:
+            self.MT.set_currently_selected(
+                r=selected[0],
+                c=selected[1],
+                item=selected[4],
+                box=selected[3],
+            )
+        else:
+            self.MT.deselect()
+        return self
+
     def get_selected_rows(
         self,
         get_cells: bool = False,
         get_cells_as_rows: bool = False,
         return_tuple: bool = False,
-    ) -> tuple | set:
+    ) -> tuple[int] | tuple[tuple[int, int]] | set[int] | set[tuple[int, int]]:
         if return_tuple:
             return tuple(self.MT.get_selected_rows(get_cells=get_cells, get_cells_as_rows=get_cells_as_rows))
         return self.MT.get_selected_rows(get_cells=get_cells, get_cells_as_rows=get_cells_as_rows)
@@ -2928,7 +2928,7 @@ class Sheet(tk.Frame):
         get_cells: bool = False,
         get_cells_as_columns: bool = False,
         return_tuple: bool = False,
-    ) -> tuple | set:
+    ) -> tuple[int] | tuple[tuple[int, int]] | set[int] | set[tuple[int, int]]:
         if return_tuple:
             return tuple(self.MT.get_selected_cols(get_cells=get_cells, get_cells_as_cols=get_cells_as_columns))
         return self.MT.get_selected_cols(get_cells=get_cells, get_cells_as_cols=get_cells_as_columns)
@@ -2939,7 +2939,7 @@ class Sheet(tk.Frame):
         get_columns: bool = False,
         sort_by_row: bool = False,
         sort_by_column: bool = False,
-    ) -> list | set:
+    ) -> list[tuple[int, int]] | set[tuple[int, int]]:
         if sort_by_row and sort_by_column:
             sels = sorted(
                 self.MT.get_selected_cells(get_rows=get_rows, get_cols=get_columns),
@@ -2968,6 +2968,14 @@ class Sheet(tk.Frame):
     def boxes(self) -> list[tuple[tuple[int, int, int, int], str]]:
         return self.MT.get_all_selection_boxes_with_types()
 
+    @boxes.setter
+    def boxes(self, boxes: Sequence[tuple[tuple[int, int, int, int], str]]) -> Sheet:
+        self.MT.deselect()
+        self.MT.reselect_from_get_boxes(
+            boxes={box[0] if isinstance(box[0], tuple) else tuple(box[0]): box[1] for box in boxes}
+        )
+        return self
+
     def cell_selected(
         self,
         r: int,
@@ -3023,7 +3031,7 @@ class Sheet(tk.Frame):
 
     def select_row(self, row: int, redraw: bool = True, run_binding_func: bool = True) -> Sheet:
         self.RI.select_row(
-            int(row) if not isinstance(row, int) else row,
+            row if isinstance(row, int) else int(row),
             redraw=False,
             run_binding_func=run_binding_func,
         )
@@ -3032,7 +3040,7 @@ class Sheet(tk.Frame):
 
     def select_column(self, column: int, redraw: bool = True, run_binding_func: bool = True) -> Sheet:
         self.CH.select_col(
-            int(column) if not isinstance(column, int) else column,
+            column if isinstance(column, int) else int(column),
             redraw=False,
             run_binding_func=run_binding_func,
         )
@@ -3041,8 +3049,8 @@ class Sheet(tk.Frame):
 
     def select_cell(self, row: int, column: int, redraw: bool = True, run_binding_func: bool = True) -> Sheet:
         self.MT.select_cell(
-            int(row) if not isinstance(row, int) else row,
-            int(column) if not isinstance(column, int) else column,
+            row if isinstance(row, int) else int(row),
+            column if isinstance(column, int) else int(column),
             redraw=False,
             run_binding_func=run_binding_func,
         )
@@ -3722,10 +3730,24 @@ class Sheet(tk.Frame):
             self.MT.all_columns_displayed = a
         return v
 
+    @property
+    def all_columns(self) -> bool:
+        return self.MT.all_columns_displayed
+
+    @all_columns.setter
+    def all_columns(self, a: bool) -> Sheet:
+        self.MT.all_columns_displayed = a
+        return self
+
     @property
     def displayed_columns(self) -> list[int]:
         return self.MT.displayed_columns
 
+    @displayed_columns.setter
+    def displayed_columns(self, columns: list[int]) -> Sheet:
+        self.display_columns(columns=columns, reset_col_positions=False, redraw=True)
+        return self
+
     # Hiding Rows
 
     def displayed_row_to_data(self, r: int) -> int:
@@ -3828,10 +3850,24 @@ class Sheet(tk.Frame):
             self.MT.all_rows_displayed = a
         return v
 
+    @property
+    def all_rows(self) -> bool:
+        return self.MT.all_rows_displayed
+
+    @all_rows.setter
+    def all_rows(self, a: bool) -> Sheet:
+        self.MT.all_rows_displayed = a
+        return self
+
     @property
     def displayed_rows(self) -> list[int]:
         return self.MT.displayed_rows
 
+    @displayed_rows.setter
+    def displayed_rows(self, rows: list[int]) -> Sheet:
+        self.display_rows(rows=rows, reset_row_positions=False, redraw=True)
+        return self
+
     # Hiding Sheet Elements
 
     def hide(
@@ -4242,9 +4278,7 @@ class Sheet(tk.Frame):
         self.MT.main_table_redraw_grid_and_text(redraw_header=redraw_header, redraw_row_index=redraw_row_index)
         return self
 
-    def refresh(self, redraw_header: bool = True, redraw_row_index: bool = True) -> Sheet:
-        self.MT.main_table_redraw_grid_and_text(redraw_header=redraw_header, redraw_row_index=redraw_row_index)
-        return self
+    refresh = redraw
 
     # Tags
 
@@ -4381,7 +4415,10 @@ class Sheet(tk.Frame):
         data: list[list[object]],
         iid_column: int,
         parent_column: int,
+        text_column: None | int = None,
     ) -> Sheet:
+        if text_column is None:
+            text_column = iid_column
         tally_of_ids = defaultdict(lambda: -1)
         ncols = max(map(len, data), default=0)
         for rn, row in enumerate(data):
@@ -4400,13 +4437,13 @@ class Sheet(tk.Frame):
                 tally_of_ids[iid] += 1
                 row[iid_column] = new
             if iid not in self.RI.tree:
-                self.RI.tree[iid] = Node(row[iid_column], iid, "")
+                self.RI.tree[iid] = Node(row[text_column], iid, "")
             if iid == pid or self.RI.pid_causes_recursive_loop(iid, pid):
                 row[parent_column] = ""
                 pid = ""
             if pid:
                 if pid not in self.RI.tree:
-                    self.RI.tree[pid] = Node(row[parent_column], pid)
+                    self.RI.tree[pid] = Node(row[text_column], pid)
                 self.RI.tree[iid].parent = self.RI.tree[pid]
                 self.RI.tree[pid].children.append(self.RI.tree[iid])
             else:
@@ -4416,7 +4453,7 @@ class Sheet(tk.Frame):
             if n.parent is None:
                 n.parent = ""
                 newrow = self.MT.get_empty_row_seq(len(data), ncols)
-                newrow[iid_column] = n.text
+                newrow[iid_column] = n.iid
                 self.RI.tree_rns[n.iid] = len(data)
                 data.append(newrow)
         self.insert_rows(
@@ -4450,7 +4487,7 @@ class Sheet(tk.Frame):
         Accepts set[str] of iids that are open in the treeview
         Closes everything else
         """
-        self.RI.tree_open_ids = open_ids
+        self.RI.tree_open_ids = open_ids if isinstance(open_ids, set) else set(open_ids)
         self.hide_rows(
             set(self.MT.displayed_rows),
             redraw=False,
@@ -4811,8 +4848,9 @@ class Sheet(tk.Frame):
         ]
 
     def selection_set(self, *items) -> Sheet:
-        self.deselect()
-        self.selection_add(*items)
+        if any(item.lower() in self.RI.tree for item in unpack(items)):
+            self.deselect()
+            self.selection_add(*items)
         return self
 
     def selection_add(self, *items) -> Sheet:
@@ -4868,12 +4906,8 @@ class Sheet(tk.Frame):
         if redraw and self.after_redraw_id is None:
             self.after_redraw_id = self.after(self.after_redraw_time_ms, self.after_redraw)
 
-    def after_redraw(
-        self,
-        redraw_header: bool = True,
-        redraw_row_index: bool = True,
-    ) -> None:
-        self.MT.main_table_redraw_grid_and_text(redraw_header=redraw_header, redraw_row_index=redraw_row_index)
+    def after_redraw(self) -> None:
+        self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
         self.after_redraw_id = None
 
     def del_options_using_span(

tksheet/vars.py

@@ -26,6 +26,16 @@ emitted_events: set[str] = {
 backwards_compatibility_keys: dict[str, str] = {
     "font": "table_font",
 }
+text_editor_to_unbind: tuple[str] = (
+    "<Alt-Return>",
+    "<Alt-KP_Enter>",
+    "<Option-Return>",
+    "<Tab>",
+    "<Return>",
+    "<KP_Enter>",
+    "<FocusOut>",
+    "<Escape>",
+)
 scrollbar_options_keys: set[str] = {
     "vertical_scroll_background",
     "horizontal_scroll_background",

{tksheet-7.1.7.dist-info → tksheet-7.1.8.dist-info}/METADATA

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

tksheet-7.1.8.dist-info/RECORD

@@ -0,0 +1,20 @@
+tksheet/__init__.py,sha256=QkLl7gG86v_1GMYTSGmOr137dpoTBZE2IpCEgCB40d8,1994
+tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
+tksheet/column_headers.py,sha256=u5SRsI3VAoqxpUpPQZfu2Zimmf2OmZUBD_hMJKso-pw,100204
+tksheet/formatters.py,sha256=DXif00aq9DgFpXwkbiqD86KxtDg0Meop51hLY-KcGNQ,10037
+tksheet/functions.py,sha256=__21LS0cft9quuzFXcJ0BMbB0DEntvS4NQvreGk2U8Y,39709
+tksheet/main_table.py,sha256=zY5RNV2AyJ3jM8JPMmYrwCXGsnefnVVlXcjaqYxdxvg,318290
+tksheet/other_classes.py,sha256=P3FYUYreLhstATvHCNow8sDQoCsD_02KB6oXcca3ahE,13628
+tksheet/row_index.py,sha256=wfOPHitGfipTysCMfQA-Nl4mJawmkv9gm5CAtIlKgxo,105673
+tksheet/sheet.py,sha256=WvCuIszL31oJLhf0XJpvc0kHxa1yMAwEjiPrjeLkAQ8,257298
+tksheet/sheet_options.py,sha256=mh0rTvWrFvIKaiv88jtMZy0TSA8zTS1GXSe88u8_rzk,11978
+tksheet/text_editor.py,sha256=81_IZKrTVa2KIx2cJ4n3cFvFMAwvbHIQYgqtyat-97I,6681
+tksheet/themes.py,sha256=OwUe31NRbosjw3ZoZsMyB8lNVyYin9YcKLhCturi5q8,13398
+tksheet/top_left_rectangle.py,sha256=-2u9GfOvcqhkKwHEtbqdFvXCY3RbvL5k2Sh9l3r_k04,8275
+tksheet/types.py,sha256=IgoEHMbceKpakcZtanxKaKJ4RdCq7UW6EoEIIz5O59k,340
+tksheet/vars.py,sha256=8Qxas-m5nU-yMaeAweO4Z30FM9cOQoRTiOsH4kgZp5s,2288
+tksheet-7.1.8.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
+tksheet-7.1.8.dist-info/METADATA,sha256=eyi1aRtOSI35o-qYZpAJSZMyYjisRqRyZk_qg1JWx74,6013
+tksheet-7.1.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+tksheet-7.1.8.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
+tksheet-7.1.8.dist-info/RECORD,,

tksheet/listbox.py

@@ -1,19 +0,0 @@
-from __future__ import annotations
-import tkinter as tk
-# from collections.abc import Callable, Generator, Iterator, Sequence
-
-from .sheet import (
-    Sheet,
-)
-
-
-class ListBox(Sheet):
-    def __init__(
-        self,
-        parent: tk.Misc,
-    ) -> None:
-        Sheet.__init__(
-            self,
-            parent=parent,
-        )
-        self.parent = parent

tksheet-7.1.7.dist-info/RECORD

@@ -1,21 +0,0 @@
-tksheet/__init__.py,sha256=UgweIADXnlw1-KpD4Xr0sA_l6qAWTP3yzQ1Bo716Fkg,2010
-tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
-tksheet/column_headers.py,sha256=dBEnPjbI6nqcS0OISWJ0tXBBxtGjB67OE8z2-Bx8X1U,99870
-tksheet/formatters.py,sha256=DXif00aq9DgFpXwkbiqD86KxtDg0Meop51hLY-KcGNQ,10037
-tksheet/functions.py,sha256=dMJwG27Qo5WsfwzkL7A9X-PERGuGFhpQvP95BnlohJ8,39612
-tksheet/listbox.py,sha256=BUHx-PsZL6yGMewxAaEZV_8mOXCVWenWqzHp3tasGvo,384
-tksheet/main_table.py,sha256=ngwXVNqrtOZPtR-BqCuh7UVAubfB8v_JfdI2peJAzPM,323154
-tksheet/other_classes.py,sha256=Hjr7c0kD2_880xjtGuFn9gQ-7ED5kSiNahniBeXcf84,13604
-tksheet/row_index.py,sha256=NHFu5a35nPMuxajHhpS2RH8sOTYKKKb6WGO8zWofxqs,105354
-tksheet/sheet.py,sha256=PbCa8RCiBYg3Zl_26j1aIKphGst84S2lGHKodnZ6Kk0,256166
-tksheet/sheet_options.py,sha256=mh0rTvWrFvIKaiv88jtMZy0TSA8zTS1GXSe88u8_rzk,11978
-tksheet/text_editor.py,sha256=81_IZKrTVa2KIx2cJ4n3cFvFMAwvbHIQYgqtyat-97I,6681
-tksheet/themes.py,sha256=OwUe31NRbosjw3ZoZsMyB8lNVyYin9YcKLhCturi5q8,13398
-tksheet/top_left_rectangle.py,sha256=-2u9GfOvcqhkKwHEtbqdFvXCY3RbvL5k2Sh9l3r_k04,8275
-tksheet/types.py,sha256=IgoEHMbceKpakcZtanxKaKJ4RdCq7UW6EoEIIz5O59k,340
-tksheet/vars.py,sha256=Iukk7-MMT9X7vv0m3nQPKzbp2Iw2Pg1wJEW7js919Mo,2092
-tksheet-7.1.7.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
-tksheet-7.1.7.dist-info/METADATA,sha256=w5PeLRxO5tOgSz577YZLks3-OtluVDYw6Kw--fixI8w,6013
-tksheet-7.1.7.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-tksheet-7.1.7.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
-tksheet-7.1.7.dist-info/RECORD,,