tksheet 7.5.8__py3-none-any.whl → 7.5.10__py3-none-any.whl

tksheet/__init__.py

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

tksheet/column_headers.py

@@ -1863,14 +1863,15 @@ class ColumnHeaders(tk.Canvas):
             except Exception:
                 self.tooltip.content_text.focus_set()
             return
-        if not self.tooltip.cell_readonly:
+        if not self.tooltip.cell_readonly or not self.tooltip.note_readonly:
             _, c, cell, note = self.tooltip.get()
             datacn = self.MT.datacn(c)
-            event_data = self.new_single_edit_event(c, datacn, "??", self.get_cell_data(datacn), cell)
-            self.do_single_edit(c, datacn, event_data, cell)
-        if not self.tooltip.note_readonly:
-            span = self.PAR.span(None, datacn, None, datacn + 1).options(table=False, header=True)
-            self.PAR.note(span, note=note if note else None, readonly=False)
+            if not self.tooltip.cell_readonly:
+                event_data = self.new_single_edit_event(c, datacn, "??", self.get_cell_data(datacn), cell)
+                self.do_single_edit(c, datacn, event_data, cell)
+            if not self.tooltip.note_readonly:
+                span = self.PAR.span(None, datacn, None, datacn + 1).options(table=False, header=True)
+                self.PAR.note(span, note=note if note else None, readonly=False)
         self.hide_tooltip()
         self.MT.refresh()
         self.focus_set()

tksheet/functions.py

@@ -835,6 +835,17 @@ def move_elements_to(
     )
 
 
+def remove_duplicates_outside_section(strings: list[str], section_start: int, section_size: int) -> list[str]:
+    if section_start == 0 and section_size >= len(strings):
+        return strings
+
+    section_end = section_start + section_size
+    section_set = set(strings[section_start:section_end])
+    print(section_set, section_start, section_size)
+
+    return [s for i, s in enumerate(strings) if (section_start <= i < section_end) or (s not in section_set)]
+
+
 def get_new_indexes(
     move_to: int,
     to_move: Iterable[int],

tksheet/main_table.py

@@ -1805,7 +1805,7 @@ class MainTable(tk.Canvas):
         create_selections: bool = True,
         event_data: EventDataDict | None = None,
         undo_modification: EventDataDict | None = None,
-        node_change: None | tuple[str, str, int] = None,
+        node_change: None | dict = None,
         manage_tree: bool = True,
     ) -> tuple[dict[int, int], dict[int, int], EventDataDict]:
         self.saved_row_heights = {}
@@ -1965,7 +1965,10 @@ class MainTable(tk.Canvas):
                     # finally, change the span coords
                     span["from_r"], span["upto_r"] = newfrom, newupto
 
-        if (not self.PAR.ops.treeview or not undo_modification) and (move_heights and disp_new_idxs):
+        if not undo_modification and create_selections and self.PAR.ops.treeview:
+            self.PAR.selection_set(*[self._row_index[k].iid for k in data_new_idxs.values()])
+
+        elif not undo_modification and move_heights and disp_new_idxs:
             self.set_row_positions(
                 itr=move_elements_by_mapping_gen(
                     self.get_row_heights(),
@@ -6577,19 +6580,20 @@ class MainTable(tk.Canvas):
             except Exception:
                 self.tooltip.content_text.focus_set()
             return
-        if not self.tooltip.cell_readonly:
+        if not self.tooltip.cell_readonly or not self.tooltip.note_readonly:
             r, c, cell, note = self.tooltip.get()
             datarn, datacn = self.datarn(r), self.datacn(c)
-            event_data = self.new_single_edit_event(
-                r, c, datarn, datacn, "??", self.get_cell_data(datarn, datacn), cell
-            )
-            value, event_data = self.single_edit_run_validation(datarn, datacn, event_data)
-            if value is not None and (
-                self.set_cell_data_undo(r=r, c=c, datarn=datarn, datacn=datacn, value=value, redraw=False)
-            ):
-                try_binding(self.extra_end_edit_cell_func, event_data)
-        if not self.tooltip.note_readonly:
-            self.PAR.note(datarn, datacn, note=note if note else None, readonly=False)
+            if not self.tooltip.cell_readonly:
+                event_data = self.new_single_edit_event(
+                    r, c, datarn, datacn, "??", self.get_cell_data(datarn, datacn), cell
+                )
+                value, event_data = self.single_edit_run_validation(datarn, datacn, event_data)
+                if value is not None and (
+                    self.set_cell_data_undo(r=r, c=c, datarn=datarn, datacn=datacn, value=value, redraw=False)
+                ):
+                    try_binding(self.extra_end_edit_cell_func, event_data)
+            if not self.tooltip.note_readonly:
+                self.PAR.note(datarn, datacn, note=note if note else None, readonly=False)
         self.hide_tooltip()
         self.refresh()
         self.focus_set()

tksheet/row_index.py

@@ -35,6 +35,7 @@ from .functions import (
     num2alpha,
     push_displayed,
     recursive_bind,
+    remove_duplicates_outside_section,
     rounded_box_coords,
     safe_copy,
     stored_event_dict,
@@ -884,7 +885,7 @@ class RowIndex(tk.Canvas):
                 elif (iid := self.event_over_tree_arrow(r, canvasy, event.x)) is not None:
                     if self.MT.selection_boxes:
                         self.select_row(r, ext=True, redraw=False)
-                    self.PAR.item(iid, open_=iid not in self.tree_open_ids)
+                    self.PAR.item(iid, open_=iid not in self.tree_open_ids, undo=False)
             else:
                 self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
             self.b1_pressed_loc = None
@@ -2036,14 +2037,15 @@ class RowIndex(tk.Canvas):
             except Exception:
                 self.tooltip.content_text.focus_set()
             return
-        if not self.tooltip.cell_readonly:
+        if not self.tooltip.cell_readonly or not self.tooltip.note_readonly:
             r, _, cell, note = self.tooltip.get()
             datarn = self.MT.datarn(r)
-            event_data = self.new_single_edit_event(r, datarn, "??", self.get_cell_data(datarn), cell)
-            self.do_single_edit(r, datarn, event_data, cell)
-        if not self.tooltip.note_readonly:
-            span = self.PAR.span(datarn).options(table=False, index=True)
-            self.PAR.note(span, note=note if note else None, readonly=False)
+            if not self.tooltip.cell_readonly:
+                event_data = self.new_single_edit_event(r, datarn, "??", self.get_cell_data(datarn), cell)
+                self.do_single_edit(r, datarn, event_data, cell)
+            if not self.tooltip.note_readonly:
+                span = self.PAR.span(datarn).options(table=False, index=True)
+                self.PAR.note(span, note=note if note else None, readonly=False)
         self.hide_tooltip()
         self.MT.refresh()
         self.focus_set()
@@ -2790,6 +2792,14 @@ class RowIndex(tk.Canvas):
 
         return event_data
 
+    def remove_descendants(self, iids: set[str]) -> tuple[list[int], set[str]]:
+        return (
+            sorted(
+                self.rns[iid] for iid in iids if not any(ancestor in iids for ancestor in self.get_iid_ancestors(iid))
+            ),
+            iids,
+        )
+
     def move_rows_mod_nodes(
         self,
         data_new_idxs: dict[int, int],
@@ -2798,7 +2808,7 @@ class RowIndex(tk.Canvas):
         maxidx: int,
         event_data: EventDataDict,
         undo_modification: EventDataDict | None = None,
-        node_change: tuple[str, str, int] | None = None,
+        node_change: dict | None = None,
     ) -> Generator[tuple[dict[int, int], dict[int, int], dict[str, int], EventDataDict]] | None:
         # data_new_idxs is {old: new, old: new}
         # data_old_idxs is {new: old, new: old}
@@ -2812,97 +2822,84 @@ class RowIndex(tk.Canvas):
 
             elif event_data["moved"]["rows"]:
                 if node_change:
-                    item = node_change[0]
-                    moved_rows = [self.rns[item]]
-                    new_parent = node_change[1]
-                    move_to_index = node_change[2]
-                    # new parent exists
+                    moved_rows, iids = self.remove_descendants(node_change["iids"])
+                    new_parent = node_change["new_par"]
+                    move_to_index = node_change["index"]
                     if new_parent:
                         new_par_cn = self.iid_children(new_parent)
-                        # determine index
+                        len_new_par_cn = len(new_par_cn)
                         if isinstance(move_to_index, int):
-                            move_to_index = min(move_to_index, len(new_par_cn))
+                            move_to_index = min(move_to_index, len_new_par_cn)
                         else:
-                            move_to_index = len(new_par_cn)
-                        # determine insert row
+                            move_to_index = len_new_par_cn
                         if not new_par_cn:
                             insert_row = self.rns[new_parent] + 1
-                        elif move_to_index >= len(new_par_cn):
+                        elif move_to_index >= len_new_par_cn:
                             insert_row = self.rns[new_par_cn[-1]] + self.num_descendants(new_par_cn[-1]) + 1
-                        elif new_parent == self.iid_parent(item):
-                            if move_to_index <= self.PAR.index(item):
-                                # Insert before the sibling at move_to_index
-                                insert_row = self.rns[new_par_cn[move_to_index]]
-                            else:
-                                # Insert after the sibling at move_to_index
-                                insert_row = self.rns[new_par_cn[move_to_index]]
-                                insert_row += 1 + self.num_descendants(new_par_cn[move_to_index])
                         else:
+                            # To get the ids to the proper index and insert row -
+                            # For every iid that is being moved under the same parent but to an
+                            # index further along we have to adjust the insert row and move to index
                             insert_row = self.rns[new_par_cn[move_to_index]]
-                    # no new parent
+                            for iid in iids:
+                                if new_parent == self.iid_parent(iid) and move_to_index > self.PAR.index(iid):
+                                    insert_row += 1 + self.num_descendants(new_par_cn[move_to_index])
+                                    move_to_index += 1
+                                    if move_to_index >= len_new_par_cn:
+                                        break
                     else:
-                        # determine index
                         if isinstance(move_to_index, int):
                             move_to_index = min(move_to_index, sum(1 for _ in self.gen_top_nodes()))
                         else:
                             move_to_index = sum(1 for _ in self.gen_top_nodes())
-                        # determine insert row
                         insert_row = self.PAR._get_id_insert_row(move_to_index, new_parent)
                 else:
-                    # remove any descendants
-                    iids = {self.MT._row_index[r].iid for r in event_data["moved"]["rows"]["data"]}
-                    moved_rows = sorted(
-                        self.rns[iid]
-                        for iid in iids
-                        if not any(ancestor in iids for ancestor in self.get_iid_ancestors(iid))
+                    moved_rows, iids = self.remove_descendants(
+                        {self.MT._row_index[r].iid for r in event_data["moved"]["rows"]["data"]}
                     )
-                    item = self.MT._row_index[moved_rows[0]].iid
                     if isinstance(event_data.value, int):
                         if event_data.value >= len(self.MT.displayed_rows):
                             insert_row = len(self.MT._row_index)
                         else:
                             insert_row = self.MT.datarn(event_data.value)
                         move_to_iid = self.MT._row_index[min(insert_row, len(self.MT._row_index) - 1)].iid
-
                     else:
                         min_from = min(event_data["moved"]["rows"]["data"])
-                        # max_from = max(event_data.moved.rows)
                         min_to = min(event_data["moved"]["rows"]["data"].values())
                         max_to = max(event_data["moved"]["rows"]["data"].values())
                         insert_row = max_to if min_from <= min_to else min_to
                         move_to_iid = self.MT._row_index[insert_row].iid
-
                     move_to_index = self.PAR.index(move_to_iid)
                     new_parent = self.iid_parent(move_to_iid)
-
-                event_data["moved"]["rows"]["data"] = {moved_rows[0]: insert_row}
+                    if any(
+                        self.move_pid_causes_recursive_loop(self.MT._row_index[r].iid, new_parent) for r in moved_rows
+                    ):
+                        event_data["moved"]["rows"], data_new_idxs, data_old_idxs = {}, {}, {}
+                        moved_rows = []
 
                 new_loc_is_displayed = not new_parent or (
                     new_parent and new_parent in self.tree_open_ids and self.PAR.item_displayed(new_parent)
                 )
-                event_data["moved"]["rows"]["displayed"] = {}
+                event_data["moved"]["rows"]["displayed"], disp_new_idxs = {}, {}
 
-                if any(self.move_pid_causes_recursive_loop(self.MT._row_index[r].iid, new_parent) for r in moved_rows):
-                    event_data["moved"]["rows"] = {}
-                    data_new_idxs, data_old_idxs, disp_new_idxs = {}, {}, {}
-
-                else:
+                if moved_rows:
+                    event_data["moved"]["rows"]["data"] = {moved_rows[0]: insert_row}
+                    iids = []
                     for r in moved_rows:
                         iid = self.MT._row_index[r].iid
-                        event_data = self.move_node(
-                            event_data=event_data,
-                            item=iid,
-                            parent=new_parent,
-                            index=move_to_index,
+                        event_data = self.move_node(event_data=event_data, item=iid, parent=new_parent)
+                        iids.append(iid)
+                    if new_parent:
+                        self.iid_node(new_parent).children[move_to_index:move_to_index] = iids
+                        self.iid_node(new_parent).children = remove_duplicates_outside_section(
+                            self.iid_children(new_parent), move_to_index, len(iids)
                         )
-                        move_to_index += 1
                     event_data["moved"]["rows"]["data"] = get_new_indexes(
                         insert_row,
                         event_data["moved"]["rows"]["data"],
                     )
                     data_new_idxs = event_data["moved"]["rows"]["data"]
                     data_old_idxs = {v: k for k, v in data_new_idxs.items()}
-                    disp_new_idxs = event_data["moved"]["rows"]["displayed"]
 
         if data_new_idxs:
             self.MT.move_rows_data(data_new_idxs, data_old_idxs, maxidx)
@@ -2919,27 +2916,16 @@ class RowIndex(tk.Canvas):
 
         yield None
 
-    def move_node(
-        self,
-        event_data: EventDataDict,
-        item: str,
-        parent: str | None = None,
-        index: int = 0,
-    ) -> EventDataDict:
+    def move_node(self, event_data: EventDataDict, item: str, parent: str | None = None) -> EventDataDict:
         # also backs up nodes
         if parent is None:
             parent = self.iid_parent(item)
-
         item_node = self.iid_node(item)
-
-        # new parent is an item
         if parent:
             parent_node = self.iid_node(parent)
             # its the same parent, we're just moving index
             if parent == item_node.parent:
                 event_data = self.copy_nodes((item, parent), event_data)
-                parent_node.children.insert(index, parent_node.children.pop(parent_node.children.index(item)))
-
             else:
                 if item_node.parent:
                     event_data = self.copy_nodes((item, item_node.parent, parent), event_data)
@@ -2947,9 +2933,6 @@ class RowIndex(tk.Canvas):
                     event_data = self.copy_nodes((item, parent), event_data)
                 self.remove_iid_from_parents_children(item)
                 item_node.parent = parent_node.iid
-                parent_node.children.insert(index, item)
-
-        # no new parent
         else:
             if item_node.parent:
                 event_data = self.copy_nodes((item, item_node.parent), event_data)
@@ -2958,7 +2941,7 @@ class RowIndex(tk.Canvas):
             self.remove_iid_from_parents_children(item)
             self.MT._row_index[self.rns[item]].parent = ""
 
-        # last row in mapping is where to start from +1
+        # last row in mapping + 1 is where to start from
         mapping = event_data["moved"]["rows"]["data"]
         row_ctr = next(reversed(mapping.values())) + 1
 
@@ -2966,13 +2949,11 @@ class RowIndex(tk.Canvas):
         if rn not in mapping:
             mapping[rn] = row_ctr
             row_ctr += 1
-
         for did in self.get_iid_descendants(item):
             mapping[self.rns[did]] = row_ctr
             row_ctr += 1
 
         event_data["moved"]["rows"]["data"] = mapping
-
         return event_data
 
     def restore_nodes(self, event_data: EventDataDict) -> None:

tksheet/sheet.py

@@ -4980,14 +4980,6 @@ class Sheet(tk.Frame):
             self.del_rows(rows, data_indexes=True, undo=undo)
         return self.set_refresh_timer(rows)
 
-    def set_children(self, parent: str, *newchildren) -> Sheet:
-        """
-        Moves everything in '*newchildren' under 'parent'
-        """
-        for iid in unpack(newchildren):
-            self.move(iid, parent)
-        return self
-
     def top_index_row(self, index: int) -> int:
         try:
             return next(self.RI.rns[n.iid] for i, n in enumerate(self.RI.gen_top_nodes()) if i == index)
@@ -5009,9 +5001,9 @@ class Sheet(tk.Frame):
         """
         if item not in self.RI.rns:
             raise ValueError(f"Item '{item}' does not exist.")
-        if parent and parent not in self.RI.rns:
+        elif parent and parent not in self.RI.rns:
             raise ValueError(f"Parent '{parent}' does not exist.")
-        if self.RI.move_pid_causes_recursive_loop(item, parent):
+        elif self.RI.move_pid_causes_recursive_loop(item, parent):
             raise ValueError(f"Item '{item}' causes recursive loop with parent '{parent}.")
         data_new_idxs, disp_new_idxs, event_data = self.MT.move_rows_adjust_options_dict(
             data_new_idxs={},
@@ -5022,7 +5014,45 @@ class Sheet(tk.Frame):
             move_heights=True,
             create_selections=select,
             event_data=None,
-            node_change=(item, parent, index),
+            node_change={"iids": {item}, "new_par": parent, "index": index},
+        )
+        if undo:
+            self.MT.undo_stack.append(stored_event_dict(event_data))
+        self.MT.sheet_modified(event_data, emit_event=emit_event)
+        self.set_refresh_timer()
+        return data_new_idxs, disp_new_idxs, event_data
+
+    def set_children(
+        self,
+        parent: str,
+        *newchildren: str,
+        index: int | None = None,
+        select: bool = True,
+        undo: bool = True,
+        emit_event: bool = False,
+    ) -> Sheet:
+        """
+        Moves everything in '*newchildren' under 'parent'
+        """
+        if parent and parent not in self.RI.rns:
+            raise ValueError(f"Parent '{parent}' does not exist.")
+        iids = set()
+        for iid in unpack(newchildren):
+            if iid not in self.RI.rns:
+                raise ValueError(f"Item '{iid}' does not exist.")
+            elif self.RI.move_pid_causes_recursive_loop(iid, parent):
+                raise ValueError(f"Item '{iid}' causes recursive loop with parent '{parent}.")
+            iids.add(iid)
+        data_new_idxs, disp_new_idxs, event_data = self.MT.move_rows_adjust_options_dict(
+            data_new_idxs={},
+            data_old_idxs={},
+            totalrows=None,
+            disp_new_idxs={},
+            move_data=True,
+            move_heights=True,
+            create_selections=select,
+            event_data=None,
+            node_change={"iids": iids, "new_par": parent, "index": index},
         )
         if undo:
             self.MT.undo_stack.append(stored_event_dict(event_data))

{tksheet-7.5.8.dist-info → tksheet-7.5.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tksheet
-Version: 7.5.8
+Version: 7.5.10
 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.5.8.dist-info → tksheet-7.5.10.dist-info}/RECORD

@@ -1,15 +1,15 @@
-tksheet/__init__.py,sha256=guUQx6M_vpYrJvYXpJHxr9eq8br5iOMXF1ZqYPEG73M,2532
+tksheet/__init__.py,sha256=3Ue-5hmalzD8JxLLXk1WoBPBWdZ3MWkFfs_3wx0S2w8,2533
 tksheet/colors.py,sha256=dHhmdFuQDlwohDHsAfT9VdrKoSl_R33L72a3HCin5zo,51591
-tksheet/column_headers.py,sha256=5hwloDxaBO2wf_3qJbDDJWX8I8rKx-WPwv0UPWQ9xnk,110618
+tksheet/column_headers.py,sha256=-i8LMCUW1UuKpyurWySJRyjiCqisgFrjm9l8U58bFAY,110720
 tksheet/constants.py,sha256=4cpU_PmOgN0isBVPWwCwBwqD8Fxnu4HJgDSSjfxjiPo,25467
 tksheet/find_window.py,sha256=aV2U-IDFL6xNRhF4VomdrXEML4qw6QBqlfrVskuiTNY,20954
 tksheet/formatters.py,sha256=r2vjgmKs_xWBYlfqVhPPNKQc67zCawOIl4dp4XAEzYg,10182
-tksheet/functions.py,sha256=8S5u8GXl-uHxsRfGqG5Vt5ec7nOql7QczvTWSNuoRPg,56109
-tksheet/main_table.py,sha256=RuITcYD9kmn8JVYBW8WH6TQzOs03DV57EZbPHTw18iA,367907
+tksheet/functions.py,sha256=O74jt9Kq-JgtWaI7fHBXbIbCTdi79B3eHidR-wfiAZ0,56585
+tksheet/main_table.py,sha256=awMX6ABc_LW-gzhZh9MKnyMv9-ZKpBEQUcEylwKjVMA,368162
 tksheet/menus.py,sha256=sRHZRgnYWddBtlzvbyWFSN2cVhlmUWyA9zf4vpqun7I,19431
 tksheet/other_classes.py,sha256=6LpexHAxj23ZweuL3a4yCcdMSj_iXP38S7WRNQAehe0,18354
-tksheet/row_index.py,sha256=UgySVE0i3MvAoVz7HVcYZnu_1DpAHby4_pTAkrAKthI,146973
-tksheet/sheet.py,sha256=i3h1FBko5dAdlWcv57WoP8e2NorRXk2eC_kACYaLK1Q,271847
+tksheet/row_index.py,sha256=wmoQylsUJQMnbONIndeRM_gW9eHJg-DdmX6MjxqlQlk,146892
+tksheet/sheet.py,sha256=gYm2o_chSI9vCtxY4r5j9soKQXXWFgvuH2FrEd3IGc4,273109
 tksheet/sheet_options.py,sha256=dhHY4jUULGXH2b_VOjoAfKXm3PAz7QL5CrVnHA0byho,14697
 tksheet/sorting.py,sha256=zcZPpRtP1h_xJGtGkG3E43H7deKQFnh9cMwZ1B2-aGc,17502
 tksheet/text_editor.py,sha256=Ksz4kT7TrCIzDhRZK9EM54M7R_5CvrwC1aeTrUPNOTg,8391
@@ -17,8 +17,8 @@ tksheet/themes.py,sha256=kUUCUmvgu8vUlzfVNk9a3BEbeBcU3asNwPB_u-OejCY,18471
 tksheet/tksheet_types.py,sha256=qthH565jq60QCAeczvIWttIa4X5rFfLWPSwWBMDPilw,4611
 tksheet/tooltip.py,sha256=TTWk3HW5Sltamish9GCnAECwZLa9Rm6QC8-RCDDtQnE,12374
 tksheet/top_left_rectangle.py,sha256=A4wWL8PFl57Pn2Ek71rASCE1-bW844cTl7bgt4tLWzI,8499
-tksheet-7.5.8.dist-info/licenses/LICENSE.txt,sha256=n1UvJHBr-AYNOf6ExICDsEggh9R7U4V4m_gH7FD-y-o,2305
-tksheet-7.5.8.dist-info/METADATA,sha256=zLKKkpmO0H9rS0wtQIokuLh9WOscff7AxfFFVFkfV6Q,9474
-tksheet-7.5.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tksheet-7.5.8.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
-tksheet-7.5.8.dist-info/RECORD,,
+tksheet-7.5.10.dist-info/licenses/LICENSE.txt,sha256=n1UvJHBr-AYNOf6ExICDsEggh9R7U4V4m_gH7FD-y-o,2305
+tksheet-7.5.10.dist-info/METADATA,sha256=GI9d24XzxknLTYE8ITC4_dWUii4pG2r_P-jczO3Sb6I,9475
+tksheet-7.5.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tksheet-7.5.10.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
+tksheet-7.5.10.dist-info/RECORD,,