tksheet 7.1.12__py3-none-any.whl → 7.1.20__py3-none-any.whl

tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.1.12"
+__version__ = "7.1.20"
 
 from .colors import (
     color_map,
@@ -42,6 +42,7 @@ from .functions import (
     event_dict,
     get_checkbox_dict,
     get_checkbox_kwargs,
+    get_data_from_clipboard,
     get_dropdown_dict,
     get_dropdown_kwargs,
     get_index_of_gap_in_sorted_integer_seq_forward,

tksheet/column_headers.py

@@ -22,10 +22,10 @@ from .colors import (
 from .formatters import is_bool_like, try_to_bool
 from .functions import (
     consecutive_ranges,
-    ev_stack_dict,
     event_dict,
     get_n2a,
     is_contiguous,
+    pickled_event_dict,
     rounded_box_coords,
     try_binding,
 )
@@ -133,6 +133,9 @@ class ColumnHeaders(tk.Canvas):
             self.bind("<Double-Button-1>", self.double_b1)
             self.bind(rc_binding, self.rc)
             self.bind("<MouseWheel>", self.mousewheel)
+            if USER_OS == "linux":
+                self.bind("<Button-4>", self.mousewheel)
+                self.bind("<Button-5>", self.mousewheel)
         else:
             self.unbind("<Motion>")
             self.unbind("<ButtonPress-1>")
@@ -141,6 +144,9 @@ class ColumnHeaders(tk.Canvas):
             self.unbind("<Double-Button-1>")
             self.unbind(rc_binding)
             self.unbind("<MouseWheel>")
+            if USER_OS == "linux":
+                self.unbind("<Button-4>")
+                self.unbind("<Button-5>")
 
     def mousewheel(self, event: object):
         maxlines = 0
@@ -845,7 +851,7 @@ class ColumnHeaders(tk.Canvas):
                         "displayed": disp_new_idxs,
                     }
                     if self.MT.undo_enabled:
-                        self.MT.undo_stack.append(ev_stack_dict(event_data))
+                        self.MT.undo_stack.append(pickled_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)
@@ -2091,7 +2097,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(ev_stack_dict(event_data))
+                    self.MT.undo_stack.append(pickled_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/functions.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
 import bisect
+import csv
+import io
 import pickle
 import re
+import tkinter as tk
 import zlib
 from collections import deque
 from collections.abc import (
@@ -19,6 +22,7 @@ from .other_classes import (
     DotDict,
     EventDataDict,
     Highlight,
+    Loc,
     Span,
 )
 
@@ -27,6 +31,21 @@ pickle_obj = partial(pickle.dumps, protocol=pickle.HIGHEST_PROTOCOL)
 unpickle_obj = pickle.loads
 
 
+def get_data_from_clipboard(
+    widget: tk.Misc,
+    delimiters: str,
+    lineterminator: str = "\n",
+) -> list[list[str]]:
+    data = widget.clipboard_get()
+    try:
+        dialect = csv.Sniffer().sniff(data, delimiters=delimiters)
+    except Exception:
+        dialect = csv.excel_tab
+    if dialect.delimiter in data or lineterminator in data:
+        return list(csv.reader(io.StringIO(data), dialect=dialect, skipinitialspace=True))
+    return [[data]]
+
+
 def pickle_compress(obj: object) -> bytes:
     return compress(pickle_obj(obj))
 
@@ -164,11 +183,8 @@ def change_eventname(event_dict: EventDataDict, newname: str) -> EventDataDict:
     return EventDataDict({**event_dict, **{"eventname": newname}})
 
 
-def ev_stack_dict(d: DotDict) -> DotDict:
-    return DotDict(
-        name=d["eventname"],
-        data=pickle_compress(d),
-    )
+def pickled_event_dict(d: DotDict) -> DotDict:
+    return DotDict(name=d["eventname"], data=pickle_compress(d))
 
 
 def len_to_idx(n: int) -> int:
@@ -406,11 +422,13 @@ def index_exists(seq: Sequence[object], index: int) -> bool:
 def move_elements_by_mapping(
     seq: list[object],
     new_idxs: dict[int, int],
-    old_idxs: dict[int, int],
+    old_idxs: dict[int, int] | None = None,
 ) -> list[object]:
     # move elements of a list around, displacing
     # other elements based on mapping
     # of {old index: new index, ...}
+    if old_idxs is None:
+        old_idxs = dict(zip(new_idxs.values(), new_idxs))
 
     # create dummy list
     res = [0] * len(seq)
@@ -1293,10 +1311,12 @@ def mod_span_widget(span: Span, widget: object) -> Span:
 def mod_event_val(
     event_data: EventDataDict,
     val: object,
-    loc: tuple[int, int] | int,
+    loc: Loc | int,
 ) -> EventDataDict:
     event_data.value = val
-    event_data.loc = loc
+    event_data.loc = Loc(*loc)
+    event_data.row = loc[0]
+    event_data.column = loc[1]
     return event_data
 
 

tksheet/main_table.py

@@ -52,9 +52,9 @@ from .functions import (
     decompress_load,
     diff_gen,
     diff_list,
-    ev_stack_dict,
     event_dict,
     gen_formatted,
+    get_data_from_clipboard,
     get_new_indexes,
     get_seq_without_gaps_at_index,
     index_exists,
@@ -68,6 +68,7 @@ from .functions import (
     mod_span_widget,
     move_elements_by_mapping,
     pickle_obj,
+    pickled_event_dict,
     rounded_box_coords,
     span_idxs_post_move,
     try_binding,
@@ -363,10 +364,10 @@ class MainTable(tk.Canvas):
             ("<ButtonRelease-1>", self, self.b1_release),
             ("<Double-Button-1>", self, self.double_b1),
             ("<MouseWheel>", self, self.mousewheel),
+            ("<MouseWheel>", self.RI, self.mousewheel),
             ("<Shift-ButtonPress-1>", self, self.shift_b1_press),
             ("<Shift-ButtonPress-1>", self.CH, self.CH.shift_b1_press),
             ("<Shift-ButtonPress-1>", self.RI, self.RI.shift_b1_press),
-            ("<MouseWheel>", self.RI, self.mousewheel),
             (rc_binding, self, self.rc),
             (f"<{ctrl_key}-ButtonPress-1>", self, self.ctrl_b1_press),
             (f"<{ctrl_key}-ButtonPress-1>", self.CH, self.CH.ctrl_b1_press),
@@ -385,9 +386,11 @@ class MainTable(tk.Canvas):
             ("<Control-equal>", self.zoom_in),
             ("<Control-minus>", self.zoom_out),
         )
-        all_canvas_linux_bindings = {
+        mt_ri_canvas_linux_bindings = {
             ("<Button-4>", self.mousewheel),
             ("<Button-5>", self.mousewheel),
+        }
+        all_canvas_linux_bindings = {
             ("<Shift-Button-4>", self.shift_mousewheel),
             ("<Shift-Button-5>", self.shift_mousewheel),
             ("<Control-Button-4>", self.ctrl_mousewheel),
@@ -400,6 +403,9 @@ class MainTable(tk.Canvas):
                 for canvas in (self, self.RI, self.CH):
                     canvas.bind(b[0], b[1])
             if USER_OS == "linux":
+                for b in mt_ri_canvas_linux_bindings:
+                    for canvas in (self, self.RI):
+                        canvas.bind(b[0], b[1])
                 for b in all_canvas_linux_bindings:
                     for canvas in (self, self.RI, self.CH):
                         canvas.bind(b[0], b[1])
@@ -410,6 +416,9 @@ class MainTable(tk.Canvas):
                 for canvas in (self, self.RI, self.CH):
                     canvas.unbind(b[0])
             if USER_OS == "linux":
+                for b in mt_ri_canvas_linux_bindings:
+                    for canvas in (self, self.RI):
+                        canvas.unbind(b[0])
                 for b in all_canvas_linux_bindings:
                     for canvas in (self, self.RI, self.CH):
                         canvas.unbind(b[0])
@@ -495,6 +504,8 @@ class MainTable(tk.Canvas):
     def get_ctrl_x_c_boxes(self) -> tuple[dict[tuple[int, int, int, int], str], int]:
         boxes = {}
         maxrows = 0
+        if not self.selected:
+            return boxes, maxrows
         if self.selected.type_ in ("cells", "columns"):
             curr_box = self.selection_boxes[self.selected.fill_iid].coords
             maxrows = curr_box[2] - curr_box[0]
@@ -517,7 +528,7 @@ class MainTable(tk.Canvas):
         )
         return s, writer
 
-    def ctrl_c(self, event=None) -> None:
+    def ctrl_c(self, event=None) -> None | EventDataDict:
         if not self.selected:
             return
         event_data = event_dict(
@@ -555,14 +566,17 @@ 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))
         self.clipboard_clear()
-        if len(event_data["cells"]["table"]) == 1:
+        if len(event_data["cells"]["table"]) == 1 and self.PAR.ops.to_clipboard_lineterminator not in next(
+            iter(event_data["cells"]["table"].values())
+        ):
             self.clipboard_append(next(iter(event_data["cells"]["table"].values())))
         else:
             self.clipboard_append(s.getvalue())
         self.update_idletasks()
         try_binding(self.extra_end_ctrl_c_func, event_data, "end_ctrl_c")
+        return event_data
 
-    def ctrl_x(self, event=None) -> None:
+    def ctrl_x(self, event=None, validation: bool = True) -> None | EventDataDict:
         if not self.selected:
             return
         event_data = event_dict(
@@ -586,10 +600,14 @@ class MainTable(tk.Canvas):
                         datacn = self.datacn(c)
                         row.append(self.get_cell_clipboard(datarn, datacn))
                         val = self.get_value_for_empty_cell(datarn, datacn)
-                        if not self.edit_validation_func or (
-                            self.edit_validation_func
-                            and (val := self.edit_validation_func(mod_event_val(event_data, val, (r1 + rn, c))))
-                            is not None
+                        if (
+                            not self.edit_validation_func
+                            or not validation
+                            or (
+                                self.edit_validation_func
+                                and (val := self.edit_validation_func(mod_event_val(event_data, val, (r1 + rn, c))))
+                                is not None
+                            )
                         ):
                             event_data = self.event_data_set_cell(
                                 datarn,
@@ -607,10 +625,14 @@ class MainTable(tk.Canvas):
                         datacn = self.datacn(c)
                         row.append(self.get_cell_clipboard(datarn, datacn))
                         val = self.get_value_for_empty_cell(datarn, datacn)
-                        if not self.edit_validation_func or (
-                            self.edit_validation_func
-                            and (val := self.edit_validation_func(mod_event_val(event_data, val, (r1 + rn, c))))
-                            is not None
+                        if (
+                            not self.edit_validation_func
+                            or not validation
+                            or (
+                                self.edit_validation_func
+                                and (val := self.edit_validation_func(mod_event_val(event_data, val, (r1 + rn, c))))
+                                is not None
+                            )
                         ):
                             event_data = self.event_data_set_cell(
                                 datarn,
@@ -620,9 +642,11 @@ class MainTable(tk.Canvas):
                             )
                     writer.writerow(row)
         if event_data["cells"]["table"]:
-            self.undo_stack.append(ev_stack_dict(event_data))
+            self.undo_stack.append(pickled_event_dict(event_data))
         self.clipboard_clear()
-        if len(event_data["cells"]["table"]) == 1:
+        if len(event_data["cells"]["table"]) == 1 and self.PAR.ops.to_clipboard_lineterminator not in next(
+            iter(event_data["cells"]["table"].values())
+        ):
             self.clipboard_append(next(iter(event_data["cells"]["table"].values())))
         else:
             self.clipboard_append(s.getvalue())
@@ -633,8 +657,9 @@ class MainTable(tk.Canvas):
         if event_data["cells"]["table"]:
             try_binding(self.extra_end_ctrl_x_func, event_data, "end_ctrl_x")
         self.sheet_modified(event_data)
+        return event_data
 
-    def ctrl_v(self, event: object = None) -> None:
+    def ctrl_v(self, event: object = None, validation: bool = True) -> None | EventDataDict:
         if not self.PAR.ops.expand_sheet_if_paste_too_big and (
             len(self.col_positions) == 1 or len(self.row_positions) == 1
         ):
@@ -660,18 +685,13 @@ class MainTable(tk.Canvas):
                 elif len(self.row_positions) > 1 and len(self.col_positions) > 1:
                     selected_c, selected_r = 0, len(self.row_positions) - 1
         try:
-            data = self.clipboard_get()
+            data = get_data_from_clipboard(
+                widget=self,
+                delimiters=self.PAR.ops.from_clipboard_delimiters,
+                lineterminator=self.PAR.ops.to_clipboard_lineterminator,
+            )
         except Exception:
             return
-        try:
-            dialect = csv.Sniffer().sniff(data, delimiters=self.PAR.ops.from_clipboard_delimiters)
-        except Exception:
-            dialect = csv.excel_tab
-        if dialect.delimiter in data:
-            if not (data := list(csv.reader(io.StringIO(data), dialect=dialect, skipinitialspace=True))):
-                return
-        else:
-            data = [[data]]
         new_data_numcols = max(map(len, data))
         new_data_numrows = len(data)
         for rn, r in enumerate(data):
@@ -749,9 +769,13 @@ class MainTable(tk.Canvas):
         for ndr, r in enumerate(range(selected_r, selected_r_adjusted_new_data_numrows)):
             for ndc, c in enumerate(range(selected_c, selected_c_adjusted_new_data_numcols)):
                 val = data[ndr][ndc]
-                if not self.edit_validation_func or (
-                    self.edit_validation_func
-                    and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
+                if (
+                    not self.edit_validation_func
+                    or not validation
+                    or (
+                        self.edit_validation_func
+                        and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
+                    )
                 ):
                     event_data = self.event_data_set_cell(
                         datarn=self.datarn(r),
@@ -785,10 +809,14 @@ class MainTable(tk.Canvas):
                 ):
                     val = data[ndr][ndc]
                     datacn = self.datacn(c)
-                    if not self.edit_validation_func or (
-                        self.edit_validation_func
-                        and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
-                        and self.input_valid_for_cell(r, datacn, val, ignore_empty=True)
+                    if (
+                        not self.edit_validation_func
+                        or not validation
+                        or (
+                            self.edit_validation_func
+                            and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
+                            and self.input_valid_for_cell(r, datacn, val, ignore_empty=True)
+                        )
                     ):
                         rows[r][datacn] = val
                         ctr += 1
@@ -823,10 +851,14 @@ class MainTable(tk.Canvas):
                 ):
                     val = data[ndr][ndc]
                     datarn = self.datarn(r)
-                    if not self.edit_validation_func or (
-                        self.edit_validation_func
-                        and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
-                        and self.input_valid_for_cell(datarn, c, val, ignore_empty=True)
+                    if (
+                        not self.edit_validation_func
+                        or not validation
+                        or (
+                            self.edit_validation_func
+                            and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
+                            and self.input_valid_for_cell(datarn, c, val, ignore_empty=True)
+                        )
                     ):
                         columns[c][datarn] = val
                         ctr += 1
@@ -839,7 +871,7 @@ class MainTable(tk.Canvas):
                 )
         self.deselect("all", redraw=False)
         if event_data["cells"]["table"] or event_data["added"]["rows"] or event_data["added"]["columns"]:
-            self.undo_stack.append(ev_stack_dict(event_data))
+            self.undo_stack.append(pickled_event_dict(event_data))
         self.create_selection_box(
             selected_r,
             selected_c,
@@ -861,8 +893,9 @@ class MainTable(tk.Canvas):
         if event_data["cells"]["table"] or event_data["added"]["rows"] or event_data["added"]["columns"]:
             try_binding(self.extra_end_ctrl_v_func, event_data, "end_ctrl_v")
         self.sheet_modified(event_data)
+        return event_data
 
-    def delete_key(self, event: object = None) -> None:
+    def delete_key(self, event: object = None, validation: bool = True) -> None | EventDataDict:
         if not self.selected:
             return
         event_data = event_dict(
@@ -879,9 +912,13 @@ class MainTable(tk.Canvas):
                 for c in range(c1, c2):
                     datarn, datacn = self.datarn(r), self.datacn(c)
                     val = self.get_value_for_empty_cell(datarn, datacn)
-                    if not self.edit_validation_func or (
-                        self.edit_validation_func
-                        and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
+                    if (
+                        not self.edit_validation_func
+                        or not validation
+                        or (
+                            self.edit_validation_func
+                            and (val := self.edit_validation_func(mod_event_val(event_data, val, (r, c)))) is not None
+                        )
                     ):
                         event_data = self.event_data_set_cell(
                             datarn,
@@ -890,10 +927,11 @@ class MainTable(tk.Canvas):
                             event_data,
                         )
         if event_data["cells"]["table"]:
-            self.undo_stack.append(ev_stack_dict(event_data))
+            self.undo_stack.append(pickled_event_dict(event_data))
             try_binding(self.extra_end_delete_key_func, event_data, "end_delete")
         self.refresh()
         self.sheet_modified(event_data)
+        return event_data
 
     def event_data_set_cell(self, datarn: int, datacn: int, value: object, event_data: dict) -> EventDataDict:
         if self.input_valid_for_cell(datarn, datacn, value):
@@ -1370,39 +1408,36 @@ class MainTable(tk.Canvas):
         # all the way from 0 to max_idx
         if old_idxs is None:
             old_idxs = dict(zip(new_idxs.values(), new_idxs))
-        seq = tuple(range(max_idx + 1))
         return dict(
             zip(
-                move_elements_by_mapping(seq, new_idxs, old_idxs),
-                seq,
+                move_elements_by_mapping(tuple(range(max_idx + 1)), new_idxs, old_idxs),
+                range(max_idx + 1),
             )
         )
 
-    def undo(self, event: object = None) -> None:
+    def undo(self, event: object = None) -> None | EventDataDict:
         if not self.undo_stack:
             return
-        if isinstance(self.undo_stack[-1]["data"], dict):
-            modification = self.undo_stack[-1]["data"]
-        else:
-            modification = decompress_load(self.undo_stack[-1]["data"])
+        modification = decompress_load(self.undo_stack[-1]["data"])
         if not try_binding(self.extra_begin_ctrl_z_func, modification, "begin_undo"):
             return
-        self.redo_stack.append(self.undo_modification_invert_event(modification))
+        event_data = self.undo_modification_invert_event(modification)
+        self.redo_stack.append(pickled_event_dict(event_data))
         self.undo_stack.pop()
-        try_binding(self.extra_end_ctrl_z_func, modification, "end_undo")
+        try_binding(self.extra_end_ctrl_z_func, event_data, "end_undo")
+        return event_data
 
-    def redo(self, event: object = None) -> None:
+    def redo(self, event: object = None) -> None | EventDataDict:
         if not self.redo_stack:
             return
-        if isinstance(self.redo_stack[-1]["data"], dict):
-            modification = self.redo_stack[-1]["data"]
-        else:
-            modification = decompress_load(self.redo_stack[-1]["data"])
+        modification = decompress_load(self.redo_stack[-1]["data"])
         if not try_binding(self.extra_begin_ctrl_z_func, modification, "begin_redo"):
             return
-        self.undo_stack.append(self.undo_modification_invert_event(modification, name="redo"))
+        event_data = self.undo_modification_invert_event(modification, name="redo")
+        self.undo_stack.append(pickled_event_dict(event_data))
         self.redo_stack.pop()
-        try_binding(self.extra_end_ctrl_z_func, modification, "end_redo")
+        try_binding(self.extra_end_ctrl_z_func, event_data, "end_redo")
+        return event_data
 
     def sheet_modified(self, event_data: EventDataDict, purge_redo: bool = True) -> None:
         self.PAR.emit_event("<<SheetModified>>", event_data)
@@ -1450,7 +1485,7 @@ class MainTable(tk.Canvas):
             k: mod_span_widget(unpickle_obj(v), self.PAR) for k, v in modification["named_spans"].items()
         }
 
-    def undo_modification_invert_event(self, modification: EventDataDict, name: str = "undo") -> bytes | EventDataDict:
+    def undo_modification_invert_event(self, modification: EventDataDict, name: str = "undo") -> EventDataDict:
         self.deselect("all", redraw=False)
         event_data = event_dict(
             name=modification["eventname"],
@@ -1615,7 +1650,7 @@ class MainTable(tk.Canvas):
 
         self.sheet_modified(event_data, purge_redo=False)
         self.refresh()
-        return ev_stack_dict(event_data)
+        return event_data
 
     def see(
         self,
@@ -2733,9 +2768,10 @@ class MainTable(tk.Canvas):
                         popup_menu = self.rc_popup_menu
             else:
                 self.deselect("all")
-                popup_menu = self.empty_rc_popup_menu
+                if self.rc_popup_menus_enabled:
+                    popup_menu = self.empty_rc_popup_menu
         try_binding(self.extra_rc_func, event)
-        if popup_menu is not None:
+        if popup_menu:
             popup_menu.tk_popup(event.x_root, event.y_root)
 
     def b1_press(self, event=None):
@@ -3715,6 +3751,22 @@ class MainTable(tk.Canvas):
             del self.row_positions[idx]
             self.row_positions[idx:] = [e - w for e in islice(self.row_positions, idx, len(self.row_positions))]
 
+    def del_col_positions(self, idxs: Iterator[int] | None = None):
+        if idxs is None:
+            del self.col_positions[-1]
+        else:
+            if not isinstance(idxs, set):
+                idxs = set(idxs)
+            self.set_col_positions(itr=(w for i, w in enumerate(self.gen_column_widths()) if i not in idxs))
+
+    def del_row_positions(self, idxs: Iterator[int] | None = None):
+        if idxs is None:
+            del self.row_positions[-1]
+        else:
+            if not isinstance(idxs, set):
+                idxs = set(idxs)
+            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)
 
@@ -3727,26 +3779,6 @@ class MainTable(tk.Canvas):
     def gen_row_heights(self) -> Generator[int]:
         return diff_gen(self.row_positions)
 
-    def del_col_positions(self, idx: int, num: int = 1, deselect_all: bool = False):
-        if deselect_all:
-            self.deselect("all", redraw=False)
-        if idx == "end" or len(self.col_positions) <= idx + 1:
-            del self.col_positions[-1]
-        else:
-            cws = self.get_column_widths()
-            cws[idx : idx + num] = []
-            self.set_col_positions(itr=cws)
-
-    def del_row_positions(self, idx: int, numrows: int = 1, deselect_all: bool = False):
-        if deselect_all:
-            self.deselect("all", redraw=False)
-        if idx == "end" or len(self.row_positions) <= idx + 1:
-            del self.row_positions[-1]
-        else:
-            rhs = self.get_row_heights()
-            rhs[idx : idx + numrows] = []
-            self.set_row_positions(itr=rhs)
-
     def insert_col_position(
         self,
         idx: Literal["end"] | int = "end",
@@ -4301,7 +4333,7 @@ class MainTable(tk.Canvas):
             event_data=event_data,
         )
         if self.undo_enabled:
-            self.undo_stack.append(ev_stack_dict(event_data))
+            self.undo_stack.append(pickled_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)
@@ -4432,7 +4464,7 @@ class MainTable(tk.Canvas):
             event_data=event_data,
         )
         if self.undo_enabled:
-            self.undo_stack.append(ev_stack_dict(event_data))
+            self.undo_stack.append(pickled_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)
@@ -4604,7 +4636,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(ev_stack_dict(event_data))
+            self.undo_stack.append(pickled_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)
@@ -4658,7 +4690,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(ev_stack_dict(event_data))
+            self.undo_stack.append(pickled_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)
@@ -6970,7 +7002,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(ev_stack_dict(event_data))
+                self.undo_stack.append(pickled_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_set_if_too_small=True, redraw=redraw, run_binding=True)

tksheet/row_index.py

@@ -29,11 +29,11 @@ from .formatters import (
 )
 from .functions import (
     consecutive_chunks,
-    ev_stack_dict,
     event_dict,
     get_n2a,
     is_contiguous,
     num2alpha,
+    pickled_event_dict,
     rounded_box_coords,
     try_binding,
 )
@@ -851,7 +851,7 @@ class RowIndex(tk.Canvas):
                         "displayed": disp_new_idxs,
                     }
                     if self.MT.undo_enabled:
-                        self.MT.undo_stack.append(ev_stack_dict(event_data))
+                        self.MT.undo_stack.append(pickled_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)
@@ -2189,7 +2189,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(ev_stack_dict(event_data))
+                    self.MT.undo_stack.append(pickled_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

@@ -19,7 +19,6 @@ from .functions import (
     del_named_span_options,
     del_named_span_options_nested,
     dropdown_search_function,
-    ev_stack_dict,
     event_dict,
     fix_format_kwargs,
     get_checkbox_dict,
@@ -30,6 +29,7 @@ from .functions import (
     is_iterable,
     key_to_span,
     num2alpha,
+    pickled_event_dict,
     pop_positions,
     set_align,
     set_readonly,
@@ -1050,29 +1050,23 @@ class Sheet(tk.Frame):
             canvas.basic_bindings(enable)
         return self
 
-    def cut(self, event: object = None) -> Sheet:
-        self.MT.ctrl_x(event)
-        return self
+    def cut(self, event: object = None, validation: bool = True) -> None | EventDataDict:
+        return self.MT.ctrl_x(event, validation)
 
-    def copy(self, event: object = None) -> Sheet:
-        self.MT.ctrl_c(event)
-        return self
+    def copy(self, event: object = None) -> None | EventDataDict:
+        return self.MT.ctrl_c(event)
 
-    def paste(self, event: object = None) -> Sheet:
-        self.MT.ctrl_v(event)
-        return self
+    def paste(self, event: object = None, validation: bool = True) -> None | EventDataDict:
+        return self.MT.ctrl_v(event, validation)
 
-    def delete(self, event: object = None) -> Sheet:
-        self.MT.delete_key(event)
-        return self
+    def delete(self, event: object = None, validation: bool = True) -> None | EventDataDict:
+        return self.MT.delete_key(event, validation)
 
-    def undo(self, event: object = None) -> Sheet:
-        self.MT.undo(event)
-        return self
+    def undo(self, event: object = None) -> None | EventDataDict:
+        return self.MT.undo(event)
 
-    def redo(self, event: object = None) -> Sheet:
-        self.MT.redo(event)
-        return self
+    def redo(self, event: object = None) -> None | EventDataDict:
+        return self.MT.redo(event)
 
     def has_focus(
         self,
@@ -1801,7 +1795,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(ev_stack_dict(event_data))
+                self.MT.undo_stack.append(pickled_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)
@@ -1840,7 +1834,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(ev_stack_dict(event_data))
+                self.MT.undo_stack.append(pickled_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)
@@ -2009,7 +2003,7 @@ class Sheet(tk.Frame):
             push_ops=push_ops,
         )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2104,7 +2098,7 @@ class Sheet(tk.Frame):
             push_ops=push_ops,
         )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2178,7 +2172,7 @@ class Sheet(tk.Frame):
                 event_data,
             )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.MT.deselect("all", redraw=False)
@@ -2219,7 +2213,7 @@ class Sheet(tk.Frame):
                 event_data,
             )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.MT.deselect("all", redraw=False)
@@ -2320,7 +2314,7 @@ class Sheet(tk.Frame):
             data_indexes=data_indexes,
         )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2348,7 +2342,7 @@ class Sheet(tk.Frame):
             data_indexes=data_indexes,
         )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2375,7 +2369,7 @@ class Sheet(tk.Frame):
             data_indexes=data_indexes,
         )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -2402,7 +2396,7 @@ class Sheet(tk.Frame):
             data_indexes=data_indexes,
         )
         if undo:
-            self.MT.undo_stack.append(ev_stack_dict(event_data))
+            self.MT.undo_stack.append(pickled_event_dict(event_data))
         if emit_event:
             self.emit_event("<<SheetModified>>", event_data)
         self.set_refresh_timer(redraw)
@@ -3446,12 +3440,22 @@ class Sheet(tk.Frame):
 
     delete_row_position = del_row_position
 
+    def del_row_positions(self, idxs: Iterator[int] | None = None) -> Sheet:
+        self.MT.del_row_positions(idxs=idxs)
+        self.set_refresh_timer()
+        return self
+
     def del_column_position(self, idx: int, deselect_all: bool = False) -> Sheet:
         self.MT.del_col_position(idx, deselect_all=deselect_all)
         return self
 
     delete_column_position = del_column_position
 
+    def del_column_positions(self, idxs: Iterator[int] | None = None) -> Sheet:
+        self.MT.del_col_positions(idxs=idxs)
+        self.set_refresh_timer()
+        return self
+
     def insert_column_position(
         self,
         idx: Literal["end"] | int = "end",
@@ -4253,27 +4257,27 @@ class Sheet(tk.Frame):
             target = self.CH.cell_options
         if key is None:
             return target
-        return {k: v for k, v in target.items() if key in v}
+        return {k: v[key] for k, v in target.items() if key in v}
 
     def get_row_options(self, key: None | str = None) -> dict:
         if key is None:
             return self.MT.row_options
-        return {k: v for k, v in self.MT.row_options.items() if key in v}
+        return {k: v[key] for k, v in self.MT.row_options.items() if key in v}
 
     def get_column_options(self, key: None | str = None) -> dict:
         if key is None:
             return self.MT.col_options
-        return {k: v for k, v in self.MT.col_options.items() if key in v}
+        return {k: v[key] for k, v in self.MT.col_options.items() if key in v}
 
     def get_index_options(self, key: None | str = None) -> dict:
         if key is None:
             return self.RI.cell_options
-        return {k: v for k, v in self.RI.cell_options.items() if key in v}
+        return {k: v[key] for k, v in self.RI.cell_options.items() if key in v}
 
     def get_header_options(self, key: None | str = None) -> dict:
         if key is None:
             return self.CH.cell_options
-        return {k: v for k, v in self.CH.cell_options.items() if key in v}
+        return {k: v[key] for k, v in self.CH.cell_options.items() if key in v}
 
     def del_out_of_bounds_options(self) -> Sheet:
         maxc = self.total_columns()

{tksheet-7.1.12.dist-info → tksheet-7.1.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.1.12
+Version: 7.1.20
 Summary: Tkinter table / sheet widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors
@@ -42,7 +42,7 @@ License-File: LICENSE.txt
 
 # tksheet
 
-[![PyPI version shields.io](https://img.shields.io/pypi/v/tksheet.svg)](https://pypi.python.org/pypi/tksheet/) ![python](https://img.shields.io/badge/python-3.8+-blue) [![License: MIT](https://img.shields.io/badge/License-MIT%20-blue.svg)](https://github.com/ragardner/tksheet/blob/master/LICENSE.txt)
+[![PyPI version shields.io](https://img.shields.io/pypi/v/tksheet.svg)](https://pypi.python.org/pypi/tksheet/) ![python](https://img.shields.io/badge/python-3.8|3.9|3.10|3.11|3.12-blue) [![License: MIT](https://img.shields.io/badge/License-MIT%20-blue.svg)](https://github.com/ragardner/tksheet/blob/master/LICENSE.txt)
 
 [![GitHub Release Date](https://img.shields.io/github/release-date-pre/ragardner/tksheet.svg)](https://github.com/ragardner/tksheet/releases) [![Downloads](https://img.shields.io/pypi/dm/tksheet.svg)](https://pypi.org/project/tksheet/)
 

tksheet-7.1.20.dist-info/RECORD

@@ -0,0 +1,20 @@
+tksheet/__init__.py,sha256=n15iE0L6zsiYW5IhLE5m3yb867QM9gl2SBrdQk_bjLc,2044
+tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
+tksheet/column_headers.py,sha256=Kzu_nIMt3oFZO6F00iHBmjv5L0STsVN7Gc34wzwKDJ4,100785
+tksheet/formatters.py,sha256=DXif00aq9DgFpXwkbiqD86KxtDg0Meop51hLY-KcGNQ,10037
+tksheet/functions.py,sha256=Vm_tCPCaos8C_or_70OGpSrXKmFnE8OxODchfrUJBMM,40281
+tksheet/main_table.py,sha256=DrRC3WLGiS6JkAS4Ir-8c1n_4C4l4Coe6jb45Uceekc,320235
+tksheet/other_classes.py,sha256=P3FYUYreLhstATvHCNow8sDQoCsD_02KB6oXcca3ahE,13628
+tksheet/row_index.py,sha256=57cWphhUGsghh9UiHtAHi0m9S403-9MrYiMtTzK7h8E,106014
+tksheet/sheet.py,sha256=TLWV_C-C3XiweHbPdskCnT9v6Zr6Dxym2Ijv-CULgWs,260302
+tksheet/sheet_options.py,sha256=mh0rTvWrFvIKaiv88jtMZy0TSA8zTS1GXSe88u8_rzk,11978
+tksheet/text_editor.py,sha256=81_IZKrTVa2KIx2cJ4n3cFvFMAwvbHIQYgqtyat-97I,6681
+tksheet/themes.py,sha256=0XY97zB9e26edyxMWutofNarNon8Pp5lpprHYeL_4b0,13490
+tksheet/top_left_rectangle.py,sha256=-2u9GfOvcqhkKwHEtbqdFvXCY3RbvL5k2Sh9l3r_k04,8275
+tksheet/types.py,sha256=IgoEHMbceKpakcZtanxKaKJ4RdCq7UW6EoEIIz5O59k,340
+tksheet/vars.py,sha256=Nb0mhxJt-SXipi3cE9J9Ea1H1iPqC8PRvUR9CqqMlVA,3062
+tksheet-7.1.20.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
+tksheet-7.1.20.dist-info/METADATA,sha256=C_WIADFKe41LVlFXKzK7QFO6vQIi0ym2Uk40WiNx9zM,6032
+tksheet-7.1.20.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+tksheet-7.1.20.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
+tksheet-7.1.20.dist-info/RECORD,,

tksheet-7.1.12.dist-info/RECORD

@@ -1,20 +0,0 @@
-tksheet/__init__.py,sha256=NUxHKOZFQzf4A8eiKohXLDQe-9iyK2d4ZDzkDr4_GQk,2014
-tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
-tksheet/column_headers.py,sha256=eZKZGZEstg5HeCtvdVYmu5nqoY0bdxrwYScQvZz5xEQ,100496
-tksheet/formatters.py,sha256=DXif00aq9DgFpXwkbiqD86KxtDg0Meop51hLY-KcGNQ,10037
-tksheet/functions.py,sha256=1aI9sN-O0DOFITj0bOORzI9XQteThciCXhTr8GPHgkw,39616
-tksheet/main_table.py,sha256=z9Q8BjFqoGW88Cm1av7nR8fkYw-HxnOMVlBqgY3R1gU,318838
-tksheet/other_classes.py,sha256=P3FYUYreLhstATvHCNow8sDQoCsD_02KB6oXcca3ahE,13628
-tksheet/row_index.py,sha256=ytD1A6dmzzrM9EYm-IIJ0_xo-2XVfecKgYBG_Hxm_m8,105999
-tksheet/sheet.py,sha256=rc4BuXw9JxV3_Ja-fdBDEkE_1P6jNl8jhPs8MoGuw6E,259740
-tksheet/sheet_options.py,sha256=mh0rTvWrFvIKaiv88jtMZy0TSA8zTS1GXSe88u8_rzk,11978
-tksheet/text_editor.py,sha256=81_IZKrTVa2KIx2cJ4n3cFvFMAwvbHIQYgqtyat-97I,6681
-tksheet/themes.py,sha256=0XY97zB9e26edyxMWutofNarNon8Pp5lpprHYeL_4b0,13490
-tksheet/top_left_rectangle.py,sha256=-2u9GfOvcqhkKwHEtbqdFvXCY3RbvL5k2Sh9l3r_k04,8275
-tksheet/types.py,sha256=IgoEHMbceKpakcZtanxKaKJ4RdCq7UW6EoEIIz5O59k,340
-tksheet/vars.py,sha256=Nb0mhxJt-SXipi3cE9J9Ea1H1iPqC8PRvUR9CqqMlVA,3062
-tksheet-7.1.12.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
-tksheet-7.1.12.dist-info/METADATA,sha256=fWMZLYa3BI5udpVfd5vuyt-S7i17enOimu6FNwkKOlc,6014
-tksheet-7.1.12.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-tksheet-7.1.12.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
-tksheet-7.1.12.dist-info/RECORD,,