listpick 0.1.13.61__py3-none-any.whl → 0.1.14.0__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,
 
@@ -173,6 +174,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 +239,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,7 +298,7 @@ class Picker:
         self.registers = {}
         
         self.SORT_METHODS = SORT_METHODS
-        self.command_stack = []
+        self.command_stack = command_stack
         self.leftmost_column = leftmost_column
         self.leftmost_char = leftmost_char
 
@@ -297,7 +312,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
@@ -312,6 +326,17 @@ class Picker:
         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)
 
@@ -320,6 +345,8 @@ class Picker:
         self.footer = self.footer_options[self.footer_style]
 
 
+
+
     def calculate_section_sizes(self):
         """
         Calculte the following for the Picker:
@@ -495,8 +522,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 +587,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 +636,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 +1091,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,
@@ -1136,17 +1183,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)
@@ -1260,7 +1345,12 @@ class Picker:
         message_width = notification_width-5
 
         if not message: message = "!!"
-        submenu_items = ["  "+message[i*message_width:(i+1)*message_width] for i in range(len(message)//message_width+1)]
+        if type(message) == type(""):
+            mw = message_width
+            submenu_items = [[message[i*mw:(i+1)*mw]] for i in range(len(message)//mw+1)]
+        elif type(message) != type([]):
+            submenu_items = [["  !!"]]
+
 
         notification_remap_keys = { 
             curses.KEY_RESIZE: curses.KEY_F5,
@@ -1270,6 +1360,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,
@@ -1286,6 +1377,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()
@@ -1338,15 +1433,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":
@@ -1391,6 +1486,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():
@@ -1458,9 +1594,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()")
@@ -1768,17 +1904,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")
 
@@ -1910,6 +2070,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. """
@@ -1958,7 +2148,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
@@ -2040,9 +2230,24 @@ class Picker:
 
             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)
+
             elif self.check_key("full_exit", key, self.keys_dict):
                 close_curses(self.stdscr)
                 exit()
@@ -2607,6 +2812,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
@@ -2684,41 +2890,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{}  "
@@ -2760,26 +2976,46 @@ class Picker:
                     if not selected_indices:
                         selected_indices = [self.indexed_items[self.cursor_pos][0]]
 
-                    full_values = [format_row_full(self.items[i], self.hidden_columns) for i in selected_indices]  # Use format_row_full for full data
-                    full_values = [self.items[i][self.selected_column] for i in selected_indices]
+                    # full_values = [format_row_full(self.items[i], self.hidden_columns) for i in selected_indices]  # Use format_row_full for full data
+                    if self.cell_cursor:
+                        
+                        full_values = []
+                        for row in self.selected_cells_by_row.keys():
+                            selected_cell_row_str = ""
+                            for cell in self.selected_cells_by_row[row]:
+                                if " " in self.items[row][cell]:
+                                    selected_cell_row_str += repr(self.items[row][cell])
+                                else:
+                                    selected_cell_row_str += self.items[row][cell]
+                                selected_cell_row_str += "\t"
+                            full_values.append(selected_cell_row_str.strip())
+
+
+                        # full_values = ["\t".join([repr(self.items[key][cell]) for cell in self.selected_cells_by_row[key]]) for key in self.selected_cells_by_row.keys()]
+                        # full_values = ["\t".join([self.items[key][cell] for cell in self.selected_cells_by_row[key]]) for key in self.selected_cells_by_row.keys()]
+                    else:
+                        full_values = [self.items[i][self.selected_column] for i in selected_indices]
                     if full_values:
-                        command = usrtxt.split()
+                        # command = usrtxt.split()
+                        command = usrtxt
                         # command = ['xargs', '-d' , '"\n"' '-I', '{}', 'mpv', '{}']
                         # command = ['xargs', '-d' , '"\n"' '-I', '{}', 'mpv', '{}']
                         # command = "xargs -d '\n' -I{} mpv {}"
 
                         try:
-                            process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+                            process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, shell=True)
 
                             if process.stdin != None:
                                 for value in full_values:
-                                    process.stdin.write((repr(value) + '\n').encode())
+                                    process.stdin.write((value + '\n').encode())
+                                    # process.stdin.write((value + '\n').encode())
 
                                 process.stdin.close()
 
                                 self.notification(self.stdscr, message=f"{len(full_values)} strings piped to {repr(usrtxt)}")
                         except Exception as e:
                             self.notification(self.stdscr, message=f"{e}")
+                            # self.notification(self.stdscr, message=f"Error: {str(e)}")
 
 
             elif self.check_key("open", key, self.keys_dict):
@@ -3011,7 +3247,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')
@@ -3033,7 +3270,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:
@@ -3071,9 +3309,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:
@@ -3158,12 +3401,13 @@ 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["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/utils/generate_data.py

@@ -25,7 +25,10 @@ def generate_columns(funcs: list, files: list) -> list[list[str]]:
     for file in files:
         item = []
         for func in funcs:
-            item.append(func(file))
+            try:
+                item.append(func(file))
+            except:
+                item.append("")
         items.append(item)
         
     return items

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:
@@ -350,6 +351,8 @@ def pad_lists_to_same_length(list_of_lists: list[list[str]]) -> list[list[str]]:
     """ Ensure that all lists in a list of lists are of the same length. Pad any shorter sublists with empty strings. """
     if not list_of_lists or list_of_lists in [[], [[]]]:
         return []
+    if type(list_of_lists) == type([]) and len(list_of_lists) and type(list_of_lists[0]) == type(""):
+        list_of_lists = [[x] for x in list_of_lists]
 
     # Find the maximum length of the sublists
     lengths = [len(sublist) for sublist in list_of_lists]

{listpick-0.1.13.61.dist-info → listpick-0.1.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: listpick
-Version: 0.1.13.61
+Version: 0.1.14.0
 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
@@ -80,7 +81,7 @@ close_curses(stdscr)
 Use the listpick binary to generate and display rows based on a list of commands:
 
 ```
-wget https://raw.githubusercontent.com/grimandgreedy/listpick/refs/heads/master/examples/list_files.toml
+wget https://raw.githubusercontent.com/grimandgreedy/listpick/refs/heads/master/examples/data_generation/list_files.toml
 listpick -g list_files.py
 ```
 
@@ -100,9 +101,9 @@ The application allows you to:
 ## Examples
 
 
-### Identify video duplicates (./examples/video_duplicates.toml):
+### Identify video duplicates (./examples/data_generation//video_duplicates.toml):
 ```python 
-listpick -g ./examples/video_duplicates.toml
+listpick -g ./examples/data_generation/video_duplicates.toml
 ```
   - From the list of commands in the toml file we generate the properties we will use to identify the duplicates. 
 
@@ -142,7 +143,7 @@ listpick -i ~/dn.pkl -t pkl
 
 2. **Generate data based on an toml file with relevant commands to generate the rows.**
 ```python 
-listpick -g ./examples/video_duplicates.toml
+listpick -g ./examples/data_generation/video_duplicates.toml
 ```
 
   - See ./examples/

{listpick-0.1.13.61.dist-info → listpick-0.1.14.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
 listpick/__init__.py,sha256=ExXc97-bibodH--wlwpQivl0zCNR5D1hvpvrf7OBofU,154
 listpick/__main__.py,sha256=wkCjDdqw093W27yWwnlC3nG_sMRKaIad7hHHWy0RBgY,193
-listpick/listpick_app.py,sha256=xCtAMJTeWwos2XTCN7PwZgEgo3lAKmsp74M0cNgyvUI,165274
+listpick/listpick_app.py,sha256=3nGXMVky_jftqWbzSLTkW6GAm0_lCKaJGe_WBTAo5xU,176388
 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
@@ -14,18 +14,18 @@ listpick/utils/clipboard_operations.py,sha256=ORdNm2kgGbfs51xJSvgJPERgoSmBgT11ax
 listpick/utils/config.py,sha256=MEnAZg2Rhfl38XofEIN0uoVAOY7I0ftc79Evk3fOiVw,1654
 listpick/utils/dump.py,sha256=60YVIMNtBoYvWhmzfTJOsNGcetOvcCB3_T7yv-bYTPQ,3838
 listpick/utils/filtering.py,sha256=uS9sW0inmFvq0cIrwRC1BfuP8kjAD5IWWtls4jGB-70,1199
-listpick/utils/generate_data.py,sha256=ByfEgPywAWp-Nzso5QgFr_Obf-TshZn8Evvb9EwQY3E,3000
+listpick/utils/generate_data.py,sha256=7sv6JRhk0-Gcj4kOlkzx4qPNBJZ-GFWg9vM77GktzpI,3073
 listpick/utils/options_selectors.py,sha256=Vbv4jRkUsSPs7g-EQAv9Q0nhYy6Z4sFsJqMjUIe1oeQ,2814
 listpick/utils/paste_operations.py,sha256=7wDXLPlxUgA3CA99gwsm47juWGO2YQ9EJghW06yo9vI,1242
 listpick/utils/picker_log.py,sha256=SW6GmjxpI7YrSf72fSr4O8Ux0fY_OzaSXUgTFdz6Xo4,805
 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=m4uzL2ZPVpFuboIola0_ZIfLzlbGqirdz0_oo61tIlU,13636
-listpick-0.1.13.61.dist-info/licenses/LICENSE.txt,sha256=2mP-MRHJptADDNE9VInMNg1tE-C6Qv93Z4CCQKrpg9w,1061
-listpick-0.1.13.61.dist-info/METADATA,sha256=VPjp9FR1XNwseaF4k0z4jyEHp3J7qXqXe3vFVlMXZrQ,7988
-listpick-0.1.13.61.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-listpick-0.1.13.61.dist-info/entry_points.txt,sha256=-QCf_BKIkUz35Y9nkYpjZWs2Qg0KfRna2PAs5DnF6BE,43
-listpick-0.1.13.61.dist-info/top_level.txt,sha256=5mtsGEz86rz3qQDe0D463gGjAfSp6A3EWg4J4AGYr-Q,9
-listpick-0.1.13.61.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.0.dist-info/licenses/LICENSE.txt,sha256=2mP-MRHJptADDNE9VInMNg1tE-C6Qv93Z4CCQKrpg9w,1061
+listpick-0.1.14.0.dist-info/METADATA,sha256=NDlbmPlgFWGV9V3UmkIyhSYXY71kjhp3GKvUkxzOPRE,8090
+listpick-0.1.14.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+listpick-0.1.14.0.dist-info/entry_points.txt,sha256=-QCf_BKIkUz35Y9nkYpjZWs2Qg0KfRna2PAs5DnF6BE,43
+listpick-0.1.14.0.dist-info/top_level.txt,sha256=5mtsGEz86rz3qQDe0D463gGjAfSp6A3EWg4J4AGYr-Q,9
+listpick-0.1.14.0.dist-info/RECORD,,