tksheet 7.4.20__tar.gz → 7.4.22__tar.gz

{tksheet-7.4.20/tksheet.egg-info → tksheet-7.4.22}/PKG-INFO

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

{tksheet-7.4.20 → tksheet-7.4.22}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "tksheet"
 description = "Tkinter table / sheet and treeview widget"
 readme = "README.md"
-version = "7.4.20"
+version = "7.4.22"
 authors = [{ name = "ragardner", email = "github@ragardner.simplelogin.com" }]
 requires-python = ">=3.8"
 license = {file = "LICENSE.txt"}

{tksheet-7.4.20 → tksheet-7.4.22}/tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.4.20"
+__version__ = "7.4.22"
 
 from .colors import (
     color_map,

{tksheet-7.4.20 → tksheet-7.4.22}/tksheet/functions.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import csv
 import io
-import pickle
 import re
 import tkinter as tk
 from bisect import bisect_left
@@ -17,7 +16,6 @@ from .constants import align_value_error, symbols_set
 from .formatters import to_bool
 from .other_classes import DotDict, EventDataDict, Highlight, Loc, Span
 
-unpickle_obj = pickle.loads
 lines_re = re.compile(r"[^\n]+")
 ORD_A = ord("A")
 

{tksheet-7.4.20 → tksheet-7.4.22}/tksheet/main_table.py

@@ -73,7 +73,6 @@ from .functions import (
     len_to_idx,
     mod_event_val,
     mod_span,
-    mod_span_widget,
     move_elements_by_mapping_gen,
     move_fast,
     new_tk_event,
@@ -83,7 +82,6 @@ from .functions import (
     span_idxs_post_move,
     stored_event_dict,
     try_binding,
-    unpickle_obj,
     wrap_text,
 )
 from .other_classes import (
@@ -1326,7 +1324,7 @@ class MainTable(tk.Canvas):
                             and self.input_valid_for_cell(r, datacn, val, ignore_empty=True)
                         )
                     ):
-                        rows[r][datacn] = val
+                        rows[r][datacn] = self.format_value(datarn, datacn, val)
                         ctr += 1
             if ctr:
                 event_data = self.add_rows(
@@ -1376,7 +1374,7 @@ class MainTable(tk.Canvas):
                             and self.input_valid_for_cell(datarn, c, val, ignore_empty=True)
                         )
                     ):
-                        columns[c][datarn] = val
+                        columns[c][datarn] = self.format_value(datarn, datacn, val)
                         ctr += 1
             if ctr:
                 event_data = self.add_columns(
@@ -1528,7 +1526,7 @@ class MainTable(tk.Canvas):
                 "displayed": {} if disp_new_idxs is None else disp_new_idxs,
             }
         event_data["options"] = self.copy_options()
-        event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
+        event_data["named_spans"] = {k: span.copy_self() for k, span in self.named_spans.items()}
 
         if move_widths and disp_new_idxs:
             self.set_col_positions(
@@ -1787,7 +1785,7 @@ class MainTable(tk.Canvas):
                 "displayed": {} if disp_new_idxs is None else disp_new_idxs,
             }
         event_data["options"] = self.copy_options()
-        event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
+        event_data["named_spans"] = {k: span.copy_self() for k, span in self.named_spans.items()}
 
         if move_data:
             maxidx = len_to_idx(totalrows)
@@ -2081,9 +2079,7 @@ class MainTable(tk.Canvas):
         if "tagged_columns" in modification["options"]:
             self.tagged_columns = modification["options"]["tagged_columns"]
         if modification["named_spans"]:
-            self.named_spans = {
-                k: mod_span_widget(unpickle_obj(v), self.PAR) for k, v in modification["named_spans"].items()
-            }
+            self.named_spans = modification["named_spans"]
         if modification["sheet_state"]:
             self.RI.tree_open_ids = modification["sheet_state"]["tree_open_ids"]
             self.row_positions = modification["sheet_state"]["row_positions"]
@@ -4792,7 +4788,7 @@ class MainTable(tk.Canvas):
         # if there are named spans where columns were added
         # add options to gap which was created by adding columns
         totalrows = None
-        new_ops = self.PAR.create_options_from_span
+        new_ops = partial(self.PAR.create_options_from_span, set_data=False)
         qkspan = self.span()
         for span in self.named_spans.values():
             if isinstance(span["from_c"], int):
@@ -4855,7 +4851,7 @@ class MainTable(tk.Canvas):
         # if there are named spans where rows were added
         # add options to gap which was created by adding rows
         totalcols = None
-        new_ops = self.PAR.create_options_from_span
+        new_ops = partial(self.PAR.create_options_from_span, set_data=False)
         qkspan = self.span()
         for span in self.named_spans.values():
             if isinstance(span["from_r"], int):
@@ -5123,7 +5119,7 @@ class MainTable(tk.Canvas):
                 )
         if isinstance(self._headers, list) and header:
             self._headers = insert_items(self._headers, header, self.CH.fix_header)
-        if push_ops:
+        if push_ops and columns:
             self.adjust_options_post_add_columns(
                 cols=tuple(columns),
                 create_ops=create_ops,
@@ -5245,7 +5241,7 @@ class MainTable(tk.Canvas):
                         repeat(default_width, maxcn + 1 - (len(self.col_positions) - 1)),
                     )
                 )
-        if push_ops:
+        if push_ops and rows:
             self.adjust_options_post_add_rows(
                 rows=tuple(rows),
                 create_ops=create_ops,
@@ -5374,11 +5370,16 @@ class MainTable(tk.Canvas):
                 for datacn, column in enumerate(columns, data_ins_col):
                     if column:
                         header_dict[datacn] = column[0]
-                        columns_dict[datacn] = dict(enumerate(islice(column, 1, None)))
+                        columns_dict[datacn] = {
+                            datarn: self.format_value(datarn, datacn, v)
+                            for datarn, v in enumerate(islice(column, 1, None))
+                        }
             else:
                 for datacn, column in enumerate(columns, data_ins_col):
                     if column:
-                        columns_dict[datacn] = dict(enumerate(column))
+                        columns_dict[datacn] = {
+                            datarn: self.format_value(datarn, datacn, v) for datarn, v in enumerate(column)
+                        }
 
         rng = range(displayed_ins_col, displayed_ins_col + len(columns_dict))
         if widths is None:
@@ -5418,12 +5419,12 @@ class MainTable(tk.Canvas):
                     if row:
                         index_dict[datarn] = row[0]
                     if len(row) > 1:
-                        rows_dict[datarn] = row[1:]
+                        rows_dict[datarn] = [self.format_value(datarn, datacn, v) for datacn, v in enumerate(row[1:])]
                     else:
                         rows_dict[datarn] = []
             else:
                 for datarn, row in enumerate(rows, data_ins_row):
-                    rows_dict[datarn] = row
+                    rows_dict[datarn] = [self.format_value(datarn, datacn, v) for datacn, v in enumerate(row)]
 
         rng = range(displayed_ins_row, displayed_ins_row + len(rows_dict))
         if heights is None:
@@ -5467,7 +5468,7 @@ class MainTable(tk.Canvas):
         if not event_data:
             event_data = self.new_event_dict("delete_columns", state=True)
         event_data["options"] = self.copy_options()
-        event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
+        event_data["named_spans"] = {k: span.copy_self() for k, span in self.named_spans.items()}
         for i, datacn in enumerate(cols):
             for rn in range(len(self.data)):
                 if datacn not in event_data["deleted"]["columns"]:
@@ -5557,7 +5558,7 @@ class MainTable(tk.Canvas):
         if not event_data:
             event_data = self.new_event_dict("delete_rows", state=True)
         event_data["options"] = self.copy_options()
-        event_data["named_spans"] = {k: span.pickle_self() for k, span in self.named_spans.items()}
+        event_data["named_spans"] = {k: span.copy_self() for k, span in self.named_spans.items()}
 
         for i, datarn in enumerate(rows):
             event_data["deleted"]["rows"][datarn] = self.data.pop(datarn - i)
@@ -5565,7 +5566,6 @@ class MainTable(tk.Canvas):
         if self.PAR.ops.treeview:
             event_data["deleted"]["index"] = {datarn: self._row_index[datarn] for datarn in rows}
             event_data = self.RI.tree_del_rows(event_data=event_data)
-
         elif isinstance(self._row_index, list):
             for i, datarn in enumerate(rows):
                 r = datarn - i
@@ -8000,6 +8000,17 @@ class MainTable(tk.Canvas):
                 else:
                     self.data[datarn][datacn] = value
 
+    def format_value(self, datarn: int, datacn: int, value: Any) -> Any:
+        if (datarn, datacn) in self.cell_options and "checkbox" in self.cell_options[(datarn, datacn)]:
+            return try_to_bool(value)
+        elif kwargs := self.get_cell_kwargs(datarn, datacn, key="format"):
+            if kwargs["formatter"] is None:
+                return format_data(value=value, **kwargs)
+            else:
+                return kwargs["formatter"](value, **kwargs)
+        else:
+            return value
+
     def get_value_for_empty_cell(self, datarn: int, datacn: int, r_ops: bool = True, c_ops: bool = True) -> Any:
         kwargs = self.get_cell_kwargs(
             datarn,
@@ -8014,7 +8025,7 @@ class MainTable(tk.Canvas):
         elif "dropdown" in kwargs and kwargs["dropdown"]["validate_input"] and kwargs["dropdown"]["values"]:
             return kwargs["dropdown"]["values"][0]
         else:
-            return ""
+            return self.format_value(datarn, datacn, "")
 
     def get_empty_row_seq(
         self, datarn: int, end: int, start: int = 0, r_ops: bool = True, c_ops: bool = True

{tksheet-7.4.20 → tksheet-7.4.22}/tksheet/other_classes.py

@@ -1,14 +1,11 @@
 from __future__ import annotations
 
-import pickle
+import copy
 import tkinter as tk
 from collections import namedtuple
 from collections.abc import Callable, Hashable, Iterator
-from functools import partial
 from typing import Any, Literal
 
-pickle_obj = partial(pickle.dumps, protocol=pickle.HIGHEST_PROTOCOL)
-
 FontTuple = namedtuple("FontTuple", "family size style")
 Box_nt = namedtuple(
     "Box_nt",
@@ -423,12 +420,45 @@ class Span(dict):
         cols = self.columns
         return Box_nt(rows.from_, cols.from_, rows.upto_, cols.upto_)
 
-    def pickle_self(self) -> bytes:
-        x = self["widget"]
-        self["widget"] = None
-        p = pickle_obj(self)
-        self["widget"] = x
-        return p
+    def copy_self(self) -> "Span":
+        # Create a new Span instance
+        span = Span()
+
+        # Iterate over all dictionary items to capture all attributes
+        for key, value in self.items():
+            if key == "widget":
+                # Tkinter widget: retain reference (do not copy)
+                span[key] = value
+            elif key == "kwargs":
+                # Handle kwargs, which may contain functions or lambdas
+                span[key] = {}
+                for k, v in value.items():
+                    if callable(v):
+                        # Functions/lambdas: shallow copy (immutable, but check for safety)
+                        span[key][k] = v
+                    else:
+                        try:
+                            # Deep copy non-callable items in kwargs
+                            span[key][k] = copy.deepcopy(v)
+                        except Exception:
+                            # Handle non-copyable objects (e.g., complex closures or objects)
+                            span[key][k] = v  # Fallback to shallow copy
+            elif key == "convert" and callable(value):
+                # Convert is a callable: shallow copy (immutable)
+                span[key] = value
+            else:
+                # Deep copy other values to handle nested objects like DotDict
+                try:
+                    span[key] = copy.deepcopy(value)
+                except Exception:
+                    # Fallback for non-copyable objects
+                    span[key] = value  # Shallow copy as fallback
+
+        # Ensure widget is set if not already present (edge case)
+        if "widget" not in span and hasattr(self, "widget"):
+            span["widget"] = self["widget"]
+
+        return span
 
     __setattr__ = __setitem__
     __getattr__ = __getitem__

{tksheet-7.4.20 → tksheet-7.4.22}/tksheet/sheet.py

@@ -954,8 +954,11 @@ class Sheet(tk.Frame):
         self.create_options_from_span(span)
         return span
 
-    def create_options_from_span(self, span: Span) -> Sheet:
-        getattr(self, span.type_)(span, **span.kwargs)
+    def create_options_from_span(self, span: Span, set_data: bool = True) -> Sheet:
+        if span.type_ == "format":
+            self.format(span, set_data=set_data, **span.kwargs)
+        else:
+            getattr(self, span.type_)(span, **span.kwargs)
         return self
 
     def del_named_span(self, name: str) -> Sheet:
@@ -1534,32 +1537,22 @@ class Sheet(tk.Frame):
                 event_data = set_h(startc, data, event_data)
         # add row/column lines (positions) if required
         if self.MT.all_columns_displayed and maxc >= (ncols := len(self.MT.col_positions) - 1):
-            _, _, widths = self.MT.get_args_for_add_columns(
-                data_ins_col=len(self.MT.col_positions) - 1,
-                displayed_ins_col=len(self.MT.col_positions) - 1,
-                columns=maxc + 1 - ncols,
-                widths=None,
-                headers=False,
-            )
+            disp_ins_col, widths_n_cols = len(self.MT.col_positions) - 1, maxc + 1 - ncols
+            w = self.ops.default_column_width
             event_data = self.MT.add_columns(
                 columns={},
                 header={},
-                column_widths=widths,
+                column_widths=dict(zip(range(disp_ins_col, disp_ins_col + widths_n_cols), repeat(w))),
                 event_data=event_data,
                 create_selections=False,
             )
         if self.MT.all_rows_displayed and maxr >= (nrows := len(self.MT.row_positions) - 1):
-            _, _, heights = self.MT.get_args_for_add_rows(
-                data_ins_row=len(self.MT.row_positions) - 1,
-                displayed_ins_row=len(self.MT.row_positions) - 1,
-                rows=maxr + 1 - nrows,
-                heights=None,
-                row_index=False,
-            )
+            disp_ins_row, heights_n_rows = len(self.MT.row_positions) - 1, maxr + 1 - nrows
+            h = self.MT.get_default_row_height()
             event_data = self.MT.add_rows(
                 rows={},
                 index={},
-                row_heights=heights,
+                row_heights=dict(zip(range(disp_ins_row, disp_ins_row + heights_n_rows), repeat(h))),
                 event_data=event_data,
                 create_selections=False,
             )
@@ -2580,6 +2573,7 @@ class Sheet(tk.Frame):
         formatter_options: dict | None = None,
         formatter_class: Any = None,
         redraw: bool = True,
+        set_data: bool = True,
         **kwargs,
     ) -> Span:
         if formatter_options is None:
@@ -2592,36 +2586,39 @@ class Sheet(tk.Frame):
                 for c in cols:
                     self.del_cell_options_checkbox(r, c)
                     add_to_options(self.MT.cell_options, (r, c), "format", kwargs)
-                    self.MT.set_cell_data(
-                        r,
-                        c,
-                        value=kwargs["value"] if "value" in kwargs else self.MT.get_cell_data(r, c),
-                        kwargs=kwargs,
-                    )
+                    if set_data:
+                        self.MT.set_cell_data(
+                            r,
+                            c,
+                            value=kwargs["value"] if "value" in kwargs else self.MT.get_cell_data(r, c),
+                            kwargs=kwargs,
+                        )
         elif span.kind == "row":
             for r in rows:
                 self.del_row_options_checkbox(r)
                 kwargs = fix_format_kwargs(kwargs)
                 add_to_options(self.MT.row_options, r, "format", kwargs)
-                for c in cols:
-                    self.MT.set_cell_data(
-                        r,
-                        c,
-                        value=kwargs["value"] if "value" in kwargs else self.MT.get_cell_data(r, c),
-                        kwargs=kwargs,
-                    )
+                if set_data:
+                    for c in cols:
+                        self.MT.set_cell_data(
+                            r,
+                            c,
+                            value=kwargs["value"] if "value" in kwargs else self.MT.get_cell_data(r, c),
+                            kwargs=kwargs,
+                        )
         elif span.kind == "column":
             for c in cols:
                 self.del_column_options_checkbox(c)
                 kwargs = fix_format_kwargs(kwargs)
                 add_to_options(self.MT.col_options, c, "format", kwargs)
-                for r in rows:
-                    self.MT.set_cell_data(
-                        r,
-                        c,
-                        value=kwargs["value"] if "value" in kwargs else self.MT.get_cell_data(r, c),
-                        kwargs=kwargs,
-                    )
+                if set_data:
+                    for r in rows:
+                        self.MT.set_cell_data(
+                            r,
+                            c,
+                            value=kwargs["value"] if "value" in kwargs else self.MT.get_cell_data(r, c),
+                            kwargs=kwargs,
+                        )
         self.set_refresh_timer(redraw)
         return span
 

{tksheet-7.4.20 → tksheet-7.4.22}/tksheet/top_left_rectangle.py

@@ -4,6 +4,7 @@ import tkinter as tk
 from typing import Any
 
 from .constants import rc_binding
+from .functions import try_binding
 
 
 class TopLeftRectangle(tk.Canvas):
@@ -198,10 +199,8 @@ class TopLeftRectangle(tk.Canvas):
         )
         self.coords(self.select_all_box, 0, 0, w - 5, h - 5)
 
-    def mouse_motion(self, event: Any = None) -> None:
-        self.MT.reset_mouse_motion_creations()
-        if self.extra_motion_func is not None:
-            self.extra_motion_func(event)
+    def mouse_motion(self, event: Any) -> None:
+        try_binding(self.extra_motion_func, event)
 
     def b1_press(self, event: Any = None) -> None:
         self.focus_set()

{tksheet-7.4.20 → tksheet-7.4.22/tksheet.egg-info}/PKG-INFO

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