listpick 0.1.13.56__tar.gz → 0.1.13.58__tar.gz

{listpick-0.1.13.56 → listpick-0.1.13.58}/CHANGELOG.md

@@ -25,6 +25,7 @@
  - 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.
+ - Added try-except wrapper to draw_screen function to prevent crashes during rapid resizing.
 
 ## [0.1.13] 2025-07-28
  - Cell-based picker is now supported.

{listpick-0.1.13.56/src/listpick.egg-info → listpick-0.1.13.58}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: listpick
-Version: 0.1.13.56
+Version: 0.1.13.58
 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.56 → listpick-0.1.13.58}/setup.py

@@ -16,7 +16,7 @@ with open("README.md", "r", encoding = "utf-8") as fh:
 
 setuptools.setup(
     name = "listpick",
-    version = "0.1.13.56",
+    version = "0.1.13.58",
     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.56 → listpick-0.1.13.58}/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 = True,
 
         colours_start: int =0,
         colours_end: int =-1,
@@ -256,7 +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
 
 
         self.colours_start = colours_start
@@ -312,17 +313,12 @@ class Picker:
         self.debug_level = debug_level
 
 
-
-
         self.initialise_picker_state(reset_colours=self.reset_colours)
 
-
         # Note: We have to set the footer after initialising the picker state so that the footer can use the get_function_data method
         self.footer_options = [StandardFooter(self.stdscr, colours_start, self.get_function_data), CompactFooter(self.stdscr, colours_start, self.get_function_data), NoFooter(self.stdscr, colours_start, self.get_function_data)]
         self.footer = self.footer_options[self.footer_style]
 
-        # self.footer = CompactFooter(self.stdscr, colours_start, self.get_function_data)
-
 
     def calculate_section_sizes(self):
         """
@@ -384,7 +380,6 @@ class Picker:
     def initialise_picker_state(self, reset_colours=False) -> None:
         """ Initialise state variables for the picker. These are: debugging and colours. """
 
-
         if curses.has_colors() and self.colours != None:
             # raise Exception("Terminal does not support color")
             curses.start_color()
@@ -658,6 +653,14 @@ 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_ function. """
+        try:
+            self.draw_screen_(self.indexed_items, self.highlights)
+        except Exception as e:
+            self.logger.warning(f"self.draw_screen_() error. {e}")
+            pass
+
+    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.")
 
@@ -686,7 +689,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)
 
@@ -785,10 +788,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
@@ -830,7 +833,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:
@@ -846,13 +849,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()
@@ -874,11 +877,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
@@ -891,7 +894,7 @@ class Picker:
 
             # Higlight cursor cell and selected cells
             if self.cell_cursor:
-                self.selected_cells_by_row = get_selected_cells_by_row(self.cell_selections)
+                # self.selected_cells_by_row = get_selected_cells_by_row(self.cell_selections)
                 if item[0] in self.selected_cells_by_row:
                     for j in self.selected_cells_by_row[item[0]]:
                         highlight_cell(idx, j, visible_column_widths, colour_pair_number=25)
@@ -985,6 +988,7 @@ class Picker:
             self.stdscr.addstr(h - 1, w-footer_string_width-1, " "*footer_string_width, curses.color_pair(self.colours_start+24))
             self.stdscr.addstr(h - 1, w-footer_string_width-1, f"{disp_string}", curses.color_pair(self.colours_start+24))
         
+        self.stdscr.refresh()
         ## Display infobox
         if self.display_infobox:
             self.infobox(self.stdscr, message=self.infobox_items, title=self.infobox_title)
@@ -1132,6 +1136,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
 
@@ -1385,6 +1390,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():
@@ -1448,7 +1455,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
@@ -1481,7 +1487,8 @@ class Picker:
             self.selections[self.indexed_items[i][0]] = True
         for i in self.cell_selections.keys():
             self.cell_selections[i] = True
-
+        for row in range(len(self.indexed_items)):
+            self.selected_cells_by_row[row] = list(range(len(self.indexed_items[row][1])))
         self.draw_screen(self.indexed_items, self.highlights)
 
     def deselect_all(self) -> None:
@@ -1491,6 +1498,7 @@ class Picker:
             self.selections[i] = False
         for i in self.cell_selections.keys():
             self.cell_selections[i] = False
+        self.selected_cells_by_row = {}
         self.draw_screen(self.indexed_items, self.highlights)
 
     def handle_visual_selection(self, selecting:bool = True) -> None:
@@ -1519,9 +1527,18 @@ class Picker:
                 xend = max(self.start_selection_col, self.selected_column)
                 for i in range(ystart, yend + 1):
                     if self.indexed_items[i][0] not in self.unselectable_indices:
-                        for j in range(xstart, xend+1):
-                            cell_index = (self.indexed_items[i][0], j)
+                        row = self.indexed_items[i][0]
+                        if row not in self.selected_cells_by_row:
+                            self.selected_cells_by_row[row] = []
+
+                        for col in range(xstart, xend+1):
+                            cell_index = (row, col)
                             self.cell_selections[cell_index] = True
+
+                            self.selected_cells_by_row[row].append(col)
+                        # Remove duplicates
+                        self.selected_cells_by_row[row] = list(set(self.selected_cells_by_row[row]))
+
             self.start_selection = -1
             self.end_selection = -1
             self.is_selecting = False
@@ -1543,10 +1560,19 @@ class Picker:
                 xstart = min(self.start_selection_col, self.selected_column)
                 xend = max(self.start_selection_col, self.selected_column)
                 for i in range(ystart, yend + 1):
+                    row = self.indexed_items[i][0]
                     if self.indexed_items[i][0] not in self.unselectable_indices:
-                        for j in range(xstart, xend+1):
-                            cell_index = (self.indexed_items[i][0], j)
-                            self.cell_selections[cell_index] = False
+                        if row in self.selected_cells_by_row:
+                            for col in range(xstart, xend+1):
+                                try:
+                                    self.selected_cells_by_row[row].remove(col)
+                                except:
+                                    pass
+                                cell_index = (row, col)
+                                self.cell_selections[cell_index] = False
+                            if self.selected_cells_by_row[row] == []:
+                                del self.selected_cells_by_row[row]
+
             self.start_selection = -1
             self.end_selection = -1
             self.is_deselecting = False
@@ -1825,7 +1851,7 @@ class Picker:
 
     def get_word_list(self) -> list[str]:
         """ Get a list of all words used in any cell of the picker. Used for completion in search/filter input_field. """
-        self.logger.info(f"function: infobox()")
+        self.logger.info(f"function: get_word_list()")
         translator = str.maketrans('', '', string.punctuation)
         
         words = []
@@ -2068,6 +2094,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."]]
@@ -2132,11 +2159,31 @@ class Picker:
                 if len(self.indexed_items) > 0:
                     item_index = self.indexed_items[self.cursor_pos][0]
                     cell_index = (self.indexed_items[self.cursor_pos][0], self.selected_column)
+                    row, col = cell_index
                     selected_count = sum(self.selections.values())
                     if self.max_selected == -1 or selected_count >= self.max_selected:
                         self.toggle_item(item_index)
 
                         self.cell_selections[cell_index] = not self.cell_selections[cell_index]
+                        ## Set self.selected_cells_by_row
+                        # If any cells in the current row are selected
+                        if row in self.selected_cells_by_row:
+                            # If the current cell is selected then remove it
+                            if col in self.selected_cells_by_row[row]:
+                                # If the current cell is the only cell in the row that is selected then remove the row from the dict
+                                if len(self.selected_cells_by_row[row]) == 1:
+
+                                    del self.selected_cells_by_row[row]
+                                # else remove only the index of the current cell
+                                else:
+                                    self.selected_cells_by_row[row].remove(col)
+                            # If there are cells in the row that are selected then append the current cell to the row
+                            else:
+                                self.selected_cells_by_row[row].append(col)
+                        # Add the a list containing only the current column
+                        else:
+                            self.selected_cells_by_row[row] = [col]
+
                 self.cursor_down()
             elif self.check_key("select_all", key, self.keys_dict):  # Select all (m or ctrl-a)
                 self.select_all()
@@ -2270,7 +2317,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
@@ -2297,8 +2344,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
@@ -2313,18 +2359,13 @@ class Picker:
                     self.leftmost_char = start_of_cell
 
                 self.leftmost_char = max(0, min(column_set_width - display_width + 5, self.leftmost_char))
-                #
+
             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 longest_row_str_len >= w-self.startx:
-                    self.leftmost_char = self.leftmost_char+5
+                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
 
             elif self.check_key("scroll_left", key, self.keys_dict):
                 self.logger.info(f"key_function scroll_left")
@@ -2341,7 +2382,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]
@@ -2442,7 +2483,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)
 
                 self.draw_screen(self.indexed_items, self.highlights)
 
@@ -2852,7 +2893,6 @@ class Picker:
 def set_colours(pick: int = 0, start: int = 0) -> Optional[int]:
     """ Initialise curses colour pairs from dictionary. """
     
-
     global COLOURS_SET, notification_colours, help_colours
     if COLOURS_SET: return None
     if start == None: start = 0
@@ -3100,6 +3140,13 @@ def main() -> None:
     #         '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
@@ -3110,6 +3157,12 @@ 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["footer_string"] = "Title"
+    function_data["highlights"] = highlights
+    function_data["show_footer"] = False
     # function_data["debug"] = True
     # function_data["debug_level"] = 1
     stdscr = start_curses()