listpick 0.1.13.62__tar.gz → 0.1.14.0__tar.gz

{listpick-0.1.13.62 → listpick-0.1.14.0}/CHANGELOG.md

@@ -10,6 +10,9 @@
  - Bug fixes:
    - When data was centred vertically it would take an extra draw_screen loop to determine the proper column widths when the column sizes changed. This has been fixed.
    - Refreshing sorted data would resort it on the selected column rather than the sort column. Fixed.
+   - Fixed error when padding uneven lists when a list of strings is passed instead of a list of lists.
+   - Fixed crash when showing certain notifications. The notification message was not being split into lines properly.
+   - Fixed wrong page number in the footer when paginate=True.
  - Added some extra options to the settings:
    - Toggle header
    - Toggle row header
@@ -31,6 +34,13 @@
      - Much faster with very large data sets as we need to determine selected_cells_by_row every time we run self.draw_screen()
  - We can now pipe data from cells in multiple columns to a command.
    - e.g., pipe two cols to gnuplot
+ - Features added:
+   - Listpick now supports multiple open files.
+     - 'file_next' setting
+   - Listpick now supports files with multiple sheets.
+     - 'sheet_next' setting
+ - Fixed error when opening xlsx files.
+ - Can now open multiple files from the command line: listpick -i file1.csv, file2.csv
 
 ## [0.1.13] 2025-07-28
  - Cell-based picker is now supported.

{listpick-0.1.13.62/src/listpick.egg-info → listpick-0.1.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: listpick
-Version: 0.1.13.62
+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

{listpick-0.1.13.62 → listpick-0.1.14.0}/TODO.md

@@ -5,6 +5,21 @@ ASAP
 > - [ ] Unify in-app load and command-line input file
 > - [ ] Implement default_option_selector and pass the picker options (!!!)
 > - [ ] Make sure that all class initialisation variables are returned in the get_function_variables function.
+> - [ ] Go through each of the class variables and see which should be held as common in set_function_data
+> - [ ] Make input field look better:
+>   - [ ] During input
+>   - [ ] While being displayed.
+> - [ ] Handle multiple files
+>   - [x] Display 'open' files in footer
+>   - [x] Open multiple files with file_picker
+>   - [x] Switch between 'open' files
+>   - [ ] Handle unsaved files.
+>   - [x] Remember state when switching between files.
+>     - [x] Selections
+>  - [ ] Add support in the alternate footers
+> - [x] Handle files with multiple sheets.
+>  - [ ] Add support in the alternate footers
+> - [ ] Support opening multiple files from the command line.
 
 
 
@@ -259,6 +274,8 @@ ASAP
 > - [ ] Add a broader editor_picker option which enables/disables add/remove columns in the settings.
 > - [ ] If no -t type argument is given then guess filetype.
 > - [ ] Add row selection using 'V'--select all cells in a row.
+> - [ ] Add option for those who don't use a nerdfont.
+>   - [ ] refreshing symbol, pin cursor symbol,
 
 > [!Bug] Bugs
 > - [ ] fix resizing when input field active

{listpick-0.1.13.62 → listpick-0.1.14.0}/requirements.txt

@@ -10,3 +10,4 @@ tmp==0.0.2
 toml==0.10.2
 traitlets==5.14.3
 wcwidth==0.2.13
+odfpy

{listpick-0.1.13.62 → listpick-0.1.14.0}/setup.py

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

{listpick-0.1.13.62 → listpick-0.1.14.0}/src/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)
@@ -1275,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,
@@ -1291,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()
@@ -1343,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":
@@ -1396,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():
@@ -1463,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()")
@@ -1773,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")
 
@@ -1915,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. """
@@ -1963,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
@@ -2045,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()
@@ -2612,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
@@ -2689,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{}  "
@@ -3036,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')
@@ -3058,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:
@@ -3096,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:
@@ -3188,7 +3406,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-0.1.13.62 → listpick-0.1.14.0}/src/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-0.1.13.62 → listpick-0.1.14.0}/src/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-0.1.13.62 → listpick-0.1.14.0}/src/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 → listpick-0.1.14.0/src/listpick.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: listpick
-Version: 0.1.13.62
+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

{listpick-0.1.13.62 → listpick-0.1.14.0}/src/listpick.egg-info/requires.txt

@@ -13,3 +13,4 @@ pandas
 pyperclip
 toml
 traitlets
+odfpy