tksheet 7.4.3__tar.gz → 7.4.5__tar.gz

{tksheet-7.4.3/tksheet.egg-info → tksheet-7.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tksheet
-Version: 7.4.3
+Version: 7.4.5
 Summary: Tkinter table / sheet and treeview widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors
@@ -24,7 +24,9 @@ License: Copyright (c) 2019 ragardner and open source contributors
         SOFTWARE.
         
 Project-URL: Homepage, https://github.com/ragardner/tksheet
-Project-URL: Bug Reports, https://github.com/ragardner/tksheet/issues
+Project-URL: Documentation, https://github.com/ragardner/tksheet/wiki/Version-7
+Project-URL: Changelog, https://github.com/ragardner/tksheet/blob/master/docs/CHANGELOG.md
+Project-URL: Issues, https://github.com/ragardner/tksheet/issues
 Project-URL: Funding, https://github.com/ragardner
 Keywords: tkinter,table,widget,tree,treeview,sheet,grid,tk
 Classifier: Development Status :: 5 - Production/Stable

{tksheet-7.4.3 → tksheet-7.4.5}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "tksheet"
 description = "Tkinter table / sheet and treeview widget"
 readme = "README.md"
-version = "7.4.3"
+version = "7.4.5"
 authors = [{ name = "ragardner", email = "github@ragardner.simplelogin.com" }]
 requires-python = ">=3.8"
 license = {file = "LICENSE.txt"}
@@ -25,9 +25,13 @@ classifiers = [
 ]
 
 [project.urls]
-"Homepage" = "https://github.com/ragardner/tksheet"
-"Bug Reports" = "https://github.com/ragardner/tksheet/issues"
-"Funding" = "https://github.com/ragardner"
+Homepage = "https://github.com/ragardner/tksheet"
+Documentation = "https://github.com/ragardner/tksheet/wiki/Version-7"
+Changelog = "https://github.com/ragardner/tksheet/blob/master/docs/CHANGELOG.md"
+Issues = "https://github.com/ragardner/tksheet/issues"
+Funding = "https://github.com/ragardner"
 
 [tool.ruff]
 line-length = 120
+extend-select = ["I", "F", "C4", "E", "B", "SIM"]
+fix = true

{tksheet-7.4.3 → tksheet-7.4.5}/tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.4.3"
+__version__ = "7.4.5"
 
 from .colors import (
     color_map,
@@ -93,7 +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 natural_sort_key
+from .sorting import fast_sort_key, natural_sort_key, version_sort_key
 from .text_editor import (
     TextEditor,
     TextEditorTkText,

{tksheet-7.4.3 → tksheet-7.4.5}/tksheet/column_headers.py

@@ -89,7 +89,7 @@ class ColumnHeaders(tk.Canvas):
         self.edit_cell_enabled = False
         self.dragged_col = None
         self.visible_col_dividers = {}
-        self.col_height_resize_bbox = tuple()
+        self.col_height_resize_bbox = ()
         self.cell_options = {}
         self.rsz_w = None
         self.rsz_h = None
@@ -255,28 +255,32 @@ class ColumnHeaders(tk.Canvas):
     def shift_b1_press(self, event: object) -> None:
         self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
         c = self.MT.identify_col(x=event.x)
-        if (self.drag_and_drop_enabled or self.col_selection_enabled) and self.rsz_h is None and self.rsz_w is None:
-            if c < len(self.MT.col_positions) - 1:
-                c_selected = self.MT.col_selected(c)
-                if not c_selected and self.col_selection_enabled:
-                    if self.MT.selected and self.MT.selected.type_ == "columns":
-                        r_to_sel, c_to_sel = self.MT.selected.row, self.MT.selected.column
-                        self.MT.deselect("all", redraw=False)
-                        self.being_drawn_item = self.MT.create_selection_box(
-                            *self.get_shift_select_box(c, c_to_sel), "columns"
-                        )
-                        self.MT.set_currently_selected(r_to_sel, c_to_sel, self.being_drawn_item)
-                    else:
-                        self.being_drawn_item = self.select_col(c, run_binding_func=False)
-                    self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
-                    sel_event = self.MT.get_select_event(being_drawn_item=self.being_drawn_item)
-                    try_binding(self.shift_selection_binding_func, sel_event)
-                    self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
-                elif c_selected:
-                    self.dragged_col = DraggedRowColumn(
-                        dragged=c,
-                        to_move=sorted(self.MT.get_selected_cols()),
+        if (
+            (self.drag_and_drop_enabled or self.col_selection_enabled)
+            and self.rsz_h is None
+            and self.rsz_w is None
+            and c < len(self.MT.col_positions) - 1
+        ):
+            c_selected = self.MT.col_selected(c)
+            if not c_selected and self.col_selection_enabled:
+                if self.MT.selected and self.MT.selected.type_ == "columns":
+                    r_to_sel, c_to_sel = self.MT.selected.row, self.MT.selected.column
+                    self.MT.deselect("all", redraw=False)
+                    self.being_drawn_item = self.MT.create_selection_box(
+                        *self.get_shift_select_box(c, c_to_sel), "columns"
                     )
+                    self.MT.set_currently_selected(r_to_sel, c_to_sel, self.being_drawn_item)
+                else:
+                    self.being_drawn_item = self.select_col(c, run_binding_func=False)
+                self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
+                sel_event = self.MT.get_select_event(being_drawn_item=self.being_drawn_item)
+                try_binding(self.shift_selection_binding_func, sel_event)
+                self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
+            elif c_selected:
+                self.dragged_col = DraggedRowColumn(
+                    dragged=c,
+                    to_move=sorted(self.MT.get_selected_cols()),
+                )
 
     def get_shift_select_box(self, c: int, min_c: int) -> tuple[int, int, int, int, str]:
         if c >= min_c:
@@ -351,12 +355,11 @@ class ColumnHeaders(tk.Canvas):
                         self.rsz_h = None
                 except Exception:
                     self.rsz_h = None
-            if not mouse_over_resize:
-                if self.MT.col_selected(self.MT.identify_col(event, allow_end=False)):
-                    mouse_over_selected = True
-                    if self.MT.current_cursor != "hand2":
-                        self.config(cursor="hand2")
-                        self.MT.current_cursor = "hand2"
+            if not mouse_over_resize and self.MT.col_selected(self.MT.identify_col(event, allow_end=False)):
+                mouse_over_selected = True
+                if self.MT.current_cursor != "hand2":
+                    self.config(cursor="hand2")
+                    self.MT.current_cursor = "hand2"
             if not mouse_over_resize and not mouse_over_selected:
                 self.MT.reset_mouse_motion_creations()
         try_binding(self.extra_motion_func, event)
@@ -718,23 +721,19 @@ class ColumnHeaders(tk.Canvas):
             self.MT.set_xviews("moveto", 1)
 
     def event_over_dropdown(self, c: int, datacn: int, event: object, canvasx: float) -> bool:
-        if (
+        return (
             event.y < self.MT.header_txt_height + 5
             and self.get_cell_kwargs(datacn, key="dropdown")
             and canvasx < self.MT.col_positions[c + 1]
             and canvasx > self.MT.col_positions[c + 1] - self.MT.header_txt_height - 4
-        ):
-            return True
-        return False
+        )
 
     def event_over_checkbox(self, c: int, datacn: int, event: object, canvasx: float) -> bool:
-        if (
+        return (
             event.y < self.MT.header_txt_height + 5
             and self.get_cell_kwargs(datacn, key="checkbox")
             and canvasx < self.MT.col_positions[c] + self.MT.header_txt_height + 4
-        ):
-            return True
-        return False
+        )
 
     def drag_width_resize(self) -> None:
         new_col_pos = int(self.coords("rwl")[0])
@@ -874,6 +873,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 +924,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(
@@ -1179,10 +1182,7 @@ class ColumnHeaders(tk.Canvas):
         # table
         if self.MT.data:
             if self.MT.all_rows_displayed:
-                if visible_only:
-                    iterable = range(*self.MT.visible_text_rows)
-                else:
-                    iterable = range(0, len(self.MT.data))
+                iterable = range(*self.MT.visible_text_rows) if visible_only else range(0, len(self.MT.data))
             else:
                 if visible_only:
                     start_row, end_row = self.MT.visible_text_rows
@@ -1199,11 +1199,13 @@ class ColumnHeaders(tk.Canvas):
                     qconf(qtxtm, text=txt, font=qfont)
                     b = qbbox(qtxtm)
                     if (
-                        self.MT.get_cell_kwargs(datarn, datacn, key="dropdown")
-                        or self.MT.get_cell_kwargs(datarn, datacn, key="checkbox")
-                    ) and (tw := b[2] - b[0] + qtxth + 7) > w:
-                        w = tw
-                    elif (tw := b[2] - b[0] + 7) > w:
+                        (
+                            self.MT.get_cell_kwargs(datarn, datacn, key="dropdown")
+                            or self.MT.get_cell_kwargs(datarn, datacn, key="checkbox")
+                        )
+                        and (tw := b[2] - b[0] + qtxth + 7) > w
+                        or (tw := b[2] - b[0] + 7) > w
+                    ):
                         w = tw
         if hw > w:
             w = hw
@@ -1512,9 +1514,8 @@ class ColumnHeaders(tk.Canvas):
         col_pos_exists: bool,
         set_scrollregion: bool,
     ) -> bool:
-        if set_scrollregion:
-            if not self.configure_scrollregion(last_col_line_pos=last_col_line_pos):
-                return False
+        if set_scrollregion and not self.configure_scrollregion(last_col_line_pos=last_col_line_pos):
+            return False
         self.hidd_text.update(self.disp_text)
         self.disp_text = {}
         self.hidd_high.update(self.disp_high)
@@ -1630,7 +1631,7 @@ class ColumnHeaders(tk.Canvas):
             if not text:
                 continue
             max_lines = int((self.current_height - top - 2) / txt_h)
-            for text in wrap_text(
+            for wrapped in wrap_text(
                 text=text,
                 max_width=max_width,
                 max_lines=max_lines,
@@ -1644,7 +1645,7 @@ class ColumnHeaders(tk.Canvas):
                     if showing:
                         self.itemconfig(
                             iid,
-                            text=text,
+                            text=wrapped,
                             fill=fill,
                             font=font,
                             anchor=align,
@@ -1652,7 +1653,7 @@ class ColumnHeaders(tk.Canvas):
                     else:
                         self.itemconfig(
                             iid,
-                            text=text,
+                            text=wrapped,
                             fill=fill,
                             font=font,
                             anchor=align,
@@ -1663,7 +1664,7 @@ class ColumnHeaders(tk.Canvas):
                     iid = self.create_text(
                         draw_x,
                         draw_y,
-                        text=text,
+                        text=wrapped,
                         fill=fill,
                         font=font,
                         anchor=align,
@@ -1791,7 +1792,7 @@ class ColumnHeaders(tk.Canvas):
             self.text_editor.set_text(self.text_editor.get() + "" if not isinstance(text, str) else text)
             return False
         self.hide_text_editor()
-        if not self.MT.see(r=0, c=c, keep_yscroll=True, check_cell_visibility=True):
+        if not self.MT.see(0, c, keep_yscroll=True):
             self.MT.main_table_redraw_grid_and_text(True, True)
         x = self.MT.col_positions[c] + 1
         y = 0
@@ -2239,16 +2240,18 @@ 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):
-            return False
-        kwargs = self.get_cell_kwargs(datacn, key="dropdown")
-        if kwargs and kwargs["validate_input"] and value not in kwargs["values"]:
-            return False
-        return True
+        else:
+            return not (
+                self.cell_equal_to(datacn, value)
+                or (kwargs := kwargs.get("dropdown", {}))
+                and kwargs["validate_input"]
+                and value not in kwargs["values"]
+            )
 
     def cell_equal_to(self, datacn: int, value: object) -> bool:
         self.fix_header(datacn)
@@ -2303,12 +2306,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 +2380,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-7.4.3 → tksheet-7.4.5}/tksheet/constants.py

@@ -7,8 +7,8 @@ ctrl_key: str = "Command" if USER_OS == "darwin" else "Control"
 rc_binding: str = "<2>" if USER_OS == "darwin" else "<3>"
 symbols_set: set[str] = set("""!#$%&'()*+,-./:;"@[]^_`{|}~>?= \\""")
 nonelike: set[object] = {None, "none", ""}
-truthy: set[object] = {True, "true", "t", "yes", "y", "on", "1", 1, 1.0}
-falsy: set[object] = {False, "false", "f", "no", "n", "off", "0", 0, 0.0}
+truthy: set[object] = {True, "true", "t", "yes", "y", "on", "1"}
+falsy: set[object] = {False, "false", "f", "no", "n", "off", "0"}
 _test_str: str = "aiW_-|"
 
 val_modifying_options: set[str] = {"checkbox", "format", "dropdown"}

{tksheet-7.4.3 → tksheet-7.4.5}/tksheet/formatters.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
 from collections.abc import Callable
+from contextlib import suppress
 
 from .constants import falsy, nonelike, truthy
 
 
 def is_none_like(o: object) -> bool:
-    if (isinstance(o, str) and o.lower().replace(" ", "") in nonelike) or o in nonelike:
-        return True
-    return False
+    return (isinstance(o, str) and o.lower().replace(" ", "") in nonelike) or o in nonelike
 
 
 def to_int(o: object, **kwargs) -> int:
@@ -42,18 +41,9 @@ def alt_to_percentage(o: object, **kwargs) -> float:
 def to_bool(val: object, **kwargs) -> bool:
     if isinstance(val, bool):
         return val
-    if isinstance(val, str):
-        v = val.lower()
-    else:
-        v = val
-    if "truthy" in kwargs:
-        _truthy = kwargs["truthy"]
-    else:
-        _truthy = truthy
-    if "falsy" in kwargs:
-        _falsy = kwargs["falsy"]
-    else:
-        _falsy = falsy
+    v = val.lower() if isinstance(val, str) else val
+    _truthy = kwargs.get("truthy", truthy)
+    _falsy = kwargs.get("falsy", falsy)
     if v in _truthy:
         return True
     elif v in _falsy:
@@ -191,16 +181,16 @@ def formatter(
     **kwargs,
 ) -> dict:
     return {
-        **dict(
-            datatypes=datatypes,
-            format_function=format_function,
-            to_str_function=to_str_function,
-            invalid_value=invalid_value,
-            nullable=nullable,
-            pre_format_function=pre_format_function,
-            post_format_function=post_format_function,
-            clipboard_function=clipboard_function,
-        ),
+        **{
+            "datatypes": datatypes,
+            "format_function": format_function,
+            "to_str_function": to_str_function,
+            "invalid_value": invalid_value,
+            "nullable": nullable,
+            "pre_format_function": pre_format_function,
+            "post_format_function": post_format_function,
+            "clipboard_function": clipboard_function,
+        },
         **kwargs,
     }
 
@@ -219,10 +209,8 @@ def format_data(
     if nullable and is_none_like(value):
         value = None
     else:
-        try:
+        with suppress(Exception):
             value = format_function(value, **kwargs)
-        except Exception:
-            pass
     if post_format_function and isinstance(value, datatypes):
         value = post_format_function(value)
     return value
@@ -243,7 +231,7 @@ def data_to_str(
     return to_str_function(value, **kwargs)
 
 
-def get_data_with_valid_check(value="", datatypes: tuple[()] | tuple[object] | object = tuple(), invalid_value="NA"):
+def get_data_with_valid_check(value="", datatypes: tuple[()] | tuple[object] | object = (), invalid_value="NA"):
     if isinstance(value, datatypes):
         return value
     return invalid_value
@@ -274,12 +262,10 @@ class Formatter:
     ) -> None:
         if nullable:
             if isinstance(datatypes, (list, tuple)):
-                datatypes = tuple({type_ for type_ in datatypes} | {type(None)})
+                datatypes = tuple(set(datatypes) | {type(None)})
             else:
                 datatypes = (datatypes, type(None))
-        elif isinstance(datatypes, (list, tuple)) and type(None) in datatypes:
-            raise TypeError("Non-nullable cells cannot have NoneType as a datatype.")
-        elif datatypes is type(None):
+        elif isinstance(datatypes, (list, tuple)) and type(None) in datatypes or datatypes is type(None):
             raise TypeError("Non-nullable cells cannot have NoneType as a datatype.")
         self.kwargs = kwargs
         self.valid_datatypes = datatypes
@@ -305,9 +291,7 @@ class Formatter:
     def valid(self, value: object = None) -> bool:
         if value is None:
             value = self.value
-        if isinstance(value, self.valid_datatypes):
-            return True
-        return False
+        return isinstance(value, self.valid_datatypes)
 
     def format_data(self, value: object) -> object:
         if self.pre_format_function:

{tksheet-7.4.3 → tksheet-7.4.5}/tksheet/functions.py

@@ -15,7 +15,7 @@ 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
@@ -279,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,
@@ -334,15 +330,13 @@ 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
-        ),
-        selected=tuple() if selected is None else selected,
-        being_selected=tuple() if being_selected is None else being_selected,
+        selection_boxes={} if boxes is None else boxes,
+        selected=() if selected is None else selected,
+        being_selected=() if being_selected is None else being_selected,
         data=[] if data is None else data,
         key="" if key is None else key,
         value=None if value is None else value,
-        loc=tuple() if loc is None else loc,
+        loc=() if loc is None else loc,
         row=row,
         column=column,
         resized=DotDict(
@@ -424,7 +418,7 @@ def push_n(num: int, sorted_seq: Sequence[int]) -> int:
 
 
 def get_dropdown_kwargs(
-    values: list = [],
+    values: list[object] | None = None,
     set_value: object = None,
     state: str = "normal",
     redraw: bool = True,
@@ -435,7 +429,7 @@ def get_dropdown_kwargs(
     text: None | str = None,
 ) -> dict:
     return {
-        "values": values,
+        "values": [] if values is None else values,
         "set_value": set_value,
         "state": state,
         "redraw": redraw,
@@ -753,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,
@@ -770,15 +775,16 @@ def move_elements_to(
 
 def get_new_indexes(
     move_to: int,
-    to_move: list[int],
+    to_move: Iterable[int],
     get_inverse: bool = False,
-) -> tuple[dict]:
+) -> tuple[dict[int, int]] | dict[int, int]:
     """
+    move_to: A positive int, could possibly be the same as an element of to_move
+    to_move: An iterable of ints, could be a dict, could be in any order
     returns {old idx: new idx, ...}
     """
     offset = sum(1 for i in to_move if i < move_to)
-    new_idxs = range(move_to - offset, move_to - offset + len(to_move))
-    new_idxs = {old: new for old, new in zip(to_move, new_idxs)}
+    new_idxs = dict(zip(to_move, range(move_to - offset, move_to - offset + len(to_move))))
     if get_inverse:
         return new_idxs, dict(zip(new_idxs.values(), new_idxs))
     return new_idxs
@@ -789,6 +795,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))
@@ -801,7 +812,7 @@ def del_placeholder_dict_key(
     d: dict[Hashable, object],
     k: Hashable,
     v: object,
-    p: tuple = tuple(),
+    p: tuple = (),
 ) -> dict[Hashable, object]:
     if p in d:
         del d[p]
@@ -876,24 +887,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(
@@ -1505,14 +1504,8 @@ def span_ranges(
 ) -> tuple[Generator[int], Generator[int]]:
     rng_from_r = 0 if span.from_r is None else span.from_r
     rng_from_c = 0 if span.from_c is None else span.from_c
-    if span.upto_r is None:
-        rng_upto_r = totalrows() if isinstance(totalrows, Callable) else totalrows
-    else:
-        rng_upto_r = span.upto_r
-    if span.upto_c is None:
-        rng_upto_c = totalcols() if isinstance(totalcols, Callable) else totalcols
-    else:
-        rng_upto_c = span.upto_c
+    rng_upto_r = (totalrows() if isinstance(totalrows, Callable) else totalrows) if span.upto_r is None else span.upto_r
+    rng_upto_c = (totalcols() if isinstance(totalcols, Callable) else totalcols) if span.upto_c is None else span.upto_c
     return range(rng_from_r, rng_upto_r), range(rng_from_c, rng_upto_c)
 
 
@@ -1674,10 +1667,7 @@ def span_idxs_post_move(
         newupto_colrange = newupto
     else:
         oldfrom = int(span[f"from_{axis}"])
-        if not oldfrom:
-            newfrom = 0
-        else:
-            newfrom = full_new_idxs[oldfrom]
+        newfrom = 0 if not oldfrom else full_new_idxs[oldfrom]
         newupto = None
         oldupto_colrange = total
         newupto_colrange = oldupto_colrange