tksheet 7.2.19__py3-none-any.whl → 7.2.21__py3-none-any.whl

tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.2.19"
+__version__ = "7.2.21"
 
 from .colors import (
     color_map,
@@ -12,6 +12,8 @@ from .colors import (
 from .column_headers import ColumnHeaders
 from .formatters import (
     Formatter,
+    alt_percentage_to_str,
+    alt_to_percentage,
     bool_formatter,
     data_to_str,
     float_formatter,
@@ -28,6 +30,7 @@ from .formatters import (
     to_bool,
     to_float,
     to_int,
+    to_percentage,
     to_str,
     try_to_bool,
 )

tksheet/column_headers.py

@@ -31,7 +31,7 @@ from .functions import (
     get_n2a,
     is_contiguous,
     new_tk_event,
-    pickled_event_dict,
+    stored_event_dict,
     rounded_box_coords,
     try_binding,
 )
@@ -56,8 +56,7 @@ from .vars import (
 
 class ColumnHeaders(tk.Canvas):
     def __init__(self, *args, **kwargs):
-        tk.Canvas.__init__(
-            self,
+        super().__init__(
             kwargs["parent"],
             background=kwargs["parent"].ops.header_bg,
             highlightthickness=0,
@@ -875,7 +874,7 @@ class ColumnHeaders(tk.Canvas):
                         "displayed": disp_new_idxs,
                     }
                     if self.MT.undo_enabled:
-                        self.MT.undo_stack.append(pickled_event_dict(event_data))
+                        self.MT.undo_stack.append(stored_event_dict(event_data))
                     self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
                     try_binding(self.ch_extra_end_drag_drop_func, event_data, "end_move_columns")
                     self.MT.sheet_modified(event_data)
@@ -2187,7 +2186,7 @@ class ColumnHeaders(tk.Canvas):
             self.fix_header(datacn)
             if not check_input_valid or self.input_valid_for_cell(datacn, value):
                 if self.MT.undo_enabled and undo:
-                    self.MT.undo_stack.append(pickled_event_dict(event_data))
+                    self.MT.undo_stack.append(stored_event_dict(event_data))
                 self.set_cell_data(datacn=datacn, value=value)
                 edited = True
         if edited and cell_resize and self.PAR.ops.cell_auto_resize_enabled:

tksheet/formatters.py

@@ -5,19 +5,25 @@ from collections.abc import Callable
 from .vars import falsy, nonelike, truthy
 
 
-def is_none_like(o: object):
+def is_none_like(o: object) -> bool:
     if (isinstance(o, str) and o.lower().replace(" ", "") in nonelike) or o in nonelike:
         return True
     return False
 
 
-def to_int(o: object, **kwargs):
+def to_int(o: object, **kwargs) -> int:
     if isinstance(o, int):
         return o
     return int(float(o))
 
 
-def to_float(o: object, **kwargs):
+def to_float(o: object, **kwargs) -> float:
+    if isinstance(o, float):
+        return o
+    return float(o)
+
+
+def to_percentage(o: object, **kwargs) -> float:
     if isinstance(o, float):
         return o
     if isinstance(o, str) and o.endswith("%"):
@@ -25,7 +31,15 @@ def to_float(o: object, **kwargs):
     return float(o)
 
 
-def to_bool(val: object, **kwargs):
+def alt_to_percentage(o: object, **kwargs) -> float:
+    if isinstance(o, float):
+        return o
+    if isinstance(o, str) and o.endswith("%"):
+        return float(o.replace("%", ""))
+    return float(o)
+
+
+def to_bool(val: object, **kwargs) -> bool:
     if isinstance(val, bool):
         return val
     if isinstance(val, str):
@@ -47,14 +61,14 @@ def to_bool(val: object, **kwargs):
     raise ValueError(f'Cannot map "{val}" to bool.')
 
 
-def try_to_bool(o: object, **kwargs):
+def try_to_bool(o: object, **kwargs) -> object:
     try:
         return to_bool(o)
     except Exception:
         return o
 
 
-def is_bool_like(o: object, **kwargs):
+def is_bool_like(o: object, **kwargs) -> bool:
     try:
         to_bool(o)
         return True
@@ -91,6 +105,10 @@ def percentage_to_str(v: object, **kwargs: dict) -> str:
     return f"{v}%"
 
 
+def alt_percentage_to_str(v: object, **kwargs: dict) -> str:
+    return f"{float_to_str(v)}%"
+
+
 def bool_to_str(v: object, **kwargs: dict) -> str:
     return f"{v}"
 
@@ -127,7 +145,7 @@ def float_formatter(
 
 def percentage_formatter(
     datatypes: tuple[object] | object = float,
-    format_function: Callable = to_float,
+    format_function: Callable = to_percentage,
     to_str_function: Callable = percentage_to_str,
     decimals: int = 2,
     **kwargs,

tksheet/functions.py

@@ -5,7 +5,6 @@ import io
 import pickle
 import re
 import tkinter as tk
-import zlib
 from bisect import (
     bisect_left,
 )
@@ -16,7 +15,6 @@ from collections.abc import (
     Iterator,
     Sequence,
 )
-from functools import partial
 from itertools import islice, repeat
 from typing import Literal
 
@@ -32,8 +30,6 @@ from .other_classes import (
     Span,
 )
 
-compress = partial(zlib.compress, level=1)
-pickle_obj = partial(pickle.dumps, protocol=pickle.HIGHEST_PROTOCOL)
 unpickle_obj = pickle.loads
 
 
@@ -65,14 +61,6 @@ def get_data_from_clipboard(
     return [[data]]
 
 
-def pickle_compress(obj: object) -> bytes:
-    return compress(pickle_obj(obj))
-
-
-def decompress_load(b: bytes) -> object:
-    return pickle.loads(zlib.decompress(b))
-
-
 def tksheet_type_error(kwarg: str, valid_types: list[str], not_type: object) -> str:
     valid_types = ", ".join(f"{type_}" for type_ in valid_types)
     return f"Argument '{kwarg}' must be one of the following types: {valid_types}, " f"not {type(not_type)}."
@@ -210,8 +198,8 @@ def change_eventname(event_dict: EventDataDict, newname: str) -> EventDataDict:
     return EventDataDict({**event_dict, **{"eventname": newname}})
 
 
-def pickled_event_dict(d: DotDict) -> DotDict:
-    return DotDict(name=d["eventname"], data=pickle_compress(DotDict({k: v for k, v in d.items() if k != "widget"})))
+def stored_event_dict(d: DotDict) -> DotDict:
+    return DotDict(name=d["eventname"], data=DotDict(kv for kv in d.items() if kv[0] != "widget"))
 
 
 def len_to_idx(n: int) -> int:

tksheet/main_table.py

@@ -53,7 +53,6 @@ from .functions import (
     b_index,
     cell_right_within_box,
     consecutive_ranges,
-    decompress_load,
     diff_gen,
     diff_list,
     down_cell_within_box,
@@ -73,8 +72,7 @@ from .functions import (
     mod_span_widget,
     move_elements_by_mapping,
     new_tk_event,
-    pickle_obj,
-    pickled_event_dict,
+    stored_event_dict,
     rounded_box_coords,
     span_idxs_post_move,
     try_binding,
@@ -88,6 +86,7 @@ from .other_classes import (
     DropdownStorage,
     EventDataDict,
     FontTuple,
+    Highlight,
     Loc,
     ProgressBar,
     Selected,
@@ -115,8 +114,7 @@ from .vars import (
 
 class MainTable(tk.Canvas):
     def __init__(self, *args, **kwargs):
-        tk.Canvas.__init__(
-            self,
+        super().__init__(
             kwargs["parent"],
             background=kwargs["parent"].ops.table_bg,
             highlightthickness=0,
@@ -671,8 +669,6 @@ class MainTable(tk.Canvas):
                                 event_data,
                             )
                     writer.writerow(row)
-        if event_data["cells"]["table"]:
-            self.undo_stack.append(pickled_event_dict(event_data))
         self.clipboard_clear()
         if len(event_data["cells"]["table"]) == 1 and self.PAR.ops.to_clipboard_lineterminator not in next(
             iter(event_data["cells"]["table"].values())
@@ -685,9 +681,10 @@ class MainTable(tk.Canvas):
         for r1, c1, r2, c2 in boxes:
             self.show_ctrl_outline(canvas="table", start_cell=(c1, r1), end_cell=(c2, r2))
         if event_data["cells"]["table"]:
+            self.undo_stack.append(stored_event_dict(event_data))
             try_binding(self.extra_end_ctrl_x_func, event_data, "end_ctrl_x")
-        self.sheet_modified(event_data)
-        self.PAR.emit_event("<<Cut>>", event_data)
+            self.sheet_modified(event_data)
+            self.PAR.emit_event("<<Cut>>", event_data)
         return event_data
 
     def ctrl_v(self, event: object = None, validation: bool = True) -> None | EventDataDict:
@@ -937,8 +934,6 @@ class MainTable(tk.Canvas):
         )
         event_data["selection_boxes"] = self.get_boxes()
         event_data["selected"] = self.selected
-        if event_data["cells"]["table"] or event_data["added"]["rows"] or event_data["added"]["columns"]:
-            self.undo_stack.append(pickled_event_dict(event_data))
         self.see(
             r=selected_r,
             c=selected_c,
@@ -950,9 +945,10 @@ class MainTable(tk.Canvas):
         )
         self.refresh()
         if event_data["cells"]["table"] or event_data["added"]["rows"] or event_data["added"]["columns"]:
+            self.undo_stack.append(stored_event_dict(event_data))
             try_binding(self.extra_end_ctrl_v_func, event_data, "end_ctrl_v")
-        self.sheet_modified(event_data)
-        self.PAR.emit_event("<<Paste>>", event_data)
+            self.sheet_modified(event_data)
+            self.PAR.emit_event("<<Paste>>", event_data)
         return event_data
 
     def delete_key(self, event: object = None, validation: bool = True) -> None | EventDataDict:
@@ -988,11 +984,11 @@ class MainTable(tk.Canvas):
                             event_data,
                         )
         if event_data["cells"]["table"]:
-            self.undo_stack.append(pickled_event_dict(event_data))
+            self.refresh()
+            self.undo_stack.append(stored_event_dict(event_data))
             try_binding(self.extra_end_delete_key_func, event_data, "end_delete")
-        self.refresh()
-        self.sheet_modified(event_data)
-        self.PAR.emit_event("<<Delete>>", event_data)
+            self.sheet_modified(event_data)
+            self.PAR.emit_event("<<Delete>>", event_data)
         return event_data
 
     def event_data_set_cell(self, datarn: int, datacn: int, value: object, event_data: dict) -> EventDataDict:
@@ -1060,7 +1056,7 @@ class MainTable(tk.Canvas):
                 "data": data_new_idxs,
                 "displayed": {} if disp_new_idxs is None else disp_new_idxs,
             }
-        event_data["options"] = self.pickle_options()
+        event_data["options"] = self.copy_options()
         event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
         if move_widths and disp_new_idxs and (not data_indexes or self.all_columns_displayed):
             self.deselect("all", run_binding=False, redraw=False)
@@ -1294,7 +1290,7 @@ class MainTable(tk.Canvas):
                 "data": data_new_idxs,
                 "displayed": {} if disp_new_idxs is None else disp_new_idxs,
             }
-        event_data["options"] = self.pickle_options()
+        event_data["options"] = self.copy_options()
         event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
         if move_heights and disp_new_idxs and (not data_indexes or self.all_rows_displayed):
             self.deselect("all", run_binding=False, redraw=False)
@@ -1485,11 +1481,11 @@ class MainTable(tk.Canvas):
     def undo(self, event: object = None) -> None | EventDataDict:
         if not self.undo_stack:
             return
-        modification = decompress_load(self.undo_stack[-1]["data"])
+        modification = self.undo_stack[-1]["data"]
         if not try_binding(self.extra_begin_ctrl_z_func, modification, "begin_undo"):
             return
         event_data = self.undo_modification_invert_event(modification)
-        self.redo_stack.append(pickled_event_dict(event_data))
+        self.redo_stack.append(stored_event_dict(event_data))
         self.undo_stack.pop()
         self.sheet_modified(event_data, purge_redo=False)
         try_binding(self.extra_end_ctrl_z_func, event_data, "end_undo")
@@ -1499,11 +1495,11 @@ class MainTable(tk.Canvas):
     def redo(self, event: object = None) -> None | EventDataDict:
         if not self.redo_stack:
             return
-        modification = decompress_load(self.redo_stack[-1]["data"])
+        modification = self.redo_stack[-1]["data"]
         if not try_binding(self.extra_begin_ctrl_z_func, modification, "begin_redo"):
             return
         event_data = self.undo_modification_invert_event(modification, name="redo")
-        self.undo_stack.append(pickled_event_dict(event_data))
+        self.undo_stack.append(stored_event_dict(event_data))
         self.redo_stack.pop()
         self.sheet_modified(event_data, purge_redo=False)
         try_binding(self.extra_end_ctrl_z_func, event_data, "end_redo")
@@ -1538,8 +1534,6 @@ class MainTable(tk.Canvas):
         return event_data
 
     def restore_options_named_spans(self, modification: EventDataDict) -> None:
-        if not isinstance(modification["options"], dict):
-            modification["options"] = unpickle_obj(modification["options"])
         if "cell_options" in modification["options"]:
             self.cell_options = modification["options"]["cell_options"]
         if "column_options" in modification["options"]:
@@ -2996,8 +2990,7 @@ class MainTable(tk.Canvas):
                 self.being_drawn_item = True
                 self.being_drawn_item = self.add_selection(rowsel, colsel, set_as_current=True, run_binding_func=False)
                 sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
-                if self.ctrl_selection_binding_func:
-                    self.ctrl_selection_binding_func(sel_event)
+                try_binding(self.ctrl_selection_binding_func, sel_event)
                 self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True, redraw_table=True)
                 self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
         elif not self.ctrl_select_enabled:
@@ -3026,8 +3019,7 @@ class MainTable(tk.Canvas):
                     )
                 self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True, redraw_table=True)
                 sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
-                if self.shift_selection_binding_func:
-                    self.shift_selection_binding_func(sel_event)
+                try_binding(self.shift_selection_binding_func, sel_event)
                 self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
         elif not self.ctrl_select_enabled:
             self.shift_b1_press(event)
@@ -3056,8 +3048,7 @@ class MainTable(tk.Canvas):
                     )
                 self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True, redraw_table=True)
                 sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
-                if self.shift_selection_binding_func:
-                    self.shift_selection_binding_func(sel_event)
+                try_binding(self.shift_selection_binding_func, sel_event)
                 self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
 
     def get_shift_select_box(self, min_r: int, rowsel: int, min_c: int, colsel: int):
@@ -3122,8 +3113,7 @@ class MainTable(tk.Canvas):
                         )
                     need_redraw = True
                     sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
-                    if self.drag_selection_binding_func:
-                        self.drag_selection_binding_func(sel_event)
+                    try_binding(self.drag_selection_binding_func, sel_event)
                     self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
             if self.scroll_if_event_offscreen(event):
                 need_redraw = True
@@ -3165,8 +3155,7 @@ class MainTable(tk.Canvas):
                         )
                     need_redraw = True
                     sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
-                    if self.drag_selection_binding_func:
-                        self.drag_selection_binding_func(sel_event)
+                    try_binding(self.drag_selection_binding_func, sel_event)
                     self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
             if self.scroll_if_event_offscreen(event):
                 need_redraw = True
@@ -3193,8 +3182,7 @@ class MainTable(tk.Canvas):
                 ),
             )
             sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
-            if self.drag_selection_binding_func:
-                self.drag_selection_binding_func(sel_event)
+            try_binding(self.drag_selection_binding_func, sel_event)
             self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
         else:
             self.being_drawn_item = None
@@ -4539,7 +4527,7 @@ class MainTable(tk.Canvas):
             event_data=event_data,
         )
         if self.undo_enabled:
-            self.undo_stack.append(pickled_event_dict(event_data))
+            self.undo_stack.append(stored_event_dict(event_data))
         self.refresh()
         try_binding(self.extra_end_insert_cols_rc_func, event_data, "end_add_columns")
         self.sheet_modified(event_data)
@@ -4674,7 +4662,7 @@ class MainTable(tk.Canvas):
             event_data=event_data,
         )
         if self.undo_enabled:
-            self.undo_stack.append(pickled_event_dict(event_data))
+            self.undo_stack.append(stored_event_dict(event_data))
         self.refresh()
         try_binding(self.extra_end_insert_rows_rc_func, event_data, "end_add_rows")
         self.sheet_modified(event_data)
@@ -4778,26 +4766,24 @@ class MainTable(tk.Canvas):
             }
         return rows, index_data, heights
 
-    def pickle_options(self) -> bytes:
-        return pickle_obj(
-            {
-                "cell_options": self.cell_options,
-                "column_options": self.col_options,
-                "row_options": self.row_options,
-                "CH_cell_options": self.CH.cell_options,
-                "RI_cell_options": self.RI.cell_options,
-                "tagged_cells": self.tagged_cells,
-                "tagged_rows": self.tagged_rows,
-                "tagged_columns": self.tagged_columns,
-            }
-        )
+    def copy_options(self) -> dict:
+        return {
+            "cell_options": dict(self.cell_options),
+            "column_options": dict(self.col_options),
+            "row_options": dict(self.row_options),
+            "CH_cell_options": dict(self.CH.cell_options),
+            "RI_cell_options": dict(self.RI.cell_options),
+            "tagged_cells": {f"{tag}": set(s) for tag, s in self.tagged_cells.items()},
+            "tagged_rows": {f"{tag}": set(s) for tag, s in self.tagged_rows.items()},
+            "tagged_columns": {f"{tag}": set(s) for tag, s in self.tagged_columns.items()},
+        }
 
     def delete_columns_data(self, cols: list, event_data: dict) -> EventDataDict:
         self.mouseclick_outside_editor_or_dropdown_all_canvases()
         event_data["deleted"]["displayed_columns"] = (
             list(self.displayed_columns) if not isinstance(self.displayed_columns, int) else int(self.displayed_columns)
         )
-        event_data["options"] = self.pickle_options()
+        event_data["options"] = self.copy_options()
         event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
         for datacn in reversed(cols):
             for rn in range(len(self.data)):
@@ -4849,7 +4835,7 @@ class MainTable(tk.Canvas):
         data_cols = selected if self.all_columns_displayed else [self.displayed_columns[c] for c in selected]
         event_data = self.delete_columns_data(data_cols, event_data)
         if self.undo_enabled:
-            self.undo_stack.append(pickled_event_dict(event_data))
+            self.undo_stack.append(stored_event_dict(event_data))
         self.deselect("all")
         try_binding(self.extra_end_del_cols_rc_func, event_data, "end_delete_columns")
         self.sheet_modified(event_data)
@@ -4859,7 +4845,7 @@ class MainTable(tk.Canvas):
         event_data["deleted"]["displayed_rows"] = (
             list(self.displayed_rows) if not isinstance(self.displayed_rows, int) else int(self.displayed_rows)
         )
-        event_data["options"] = self.pickle_options()
+        event_data["options"] = self.copy_options()
         event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
         for datarn in reversed(rows):
             event_data["deleted"]["rows"][datarn] = self.data.pop(datarn)
@@ -4905,7 +4891,7 @@ class MainTable(tk.Canvas):
         data_rows = selected if self.all_rows_displayed else [self.displayed_rows[r] for r in selected]
         event_data = self.delete_rows_data(data_rows, event_data)
         if self.undo_enabled:
-            self.undo_stack.append(pickled_event_dict(event_data))
+            self.undo_stack.append(stored_event_dict(event_data))
         self.deselect("all")
         try_binding(self.extra_end_del_rows_rc_func, event_data, "end_delete_rows")
         self.sheet_modified(event_data)
@@ -5184,6 +5170,12 @@ class MainTable(tk.Canvas):
             kwargs = self.progress_bars[(datarn, datacn)]
         else:
             kwargs = self.get_cell_kwargs(datarn, datacn, key="highlight")
+        if not kwargs and (self.PAR.ops.alternate_color and r % 2):
+            kwargs = Highlight(
+                bg=self.PAR.ops.alternate_color,
+                fg=None,
+                end=False,
+            )
         if kwargs:
             if kwargs[0] is not None:
                 c_1 = kwargs[0] if kwargs[0].startswith("#") else color_map[kwargs[0]]
@@ -5862,7 +5854,13 @@ class MainTable(tk.Canvas):
                                 if draw_y + self.table_half_txt_height - 1 > rbotgridln:
                                     break
         if redraw_table:
-            for dct in (self.hidd_text, self.hidd_high, self.hidd_grid, self.hidd_dropdown, self.hidd_checkbox):
+            for dct in (
+                self.hidd_text,
+                self.hidd_high,
+                self.hidd_grid,
+                self.hidd_dropdown,
+                self.hidd_checkbox,
+            ):
                 for iid, showing in dct.items():
                     if showing:
                         self.itemconfig(iid, state="hidden")
@@ -7271,7 +7269,7 @@ class MainTable(tk.Canvas):
         )
         if not check_input_valid or self.input_valid_for_cell(datarn, datacn, value):
             if self.undo_enabled and undo:
-                self.undo_stack.append(pickled_event_dict(event_data))
+                self.undo_stack.append(stored_event_dict(event_data))
             self.set_cell_data(datarn, datacn, value)
             if cell_resize and self.PAR.ops.cell_auto_resize_enabled:
                 self.set_cell_size_to_text(r, c, only_if_too_small=True, redraw=redraw, run_binding=True)

tksheet/row_index.py

@@ -41,7 +41,7 @@ from .functions import (
     is_contiguous,
     new_tk_event,
     num2alpha,
-    pickled_event_dict,
+    stored_event_dict,
     rounded_box_coords,
     try_binding,
 )
@@ -66,8 +66,7 @@ from .vars import (
 
 class RowIndex(tk.Canvas):
     def __init__(self, *args, **kwargs):
-        tk.Canvas.__init__(
-            self,
+        super().__init__(
             kwargs["parent"],
             background=kwargs["parent"].ops.index_bg,
             highlightthickness=0,
@@ -879,7 +878,7 @@ class RowIndex(tk.Canvas):
                         "displayed": disp_new_idxs,
                     }
                     if self.MT.undo_enabled:
-                        self.MT.undo_stack.append(pickled_event_dict(event_data))
+                        self.MT.undo_stack.append(stored_event_dict(event_data))
                     self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
                     try_binding(self.ri_extra_end_drag_drop_func, event_data, "end_move_rows")
                     self.MT.sheet_modified(event_data)
@@ -2345,7 +2344,7 @@ class RowIndex(tk.Canvas):
             self.fix_index(datarn)
             if not check_input_valid or self.input_valid_for_cell(datarn, value):
                 if self.MT.undo_enabled and undo:
-                    self.MT.undo_stack.append(pickled_event_dict(event_data))
+                    self.MT.undo_stack.append(stored_event_dict(event_data))
                 self.set_cell_data(datarn=datarn, value=value)
                 edited = True
         if edited and cell_resize and self.PAR.ops.cell_auto_resize_enabled:

tksheet/sheet.py

@@ -48,7 +48,7 @@ from .functions import (
     key_to_span,
     new_tk_event,
     num2alpha,
-    pickled_event_dict,
+    stored_event_dict,
     pop_positions,
     set_align,
     set_readonly,
@@ -289,8 +289,7 @@ class Sheet(tk.Frame):
         row_index_width: int | None = None,
         expand_sheet_if_paste_too_big: bool | None = None,
     ) -> None:
-        tk.Frame.__init__(
-            self,
+        super().__init__(
             parent,
             background=frame_bg,
             highlightthickness=outline_thickness,
@@ -1843,7 +1842,7 @@ class Sheet(tk.Frame):
             or event_data["added"]["rows"]
         ):
             if undo is True or (undo is None and span.undo):
-                self.MT.undo_stack.append(pickled_event_dict(event_data))
+                self.MT.undo_stack.append(stored_event_dict(event_data))
             if emit_event is True or (emit_event is None and span.emit_event):
                 self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -1883,7 +1882,7 @@ class Sheet(tk.Frame):
                     event_data = clear_t(r, c, quick_tval(r, c), event_data)
         if event_data["cells"]["table"] or event_data["cells"]["header"] or event_data["cells"]["index"]:
             if undo is True or (undo is None and span.undo):
-                self.MT.undo_stack.append(pickled_event_dict(event_data))
+                self.MT.undo_stack.append(stored_event_dict(event_data))
             if emit_event is True or (emit_event is None and span.emit_event):
                 self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2052,7 +2051,7 @@ class Sheet(tk.Frame):
             push_ops=push_ops,
         )
         if undo:
-            self.MT.undo_stack.append(pickled_event_dict(event_data))
+            self.MT.undo_stack.append(stored_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2147,7 +2146,7 @@ class Sheet(tk.Frame):
             push_ops=push_ops,
         )
         if undo:
-            self.MT.undo_stack.append(pickled_event_dict(event_data))
+            self.MT.undo_stack.append(stored_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2223,7 +2222,7 @@ class Sheet(tk.Frame):
                 event_data,
             )
         if undo:
-            self.MT.undo_stack.append(pickled_event_dict(event_data))
+            self.MT.undo_stack.append(stored_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2265,7 +2264,7 @@ class Sheet(tk.Frame):
                 event_data,
             )
         if undo:
-            self.MT.undo_stack.append(pickled_event_dict(event_data))
+            self.MT.undo_stack.append(stored_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2362,7 +2361,7 @@ class Sheet(tk.Frame):
             data_indexes=data_indexes,
         )
         if undo:
-            self.MT.undo_stack.append(pickled_event_dict(event_data))
+            self.MT.undo_stack.append(stored_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2392,7 +2391,7 @@ class Sheet(tk.Frame):
             data_indexes=data_indexes,
         )
         if undo:
-            self.MT.undo_stack.append(pickled_event_dict(event_data))
+            self.MT.undo_stack.append(stored_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2419,7 +2418,7 @@ class Sheet(tk.Frame):
             data_indexes=data_indexes,
         )
         if undo:
-            self.MT.undo_stack.append(pickled_event_dict(event_data))
+            self.MT.undo_stack.append(stored_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2446,7 +2445,7 @@ class Sheet(tk.Frame):
             data_indexes=data_indexes,
         )
         if undo:
-            self.MT.undo_stack.append(pickled_event_dict(event_data))
+            self.MT.undo_stack.append(stored_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)

tksheet/text_editor.py

@@ -22,8 +22,7 @@ class TextEditorTkText(tk.Text):
         parent: tk.Misc,
         newline_binding: None | Callable = None,
     ) -> None:
-        tk.Text.__init__(
-            self,
+        super().__init__(
             parent,
             spacing1=0,
             spacing2=1,
@@ -170,8 +169,7 @@ class TextEditor(tk.Frame):
         parent: tk.Misc,
         newline_binding: None | Callable = None,
     ) -> None:
-        tk.Frame.__init__(
-            self,
+        super().__init__(
             parent,
             width=0,
             height=0,

{tksheet-7.2.19.dist-info → tksheet-7.2.21.dist-info}/METADATA

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

tksheet-7.2.21.dist-info/RECORD

@@ -0,0 +1,20 @@
+tksheet/__init__.py,sha256=1KjTw8xxFD3fY1W7O-p1bo6i-ZvwEUmORhaIS3kSJlI,2237
+tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
+tksheet/column_headers.py,sha256=ekuZjXjTHuyRsog5rNMBCJU3Fmj6OgeRVgKEDysjEaw,102184
+tksheet/formatters.py,sha256=_exO2KnjtcnE_MVWLG1ngOZ-wmrXZhuh7uEi2iPs1Tk,10546
+tksheet/functions.py,sha256=1lVrGCnNUUorh68bcFJMqSn3C4_OFH7Y-c4fEalDKc4,42413
+tksheet/main_table.py,sha256=7I0qPQbeWpEzY8LCaZrUvAygdDWkqFEF8a0jX-CgWCc,332201
+tksheet/other_classes.py,sha256=eB-kDTJjYOe5QcSA25Bg9JS2JimZau2fAvyz8rcBT0Q,15631
+tksheet/row_index.py,sha256=5auK_MfMnT-tEO8QwHTa74WT48nXvj9bqVmgtnn8QjQ,111171
+tksheet/sheet.py,sha256=RgP2MhOaxNPwIAa2cXwHNUGbJZJRib6hkvMfoph0nWA,283215
+tksheet/sheet_options.py,sha256=XM3XSWWVnAOctP2z2_WkkXonoIT8_brXwJaSO0sFZbE,12788
+tksheet/text_editor.py,sha256=pf9o3JuRI6cbr7ZoVfaookCBJsmRBgGDubdtShLZXBA,7064
+tksheet/themes.py,sha256=OhUzZL4JH0YPhb2f1F62CcJFzhVsEvNxF-ObC9zVb44,14474
+tksheet/top_left_rectangle.py,sha256=ri7hb9CC5l37ynmxceprq11UuWWRpWEI_0AI42wzv0A,8444
+tksheet/types.py,sha256=IgoEHMbceKpakcZtanxKaKJ4RdCq7UW6EoEIIz5O59k,340
+tksheet/vars.py,sha256=86ubZZElsnQuC6Lv6bW2lt2NhD9wAp6PxtkK7ufKqq0,3452
+tksheet-7.2.21.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
+tksheet-7.2.21.dist-info/METADATA,sha256=8O8nElk2NXgmuIFPftStjlzYkjSk4Kz-7VLqkbCf6Ls,6476
+tksheet-7.2.21.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+tksheet-7.2.21.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
+tksheet-7.2.21.dist-info/RECORD,,

{tksheet-7.2.19.dist-info → tksheet-7.2.21.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tksheet-7.2.19.dist-info/RECORD

@@ -1,20 +0,0 @@
-tksheet/__init__.py,sha256=UsF3O0h1sHVKInJEx2LacaojWXG47p8uUduX7lWjt7o,2165
-tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
-tksheet/column_headers.py,sha256=9ub7pF0F3HJppOaJ1y1_Ri6F4l7YYO9eo6XeQCbgP00,102208
-tksheet/formatters.py,sha256=DfsekFfOiNKZuIqk1xD7IUiO8W9HIeCSaB6zMwsDv40,10051
-tksheet/functions.py,sha256=P7nyiL5Q4nGmWo6CgPz0g2Vn56QclmOkniPDRFUNfTI,42768
-tksheet/main_table.py,sha256=me7dkHYma49b16e4ygc_jBum3JfGG-j4oK1dbNQb9xo,332431
-tksheet/other_classes.py,sha256=eB-kDTJjYOe5QcSA25Bg9JS2JimZau2fAvyz8rcBT0Q,15631
-tksheet/row_index.py,sha256=Hcgqi04YFNx_0S4pMko8Jf7idIFRqJdlEEy_WCX0DvI,111195
-tksheet/sheet.py,sha256=XuFqVOljwrdM5IYpm5NwT_oyVn9iOkPKABtQ2GQ8ziM,283246
-tksheet/sheet_options.py,sha256=XM3XSWWVnAOctP2z2_WkkXonoIT8_brXwJaSO0sFZbE,12788
-tksheet/text_editor.py,sha256=lmmHOPb11S8tlNtC10vijF1QqVB5Ts2hUKnGJd_JkWA,7103
-tksheet/themes.py,sha256=OhUzZL4JH0YPhb2f1F62CcJFzhVsEvNxF-ObC9zVb44,14474
-tksheet/top_left_rectangle.py,sha256=ri7hb9CC5l37ynmxceprq11UuWWRpWEI_0AI42wzv0A,8444
-tksheet/types.py,sha256=IgoEHMbceKpakcZtanxKaKJ4RdCq7UW6EoEIIz5O59k,340
-tksheet/vars.py,sha256=86ubZZElsnQuC6Lv6bW2lt2NhD9wAp6PxtkK7ufKqq0,3452
-tksheet-7.2.19.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
-tksheet-7.2.19.dist-info/METADATA,sha256=Df7jqZRsrUMBTHgI-1_fIncmszk1asde1sohy3z8YXw,6476
-tksheet-7.2.19.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-tksheet-7.2.19.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
-tksheet-7.2.19.dist-info/RECORD,,