listpick 0.1.13.28__tar.gz → 0.1.13.30__tar.gz

{listpick-0.1.13.28 → listpick-0.1.13.30}/CHANGELOG.md

@@ -25,8 +25,17 @@
  - Setup logging for the Picker class. Currently still very basic but will track to the last function that was run before crash if the --debug flag is passed to the picker.
  - Added pin_cursor options which keeps the cursor on the same row during a refresh rather than tracking the id of the highlighted row. 
  - Updated StandardFooter. Now shows information on two lines rather than three; all cursor and selection information on the first line and the sort information on the second. Cursor, Visual (de)selection now abreviated to C, VS, and VDS.
- - Fixed flickering when displaying an infobox.
+ - Reduced flickering when displaying an infobox.
  - Optimised cpu usage by created a class variable selected_cells_by_row which updates with selection/deselection rather than being determined each time the draw_screen loop is run.
+ - Added unicode_char_width option which will set the calculating character widths. If True then wcwidth will be used to calculate the display with if False then len will be used.
+   - unicode_char_width should be set to true if special characters will be displayed
+     - Special characters=East Asian scripts, emojis, etc.
+   - With data that has several thousand columns wcwidth is extremely slow so unicode_char_width should be set to False.
+ - Speed improvements:
+   - get_column_widths calculated only once when drawing the screen.
+   - unicode_char_width option to improve performance with large (in particular wide) data sets.
+   - truncate_to_display width now guesses the target width and then adjusts rather than adding one display-width character at a time. 5-10 times faster.
+   - Reduced number of calls to draw_screen. It is called (1) when a key is pressed, (2) before showing a notification, and (3) when the data is refreshed.
 
 ## [0.1.13] 2025-07-28
  - Cell-based picker is now supported.

{listpick-0.1.13.28/src/listpick.egg-info → listpick-0.1.13.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: listpick
-Version: 0.1.13.28
+Version: 0.1.13.30
 Summary: Listpick is a powerful TUI data tool for creating TUI apps or viewing/comparing tabulated data.
 Home-page: https://github.com/grimandgreedy/listpick
 Author: Grim

{listpick-0.1.13.28 → listpick-0.1.13.30}/TODO.md

@@ -5,6 +5,9 @@ ASAP
 > - [ ] Unify in-app load and command-line input file
 > - [ ] Implement default_option_selector and pass the picker options (!!!)
 > - [ ] Make sure that all class initialisation variables are returned in the get_function_variables function.
+> - [ ] Adjust leftmost_char when:
+>   - [ ] cursor_down
+>   - [ ] 'g', 'G'
 
 
 
@@ -114,6 +117,7 @@ ASAP
 > - [x] Support pasting copied cells into the picker
 >   - [ ] Ensure that we can only paste when cells are editable.
 >   - [ ] Add option to insert cells; e.g., insert two columns and move the data to the right of the selected column across
+>   - [ ] Add support for pasting as a string
 > - [ ] Support inserting cells/rows.
 > - [ ] Bulk edit in nvim
 > - [ ] Add formula and display value...

{listpick-0.1.13.28 → listpick-0.1.13.30}/setup.py

@@ -16,7 +16,7 @@ with open("README.md", "r", encoding = "utf-8") as fh:
 
 setuptools.setup(
     name = "listpick",
-    version = "0.1.13.28",
+    version = "0.1.13.30",
     author = "Grim",
     author_email = "grimandgreedy@protonmail.com",
     description = "Listpick is a powerful TUI data tool for creating TUI apps or viewing/comparing tabulated data.",

{listpick-0.1.13.28 → listpick-0.1.13.30}/src/listpick/listpick_app.py

@@ -140,6 +140,7 @@ class Picker:
         footer_string_refresh_function: Optional[Callable] = None,
         footer_timer: float=1,
         get_footer_string_startup=False,
+        unicode_char_width: bool = False,
 
         colours_start: int =0,
         colours_end: int =-1,
@@ -256,6 +257,7 @@ class Picker:
         self.footer_string_refresh_function = footer_string_refresh_function
         self.footer_timer = footer_timer
         self.get_footer_string_startup = get_footer_string_startup,
+        self.unicode_char_width = unicode_char_width
 
 
 
@@ -662,12 +664,13 @@ class Picker:
         self.stdscr.refresh()
 
     def draw_screen(self, indexed_items: list[Tuple[int, list[str]]], highlights: list[dict] = [{}], clear: bool = True) -> None:
+        """ Try-except wrapper for the draw_screen_() method to prevent crashes when rapidly resizing the terminal. """
         try:
-            self.draw_screen(self.indexed_items, self.highlights)
+            self.draw_screen_(self.indexed_items, self.highlights)
         except:
             self.logger.warning(f"draw_screen function error")
-            pass
-    def draw_screen2(self, indexed_items: list[Tuple[int, list[str]]], highlights: list[dict] = [{}], clear: bool = True) -> None:
+
+    def draw_screen_(self, indexed_items: list[Tuple[int, list[str]]], highlights: list[dict] = [{}], clear: bool = True) -> None:
         """ Draw Picker screen. """
         self.logger.debug("Draw screen.")
 
@@ -696,7 +699,7 @@ class Picker:
         # rows = [v[1] for v in self.indexed_items] if len(self.indexed_items) else self.items
         # Determine widths based only on the currently displayed indexed rows
         rows = [v[1] for v in self.indexed_items[start_index:end_index]] if len(self.indexed_items) else self.items
-        self.column_widths = get_column_widths(rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w)
+        self.column_widths = get_column_widths(rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w, unicode_char_width=self.unicode_char_width)
         visible_column_widths = [c for i,c in enumerate(self.column_widths) if i not in self.hidden_columns]
         visible_columns_total_width = sum(visible_column_widths) + len(self.separator)*(len(visible_column_widths)-1)
 
@@ -795,10 +798,10 @@ class Picker:
                     else:
                         cell_value = self.indexed_items[row][1][col] + self.separator
                     # cell_value = cell_value[:min(cell_width, cell_max_width)-len(self.separator)]
-                    cell_value = truncate_to_display_width(cell_value, min(cell_width, cell_max_width)-len(self.separator))
+                    cell_value = truncate_to_display_width(cell_value, min(cell_width, cell_max_width)-len(self.separator), self.unicode_char_width)
                     cell_value = cell_value + self.separator
                     # cell_value = cell_value
-                    cell_value = truncate_to_display_width(cell_value, min(cell_width, cell_max_width))
+                    cell_value = truncate_to_display_width(cell_value, min(cell_width, cell_max_width), self.unicode_char_width)
                     # row_str = truncate_to_display_width(row_str_left_adj, min(w-self.startx, visible_columns_total_width))
                     self.stdscr.addstr(y, cell_pos, cell_value, curses.color_pair(self.colours_start+colour_pair_number) | curses.A_BOLD)
                 # Part of the cell is on screen
@@ -840,7 +843,7 @@ class Picker:
         def draw_highlights(highlights: list[dict], idx: int, y: int, item: tuple[int, list[str]]):
             self.logger.debug(f"function: draw_highlights()")
             if len(highlights) == 0: return None
-            full_row_str = format_row(item[1], self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols)
+            full_row_str = format_row(item[1], self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols, self.unicode_char_width)
             row_str = full_row_str[self.leftmost_char:]
             for highlight in highlights:
                 if "row" in highlight:
@@ -856,13 +859,13 @@ class Picker:
                             continue
 
                     elif type(highlight["field"]) == type(0) and highlight["field"] not in self.hidden_columns:
-                        match = re.search(highlight["match"], truncate_to_display_width(item[1][highlight["field"]], self.column_widths[highlight["field"]], centre=False), re.IGNORECASE)
+                        match = re.search(highlight["match"], truncate_to_display_width(item[1][highlight["field"]], self.column_widths[highlight["field"]], centre=False, unicode_char_width=self.unicode_char_width), re.IGNORECASE)
                         if not match: continue
                         field_start = sum([width for i, width in enumerate(self.column_widths[:highlight["field"]]) if i not in self.hidden_columns]) + sum([1 for i in range(highlight["field"]) if i not in self.hidden_columns])*wcswidth(self.separator)
 
                         ## We want to search the non-centred values but highlight the centred values.
                         if self.centre_in_cols:
-                            tmp = truncate_to_display_width(item[1][highlight["field"]], self.column_widths[highlight["field"]], self.centre_in_cols)
+                            tmp = truncate_to_display_width(item[1][highlight["field"]], self.column_widths[highlight["field"]], self.centre_in_cols, self.unicode_char_width)
                             field_start += (len(tmp) - len(tmp.lstrip()))
 
                         highlight_start = field_start + match.start()
@@ -884,11 +887,11 @@ class Picker:
             item = self.indexed_items[idx]
             y = idx - start_index + self.top_space
 
-            row_str = format_row(item[1], self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols)[self.leftmost_char:]
+            # row_str = format_row(item[1], self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols)[self.leftmost_char:]
             # row_str = truncate_to_display_width(row_str, min(w-self.startx, visible_columns_total_width))
-            row_str_orig = format_row(item[1], self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols)
+            row_str_orig = format_row(item[1], self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols, self.unicode_char_width)
             row_str_left_adj = clip_left(row_str_orig, self.leftmost_char)
-            row_str = truncate_to_display_width(row_str_left_adj, min(w-self.startx, visible_columns_total_width))
+            row_str = truncate_to_display_width(row_str_left_adj, min(w-self.startx, visible_columns_total_width), self.unicode_char_width)
             # row_str = truncate_to_display_width(row_str, min(w-self.startx, visible_columns_total_width))[self.leftmost_char:]
 
             ## Display the standard row
@@ -1153,6 +1156,7 @@ class Picker:
             "debug":                            self.debug,
             "debug_level":                      self.debug_level,
             "reset_colours":                    self.reset_colours,
+            "unicode_char_width":               self.unicode_char_width,
         }
         return function_data
 
@@ -1250,7 +1254,7 @@ class Picker:
         while True:
             h, w = stdscr.getmaxyx()
 
-            choose_opts_widths = get_column_widths(options)
+            choose_opts_widths = get_column_widths(options, unicode_char_width=self.unicode_char_width)
             window_width = min(max(sum(choose_opts_widths) + 6, 50) + 6, w)
             window_height = min(h//2, max(6, len(options)+3))
 
@@ -1405,6 +1409,8 @@ class Picker:
                     self.initialise_variables()
                 elif setting == "pc":
                     self.pin_cursor = not self.pin_cursor
+                elif setting == "unicode":
+                    self.unicode_char_width = not self.unicode_char_width
 
                 elif setting.startswith("ft"):
                     if len(setting) > 2 and setting[2:].isnumeric():
@@ -1468,7 +1474,6 @@ class Picker:
                         self.draw_screen(self.indexed_items, self.highlights)
                         self.notification(self.stdscr, message=f"Theme {self.colour_theme_number} applied.")
 
-
                 else:
                     self.user_settings = ""
                     return None
@@ -1702,12 +1707,10 @@ class Picker:
                     if not acceptable_data_type:
                         break
                 if not acceptable_data_type:
-                    self.draw_screen(self.indexed_items, self.highlights)
                     self.notification(self.stdscr, message="Error pasting data.")
                     return None
 
         except:
-            self.draw_screen(self.indexed_items, self.highlights)
             self.notification(self.stdscr, message="Error pasting data.")
             return None
         if type(pasta) == type([]) and len(pasta) > 0 and type(pasta[0]) == type([]):
@@ -1813,6 +1816,7 @@ class Picker:
         with self.data_lock:
             self.items, self.header = tmp_items, tmp_header
             self.data_ready = True
+            self.draw_screen(self.indexed_items, self.highlights)
 
     def save_input_history(self, file_path: str) -> bool:
         """ Save input field history. Returns True if successful save. """
@@ -2099,6 +2103,7 @@ class Picker:
                     options += [["rh", "Toggle row header"]]
                     options += [["modes", "Toggle modes"]]
                     options += [["ft", "Cycle through footer styles (accepts ft#)"]]
+                    options += [["unicode", "Toggle b/w using len and wcwidth to calculate char width."]]
                     options += [[f"s{i}", f"Select col. {i}"] for i in range(len(self.items[0]))]
                     options += [[f"!{i}", f"Toggle col. {i}"] for i in range(len(self.items[0]))]
                     options += [["ara", "Add empty row after cursor."]]
@@ -2203,8 +2208,6 @@ class Picker:
                 if new_pos < len(self.indexed_items):
                     self.cursor_pos = new_pos
 
-                self.draw_screen(self.indexed_items, self.highlights)
-
             elif self.check_key("cursor_bottom", key, self.keys_dict):
                 new_pos = len(self.indexed_items)-1
                 while True:
@@ -2212,12 +2215,7 @@ class Picker:
                     else: break
                 if new_pos < len(self.items) and new_pos >= 0:
                     self.cursor_pos = new_pos
-                self.draw_screen(self.indexed_items, self.highlights)
-                # current_row = items_per_page - 1
-                # if current_page + 1 == (len(self.indexed_items) + items_per_page - 1) // items_per_page:
-                #
-                #     current_row = (len(self.indexed_items) +items_per_page - 1) % items_per_page
-                # self.draw_screen(self.indexed_items, self.highlights)
+
             elif self.check_key("enter", key, self.keys_dict):
                 self.logger.info(f"key_function enter")
                 # Print the selected indices if any, otherwise print the current index
@@ -2297,7 +2295,6 @@ class Picker:
                 if len(self.indexed_items) > 0:
                     current_index = self.indexed_items[self.cursor_pos][0]
                     sort_items(self.indexed_items, sort_method=self.columns_sort_method[self.sort_column], sort_column=self.sort_column, sort_reverse=self.sort_reverse[self.sort_column])  # Re-sort self.items based on new column
-                    self.draw_screen(self.indexed_items, self.highlights)
                     self.cursor_pos = [row[0] for row in self.indexed_items].index(current_index)
                 self.logger.info(f"key_function cycle_sort_order. (sort_column, sort_method, sort_reverse) = ({self.sort_column}, {self.columns_sort_method[self.sort_column]}, {self.sort_reverse[self.sort_column]})")
             elif self.check_key("col_select", key, self.keys_dict):
@@ -2321,7 +2318,7 @@ class Picker:
 
                 ## Scroll with column select
                 rows = self.get_visible_rows()
-                self.column_widths = get_column_widths(rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w)
+                self.column_widths = get_column_widths(rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w, unicode_char_width=self.unicode_char_width)
                 visible_column_widths = [c for i,c in enumerate(self.column_widths) if i not in self.hidden_columns]
                 column_set_width = sum(visible_column_widths)+len(self.separator)*len(visible_column_widths)
                 start_of_cell = sum(visible_column_widths[:self.selected_column])+len(self.separator)*self.selected_column
@@ -2348,7 +2345,7 @@ class Picker:
 
                 ## Scroll with column select
                 rows = self.get_visible_rows()
-                self.column_widths = get_column_widths(rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w)
+                self.column_widths = get_column_widths(rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w, unicode_char_width=self.unicode_char_width)
 
                 visible_column_widths = [c for i,c in enumerate(self.column_widths) if i not in self.hidden_columns]
                 column_set_width = sum(visible_column_widths)+len(self.separator)*len(visible_column_widths)
@@ -2367,15 +2364,11 @@ class Picker:
                 #
             elif self.check_key("scroll_right", key, self.keys_dict):
                 self.logger.info(f"key_function scroll_right")
-                rows = self.get_visible_rows()
-                longest_row_str_len = 0
-                for i in range(len(rows)):
-                    item = rows[i]
-                    row_str = format_row(item, self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols)[self.leftmost_char:]
-                    if len(row_str) > longest_row_str_len: longest_row_str_len=len(row_str)
+                if len(self.indexed_items):
+                    row_width = sum(self.column_widths) + len(self.separator)*(len(self.column_widths)-1)
+                    if row_width-self.leftmost_char >= w-self.startx:
+                        self.leftmost_char = self.leftmost_char+5
 
-                if longest_row_str_len >= w-self.startx:
-                    self.leftmost_char = self.leftmost_char+5
 
             elif self.check_key("scroll_left", key, self.keys_dict):
                 self.logger.info(f"key_function scroll_left")
@@ -2392,7 +2385,7 @@ class Picker:
                 rows = self.get_visible_rows()
                 for i in range(len(rows)):
                     item = rows[i]
-                    row_str = format_row(item, self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols)
+                    row_str = format_row(item, self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols, self.unicode_char_width)
                     if len(row_str) > longest_row_str_len: longest_row_str_len=len(row_str)
                 # for i in range(len(self.indexed_items)):
                 #     item = self.indexed_items[i]
@@ -2463,11 +2456,10 @@ class Picker:
 
             # elif self.check_key("increase_lines_per_page", key, self.keys_dict):
             #     self.items_per_page += 1
-            #     self.draw_screen(self.indexed_items, self.highlights)
             # elif self.check_key("decrease_lines_per_page", key, self.keys_dict):
             #     if self.items_per_page > 1:
             #         self.items_per_page -= 1
-            #     self.draw_screen(self.indexed_items, self.highlights)
+
             elif self.check_key("decrease_column_width", key, self.keys_dict):
                 self.logger.info(f"key_function decrease_column_width")
                 if self.max_column_width > 10:
@@ -2489,7 +2481,7 @@ class Picker:
             elif key == curses.KEY_RESIZE:  # Terminal resize signal
 
                 self.calculate_section_sizes()
-                self.column_widths = get_column_widths(self.items, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w)
+                self.column_widths = get_column_widths(self.items, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w, unicode_char_width=self.unicode_char_width)
 
 
 
@@ -2884,11 +2876,10 @@ class Picker:
                 self.stdscr.clear()
                 self.stdscr.refresh()
                 self.initialise_variables()
-                # self.draw_screen(self.indexed_items, self.highlights)
 
 
-
-            self.draw_screen(self.indexed_items, self.highlights, clear=clear_screen)
+            if key != -1:
+                self.draw_screen(self.indexed_items, self.highlights, clear=clear_screen)
 
 
 
@@ -3128,21 +3119,28 @@ def main() -> None:
         pass
         
     function_data["colour_theme_number"] = 3
-    # function_data["modes"]  = [ 
-    #     {
-    #         'filter': '',
-    #         'sort': 0,
-    #         'name': 'All',
-    #     },
-    #     {
-    #         'filter': '--2 miss',
-    #         'name': 'miss',
-    #     },
-    #     {
-    #         'filter': '--2 mp4',
-    #         'name': 'mp4',
-    #     },
-    # ]
+    function_data["modes"]  = [ 
+        {
+            'filter': '',
+            'sort': 0,
+            'name': 'All',
+        },
+        {
+            'filter': '--2 miss',
+            'name': 'miss',
+        },
+        {
+            'filter': '--2 mp4',
+            'name': 'mp4',
+        },
+    ]
+    highlights = [
+        {
+            "field": 1,
+            "match": "a",
+            "color": 8,
+        }
+    ]
     function_data["cell_cursor"] = True
     function_data["display_modes"] = True
     function_data["centre_in_cols"] = True
@@ -3153,15 +3151,18 @@ def main() -> None:
     function_data["centre_in_terminal_vertical"] = True
     function_data["highlight_full_row"] = True
     function_data["pin_cursor"] = True
-    function_data["display_infobox"] = True
-    function_data["infobox_items"] = [["1"], ["2"], ["3"]]
-    function_data["infobox_title"] = "Title"
+    # function_data["display_infobox"] = True
+    # function_data["infobox_items"] = [["1"], ["2"], ["3"]]
+    # function_data["infobox_title"] = "Title"
     function_data["footer_string"] = "Title"
+    function_data["highlights"] = highlights
 
 
     # function_data["debug"] = True
     # function_data["debug_level"] = 1
     stdscr = start_curses()
+    # h, w = stdscr.getmaxyx()
+    # win = stdscr.derwin(h, w//2, 0, 0)
     try:
         # Run the Picker
         # h, w = stdscr.getmaxyx()

{listpick-0.1.13.28 → listpick-0.1.13.30}/src/listpick/utils/utils.py

@@ -36,7 +36,7 @@ def clip_left(text, n):
         width += char_width
     return text  # If the total width is less than n, return the full string
 
-def truncate_to_display_width(text: str, max_column_width: int, centre=False) -> str:
+def truncate_to_display_width(text: str, max_column_width: int, centre=False, unicode_char_width:bool = True) -> str:
     """ 
     Truncate and/or pad text to max_column_width using wcwidth to ensure visual width is correct 
         with foreign character sets. 
@@ -46,19 +46,31 @@ def truncate_to_display_width(text: str, max_column_width: int, centre=False) ->
 
     """
     # logger.debug("function: truncate_to_display_width (utils.py)")
-    result = ''
-    width = 0
-    for char in text:
-        w = wcwidth(char)
-        if w < 0:
-            continue
-        if width + w > max_column_width:
-            break
-        result += char
-        width += w
-    # Pad if it's shorter
-    padding = max_column_width - wcswidth(result)
-    # return result + ' ' * padding
+    if unicode_char_width:
+        result = ''
+        width = 0
+        test_str = text[:max_column_width]
+        while True:
+            width = wcswidth(test_str)
+            if width  < max_column_width or width == 0:
+                break
+            test_str = test_str[:-1]
+        # for char in text:
+        #     w = wcwidth(char)
+        #     if w < 0:
+        #         continue
+        #     if width + w > max_column_width:
+        #         break
+        #     result += char
+        #     width += w
+        # Pad if it's shorter
+        # padding = max_column_width - wcswidth(result)
+        result = test_str
+        # return result + ' ' * padding
+    else:
+        result = text[:max_column_width]
+        width = len(result)
+    padding = max_column_width - width
     if centre:
         result = ' '*(padding//2) + result + ' '*(padding//2 + padding%2)
     else:
@@ -83,7 +95,7 @@ def format_full_row(row:str) -> str:
     return '\t'.join(row)
 
 
-def format_row(row: list[str], hidden_columns: list, column_widths: list[int], separator: str, centre:bool=False) -> str:
+def format_row(row: list[str], hidden_columns: list, column_widths: list[int], separator: str, centre:bool=False, unicode_char_width:bool = True) -> str:
     """ Format list of strings as a single string. Requires separator string and the maximum width of the columns. """
     row_str = ""
     for i, cell in enumerate(row):
@@ -91,20 +103,22 @@ def format_row(row: list[str], hidden_columns: list, column_widths: list[int], s
         # if is_formula_cell(cell):
         #     cell = evaluate_cell(cell)
         
-        val = truncate_to_display_width(str(cell), column_widths[i], centre)
+        val = truncate_to_display_width(str(cell), column_widths[i], centre, unicode_char_width)
         row_str += val + separator
     return row_str
-    # return row_str.strip()
 
-def get_column_widths(items: list[list[str]], header: list[str]=[], max_column_width:int=70, number_columns:bool=True, max_total_width=-1, separator = "    ") -> list[int]:
+def get_column_widths(items: list[list[str]], header: list[str]=[], max_column_width:int=70, number_columns:bool=True, max_total_width=-1, separator = "    ", unicode_char_width:bool=True) -> list[int]:
     """ Calculate maximum width of each column with clipping. """
     if len(items) == 0: return [0]
     assert len(items) > 0
-    widths = [max(wcswidth(str(row[i])) for row in items) for i in range(len(items[0]))]
-    # widths = [max(len(str(row[i])) for row in items) for i in range(len(items[0]))]
-    if header:
-        header_widths = [wcswidth(f"{i}. {str(h)}") if number_columns else wcswidth(str(h)) for i, h in enumerate(header)]
-        col_widths =  [min(max_column_width, max(widths[i], header_widths[i])) for i in range(len(header))]
+
+    if unicode_char_width:
+        widths = [max(wcswidth(str(row[i])) for row in items) for i in range(len(items[0]))]
+        # widths = [max(len(str(row[i])) for row in items) for i in range(len(items[0]))]
+        if header:
+            header_widths = [wcswidth(f"{i}. {str(h)}") if number_columns else wcswidth(str(h)) for i, h in enumerate(header)]
+            col_widths =  [min(max_column_width, max(widths[i], header_widths[i])) for i in range(len(header))]
+
         # actual_max_widths = [max(header_widths[i], widths[i]) for i in range(len(widths))]
         #
         # if sum(col_widths) + len(separator)*(len(col_widths)-1) < max_total_width:
@@ -124,8 +138,15 @@ def get_column_widths(items: list[list[str]], header: list[str]=[], max_column_w
         #     else:
         #         # Maximise balance.....
         #         pass
+        else:
+            col_widths = [min(max_column_width, width) for width in widths]
     else:
-        col_widths = [min(max_column_width, width) for width in widths]
+        widths = [max(len(str(row[i])) for row in items) for i in range(len(items[0]))]
+        if header:
+            header_widths = [len(f"{i}. {str(h)}") if number_columns else len(str(h)) for i, h in enumerate(header)]
+            col_widths =  [min(max_column_width, max(widths[i], header_widths[i])) for i in range(len(header))]
+        else:
+            col_widths = [min(max_column_width, width) for width in widths]
     return col_widths
 
 def get_mode_widths(item_list: list[str]) -> list[int]:

{listpick-0.1.13.28 → listpick-0.1.13.30/src/listpick.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: listpick
-Version: 0.1.13.28
+Version: 0.1.13.30
 Summary: Listpick is a powerful TUI data tool for creating TUI apps or viewing/comparing tabulated data.
 Home-page: https://github.com/grimandgreedy/listpick
 Author: Grim