tksheet 7.1.0__tar.gz → 7.1.2__tar.gz

{tksheet-7.1.0/tksheet.egg-info → tksheet-7.1.2}/PKG-INFO

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

{tksheet-7.1.0 → tksheet-7.1.2}/pyproject.toml

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

{tksheet-7.1.0 → tksheet-7.1.2}/tksheet/__init__.py

@@ -1,96 +1,96 @@
-# ruff: noqa: F401
-
-"""
-tksheet - A Python tkinter table widget
-"""
-
-__version__ = "7.1.0"
-
-from .colors import (
-    color_map,
-)
-from .column_headers import ColumnHeaders
-from .formatters import (
-    Formatter,
-    bool_formatter,
-    data_to_str,
-    float_formatter,
-    float_to_str,
-    format_data,
-    formatter,
-    get_clipboard_data,
-    get_data_with_valid_check,
-    int_formatter,
-    is_bool_like,
-    is_none_like,
-    percentage_formatter,
-    percentage_to_str,
-    to_bool,
-    to_float,
-    to_int,
-    to_str,
-    try_to_bool,
-)
-from .functions import (
-    alpha2idx,
-    alpha2num,
-    consecutive_chunks,
-    data_to_displayed_idxs,
-    displayed_to_data_idxs,
-    dropdown_search_function,
-    event_dict,
-    get_checkbox_dict,
-    get_checkbox_kwargs,
-    get_checkbox_points,
-    get_dropdown_dict,
-    get_dropdown_kwargs,
-    get_index_of_gap_in_sorted_integer_seq_forward,
-    get_index_of_gap_in_sorted_integer_seq_reverse,
-    get_n2a,
-    get_new_indexes,
-    get_seq_without_gaps_at_index,
-    is_iterable,
-    move_elements_by_mapping,
-    move_elements_to,
-    num2alpha,
-    span_dict,
-    tksheet_type_error,
-)
-from .main_table import MainTable
-from .other_classes import (
-    DotDict,
-    DraggedRowColumn,
-    DrawnItem,
-    EventDataDict,
-    GeneratedMouseEvent,
-    Selected,
-    Span,
-    SpanRange,
-    TextCfg,
-)
-from .row_index import RowIndex
-from .sheet import Dropdown, Sheet
-from .sheet_options import new_sheet_options
-from .text_editor import (
-    TextEditor,
-    TextEditorTkText,
-)
-from .themes import (
-    theme_black,
-    theme_dark,
-    theme_dark_blue,
-    theme_dark_green,
-    theme_light_blue,
-    theme_light_green,
-)
-from .top_left_rectangle import TopLeftRectangle
-from .vars import (
-    USER_OS,
-    ctrl_key,
-    emitted_events,
-    falsy,
-    nonelike,
-    rc_binding,
-    symbols_set,
-    truthy,
-)
+# ruff: noqa: F401
+
+"""
+tksheet - A Python tkinter table widget
+"""
+
+__version__ = "7.1.2"
+
+from .colors import (
+    color_map,
+)
+from .column_headers import ColumnHeaders
+from .formatters import (
+    Formatter,
+    bool_formatter,
+    data_to_str,
+    float_formatter,
+    float_to_str,
+    format_data,
+    formatter,
+    get_clipboard_data,
+    get_data_with_valid_check,
+    int_formatter,
+    is_bool_like,
+    is_none_like,
+    percentage_formatter,
+    percentage_to_str,
+    to_bool,
+    to_float,
+    to_int,
+    to_str,
+    try_to_bool,
+)
+from .functions import (
+    alpha2idx,
+    alpha2num,
+    consecutive_chunks,
+    data_to_displayed_idxs,
+    displayed_to_data_idxs,
+    dropdown_search_function,
+    event_dict,
+    get_checkbox_dict,
+    get_checkbox_kwargs,
+    get_checkbox_points,
+    get_dropdown_dict,
+    get_dropdown_kwargs,
+    get_index_of_gap_in_sorted_integer_seq_forward,
+    get_index_of_gap_in_sorted_integer_seq_reverse,
+    get_n2a,
+    get_new_indexes,
+    get_seq_without_gaps_at_index,
+    is_iterable,
+    move_elements_by_mapping,
+    move_elements_to,
+    num2alpha,
+    span_dict,
+    tksheet_type_error,
+)
+from .main_table import MainTable
+from .other_classes import (
+    DotDict,
+    DraggedRowColumn,
+    DrawnItem,
+    EventDataDict,
+    GeneratedMouseEvent,
+    Selected,
+    Span,
+    SpanRange,
+    TextCfg,
+)
+from .row_index import RowIndex
+from .sheet import Dropdown, Sheet
+from .sheet_options import new_sheet_options
+from .text_editor import (
+    TextEditor,
+    TextEditorTkText,
+)
+from .themes import (
+    theme_black,
+    theme_dark,
+    theme_dark_blue,
+    theme_dark_green,
+    theme_light_blue,
+    theme_light_green,
+)
+from .top_left_rectangle import TopLeftRectangle
+from .vars import (
+    USER_OS,
+    ctrl_key,
+    emitted_events,
+    falsy,
+    nonelike,
+    rc_binding,
+    symbols_set,
+    truthy,
+)

{tksheet-7.1.0 → tksheet-7.1.2}/tksheet/functions.py

@@ -1254,6 +1254,11 @@ def mod_span(
     return to_set_to
 
 
+def mod_span_widget(span: Span, widget: object) -> Span:
+    span.widget = widget
+    return span
+
+
 def mod_event_val(
     event_data: EventDataDict,
     val: object,

{tksheet-7.1.0 → tksheet-7.1.2}/tksheet/main_table.py

@@ -69,6 +69,7 @@ from .functions import (
     move_elements_by_mapping,
     pickle_obj,
     span_idxs_post_move,
+    mod_span_widget,
     try_binding,
     unpickle_obj,
 )
@@ -1098,29 +1099,16 @@ class MainTable(tk.Canvas):
     def get_max_column_idx(self, maxidx: int | None = None) -> int:
         if maxidx is None:
             maxidx = len_to_idx(self.total_data_cols())
-        # max column number in cell_options
-        if maxidx < (maxk := max(self.cell_options, key=itemgetter(1), default=(0, 0))[1]):
-            maxidx = maxk
-        # max column number in column_options, index cell options
-        for d in (self.col_options, self.CH.cell_options):
-            if maxidx < (maxk := max(d, default=0)):
-                maxidx = maxk
-        # max column number in named spans
-        if maxidx < (
-            maxk := max(
-                (d["from_c"] for d in self.named_spans.values() if isinstance(d["from_c"], int)),
-                default=0,
-            )
-        ):
-            maxidx = maxk
-        if maxidx < (
-            maxk := max(
-                (d["upto_c"] for d in self.named_spans.values() if isinstance(d["upto_c"], int)),
-                default=0,
-            )
-        ):
-            maxidx = maxk
-        return maxidx
+        maxiget = partial(max, key=itemgetter(1))
+        return max(
+            max(self.cell_options, key=itemgetter(1), default=(0, maxidx))[1],
+            max(self.col_options, default=maxidx),
+            max(self.CH.cell_options, default=maxidx),
+            maxiget(map(maxiget, self.tagged_cells.values()), default=(0, maxidx))[1],
+            max(map(max, self.tagged_columns.values()), default=maxidx),
+            max((d.from_c for d in self.named_spans.values() if isinstance(d.from_c, int)), default=maxidx),
+            max((d.upto_c for d in self.named_spans.values() if isinstance(d.upto_c, int)), default=maxidx),
+        )
 
     def get_args_for_move_rows(
         self,
@@ -1328,28 +1316,16 @@ class MainTable(tk.Canvas):
     def get_max_row_idx(self, maxidx: int | None = None) -> int:
         if maxidx is None:
             maxidx = len_to_idx(self.total_data_rows())
-        if maxidx < (maxk := max(self.cell_options, key=itemgetter(0), default=(0, 0))[0]):
-            maxidx = maxk
-        # max row number in row_options, index cell options
-        for d in (self.row_options, self.RI.cell_options):
-            if maxidx < (maxk := max(d, default=0)):
-                maxidx = maxk
-        # max row number in named spans
-        if maxidx < (
-            maxk := max(
-                (d["from_r"] for d in self.named_spans.values() if isinstance(d["from_r"], int)),
-                default=0,
-            )
-        ):
-            maxidx = maxk
-        if maxidx < (
-            maxk := max(
-                (d["upto_r"] for d in self.named_spans.values() if isinstance(d["upto_r"], int)),
-                default=0,
-            )
-        ):
-            maxidx = maxk
-        return maxidx
+        maxiget = partial(max, key=itemgetter(0))
+        return max(
+            max(self.cell_options, key=itemgetter(0), default=(maxidx, 0))[0],
+            max(self.row_options, default=maxidx),
+            max(self.RI.cell_options, default=maxidx),
+            maxiget(map(maxiget, self.tagged_cells.values()), default=(maxidx, 0))[0],
+            max(map(max, self.tagged_rows.values()), default=maxidx),
+            max((d.from_r for d in self.named_spans.values() if isinstance(d.from_r, int)), default=maxidx),
+            max((d.upto_r for d in self.named_spans.values() if isinstance(d.upto_r, int)), default=maxidx),
+        )
 
     def get_full_new_idxs(
         self,
@@ -1434,7 +1410,15 @@ class MainTable(tk.Canvas):
             self.CH.cell_options = modification["options"]["CH_cell_options"]
         if "RI_cell_options" in modification["options"]:
             self.RI.cell_options = modification["options"]["RI_cell_options"]
-        self.named_spans = {k: unpickle_obj(v) for k, v in modification["named_spans"].items()}
+        if "tagged_cells" in modification["options"]:
+            self.tagged_cells = modification["options"]["tagged_cells"]
+        if "tagged_rows" in modification["options"]:
+            self.tagged_rows = modification["options"]["tagged_rows"]
+        if "tagged_columns" in modification["options"]:
+            self.tagged_columns = modification["options"]["tagged_columns"]
+        self.named_spans = {
+            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:
         self.deselect("all", redraw=False)
@@ -1709,7 +1693,7 @@ class MainTable(tk.Canvas):
         return False
 
     def select_all(self, redraw: bool = True, run_binding_func: bool = True) -> None:
-        iid, r, c = self.selected.iid, self.selected.row, self.selected.column
+        selected = self.selected
         self.deselect("all", redraw=False)
         if len(self.row_positions) > 1 and len(self.col_positions) > 1:
             item = self.create_selection_box(
@@ -1719,8 +1703,8 @@ class MainTable(tk.Canvas):
                 len(self.col_positions) - 1,
                 set_current=False,
             )
-            if iid:
-                self.set_currently_selected(r, c, item=item)
+            if selected:
+                self.set_currently_selected(selected.row, selected.column, item=item)
             else:
                 self.set_currently_selected(0, 0, item=item)
             if redraw:
@@ -3973,7 +3957,7 @@ class MainTable(tk.Canvas):
                         # if to_add then it's an undo/redo and don't
                         # need to create fresh options
                         if create_ops:
-                            # if rows are none it's a row options span
+                            # if cols are none it's a row options span
                             if span["from_c"] is None:
                                 new_ops(
                                     mod_span(
@@ -4531,6 +4515,9 @@ class MainTable(tk.Canvas):
                 "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,
             }
         )
 
@@ -6252,10 +6239,10 @@ class MainTable(tk.Canvas):
         return [(box.coords, box.type) for item, box in self.get_selection_items()]
 
     def all_selected(self) -> bool:
-        for r1, c1, r2, c2 in self.get_all_selection_boxes():
-            if not r1 and not c1 and r2 == len(self.row_positions) - 1 and c2 == len(self.col_positions) - 1:
-                return True
-        return False
+        return any(
+            not r1 and not c1 and r2 == len(self.row_positions) - 1 and c2 == len(self.col_positions) - 1
+            for r1, c1, r2, c2 in self.get_all_selection_boxes()
+        )
 
     def cell_selected(
         self,
@@ -6264,31 +6251,35 @@ class MainTable(tk.Canvas):
         inc_cols: bool = False,
         inc_rows: bool = False,
     ) -> bool:
-        if not isinstance(r, int) or not isinstance(c, int):
-            return False
-        for item, box in self.get_selection_items(rows=inc_rows, columns=inc_cols):
-            r1, c1, r2, c2 = box.coords
-            if r1 <= r and c1 <= c and r2 > r and c2 > c:
-                return True
-        return False
+        return (
+            isinstance(r, int)
+            and isinstance(c, int)
+            and any(
+                box.coords.from_r <= r and box.coords.upto_r > r and box.coords.from_c <= c and box.coords.upto_c > c
+                for item, box in self.get_selection_items(
+                    rows=inc_rows,
+                    columns=inc_cols,
+                )
+            )
+        )
 
     def col_selected(self, c: int) -> bool:
-        if not isinstance(c, int):
-            return False
-        for item, box in self.get_selection_items(cells=False, rows=False):
-            r1, c1, r2, c2 = box.coords
-            if c1 <= c and c2 > c:
-                return True
-        return False
+        return isinstance(c, int) and any(
+            box.coords.from_c <= c and box.coords.upto_c > c
+            for item, box in self.get_selection_items(
+                cells=False,
+                rows=False,
+            )
+        )
 
     def row_selected(self, r: int) -> bool:
-        if not isinstance(r, int):
-            return False
-        for item, box in self.get_selection_items(cells=False, columns=False):
-            r1, c1, r2, c2 = box.coords
-            if r1 <= r and r2 > r:
-                return True
-        return False
+        return isinstance(r, int) and any(
+            box.coords.from_r <= r and box.coords.upto_r > r
+            for item, box in self.get_selection_items(
+                cells=False,
+                columns=False,
+            )
+        )
 
     def anything_selected(
         self,

{tksheet-7.1.0 → tksheet-7.1.2}/tksheet/row_index.py

@@ -129,7 +129,7 @@ class RowIndex(tk.Canvas):
         self.align = kwargs["row_index_align"]
         self.default_index = kwargs["default_row_index"].lower()
 
-        self.reset_tree()
+        self.tree_reset()
         self.basic_bindings()
 
     def basic_bindings(self, enable: bool = True) -> None:
@@ -148,7 +148,7 @@ class RowIndex(tk.Canvas):
             self.unbind("<Double-Button-1>")
             self.unbind(rc_binding)
 
-    def reset_tree(self) -> None:
+    def tree_reset(self) -> None:
         # treeview mode
         self.tree = {}
         self.tree_open_ids = set()

{tksheet-7.1.0 → tksheet-7.1.2}/tksheet/sheet.py

@@ -1476,7 +1476,7 @@ class Sheet(tk.Frame):
         if sheet_options:
             self.ops = new_sheet_options()
         if tree:
-            self.RI.reset_tree()
+            self.RI.tree_reset()
         self.set_refresh_timer(redraw)
         return self
 
@@ -2998,9 +2998,10 @@ class Sheet(tk.Frame):
 
     def get_selected_min_max(
         self,
-    ) -> (
-        tuple[int, int, int, int] | tuple[None, None, None, None]
-    ):  # returns (min_y, min_x, max_y, max_x) of any selections including rows/columns
+    ) -> tuple[int, int, int, int] | tuple[None, None, None, None]:
+        """
+        Returns (min_y, min_x, max_y, max_x) of all selection boxes
+        """
         return self.MT.get_selected_min_max()
 
     # Modifying Selected Cells
@@ -3286,12 +3287,12 @@ class Sheet(tk.Frame):
 
     def get_column_widths(self, canvas_positions: bool = False) -> list[float]:
         if canvas_positions:
-            return [int(n) for n in self.MT.col_positions]
+            return self.MT.col_positions
         return self.MT.get_column_widths()
 
     def get_row_heights(self, canvas_positions: bool = False) -> list[float]:
         if canvas_positions:
-            return [int(n) for n in self.MT.row_positions]
+            return self.MT.row_positions
         return self.MT.get_row_heights()
 
     def set_column_widths(
@@ -4391,6 +4392,61 @@ class Sheet(tk.Frame):
         )
         return self
 
+    def tree_reset(self) -> Sheet:
+        self.deselect()
+        self.RI.tree_reset()
+        return self
+
+    def tree_get_open(self) -> set[str]:
+        """
+        Returns the set[str] of iids that are open in the treeview
+        """
+        return self.RI.tree_open_ids
+
+    def tree_set_open(self, open_ids: set[str]) -> Sheet:
+        """
+        Accepts set[str] of iids that are open in the treeview
+        Closes everything else
+        """
+        self.RI.tree_open_ids = open_ids
+        self.hide_rows(
+            set(self.MT.displayed_rows),
+            redraw=False,
+            deselect_all=False,
+            data_indexes=True,
+        )
+        self.show_rows(
+            (self.RI.tree_rns[iid] for iid in self.get_children("")),
+            redraw=False,
+            deselect_all=True,
+        )
+        self.tree_open(*open_ids)
+        return self
+
+    def tree_open(self, *items) -> Sheet:
+        """
+        If used without args all items are opened
+        """
+        if items:
+            for item in items:
+                self.item(item, open_=True)
+        else:
+            for item in self.get_children():
+                self.item(item, open_=True)
+        return self
+
+    def tree_close(self, *items) -> Sheet:
+        """
+        If used without args all items are closed
+        """
+        if items:
+            for item in items:
+                self.item(item, open_=False)
+        else:
+            for item in self.get_children():
+                self.item(item, open_=False)
+        return self
+
     def insert(
         self,
         parent: str = "",
@@ -4460,7 +4516,12 @@ class Sheet(tk.Frame):
         text: str | None = None,
         values: list | None = None,
         open_: bool | None = None,
-    ) -> DotDict:
+    ) -> DotDict | Sheet:
+        """
+        Modify options for item
+        If no options are set then returns DotDict of options for item
+        Else returns Sheet
+        """
         if not (item := item.lower()) or item not in self.RI.tree:
             raise ValueError(f"Item '{item}' does not exist.")
         if isinstance(iid, str):
@@ -4479,28 +4540,33 @@ class Sheet(tk.Frame):
         if isinstance(values, list):
             self.set_data(self.RI.tree_rns[item], values)
         if isinstance(open_, bool):
-            if not self.RI.tree[item].children or not open_:
+            if self.RI.tree[item].children:
+                if open_:
+                    self.RI.tree_open_ids.add(item)
+                    self.show_rows(
+                        (self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True)),
+                        redraw=False,
+                        deselect_all=False,
+                    )
+                else:
+                    self.RI.tree_open_ids.discard(item)
+                    self.hide_rows(
+                        (self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item)),
+                        redraw=False,
+                        deselect_all=False,
+                        data_indexes=True,
+                    )
+            else:
                 self.RI.tree_open_ids.discard(item)
-            if open_:
-                self.RI.tree_open_ids.add(item)
-                self.show_rows(
-                    (self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True)),
-                    redraw=False,
-                    deselect_all=False,
-                )
-            elif self.RI.tree[item].children:
-                self.hide_rows(
-                    (self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item)),
-                    redraw=False,
-                    deselect_all=False,
-                    data_indexes=True,
-                )
-        self.set_refresh_timer(isinstance(text, str) or isinstance(values, list) or isinstance(open_, bool))
-        return DotDict(
-            text=self.RI.tree[item].text,
-            values=self[self.RI.tree_rns[item]].options(ndim=1).data,
-            open_=item in self.RI.tree_open_ids,
-        )
+        get = not (isinstance(iid, str) or isinstance(text, str) or isinstance(values, list) or isinstance(open_, bool))
+        self.set_refresh_timer(redraw=not get)
+        if get:
+            return DotDict(
+                text=self.RI.tree[item].text,
+                values=self[self.RI.tree_rns[item]].options(ndim=1).data,
+                open_=item in self.RI.tree_open_ids,
+            )
+        return self
 
     def itemrow(self, item: str) -> int:
         return self.RI.tree_rns[item.lower()]
@@ -4522,11 +4588,6 @@ class Sheet(tk.Frame):
         else:
             yield from (n.iid for n in self.RI.tree[item].children)
 
-    def reset_tree(self) -> Sheet:
-        self.deselect()
-        self.RI.reset_tree()
-        return self
-
     def del_items(self, *items) -> Sheet:
         """
         Also deletes all descendants of items

{tksheet-7.1.0 → tksheet-7.1.2/tksheet.egg-info}/PKG-INFO

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