listpick 0.1.14.14__py3-none-any.whl → 0.1.15.1__py3-none-any.whl

listpick/listpick_app.py

@@ -41,6 +41,8 @@ from listpick.ui.build_help import build_help_rows
 from listpick.ui.footer import StandardFooter, CompactFooter, NoFooter
 from listpick.utils.picker_log import setup_logger
 from listpick.utils.user_input import get_char, open_tty
+from listpick.pane.pane_functions import right_split_file_attributes, right_split_graph, right_split_display_list
+from listpick.pane.get_data import *
 
 
 try:
@@ -62,7 +64,7 @@ class Picker:
         items: list[list[str]] = [],
         cursor_pos: int = 0,
         colours: dict = get_colours(0),
-        colour_theme_number: int = 0,
+        colour_theme_number: int = 3,
         max_selected: int = -1,
         top_gap: int =0,
         title: str ="Picker",
@@ -186,7 +188,17 @@ class Picker:
         sheets = ["Untitled"],
         sheet_name = "Untitled",
         sheet_index = 0,
-        sheet_states = [{}],
+        sheet_states: list = [{}],
+
+        split_right: bool = False,
+        split_right_proportion: float = 1/2,
+        split_right_function: Callable = lambda stdscr, x, y, w, h, state, row, cell, data, test: False,
+        split_right_auto_refresh: bool = False,
+        split_right_refresh_data: Callable = lambda old_data, arg_dict: [],
+        split_right_refresh_data_timer: float = 1.0,
+        split_right_data: list = [],
+        
+
 
 
     ):
@@ -337,6 +349,14 @@ class Picker:
         self.sheet_states = sheet_states
         self.sheets = sheets
 
+        self.split_right = split_right
+        self.split_right_proportion = split_right_proportion
+        self.split_right_function = split_right_function
+        self.split_right_auto_refresh = split_right_auto_refresh
+        self.split_right_refresh_data = split_right_refresh_data
+        self.split_right_refresh_data_timer = split_right_refresh_data_timer
+        self.split_right_data = split_right_data
+
         self.initialise_picker_state(reset_colours=self.reset_colours)
 
         # Note: We have to set the footer after initialising the picker state so that the footer can use the get_function_data method
@@ -405,20 +425,26 @@ class Picker:
 
         ## self.top_space
         h, w = self.stdscr.getmaxyx()
+        self.term_h, self.term_w = self.stdscr.getmaxyx()
+        if self.split_right and self.split_right_function(self.stdscr, 0,0,0,0,{},[],[],"",test=True):
+            self.rows_w, self.rows_h = int(self.term_w*self.split_right_proportion), self.term_h
+        else:
+            self.rows_w, self.rows_h = self.term_w, self.term_h
+
         self.top_space = self.top_gap
         if self.title: self.top_space+=1
         if self.modes and self.display_modes: self.top_space+=1
         if self.header and self.show_header: self.top_space += 1
 
         # self.items_per_page
-        self.items_per_page = h - self.top_space - self.bottom_space
+        self.items_per_page = self.term_h - self.top_space - self.bottom_space
         if not self.show_footer and self.footer_string: self.items_per_page-=1
-        self.items_per_page = min(h-self.top_space-1, self.items_per_page)
+        self.items_per_page = min(self.term_h-self.top_space-1, self.items_per_page)
 
 
         # Adjust top space if centring vertically and we have fewer rows than terminal lines
         if self.centre_in_terminal_vertical and len(self.indexed_items) < self.items_per_page:
-            self.top_space += ((h-(self.top_space+self.bottom_space))-len(self.indexed_items))//2
+            self.top_space += ((self.term_h-(self.top_space+self.bottom_space))-len(self.indexed_items))//2
 
         # self.column_widths
         visible_column_widths = [c for i,c in enumerate(self.column_widths) if i not in self.hidden_columns]
@@ -427,8 +453,8 @@ class Picker:
         # self.startx
         self.startx = 1 if self.highlight_full_row else 2
         if self.show_row_header: self.startx += len(str(len(self.items))) + 2
-        if visible_columns_total_width < w and self.centre_in_terminal:
-            self.startx += (w - visible_columns_total_width) // 2
+        if visible_columns_total_width < self.rows_w and self.centre_in_terminal:
+            self.startx += (self.rows_w - visible_columns_total_width) // 2
 
     def get_visible_rows(self) -> list[list[str]]:
 
@@ -614,7 +640,6 @@ class Picker:
         if len(self.indexed_items) > 0:
             sort_items(self.indexed_items, sort_method=self.columns_sort_method[self.sort_column], sort_column=self.sort_column, sort_reverse=self.sort_reverse[self.sort_column])  # Re-sort self.items based on new column
 
-        h, w = self.stdscr.getmaxyx()
 
         # Adjust variables to ensure correctness if errors
         ## Move to a selectable row (if applicable)
@@ -761,8 +786,14 @@ class Picker:
             self.stdscr.erase()
 
         h, w = self.stdscr.getmaxyx()
+        self.term_h, self.term_w = self.stdscr.getmaxyx()
+        if self.split_right and self.split_right_function(self.stdscr, 0,0,0,0,{},[],[],"",test=True):
+            self.rows_w, self.rows_h = int(self.term_w*self.split_right_proportion), self.term_h
+        else:
+            self.rows_w, self.rows_h = self.term_w, self.term_h
+
         # The height of the footer may need to be adjusted if the file changes.
-        self.footer.adjust_sizes(h,w)
+        self.footer.adjust_sizes(self.term_h,self.term_w)
         self.calculate_section_sizes()
 
         # Test if the terminal is of a sufficient size to display the picker
@@ -785,7 +816,7 @@ class Picker:
         # rows = [v[1] for v in self.indexed_items] if len(self.indexed_items) else self.items
         # Determine widths based only on the currently displayed indexed rows
         rows = [v[1] for v in self.indexed_items[start_index:end_index]] if len(self.indexed_items) else self.items
-        self.column_widths = get_column_widths(rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w, unicode_char_width=self.unicode_char_width)
+        self.column_widths = get_column_widths(rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=self.rows_w, unicode_char_width=self.unicode_char_width)
         visible_column_widths = [c for i,c in enumerate(self.column_widths) if i not in self.hidden_columns]
         visible_columns_total_width = sum(visible_column_widths) + len(self.separator)*(len(visible_column_widths)-1)
 
@@ -797,23 +828,22 @@ class Picker:
         ## Display title (if applicable)
         if self.title:
             padded_title = f" {self.title.strip()} "
-            self.stdscr.addstr(self.top_gap, 0, f"{' ':^{w}}", curses.color_pair(self.colours_start+16))
-            title_x = (w-wcswidth(padded_title))//2
-            # title = f"{title:^{w}}"
+            self.stdscr.addstr(self.top_gap, 0, f"{' ':^{self.term_w}}", curses.color_pair(self.colours_start+16))
+            title_x = (self.term_w-wcswidth(padded_title))//2
             self.stdscr.addstr(self.top_gap, title_x, padded_title, curses.color_pair(self.colours_start+16) | curses.A_BOLD)
             # top_space += 1
 
         ## Display modes
         if self.display_modes and self.modes not in [[{}], []]:
-            self.stdscr.addstr(self.top_gap+1, 0, ' '*w, curses.A_REVERSE)
+            self.stdscr.addstr(self.top_gap+1, 0, ' '*self.term_w, curses.A_REVERSE)
             modes_list = [f"{mode['name']}" if 'name' in mode else f"{i}. " for i, mode in enumerate(self.modes)]
             # mode_colours = [mode["colour"] for mode ]
             mode_widths = get_mode_widths(modes_list)
-            split_space = (w-sum(mode_widths))//len(self.modes)
+            split_space = (self.term_w-sum(mode_widths))//len(self.modes)
             xmode = 0
             for i, mode in enumerate(modes_list):
                 if i == len(modes_list)-1:
-                    mode_str = f"{mode:^{mode_widths[i]+split_space+(w-sum(mode_widths))%len(self.modes)}}"
+                    mode_str = f"{mode:^{mode_widths[i]+split_space+(self.term_w-sum(mode_widths))%len(self.modes)}}"
                 else:
                     mode_str = f"{mode:^{mode_widths[i]+split_space}}"
                 # current mode
@@ -841,21 +871,19 @@ class Picker:
 
             header_str = header_str[self.leftmost_char:]
             header_ypos = self.top_gap + bool(self.title) + bool(self.display_modes and self.modes)
-            self.stdscr.addstr(header_ypos, 0, ' '*w, curses.color_pair(self.colours_start+4) | curses.A_BOLD)
-            self.stdscr.addstr(header_ypos, self.startx, header_str[:min(w-self.startx, visible_columns_total_width+1)], curses.color_pair(self.colours_start+4) | curses.A_BOLD)
+            self.stdscr.addstr(header_ypos, 0, ' '*self.rows_w, curses.color_pair(self.colours_start+4) | curses.A_BOLD)
+            self.stdscr.addstr(header_ypos, self.startx, header_str[:min(self.rows_w-self.startx, visible_columns_total_width+1)], curses.color_pair(self.colours_start+4) | curses.A_BOLD)
 
             # Highlight sort column
             try:
                 if self.selected_column != None and self.selected_column not in self.hidden_columns:
-                    if len(self.header) > 1 and (len(up_to_selected_col)-self.leftmost_char) < w:
-                        # if len(up_to_selected_col) + 1 < w or True:
-                            # if self.startx + len(up_to_selected_col) - self.leftmost_char > 0 or True:
+                    if len(self.header) > 1 and (len(up_to_selected_col)-self.leftmost_char) < self.rows_w:
                         number = f"{self.selected_column}. " if self.number_columns else ""
                         # number = f"{intStringToExponentString(self.selected_column)}. " if self.number_columns else ""
                         # self.startx + len(up_to_selected_col) - self.leftmost_char
                         highlighed_col_startx = max(self.startx, self.startx + len(up_to_selected_col) - self.leftmost_char)
                         highlighted_col_str = (number+f"{self.header[self.selected_column]:^{self.column_widths[self.selected_column]-len(number)}}") + self.separator
-                        end_of_highlighted_col_str = w-(highlighed_col_startx+len(highlighted_col_str)) if (highlighed_col_startx+len(highlighted_col_str)) > w else len(highlighted_col_str)
+                        end_of_highlighted_col_str = self.rows_w-(highlighed_col_startx+len(highlighted_col_str)) if (highlighed_col_startx+len(highlighted_col_str)) > self.rows_w else len(highlighted_col_str)
                         start_of_highlighted_col_str = max(self.leftmost_char - len(up_to_selected_col), 0)
                         self.stdscr.addstr(header_ypos, highlighed_col_startx , highlighted_col_str[start_of_highlighted_col_str:end_of_highlighted_col_str], curses.color_pair(self.colours_start+19) | curses.A_BOLD)
             except:
@@ -874,10 +902,10 @@ class Picker:
             cell_pos = sum(visible_column_widths[:col])+col*len(self.separator)-self.leftmost_char + self.startx
             # cell_width = self.column_widths[self.selected_column]
             cell_width = visible_column_widths[col] + len(self.separator)
-            cell_max_width = w-cell_pos
+            cell_max_width = self.rows_w-cell_pos
             try:
                 # Start of cell is on screen
-                if self.startx <= cell_pos <= w:
+                if self.startx <= cell_pos <= self.rows_w:
                     self.stdscr.addstr(y, cell_pos, (' '*cell_width)[:cell_max_width], curses.color_pair(self.colours_start+colour_pair_number))
                     if self.centre_in_cols:
                         cell_value = f"{self.indexed_items[row][1][col]:^{cell_width-len(self.separator)}}" + self.separator
@@ -888,10 +916,9 @@ class Picker:
                     cell_value = cell_value + self.separator
                     # cell_value = cell_value
                     cell_value = truncate_to_display_width(cell_value, min(cell_width, cell_max_width), self.centre_in_cols, self.unicode_char_width)
-                    # row_str = truncate_to_display_width(row_str_left_adj, min(w-self.startx, visible_columns_total_width))
                     self.stdscr.addstr(y, cell_pos, cell_value, curses.color_pair(self.colours_start+colour_pair_number) | curses.A_BOLD)
                 # Part of the cell is on screen
-                elif self.startx <= cell_pos+cell_width <= w:
+                elif self.startx <= cell_pos+cell_width <= self.rows_w:
                     cell_start = self.startx - cell_pos
                     self.stdscr.addstr(y, self.startx, ' '*(cell_width-cell_start), curses.color_pair(self.colours_start+colour_pair_number))
                     cell_value = self.indexed_items[row][1][col][cell_start:visible_column_widths[col]]
@@ -954,7 +981,7 @@ class Picker:
                         continue
                     highlight_start -= self.leftmost_char
                     highlight_end -= self.leftmost_char
-                    self.stdscr.addstr(y, max(self.startx, self.startx+highlight_start), row_str[max(highlight_start,0):min(w-self.startx, highlight_end)], curses.color_pair(self.colours_start+highlight["color"]) | curses.A_BOLD)
+                    self.stdscr.addstr(y, max(self.startx, self.startx+highlight_start), row_str[max(highlight_start,0):min(self.rows_w-self.startx, highlight_end)], curses.color_pair(self.colours_start+highlight["color"]) | curses.A_BOLD)
                 except:
                     pass
 
@@ -978,11 +1005,11 @@ class Picker:
             # row_str = truncate_to_display_width(row_str, min(w-self.startx, visible_columns_total_width))
             row_str_orig = format_row(item[1], self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols, self.unicode_char_width)
             row_str_left_adj = clip_left(row_str_orig, self.leftmost_char)
-            row_str = truncate_to_display_width(row_str_left_adj, min(w-self.startx, visible_columns_total_width), self.unicode_char_width)
+            row_str = truncate_to_display_width(row_str_left_adj, min(self.rows_w-self.startx, visible_columns_total_width), self.unicode_char_width)
             # row_str = truncate_to_display_width(row_str, min(w-self.startx, visible_columns_total_width))[self.leftmost_char:]
 
             ## Display the standard row
-            self.stdscr.addstr(y, self.startx, row_str[:min(w-self.startx, visible_columns_total_width)], curses.color_pair(self.colours_start+2))
+            self.stdscr.addstr(y, self.startx, row_str[:min(self.rows_w-self.startx, visible_columns_total_width)], curses.color_pair(self.colours_start+2))
             
 
             # Draw the level 0 highlights
@@ -1012,15 +1039,15 @@ class Picker:
             # Higlight cursor row and selected rows
             elif self.highlight_full_row:
                 if self.selections[item[0]]:
-                    self.stdscr.addstr(y, self.startx, row_str[:min(w-self.startx, visible_columns_total_width)], curses.color_pair(self.colours_start+25) | curses.A_BOLD)
+                    self.stdscr.addstr(y, self.startx, row_str[:min(self.rows_w-self.startx, visible_columns_total_width)], curses.color_pair(self.colours_start+25) | curses.A_BOLD)
                 # Visually selected
                 if self.is_selecting:
                     if self.start_selection <= idx <= self.cursor_pos or self.start_selection >= idx >= self.cursor_pos:
-                        self.stdscr.addstr(y, self.startx, row_str[:min(w-self.startx, visible_columns_total_width)], curses.color_pair(self.colours_start+25))
+                        self.stdscr.addstr(y, self.startx, row_str[:min(self.rows_w-self.startx, visible_columns_total_width)], curses.color_pair(self.colours_start+25))
                 # Visually deslected
                 elif self.is_deselecting:
                     if self.start_selection >= idx >= self.cursor_pos or self.start_selection <= idx <= self.cursor_pos:
-                        self.stdscr.addstr(y, self.startx, row_str[:min(w-self.startx, visible_columns_total_width)], curses.color_pair(self.colours_start+26))
+                        self.stdscr.addstr(y, self.startx, row_str[:min(self.rows_w-self.startx, visible_columns_total_width)], curses.color_pair(self.colours_start+26))
 
             # Highlight the cursor row and the first char of the selected rows.
             else:
@@ -1043,7 +1070,7 @@ class Picker:
                 if self.cell_cursor:
                     highlight_cell(idx, self.selected_column, visible_column_widths)
                 else:
-                    self.stdscr.addstr(y, self.startx, row_str[:min(w-self.startx, visible_columns_total_width)], curses.color_pair(self.colours_start+5) | curses.A_BOLD)
+                    self.stdscr.addstr(y, self.startx, row_str[:min(self.rows_w-self.startx, visible_columns_total_width)], curses.color_pair(self.colours_start+5) | curses.A_BOLD)
             
             if not self.highlights_hide:
                 draw_highlights(l2_highlights, idx, y, item)
@@ -1054,36 +1081,49 @@ class Picker:
             if self.cursor_pos <= self.items_per_page//2:
                 scroll_bar_start=self.top_space
             elif self.cursor_pos + self.items_per_page//2 >= len(self.indexed_items):
-                scroll_bar_start = h - int(bool(self.show_footer))*self.footer.height - scroll_bar_length
+                scroll_bar_start = self.term_h - int(bool(self.show_footer))*self.footer.height - scroll_bar_length
             else:
                 scroll_bar_start = int(((self.cursor_pos)/len(self.indexed_items))*self.items_per_page)+self.top_space - scroll_bar_length//2
-            scroll_bar_start = min(scroll_bar_start, h-self.top_space-1)
-            scroll_bar_length = min(scroll_bar_length, h - scroll_bar_start-1)
+            scroll_bar_start = min(scroll_bar_start, self.term_h-self.top_space-1)
+            scroll_bar_length = min(scroll_bar_length, self.term_h - scroll_bar_start-1)
             scroll_bar_length = max(1, scroll_bar_length)
             for i in range(scroll_bar_length):
                 v = max(self.top_space+int(bool(self.header)), scroll_bar_start-scroll_bar_length//2)
-                self.stdscr.addstr(scroll_bar_start+i, w-1, ' ', curses.color_pair(self.colours_start+18))
+                self.stdscr.addstr(scroll_bar_start+i, self.rows_w-1, ' ', curses.color_pair(self.colours_start+18))
 
         # Display refresh symbol
         if self.auto_refresh:
             if self.refreshing_data:
-                self.stdscr.addstr(0,w-3,"  ", curses.color_pair(self.colours_start+21) | curses.A_BOLD)
+                self.stdscr.addstr(0,self.term_w-3,"  ", curses.color_pair(self.colours_start+21) | curses.A_BOLD)
             else:
-                self.stdscr.addstr(0,w-3,"  ", curses.color_pair(self.colours_start+23) | curses.A_BOLD)
+                self.stdscr.addstr(0,self.term_w-3,"  ", curses.color_pair(self.colours_start+23) | curses.A_BOLD)
 
         ## Display footer
         if self.show_footer:
             # self.footer = NoFooter(self.stdscr, self.colours_start, self.get_function_data)
             h, w = self.stdscr.getmaxyx()
             try:
-                self.footer.draw(h, w)
+                self.footer.draw(self.term_h, self.term_w)
             except:
                 pass
         elif self.footer_string:
-            footer_string_width = min(w-1, len(self.footer_string)+2)
+            footer_string_width = min(self.term_w-1, len(self.footer_string)+2)
             disp_string = f" {self.footer_string[:footer_string_width]:>{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))
+            self.stdscr.addstr(self.term_h - 1, self.term_w-footer_string_width-1, " "*footer_string_width, curses.color_pair(self.colours_start+24))
+            self.stdscr.addstr(self.term_h - 1, self.term_w-footer_string_width-1, f"{disp_string}", curses.color_pair(self.colours_start+24))
+
+        if self.split_right and self.split_right_function(self.stdscr, 0,0,0,0,{},[],[],"",test=True):
+            self.right_pane_previous_data = self.split_right_function(
+                self.stdscr, 
+                x = self.rows_w,
+                y = self.top_space - int(bool(self.show_header and self.header)),
+                w = self.term_w-self.rows_w,
+                h = self.items_per_page + int(bool(self.show_header and self.header)),
+                state = self.get_function_data(),
+                row = self.indexed_items[self.cursor_pos] if self.indexed_items else [],
+                cell = self.indexed_items[self.cursor_pos][1][self.selected_column] if self.indexed_items else "",
+                data=self.split_right_data,
+            )
         
         self.stdscr.refresh()
         ## Display infobox
@@ -1130,6 +1170,7 @@ class Picker:
                 "title": title,
                 "reset_colours": False,
                 "cell_cursor": False,
+                "split_right": False,
             }
 
             OptionPicker = Picker(submenu_win, **infobox_data)
@@ -1244,6 +1285,13 @@ class Picker:
             "sheets":                           self.sheets,
             "sheet_name":                       self.sheet_name,
             "sheet_states":                     self.sheet_states,
+            "split_right":                      self.split_right,
+            "split_right_proportion":           self.split_right_proportion,
+            "split_right_function":             self.split_right_function,
+            "split_right_auto_refresh":         self.split_right_auto_refresh,
+            "split_right_refresh_data_timer":   self.split_right_refresh_data_timer,
+            "split_right_refresh_data":         self.split_right_refresh_data,
+            "split_right_data":                 self.split_right_data,
         }
         return function_data
 
@@ -1278,6 +1326,9 @@ class Picker:
             "centre_in_terminal_vertical",
             "centre_in_cols",
             "centre_in_terminal",
+            "split_right",
+            "split_right_proportion",
+            "split_right_function",
         ]
 
         for var in variables:
@@ -1370,6 +1421,7 @@ class Picker:
             "cancel_is_back": True,
             "number_columns": False,
             "reset_colours": False,
+            "split_right": False,
         }
         while True:
             h, w = stdscr.getmaxyx()
@@ -1425,6 +1477,7 @@ class Picker:
                 "top_gap": 0,
                 "cancel_is_back": True,
                 "reset_colours": False,
+                "split_right": False,
 
             }
             OptionPicker = Picker(submenu_win, **notification_data)
@@ -1562,6 +1615,8 @@ class Picker:
                         self.footer_style = (self.footer_style+1)%len(self.footer_options)
                         self.footer = self.footer_options[self.footer_style]
                     self.initialise_variables()
+                elif setting == "pane":
+                    self.toggle_right_pane()
 
                 elif setting.startswith("cwd="):
                     os.chdir(os.path.expandvars(os.path.expanduser(setting[len("cwd="):])))
@@ -1951,7 +2006,6 @@ class Picker:
 
                 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)
@@ -2177,6 +2231,9 @@ class Picker:
             self.set_function_data(function_data, reset_absent_variables=True)
             self.load_sheet(self.loaded_file, sheet_number=self.sheet_index)
 
+    def toggle_right_pane(self):
+        if self.split_right_function(self.stdscr, 0,0,0,0,{},[],[],"",test=True):
+            self.split_right = not self.split_right
 
 
     def run(self) -> Tuple[list[int], str, dict]:
@@ -2192,6 +2249,7 @@ class Picker:
 
         initial_time = time.time()
         initial_time_footer = time.time()-self.footer_timer
+        initial_split_time = time.time()-self.split_right_refresh_data_timer
 
         if self.startup_notification:
             self.notification(self.stdscr, message=self.startup_notification)
@@ -2226,6 +2284,11 @@ class Picker:
         tty_fd = open_tty()
 
         h, w = self.stdscr.getmaxyx()
+        self.term_h, self.term_w = self.stdscr.getmaxyx()
+        if self.split_right and self.split_right_function(self.stdscr, 0,0,0,0,{},[],[],"",test=True):
+            self.rows_w, self.rows_h = int(self.term_w*self.split_right_proportion), self.term_h
+        else:
+            self.rows_w, self.rows_h = self.term_w, self.term_h
         def terminal_resized(old_w, old_h) -> bool:
             w, h = os.get_terminal_size()
             if old_h != h or old_w != w: return True
@@ -2246,6 +2309,11 @@ class Picker:
                 key = curses.KEY_RESIZE
 
             h, w = self.stdscr.getmaxyx()
+            self.term_h, self.term_w = self.stdscr.getmaxyx()
+            if self.split_right and self.split_right_function(self.stdscr, 0,0,0,0,{},[],[],"",test=True):
+                self.rows_w, self.rows_h = int(self.term_w*self.split_right_proportion), self.term_h
+            else:
+                self.rows_w, self.rows_h = self.term_w, self.term_h
 
             if key in self.disabled_keys: continue
             clear_screen=True
@@ -2267,7 +2335,7 @@ class Picker:
 
             elif self.check_key("refresh", key, self.keys_dict) or self.remapped_key(key, curses.KEY_F5, self.key_remappings) or (self.auto_refresh and (time.time() - initial_time) >= self.timer):
                 self.logger.debug(f"Get new data (refresh).")
-                self.stdscr.addstr(0,w-3,"  ", curses.color_pair(self.colours_start+21) | curses.A_BOLD)
+                self.stdscr.addstr(0,self.term_w-3,"  ", curses.color_pair(self.colours_start+21) | curses.A_BOLD)
                 self.stdscr.refresh()
                 if self.get_new_data and self.refresh_function:
                     self.refreshing_data = True
@@ -2297,6 +2365,9 @@ class Picker:
                 self.footer_string = self.footer_string_refresh_function()
                 initial_time_footer = time.time()
                 self.draw_screen(self.indexed_items, self.highlights)
+            if self.split_right_auto_refresh and ((time.time() - initial_split_time) > self.split_right_refresh_data_timer):
+                self.split_right_data = self.split_right_refresh_data(self.split_right_data, self.get_function_data())
+                initial_split_time = time.time()
 
             if self.check_key("help", key, self.keys_dict):
                 self.logger.info(f"key_function help")
@@ -2315,11 +2386,12 @@ class Picker:
                     "highlight_full_row": True,
                     "top_gap": 0,
                     "paginate": self.paginate,
-                    "centre_in_terminal": True,
+                    "centre_in_terminal": False,
                     "centre_in_terminal_vertical": True,
                     "hidden_columns": [],
                     "reset_colours": False,
                     "cell_cursor": False,
+                    "split_right": False,
 
                 }
                 OptionPicker = Picker(self.stdscr, **help_data)
@@ -2431,6 +2503,7 @@ class Picker:
                     "hidden_columns": [],
                     "reset_colours": False,
                     "cell_cursor": False,
+                    "split_right": False,
 
                 }
                 OptionPicker = Picker(self.stdscr, **info_data)
@@ -2741,12 +2814,12 @@ class Picker:
 
                 ## Scroll with column select
                 rows = self.get_visible_rows()
-                self.column_widths = get_column_widths(rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w, unicode_char_width=self.unicode_char_width)
+                self.column_widths = get_column_widths(rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=self.rows_w, unicode_char_width=self.unicode_char_width)
                 visible_column_widths = [c for i,c in enumerate(self.column_widths) if i not in self.hidden_columns]
                 column_set_width = sum(visible_column_widths)+len(self.separator)*len(visible_column_widths)
                 start_of_cell = sum(visible_column_widths[:self.selected_column])+len(self.separator)*self.selected_column
                 end_of_cell = sum(visible_column_widths[:self.selected_column+1])+len(self.separator)*(self.selected_column+1)
-                display_width = w-self.startx
+                display_width = self.rows_w-self.startx
                 # If the full column is within the current display then don't do anything
                 if start_of_cell >= self.leftmost_char and end_of_cell <= self.leftmost_char + display_width:
                     pass
@@ -2768,12 +2841,12 @@ class Picker:
 
                 ## Scroll with column select
                 rows = self.get_visible_rows()
-                self.column_widths = get_column_widths(rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w, unicode_char_width=self.unicode_char_width)
+                self.column_widths = get_column_widths(rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=self.rows_w, unicode_char_width=self.unicode_char_width)
                 visible_column_widths = [c for i,c in enumerate(self.column_widths) if i not in self.hidden_columns]
                 column_set_width = sum(visible_column_widths)+len(self.separator)*len(visible_column_widths)
                 start_of_cell = sum(visible_column_widths[:self.selected_column])+len(self.separator)*self.selected_column
                 end_of_cell = sum(visible_column_widths[:self.selected_column+1])+len(self.separator)*(self.selected_column+1)
-                display_width = w-self.startx
+                display_width = self.rows_w-self.startx
 
                 # If the entire column is within the current display then don't do anything
                 if start_of_cell >= self.leftmost_char and end_of_cell <= self.leftmost_char + display_width:
@@ -2788,7 +2861,7 @@ class Picker:
                 self.logger.info(f"key_function scroll_right")
                 if len(self.indexed_items):
                     row_width = sum(self.column_widths) + len(self.separator)*(len(self.column_widths)-1)
-                    if row_width-self.leftmost_char >= w-self.startx:
+                    if row_width-self.leftmost_char >= self.rows_w-self.startx:
                         self.leftmost_char = self.leftmost_char+5
 
             elif self.check_key("scroll_left", key, self.keys_dict):
@@ -2813,7 +2886,7 @@ class Picker:
                 #     row_str = format_row(item[1], self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols)
                 #     if len(row_str) > longest_row_str_len: longest_row_str_len=len(row_str)
                 # self.notification(self.stdscr, f"{longest_row_str_len}")
-                self.leftmost_char = max(0, longest_row_str_len-w+2+self.startx)
+                self.leftmost_char = max(0, longest_row_str_len-self.rows_w+2+self.startx)
                 if len(self.items):
                     self.selected_column = len(self.items[0])-1
 
@@ -2907,7 +2980,7 @@ class Picker:
             elif key == curses.KEY_RESIZE:  # Terminal resize signal
 
                 self.calculate_section_sizes()
-                self.column_widths = get_column_widths(self.items, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w, unicode_char_width=self.unicode_char_width)
+                self.column_widths = get_column_widths(self.items, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=self.rows_w, unicode_char_width=self.unicode_char_width)
 
                 self.draw_screen(self.indexed_items, self.highlights)
 
@@ -3149,6 +3222,9 @@ class Picker:
             elif self.check_key("file_prev", key, self.keys_dict):
                 self.switch_file(increment=-1)
 
+            elif self.check_key("toggle_right_pane", key, self.keys_dict):
+                self.toggle_right_pane()
+
             elif self.check_key("pipe_input", key, self.keys_dict):
                 self.logger.info(f"key_function pipe_input")
                 # usrtxt = "xargs -d '\n' -I{}  "
@@ -3323,7 +3399,7 @@ class Picker:
                         self.history_edits.append(usrtxt)
             elif self.check_key("edit_ipython", key, self.keys_dict):
                 self.logger.info(f"key_function edit_picker")
-                import IPython
+                import IPython, termios
                 self.stdscr.clear()
                 restrict_curses(self.stdscr)
                 self.stdscr.clear()
@@ -3338,10 +3414,24 @@ class Picker:
                 # ]
                 msg = "The active Picker object has variable name self.\n"
                 msg += "\te.g., self.items will display the items in Picker"
+                tty_in = open("/dev/tty", "r")
+                tty_out = open("/dev/tty", "w")
+
+                fd = tty_in.fileno()
+                old_attrs = termios.tcgetattr(fd)
+                new_attrs = termios.tcgetattr(fd)
+                new_attrs[3] |= termios.ECHO  # lflags
+                termios.tcsetattr(fd, termios.TCSADRAIN, new_attrs)
+
+                sys.stdin = tty_in
+                sys.stdout = tty_out
+                sys.stderr = tty_out
                 IPython.embed(header=msg, config=c)
 
                 unrestrict_curses(self.stdscr)
 
+                tty_in.close()
+                tty_out.close()
                 self.stdscr.clear()
                 self.stdscr.refresh()
                 self.initialise_variables()
@@ -3657,16 +3747,24 @@ def main() -> None:
     # function_data["paginate"] = True
     # function_data["debug"] = True
     # function_data["debug_level"] = 1
+
+    function_data["split_right"] = True
+    function_data["split_right_proportion"] = 2/3
+    function_data["split_right_refresh_data"] = data_refresh_randint_title
+    function_data["split_right_function"] = right_split_display_list
+    function_data["split_right_data"] = ["Files", [str(x) for x in range(100)]]
+
+
+    # function_data["split_right_refresh_data"] = get_dl
+
+
+    # function_data["split_right_function"] = right_split_file_attributes
+    # function_data["split_right_auto_refresh"] = True
+    # function_data["split_right_function"] = right_split_graph
+
     stdscr = start_curses()
     try:
         # Run the Picker
-        # h, w = stdscr.getmaxyx()
-        # if (h>8 and w >20):
-        #     curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLACK)
-        #     stdscr.bkgd(' ', curses.color_pair(1))  # Apply background color
-        #     s = "Listpick is loading your data..."
-        #     stdscr.addstr(h//2, (w-len(s))//2, s)
-        #     stdscr.refresh()
 
         # app = Picker(stdscr, **function_data)
         app = Picker(stdscr)

listpick/pane/get_data.py

@@ -0,0 +1,95 @@
+#!/bin/python
+# -*- coding: utf-8 -*-
+"""
+get_data.py
+Functions to get data to be displayed in the a pane.
+
+Author: GrimAndGreedy
+License: MIT
+"""
+
+def data_refresh_randint_by_row(data, state):
+    """
+    Add a random number to the data if row id is the same.
+
+
+    Can be used with right_split_graph()
+    
+    data[0]: 0,1,2,...,n+1
+    data[1]: randint(), randint(), ...
+    data[2]: row id
+    """
+    from random import randint
+    if state["indexed_items"]:
+        id = state["indexed_items"][state["cursor_pos"]][1][state["id_column"]]
+    else:
+        return [[0], [0], -1]
+    if data in [[], {}, None] or data[2] != id:
+        return [[0], [randint(0, 1000)], id]
+    else:
+        data[0].append(data[0][-1]+1)
+        data[1].append(randint(0, 1000))
+    return data
+
+def data_refresh_randint(data, state):
+    """ 
+    Add a random number to the data--regardless of whether the row id is the same.
+
+
+    Can be used with right_split_graph()
+
+    data[0]: 0,1,2,...,n+1
+    data[1]: randint(), randint(), ...
+    data[2]: row id
+    """
+    from random import randint
+
+    if data in [[], {}, None]:
+        return [[0], [randint(0, 1000)], -1]
+    else:
+        data[0].append(data[0][-1]+1)
+        data[1].append(randint(0, 1000))
+    return data
+
+
+def data_refresh_randint_title(data, state):
+    """ 
+    Add a random number to data[1]. 
+
+    Can be used with right_split_display_list()
+
+    data[0]: title
+    data[1]: randint(), randint(), ...
+    """
+    from random import randint
+
+    if data in [[], {}, None]:
+        return ["I CHOOSE", [str(randint(0, 1000))]]
+    else:
+        data[1].append(str(randint(0, 1000)))
+    return data
+
+def get_dl(data, state):
+    """
+    Get dl speed and add it to data[1]
+
+    data[0]: 0,1,2,...,n+1
+    data[1]: dl_speed_at_0, dl_speed_at_1, ...
+    data[2]: row id
+    """
+    from aria2tui.utils import aria2c_utils
+
+    gid = "3c60b0fc67230b66"
+    req = aria2c_utils.tellStatus(gid)
+    info = aria2c_utils.sendReq(req)
+    dl = info["result"]["downloadSpeed"]
+    ul = info["result"]["uploadSpeed"]
+
+    dl, ul = int(dl), int(ul)
+
+    if data in [[], {}, None]:
+        return [[0], [dl], gid]
+    else:
+        data[0].append(data[0][-1]+1)
+        data[1].append(dl)
+    return data

listpick/pane/pane_functions.py

@@ -0,0 +1,112 @@
+#!/bin/python
+# -*- coding: utf-8 -*-
+"""
+pane_functions.py
+Functions which are run by a listpick Picker to display data in a pane.
+
+Author: GrimAndGreedy
+License: MIT
+"""
+
+import curses
+import os
+from listpick.pane.pane_utils import get_file_attributes, get_graph_string, escape_ansi
+
+def right_split_file_attributes(stdscr, x, y, w, h, state, row, cell, past_data: list = [], data: list = [], test: bool = False):
+    """
+    Display file attributes in right pane.
+    """
+    if test: return True
+
+    os.chdir(os.path.expanduser("~/Downloads/new"))
+
+    # Title
+    title = "File attributes"
+    if len(title) < w: title = f"{title:^{w}}"
+    stdscr.addstr(y, x,title[:w], curses.color_pair(state["colours_start"]+4) | curses.A_BOLD)
+
+    # Separator
+    for j in range(h):
+        stdscr.addstr(j+y, x, ' ', curses.color_pair(state["colours_start"]+16))
+
+
+    # Filename/cursor cell value
+    stdscr.addstr(y+2, x+2, cell[:w-3])
+
+    attributes = get_file_attributes(cell)
+    for i, attr in enumerate(attributes):
+        stdscr.addstr(y+3+i, x+4, attr[:w-5])
+
+    return []
+
+def right_split_graph(stdscr, x, y, w, h, state, row, cell, past_data: list = [], data: list = [], test: bool = False):
+    """
+    Display a graph of the data in right pane.
+
+    data[0] = x_vals
+    data[1] = y_vals
+    data[2] = id
+    """
+    if test: return True
+
+    # Title
+    title = "Graph"
+    if len(title) < w: title = f"{title:^{w}}"
+    stdscr.addstr(y, x,title[:w], curses.color_pair(state["colours_start"]+4) | curses.A_BOLD)
+
+    # Separator
+    for j in range(h):
+        stdscr.addstr(j+y, x, ' ', curses.color_pair(state["colours_start"]+16))
+
+    try:
+        import plotille as plt
+    except:
+        s = f"No module named 'plotille'"
+        stdscr.addstr(y+2, x+2, s[:w-2])
+        return None
+
+
+    # x_vals, y_vals = list(range(100)), [x**2 for x in range(100)]
+    if data in [[], {}, None]:
+        return None
+    x_vals, y_vals = data[0], data[1]
+    graph_str = get_graph_string(x_vals, y_vals, width=w-3-10, height=h-3)
+    for i, s in enumerate(graph_str.split("\n")):
+        s = escape_ansi(s)
+        stdscr.addstr(y+2+i, x+2, s[:w-2])
+
+    return []
+
+
+
+
+def right_split_display_list(stdscr, x, y, w, h, state, row, cell, past_data: list = [], data: list = [], test: bool = False):
+    """
+    data[0]:str = title
+    data[1]:list[str] = list of strings to display
+    """
+    if test: return True
+
+    # Title
+    title = data[0]
+    if len(title) < w: title = f"{title:^{w}}"
+    stdscr.addstr(y, x,title[:w], curses.color_pair(state["colours_start"]+4) | curses.A_BOLD)
+
+    # Separator
+    for j in range(h):
+        stdscr.addstr(j+y, x, ' ', curses.color_pair(state["colours_start"]+16))
+
+    if data in [[], {}, None]:
+        return None
+
+    items = data[1]
+    number_to_display = min(len(items), h-3)
+    for i in range(number_to_display):
+        s = items[i]
+        stdscr.addstr(y+1+i, x+2, s[:w-2])
+
+    if number_to_display < len(items):
+        stdscr.addstr(y+1+number_to_display, x+2, f" ... {len(items)-number_to_display} more"[:w-2])
+
+
+    return []

listpick/pane/pane_utils.py

@@ -0,0 +1,88 @@
+#!/bin/python
+# -*- coding: utf-8 -*-
+"""
+pane_utils.py
+Utility functions for Picker panes.
+
+Author: GrimAndGreedy
+License: MIT
+"""
+
+import re
+
+def escape_ansi(line: str) -> str:
+    """ Remove ansi characters from string. """
+    ansi_escape =re.compile(r'(\x9B|\x1B\[)[0-?]*[ -\/]*[@-~]')
+    return ansi_escape.sub('', line)
+
+
+def get_graph_string(x_vals, y_vals, width=50, height=20, title=None, x_label=None, y_label=None):
+    """ Generate a graph of x_vals, y_vals using plotille"""
+
+    import plotille as plt
+    # Create a figure and axis object using plotille
+    fig = plt.Figure()
+    
+    # Plot the data on the figure
+    fig.plot(x_vals, y_vals)
+    
+    # Set the dimensions of the graph
+    fig.width = width-10
+    fig.height = height-4
+    fig.x_ticks_fkt = lambda x, _: f"{int(x)}s"
+    fig.y_ticks_fkt = lambda y, _: f"{int(y)}"
+    
+    # Set the title and labels if provided
+    if title:
+        fig.title = title
+    if x_label:
+        fig.xlabel = x_label
+    if y_label:
+        fig.ylabel = y_label
+    
+    # Generate the ASCII art of the graph
+    ascii_art = str(fig.show())
+    
+    return ascii_art
+
+
+def get_file_attributes(filename):
+    import mimetypes
+    import time
+    import os
+    try:
+        if not os.path.exists(filename) and len(filename) > 2 and filename[0] == "'" and filename[-1] == "'":
+            filename = filename[1:-1] 
+
+        abs_path = os.path.abspath(filename)
+        
+        if not os.path.exists(abs_path):
+            return ["File not found"]
+
+        # Get the size of the file in bytes and convert it to a human-readable format
+        size = os.path.getsize(abs_path)
+        size_str = f"{(size / (1024 * 1024 * 1024)):,.2f}GB" if size > 1024 ** 3 else \
+                   f"{(size / (1024 * 1024)):,.2f}MB" if size > 1024 ** 2 else \
+                   f"{(size / 1024):,.2f}KB" if size > 1024 else f"{size}B"
+        
+        # Get the file type
+        mime_type, _ = mimetypes.guess_type(abs_path)
+        if mime_type is None:
+            mime_type = "application/octet-stream"
+        
+        # Get the last modified time in a human-readable format
+        mod_time = os.path.getmtime(abs_path)
+        mod_str = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(mod_time))
+        
+        attributes = [
+            f"Size: {size_str}",
+            f"Filetype: {mime_type}",
+            f"Last Modified: {mod_str}"
+        ]
+        
+        return attributes
+    
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return []
+

listpick/ui/build_help.py

@@ -142,14 +142,15 @@ def build_help_rows(keys_dict: dict, debug: bool = False) -> list[list[str]]:
         "file_prev":                        "Go to the previous open file.",
         "sheet_next":                       "Go to the next sheet.",
         "sheet_prev":                       "Go to the previous sheet.",
+        "toggle_right_pane":                "Toggle the right pane",
     }
     sections = {
         "Navigation:": [ "cursor_down", "cursor_up", "half_page_up", "half_page_down", "page_up", "page_down", "cursor_bottom", "cursor_top", "five_up", "five_down", "scroll_right", "scroll_left", "scroll_far_right", "scroll_far_left" ],
         "Selection:": [ "toggle_select", "select_all", "select_none", "visual_selection_toggle", "visual_deselection_toggle", "enter" ],
-        "UI:": [ "toggle_footer", "redraw_screen", "decrease_lines_per_page", "increase_lines_per_page", "increase_column_width", "decrease_column_width", "notification_toggle" ],
+        "UI:": [ "toggle_footer", "redraw_screen", "decrease_lines_per_page", "increase_lines_per_page", "increase_column_width", "decrease_column_width", "notification_toggle", "toggle_right_pane"],
         "Sort:": [ "cycle_sort_method", "cycle_sort_method_reverse", "cycle_sort_order", ] ,
         "Data manipulation:": [ "delete", "delete_column", "edit", "edit_picker", "edit_ipython", "add_column_before", "add_column_after", "add_row_before", "add_row_after"],
-        "Filter and sort:": [ "filter_input", "x", "search_input", "continue_search_forward", "continue_search_backward", ] ,
+        "Filter and sort:": [ "filter_input", "search_input", "continue_search_forward", "continue_search_backward", ] ,
         "Settings:": [ "settings_input", "settings_options" ],
         "Cancel:": [ "opts_input", "opts_select", "mode_next", "mode_prev", "pipe_input", "reset_opts", "col_select", "col_select_next", "col_select_prev", "col_hide" ],
         "Save, load, copy and paste:": [ "save", "load", "open", "copy", "paste" ],
@@ -197,15 +198,20 @@ def build_help_rows(keys_dict: dict, debug: bool = False) -> list[list[str]]:
             row = [f"    {str(keys)[1:-1]}", description]
             section_rows.append(row)
         if section_rows:
-            items.append([section_name, ""])
+            items.append([f"  {section_name}", ""])
             items += section_rows
             items.append(["",""])
 
+    if debug:
+        for operation in keys_dict:
+            if operation not in help_descriptions:
+                print(f"Note that {operation} is not in the help_descriptions")
+
     return items
 
 if __name__ == "__main__":
     items = build_help_rows(picker_keys, debug=True)
-    items = build_help_rows(notification_keys, debug=True)
+    # items = build_help_rows(notification_keys, debug=True)
 
     # from listpick.listpick_app import Picker, start_curses, close_curses
     # stdscr = start_curses()

listpick/ui/footer.py

@@ -209,7 +209,7 @@ class StandardFooter(Footer):
         max_chars = min(len(sort_disp_str)+2, w)
         self.stdscr.addstr(self.sort_info_y, w-max_chars, f"{sort_disp_str:>{max_chars-1}}", curses.color_pair(self.colours_start+20))
 
-        self.stdscr.refresh()
+        # self.stdscr.refresh()
 
 
 

listpick/ui/keys.py

@@ -84,6 +84,9 @@ picker_keys = {
     "info":                             [ord('i')], 
     "file_next":                             [ord('}')], 
     "file_prev":                             [ord('{')], 
+    # "sheet_next":                           [],
+    # "sheet_prev":                           [],
+    "toggle_right_pane":                             [ord("'")], 
 }
 
 

listpick/utils/graphing.py

@@ -0,0 +1,224 @@
+#!/bin/python
+# -*- coding: utf-8 -*-
+"""
+graphing.py
+
+Author: GrimAndGreedy
+License: MIT
+"""
+
+import sys, os
+sys.path.append(os.path.expanduser(".."))
+os.chdir(os.path.dirname(os.path.realpath(__file__)))
+os.chdir("../../..")
+from aria2tui.lib.aria2c_wrapper import *
+from aria2tui.utils.aria2c_utils import *
+from listpick import *
+from listpick.listpick_app import *
+import time
+import re
+from typing import Callable
+
+def escape_ansi(line: str) -> str:
+    """ Remove ansi characters from string. """
+    ansi_escape =re.compile(r'(\x9B|\x1B\[)[0-?]*[ -\/]*[@-~]')
+    return ansi_escape.sub('', line)
+
+def handle_plotille_not_found(stdscr: curses.window) -> None:
+    """ Display ModuleNotFoundError. """
+    h, w = stdscr.getmaxyx()
+    s = "ModuleNotFoundError: No module named 'plotille'"
+    stdscr.addstr(h//2, (w - len(s))//2, s)
+    stdscr.refresh()
+    stdscr.getch()
+
+
+def graph_speeds(
+        stdscr: curses.window,
+        get_data_function: Callable,
+        timeout:int=1000,
+        title:str="",
+        refresh_time: int = 2,
+        xposf: Callable = lambda: 0,
+        yposf: Callable = lambda: 0,
+        graph_wh: Callable[None,Tuple[int, int]] = lambda: os.get_terminal_size(),
+
+    ) -> None:
+    """ Display a graph of the global stats in a curses window. """
+    try:
+        import plotille as plt
+    except:
+        handle_plotille_not_found(stdscr)
+        return None
+
+    initial_time = time.time()
+    x, y, y2 = [], [], []
+    while time.time()-initial_time < timeout:
+
+
+        resp = get_data_function()
+        x.append(time.time()-initial_time)
+        down = int(resp['result']['downloadSpeed'])
+        up = int(resp['result']['uploadSpeed'])
+
+        y.append(down)
+        y2.append(up)
+
+        fig = plt.Figure()
+        fig.plot(x, y)
+        fig.plot(x, y2)
+
+        fig.y_ticks_fkt = lambda y, _: bytes_to_human_readable(y)
+        fig.x_ticks_fkt = lambda x, _: f"{int(x)}s"
+        fig.set_y_limits(min_=0)
+        fig.set_x_limits(min_=0)
+        fig.text([x[-1]], [y[0]], ['Dn'])
+        fig.text([x[0]], [y2[0]], ['Up'])
+
+        width, height = graph_wh()
+        fig.width = width - 7
+        fig.height = height - 4
+        globh, globw = stdscr.getmaxyx()
+        xpos, ypos = xposf(), yposf()
+        maxw, maxh = globw-xpos-1, globh-ypos
+
+        stdscr.erase()
+
+        # Draw title
+        stdscr.addstr(ypos, xpos, f"{title:^{min(width,maxw)}}")
+
+        # Draw graph
+        lines = fig.show().split('\n')
+        for i, line in enumerate(lines):
+            if i > maxh-2: break
+            line = escape_ansi(line)
+
+            stdscr.addstr(i+1+ypos, xpos , line[:min(width,maxw)])
+
+        # Show the extreme points of the width and also the last printable char
+        show_control_chars = False
+        if show_control_chars:
+            stdscr.addstr(0,0, f"{maxw}, {maxh}")
+            stdscr.addstr(ypos, xpos, "*", curses.A_REVERSE)
+            stdscr.addstr(ypos+maxh-1, xpos, "*", curses.A_REVERSE)
+            stdscr.addstr(ypos, xpos+maxw-1, "*", curses.A_REVERSE)
+            stdscr.addstr(ypos+maxh-1, xpos+maxw-2, "*", curses.A_REVERSE)
+            stdscr.addstr(ypos+ min(height, maxh-1), xpos, "+", curses.A_REVERSE)
+            stdscr.addstr(ypos, xpos+min(maxw-1, width), "+", curses.A_REVERSE)
+            stdscr.addstr(ypos+min(height, maxh-1), xpos+min(width, maxw-2), "+", curses.A_REVERSE)
+
+        stdscr.refresh()
+        key = stdscr.getch()
+        if key in [3, ord('q')]: 
+            return None
+
+def graph_speeds_gid(
+        stdscr: curses.window,
+        get_data_function: Callable,
+        timeout:int=1000,
+        title:str="",
+        refresh_time: int = 2,
+        xposf: Callable = lambda: 0,
+        yposf: Callable = lambda: 0,
+        graph_wh: Callable[None,Tuple[int, int]] = lambda: os.get_terminal_size(),
+        gid:str = ""
+
+    ) -> None:
+    """ Display a graph in a curses window for a certain gid. """
+    try:
+        import plotille as plt
+    except:
+        handle_plotille_not_found(stdscr)
+        return None
+
+    initial_time = time.time()
+    x, y, y2 = [], [], []
+    while time.time()-initial_time < timeout:
+
+        resp = get_data_function(gid)
+        x.append(time.time()-initial_time)
+        down = int(resp['result']['downloadSpeed'])
+        up = int(resp['result']['uploadSpeed'])
+
+        y.append(down)
+        y2.append(up)
+
+        fig = plt.Figure()
+        fig.plot(x, y)
+        fig.plot(x, y2)
+
+        fig.y_ticks_fkt = lambda y, _: bytes_to_human_readable(y)
+        fig.x_ticks_fkt = lambda x, _: f"{int(x)}s"
+        fig.set_y_limits(min_=0)
+        fig.set_x_limits(min_=0)
+        fig.text([x[-1]], [y[0]], ['Dn'])
+        fig.text([x[0]], [y2[0]], ['Up'])
+
+        width, height = graph_wh()
+        fig.width = width - 7
+        fig.height = height - 4
+        globh, globw = stdscr.getmaxyx()
+        xpos, ypos = xposf(), yposf()
+        maxw, maxh = globw-xpos-1, globh-ypos
+
+        stdscr.erase()
+
+        # Draw title
+        stdscr.addstr(ypos, xpos, f"{title:^{min(width,maxw)}}")
+
+        # Draw graph
+        lines = fig.show().split('\n')
+        for i, line in enumerate(lines):
+            if i > maxh-2: break
+            line = escape_ansi(line)
+
+            stdscr.addstr(i+1+ypos, xpos , line[:min(width,maxw)])
+
+        # Show the extreme points of the width and also the last printable char
+        show_control_chars = False
+        if show_control_chars:
+            stdscr.addstr(0,0, f"{maxw}, {maxh}")
+            stdscr.addstr(ypos, xpos, "*", curses.A_REVERSE)
+            stdscr.addstr(ypos+maxh-1, xpos, "*", curses.A_REVERSE)
+            stdscr.addstr(ypos, xpos+maxw-1, "*", curses.A_REVERSE)
+            stdscr.addstr(ypos+maxh-1, xpos+maxw-2, "*", curses.A_REVERSE)
+            stdscr.addstr(ypos+ min(height, maxh-1), xpos, "+", curses.A_REVERSE)
+            stdscr.addstr(ypos, xpos+min(maxw-1, width), "+", curses.A_REVERSE)
+            stdscr.addstr(ypos+min(height, maxh-1), xpos+min(width, maxw-2), "+", curses.A_REVERSE)
+
+        stdscr.refresh()
+        key = stdscr.getch()
+        stdscr.refresh()
+        if key in [3, ord('q')]: 
+            return None
+        resp = get_data_function(gid)
+
+
+
+if __name__ == "__main__":
+    title = "Global Transfer Speeds"
+    end_time = 180
+    get_data_function = lambda: sendReq(getGlobalStat())
+    gid = "60e0c88ed77a24d6"
+    get_data_function = lambda: sendReq(tellStatus(gid))
+    wait_time = 2
+
+    stdscr = start_curses()
+    size_func = lambda: (
+        3*os.get_terminal_size()[0]//4,
+        3*os.get_terminal_size()[1]//4,
+    )
+    xposf = lambda: os.get_terminal_size()[0]//8
+    yposf = lambda: os.get_terminal_size()[1]//8
+    graph_speeds(
+        stdscr,
+        get_data_function=get_data_function,
+        timeout=end_time,
+        refresh_time=wait_time,
+        title=title,
+        graph_wh= size_func,
+        xposf=xposf,
+        yposf=yposf,
+            
+    )
+    close_curses(stdscr)

{listpick-0.1.14.14.dist-info → listpick-0.1.15.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: listpick
-Version: 0.1.14.14
+Version: 0.1.15.1
 Summary: Listpick is a powerful TUI data tool for creating TUI apps or viewing/comparing tabulated data.
 Home-page: https://github.com/grimandgreedy/listpick
 Author: Grim
@@ -27,6 +27,7 @@ Requires-Dist: pyperclip; extra == "full"
 Requires-Dist: toml; extra == "full"
 Requires-Dist: traitlets; extra == "full"
 Requires-Dist: odfpy; extra == "full"
+Requires-Dist: plotille; extra == "full"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{listpick-0.1.14.14.dist-info → listpick-0.1.15.1.dist-info}/RECORD

@@ -1,13 +1,16 @@
 listpick/__init__.py,sha256=ExXc97-bibodH--wlwpQivl0zCNR5D1hvpvrf7OBofU,154
 listpick/__main__.py,sha256=wkCjDdqw093W27yWwnlC3nG_sMRKaIad7hHHWy0RBgY,193
-listpick/listpick_app.py,sha256=lvmg2iAxoL91NMv7ptQmdjZHCG0GvsSIqEKBJmtDhFw,187716
+listpick/listpick_app.py,sha256=iWa6N4PVeOoLa9Yi9CMUojDHoXzSQviObnfv5vPgpiA,193216
+listpick/pane/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+listpick/pane/get_data.py,sha256=21PTDXt9HP-4vZV4QUM8sidTqDEaKnKCDshl3-cSRCo,2255
+listpick/pane/pane_functions.py,sha256=7xynpd3HjZnt6s9W0ZsJlrmYvGCMstAI5OJ7EuQSzdg,3092
+listpick/pane/pane_utils.py,sha256=tMp8KlFng6ZQgNjd8iFrl1zWZLPXMH_Y1A_QeuQYAk0,2537
 listpick/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-listpick/ui/build_help.py,sha256=B_NuIqexvqui8sDZotyu36aN_Yypfg6EJYCynZICLOY,10176
-listpick/ui/footer.py,sha256=9oJm95pOCxMEoS7Y-77G3D3dPGK4NnsqPMEAtaOpJco,15087
+listpick/ui/build_help.py,sha256=NY-bDVV5NYQ2mEJo3-tTUsFpG7R6hwROPZPgc8NGfA0,10451
+listpick/ui/footer.py,sha256=OH27JLGvvq9TlUsI30ODG6cHvjm7NTGSbXvF6lN1qiY,15089
 listpick/ui/help_screen.py,sha256=zbfGIgb-IXtATpl4_Sx7nPbsnRXZ7eiMYlCKGS9EFmw,5608
 listpick/ui/input_field.py,sha256=ylf3fiLXdAD4pueHWfzIrlwaRb9f5zm8f1UGkEPBxgM,30539
-listpick/ui/keys.py,sha256=7ZhJfsSatpk-jwfXj_FvzgQsQdUoF7JkD5Mniu9XZ0o,13328
-listpick/ui/pane_stuff.py,sha256=7GXa4UnV_7YmBv-baRi5moN51wYcuS4p0odl5C3m0Tc,169
+listpick/ui/keys.py,sha256=82uzU_cMo6NFHVi3P6cP0uE2ZN0h1EaVLYIVKuB26AU,13494
 listpick/ui/picker_colours.py,sha256=wftDxmUI6tGmOIPwBe4rUUsrPTtpFGgztptCifa_tqA,12287
 listpick/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 listpick/utils/clipboard_operations.py,sha256=ORdNm2kgGbfs51xJSvgJPERgoSmBgT11axuMkvSoP9A,3133
@@ -15,6 +18,7 @@ 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=7sv6JRhk0-Gcj4kOlkzx4qPNBJZ-GFWg9vM77GktzpI,3073
+listpick/utils/graphing.py,sha256=ugjAH8js_iH7hulg4SySxb_W_f8B6GhTaceN5i7DID4,6954
 listpick/utils/keycodes.py,sha256=ZGkw1-4szxPnP81wj80r92L6_neIOlBBjQltEieCwnk,2696
 listpick/utils/options_selectors.py,sha256=Vbv4jRkUsSPs7g-EQAv9Q0nhYy6Z4sFsJqMjUIe1oeQ,2814
 listpick/utils/paste_operations.py,sha256=7wDXLPlxUgA3CA99gwsm47juWGO2YQ9EJghW06yo9vI,1242
@@ -25,9 +29,9 @@ listpick/utils/sorting.py,sha256=WZZiVlVA3Zkcpwji3U5SNFlQ14zVEk3cZJtQirBkecQ,532
 listpick/utils/table_to_list_of_lists.py,sha256=XBj7eGBDF15BRME-swnoXyOfZWxXCxrXp0pzsBfcJ5g,12224
 listpick/utils/user_input.py,sha256=oyJZPAwA7UGAclPhdPL44tKnPIVNHWhX-tZEnCdBKC0,4318
 listpick/utils/utils.py,sha256=McOl9uT3jh7l4TIWeSd8ZGjK_e7r0YZF0Gl20yI6fl0,13873
-listpick-0.1.14.14.dist-info/licenses/LICENSE.txt,sha256=2mP-MRHJptADDNE9VInMNg1tE-C6Qv93Z4CCQKrpg9w,1061
-listpick-0.1.14.14.dist-info/METADATA,sha256=Xm4gp-Ad6QT0I7nKM7k9c00IWS9xLNj5R68nRAVTzOc,8091
-listpick-0.1.14.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-listpick-0.1.14.14.dist-info/entry_points.txt,sha256=-QCf_BKIkUz35Y9nkYpjZWs2Qg0KfRna2PAs5DnF6BE,43
-listpick-0.1.14.14.dist-info/top_level.txt,sha256=5mtsGEz86rz3qQDe0D463gGjAfSp6A3EWg4J4AGYr-Q,9
-listpick-0.1.14.14.dist-info/RECORD,,
+listpick-0.1.15.1.dist-info/licenses/LICENSE.txt,sha256=2mP-MRHJptADDNE9VInMNg1tE-C6Qv93Z4CCQKrpg9w,1061
+listpick-0.1.15.1.dist-info/METADATA,sha256=aQnHr2pHjI9T5RcXrHPqfOPoK5fR792K_79TOradL3E,8131
+listpick-0.1.15.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+listpick-0.1.15.1.dist-info/entry_points.txt,sha256=-QCf_BKIkUz35Y9nkYpjZWs2Qg0KfRna2PAs5DnF6BE,43
+listpick-0.1.15.1.dist-info/top_level.txt,sha256=5mtsGEz86rz3qQDe0D463gGjAfSp6A3EWg4J4AGYr-Q,9
+listpick-0.1.15.1.dist-info/RECORD,,

listpick/ui/pane_stuff.py

@@ -1,8 +0,0 @@
-import curses
-
-features = {
-    "position": "top",
-    "height": 4,
-}
-def textbox(x:int, y:int, w:int, h:int, text:str):
-    """ Draw a textbox in the region given. """