listpick 0.1.13.62__py3-none-any.whl → 0.1.14.1__py3-none-any.whl

listpick/listpick_app.py

@@ -106,6 +106,7 @@ class Picker:
 
         selections: dict = {},
         cell_selections: dict[tuple[int,int], bool] = {},
+        selected_cells_by_row: dict = {},
         highlight_full_row: bool =False,
         cell_cursor: bool = False,
 
@@ -122,7 +123,7 @@ class Picker:
 
         paginate: bool =False,
         cancel_is_back: bool = False,
-        mode_index: int =0,
+        mode_index: int = 0,
         modes: list[dict] = [],
         display_modes: bool =False,
         require_option: list=[],
@@ -161,10 +162,8 @@ class Picker:
 
         startup_notification:str = "",
 
-        leftmost_column: int = 0,
         leftmost_char: int = 0,
 
-
         history_filter_and_search: list[str] = [],
         history_opts: list[str] = [],
         history_settings: list[str] = [],
@@ -173,6 +172,19 @@ class Picker:
         debug: bool = False,
         debug_level: int = 1,
 
+        command_stack: list = [],
+
+        loaded_file: str = "Untitled",
+        loaded_files: list[str] = ["Untitled"],
+        loaded_file_index: int = 0,
+        loaded_file_states: list[dict] = [{}],
+
+
+        sheets = ["Untitled"],
+        sheet_name = "Untitled",
+        sheet_index = 0,
+        sheet_states = [{}],
+
     ):
         self.stdscr = stdscr
         self.items = items
@@ -225,6 +237,7 @@ class Picker:
 
         self.selections = selections
         self.cell_selections = cell_selections
+        self.selected_cells_by_row = selected_cells_by_row
         self.highlight_full_row = highlight_full_row
         self.cell_cursor = cell_cursor
 
@@ -283,8 +296,7 @@ class Picker:
         self.registers = {}
         
         self.SORT_METHODS = SORT_METHODS
-        self.command_stack = []
-        self.leftmost_column = leftmost_column
+        self.command_stack = command_stack
         self.leftmost_char = leftmost_char
 
 
@@ -297,7 +309,6 @@ class Picker:
         self.cursor_pos_prev = 0
         self.ids = []
         self.ids_tuples = []
-        self.selected_cells_by_row = {}
 
         # History variables
         self.history_filter_and_search = history_filter_and_search
@@ -307,18 +318,37 @@ class Picker:
         self.history_edits = history_edits
 
 
-
-
         self.debug = debug
         self.debug_level = debug_level
 
+        # Multiple file support
+        self.loaded_files = loaded_files
+        self.loaded_file = loaded_file
+        self.loaded_file_index = loaded_file_index
+        self.loaded_file_states = loaded_file_states
+
+        # Multiple sheet support
+        self.sheet_index = sheet_index
+        self.sheet_name = sheet_name
+        self.sheet_states = sheet_states
+        self.sheets = sheets
 
         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.__version__ = "1.0"
 
+    def __sizeof__(self):
+
+        size = super().__sizeof__()
+        
+        # Add the size of each attribute directly owned by the object
+        for attr_name in dir(self):
+            if not attr_name.startswith('__') and not callable(getattr(self, attr_name)):
+                size += sys.getsizeof(getattr(self, attr_name))
+        return size
 
     def calculate_section_sizes(self):
         """
@@ -495,8 +525,12 @@ class Picker:
 
         if len(self.items) and len(self.cell_selections) != len(self.items)*len(self.items[0]):
             self.cell_selections = {(i, j) : False if (i, j) not in self.cell_selections else self.cell_selections[(i, j)] for i in range(len(self.items)) for j in range(len(self.items[0]))}
+            self.selected_cells_by_row = get_selected_cells_by_row(self.cell_selections)
         elif len(self.items) == 0:
             self.cell_selections = {}
+            self.selected_cells_by_row = {}
+
+        
 
         if len(self.require_option) < len(self.items):
             self.require_option += [self.require_option_default for i in range(len(self.items)-len(self.require_option))]
@@ -556,6 +590,20 @@ class Picker:
         assert new_pos < len(self.items)
         self.cursor_pos = new_pos
 
+        # Sheets and files
+        if len(self.sheet_states) < len(self.sheets):
+            self.sheet_states += [{} for _ in range(len(self.sheets) - len(self.sheet_states))]
+        if len(self.sheets):
+            if self.sheet_index >= len(self.sheets):
+                self.sheet_index = 0
+            self.sheet_name = self.sheets[self.sheet_index]
+
+        if len(self.loaded_file_states) < len(self.loaded_files):
+            self.loaded_file_states += [{} for _ in range(len(self.loaded_files) - len(self.loaded_file_states))]
+        if len(self.loaded_files):
+            if self.loaded_file_index >= len(self.loaded_files):
+                self.loaded_file_index = 0
+            self.loaded_file = self.loaded_files[self.loaded_file_index]
 
         # if tracking and len(self.items) > 1:
         # Ensure that selected indices are tracked upon data refresh
@@ -591,6 +639,7 @@ class Picker:
                             self.cursor_pos = [i[0] for i in self.indexed_items].index(cursor_pos_x)
             else:
                 self.cursor_pos = 0
+
         
 
 
@@ -1045,6 +1094,7 @@ class Picker:
         function_data = {
             "selections":                       self.selections,
             "cell_selections":                  self.cell_selections,
+            "selected_cells_by_row":            self.selected_cells_by_row,
             "items_per_page":                   self.items_per_page,
             "current_row":                      self.current_row,
             "current_page":                     self.current_page,
@@ -1123,7 +1173,6 @@ class Picker:
             "keys_dict":                        self.keys_dict,
             "cancel_is_back":                   self.cancel_is_back,
             "paginate":                         self.paginate,
-            "leftmost_column":                  self.leftmost_column,
             "leftmost_char":                    self.leftmost_char,
             "history_filter_and_search" :       self.history_filter_and_search,
             "history_pipes" :                   self.history_pipes,
@@ -1136,17 +1185,55 @@ class Picker:
             "debug_level":                      self.debug_level,
             "reset_colours":                    self.reset_colours,
             "unicode_char_width":               self.unicode_char_width,
+            "command_stack":                    self.command_stack,
+            "loaded_file":                      self.loaded_file,
+            "loaded_files":                     self.loaded_files,
+            "loaded_file_index":                self.loaded_file_index,
+            "loaded_file_states":               self.loaded_file_states,
+            "sheet_index":                      self.sheet_index,
+            "sheets":                           self.sheets,
+            "sheet_name":                       self.sheet_name,
+            "sheet_states":                     self.sheet_states,
         }
         return function_data
 
-    def set_function_data(self, function_data: dict) -> None:
+    def set_function_data(self, function_data: dict, reset_absent_variables: bool = False, do_not_set: list=[]) -> None:
         """ Set variables from state dict containing core variables."""
         self.logger.info(f"function: set_function_data()")
         variables = self.get_function_data().keys()
 
+        x = Picker(self.stdscr, reset_colours=False)
+
+
+        common_picker_vars = [
+            "loaded_file_index",
+            "loaded_file_states",
+            "loaded_files",
+            "loaded_file",
+            "command_stack",
+            "colour_theme_number",
+            "reset_colours",
+            "show_footer",
+            "show_header",
+            "history_filter_and_search",
+            "history_settings",
+            "history_opts",
+            "history_edits",
+            "history_pipes",
+            "reset_colours",
+            "cell_cursor",
+            "top_gap",
+            "unicode_char_width",
+            "show_row_header",
+        ]
+
         for var in variables:
             if var in function_data:
                 setattr(self, var, function_data[var])
+            elif reset_absent_variables and var not in common_picker_vars and var not in do_not_set:
+                # Set value to the default for an empty picker
+                setattr(self, var, getattr(x, var))
+
 
         reset_colours = bool("colour_theme_number" in function_data)
         self.initialise_picker_state(reset_colours=reset_colours)
@@ -1275,6 +1362,7 @@ class Picker:
             h, w = stdscr.getmaxyx()
 
             submenu_win = curses.newwin(notification_height, notification_width, 3, w - (notification_width+4))
+            # submenu_win = self.stdscr.subwin(notification_height, notification_width, 3, w - (notification_width+4))
             notification_data = {
                 "items": submenu_items,
                 "title": title,
@@ -1291,6 +1379,10 @@ class Picker:
                 "cancel_is_back": True,
                 "reset_colours": False,
 
+                "loaded_files": [],
+                "loaded_file_states": [],
+                "loaded_file": "",
+                "loaded_file_index": 0,
             }
             OptionPicker = Picker(submenu_win, **notification_data)
             s, o, f = OptionPicker.run()
@@ -1343,15 +1435,15 @@ class Picker:
                     # highlights = [highlight for highlight in highlights if "type" not in highlight or highlight["type"] != "search" ]
                     
                     self.highlights_hide = not self.highlights_hide
-                elif setting[0] == "s":
-                    if 0 <= int(setting[1:]) < len(self.items[0]):
-                        self.sort_column = int(setting[1:])
-                        if len(self.indexed_items):
-                            current_pos = 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 items based on new column
-                        if len(self.indexed_items):
-                            new_pos = [row[0] for row in self.indexed_items].index(current_pos)
-                            self.cursor_pos = new_pos
+                # elif setting[0] == "s":
+                #     if 0 <= int(setting[1:]) < len(self.items[0]):
+                #         self.sort_column = int(setting[1:])
+                #         if len(self.indexed_items):
+                #             current_pos = 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 items based on new column
+                #         if len(self.indexed_items):
+                #             new_pos = [row[0] for row in self.indexed_items].index(current_pos)
+                #             self.cursor_pos = new_pos
                 elif setting == "ct":
                     self.centre_in_terminal = not self.centre_in_terminal
                 elif setting == "cc":
@@ -1396,6 +1488,47 @@ class Picker:
                     self.pin_cursor = not self.pin_cursor
                 elif setting == "unicode":
                     self.unicode_char_width = not self.unicode_char_width
+                elif setting == "file_next":
+                    if len(self.loaded_files) > 1:
+                        self.command_stack.append(Command("setting", self.user_settings))
+                        # Cache file state
+                        self.loaded_file_states[self.loaded_file_index] = self.get_function_data()
+
+                        self.loaded_file_index = (self.loaded_file_index + 1) % len(self.loaded_files)
+                        self.loaded_file = self.loaded_files[self.loaded_file_index]
+
+                        # If we already have a loaded state for this file
+                        if self.loaded_file_states[self.loaded_file_index]:
+                            self.set_function_data(self.loaded_file_states[self.loaded_file_index])
+                        else:
+                            self.set_function_data({}, reset_absent_variables=True)
+                            self.load_file(self.loaded_file)
+
+                elif setting == "sheet_next":
+                    if not os.path.exists(self.loaded_file):
+                        self.notification(self.stdscr, message=f"File {repr(self.loaded_file)} not found.")
+                        return None
+                    if len(self.sheets) > 1:
+                        self.command_stack.append(Command("setting", self.user_settings))
+
+                        # Cache sheet state
+                        self.sheet_states[self.sheet_index] = self.get_function_data()
+                        self.sheet_index = (self.sheet_index + 1) % len(self.sheets)
+                        self.sheet_name = self.sheets[self.sheet_index]
+
+                        # If we already have a loaded state for this file
+                        if self.sheet_states[self.sheet_index]:
+                            self.set_function_data(self.sheet_states[self.sheet_index])
+                        else:
+                            function_data = {
+                                "sheet_index": self.sheet_index,
+                                "sheet_name":  self.sheet_name,
+                                "sheet_states":self.sheet_states,
+                                "sheets":       self.sheets,
+                            }
+                            self.set_function_data(function_data, reset_absent_variables=True)
+                            self.load_sheet(self.loaded_file, sheet_number=self.sheet_index)
+
 
                 elif setting.startswith("ft"):
                     if len(setting) > 2 and setting[2:].isnumeric():
@@ -1463,9 +1596,9 @@ class Picker:
                     self.user_settings = ""
                     return None
 
-
-            self.command_stack.append(Command("setting", self.user_settings))
-            self.user_settings = ""
+            if self.user_settings:
+                self.command_stack.append(Command("setting", self.user_settings))
+                self.user_settings = ""
 
     def apply_command(self, command: Command):
         self.logger.info(f"function: apply_command()")
@@ -1773,17 +1906,41 @@ class Picker:
         ]
 
         if s:
-            file_to_load = file_picker()
-            if file_to_load:
+            restrict_curses(self.stdscr)
+            files_to_load = file_picker()
+            unrestrict_curses(self.stdscr)
+            if files_to_load:
                 index = list(s.keys())[0]
+                file_to_load = files_to_load[0]
                 return_val = funcs[index](file_to_load)
-                self.set_function_data(return_val)
 
+                self.loaded_file_states[self.loaded_file_index] = self.get_function_data()
+
+                self.stdscr.clear()
+                self.draw_screen(self.indexed_items, self.highlights)
+
+                tmp = self.stdscr
+
+                self.loaded_files += files_to_load
+                self.loaded_file_states += [{} for _ in files_to_load]
+                self.loaded_file = file_to_load
+                self.loaded_file_index = len(self.loaded_files)-len(files_to_load)
+
+
+                self.stdscr = tmp
+
+                h, w = self.stdscr.getmaxyx()
+                self.notification(self.stdscr, f"{repr(file_to_load)} has been loaded!")
+
+                self.set_function_data({}, reset_absent_variables=True)
+                self.load_file(self.loaded_file)
                 # items = return_val["items"]
                 # header = return_val["header"]
-                self.initialise_variables()
+                self.stdscr.clear()
+                # self.initialise_variables()
                 self.draw_screen(self.indexed_items, self.highlights)
-                self.notification(self.stdscr, f"{repr(file_to_load)} has been loaded!")
+                # self.stdscr.refresh()
+
                 # if return_val:
                 #     notification(stdscr, message=return_val, title="Error")
 
@@ -1915,6 +2072,36 @@ class Picker:
         self.cursor_pos = current_cursor_pos
 
 
+    def load_file(self, filename: str) -> None:
+        if not os.path.exists(filename):
+            self.notification(self.stdscr, message = f"File not found: {filename}")
+            return None
+
+        filetype = guess_file_type(filename)
+        items, header, sheets = table_to_list(filename, file_type=filetype)
+
+        if items != None:
+            self.items = items
+            self.header = header if header != None else []
+            self.sheets = sheets
+
+
+            self.initialise_variables()
+
+    def load_sheet(self, filename: str, sheet_number: int = 0):
+        filetype = guess_file_type(filename)
+        items, header, sheets = table_to_list(filename, file_type=filetype, sheet_number=sheet_number)
+
+        if items != None:
+            self.items = items
+            self.header = header if header != None else []
+            self.sheets = sheets
+
+            self.initialise_variables()
+
+
+
+
 
     def run(self) -> Tuple[list[int], str, dict]:
         """ Run the picker. """
@@ -1963,7 +2150,7 @@ class Picker:
 
         while True:
             key = self.stdscr.getch()
-            if key:
+            if key != -1:
                 self.logger.info(f"key={key}")
             h, w = self.stdscr.getmaxyx()
             if key in self.disabled_keys: continue
@@ -2042,12 +2229,130 @@ class Picker:
                 }
                 OptionPicker = Picker(self.stdscr, **help_data)
                 s, o, f = OptionPicker.run()
+                self.draw_screen(self.indexed_items, self.highlights)
+
+            if self.check_key("info", key, self.keys_dict):
+                self.logger.info(f"key_function help")
+                self.stdscr.clear()
+                self.stdscr.refresh()
+                import importlib.metadata as metadata
+                version = metadata.version('listpick')
+
+                info_items = [
+                    ["    Listpick info:", "-*"*30],
+                    ["",""],
+                    ["listpick version", f"{version}"],
+
+                    ["",""],
+                    ["    Global:", "-*"*30],
+                    ["",""],
+                    ["current_file", self.loaded_file],
+                    ["loaded_files", repr(self.loaded_files)],
+                    ["auto_refresh", f"{repr(self.auto_refresh)}"],
+                    ["timer", f"{repr(self.timer)}"],
+                    ["pin_cursor", f"{repr(self.pin_cursor)}"],
+                    ["cwd", f"{os.getcwd()}"],
+                    ["Picker memory", f"{format_size(sys.getsizeof(self))}"],
+                    ["debug", f"{repr(self.debug)}"],
+                    ["debug level", f"{repr(self.debug_level)}"],
+
+                    ["",""],
+                    ["    Current File:", "-*"*30],
+                    ["",""],
+                    ["row/row count", f"{self.cursor_pos}/{len(self.indexed_items)}"],
+                    ["total rows", f"{len(self.items)}"],
+                    ["selections", f"{self.selected_cells_by_row}"],
+                    ["current_sheet", self.sheet_name],
+                    ["sheets", repr(self.sheets)],
+                    ["current column/column_count", f"{self.selected_column}/{len(self.column_widths)}"],
+                    ["hidden columns", f"{self.hidden_columns}"],
+                    ["sort column", f"{self.sort_column}"],
+                    ["sort method", f"{self.SORT_METHODS[self.columns_sort_method[self.sort_column]]}"],
+                    ["sort order", f"{'Descending' if self.sort_reverse[self.sort_column] else 'Ascending'}"],
+                    ["id_column", f"{self.id_column}"],
+
+                    ["",""],
+                    ["    Display options:", "-*"*30],
+                    ["",""],
+                    ["show_header", str(self.show_header)],
+                    ["show_footer", repr(self.show_footer)],
+                    ["show_row_header", repr(self.show_row_header)],
+                    ["max_column_width", str(self.max_column_width)],
+                    ["colour_theme_number", str(self.colour_theme_number)],
+                    ["top_gap", str(self.top_gap)],
+                    ["highlight_full_row", repr(self.highlight_full_row)],
+                    ["cell_cursor", repr(self.cell_cursor)],
+                    ["items_per_page", repr(self.items_per_page)],
+                    ["paginate", repr(self.paginate)],
+                    ["display_modes", repr(self.display_modes)],
+                    ["footer_style", repr(self.footer_style)],
+                    ["unicode_char_width", repr(self.unicode_char_width)],
+                    ["centre_in_terminal", repr(self.centre_in_terminal)],
+                    ["centre_in_cols", repr(self.centre_in_cols)],
+                    ["centre_in_terminal_vertical", repr(self.centre_in_terminal_vertical)],
+                ]
+                
+                data = self.get_function_data()
+                del data["indexed_items"]
+                del data["selections"]
+                del data["selected_cells_by_row"]
+                del data["cell_selections"]
+                del data["items"]
+                del data["require_option"]
+                del data["option_functions"]
+                info_items += [
+                    ["",""],
+                    ["    get_function_data():", "-*"*30],
+                    ["",""],
+                    ["show_header", str(self.show_header)],
+                ]
+                info_items += [[key, repr(value)] for key, value in data.items()]
+                info_header = ["Option", "Value"]
+                info_data = {
+                    "items": info_items,
+                    "header": info_header,
+                    "title": f"{self.title} Info",
+                    "colours_start": self.help_colours_start,
+                    "colours": help_colours,
+                    "show_footer": True,
+                    "max_selected": 1,
+                    "keys_dict": help_keys,
+                    "disabled_keys": [ord('?'), ord('v'), ord('V'), ord('m'), ord('M'), ord('l'), curses.KEY_ENTER, ord('\n')],
+                    "highlight_full_row": True,
+                    "top_gap": 0,
+                    "paginate": self.paginate,
+                    "centre_in_terminal": False,
+                    "centre_in_terminal_vertical": True,
+                    "hidden_columns": [],
+                    "reset_colours": False,
+
+                }
+                OptionPicker = Picker(self.stdscr, **info_data)
+                s, o, f = OptionPicker.run()
+                
+                self.draw_screen(self.indexed_items, self.highlights)
 
             elif self.check_key("exit", key, self.keys_dict):
                 self.stdscr.clear()
-                function_data = self.get_function_data()
-                function_data["last_key"] = key
-                return [], "", function_data
+                if len(self.loaded_files) <= 1:
+                    function_data = self.get_function_data()
+                    function_data["last_key"] = key
+                    return [], "", function_data
+                else:
+                    del self.loaded_files[self.loaded_file_index]
+                    del self.loaded_file_states[self.loaded_file_index]
+                    self.loaded_file_index = min(self.loaded_file_index, len(self.loaded_files)-1)
+                    self.loaded_file = self.loaded_files[self.loaded_file_index]
+
+
+                    # If we already have a loaded state for this file
+                    if self.loaded_file_states[self.loaded_file_index]:
+                        self.set_function_data(self.loaded_file_states[self.loaded_file_index])
+                    else:
+                        self.set_function_data({}, reset_absent_variables=True)
+                        self.load_file(self.loaded_file)
+                    self.draw_screen(self.indexed_items, self.highlights)
+
             elif self.check_key("full_exit", key, self.keys_dict):
                 close_curses(self.stdscr)
                 exit()
@@ -2612,6 +2917,7 @@ class Picker:
                 # 4. if self.cancel_is_back (e.g., notification) then we exit
                 # 4. selecting
 
+                pass
                 # Cancel visual de/selection
                 if self.is_selecting or self.is_deselecting:
                     self.start_selection = -1
@@ -2689,41 +2995,51 @@ class Picker:
 
             elif self.check_key("mode_next", key, self.keys_dict): # tab key
                 self.logger.info(f"key_function mode_next")
-                # apply setting 
-                prev_mode_index = self.mode_index
-                self.mode_index = (self.mode_index+1)%len(self.modes)
-                mode = self.modes[self.mode_index]
-                for key, val in mode.items():
-                    if key == 'filter':
-                        if 'filter' in self.modes[prev_mode_index]:
-                            self.filter_query = self.filter_query.replace(self.modes[prev_mode_index]['filter'], '')
-                        self.filter_query = f"{self.filter_query.strip()} {val.strip()}".strip()
-                        prev_index = self.indexed_items[self.cursor_pos][0] if len(self.indexed_items)>0 else 0
-
-                        self.indexed_items = filter_items(self.items, self.indexed_items, self.filter_query)
-                        if prev_index in [x[0] for x in self.indexed_items]: new_index = [x[0] for x in self.indexed_items].index(prev_index)
-                        else: new_index = 0
-                        self.cursor_pos = new_index
-                        # Re-sort self.items after applying filter
-                        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
+                if len(self.modes):
+                    prev_mode_index = self.mode_index
+                    self.mode_index = (self.mode_index+1)%len(self.modes)
+                    mode = self.modes[self.mode_index]
+                    for key, val in mode.items():
+                        if key == 'filter':
+                            if 'filter' in self.modes[prev_mode_index]:
+                                self.filter_query = self.filter_query.replace(self.modes[prev_mode_index]['filter'], '')
+                            self.filter_query = f"{self.filter_query.strip()} {val.strip()}".strip()
+                            prev_index = self.indexed_items[self.cursor_pos][0] if len(self.indexed_items)>0 else 0
+
+                            self.indexed_items = filter_items(self.items, self.indexed_items, self.filter_query)
+                            if prev_index in [x[0] for x in self.indexed_items]: new_index = [x[0] for x in self.indexed_items].index(prev_index)
+                            else: new_index = 0
+                            self.cursor_pos = new_index
+                            # Re-sort self.items after applying filter
+                            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
             elif self.check_key("mode_prev", key, self.keys_dict): # shift+tab key
                 self.logger.info(f"key_function mode_prev")
-                # apply setting 
-                prev_mode_index = self.mode_index
-                self.mode_index = (self.mode_index-1)%len(self.modes)
-                mode = self.modes[self.mode_index]
-                for key, val in mode.items():
-                    if key == 'filter':
-                        if 'filter' in self.modes[prev_mode_index]:
-                            self.filter_query = self.filter_query.replace(self.modes[prev_mode_index]['filter'], '')
-                        self.filter_query = f"{self.filter_query.strip()} {val.strip()}".strip()
-                        prev_index = self.indexed_items[self.cursor_pos][0] if len(self.indexed_items)>0 else 0
-                        self.indexed_items = filter_items(self.items, self.indexed_items, self.filter_query)
-                        if prev_index in [x[0] for x in self.indexed_items]: new_index = [x[0] for x in self.indexed_items].index(prev_index)
-                        else: new_index = 0
-                        self.cursor_pos = new_index
-                        # Re-sort self.items after applying filter
-                        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
+                if len(self.modes):
+                    prev_mode_index = self.mode_index
+                    self.mode_index = (self.mode_index-1)%len(self.modes)
+                    mode = self.modes[self.mode_index]
+                    for key, val in mode.items():
+                        if key == 'filter':
+                            if 'filter' in self.modes[prev_mode_index]:
+                                self.filter_query = self.filter_query.replace(self.modes[prev_mode_index]['filter'], '')
+                            self.filter_query = f"{self.filter_query.strip()} {val.strip()}".strip()
+                            prev_index = self.indexed_items[self.cursor_pos][0] if len(self.indexed_items)>0 else 0
+                            self.indexed_items = filter_items(self.items, self.indexed_items, self.filter_query)
+                            if prev_index in [x[0] for x in self.indexed_items]: new_index = [x[0] for x in self.indexed_items].index(prev_index)
+                            else: new_index = 0
+                            self.cursor_pos = new_index
+                            # Re-sort self.items after applying filter
+                            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
+            elif self.check_key("file_next", key, self.keys_dict):
+                if len(self.loaded_files):
+                    self.loaded_file_index = (self.loaded_file_index + 1) % len(self.loaded_files)
+                    self.loaded_file = self.loaded_files[self.loaded_file_index]
+
+            elif self.check_key("file_prev", key, self.keys_dict):
+                if len(self.loaded_files):
+                    self.loaded_file_index = (self.loaded_file_index - 1) % len(self.loaded_files)
+                    self.loaded_file = self.loaded_files[self.loaded_file_index]
+
             elif self.check_key("pipe_input", key, self.keys_dict):
                 self.logger.info(f"key_function pipe_input")
                 # usrtxt = "xargs -d '\n' -I{}  "
@@ -3036,7 +3352,8 @@ def parse_arguments() -> Tuple[argparse.Namespace, dict]:
     """ Parse command line arguments. """
     parser = argparse.ArgumentParser(description='Convert table to list of lists.')
     # parser.add_argument('filename', type=str, help='The file to process')
-    parser.add_argument('-i', dest='file', help='File containing the table to be converted.')
+    # parser.add_argument('-i', dest='file', help='File containing the table to be converted.')
+    parser.add_argument('-i', dest='file', nargs='+', help='File containing the table to be converted.')
     parser.add_argument('--load', '-l', dest='load', type=str, help='Load file from Picker dump.')
     parser.add_argument('--stdin', dest='stdin', action='store_true', help='Table passed on stdin')
     parser.add_argument('--stdin2', action='store_true', help='Table passed on stdin')
@@ -3058,7 +3375,8 @@ def parse_arguments() -> Tuple[argparse.Namespace, dict]:
     }
     
     if args.file:
-        input_arg = args.file
+        input_arg = args.file[0]
+
     elif args.stdin:
         input_arg = '--stdin'
     elif args.stdin2:
@@ -3096,9 +3414,14 @@ def parse_arguments() -> Tuple[argparse.Namespace, dict]:
         filetype = args.file_type
     
 
-    items, header = table_to_list(input_arg, args.delimiter, filetype)
+    items, header, sheets = table_to_list(input_arg, args.delimiter, filetype)
     function_data["items"] = items
     if header: function_data["header"] = header
+    function_data["sheets"] = sheets
+    if args.file:
+        function_data["loaded_file"] = args.file[0]
+        function_data["loaded_files"] = args.file
+
     return args, function_data
 
 def start_curses() -> curses.window:
@@ -3188,7 +3511,8 @@ def main() -> None:
     # function_data["infobox_title"] = "Title"
     # function_data["footer_string"] = "Title"
     function_data["highlights"] = highlights
-    function_data["show_footer"] = False
+    # function_data["show_footer"] = False
+    # function_data["paginate"] = True
     # function_data["debug"] = True
     # function_data["debug_level"] = 1
     stdscr = start_curses()

listpick/ui/footer.py

@@ -50,32 +50,109 @@ class StandardFooter(Footer):
     def draw(self, h, w):
         state = self.get_state()
         # Fill background
-        for i in range(self.height):
-            self.stdscr.addstr(h-self.height+i, 0, ' '*(w-1), curses.color_pair(self.colours_start+20))
 
+
+        sheets_y=-1
         if state["footer_string"]:
-            footer_string_width = min(w-1, len(state["footer_string"])+2)
 
-            disp_string = f"{state["footer_string"][:footer_string_width]}"
-            disp_string = f" {disp_string:>{footer_string_width-2}} "
-            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))
         
+            footer_string_y = h-1
             picker_info_y = h-3
             sort_info_y = h-2
+            
             self.height = 3
 
         else:
             picker_info_y = h-2
             sort_info_y = h-1
-            ""
-            select_mode = "C"
-            if state["is_selecting"]: select_mode = "VS"
-            elif state["is_deselecting"]: select_mode = "VDS"
-            if state["pin_cursor"]: select_mode = f"{select_mode} "
-            self.stdscr.addstr(h - 1, w-35, f"{select_mode:>33} ", curses.color_pair(self.colours_start+20))
+            footer_string_y = -1
             self.height = 2
 
+        if len(state["sheets"]) > 1:
+            self.height += 1
+            picker_info_y -= 1
+            sort_info_y -= 1
+            footer_string_y -= 1
+            sheets_y = h-1
+
+        if len(state["loaded_files"]) > 1 and state["loaded_file"] in state["loaded_files"]:
+            self.height += 1
+            picker_info_y -= 1
+            sort_info_y -= 1
+            footer_string_y -= 1
+            sheets_y -= 1
+
+            files_y = h-1
+
+
+        for i in range(self.height):
+            self.stdscr.addstr(h-self.height+i, 0, ' '*(w-1), curses.color_pair(self.colours_start+20))
+
+        if len(state["loaded_files"]) > 1 and state["loaded_file"] in state["loaded_files"]:
+
+            sep = "◢ "
+            files = [x.split("/")[-1] for x in state["loaded_files"]]
+            filename = state["loaded_file"].split("/")[:-1]
+
+            files_str = sep.join(files)
+            files_str = files_str[:w-2]
+
+            idx = state["loaded_file_index"]
+            current_file_x = sum((len(x) for x in files[:idx])) + idx*len(sep)
+            current_file_str = state["loaded_file"].split("/")[-1]
+            current_file_x_end = current_file_x + len(current_file_str) + 2
+            self.stdscr.addstr(files_y, 0, ' '*(w-1), curses.color_pair(self.colours_start+4))
+            if current_file_x_end < w:
+
+                self.stdscr.addstr(files_y, 0, f" {files_str}", curses.color_pair(self.colours_start+4))
+
+                self.stdscr.addstr(files_y, current_file_x, f" {current_file_str}{sep[0]}", curses.color_pair(self.colours_start+4) | curses.A_REVERSE)
+            else:
+                files_str = sep.join(files)
+                files_str = files_str[current_file_x_end-w:current_file_x_end][:w-2]
+                self.stdscr.addstr(files_y, 0, f" {files_str}", curses.color_pair(self.colours_start+4))
+
+                self.stdscr.addstr(files_y, w - (len(current_file_str)+3), f" {current_file_str}{sep[0]}", curses.color_pair(self.colours_start+4) | curses.A_REVERSE)
+
+        if len(state["sheets"]) > 1:
+
+            sep = "◢ "
+            sheets = [x.split("/")[-1] for x in state["sheets"]]
+            filename = state["sheet_name"].split("/")[:-1]
+
+            sheets_str = sep.join(sheets)
+            sheets_str = sheets_str[:w-2]
+
+            idx = state["sheet_index"]
+            current_sheet_x = sum((len(x) for x in sheets[:idx])) + idx*len(sep)
+            current_sheet_str = state["sheet_name"].split("/")[-1]
+            current_sheet_x_end = current_sheet_x + len(current_sheet_str) + 2
+            self.stdscr.addstr(sheets_y, 0, ' '*(w-1), curses.color_pair(self.colours_start+4))
+            if current_sheet_x_end < w:
+
+                self.stdscr.addstr(sheets_y, 0, f" {sheets_str}", curses.color_pair(self.colours_start+4))
+
+                self.stdscr.addstr(sheets_y, current_sheet_x, f" {current_sheet_str}{sep[0]}", curses.color_pair(self.colours_start+4) | curses.A_REVERSE)
+            else:
+                sheets_str = sep.join(sheets)
+                sheets_str = sheets_str[current_sheet_x_end-w:current_sheet_x_end][:w-2]
+                self.stdscr.addstr(sheets_y, 0, f" {sheets_str}", curses.color_pair(self.colours_start+4))
+
+                self.stdscr.addstr(sheets_y, w - (len(current_sheet_str)+3), f" {current_sheet_str}{sep[0]}", curses.color_pair(self.colours_start+4) | curses.A_REVERSE)
+                
+
+
+
+        if state["footer_string"]:
+            footer_string_width = min(w-1, len(state["footer_string"])+2)
+
+            disp_string = f"{state["footer_string"][:footer_string_width]}"
+            disp_string = f" {disp_string:>{footer_string_width-2}} "
+            self.stdscr.addstr(footer_string_y, w-footer_string_width-1, " "*footer_string_width, curses.color_pair(self.colours_start+24))
+            self.stdscr.addstr(footer_string_y, w-footer_string_width-1, f"{disp_string}", curses.color_pair(self.colours_start+24))
+
+        
+
 
         if state["filter_query"]:
             self.stdscr.addstr(h - 2, 2, f" Filter: {state['filter_query']} "[:w-40], curses.color_pair(self.colours_start+20) | curses.A_BOLD)
@@ -93,10 +170,14 @@ class StandardFooter(Footer):
         # Cursor & selection info
         selected_count = sum(state["selections"].values())
         if state["paginate"]:
-            cursor_disp_str = f" [{selected_count}] {state['cursor_pos']+1}/{len(state['indexed_items'])}  Page {state['cursor_pos']//state['items_per_page']}/{len(state['indexed_items'])}"
+            # cursor_disp_str = f" [{selected_count}] {state['cursor_pos']+1}/{len(state['indexed_items'])} | Page {state['cursor_pos']//state['items_per_page']}/{len(state['indexed_items'])//state['items_per_page']} | {select_mode}"
+            cursor_disp_str = f" [{selected_count}] {state['cursor_pos']+1}/{len(state['indexed_items'])} | Page {state['cursor_pos']//state['items_per_page']}/{len(state['indexed_items'])//state['items_per_page']} | {select_mode}"
         else:
             cursor_disp_str = f" [{selected_count}] {state['cursor_pos']+1}/{len(state['indexed_items'])} | {select_mode}"
-        self.stdscr.addstr(picker_info_y, w-35, f"{cursor_disp_str:>33} ", curses.color_pair(self.colours_start+20))
+
+        # Maximum chars that should be displayed
+        max_chars = min(len(cursor_disp_str)+2, w)
+        self.stdscr.addstr(picker_info_y, w-max_chars, f"{cursor_disp_str:>{max_chars-2}} ", curses.color_pair(self.colours_start+20))
 
 
         # Sort info
@@ -105,7 +186,8 @@ class StandardFooter(Footer):
         sort_order_info = "Desc." if state["sort_reverse"] else "Asc."
         sort_order_info = "▼" if state["sort_reverse"][state['sort_column']] else "▲"
         sort_disp_str = f" Sort: ({sort_column_info}, {sort_method_info}, {sort_order_info}) "
-        self.stdscr.addstr(sort_info_y, w-35, f"{sort_disp_str:>34}", curses.color_pair(self.colours_start+20))
+        max_chars = min(len(sort_disp_str)+2, w)
+        self.stdscr.addstr(sort_info_y, w-max_chars, f"{sort_disp_str:>{max_chars-1}}", curses.color_pair(self.colours_start+20))
 
         self.stdscr.refresh()
 

listpick/ui/keys.py

@@ -47,8 +47,8 @@ picker_keys = {
     "search_input":                     [ord('/')],
     "settings_input":                   [ord('`')],
     "settings_options":                 [ord('~')],
-    "continue_search_forward":          [ord('n'), ord('i')],
-    "continue_search_backward":         [ord('N'), ord('I')],
+    "continue_search_forward":          [ord('n')],
+    "continue_search_backward":         [ord('N')],
     "cancel":                           [27], # Escape key
     "opts_input":                       [ord(':')],
     "opts_select":                      [ord('o')],
@@ -80,6 +80,7 @@ picker_keys = {
     "add_column_after":                       [ord('+')],
     # "add_row_before":                          [ord('=')],
     "add_row_after":                          [ord('=')],
+    "info":                             [ord('i')], 
 }
 
 
@@ -106,8 +107,8 @@ help_keys = {
     "search_input":                     [ord('/')],
     "settings_input":                   [ord('`')],
     "settings_options":                 [ord('~')],
-    "continue_search_forward":          [ord('n'), ord('i')],
-    "continue_search_backward":         [ord('N'), ord('I')],
+    "continue_search_forward":          [ord('n')],
+    "continue_search_backward":         [ord('N')],
     "cancel":                           [27], # Escape key
     "col_select":                       [ord('0'), ord('1'), ord('2'), ord('3'), ord('4'), ord('5'), ord('6'), ord('7'), ord('8'), ord('9')],
     "col_select_next":                             [ord('>')], 

listpick/utils/table_to_list_of_lists.py

@@ -37,10 +37,27 @@ def strip_whitespace(item: Iterable) -> Iterable:
 
 
 
-def table_to_list(input_arg: str, delimiter:str='\t', file_type:Optional[str]=None) -> Tuple[list[list[str]], list[str]]:
+def table_to_list(
+
+        input_arg: str,
+        delimiter:str='\t',
+        file_type:Optional[str]=None,
+        sheet_number:int = 0,
+
+) -> Tuple[list[list[str]], list[str], list[str]]:
     """ 
     Convert data string to list. The input_arg
     Currently accepts: csv, tsv, json, xlsx, ods
+
+
+    input_arg: filename
+
+
+    returns:
+        items: list[list[str]]
+        header: list[str]
+        sheets: list[str]
+    
     """
     logger.info("function: table_to_list (table_to_list_of_lists.py)")
     table_data = []
@@ -76,10 +93,10 @@ def table_to_list(input_arg: str, delimiter:str='\t', file_type:Optional[str]=No
             table_data = csv_string_to_list(input_data)
             table_data = strip_whitespace(table_data)
             # table_data = parse_csv_like(input_data, ",")
-            return table_data, []
+            return table_data, [], []
         except Exception as e:
             print(f"Error reading CSV/TSV input: {e}")
-            return [], []
+            return [], [], []
 
     elif file_type == 'tsv':
         try:
@@ -99,10 +116,10 @@ def table_to_list(input_arg: str, delimiter:str='\t', file_type:Optional[str]=No
             
             table_data = parse_csv_like(input_data, delimiter)
             table_data = strip_whitespace(table_data)
-            return table_data, []
+            return table_data, [], []
         except Exception as e:
             print(f"Error reading CSV/TSV input: {e}")
-            return [], []
+            return [], [], []
 
     elif file_type == 'json':
         try:
@@ -115,55 +132,53 @@ def table_to_list(input_arg: str, delimiter:str='\t', file_type:Optional[str]=No
                 input_data = read_file_content(input_arg)
             
             table_data = json.loads(input_data)
-            return table_data, []
+            return table_data, [], []
         except json.JSONDecodeError as e:
             print(f"Error decoding JSON input: {e}")
-            return [], []
+            return [], [], []
         except FileNotFoundError as e:
             print(f"File not found: {e}")
-            return [], []
+            return [], [], []
 
     elif file_type == 'xlsx':
-        from openpyxl import load_workbook
+        import pandas as pd
+        ef = pd.ExcelFile(input_arg)
+        sheets = ef.sheet_names
+        if sheet_number < len(sheets):
+            df = pd.read_excel(input_arg, sheet_name=sheet_number)
+        else:
+            df = pd.read_excel(input_arg)
+        table_data = df.values.tolist()
         try:
-            if input_arg == '--stdin':
-                input_data = sys.stdin.read()
-                with open('temp.xlsx', 'wb') as f:
-                    f.write(input_data.encode())
-            elif input_arg == '--stdin2':
-                input_count = int(sys.stdin.readline())
-                input_data = "\n".join([sys.stdin.readline() for i in range(input_count)])
-                with open('temp.xlsx', 'wb') as f:
-                    f.write(input_data.encode())
-            else:
-                input_data = read_file_content(input_arg)
-                with open('temp.xlsx', 'wb') as f:
-                    f.write(input_data.encode())
-            
-            wb = load_workbook(filename='temp.xlsx')
-            sheet = wb.active
-            for row in sheet.iter_rows(values_only=True):
-                table_data.append(list(row))
-            return table_data, []
-        except Exception as e:
-            print(f"Error loading Excel file: {e}")
-            return [], []
+            header = list(df.columns)
+        except:
+            header = []
+        return table_data, header, sheets
 
     elif file_type == 'ods':
         try:
             import pandas as pd
-            df = pd.read_excel(input_arg, engine='odf')
+            ef = pd.ExcelFile(input_arg)
+            sheets = ef.sheet_names
+            if sheet_number < len(sheets):
+                df = pd.read_excel(input_arg, engine='odf', sheet_name=sheet_number)
+            else:
+                df = pd.read_excel(input_arg, engine='odf')
             table_data = df.values.tolist()
-            return table_data, []
+            try:
+                header = list(df.columns)
+            except:
+                header = []
+            return table_data, header, sheets
         except Exception as e:
             print(f"Error loading ODS file: {e}")
-            return [], []
+            return [], [], []
     elif file_type == 'pkl':
         with open(os.path.expandvars(os.path.expanduser(input_arg)), 'rb') as f:
             loaded_data = pickle.load(f)
         items = loaded_data["items"] if "items" in loaded_data else []
         header = loaded_data["header"] if "header" in loaded_data else []
-        return items, header
+        return items, header, []
 
     if input_arg == '--stdin':
         input_data = sys.stdin.read()
@@ -175,7 +190,7 @@ def table_to_list(input_arg: str, delimiter:str='\t', file_type:Optional[str]=No
     
     table_data = parse_csv_like(input_data, delimiter)
 
-    return table_data, []
+    return table_data, [], []
 
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(description='Convert table to list of lists.')

listpick/utils/utils.py

@@ -311,7 +311,7 @@ def openFiles(files: list[str]) -> str:
         #     return result.stderr.read().decode("utf-8").strip()
     return ""
 
-def file_picker() -> str:
+def file_picker() -> list[str]:
     """ Run file picker (yazi by default) and return the path of the file picked. If no file is picked an empty string is returned. """
 
     logger.info("function: file_picker (utils.py)")
@@ -320,10 +320,11 @@ def file_picker() -> str:
 
         lines = tmpfile.readlines()
         if lines:
-            filename = lines[0].decode("utf-8").strip()
-            return filename
+            filenames = [line.decode("utf-8").strip() for line in lines]
+            # filename = lines[0].decode("utf-8").strip()
+            return filenames
         else:
-            return ""
+            return []
 
             
 def dir_picker() -> str:

{listpick-0.1.13.62.dist-info → listpick-0.1.14.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: listpick
-Version: 0.1.13.62
+Version: 0.1.14.1
 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
@@ -26,6 +26,7 @@ Requires-Dist: pandas; extra == "full"
 Requires-Dist: pyperclip; extra == "full"
 Requires-Dist: toml; extra == "full"
 Requires-Dist: traitlets; extra == "full"
+Requires-Dist: odfpy; extra == "full"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{listpick-0.1.13.62.dist-info → listpick-0.1.14.1.dist-info}/RECORD

@@ -1,12 +1,12 @@
 listpick/__init__.py,sha256=ExXc97-bibodH--wlwpQivl0zCNR5D1hvpvrf7OBofU,154
 listpick/__main__.py,sha256=wkCjDdqw093W27yWwnlC3nG_sMRKaIad7hHHWy0RBgY,193
-listpick/listpick_app.py,sha256=OE6Py8M0R0TVAb72SCiCk9MSc3TLh4ZgO2qe5xBtNro,166710
+listpick/listpick_app.py,sha256=-QdN2nv3Aii_vJdt8ROOkL_v-mI2TNQi1q34f5tGAno,181819
 listpick/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 listpick/ui/build_help.py,sha256=_rVKKrX3HfFJtw-pyeNb2lQWbml4-AAw8sZIUYGn97Y,8731
-listpick/ui/footer.py,sha256=s1L68MNmhWwbWRy0mn0ChmnE_dMQBAzNlTv917pyHE0,10673
+listpick/ui/footer.py,sha256=85sVZ6zvzZXSc0TwgvCHGuzGElp6KwUVzwzF5VQwLyY,14219
 listpick/ui/help_screen.py,sha256=zbfGIgb-IXtATpl4_Sx7nPbsnRXZ7eiMYlCKGS9EFmw,5608
 listpick/ui/input_field.py,sha256=eyoWHoApdZybjfXcp7Eth7xwb-C-856ZVnq5j_Q3Ojs,30412
-listpick/ui/keys.py,sha256=TzaadgBP_rC7jbp--RFJZDOkHd0EB4K1wToDTiVs6CI,13029
+listpick/ui/keys.py,sha256=8LRO0CqX8tn6LM9irwSK7eA_Go-v0nBDztWtQKPFXUk,13042
 listpick/ui/pane_stuff.py,sha256=7GXa4UnV_7YmBv-baRi5moN51wYcuS4p0odl5C3m0Tc,169
 listpick/ui/picker_colours.py,sha256=FLOzvkq83orrN2bL0Mw-6RugWOZyuwUjQCrUFMUnKGY,11563
 listpick/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -21,11 +21,11 @@ listpick/utils/picker_log.py,sha256=SW6GmjxpI7YrSf72fSr4O8Ux0fY_OzaSXUgTFdz6Xo4,
 listpick/utils/search_and_filter_utils.py,sha256=XxGfkyDVXO9OAKcftPat8IReMTFIuTH-jorxI4o84tg,3239
 listpick/utils/searching.py,sha256=Xk5UIqamNHL2L90z3ACB_Giqdpi9iRKoAJ6pKaqaD7Q,3093
 listpick/utils/sorting.py,sha256=WZZiVlVA3Zkcpwji3U5SNFlQ14zVEk3cZJtQirBkecQ,5329
-listpick/utils/table_to_list_of_lists.py,sha256=T-i-nV1p6g8UagdgUPKrhIGpKY_YXZDxf4xZzcPepNA,7635
-listpick/utils/utils.py,sha256=3La3uyij4QazWV_8GpXJ7nFFMHY2sRTW2OWXJTX-LeY,13791
-listpick-0.1.13.62.dist-info/licenses/LICENSE.txt,sha256=2mP-MRHJptADDNE9VInMNg1tE-C6Qv93Z4CCQKrpg9w,1061
-listpick-0.1.13.62.dist-info/METADATA,sha256=YNt1kbQKoIp0L_kCs8GZwEWPbt6hDquSrq4GmDlpoW0,8053
-listpick-0.1.13.62.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-listpick-0.1.13.62.dist-info/entry_points.txt,sha256=-QCf_BKIkUz35Y9nkYpjZWs2Qg0KfRna2PAs5DnF6BE,43
-listpick-0.1.13.62.dist-info/top_level.txt,sha256=5mtsGEz86rz3qQDe0D463gGjAfSp6A3EWg4J4AGYr-Q,9
-listpick-0.1.13.62.dist-info/RECORD,,
+listpick/utils/table_to_list_of_lists.py,sha256=Ox_4OWtZcFp5XWcItlMqE6_Q27YiJz7M9w23Y9vfzYQ,7604
+listpick/utils/utils.py,sha256=McOl9uT3jh7l4TIWeSd8ZGjK_e7r0YZF0Gl20yI6fl0,13873
+listpick-0.1.14.1.dist-info/licenses/LICENSE.txt,sha256=2mP-MRHJptADDNE9VInMNg1tE-C6Qv93Z4CCQKrpg9w,1061
+listpick-0.1.14.1.dist-info/METADATA,sha256=pEzvDtilAXf9X5luuKJXLfL25sHxBiaVAVrirREgt0I,8090
+listpick-0.1.14.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+listpick-0.1.14.1.dist-info/entry_points.txt,sha256=-QCf_BKIkUz35Y9nkYpjZWs2Qg0KfRna2PAs5DnF6BE,43
+listpick-0.1.14.1.dist-info/top_level.txt,sha256=5mtsGEz86rz3qQDe0D463gGjAfSp6A3EWg4J4AGYr-Q,9
+listpick-0.1.14.1.dist-info/RECORD,,