tksheet 6.1.7__tar.gz → 6.1.9__tar.gz

{tksheet-6.1.7/tksheet.egg-info → tksheet-6.1.9}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 6.1.7
+Version: 6.1.9
 Summary: Tkinter table / sheet widget
 Home-page: https://github.com/ragardner/tksheet
-Download-URL: https://github.com/ragardner/tksheet/archive/6.1.7.tar.gz
+Download-URL: https://github.com/ragardner/tksheet/archive/6.1.9.tar.gz
 Author: ragardner
 Author-email: github@ragardner.simplelogin.com
 License: MIT

{tksheet-6.1.7 → tksheet-6.1.9}/setup.py

@@ -8,7 +8,7 @@ with open(path.join(this_directory, 'README.md'), encoding = 'utf-8') as f:
 setup(
   name = 'tksheet',
   packages = ['tksheet'],
-  version = '6.1.7',
+  version = '6.1.9',
   python_requires = '>=3.6',
   license = 'MIT',
   description = 'Tkinter table / sheet widget',
@@ -17,7 +17,7 @@ setup(
   author = 'ragardner',
   author_email = 'github@ragardner.simplelogin.com',
   url = 'https://github.com/ragardner/tksheet',
-  download_url = 'https://github.com/ragardner/tksheet/archive/6.1.7.tar.gz',
+  download_url = 'https://github.com/ragardner/tksheet/archive/6.1.9.tar.gz',
   keywords = ['tkinter', 'table', 'widget', 'sheet', 'grid', 'tk'],
   install_requires = [],
   classifiers = [

{tksheet-6.1.7 → tksheet-6.1.9}/tksheet/_tksheet.py

@@ -86,6 +86,8 @@ class Sheet(tk.Frame):
         after_redraw_time_ms: int = 20,
         row_index_width: int = None,
         auto_resize_default_row_index: bool = True,
+        auto_resize_columns: Union[int, None] = None,
+        auto_resize_rows: Union[int, None] = None,
         set_all_heights_and_widths: bool = False,
         row_height: str = "1",  # str or int
         font: tuple = get_font(),
@@ -248,6 +250,8 @@ class Sheet(tk.Frame):
             headers=headers,
             header=header,
             data_reference=data if data_reference is None else data_reference,
+            auto_resize_columns=auto_resize_columns,
+            auto_resize_rows=auto_resize_rows,
             total_cols=total_columns,
             total_rows=total_rows,
             row_index=row_index,
@@ -2227,6 +2231,10 @@ class Sheet(tk.Frame):
         return self.MT.set_header_font(newfont)
 
     def set_options(self, redraw=True, **kwargs):
+        if "auto_resize_columns" in kwargs:
+            self.MT.auto_resize_columns = kwargs["auto_resize_columns"]
+        if "auto_resize_rows" in kwargs:
+            self.MT.auto_resize_rows = kwargs["auto_resize_rows"]
         if "to_clipboard_delimiter" in kwargs:
             self.MT.to_clipboard_delimiter = kwargs["to_clipboard_delimiter"]
         if "to_clipboard_quotechar" in kwargs:

{tksheet-6.1.7 → tksheet-6.1.9}/tksheet/_tksheet_column_headers.py

@@ -428,6 +428,7 @@ class ColumnHeaders(tk.Canvas):
             col = self.rsz_w - 1
             old_width = self.MT.col_positions[self.rsz_w] - self.MT.col_positions[self.rsz_w - 1]
             new_width = self.set_col_width(col)
+            self.MT.allow_auto_resize_columns = False
             self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
             if self.column_width_resize_func is not None and old_width != new_width:
                 self.column_width_resize_func(ResizeEvent("column_width_resize", col, old_width, new_width))
@@ -829,6 +830,7 @@ class ColumnHeaders(tk.Canvas):
             ]
             self.MT.col_positions[self.rsz_w] = new_col_pos
             new_width = self.MT.col_positions[self.rsz_w] - self.MT.col_positions[self.rsz_w - 1]
+            self.MT.allow_auto_resize_columns = False
             self.MT.recreate_all_selection_boxes()
             self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
             if self.column_width_resize_func is not None and old_width != new_width:

{tksheet-6.1.7 → tksheet-6.1.9}/tksheet/_tksheet_main_table.py

@@ -58,6 +58,8 @@ class MainTable(tk.Canvas):
             highlightthickness=0,
         )
         self.parentframe = kwargs["parentframe"]
+        self.parentframe_width = 0
+        self.parentframe_height = 0
         self.b1_pressed_loc = None
         self.existing_dropdown_canvas_id = None
         self.existing_dropdown_window = None
@@ -123,6 +125,10 @@ class MainTable(tk.Canvas):
         self.paste_insert_row_limit = kwargs["paste_insert_row_limit"]
         self.arrow_key_down_right_scroll_page = kwargs["arrow_key_down_right_scroll_page"]
         self.cell_auto_resize_enabled = kwargs["enable_edit_cell_auto_resize"]
+        self.auto_resize_columns = kwargs["auto_resize_columns"]
+        self.auto_resize_rows = kwargs["auto_resize_rows"]
+        self.allow_auto_resize_columns = True
+        self.allow_auto_resize_rows = True
         self.edit_cell_validation = kwargs["edit_cell_validation"]
         self.display_selected_fg_over_highlights = kwargs["display_selected_fg_over_highlights"]
         self.show_index = kwargs["show_index"]
@@ -330,12 +336,23 @@ class MainTable(tk.Canvas):
         self.basic_bindings()
         self.create_rc_menus()
 
-    def refresh(self, event=None):
+    def refresh(self, event=None) -> None:
+        self.main_table_redraw_grid_and_text(True, True)
+
+    def window_configured(self, event) -> None:
+        w = self.parentframe.winfo_width()
+        if w != self.parentframe_width:
+            self.parentframe_width = w
+            self.allow_auto_resize_columns = True
+        h = self.parentframe.winfo_height()
+        if h != self.parentframe_height:
+            self.parentframe_height = h
+            self.allow_auto_resize_rows = True
         self.main_table_redraw_grid_and_text(True, True)
 
     def basic_bindings(self, enable=True):
         if enable:
-            self.bind("<Configure>", self.refresh)
+            self.bind("<Configure>", self.window_configured)
             self.bind("<Motion>", self.mouse_motion)
             self.bind("<ButtonPress-1>", self.b1_press)
             self.bind("<B1-Motion>", self.b1_motion)
@@ -1797,7 +1814,7 @@ class MainTable(tk.Canvas):
                 self.delete_current()
             deselected = ("deselect_all_cols", deleted_boxes)
         elif r is not None and c is None and cell is None:
-            current = self.find_withtag("currently")
+            current = self.find_withtag("selected")
             current_tags = self.gettags(current[0]) if current else tuple()
             if current:
                 curr_r1, curr_c1, curr_r2, curr_c2 = tuple(int(e) for e in current_tags[1].split("_") if e)
@@ -1819,7 +1836,7 @@ class MainTable(tk.Canvas):
                 self.set_current_to_last()
             deselected = ("deselect_row", deleted_boxes)
         elif c is not None and r is None and cell is None:
-            current = self.find_withtag("currently")
+            current = self.find_withtag("selected")
             current_tags = self.gettags(current[0]) if current else tuple()
             if current:
                 curr_r1, curr_c1, curr_r2, curr_c2 = tuple(int(e) for e in current_tags[1].split("_") if e)
@@ -1848,7 +1865,7 @@ class MainTable(tk.Canvas):
                 self.find_withtag("cells"),
                 self.find_withtag("rows"),
                 self.find_withtag("columns"),
-                self.find_withtag("currently"),
+                self.find_withtag("selected"),
             ):
                 alltags = self.gettags(item)
                 if alltags:
@@ -3037,7 +3054,7 @@ class MainTable(tk.Canvas):
                 else:
                     self.select_cell(rowsel, colsel, redraw=False)
                     last_selected = tuple(
-                        int(e) for e in self.gettags(self.find_withtag("currently"))[1].split("_") if e
+                        int(e) for e in self.gettags(self.find_withtag("selected"))[1].split("_") if e
                     )
                 self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True, redraw_table=True)
                 if self.shift_selection_binding_func is not None:
@@ -3611,6 +3628,8 @@ class MainTable(tk.Canvas):
                 self.RI.row_height_resize_func(ResizeEvent("row_height_resize", r, old_height, new_height))
         if cell_needs_resize_w or cell_needs_resize_h:
             self.recreate_all_selection_boxes()
+            self.allow_auto_resize_columns = not cell_needs_resize_w
+            self.allow_auto_resize_rows = not cell_needs_resize_h
             if redraw:
                 self.refresh()
                 return True
@@ -4768,22 +4787,62 @@ class MainTable(tk.Canvas):
                 t = self.create_polygon(points, fill=fill, outline=outline, tag=tag, smooth=True)
             self.disp_checkbox[t] = True
 
-    def main_table_redraw_grid_and_text(self, redraw_header=False, redraw_row_index=False, redraw_table=True):
-        last_col_line_pos = self.col_positions[-1] + 1
-        last_row_line_pos = self.row_positions[-1] + 1
+    def main_table_redraw_grid_and_text(self, redraw_header=False, redraw_row_index=False, redraw_table=True,):
         try:
             can_width = self.winfo_width()
             can_height = self.winfo_height()
-            self.configure(
-                scrollregion=(
-                    0,
-                    0,
-                    last_col_line_pos + self.empty_horizontal,
-                    last_row_line_pos + self.empty_vertical,
-                )
-            )
         except Exception:
-            return
+            return False
+        row_pos_exists = self.row_positions != [0] and self.row_positions
+        col_pos_exists = self.col_positions != [0] and self.col_positions
+        resized_cols = False
+        resized_rows = False
+        if self.auto_resize_columns and self.allow_auto_resize_columns and col_pos_exists:
+            max_w = int(can_width)
+            max_w -= self.empty_horizontal
+            if (len(self.col_positions) - 1) * self.auto_resize_columns < max_w:
+                resized_cols = True
+                change = int((max_w - self.col_positions[-1]) / (len(self.col_positions) - 1))
+                widths = [
+                    int(b - a) + change - 1
+                    for a, b in zip(self.col_positions, islice(self.col_positions, 1, len(self.col_positions)))
+                ]
+                diffs = {}
+                for i, w in enumerate(widths):
+                    if w < self.auto_resize_columns:
+                        diffs[i] = self.auto_resize_columns - w
+                        widths[i] = self.auto_resize_columns
+                if diffs and len(diffs) < len(widths):
+                    change = sum(diffs.values()) / (len(widths) - len(diffs))
+                    for i, w in enumerate(widths):
+                        if i not in diffs:
+                            widths[i] -= change
+                self.col_positions = list(accumulate(chain([0], widths)))
+        if self.auto_resize_rows and self.allow_auto_resize_rows and row_pos_exists:
+            max_h = int(can_height)
+            max_h -= self.empty_vertical
+            if (len(self.row_positions) - 1) * self.auto_resize_rows < max_h:
+                resized_rows = True
+                change = int((max_h - self.row_positions[-1]) / (len(self.row_positions) - 1))
+                heights = [
+                    int(b - a) + change - 1
+                    for a, b in zip(self.row_positions, islice(self.row_positions, 1, len(self.row_positions)))
+                ]
+                diffs = {}
+                for i, h in enumerate(heights):
+                    if h < self.auto_resize_rows:
+                        diffs[i] = self.auto_resize_rows - h
+                        heights[i] = self.auto_resize_rows
+                if diffs and len(diffs) < len(heights):
+                    change = sum(diffs.values()) / (len(heights) - len(diffs))
+                    for i, h in enumerate(heights):
+                        if i not in diffs:
+                            heights[i] -= change
+                self.row_positions = list(accumulate(chain([0], heights)))
+        if resized_cols or resized_rows:
+            self.recreate_all_selection_boxes()
+        last_col_line_pos = self.col_positions[-1] + 1
+        last_row_line_pos = self.row_positions[-1] + 1
         if can_width >= last_col_line_pos + self.empty_horizontal and self.parentframe.xscroll_showing:
             self.parentframe.xscroll.grid_forget()
             self.parentframe.xscroll_showing = False
@@ -4791,7 +4850,7 @@ class MainTable(tk.Canvas):
             can_width < last_col_line_pos + self.empty_horizontal
             and not self.parentframe.xscroll_showing
             and not self.parentframe.xscroll_disabled
-            and can_height > 45
+            and can_height > 40
         ):
             self.parentframe.xscroll.grid(row=2, column=0, columnspan=2, sticky="nswe")
             self.parentframe.xscroll_showing = True
@@ -4802,20 +4861,31 @@ class MainTable(tk.Canvas):
             can_height < last_row_line_pos + self.empty_vertical
             and not self.parentframe.yscroll_showing
             and not self.parentframe.yscroll_disabled
-            and can_width > 45
+            and can_width > 40
         ):
             self.parentframe.yscroll.grid(row=0, column=2, rowspan=3, sticky="nswe")
             self.parentframe.yscroll_showing = True
+        self.configure(
+            scrollregion=(
+                0,
+                0,
+                last_col_line_pos + self.empty_horizontal + 2,
+                last_row_line_pos + self.empty_vertical + 2,
+            )
+        )
         scrollpos_bot = self.canvasy(can_height)
         end_row = bisect.bisect_right(self.row_positions, scrollpos_bot)
         if not scrollpos_bot >= self.row_positions[-1]:
             end_row += 1
         if redraw_row_index and self.show_index:
             self.RI.auto_set_index_width(end_row - 1)
+            # return
         scrollpos_left = self.canvasx(0)
         scrollpos_top = self.canvasy(0)
         scrollpos_right = self.canvasx(can_width)
         start_row = bisect.bisect_left(self.row_positions, scrollpos_top)
+        start_col = bisect.bisect_left(self.col_positions, scrollpos_left)
+        end_col = bisect.bisect_right(self.col_positions, scrollpos_right)
         self.row_width_resize_bbox = (
             scrollpos_left,
             scrollpos_top,
@@ -4846,8 +4916,7 @@ class MainTable(tk.Canvas):
         self.disp_dropdown = {}
         self.hidd_checkbox.update(self.disp_checkbox)
         self.disp_checkbox = {}
-        start_col = bisect.bisect_left(self.col_positions, scrollpos_left)
-        end_col = bisect.bisect_right(self.col_positions, scrollpos_right)
+
         if not scrollpos_right >= self.col_positions[-1]:
             end_col += 1
         if last_col_line_pos > scrollpos_right:
@@ -4858,8 +4927,6 @@ class MainTable(tk.Canvas):
             y_stop = scrollpos_bot
         else:
             y_stop = last_row_line_pos
-        row_pos_exists = self.row_positions != [0] and self.row_positions
-        col_pos_exists = self.col_positions != [0] and self.col_positions
         if self.show_horizontal_grid and row_pos_exists:
             self.grid_cyc = cycle(self.grid_cyctup)
             points = []
@@ -5281,7 +5348,7 @@ class MainTable(tk.Canvas):
                     self.hidd_checkbox[t] = False
             if self.show_selected_cells_border:
                 self.tag_raise("cellsbd")
-                self.tag_raise("currently")
+                self.tag_raise("selected")
                 self.tag_raise("rowsbd")
                 self.tag_raise("columnsbd")
         if redraw_header and self.show_header:
@@ -5312,7 +5379,7 @@ class MainTable(tk.Canvas):
             self.find_withtag("cells")
             + self.find_withtag("rows")
             + self.find_withtag("columns")
-            + self.find_withtag("currently")
+            + self.find_withtag("selected")
         )
 
     def get_boxes(self, include_current=True):
@@ -5325,7 +5392,7 @@ class MainTable(tk.Canvas):
                 boxes[tuple(int(e) for e in alltags[1].split("_") if e)] = "rows"
             elif alltags[0] == "columns":
                 boxes[tuple(int(e) for e in alltags[1].split("_") if e)] = "columns"
-            elif include_current and alltags[0] == "currently":
+            elif include_current and alltags[0] == "selected":
                 boxes[tuple(int(e) for e in alltags[1].split("_") if e)] = f"{alltags[2]}"
         return boxes
 
@@ -5402,13 +5469,13 @@ class MainTable(tk.Canvas):
             self.RI.delete("columns", "columnsbd")
             self.CH.delete("columns", "columnsbd")
         if delete_current:
-            self.delete("currently")
-            self.RI.delete("currently")
-            self.CH.delete("currently")
+            self.delete("selected")
+            self.RI.delete("selected")
+            self.CH.delete("selected")
         return deleted_boxes
 
     def currently_selected(self):
-        items = self.find_withtag("currently")
+        items = self.find_withtag("selected")
         if not items:
             return tuple()
         alltags = self.gettags(items[0])
@@ -5416,7 +5483,7 @@ class MainTable(tk.Canvas):
         return CurrentlySelectedClass(box[0], box[1], alltags[2])
 
     def get_tags_of_current(self):
-        items = self.find_withtag("currently")
+        items = self.find_withtag("selected")
         if items:
             return self.gettags(items[0])
         else:
@@ -5424,17 +5491,17 @@ class MainTable(tk.Canvas):
 
     def set_currently_selected(self, r, c, type_="cell"):  # cell, column or row
         r1, c1, r2, c2 = r, c, r + 1, c + 1
-        self.delete("currently")
-        self.RI.delete("currently")
-        self.CH.delete("currently")
+        self.delete("selected")
+        self.RI.delete("selected")
+        self.CH.delete("selected")
         if self.col_positions == [0]:
             c1 = 0
             c2 = 0
         if self.row_positions == [0]:
             r1 = 0
             r2 = 0
-        tagr = ("currently", f"{r1}_{c1}_{r2}_{c2}", type_)
-        tag_index_header = ("cells", f"{r1}_{c1}_{r2}_{c2}")
+        tagr = ("selected", f"{r1}_{c1}_{r2}_{c2}", type_)
+        tag_index_header = ("cells", f"{r1}_{c1}_{r2}_{c2}", "selected")
         if type_ == "cell":
             outline = self.table_selected_cells_border_fg
         elif type_ == "row":
@@ -5501,9 +5568,9 @@ class MainTable(tk.Canvas):
         return tuple()
 
     def delete_current(self):
-        self.delete("currently")
-        self.RI.delete("currently")
-        self.CH.delete("currently")
+        self.delete("selected")
+        self.RI.delete("selected")
+        self.CH.delete("selected")
 
     def create_selected(
         self,
@@ -5516,21 +5583,22 @@ class MainTable(tk.Canvas):
         state="normal",
     ):
         self.itemconfig("cells", state="normal")
+        coords = f"{r1}_{c1}_{r2}_{c2}"
         if type_ == "cells":
-            tagr = ("cells", f"{r1}_{c1}_{r2}_{c2}")
-            tagb = ("cellsbd", f"{r1}_{c1}_{r2}_{c2}")
+            tagr = ("cells", coords)
+            tagb = ("cellsbd", coords)
             mt_bg = self.table_selected_cells_bg
             mt_border_col = self.table_selected_cells_border_fg
         elif type_ == "rows":
-            tagr = ("rows", f"{r1}_{c1}_{r2}_{c2}")
-            tagb = ("rowsbd", f"{r1}_{c1}_{r2}_{c2}")
-            tag_index_header = ("cells", f"{r1}_{c1}_{r2}_{c2}")
+            tagr = ("rows", coords)
+            tagb = ("rowsbd", coords)
+            tag_index_header = ("cells", coords)
             mt_bg = self.table_selected_rows_bg
             mt_border_col = self.table_selected_rows_border_fg
         elif type_ == "columns":
-            tagr = ("columns", f"{r1}_{c1}_{r2}_{c2}")
-            tagb = ("columnsbd", f"{r1}_{c1}_{r2}_{c2}")
-            tag_index_header = ("cells", f"{r1}_{c1}_{r2}_{c2}")
+            tagr = ("columns", coords)
+            tagb = ("columnsbd", coords)
+            tag_index_header = ("cells", coords)
             mt_bg = self.table_selected_columns_bg
             mt_border_col = self.table_selected_columns_border_fg
         self.last_selected = (r1, c1, r2, c2, type_)
@@ -5590,15 +5658,16 @@ class MainTable(tk.Canvas):
         return r, b
 
     def recreate_all_selection_boxes(self):
+        curr = self.currently_selected()
         for item in chain(
             self.find_withtag("cells"),
             self.find_withtag("rows"),
             self.find_withtag("columns"),
-            self.find_withtag("currently"),
         ):
             tags = self.gettags(item)
             if tags:
                 r1, c1, r2, c2 = tuple(int(e) for e in tags[1].split("_") if e)
+                state = self.itemcget(item, "state")
                 self.delete(f"{r1}_{c1}_{r2}_{c2}")
                 self.RI.delete(f"{r1}_{c1}_{r2}_{c2}")
                 self.CH.delete(f"{r1}_{c1}_{r2}_{c2}")
@@ -5608,10 +5677,9 @@ class MainTable(tk.Canvas):
                     r2 = len(self.row_positions) - 1
                 if c2 > len(self.col_positions) - 1:
                     c2 = len(self.col_positions) - 1
-                if tags[0] == "currently":
-                    self.set_currently_selected(r1, c1, tags[2])
-                else:
-                    self.create_selected(r1, c1, r2, c2, tags[0])
+                self.create_selected(r1, c1, r2, c2, tags[0], state=state)
+        if curr:
+            self.set_currently_selected(curr.row, curr.column, curr.type_)
         self.tag_lower("rows")
         self.RI.tag_lower("rows")
         self.tag_lower("columns")
@@ -5620,7 +5688,7 @@ class MainTable(tk.Canvas):
         self.RI.tag_lower("cells")
         self.CH.tag_lower("cells")
         if not self.show_selected_cells_border:
-            self.tag_lower("currently")
+            self.tag_lower("selected")
 
     def get_redraw_selections(self, startr, endr, startc, endc):
         d = defaultdict(list)
@@ -5655,7 +5723,7 @@ class MainTable(tk.Canvas):
             self.find_withtag("cells"),
             self.find_withtag("rows"),
             self.find_withtag("columns"),
-            self.find_withtag("currently"),
+            self.find_withtag("selected"),
         ):
             r1, c1, r2, c2 = tuple(int(e) for e in self.gettags(item)[1].split("_") if e)
             if r1 < min_y:
@@ -5898,7 +5966,7 @@ class MainTable(tk.Canvas):
                 return True
         return False
 
-    # don't have to use "currently" because you can't have a current without a selection box
+    # don't have to use "selected" because you can't have a current without a selection box
     def cell_selected(self, r, c, inc_cols=False, inc_rows=False):
         if not isinstance(r, int) or not isinstance(c, int):
             return False
@@ -5959,11 +6027,11 @@ class MainTable(tk.Canvas):
         return tuple()
 
     def hide_current(self):
-        for item in self.find_withtag("currently"):
+        for item in self.find_withtag("selected"):
             self.itemconfig(item, state="hidden")
 
     def show_current(self):
-        for item in self.find_withtag("currently"):
+        for item in self.find_withtag("selected"):
             self.itemconfig(item, state="normal")
 
     def open_cell(self, event=None, ignore_existing_editor=False):

{tksheet-6.1.7 → tksheet-6.1.9}/tksheet/_tksheet_row_index.py

@@ -374,6 +374,7 @@ class RowIndex(tk.Canvas):
             row = self.rsz_h - 1
             old_height = self.MT.row_positions[self.rsz_h] - self.MT.row_positions[self.rsz_h - 1]
             new_height = self.set_row_height(row)
+            self.MT.allow_auto_resize_rows = False
             self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
             if self.row_height_resize_func is not None and old_height != new_height:
                 self.row_height_resize_func(ResizeEvent("row_height_resize", row, old_height, new_height))
@@ -783,6 +784,7 @@ class RowIndex(tk.Canvas):
                 e + increment for e in islice(self.MT.row_positions, self.rsz_h + 1, len(self.MT.row_positions))
             ]
             self.MT.row_positions[self.rsz_h] = new_row_pos
+            self.MT.allow_auto_resize_rows = False
             new_height = self.MT.row_positions[self.rsz_h] - self.MT.row_positions[self.rsz_h - 1]
             self.MT.recreate_all_selection_boxes()
             self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)

{tksheet-6.1.7 → tksheet-6.1.9/tksheet.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 6.1.7
+Version: 6.1.9
 Summary: Tkinter table / sheet widget
 Home-page: https://github.com/ragardner/tksheet
-Download-URL: https://github.com/ragardner/tksheet/archive/6.1.7.tar.gz
+Download-URL: https://github.com/ragardner/tksheet/archive/6.1.9.tar.gz
 Author: ragardner
 Author-email: github@ragardner.simplelogin.com
 License: MIT