tksheet 7.1.1__tar.gz → 7.1.3__tar.gz

{tksheet-7.1.1/tksheet.egg-info → tksheet-7.1.3}/PKG-INFO

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

{tksheet-7.1.1 → tksheet-7.1.3}/pyproject.toml

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

{tksheet-7.1.1 → tksheet-7.1.3}/tksheet/__init__.py

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

{tksheet-7.1.1 → tksheet-7.1.3}/tksheet/functions.py

@@ -628,6 +628,7 @@ def span_dict(
     ndim: int | None = None,
     convert: Callable | None = None,
     undo: bool = False,
+    emit_event: bool = False,
     widget: object = None,
 ) -> Span:
     d: Span = Span(
@@ -648,6 +649,7 @@ def span_dict(
         ndim=ndim,
         convert=convert,
         undo=undo,
+        emit_event=emit_event,
         widget=widget,
     )
     return d

{tksheet-7.1.1 → tksheet-7.1.3}/tksheet/main_table.py

@@ -1099,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,
@@ -1329,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,
@@ -2724,42 +2699,22 @@ class MainTable(tk.Canvas):
         self.mouseclick_outside_editor_or_dropdown_all_canvases()
         self.focus_set()
         popup_menu = None
-        if self.single_selection_enabled and self.not_currently_resizing():
-            r = self.identify_row(y=event.y)
-            c = self.identify_col(x=event.x)
-            if r < len(self.row_positions) - 1 and c < len(self.col_positions) - 1:
-                if self.col_selected(c):
-                    if self.rc_popup_menus_enabled:
-                        popup_menu = self.CH.ch_rc_popup_menu
-                elif self.row_selected(r):
-                    if self.rc_popup_menus_enabled:
-                        popup_menu = self.RI.ri_rc_popup_menu
-                elif self.cell_selected(r, c):
-                    if self.rc_popup_menus_enabled:
-                        popup_menu = self.rc_popup_menu
-                else:
-                    if self.rc_select_enabled:
-                        self.select_cell(r, c, redraw=True)
-                    if self.rc_popup_menus_enabled:
-                        popup_menu = self.rc_popup_menu
-            else:
-                popup_menu = self.empty_rc_popup_menu
-        elif self.toggle_selection_enabled and self.not_currently_resizing():
+        if (self.single_selection_enabled or self.toggle_selection_enabled) and self.not_currently_resizing():
             r = self.identify_row(y=event.y)
             c = self.identify_col(x=event.x)
             if r < len(self.row_positions) - 1 and c < len(self.col_positions) - 1:
-                if self.col_selected(c):
-                    if self.rc_popup_menus_enabled:
-                        popup_menu = self.CH.ch_rc_popup_menu
-                elif self.row_selected(r):
-                    if self.rc_popup_menus_enabled:
-                        popup_menu = self.RI.ri_rc_popup_menu
-                elif self.cell_selected(r, c):
-                    if self.rc_popup_menus_enabled:
-                        popup_menu = self.rc_popup_menu
+                if self.col_selected(c) and self.rc_popup_menus_enabled:
+                    popup_menu = self.CH.ch_rc_popup_menu
+                elif self.row_selected(r) and self.rc_popup_menus_enabled:
+                    popup_menu = self.RI.ri_rc_popup_menu
+                elif self.cell_selected(r, c) and self.rc_popup_menus_enabled:
+                    popup_menu = self.rc_popup_menu
                 else:
                     if self.rc_select_enabled:
-                        self.toggle_select_cell(r, c, redraw=True)
+                        if self.single_selection_enabled:
+                            self.select_cell(r, c, redraw=True)
+                        elif self.toggle_selection_enabled:
+                            self.toggle_select_cell(r, c, redraw=True)
                     if self.rc_popup_menus_enabled:
                         popup_menu = self.rc_popup_menu
             else:
@@ -3982,7 +3937,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(
@@ -6261,7 +6216,7 @@ class MainTable(tk.Canvas):
         return tuple(box.coords for item, box in self.get_selection_items())
 
     def get_all_selection_boxes_with_types(self) -> list[tuple[tuple[int, int, int, int], str]]:
-        return [(box.coords, box.type) for item, box in self.get_selection_items()]
+        return [(box.coords, box.type_) for item, box in self.get_selection_items()]
 
     def all_selected(self) -> bool:
         return any(
@@ -6293,7 +6248,7 @@ class MainTable(tk.Canvas):
             box.coords.from_c <= c and box.coords.upto_c > c
             for item, box in self.get_selection_items(
                 cells=False,
-                columns=False,
+                rows=False,
             )
         )
 

{tksheet-7.1.1 → tksheet-7.1.3}/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.1 → tksheet-7.1.3}/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,62 @@ 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,
+        )
+        if open_ids:
+            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 unpack(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 unpack(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,12 +4517,15 @@ 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):
-            if not (iid := iid.lower()):
-                raise ValueError(f"iid '{iid}' does not exist.")
             if iid in self.RI.tree:
                 raise ValueError(f"Cannot rename '{iid}', it already exists.")
             iid = iid.lower()
@@ -4477,36 +4537,46 @@ class Sheet(tk.Frame):
         if isinstance(text, str):
             self.RI.tree[item].text = text
         if isinstance(values, list):
-            self.set_data(self.RI.tree_rns[item], values)
+            self.set_data(self.RI.tree_rns[item], data=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()]
+        try:
+            return self.RI.tree_rns[item.lower()]
+        except Exception:
+            raise ValueError(f"item '{item.lower()}' does not exist.")
 
-    def rowitem(self, row: int) -> str | None:
-        if len(self.MT._row_index) > row:
+    def rowitem(self, row: int, data_index: bool = False) -> str | None:
+        if not data_index:
+            row = self.data_r(row)
+        if isinstance(row, int) and len(self.MT._row_index) > row:
             return self.MT._row_index[row].iid
         return None
 
@@ -4522,11 +4592,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
@@ -4736,7 +4801,7 @@ class Sheet(tk.Frame):
     def selection_add(self, *items) -> Sheet:
         for item in unpack(items):
             if (item := item.lower()) not in self.RI.tree:
-                raise ValueError(f"Item '{item}' does not exist.")
+                continue
             if not self.item_displayed(item):
                 self.display_item(item)
             self.add_row_selection(bisect_left(self.MT.displayed_rows, self.RI.tree_rns[item]))
@@ -4745,7 +4810,7 @@ class Sheet(tk.Frame):
     def selection_remove(self, *items) -> Sheet:
         for item in unpack(items):
             if (item := item.lower()) not in self.RI.tree:
-                raise ValueError(f"Item '{item}' does not exist.")
+                continue
             try:
                 self.deselect(bisect_left(self.MT.displayed_rows, self.RI.tree_rns[item]))
             except Exception:

{tksheet-7.1.1 → tksheet-7.1.3/tksheet.egg-info}/PKG-INFO

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