tksheet 7.3.3__py3-none-any.whl → 7.4.0__py3-none-any.whl

tksheet/constants.py

@@ -9,6 +9,7 @@ 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}
+_test_str: str = "aiW_-|"
 
 val_modifying_options: set[str] = {"checkbox", "format", "dropdown"}
 
@@ -34,6 +35,18 @@ emitted_events: set[str] = {
     "<<SelectAll>>",
 }
 
+align_helper: dict[str, str] = {
+    "w": "nw",
+    "e": "ne",
+    "center": "n",
+    "n": "center",
+    "nw": "left",
+    "ne": "right",
+}
+
+align_value_error: str = "Align must be one of the following values: c, center, w, nw, west, left, e, ne, east, right"
+font_value_error: str = "Argument must be font, size and 'normal', 'bold' or'italic' e.g. ('Carlito',12,'normal')"
+
 backwards_compatibility_keys: dict[str, str] = {
     "font": "table_font",
 }

tksheet/find_window.py

@@ -1,21 +1,12 @@
 from __future__ import annotations
 
 import tkinter as tk
-from collections.abc import (
-    Callable,
-)
+from collections.abc import Callable
 from typing import Literal
 
-from .other_classes import (
-    DotDict,
-)
-from .constants import (
-    ctrl_key,
-    rc_binding,
-)
-from .functions import (
-    recursive_bind,
-)
+from .constants import ctrl_key, rc_binding
+from .functions import recursive_bind
+from .other_classes import DotDict
 
 
 class FindWindowTkText(tk.Text):

tksheet/functions.py

@@ -5,41 +5,166 @@ import io
 import pickle
 import re
 import tkinter as tk
-from bisect import (
-    bisect_left,
-)
+from bisect import bisect_left
 from collections import deque
-from collections.abc import (
-    Callable,
-    Generator,
-    Hashable,
-    Iterable,
-    Iterator,
-    Sequence,
-)
+from collections.abc import Callable, Generator, Hashable, Iterable, Iterator, Sequence
 from itertools import islice, repeat
 from typing import Literal
 
 from .colors import color_map
-from .constants import (
-    symbols_set,
-)
-from .formatters import (
-    to_bool,
-)
-from .other_classes import (
-    Box_nt,
-    DotDict,
-    EventDataDict,
-    Highlight,
-    Loc,
-    Span,
-)
-from .types import (
-    AnyIter,
-)
+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 .tksheet_types import AnyIter
 
 unpickle_obj = pickle.loads
+lines_re = re.compile(r"[^\n]+")
+
+
+def wrap_text(
+    text: str,
+    max_width: int,
+    max_lines: int,
+    char_width_fn: Callable,
+    widths: dict[str, int],
+    wrap: Literal["", "c", "w"] = "",
+    start_line: int = 0,
+) -> Generator[str]:
+    lines = (match.group() for match in lines_re.finditer(text))
+    current_line = []
+    total_lines = 0
+    line_width = 0
+
+    if not wrap:
+        for line in lines:
+            line_width = 0
+            current_line = []
+            for char in line:
+                char_width = widths.get(char, char_width_fn(char))
+                line_width += char_width
+                if line_width >= max_width:
+                    break
+                current_line.append(char)
+
+            if total_lines >= start_line:
+                yield "".join(current_line)
+
+            # Count the line whether it's empty or not
+            total_lines += 1
+            if total_lines >= max_lines:
+                return
+
+    elif wrap == "c":
+        for line in lines:
+            for char in line:
+                char_width = widths.get(char, char_width_fn(char))
+
+                # adding char to line would result in wrap
+                if line_width + char_width >= max_width:
+                    if total_lines >= start_line:
+                        yield "".join(current_line)
+
+                    total_lines += 1
+                    if total_lines >= max_lines:
+                        return
+                    current_line = []
+                    line_width = 0
+
+                    if char_width <= max_width:
+                        current_line.append(char)
+                        line_width = char_width
+                # adding char to line is okay
+                else:
+                    current_line.append(char)
+                    line_width += char_width
+
+            if total_lines >= start_line:
+                yield "".join(current_line)
+
+            total_lines += 1
+            if total_lines >= max_lines:
+                return
+            current_line = []  # Reset for next line
+            line_width = 0
+
+    elif wrap == "w":
+        space_width = widths.get(" ", char_width_fn(" "))
+
+        for line in lines:
+            words = line.split()
+            for i, word in enumerate(words):
+                # if we're going to next word and
+                # if a space fits on the end of the current line we add one
+                if i and line_width + space_width < max_width:
+                    current_line.append(" ")
+                    line_width += space_width
+
+                # check if word will fit
+                word_width = 0
+                word_char_widths = []
+                for char in word:
+                    word_char_widths.append((w := widths.get(char, char_width_fn(char))))
+                    word_width += w
+
+                # we only wrap by character if the whole word alone wont fit max width
+                # word won't fit at all we resort to char wrapping it
+                if word_width >= max_width:
+                    # yield current line before char wrapping word
+                    if current_line:
+                        if total_lines >= start_line:
+                            yield "".join(current_line)
+
+                        total_lines += 1
+                        if total_lines >= max_lines:
+                            return
+                        current_line = []
+                        line_width = 0
+
+                    for char, w in zip(word, word_char_widths):
+                        # adding char to line would result in wrap
+                        if line_width + w >= max_width:
+                            if total_lines >= start_line:
+                                yield "".join(current_line)
+
+                            total_lines += 1
+                            if total_lines >= max_lines:
+                                return
+                            current_line = []
+                            line_width = 0
+
+                            if w <= max_width:
+                                current_line.append(char)
+                                line_width = w
+                        # adding char to line is okay
+                        else:
+                            current_line.append(char)
+                            line_width += w
+
+                # word won't fit on current line but will fit on a newline
+                elif line_width + word_width >= max_width:
+                    if total_lines >= start_line:
+                        yield "".join(current_line)
+
+                    total_lines += 1
+                    if total_lines >= max_lines:
+                        return
+                    current_line = [word]
+                    line_width = word_width
+
+                # word will fit we put it on the current line
+                else:
+                    current_line.append(word)
+                    line_width += word_width
+
+            if total_lines >= start_line:
+                yield "".join(current_line)
+
+            total_lines += 1
+            if total_lines >= max_lines:
+                return
+
+            current_line = []  # Reset for next line
+            line_width = 0
 
 
 def get_csv_str_dialect(s: str, delimiters: str) -> csv.Dialect:
@@ -183,6 +308,8 @@ def event_dict(
     # resized_header: None, dict] = None,
     being_selected: None | tuple = None,
     named_spans: None | dict = None,
+    sheet_state: None | dict = None,
+    treeview: None | dict = None,
     **kwargs,
 ) -> EventDataDict:
     return EventDataDict(
@@ -208,8 +335,6 @@ def event_dict(
             index=DotDict(),
             column_widths=DotDict(),
             row_heights=DotDict(),
-            displayed_rows=None,
-            displayed_columns=None,
         ),
         named_spans=DotDict() if named_spans is None else named_spans,
         options=DotDict(),
@@ -231,6 +356,12 @@ def event_dict(
             # "index": DotDict() if resized_index is None else resized_index,
         ),
         widget=widget,
+        sheet_state=DotDict() if sheet_state is None else sheet_state,
+        treeview=DotDict(
+            nodes={},
+        )
+        if treeview is None
+        else treeview,
     )
 
 
@@ -258,6 +389,12 @@ def b_index(sorted_seq: Sequence[int], num_to_index: int) -> int:
     return idx
 
 
+def try_b_index(sorted_seq: Sequence[int], num_to_index: int) -> int | None:
+    if (idx := bisect_left(sorted_seq, num_to_index)) == len(sorted_seq) or sorted_seq[idx] != num_to_index:
+        return None
+    return idx
+
+
 def bisect_in(sorted_seq: Sequence[int], num: int) -> bool:
     """
     Faster than 'num in sorted_seq'
@@ -268,6 +405,18 @@ def bisect_in(sorted_seq: Sequence[int], num: int) -> bool:
         return False
 
 
+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
+
+
 def get_dropdown_kwargs(
     values: list = [],
     set_value: object = None,
@@ -638,6 +787,18 @@ def insert_items(
     return seq
 
 
+def del_placeholder_dict_key(
+    d: dict[Hashable, object],
+    k: Hashable,
+    v: object,
+    p: tuple = tuple(),
+) -> dict[Hashable, object]:
+    if p in d:
+        del d[p]
+    d[k] = v
+    return d
+
+
 def data_to_displayed_idxs(
     to_convert: list[int],
     displayed: list[int],
@@ -1412,15 +1573,15 @@ def convert_align(align: str | None) -> str | None:
         a = align.lower()
         if a == "global":
             return None
-        elif a in ("c", "center", "centre"):
-            return "center"
-        elif a in ("w", "west", "left"):
-            return "w"
-        elif a in ("e", "east", "right"):
-            return "e"
+        elif a in ("c", "center", "centre", "n"):
+            return "n"
+        elif a in ("w", "west", "left", "nw"):
+            return "nw"
+        elif a in ("e", "east", "right", "ne"):
+            return "ne"
     elif align is None:
         return None
-    raise ValueError("Align must be one of the following values: c, center, w, west, left, e, east, right")
+    raise ValueError(align_value_error)
 
 
 def set_align(