tksheet 7.4.2__py3-none-any.whl → 7.4.4__py3-none-any.whl

tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.4.2"
+__version__ = "7.4.4"
 
 from .colors import (
     color_map,
@@ -93,6 +93,7 @@ from .other_classes import (
 from .row_index import RowIndex
 from .sheet import Dropdown, Sheet
 from .sheet_options import new_sheet_options
+from .sorting import fast_sort_key, natural_sort_key, version_sort_key
 from .text_editor import (
     TextEditor,
     TextEditorTkText,

tksheet/column_headers.py

@@ -874,6 +874,8 @@ class ColumnHeaders(tk.Canvas):
             columns = list(range(0, len(self.MT.col_positions) - 1))
         event_data = self.MT.new_event_dict("edit_table")
         try_binding(self.MT.extra_begin_sort_cells_func, event_data)
+        if key is None:
+            key = self.PAR.ops.sort_key
         for c in columns:
             datacn = self.MT.datacn(c)
             for r, val in enumerate(
@@ -923,6 +925,8 @@ class ColumnHeaders(tk.Canvas):
                 return event_data
             column = self.MT.selected.column
         if try_binding(self.ch_extra_begin_sort_rows_func, event_data, "begin_move_rows"):
+            if key is None:
+                key = self.PAR.ops.sort_key
             disp_new_idxs, disp_row_ctr = {}, 0
             if self.ops.treeview:
                 new_nodes_order, data_new_idxs = sort_tree_view(
@@ -2239,16 +2243,17 @@ class ColumnHeaders(tk.Canvas):
                 self.MT._headers[datacn] = value
 
     def input_valid_for_cell(self, datacn: int, value: object, check_readonly: bool = True) -> bool:
-        if check_readonly and self.get_cell_kwargs(datacn, key="readonly"):
+        kwargs = self.get_cell_kwargs(datacn, key=None)
+        if check_readonly and "readonly" in kwargs:
             return False
-        if self.get_cell_kwargs(datacn, key="checkbox"):
+        elif "checkbox" in kwargs:
             return is_bool_like(value)
-        if self.cell_equal_to(datacn, value):
+        elif self.cell_equal_to(datacn, value):
             return False
-        kwargs = self.get_cell_kwargs(datacn, key="dropdown")
-        if kwargs and kwargs["validate_input"] and value not in kwargs["values"]:
+        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and value not in kwargs["values"]:
             return False
-        return True
+        else:
+            return True
 
     def cell_equal_to(self, datacn: int, value: object) -> bool:
         self.fix_header(datacn)
@@ -2303,12 +2308,13 @@ class ColumnHeaders(tk.Canvas):
         return value
 
     def get_value_for_empty_cell(self, datacn: int, c_ops: bool = True) -> object:
-        if self.get_cell_kwargs(datacn, key="checkbox", cell=c_ops):
+        kwargs = self.get_cell_kwargs(datacn, key=None, cell=c_ops)
+        if "checkbox" in kwargs:
             return False
-        kwargs = self.get_cell_kwargs(datacn, key="dropdown", cell=c_ops)
-        if kwargs and kwargs["validate_input"] and kwargs["values"]:
+        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and kwargs["values"]:
             return kwargs["values"][0]
-        return ""
+        else:
+            return ""
 
     def get_empty_header_seq(self, end: int, start: int = 0, c_ops: bool = True) -> list[object]:
         return [self.get_value_for_empty_cell(datacn, c_ops=c_ops) for datacn in range(start, end)]
@@ -2376,7 +2382,8 @@ class ColumnHeaders(tk.Canvas):
         if redraw:
             self.MT.refresh()
 
-    def get_cell_kwargs(self, datacn: int, key: Hashable = "dropdown", cell: bool = True) -> dict:
-        if cell and datacn in self.cell_options and key in self.cell_options[datacn]:
-            return self.cell_options[datacn][key]
-        return {}
+    def get_cell_kwargs(self, datacn: int, key: Hashable | None = "dropdown", cell: bool = True) -> dict:
+        if cell and datacn in self.cell_options:
+            return self.cell_options[datacn] if key is None else self.cell_options[datacn].get(key, {})
+        else:
+            return {}

tksheet/functions.py

@@ -8,13 +8,14 @@ import tkinter as tk
 from bisect import bisect_left
 from collections import deque
 from collections.abc import Callable, Generator, Hashable, Iterable, Iterator, Sequence
+from difflib import SequenceMatcher
 from itertools import islice, repeat
 from typing import Literal
 
 from .colors import color_map
 from .constants import align_value_error, symbols_set
 from .formatters import to_bool
-from .other_classes import Box_nt, DotDict, EventDataDict, Highlight, Loc, Span
+from .other_classes import DotDict, EventDataDict, Highlight, Loc, Span
 from .tksheet_types import AnyIter
 
 unpickle_obj = pickle.loads
@@ -231,50 +232,45 @@ def event_opens_dropdown_or_checkbox(event=None) -> bool:
     )
 
 
-def dropdown_search_function(
-    search_for: object,
-    data: Sequence[object],
-) -> None | int:
+def dropdown_search_function(search_for: str, data: Iterable[object]) -> None | int:
+    search_for = search_for.lower()
     search_len = len(search_for)
-    # search_for in data
-    match_rn = float("inf")
+    if not search_len:
+        return next((i for i, v in enumerate(data) if not str(v)), None)
+
+    matcher = SequenceMatcher(None, search_for, "", autojunk=False)
+
+    match_rn = None
     match_st = float("inf")
     match_len_diff = float("inf")
-    # data in search_for in case no match
-    match_data_rn = float("inf")
-    match_data_st = float("inf")
-    match_data_numchars = 0
-    for rn, row in enumerate(data):
-        dd_val = rf"{row[0]}".lower()
-        # checking if search text is in dropdown row
-        st = dd_val.find(search_for)
-        if st > -1:
-            # priority is start index
-            # if there's already a matching start
-            # then compare the len difference
-            len_diff = len(dd_val) - search_len
+
+    fallback_rn = None
+    fallback_match_length = 0
+    fallback_st = float("inf")
+
+    for rn, value in enumerate(data):
+        value = str(value).lower()
+        if not value:
+            continue
+        st = value.find(search_for)
+        if st != -1:
+            len_diff = len(value) - search_len
             if st < match_st or (st == match_st and len_diff < match_len_diff):
                 match_rn = rn
                 match_st = st
                 match_len_diff = len_diff
-        # fall back in case of no existing match
-        elif match_rn == float("inf"):
-            for numchars in range(2, search_len - 1):
-                for from_idx in range(search_len - 1):
-                    if from_idx + numchars > search_len:
-                        break
-                    st = dd_val.find(search_for[from_idx : from_idx + numchars])
-                    if st > -1 and (
-                        numchars > match_data_numchars or (numchars == match_data_numchars and st < match_data_st)
-                    ):
-                        match_data_rn = rn
-                        match_data_st = st
-                        match_data_numchars = numchars
-    if match_rn != float("inf"):
-        return match_rn
-    elif match_data_rn != float("inf"):
-        return match_data_rn
-    return None
+
+        elif match_rn is None:
+            matcher.set_seq2(value)
+            match = matcher.find_longest_match(0, search_len, 0, len(value))
+            match_length = match.size
+            start = match.b if match_length > 0 else -1
+            if match_length > fallback_match_length or (match_length == fallback_match_length and start < fallback_st):
+                fallback_rn = rn
+                fallback_match_length = match_length
+                fallback_st = start
+
+    return match_rn if match_rn is not None else fallback_rn
 
 
 def float_to_int(f: int | float) -> int | float:
@@ -283,10 +279,6 @@ def float_to_int(f: int | float) -> int | float:
     return int(f)
 
 
-def selection_box_tup_to_dict(box: tuple) -> dict:
-    return {Box_nt(*box[:-1]): box[-1]}
-
-
 def event_dict(
     name: str = None,
     sheet: object = None,
@@ -338,9 +330,7 @@ def event_dict(
         ),
         named_spans=DotDict() if named_spans is None else named_spans,
         options=DotDict(),
-        selection_boxes=(
-            {} if boxes is None else selection_box_tup_to_dict(boxes) if isinstance(boxes, tuple) else boxes
-        ),
+        selection_boxes={} if boxes is None else boxes,
         selected=tuple() if selected is None else selected,
         being_selected=tuple() if being_selected is None else being_selected,
         data=[] if data is None else data,
@@ -409,12 +399,22 @@ def push_n(num: int, sorted_seq: Sequence[int]) -> int:
     if num < sorted_seq[0]:
         return num
     else:
-        for e in sorted_seq:
-            if num >= e:
-                num += 1
-            else:
-                return num
-        return num
+        if (hi := len(sorted_seq)) < 5:
+            for e in sorted_seq:
+                if num >= e:
+                    num += 1
+                else:
+                    return num
+            return num
+        else:
+            lo = 0
+            while lo < hi:
+                mid = (lo + hi) // 2
+                if sorted_seq[mid] < num + mid + 1:
+                    lo = mid + 1
+                else:
+                    hi = mid
+            return num + lo
 
 
 def get_dropdown_kwargs(
@@ -615,14 +615,18 @@ def consecutive_chunks(seq: list[int]) -> Generator[list[int]]:
 
 
 def consecutive_ranges(seq: Sequence[int]) -> Generator[tuple[int, int]]:
-    start = 0
-    for index, value in enumerate(seq, 1):
-        try:
-            if seq[index] > value + 1:
-                yield seq[start], seq[index - 1] + 1
-                start = index
-        except Exception:
-            yield seq[start], seq[-1] + 1
+    seq_iter = iter(seq)
+    try:
+        start = next(seq_iter)
+    except StopIteration:
+        return
+    prev = start
+    for curr in seq_iter:
+        if curr > prev + 1:
+            yield start, prev + 1
+            start = curr
+        prev = curr
+    yield start, prev + 1
 
 
 def is_contiguous(iterable: Iterable[int]) -> bool:
@@ -743,6 +747,17 @@ def move_elements_by_mapping(
     return [seq[old_idxs[i]] if i in old_idxs else next(remaining_values) for i in range(len(seq))]
 
 
+def move_elements_by_mapping_gen(
+    seq: list[object],
+    new_idxs: dict[int, int],
+    old_idxs: dict[int, int] | None = None,
+) -> Generator[object]:
+    if old_idxs is None:
+        old_idxs = dict(zip(new_idxs.values(), new_idxs))
+    remaining_values = (e for i, e in enumerate(seq) if i not in new_idxs)
+    return (seq[old_idxs[i]] if i in old_idxs else next(remaining_values) for i in range(len(seq)))
+
+
 def move_elements_to(
     seq: list[object],
     move_to: int,
@@ -760,10 +775,12 @@ def move_elements_to(
 
 def get_new_indexes(
     move_to: int,
-    to_move: list[int],
+    to_move: AnyIter[int],
     get_inverse: bool = False,
 ) -> tuple[dict]:
     """
+    move_to: A positive int, could possibly be the same as an element of to_move
+    to_move: A sorted list[int], ints always positive and unique, list never empty.
     returns {old idx: new idx, ...}
     """
     offset = sum(1 for i in to_move if i < move_to)
@@ -779,6 +796,11 @@ def insert_items(
     to_insert: dict[int, object],
     seq_len_func: Callable | None = None,
 ) -> list[object]:
+    """
+    seq: list[object]
+    to_insert: keys are ints sorted in reverse, representing list indexes to insert items.
+               Values are any object, e.g. {1: 200, 0: 200}
+    """
     if to_insert:
         if seq_len_func and next(iter(to_insert)) >= len(seq) + len(to_insert):
             seq_len_func(next(iter(to_insert)) - len(to_insert))
@@ -866,24 +888,12 @@ def rounded_box_coords(
     )
 
 
-def diff_list(seq: list[float]) -> list[int]:
-    return [
-        int(b - a)
-        for a, b in zip(
-            seq,
-            islice(seq, 1, None),
-        )
-    ]
-
-
 def diff_gen(seq: list[float]) -> Generator[int]:
-    return (
-        int(b - a)
-        for a, b in zip(
-            seq,
-            islice(seq, 1, None),
-        )
-    )
+    it = iter(seq)
+    a = next(it)
+    for b in it:
+        yield int(b - a)
+        a = b
 
 
 def gen_coords(