tksheet 7.4.5__py3-none-any.whl → 7.4.7__py3-none-any.whl

tksheet/functions.py

@@ -10,7 +10,7 @@ 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 typing import Any, Literal
 
 from .colors import color_map
 from .constants import align_value_error, symbols_set
@@ -20,6 +20,7 @@ from .tksheet_types import AnyIter
 
 unpickle_obj = pickle.loads
 lines_re = re.compile(r"[^\n]+")
+ORD_A = ord("A")
 
 
 def wrap_text(
@@ -202,7 +203,7 @@ def recursive_bind(widget: tk.Misc, event: str, callback: Callable) -> None:
         recursive_bind(child, event, callback)
 
 
-def tksheet_type_error(kwarg: str, valid_types: list[str], not_type: object) -> str:
+def tksheet_type_error(kwarg: str, valid_types: list[str], not_type: Any) -> str:
     valid_types = ", ".join(f"{type_}" for type_ in valid_types)
     return f"Argument '{kwarg}' must be one of the following types: {valid_types}, not {type(not_type)}."
 
@@ -213,7 +214,7 @@ def new_tk_event(keysym: str) -> tk.Event:
     return event
 
 
-def event_has_char_key(event: object) -> bool:
+def event_has_char_key(event: Any) -> bool:
     return (
         event and hasattr(event, "char") and (event.char.isalpha() or event.char.isdigit() or event.char in symbols_set)
     )
@@ -232,7 +233,7 @@ def event_opens_dropdown_or_checkbox(event=None) -> bool:
     )
 
 
-def dropdown_search_function(search_for: str, data: Iterable[object]) -> None | int:
+def dropdown_search_function(search_for: str, data: Iterable[Any]) -> None | int:
     search_for = search_for.lower()
     search_len = len(search_for)
     if not search_len:
@@ -281,16 +282,16 @@ def float_to_int(f: int | float) -> int | float:
 
 def event_dict(
     name: str = None,
-    sheet: object = None,
+    sheet: Any = None,
     widget: tk.Canvas | None = None,
     boxes: None | dict | tuple = None,
     cells_table: None | dict = None,
     cells_header: None | dict = None,
     cells_index: None | dict = None,
     selected: None | tuple = None,
-    data: object = None,
+    data: Any = None,
     key: None | str = None,
-    value: object = None,
+    value: Any = None,
     loc: None | int | tuple[int] = None,
     row: None | int = None,
     column: None | int = None,
@@ -366,7 +367,8 @@ def stored_event_dict(d: DotDict) -> DotDict:
 def len_to_idx(n: int) -> int:
     if n < 1:
         return 0
-    return n - 1
+    else:
+        return n - 1
 
 
 def b_index(sorted_seq: Sequence[int], num_to_index: int) -> int:
@@ -376,13 +378,15 @@ def b_index(sorted_seq: Sequence[int], num_to_index: int) -> int:
     """
     if (idx := bisect_left(sorted_seq, num_to_index)) == len(sorted_seq) or sorted_seq[idx] != num_to_index:
         raise ValueError(f"{num_to_index} is not in Sequence")
-    return idx
+    else:
+        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
+    else:
+        return idx
 
 
 def bisect_in(sorted_seq: Sequence[int], num: int) -> bool:
@@ -399,27 +403,20 @@ def push_n(num: int, sorted_seq: Sequence[int]) -> int:
     if num < sorted_seq[0]:
         return num
     else:
-        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
+        hi = len(sorted_seq)
+        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(
-    values: list[object] | None = None,
-    set_value: object = None,
+    values: list[Any] | None = None,
+    set_value: Any = None,
     state: str = "normal",
     redraw: bool = True,
     selection_function: Callable | None = None,
@@ -477,7 +474,7 @@ def get_checkbox_dict(**kwargs) -> dict:
     }
 
 
-def is_iterable(o: object) -> bool:
+def is_iterable(o: Any) -> bool:
     if isinstance(o, str):
         return False
     try:
@@ -499,7 +496,7 @@ def int_x_tuple(i: AnyIter[int] | int) -> tuple[int]:
     return tuple(i)
 
 
-def unpack(t: tuple[object] | tuple[AnyIter[object]]) -> tuple[object]:
+def unpack(t: tuple[Any] | tuple[AnyIter[Any]]) -> tuple[Any]:
     if not len(t):
         return t
     if is_iterable(t[0]) and len(t) == 1:
@@ -507,11 +504,11 @@ def unpack(t: tuple[object] | tuple[AnyIter[object]]) -> tuple[object]:
     return t
 
 
-def is_type_int(o: object) -> bool:
+def is_type_int(o: Any) -> bool:
     return isinstance(o, int) and not isinstance(o, bool)
 
 
-def force_bool(o: object) -> bool:
+def force_bool(o: Any) -> bool:
     try:
         return to_bool(o)
     except Exception:
@@ -521,9 +518,8 @@ def force_bool(o: object) -> bool:
 def alpha2idx(a: str) -> int | None:
     try:
         n = 0
-        orda = ord("A")
         for c in a.upper():
-            n = n * 26 + ord(c) - orda + 1
+            n = n * 26 + ord(c) - ORD_A + 1
         return n - 1
     except Exception:
         return None
@@ -702,8 +698,8 @@ def cell_right_within_box(
 
 
 def get_last(
-    it: AnyIter[object],
-) -> object:
+    it: AnyIter[Any],
+) -> Any:
     if hasattr(it, "__reversed__"):
         try:
             return next(reversed(it))
@@ -716,7 +712,7 @@ def get_last(
             return None
 
 
-def index_exists(seq: Sequence[object], index: int) -> bool:
+def index_exists(seq: Sequence[Any], index: int) -> bool:
     try:
         seq[index]
         return True
@@ -733,10 +729,10 @@ def add_to_displayed(displayed: list[int], to_add: Iterable[int]) -> list[int]:
 
 
 def move_elements_by_mapping(
-    seq: list[object],
+    seq: list[Any],
     new_idxs: dict[int, int],
     old_idxs: dict[int, int] | None = None,
-) -> list[object]:
+) -> list[Any]:
     # move elements of a list around
     # displacing other elements based on mapping
     # new_idxs = {old index: new index, ...}
@@ -748,10 +744,10 @@ def move_elements_by_mapping(
 
 
 def move_elements_by_mapping_gen(
-    seq: list[object],
+    seq: list[Any],
     new_idxs: dict[int, int],
     old_idxs: dict[int, int] | None = None,
-) -> Generator[object]:
+) -> Generator[Any]:
     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)
@@ -759,10 +755,10 @@ def move_elements_by_mapping_gen(
 
 
 def move_elements_to(
-    seq: list[object],
+    seq: list[Any],
     move_to: int,
     to_move: list[int],
-) -> list[object]:
+) -> list[Any]:
     return move_elements_by_mapping(
         seq,
         *get_new_indexes(
@@ -791,14 +787,14 @@ def get_new_indexes(
 
 
 def insert_items(
-    seq: list[object],
-    to_insert: dict[int, object],
+    seq: list[Any],
+    to_insert: dict[int, Any],
     seq_len_func: Callable | None = None,
-) -> list[object]:
+) -> list[Any]:
     """
-    seq: list[object]
+    seq: list[Any]
     to_insert: keys are ints sorted in reverse, representing list indexes to insert items.
-               Values are any object, e.g. {1: 200, 0: 200}
+               Values are any, e.g. {1: 200, 0: 200}
     """
     if to_insert:
         if seq_len_func and next(iter(to_insert)) >= len(seq) + len(to_insert):
@@ -809,11 +805,11 @@ def insert_items(
 
 
 def del_placeholder_dict_key(
-    d: dict[Hashable, object],
+    d: dict[Hashable, Any],
     k: Hashable,
-    v: object,
+    v: Any,
     p: tuple = (),
-) -> dict[Hashable, object]:
+) -> dict[Hashable, Any]:
     if p in d:
         del d[p]
     d[k] = v
@@ -994,7 +990,7 @@ def is_last_cell(
     return row == end_row - 1 and col == end_col - 1
 
 
-def zip_fill_2nd_value(x: AnyIter[object], o: object) -> Generator[object, object]:
+def zip_fill_2nd_value(x: AnyIter[Any], o: Any) -> Generator[Any, Any]:
     return zip(x, repeat(o))
 
 
@@ -1011,7 +1007,7 @@ def str_to_int(s: str) -> int | None:
 
 def gen_formatted(
     options: dict,
-    formatter: object = None,
+    formatter: Any = None,
 ) -> Generator[tuple[int, int]] | Generator[int]:
     if formatter is None:
         return (k for k, dct in options.items() if "format" in dct)
@@ -1060,7 +1056,7 @@ def span_dict(
     convert: Callable | None = None,
     undo: bool = False,
     emit_event: bool = False,
-    widget: object = None,
+    widget: Any = None,
 ) -> Span:
     d: Span = Span(
         from_r=from_r,
@@ -1087,7 +1083,7 @@ def span_dict(
 
 
 def coords_to_span(
-    widget: object,
+    widget: Any,
     from_r: int | None = None,
     from_c: int | None = None,
     upto_r: int | None = None,
@@ -1112,6 +1108,37 @@ def coords_to_span(
     )
 
 
+PATTERN_ROW = re.compile(r"^(\d+)$")  # "1"
+PATTERN_COL = re.compile(r"^([A-Z]+)$")  # "A"
+PATTERN_CELL = re.compile(r"^([A-Z]+)(\d+)$")  # "A1"
+PATTERN_RANGE = re.compile(r"^([A-Z]+)(\d+):([A-Z]+)(\d+)$")  # "A1:B2"
+PATTERN_ROW_RANGE = re.compile(r"^(\d+):(\d+)$")  # "1:2"
+PATTERN_ROW_START = re.compile(r"^(\d+):$")  # "2:"
+PATTERN_ROW_END = re.compile(r"^:(\d+)$")  # ":2"
+PATTERN_COL_RANGE = re.compile(r"^([A-Z]+):([A-Z]+)$")  # "A:B"
+PATTERN_COL_START = re.compile(r"^([A-Z]+):$")  # "A:"
+PATTERN_COL_END = re.compile(r"^:([A-Z]+)$")  # ":B"
+PATTERN_CELL_START = re.compile(r"^([A-Z]+)(\d+):$")  # "A1:"
+PATTERN_CELL_END = re.compile(r"^:([A-Z]+)(\d+)$")  # ":B1"
+PATTERN_CELL_COL = re.compile(r"^([A-Z]+)(\d+):([A-Z]+)$")  # "A1:B"
+PATTERN_CELL_ROW = re.compile(r"^([A-Z]+)(\d+):(\d+)$")  # "A1:2"
+PATTERN_ALL = re.compile(r"^:$")  # ":"
+
+
+def span_a2i(a: str) -> int | None:
+    n = 0
+    for c in a:
+        n = n * 26 + ord(c) - ORD_A + 1
+    return n - 1
+
+
+def span_a2n(a: str) -> int | None:
+    n = 0
+    for c in a:
+        n = n * 26 + ord(c) - ORD_A + 1
+    return n
+
+
 def key_to_span(
     key: (
         str
@@ -1122,78 +1149,34 @@ def key_to_span(
         | Sequence[Sequence[int | None, int | None], Sequence[int | None, int | None]]
     ),
     spans: dict[str, Span],
-    widget: object = None,
+    widget: Any = None,
 ) -> Span:
+    """
+    Convert various input types to a Span object representing a 2D range.
+
+    Args:
+        key: The input to convert (str, int, slice, sequence, or None).
+        spans: A dictionary of named spans (e.g., {"<name>": Span(...)}).
+        widget: Optional widget context for span creation.
+
+    Returns:
+        A Span object or an error message string if the key is invalid.
+    """
+    # Handle Span object directly
     if isinstance(key, Span):
         return key
+
+    # Handle None as full span
     elif key is None:
-        key = (None, None, None, None)
+        return coords_to_span(widget=widget, from_r=None, from_c=None, upto_r=None, upto_c=None)
+
+    # Validate input type
     elif not isinstance(key, (str, int, slice, list, tuple)):
-        return f"Key type must be either str, int, list, tuple or slice, not '{type(key)}'."
+        return f"Key type must be either str, int, list, tuple or slice, not '{type(key).__name__}'."
+
     try:
-        if isinstance(key, (list, tuple)):
-            if isinstance(key[0], int) or key[0] is None:
-                if len(key) == 2:
-                    """
-                    (int | None, int | None) -
-                    (0, 0) - row 0, column 0 - the first cell
-                    (0, None) - row 0, all columns
-                    (None, 0) - column 0, all rows
-                    """
-                    return span_dict(
-                        from_r=key[0] if isinstance(key[0], int) else 0,
-                        from_c=key[1] if isinstance(key[1], int) else 0,
-                        upto_r=(key[0] + 1) if isinstance(key[0], int) else None,
-                        upto_c=(key[1] + 1) if isinstance(key[1], int) else None,
-                        widget=widget,
-                    )
-
-                elif len(key) == 4:
-                    """
-                    (int | None, int | None, int | None, int | None) -
-                    (from row,  from column, up to row, up to column)
-                    """
-                    return coords_to_span(
-                        widget=widget,
-                        from_r=key[0],
-                        from_c=key[1],
-                        upto_r=key[2],
-                        upto_c=key[3],
-                    )
-                    # return span_dict(
-                    #     from_r=key[0] if isinstance(key[0], int) else 0,
-                    #     from_c=key[1] if isinstance(key[1], int) else 0,
-                    #     upto_r=key[2] if isinstance(key[2], int) else None,
-                    #     upto_c=key[3] if isinstance(key[3], int) else None,
-                    #     widget=widget,
-                    # )
-
-            elif isinstance(key[0], (list, tuple)):
-                """
-                ((int | None, int | None), (int | None, int | None))
-
-                First Sequence is start row and column
-                Second Sequence is up to but not including row and column
-                """
-                return coords_to_span(
-                    widget=widget,
-                    from_r=key[0][0],
-                    from_c=key[0][1],
-                    upto_r=key[1][0],
-                    upto_c=key[1][1],
-                )
-                # return span_dict(
-                #     from_r=key[0][0] if isinstance(key[0][0], int) else 0,
-                #     from_c=key[0][1] if isinstance(key[0][1], int) else 0,
-                #     upto_r=key[1][0],
-                #     upto_c=key[1][1],
-                #     widget=widget,
-                # )
-
-        elif isinstance(key, int):
-            """
-            [int] - Whole row at that index
-            """
+        # Integer key: whole row
+        if isinstance(key, int):
             return span_dict(
                 from_r=key,
                 from_c=None,
@@ -1202,29 +1185,8 @@ def key_to_span(
                 widget=widget,
             )
 
+        # Slice key: row range
         elif isinstance(key, slice):
-            """
-            [slice]
-            """
-            """
-            [:] - All rows
-            """
-            if key.start is None and key.stop is None:
-                """
-                [:]
-                """
-                return span_dict(
-                    from_r=0,
-                    from_c=None,
-                    upto_r=None,
-                    upto_c=None,
-                    widget=widget,
-                )
-            """
-            [1:3] - Rows 1, 2
-            [:2] - Rows up to but not including 2
-            [2:] - Rows starting from and including 2
-            """
             start = 0 if key.start is None else key.start
             return span_dict(
                 from_r=start,
@@ -1234,251 +1196,187 @@ def key_to_span(
                 widget=widget,
             )
 
+        # Sequence key: various span formats
+        elif isinstance(key, (list, tuple)):
+            if (
+                len(key) == 2
+                and (isinstance(key[0], int) or key[0] is None)
+                and (isinstance(key[1], int) or key[1] is None)
+            ):
+                # Single cell or partial span: (row, col)
+                r_int = isinstance(key[0], int)
+                c_int = isinstance(key[1], int)
+                return span_dict(
+                    from_r=key[0] if r_int else 0,
+                    from_c=key[1] if c_int else 0,
+                    upto_r=key[0] + 1 if r_int else None,
+                    upto_c=key[1] + 1 if c_int else None,
+                    widget=widget,
+                )
+            elif len(key) == 4:
+                # Full span coordinates: (from_r, from_c, upto_r, upto_c)
+                return coords_to_span(
+                    widget=widget,
+                    from_r=key[0],
+                    from_c=key[1],
+                    upto_r=key[2],
+                    upto_c=key[3],
+                )
+            elif len(key) == 2 and all(isinstance(k, (list, tuple)) for k in key):
+                # Start and end points: ((from_r, from_c), (upto_r, upto_c))
+                return coords_to_span(
+                    widget=widget,
+                    from_r=key[0][0],
+                    from_c=key[0][1],
+                    upto_r=key[1][0],
+                    upto_c=key[1][1],
+                )
+
+        # String key: parse various span formats
         elif isinstance(key, str):
             if not key:
-                key = ":"
-
-            if key.startswith("<") and key.endswith(">"):
-                if (key := key[1:-1]) in spans:
-                    """
-                    ["<name>"] - Surrounded by "<" ">" cells from a named range
-                    """
-                    return spans[key]
-                return f"'{key}' not in named spans."
-
-            key = key.upper()
-
-            if key.isdigit():
-                """
-                ["1"] - Row 0
-                """
+                # Empty string treated as full span
                 return span_dict(
-                    from_r=int(key) - 1,
+                    from_r=0,
                     from_c=None,
-                    upto_r=int(key),
+                    upto_r=None,
                     upto_c=None,
                     widget=widget,
                 )
+            elif key.startswith("<") and key.endswith(">"):
+                name = key[1:-1]
+                return spans.get(name, f"'{name}' not in named spans.")
+
+            key = key.upper()  # Case-insensitive parsing
 
-            if key.isalpha():
-                """
-                ["A"] - Column 0
-                """
+            # Match string against precompiled patterns
+            if m := PATTERN_ROW.match(key):
+                return span_dict(
+                    from_r=int(m[1]) - 1,
+                    from_c=None,
+                    upto_r=int(m[1]),
+                    upto_c=None,
+                    widget=widget,
+                )
+            elif m := PATTERN_COL.match(key):
                 return span_dict(
                     from_r=None,
-                    from_c=alpha2idx(key),
+                    from_c=span_a2i(m[1]),
                     upto_r=None,
-                    upto_c=alpha2idx(key) + 1,
+                    upto_c=span_a2n(m[1]),
                     widget=widget,
                 )
-
-            splitk = key.split(":")
-            if len(splitk) > 2:
-                return f"'{key}' could not be converted to span."
-
-            if len(splitk) == 1 and not splitk[0].isdigit() and not splitk[0].isalpha() and not splitk[0][0].isdigit():
-                """
-                ["A1"] - Cell (0, 0)
-                """
-                keys_digits = re.search(r"\d", splitk[0])
-                if keys_digits:
-                    digits_start = keys_digits.start()
-                    if not digits_start:
-                        return f"'{key}' could not be converted to span."
-                    if digits_start:
-                        key_row = splitk[0][digits_start:]
-                        key_column = splitk[0][:digits_start]
-                        return span_dict(
-                            from_r=int(key_row) - 1,
-                            from_c=alpha2idx(key_column),
-                            upto_r=int(key_row),
-                            upto_c=alpha2idx(key_column) + 1,
-                            widget=widget,
-                        )
-
-            if not splitk[0] and not splitk[1]:
-                """
-                [":"] - All rows
-                """
+            elif m := PATTERN_CELL.match(key):
+                c = span_a2i(m[1])
+                r = int(m[2]) - 1
                 return span_dict(
-                    from_r=0,
-                    from_c=None,
-                    upto_r=None,
-                    upto_c=None,
+                    from_r=r,
+                    from_c=c,
+                    upto_r=r + 1,
+                    upto_c=c + 1,
                     widget=widget,
                 )
-
-            if splitk[0].isdigit() and not splitk[1]:
-                """
-                ["2:"] - Rows starting from and including 1
-                """
+            elif m := PATTERN_RANGE.match(key):
+                return span_dict(
+                    from_r=int(m[2]) - 1,
+                    from_c=span_a2i(m[1]),
+                    upto_r=int(m[4]),
+                    upto_c=span_a2n(m[3]),
+                    widget=widget,
+                )
+            elif m := PATTERN_ROW_RANGE.match(key):
                 return span_dict(
-                    from_r=int(splitk[0]) - 1,
+                    from_r=int(m[1]) - 1,
                     from_c=None,
-                    upto_r=None,
+                    upto_r=int(m[2]),
                     upto_c=None,
                     widget=widget,
                 )
-
-            if splitk[1].isdigit() and not splitk[0]:
-                """
-                [":2"] - Rows up to and including 1
-                """
+            elif m := PATTERN_ROW_START.match(key):
                 return span_dict(
-                    from_r=0,
+                    from_r=int(m[1]) - 1,
                     from_c=None,
-                    upto_r=int(splitk[1]),
+                    upto_r=None,
                     upto_c=None,
                     widget=widget,
                 )
-
-            if splitk[0].isdigit() and splitk[1].isdigit():
-                """
-                ["1:2"] - Rows 0, 1
-                """
+            elif m := PATTERN_ROW_END.match(key):
                 return span_dict(
-                    from_r=int(splitk[0]) - 1,
+                    from_r=0,
                     from_c=None,
-                    upto_r=int(splitk[1]),
+                    upto_r=int(m[1]),
                     upto_c=None,
                     widget=widget,
                 )
-
-            if splitk[0].isalpha() and not splitk[1]:
-                """
-                ["B:"] - Columns starting from and including 2
-                """
+            elif m := PATTERN_COL_RANGE.match(key):
                 return span_dict(
                     from_r=None,
-                    from_c=alpha2idx(splitk[0]),
+                    from_c=span_a2i(m[1]),
                     upto_r=None,
-                    upto_c=None,
+                    upto_c=span_a2n(m[2]),
                     widget=widget,
                 )
-
-            if splitk[1].isalpha() and not splitk[0]:
-                """
-                [":B"] - Columns up to and including 2
-                """
+            elif m := PATTERN_COL_START.match(key):
                 return span_dict(
                     from_r=None,
-                    from_c=0,
+                    from_c=span_a2i(m[1]),
                     upto_r=None,
-                    upto_c=alpha2idx(splitk[1]) + 1,
+                    upto_c=None,
                     widget=widget,
                 )
-
-            if splitk[0].isalpha() and splitk[1].isalpha():
-                """
-                ["A:B"] - Columns 0, 1
-                """
+            elif m := PATTERN_COL_END.match(key):
                 return span_dict(
                     from_r=None,
-                    from_c=alpha2idx(splitk[0]),
+                    from_c=0,
                     upto_r=None,
-                    upto_c=alpha2idx(splitk[1]) + 1,
+                    upto_c=span_a2n(m[1]),
                     widget=widget,
                 )
-
-            m1 = re.search(r"\d", splitk[0])
-            m2 = re.search(r"\d", splitk[1])
-            m1start = m1.start() if m1 else None
-            m2start = m2.start() if m2 else None
-            if m1start and m2start:
-                """
-                ["A1:B1"] - Cells (0, 0), (0, 1)
-                """
-                c1 = splitk[0][:m1start]
-                r1 = splitk[0][m1start:]
-                c2 = splitk[1][:m2start]
-                r2 = splitk[1][m2start:]
+            elif m := PATTERN_CELL_START.match(key):
                 return span_dict(
-                    from_r=int(r1) - 1,
-                    from_c=alpha2idx(c1),
-                    upto_r=int(r2),
-                    upto_c=alpha2idx(c2) + 1,
+                    from_r=int(m[2]) - 1,
+                    from_c=span_a2i(m[1]),
+                    upto_r=None,
+                    upto_c=None,
                     widget=widget,
                 )
-
-            if not splitk[0] and m2start:
-                """
-                [":B1"] - Cells (0, 0), (0, 1)
-                """
-                c2 = splitk[1][:m2start]
-                r2 = splitk[1][m2start:]
+            elif m := PATTERN_CELL_END.match(key):
                 return span_dict(
                     from_r=0,
                     from_c=0,
-                    upto_r=int(r2),
-                    upto_c=alpha2idx(c2) + 1,
+                    upto_r=int(m[2]),
+                    upto_c=span_a2n(m[1]),
                     widget=widget,
                 )
-
-            if not splitk[1] and m1start:
-                """
-                ["A1:"] - Cells starting from and including (0, 0)
-                """
-                c1 = splitk[0][:m1start]
-                r1 = splitk[0][m1start:]
+            elif m := PATTERN_CELL_COL.match(key):
                 return span_dict(
-                    from_r=int(r1) - 1,
-                    from_c=alpha2idx(c1),
+                    from_r=int(m[2]) - 1,
+                    from_c=span_a2i(m[1]),
                     upto_r=None,
-                    upto_c=None,
+                    upto_c=span_a2n(m[3]),
                     widget=widget,
                 )
-
-            if m1start and splitk[1].isalpha():
-                """
-                ["A1:B"] - All the cells starting from (0, 0)
-                        expanding out to include column 1
-                        but not including cells beyond column
-                        1 and expanding down to include all rows
-                    A   B   C   D
-                1   x   x
-                2   x   x
-                3   x   x
-                4   x   x
-                ...
-                """
-                c1 = splitk[0][:m1start]
-                r1 = splitk[0][m1start:]
+            elif m := PATTERN_CELL_ROW.match(key):
                 return span_dict(
-                    from_r=int(r1) - 1,
-                    from_c=alpha2idx(c1),
-                    upto_r=None,
-                    upto_c=alpha2idx(splitk[1]) + 1,
+                    from_r=int(m[2]) - 1,
+                    from_c=span_a2i(m[1]),
+                    upto_r=int(m[3]),
+                    upto_c=None,
                     widget=widget,
                 )
-
-            if m1start and splitk[1].isdigit():
-                """
-                ["A1:2"] - All the cells starting from (0, 0)
-                        expanding down to include row 1
-                        but not including cells beyond row
-                        1 and expanding out to include all
-                        columns
-                    A   B   C   D
-                1   x   x   x   x
-                2   x   x   x   x
-                3
-                4
-                ...
-                """
-                c1 = splitk[0][:m1start]
-                r1 = splitk[0][m1start:]
+            elif PATTERN_ALL.match(key):
                 return span_dict(
-                    from_r=int(r1) - 1,
-                    from_c=alpha2idx(c1),
-                    upto_r=int(splitk[1]),
+                    from_r=0,
+                    from_c=None,
+                    upto_r=None,
                     upto_c=None,
                     widget=widget,
                 )
+            else:
+                return f"'{key}' could not be converted to span."
 
     except ValueError as error:
         return f"Error, '{key}' could not be converted to span: {error}"
-    else:
-        return f"'{key}' could not be converted to span."
 
 
 def span_is_cell(span: Span) -> bool:
@@ -1623,7 +1521,7 @@ def add_to_options(
     options: dict,
     coords: int | tuple[int, int],
     key: str,
-    value: object,
+    value: Any,
 ) -> dict:
     if coords not in options:
         options[coords] = {}
@@ -1694,14 +1592,14 @@ def mod_span(
     return to_set_to
 
 
-def mod_span_widget(span: Span, widget: object) -> Span:
+def mod_span_widget(span: Span, widget: Any) -> Span:
     span.widget = widget
     return span
 
 
 def mod_event_val(
     event_data: EventDataDict,
-    val: object,
+    val: Any,
     loc: Loc | None = None,
     row: int | None = None,
     column: int | None = None,