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

tksheet/sorting.py

@@ -3,12 +3,12 @@ from __future__ import annotations
 from collections.abc import Callable, Generator, Iterable, Iterator
 from datetime import datetime
 from pathlib import Path
-from re import finditer
+from re import split
 
 AnyIter = Iterable | Iterator
 
 # Possible date formats to try for the entire string
-date_formats = [
+date_formats = (
     # Common formats
     "%d/%m/%Y",  # Day/Month/Year
     "%m/%d/%Y",  # Month/Day/Year (US format)
@@ -24,7 +24,8 @@ date_formats = [
     "%m,%d,%Y",  # Month,Day,Year
     "%Y,%m,%d",  # Year,Month,Day
     "%d %m %Y",  # Day Month Year (with space)
-    "%m %d %Y",  # Month Day Year
+    "%m %d %Y",  # Month Day Year (with space)
+    "%Y %d %m",  # Year Month Day (with space)
     # With month names
     "%d %b %Y",  # Day Abbreviated Month Year
     "%b %d, %Y",  # Abbreviated Month Day, Year
@@ -42,76 +43,228 @@ date_formats = [
     "%d/%m/%y %H:%M",  # Day/Month/Year Hour:Minute
     "%m/%d/%y %H:%M",  # Month/Day/Year Hour:Minute
     "%Y-%m-%d %H:%M:%S",  # Year-Month-Day Hour:Minute:Second
-]
+)
 
 
-def natural_sort_key(
-    item: object,
-) -> tuple[int, ...]:
+def _string_fallback(item: str) -> tuple[int, ...]:
+    """
+    In order to have reasonable file path sorting:
+    - Split by path separators
+    - Determine depth, more separators more depth
+    - Deal with every dir by splitting by digits
+    - Deal with file name by splitting by digits
+    """
+    components = split(r"[/\\]", item)
+    if components[-1]:
+        return (
+            5,
+            len(components),
+            tuple(int(e) if e.isdigit() else e.lower() for comp in components[:-1] for e in split(r"(\d+)", comp) if e),
+            tuple(int(e) if e.isdigit() else e.lower() for e in split(r"(\d+)", components[-1])),
+        )
+    else:
+        return (
+            5,
+            len(components),
+            tuple(int(e) if e.isdigit() else e.lower() for comp in components[:-1] for e in split(r"(\d+)", comp) if e),
+            tuple(),
+        )
+
+
+def version_sort_key(item: object) -> tuple[int, ...]:
     """
     A key for natural sorting of various Python types.
 
-    This function returns a tuple where the first element is an integer
-    ranking the type, followed by type-specific comparison values.
+    - Won't convert strings to floats
+    - Will sort string version numbers
 
-    1. None
+    0. None
+    1. Empty strings
     2. bool
     3. int, float
-    4. datetime
-    5. filepaths
-    6. empty strings
-    7. strings
-    8. unknown objects with __str__ method
-    9. unknown objects
-
-    :param item: Any Python object to be sorted.
-    :return: A tuple for sorting, with type indicator and comparison values.
+    4. datetime (inc. strings that are dates)
+    5. strings (including string file paths and paths as POSIX strings) & unknown objects with __str__
+    6. unknown objects
     """
-    if item is None:
+    if isinstance(item, str):
+        if item:
+            for date_format in date_formats:
+                try:
+                    return (4, datetime.strptime(item, date_format).timestamp())
+                except ValueError:
+                    continue
+            # the same as _string_fallback
+            components = split(r"[/\\]", item)
+            if components[-1]:
+                return (
+                    5,
+                    len(components),
+                    tuple(
+                        int(e) if e.isdigit() else e.lower()
+                        for comp in components[:-1]
+                        for e in split(r"(\d+)", comp)
+                        if e
+                    ),
+                    tuple(int(e) if e.isdigit() else e.lower() for e in split(r"(\d+)", components[-1])),
+                )
+            else:
+                return (
+                    5,
+                    len(components),
+                    tuple(
+                        int(e) if e.isdigit() else e.lower()
+                        for comp in components[:-1]
+                        for e in split(r"(\d+)", comp)
+                        if e
+                    ),
+                    tuple(),
+                )
+        else:
+            return (1, item)
+
+    elif item is None:
         return (0,)
 
     elif isinstance(item, bool):
-        return (1, item)
+        return (2, item)
 
     elif isinstance(item, (int, float)):
-        return (2, item)
+        return (3, item)
 
     elif isinstance(item, datetime):
-        return (3, item.timestamp())
+        return (4, item.timestamp())
 
     elif isinstance(item, Path):
-        return (4, item.as_posix())
+        return _string_fallback(item.as_posix())
 
-    elif isinstance(item, str):
-        if not item:
-            return (5, item)
+    else:
+        try:
+            return _string_fallback(f"{item}")
+        except Exception:
+            return (6, item)
 
-        else:
+
+def natural_sort_key(item: object) -> tuple[int, ...]:
+    """
+    A key for natural sorting of various Python types.
+
+    - Won't sort string version numbers
+    - Will convert strings to floats
+    - Will sort strings that are file paths
+
+    0. None
+    1. Empty strings
+    2. bool
+    3. int, float (inc. strings that are numbers)
+    4. datetime (inc. strings that are dates)
+    5. strings (including string file paths and paths as POSIX strings) & unknown objects with __str__
+    6. unknown objects
+    """
+    if isinstance(item, str):
+        if item:
             for date_format in date_formats:
                 try:
-                    return (3, datetime.strptime(item, date_format).timestamp())
+                    return (4, datetime.strptime(item, date_format).timestamp())
                 except ValueError:
                     continue
 
             try:
-                return (2, float(item))
-            except Exception:
-                pass
+                return (3, float(item))
+            except ValueError:
+                # the same as _string_fallback
+                components = split(r"[/\\]", item)
+                if components[-1]:
+                    return (
+                        5,
+                        len(components),
+                        tuple(
+                            int(e) if e.isdigit() else e.lower()
+                            for comp in components[:-1]
+                            for e in split(r"(\d+)", comp)
+                            if e
+                        ),
+                        tuple(int(e) if e.isdigit() else e.lower() for e in split(r"(\d+)", components[-1])),
+                    )
+                else:
+                    return (
+                        5,
+                        len(components),
+                        tuple(
+                            int(e) if e.isdigit() else e.lower()
+                            for comp in components[:-1]
+                            for e in split(r"(\d+)", comp)
+                            if e
+                        ),
+                        tuple(),
+                    )
+        else:
+            return (1, item)
 
-            if "/" in item or "\\" in item:
-                try:
-                    return (4, Path(item).as_posix())
-                except Exception:
-                    pass
+    elif item is None:
+        return (0,)
 
-            return (6, item.lower(), tuple(int(match.group()) for match in finditer(r"\d+", item)))
+    elif isinstance(item, bool):
+        return (2, item)
+
+    elif isinstance(item, (int, float)):
+        return (3, item)
+
+    elif isinstance(item, datetime):
+        return (4, item.timestamp())
+
+    elif isinstance(item, Path):
+        return _string_fallback(item.as_posix())
 
-    # For unknown types, attempt to convert to string, or place at end
     else:
         try:
-            return (7, f"{item}".lower())
+            return _string_fallback(f"{item}")
         except Exception:
-            return (8, item)
+            return (6, item)
+
+
+def fast_sort_key(item: object) -> tuple[int, ...]:
+    """
+    A faster key for natural sorting of various Python types.
+
+    - Won't sort strings that are dates very well
+    - Won't convert strings to floats
+    - Won't sort string file paths very well
+    - Will do ok with string version numbers
+
+    0. None
+    1. Empty strings
+    2. bool
+    3. int, float
+    4. datetime
+    5. strings (including paths as POSIX strings) & unknown objects with __str__
+    6. unknown objects
+    """
+    if isinstance(item, str):
+        if item:
+            return (5, tuple(int(e) if e.isdigit() else e.lower() for e in split(r"(\d+)", item)))
+        else:
+            return (1, item)
+
+    elif item is None:
+        return (0,)
+
+    elif isinstance(item, bool):
+        return (2, item)
+
+    elif isinstance(item, (int, float)):
+        return (3, item)
+
+    elif isinstance(item, datetime):
+        return (4, item.timestamp())
+
+    elif isinstance(item, Path):
+        return _string_fallback(item.as_posix())
+
+    else:
+        try:
+            return _string_fallback(f"{item}")
+        except Exception:
+            return (6, item)
 
 
 def sort_selection(
@@ -264,14 +417,15 @@ def sort_tree_view(
     _row_index: list[object],
     tree_rns: dict[str, int],
     tree: dict[str, object],
-    key: Callable = natural_sort_key,
+    key: Callable | None = None,
     reverse: bool = False,
 ) -> tuple[list[object], dict[int, int]]:
     if not _row_index or not tree_rns or not tree:
         return [], {}
 
     if key is None:
-        key = natural_sort_key
+        # prefer version_sort_key for iid names
+        key = version_sort_key
 
     # Create the index map and sorted nodes list
     mapping = {}
@@ -298,38 +452,80 @@ def sort_tree_view(
     return sorted_nodes, mapping
 
 
-# def test_natural_sort_key():
-#     test_items = [
-#         None,
-#         False,
-#         True,
-#         5,
-#         3.14,
-#         datetime(2023, 1, 1),
-#         "abc123",
-#         "123abc",
-#         "abc123def",
-#         "998zzz",
-#         "10-01-2023",
-#         "01-10-2023",
-#         "fi1le_0.txt",
-#         "file_2.txt",
-#         "file_10.txt",
-#         "file_1.txt",
-#         "path/to/file_2.txt",
-#         "path/to/file_10.txt",
-#         "path/to/file_1.txt",
-#         "/another/path/file_2.log",
-#         "/another/path/file_10.log",
-#         "/another/path/file_1.log",
-#         "C:\\Windows\\System32\\file_2.dll",
-#         "C:\\Windows\\System32\\file_10.dll",
-#         "C:\\Windows\\System32\\file_1.dll",
-#     ]
-#     print("Sort objects:", [natural_sort_key(e) for e in test_items])
-#     sorted_items = sorted(test_items, key=natural_sort_key)
-#     print("\nNatural Sort Order:", sorted_items)
-
-
 # if __name__ == "__main__":
-#     test_natural_sort_key()
+#     test_cases = {
+#         "Filenames": ["file10.txt", "file2.txt", "file1.txt"],
+#         "Versions": ["1.10", "1.2", "1.9", "1.21"],
+#         "Mixed": ["z1.doc", "z10.doc", "z2.doc", "z100.doc"],
+#         "Paths": [
+#             "/folder/file.txt",
+#             "/folder/file (1).txt",
+#             "/folder (1)/file.txt",
+#             "/folder (10)/file.txt",
+#             "/dir/subdir/file1.txt",
+#             "/dir/subdir/file10.txt",
+#             "/dir/subdir/file2.txt",
+#             "/dir/file.txt",
+#             "/dir/sub/file123.txt",
+#             "/dir/sub/file12.txt",
+#             # New challenging cases
+#             "/a/file.txt",
+#             "/a/file1.txt",
+#             "/a/b/file.txt",
+#             "/a/b/file1.txt",
+#             "/x/file-v1.2.txt",
+#             "/x/file-v1.10.txt",
+#             # My own new challenging cases
+#             "/a/zzzzz.txt",
+#             "/a/b/a.txt",
+#         ],
+#         "Case": ["Apple", "banana", "Corn", "apple", "Banana", "corn"],
+#         "Leading Zeros": ["001", "010", "009", "100"],
+#         "Complex": ["x-1-y-10", "x-1-y-2", "x-2-y-1", "x-10-y-1"],
+#         "Lengths": ["2 ft 9 in", "2 ft 10 in", "10 ft 1 in", "10 ft 2 in"],
+#         "Floats": [
+#             "1.5",
+#             "1.25",
+#             "1.025",
+#             "10.5",
+#             "-10.2",
+#             "-2.5",
+#             "5.7",
+#             "-1.25",
+#             "0.0",
+#             "1.5e3",
+#             "2.5e2",
+#             "1.23e4",
+#             "1e-2",
+#             "file1.2.txt",
+#             "file1.5.txt",
+#             "file1.10.txt",
+#         ],
+#         "Strings": [
+#             "123abc",
+#             "abc123",
+#             "123abc456",
+#             "abc123def",
+#         ],
+#     }
+
+#     print("FAST SORT KEY:")
+
+#     for name, data in test_cases.items():
+#         sorted1 = sorted(data, key=fast_sort_key)
+#         print(f"\n{name}:")
+#         print(sorted1)
+
+#     print("\nNATURAL SORT KEY:")
+
+#     for name, data in test_cases.items():
+#         sorted1 = sorted(data, key=natural_sort_key)
+#         print(f"\n{name}:")
+#         print(sorted1)
+
+#     print("\nVERSION SORT KEY:")
+
+#     for name, data in test_cases.items():
+#         sorted1 = sorted(data, key=version_sort_key)
+#         print(f"\n{name}:")
+#         print(sorted1)

{tksheet-7.4.2.dist-info → tksheet-7.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tksheet
-Version: 7.4.2
+Version: 7.4.4
 Summary: Tkinter table / sheet and treeview widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors
@@ -101,6 +101,8 @@ License-File: LICENSE.txt
 - [In-built natural sorting](https://github.com/ragardner/tksheet/wiki/Version-7#sorting-the-table)
 - [Optional built-in find window](https://github.com/ragardner/tksheet/wiki/Version-7#table-functionality-and-bindings)
 
+Note that due to the limitations of the Tkinter Canvas right-to-left (RTL) languages are not supported.
+
 ```python
 """
 Versions 7+ have succinct and easy to read syntax:

tksheet-7.4.4.dist-info/RECORD

@@ -0,0 +1,22 @@
+tksheet/__init__.py,sha256=DJduXwiEFlPhe0uDqKUZCRGgf9pB-aubUvC_sXCpVp8,2313
+tksheet/colors.py,sha256=dHhmdFuQDlwohDHsAfT9VdrKoSl_R33L72a3HCin5zo,51591
+tksheet/column_headers.py,sha256=Dq3GqcUvBpereMdOTU3OqkfSkCb8nSUM18uHF2Vsrqo,103442
+tksheet/constants.py,sha256=PkvAtdYXSOiOO5zuxqrObvGIVV2sEE0enN8YLhI8zCc,3922
+tksheet/find_window.py,sha256=JfkgpGluSng3bKMBneDNQg-AJmBcmCW7JIhtYbSUZaE,8036
+tksheet/formatters.py,sha256=21ZkMaDIJNUtjvtlAbPl8Y19I9nDxue-JJegw6hblz8,10551
+tksheet/functions.py,sha256=KQe1AncAiVUxvcq9GAJ8TBXKaSAxk5-VDHDY6hHApLk,53183
+tksheet/main_table.py,sha256=jWG9Of249O-bPujDG1umoXZUndM6wIsx8lqNWPqVTz4,358190
+tksheet/other_classes.py,sha256=ADybikLipEG4NABXx8bGVAovJJhWcomQOWTorzS1CPU,16581
+tksheet/row_index.py,sha256=NUpv_cpGDKO_tF4tICcK2BaW1Z0-w8sdE9NYVyHNHO8,133849
+tksheet/sheet.py,sha256=s_9jyRok7AGanMZ9NzQYjkFxlwavjEMSBnOEN3uoJoQ,283724
+tksheet/sheet_options.py,sha256=A_cJEc6XirLO8YrWQHfb10lK2VhGbz28_3XgrKx3TfM,9753
+tksheet/sorting.py,sha256=xBSh_b7QyRRDzwqmKMPEevCZY1KpmMbyA6kl0yvcK6U,16887
+tksheet/text_editor.py,sha256=ZLVF-0WxDin5qUAJ5r7dmsdwvhyEoxw0PlPvi_AGNPE,7328
+tksheet/themes.py,sha256=AoNAxibnQi04MN0Zpbn9-kyDnkiiV8TDNWP9FYjpuf0,18473
+tksheet/tksheet_types.py,sha256=8JQVlA6N9jEZTEAytbcyuhOGuNE4fUPxYhTqoidxEE0,588
+tksheet/top_left_rectangle.py,sha256=KhTT-rBUwQTgaHjSwL83cL5_71k2L1B7gxkSxZlTSK8,8598
+tksheet-7.4.4.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
+tksheet-7.4.4.dist-info/METADATA,sha256=F4df5FisLoL6dkzwUbayE2Djt0fgD1bibXlVOFLaoDM,7839
+tksheet-7.4.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+tksheet-7.4.4.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
+tksheet-7.4.4.dist-info/RECORD,,

tksheet-7.4.2.dist-info/RECORD

@@ -1,22 +0,0 @@
-tksheet/__init__.py,sha256=BuxXbfmHJXeezYFzX9NIu-OAj8cCTE8KGSuIo2uJUXY,2241
-tksheet/colors.py,sha256=dHhmdFuQDlwohDHsAfT9VdrKoSl_R33L72a3HCin5zo,51591
-tksheet/column_headers.py,sha256=ZfHLhXEKe8M9ggf3nzg252DBVH_NRtQichtTF7pisIc,103245
-tksheet/constants.py,sha256=PkvAtdYXSOiOO5zuxqrObvGIVV2sEE0enN8YLhI8zCc,3922
-tksheet/find_window.py,sha256=JfkgpGluSng3bKMBneDNQg-AJmBcmCW7JIhtYbSUZaE,8036
-tksheet/formatters.py,sha256=21ZkMaDIJNUtjvtlAbPl8Y19I9nDxue-JJegw6hblz8,10551
-tksheet/functions.py,sha256=tVwMLWsW4n5M-RCL8DrLMOXygDhBP26wz4nEQq1gkUo,52734
-tksheet/main_table.py,sha256=mK74o6VlN8EdM6iJt3XyLlJc4DvNGENyjmDJcNEIcX0,357780
-tksheet/other_classes.py,sha256=ADybikLipEG4NABXx8bGVAovJJhWcomQOWTorzS1CPU,16581
-tksheet/row_index.py,sha256=66AZdMHiP85cqSYe01sSOVdue-DDEIlpLH2NRSeH5Fw,133222
-tksheet/sheet.py,sha256=2_fMNnJqwvEkYsrDuyxFC68l6XZROzZVjG2FrSZc7IU,284689
-tksheet/sheet_options.py,sha256=RAQX9NF8Bvauj4fHW-8TGtZG6cRVSzwGxSUKplg3c28,9625
-tksheet/sorting.py,sha256=Lh2jrbh6fGXxA7FuosiBFKj7etJe3IYJ33cVhE6g8qU,10374
-tksheet/text_editor.py,sha256=ZLVF-0WxDin5qUAJ5r7dmsdwvhyEoxw0PlPvi_AGNPE,7328
-tksheet/themes.py,sha256=AoNAxibnQi04MN0Zpbn9-kyDnkiiV8TDNWP9FYjpuf0,18473
-tksheet/tksheet_types.py,sha256=8JQVlA6N9jEZTEAytbcyuhOGuNE4fUPxYhTqoidxEE0,588
-tksheet/top_left_rectangle.py,sha256=KhTT-rBUwQTgaHjSwL83cL5_71k2L1B7gxkSxZlTSK8,8598
-tksheet-7.4.2.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
-tksheet-7.4.2.dist-info/METADATA,sha256=QeRPqI62tWbTBzRkMxe-mIhXNHB8xLP44SWDfGglYr0,7734
-tksheet-7.4.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-tksheet-7.4.2.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
-tksheet-7.4.2.dist-info/RECORD,,