listpick 0.1.13.58__py3-none-any.whl → 0.1.13.59__py3-none-any.whl

listpick/listpick_app_problem_branch.py

@@ -1,3248 +0,0 @@
-#!/bin/python
-# -*- coding: utf-8 -*-
-"""
-listpick_app.py
-Set up environment to parse command-line arguments and run a Picker.
-
-Author: GrimAndGreedy
-License: MIT
-"""
-
-import curses
-import re
-import os
-import subprocess
-import argparse
-import time
-from wcwidth import wcswidth
-from typing import Callable, Optional, Tuple, Dict
-import json
-import threading
-import string
-import logging
-
-from listpick.ui.picker_colours import get_colours, get_help_colours, get_notification_colours, get_theme_count, get_fallback_colours
-from listpick.utils.options_selectors import default_option_input, output_file_option_selector, default_option_selector
-from listpick.utils.table_to_list_of_lists import *
-from listpick.utils.utils import *
-from listpick.utils.sorting import *
-from listpick.utils.filtering import *
-from listpick.ui.input_field import *
-from listpick.utils.clipboard_operations import *
-from listpick.utils.paste_operations import *
-from listpick.utils.searching import search
-from listpick.ui.help_screen import help_lines
-from listpick.ui.keys import picker_keys, notification_keys, options_keys, help_keys
-from listpick.utils.generate_data import generate_picker_data
-from listpick.utils.dump import dump_state, load_state, dump_data
-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
-
-
-try:
-    from tmp.data_stuff import test_items, test_highlights, test_header
-except:
-    test_items, test_highlights, test_header = [], [], []
-
-COLOURS_SET = False
-help_colours, notification_colours = {}, {}
-
-class Command:
-    def __init__(self, command_type, command_value):
-        self.command_type = command_type
-        self.command_value = command_value
-
-class Picker:
-    def __init__(self,
-        stdscr: curses.window, 
-        items: list[list[str]] = [],
-        cursor_pos: int = 0,
-        colours: dict = get_colours(0),
-        colour_theme_number: int = 0,
-        max_selected: int = -1,
-        top_gap: int =0,
-        title: str ="Picker",
-        header: list =[],
-        max_column_width: int =70,
-        clear_on_start: bool = False,
-        
-        auto_refresh: bool =False,
-        timer: float = 5,
-
-        get_new_data: bool =False,                          # Whether we can get new data
-        refresh_function: Optional[Callable] = lambda: [],  # The function with which we get new data
-        get_data_startup: bool =False,                      # Whether we should get data at statrup
-        track_entries_upon_refresh: bool = True,
-        pin_cursor: bool = False,
-        id_column: int = 0,
-
-        unselectable_indices: list =[],
-        highlights: list =[],
-        highlights_hide: bool =False,
-        number_columns: bool =True,
-        column_widths: list = [],
-        column_indices: list = [],
-
-
-        current_row : int = 0,
-        current_page : int = 0,
-        is_selecting : bool = False,
-        is_deselecting : int = False,
-        start_selection: int = -1,
-        start_selection_col: int = -1,
-        end_selection: int = -1,
-        user_opts : str = "",
-        options_list: list[str] = [],
-        user_settings : str = "",
-        separator : str = "    ",
-        search_query : str = "",
-        search_count : int = 0,
-        search_index : int = 0,
-        filter_query : str = "",
-        hidden_columns: list = [],
-        indexed_items: list[Tuple[int, list[str]]] = [],
-        scroll_bar : int = True,
-
-        selections: dict = {},
-        cell_selections: dict[tuple[int,int], bool] = {},
-        highlight_full_row: bool =False,
-        cell_cursor: bool = False,
-
-        items_per_page : int = -1,
-        sort_method : int = 0,
-        SORT_METHODS: list[str] = ['Orig', 'lex', 'LEX', 'alnum', 'ALNUM', 'time', 'num', 'size'],
-        sort_reverse: list[bool] = [False],
-        selected_column: int = 0,
-        sort_column : int = 0,
-
-        columns_sort_method: list[int] = [0],
-        key_chain: str = "",
-        last_key: Optional[str] = None,
-
-        paginate: bool =False,
-        cancel_is_back: bool = False,
-        mode_index: int =0,
-        modes: list[dict] = [],
-        display_modes: bool =False,
-        require_option: list=[],
-        require_option_default: list=[],
-        option_functions: list[Callable[..., Tuple[bool, str]]] = [],
-        default_option_function: Callable[..., Tuple[bool, str]] = default_option_input,
-        disabled_keys: list=[],
-
-        show_header: bool = True,
-        show_row_header: bool = False,
-        show_footer: bool =True,
-        footer_style: int = 0,
-        footer_string: str="",
-        footer_string_auto_refresh: bool=False,
-        footer_string_refresh_function: Optional[Callable] = None,
-        footer_timer: float=1,
-        get_footer_string_startup=False,
-        unicode_char_width: bool = True,
-
-        colours_start: int =0,
-        colours_end: int =-1,
-        reset_colours: bool = True,
-        key_remappings: dict = {},
-        keys_dict:dict = picker_keys,
-        display_infobox : bool = False,
-        infobox_items: list[list[str]] = [],
-        infobox_title: str = "",
-        display_only: bool = False,
-
-        editable_columns: list[int] = [],
-        editable_by_default: bool = True,
-        
-        centre_in_terminal: bool = False,
-        centre_in_terminal_vertical: bool = False,
-        centre_in_cols: bool = False,
-
-        startup_notification:str = "",
-
-        leftmost_column: int = 0,
-        leftmost_char: int = 0,
-
-
-        history_filter_and_search: list[str] = [],
-        history_opts: list[str] = [],
-        history_settings: list[str] = [],
-        history_edits: list[str] = [],
-        history_pipes: list[str] = [],
-        debug: bool = False,
-        debug_level: int = 1,
-
-    ):
-        self.stdscr = stdscr
-        self.items = items
-        self.cursor_pos = cursor_pos
-        self.colours = colours
-        self.colour_theme_number = colour_theme_number
-        self.max_selected = max_selected
-        self.top_gap = top_gap
-        self.title = title
-        self.header = header
-        self.max_column_width = max_column_width
-        self.clear_on_start = clear_on_start
-        
-        self.auto_refresh = auto_refresh
-        self.timer = timer
-
-        self.get_new_data = get_new_data
-        self.refresh_function = refresh_function
-        self.get_data_startup = get_data_startup
-        self.track_entries_upon_refresh = track_entries_upon_refresh
-        self.pin_cursor = pin_cursor
-        self.id_column = id_column
-
-        self.unselectable_indices = unselectable_indices
-        self.highlights = highlights
-        self.highlights_hide = highlights_hide
-        self.number_columns = number_columns
-        self.column_widths, = [],
-        self.column_indices, = [],
-
-
-        self.current_row  = current_row
-        self.current_page = current_page
-        self.is_selecting = is_selecting
-        self.is_deselecting = is_deselecting
-        self.start_selection = start_selection
-        self.start_selection_col = start_selection_col
-        self.end_selection = end_selection
-        self.user_opts = user_opts
-        self.options_list = options_list
-        self.user_settings = user_settings
-        self.separator = separator
-        self.search_query = search_query
-        self.search_count = search_count
-        self.search_index = search_index
-        self.filter_query = filter_query
-        self.hidden_columns = hidden_columns
-        self.indexed_items = indexed_items
-        self.scroll_bar = scroll_bar
-
-        self.selections = selections
-        self.cell_selections = cell_selections
-        self.highlight_full_row = highlight_full_row
-        self.cell_cursor = cell_cursor
-
-        self.items_per_page = items_per_page
-        self.sort_method = sort_method
-        self.sort_reverse = sort_reverse
-        self.selected_column = selected_column
-        self.sort_column = sort_column
-        self.columns_sort_method = columns_sort_method
-        self.key_chain = key_chain
-        self.last_key = last_key
-
-        self.paginate = paginate
-        self.cancel_is_back = cancel_is_back
-        self.mode_index = mode_index
-        self.modes = modes
-        self.display_modes = display_modes
-        self.require_option = require_option
-        self.require_option_default = require_option_default
-        self.option_functions = option_functions
-        self.default_option_function = default_option_function
-        self.disabled_keys = disabled_keys
-
-        self.show_header = show_header
-        self.show_row_header = show_row_header
-        self.show_footer = show_footer
-        self.footer_style = footer_style
-        self.footer_string = footer_string
-        self.footer_string_auto_refresh = footer_string_auto_refresh
-        self.footer_string_refresh_function = footer_string_refresh_function
-        self.footer_timer = footer_timer
-        self.get_footer_string_startup = get_footer_string_startup,
-        self.unicode_char_width = unicode_char_width
-
-
-        self.colours_start = colours_start
-        self.colours_end = colours_end
-        self.reset_colours = reset_colours
-        self.key_remappings = key_remappings
-        self.keys_dict = keys_dict
-        self.display_infobox = display_infobox
-        self.infobox_items = infobox_items
-        self.infobox_title = infobox_title
-        self.display_only = display_only
-
-        self.editable_columns = editable_columns
-        self.editable_by_default = editable_by_default
-
-        self.centre_in_terminal = centre_in_terminal
-        self.centre_in_terminal_vertical = centre_in_terminal_vertical
-        self.centre_in_cols = centre_in_cols
-
-        self.startup_notification = startup_notification
-
-
-        self.registers = {}
-        
-        self.SORT_METHODS = SORT_METHODS
-        self.command_stack = []
-        self.leftmost_column = leftmost_column
-        self.leftmost_char = leftmost_char
-
-
-        # Refresh function variables
-        self.data_refreshed = False
-        self.refreshing_data = False
-        self.data_lock = threading.Lock()
-        self.data_ready = False
-        self.cursor_pos_id = 0
-        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
-        self.history_pipes = history_pipes
-        self.history_opts = history_opts
-        self.history_settings = history_settings
-        self.history_edits = history_edits
-
-
-
-
-        self.debug = debug
-        self.debug_level = debug_level
-
-
-        self.initialise_picker_state(reset_colours=self.reset_colours)
-
-        # Note: We have to set the footer after initialising the picker state so that the footer can use the get_function_data method
-        # self.footer_options = [StandardFooter(self.stdscr, colours_start, self.get_function_data), CompactFooter(self.stdscr, colours_start, self.get_function_data), NoFooter(self.stdscr, colours_start, self.get_function_data)]
-        self.footer_options = []
-        # self.footer = self.footer_options[self.footer_style]
-
-        self.footer = CompactFooter(self.stdscr, colours_start, self.get_function_data)
-
-
-
-    def calculate_section_sizes(self):
-        """
-        Calculte the following for the Picker:
-        self.items_per_page: the number of entry rows displayed
-        self.bottom_space: the size of the footer + the bottom buffer space
-        self.top_space: the size of the space at the top of the picker: title + modes + header + top_gap
-        """
-
-        self.logger.debug(f"function: calculate_section_sizes()")
-
-        # self.bottom_space
-        self.bottom_space = self.footer.height if self.show_footer else 0
-
-        ## self.top_space
-        h, w = self.stdscr.getmaxyx()
-        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
-        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)
-
-
-        # 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.column_widths
-        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)
-
-        # 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
-
-    def get_visible_rows(self) -> list[list[str]]:
-
-        self.logger.debug(f"function: get_visible_rows()")
-        ## Scroll with column select
-        if self.paginate:
-            start_index = (self.cursor_pos//self.items_per_page) * self.items_per_page
-            end_index = min(start_index + self.items_per_page, len(self.indexed_items))
-        ## Scroll
-        else:
-            scrolloff = self.items_per_page//2
-            start_index = max(0, min(self.cursor_pos - (self.items_per_page-scrolloff), len(self.indexed_items)-self.items_per_page))
-            end_index = min(start_index + self.items_per_page, len(self.indexed_items))
-        if len(self.indexed_items) == 0: start_index, end_index = 0, 0
-
-        rows = [v[1] for v in self.indexed_items[start_index:end_index]] if len(self.indexed_items) else self.items
-        return rows
-
-    def initialise_picker_state(self, reset_colours=False) -> None:
-        """ Initialise state variables for the picker. These are: debugging and colours. """
-
-        if curses.has_colors() and self.colours != None:
-            # raise Exception("Terminal does not support color")
-            curses.start_color()
-            if reset_colours:
-                global COLOURS_SET
-                COLOURS_SET = False
-                colours_end = set_colours(pick=self.colour_theme_number, start=self.colours_start)
-            if curses.COLORS >= 255 and curses.COLOR_PAIRS >= 150:
-                self.colours_start = self.colours_start
-                self.notification_colours_start = self.colours_start+50
-                self.help_colours_start = self.colours_start+100
-            else:
-                self.colours_start = 0
-                self.notification_colours_start = 0
-                self.help_colours_start = 0
-        else:
-                self.colours_start = 0
-                self.notification_colours_start = 0
-                self.help_colours_start = 0
-
-
-        debug_levels = [logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR, logging.CRITICAL]
-        dbglvl =  debug_levels[self.debug_level]
-        self.logger = setup_logger(name="picker_log", log_file="picker.log", log_enabled=self.debug, level =dbglvl)
-        self.logger.info(f"Initialiasing Picker.")
-        # self.notification(self.stdscr, message=repr(self.logger))
-
-
-        #                     1              2             3                4              5
-        # logger = logging.getLogger(__file__)
-        # if self.debug_level == 0:
-        #     logger = logging.getLogger()
-        #     logger.disabled = True
-        # else:
-        #
-        #     file_handler = logging.FileHandler(f"{self.title}.log", mode='w')
-        #     formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s', '%m-%d-%Y %H:%M:%S')
-        #     file_handler.setFormatter(formatter)
-        #     logger.addHandler(file_handler)
-        #     logger.setLevel(debug_levels[self.debug_level-1])
-
-            # logging.basicConfig(
-            #     level=debug_levels[self.debug_level-1],
-            #     format='%(asctime)s - %(levelname)s - %(message)s',
-            #     datefmt='%m-%d-%Y %H:%M:%S',
-            #     filename=f"{self.title}.log",
-            #     filemode="w",
-            # )
-        #
-        # self.logger.info(f"Starging log. Log level {logger.getEffectiveLevel()}")
-        # self.logger.info(f"Starging log. Log level {repr(debug_levels)}, {self.debug_level}, {debug_levels[self.debug_level-1]}")
-        # self.notification(self.stdscr, f"Starging log. Log level {repr(debug_levels)}, {self.debug_level}, {debug_levels[self.debug_level-1]}")
-        # self.notification(self.stdscr, f"{__file__}")
-
-        ## Logging level plan
-        # DEBUG: loop functions, draw screen, etc.
-        # INFO: main functions 
-        # WARNING: any try-except fails 
-
-        # No set_escdelay function on windows.
-        try:
-            curses.set_escdelay(25)
-        except:
-            logging.warning("Error trying to set curses.set_escdelay")
-
-        # self.stdscr.clear()
-        # self.stdscr.refresh()
-        # self.draw_screen(self.indexed_items, self.highlights)
-
-
-
-    def initialise_variables(self, get_data: bool = False) -> None:
-        """ Initialise the variables that keep track of the data. """
-
-        self.logger.info(f"function: initialise_variables()")
-
-        tracking = False
-
-        ## Get data synchronously
-        if get_data and self.refresh_function != None:
-            if self.track_entries_upon_refresh and len(self.items) > 0:
-                tracking = True
-                selected_indices = get_selected_indices(self.selections)
-                self.selected_cells_by_row = get_selected_cells_by_row(self.cell_selections)
-                self.ids = [item[self.id_column] for i, item in enumerate(self.items) if i in selected_indices]
-                self.ids_tuples = [(i, item[self.id_column]) for i, item in enumerate(self.items) if i in selected_indices]
-        
-                if len(self.indexed_items) > 0 and len(self.indexed_items) >= self.cursor_pos and len(self.indexed_items[0][1]) >= self.id_column:
-                    self.cursor_pos_id = self.indexed_items[self.cursor_pos][1][self.id_column]
-        
-            self.items, self.header = self.refresh_function()
-
-                    
-        if self.items == []: self.items = [[]]
-        ## Ensure that items is a List[List[Str]] object
-        if len(self.items) > 0 and not isinstance(self.items[0], list):
-            self.items = [[item] for item in self.items]
-        self.items = [[str(cell) for cell in row] for row in self.items]
-
-
-        # Ensure that header is of the same length as the rows
-        if self.header and len(self.items) > 0 and len(self.header) != len(self.items[0]):
-            self.header = [str(self.header[i]) if i < len(self.header) else "" for i in range(len(self.items[0]))]
-
-        # Constants
-        # DEFAULT_ITEMS_PER_PAGE = os.get_terminal_size().lines - top_gap*2-2-int(bool(header))
-
-        self.calculate_section_sizes()
-
-        # Initial states
-        if len(self.selections) != len(self.items):
-            self.selections = {i : False if i not in self.selections else bool(self.selections[i]) for i in range(len(self.items))}
-
-        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]))}
-        elif len(self.items) == 0:
-            self.cell_selections = {}
-
-        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))]
-        if len(self.option_functions) < len(self.items):
-            self.option_functions += [self.default_option_function for i in range(len(self.items)-len(self.option_functions))]
-        if len(self.items)>0 and len(self.columns_sort_method) < len(self.items[0]):
-            self.columns_sort_method = self.columns_sort_method + [0 for i in range(len(self.items[0])-len(self.columns_sort_method))]
-        if len(self.items)>0 and len(self.sort_reverse) < len(self.items[0]):
-            self.sort_reverse = self.sort_reverse + [False for i in range(len(self.items[0])-len(self.sort_reverse))]
-        if len(self.items)>0 and len(self.editable_columns) < len(self.items[0]):
-            self.editable_columns = self.editable_columns + [self.editable_by_default for i in range(len(self.items[0])-len(self.editable_columns))]
-        if len(self.items)>0 and len(self.column_indices) < len(self.items[0]):
-            self.column_indices = self.column_indices + [i for i in range(len(self.column_indices), len(self.items[0]))]
-
-
-        
-        # items2 = [[row[self.column_indices[i]] for i in range(len(row))] for row in self.items]
-        # self.indexed_items = list(enumerate(items2))
-        if self.items == [[]]: self.indexed_items = []
-        else: self.indexed_items = list(enumerate(self.items))
-
-        # If a filter is passed then refilter
-        if self.filter_query:
-            # prev_index = self.indexed_items[cursor_pos][0] if len(self.indexed_items)>0 else 0
-            # prev_index = self.indexed_items[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 self.cursor_pos in [x[0] for x in self.indexed_items]: self.cursor_pos = [x[0] for x in self.indexed_items].index(self.cursor_pos)
-            else: self.cursor_pos = 0
-        if self.search_query:
-            return_val, tmp_cursor, tmp_index, tmp_count, tmp_highlights = search(
-                query=self.search_query,
-                indexed_items=self.indexed_items,
-                highlights=self.highlights,
-                cursor_pos=self.cursor_pos,
-                unselectable_indices=self.unselectable_indices,
-                continue_search=True,
-            )
-            if return_val:
-                self.cursor_pos, self.search_index, self.search_count, self.highlights = tmp_cursor, tmp_index, tmp_count, tmp_highlights
-        # If a sort is passed
-        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
-        # if len(self.items[0]) == 1:
-        #     self.number_columns = False
-
-
-
-        h, w = self.stdscr.getmaxyx()
-
-        # Adjust variables to ensure correctness if errors
-        ## Move to a selectable row (if applicable)
-        if len(self.items) <= len(self.unselectable_indices): self.unselectable_indices = []
-        new_pos = (self.cursor_pos)%len(self.items)
-        while new_pos in self.unselectable_indices and new_pos != self.cursor_pos:
-            new_pos = (new_pos + 1) % len(self.items)
-
-        assert new_pos < len(self.items)
-        self.cursor_pos = new_pos
-
-
-        # if tracking and len(self.items) > 1:
-        # Ensure that selected indices are tracked upon data refresh
-        if self.track_entries_upon_refresh and (self.data_ready or tracking) and len(self.items) > 1:
-            selected_indices = []
-            all_ids = [item[self.id_column] for item in self.items]
-            self.selections = {i: False for i in range(len(self.items))}
-            if len(self.items) > 0:
-                self.cell_selections = {(i, j): False for i in range(len(self.items)) for j in range(len(self.items[0]))}
-            else:
-                self.cell_selections = {}
-
-            for id in self.ids:
-                if id in all_ids:
-                    selected_indices.append(all_ids.index(id))
-                    self.selections[all_ids.index(id)] = True
-
-            for i, id in self.ids_tuples:
-                if id in all_ids:
-                    # rows_with_selected_cells
-                    for j in self.selected_cells_by_row[i]:
-                        self.cell_selections[(all_ids.index(id), j)] = True
-
-
-
-            if len(self.indexed_items):
-                if self.pin_cursor:
-                    self.cursor_pos = min(self.cursor_pos_prev, len(self.indexed_items)-1)
-                else:
-                    if self.cursor_pos_id in all_ids:
-                        cursor_pos_x = all_ids.index(self.cursor_pos_id)
-                        if cursor_pos_x in [i[0] for i in self.indexed_items]:
-                            self.cursor_pos = [i[0] for i in self.indexed_items].index(cursor_pos_x)
-            else:
-                self.cursor_pos = 0
-        
-        # if self.display_infobox:
-        #     self.infobox_picker = self.infobox(self.stdscr, self.infobox_items, self.infobox_title)
-
-
-    def move_column(self, direction: int) -> None:
-        """ 
-        Cycles the column $direction places. 
-        E.g., If $direction == -1 and the sort column is 3, then column 3 will swap with column 2
-            in each of the rows in $items and 2 will become the new sort column.
-
-        sort_column = 3, direction = -1
-            [[0,1,2,*3*,4],
-             [5,6,7,*8*,9]]
-                -->
-            [[0,1,*3*,2,4],
-             [5,6,*8*,7,9]]
-
-        returns:
-            adjusted items, header, sort_column and column_widths
-        """
-        self.logger.info(f"function: move_column(direction={direction})")
-        if len(self.items) < 1: return None
-        if (self.selected_column+direction) < 0 or (self.selected_column+direction) >= len(self.items[0]): return None
-
-        new_index = self.selected_column + direction
-
-        # Swap columns in each row
-        for row in self.items:
-            row[self.selected_column], row[new_index] = row[new_index], row[self.selected_column]
-        if self.header:
-            self.header[self.selected_column], self.header[new_index] = self.header[new_index], self.header[self.selected_column]
-
-        # Swap column widths
-        self.column_widths[self.selected_column], self.column_widths[new_index] = self.column_widths[new_index], self.column_widths[self.selected_column]
-
-        # Update current column index
-        self.selected_column = new_index
-
-    def test_screen_size(self):
-        self.logger.debug("function: test_screen_size()")
-        h, w = self.stdscr.getmaxyx()
-        ## Terminal too small to display Picker
-        if h<3 or w<len("Terminal"): return False
-        if (self.show_footer or self.footer_string) and (h<12 or w<35) or (h<12 and w<10):
-            self.stdscr.addstr(h//2-1, (w-len("Terminal"))//2, "Terminal")
-            self.stdscr.addstr(h//2, (w-len("Too"))//2, "Too")
-            self.stdscr.addstr(h//2+1, (w-len("Small"))//2, "Small")
-            return False
-        return True
-
-    def splash_screen(self, message=""):
-        self.logger.info(f"function: splash_screen({message})")
-        """ Display a splash screen with a message. Useful when loading a large data set. """
-        h, w =self.stdscr.getmaxyx()
-        self.stdscr.bkgd(' ', curses.color_pair(2))
-        try:
-            self.stdscr.addstr(h//2, (w-len(message))//2, message, curses.color_pair(2))
-        except:
-            pass
-        self.stdscr.refresh()
-
-    def draw_screen_wr(self, indexed_items: list[Tuple[int, list[str]]], highlights: list[dict] = [{}], clear: bool = True) -> None:
-        """ Try-except wrapper for the draw_screen_() method to prevent crashes when rapidly resizing the terminal. """
-        try:
-            self.draw_screen(self.indexed_items, self.highlights, clear=clear)
-        except:
-            self.logger.warning(f"draw_screen function error")
-
-    def draw_screen(self, indexed_items: list[Tuple[int, list[str]]], highlights: list[dict] = [{}], clear: bool = True) -> None:
-        """ Draw Picker screen. """
-        self.logger.debug("Draw screen.")
-
-        if clear:
-            self.stdscr.erase()
-
-        h, w = self.stdscr.getmaxyx()
-
-        # Test if the terminal is of a sufficient size to display the picker
-        if not self.test_screen_size(): return None
-
-        # Determine which rows are to be displayed on the current screen
-        ## Paginate
-        if self.paginate:
-            start_index = (self.cursor_pos//self.items_per_page) * self.items_per_page
-            end_index = min(start_index + self.items_per_page, len(self.indexed_items))
-        ## Scroll
-        else:
-            scrolloff = self.items_per_page//2
-            start_index = max(0, min(self.cursor_pos - (self.items_per_page-scrolloff), len(self.indexed_items)-self.items_per_page))
-            end_index = min(start_index + self.items_per_page, len(self.indexed_items))
-        if len(self.indexed_items) == 0: start_index, end_index = 0, 0
-
-        # 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)
-        # Determine widths based only on the currently indexed rows
-        # 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)
-        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)
-
-        # Determine the number of items_per_page, top_size and bottom_size
-        self.calculate_section_sizes()
-        
-        # top_space = self.top_gap
-
-        ## 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, 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)
-            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)
-            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)}}"
-                else:
-                    mode_str = f"{mode:^{mode_widths[i]+split_space}}"
-                # current mode
-                if i == self.mode_index:
-                    self.stdscr.addstr(self.top_gap+1, xmode, mode_str, curses.color_pair(self.colours_start+14) | curses.A_BOLD)
-                # other modes
-                else:
-                    self.stdscr.addstr(self.top_gap+1, xmode, mode_str, curses.color_pair(self.colours_start+15) | curses.A_UNDERLINE)
-                xmode += split_space+mode_widths[i]
-            # top_space += 1
-
-        ## Display header
-        if self.header and self.show_header:
-            header_str = ""
-            up_to_selected_col = ""
-            selected_col_str = ""
-            for i in range(len(self.header)):
-                if i == self.selected_column: up_to_selected_col = header_str
-                if i in self.hidden_columns: continue
-                number = f"{i}. " if self.number_columns else ""
-                # number = f"{intStringToExponentString(str(i))}. " if self.number_columns else ""
-                header_str += number
-                header_str += f"{self.header[i]:^{self.column_widths[i]-len(number)}}"
-                header_str += self.separator
-
-            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)
-
-            # 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:
-                        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)
-                        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:
-                pass
-                
-        # Display row header 
-        if self.show_row_header:
-            for idx in range(start_index, end_index):
-                y = idx - start_index + self.top_space
-                if idx == self.cursor_pos:
-                    self.stdscr.addstr(y, 0, f" {self.indexed_items[idx][0]} ", curses.color_pair(self.colours_start+19) | curses.A_BOLD)
-                else:
-                    self.stdscr.addstr(y, 0, f" {self.indexed_items[idx][0]} ", curses.color_pair(self.colours_start+4) | curses.A_BOLD)
-
-        def highlight_cell(row: int, col:int, visible_column_widths, colour_pair_number: int = 5):
-            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
-            try:
-                # Start of cell is on screen
-                if self.startx <= cell_pos <= 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
-                    else:
-                        cell_value = self.indexed_items[row][1][col] + self.separator
-                    # cell_value = cell_value[:min(cell_width, cell_max_width)-len(self.separator)]
-                    cell_value = truncate_to_display_width(cell_value, min(cell_width, cell_max_width)-len(self.separator), self.unicode_char_width)
-                    cell_value = cell_value + self.separator
-                    # cell_value = cell_value
-                    cell_value = truncate_to_display_width(cell_value, min(cell_width, cell_max_width), 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:
-                    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]]
-                    self.stdscr.addstr(y, self.startx, cell_value, curses.color_pair(self.colours_start+colour_pair_number) | curses.A_BOLD)
-            except:
-                pass
-
-        # Draw:
-        #    1. standard row
-        #    2. highlights l0
-        #    3. selected
-        #    4. above-selected highlights l1
-        #    5. cursor
-        #    6. top-level highlights l2
-        ## Display rows and highlights
-
-        def sort_highlights(highlights):
-            """ 
-            Sort highlights into lists based on their display level.
-            Highlights with no level defined will be displayed at level 0.
-            """
-            l0 = []
-            l1 = []
-            l2 = []
-            for highlight in highlights:
-                if "level" in highlight:
-                    if highlight["level"] == 0: l0.append(highlight)
-                    elif highlight["level"] == 1: l1.append(highlight)
-                    elif highlight["level"] == 2: l2.append(highlight)
-                    else: l0.append(highlight)
-                else:
-                    l0.append(highlight)
-            return l0, l1, l2
-
-        def draw_highlights(highlights: list[dict], idx: int, y: int, item: tuple[int, list[str]]):
-            self.logger.debug(f"function: draw_highlights()")
-            if len(highlights) == 0: return None
-            full_row_str = format_row(item[1], self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols, self.unicode_char_width)
-            row_str = full_row_str[self.leftmost_char:]
-            for highlight in highlights:
-                if "row" in highlight:
-                    if highlight["row"] != self.indexed_items[idx][0]:
-                        continue
-                try:
-                    if highlight["field"] == "all":
-                        match = re.search(highlight["match"], full_row_str, re.IGNORECASE)
-                        if not match: continue
-                        highlight_start = match.start()
-                        highlight_end = match.end()
-                        if highlight_end - self.leftmost_char < 0:
-                            continue
-
-                    elif type(highlight["field"]) == type(0) and highlight["field"] not in self.hidden_columns:
-                        match = re.search(highlight["match"], truncate_to_display_width(item[1][highlight["field"]], self.column_widths[highlight["field"]], centre=False, unicode_char_width=self.unicode_char_width), re.IGNORECASE)
-                        if not match: continue
-                        field_start = sum([width for i, width in enumerate(self.column_widths[:highlight["field"]]) if i not in self.hidden_columns]) + sum([1 for i in range(highlight["field"]) if i not in self.hidden_columns])*wcswidth(self.separator)
-
-                        ## We want to search the non-centred values but highlight the centred values.
-                        if self.centre_in_cols:
-                            tmp = truncate_to_display_width(item[1][highlight["field"]], self.column_widths[highlight["field"]], self.centre_in_cols, self.unicode_char_width)
-                            field_start += (len(tmp) - len(tmp.lstrip()))
-
-                        highlight_start = field_start + match.start()
-                        highlight_end = match.end() + field_start
-                        if highlight_end - self.leftmost_char < 0:
-                            continue
-                    else:
-                        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)
-                except:
-                    pass
-
-        l0_highlights, l1_highlights, l2_highlights = sort_highlights(self.highlights)
-
-
-        for idx in range(start_index, end_index):
-            item = self.indexed_items[idx]
-            y = idx - start_index + self.top_space
-
-            # row_str = format_row(item[1], self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols)[self.leftmost_char:]
-            # row_str = 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, 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))
-            
-
-            # Draw the level 0 highlights
-            if not self.highlights_hide:
-                draw_highlights(l0_highlights, idx, y, item)
-
-            # Higlight cursor cell and selected cells
-            if self.cell_cursor:
-                # self.selected_cells_by_row = get_selected_cells_by_row(self.cell_selections)
-                if item[0] in self.selected_cells_by_row:
-                    for j in self.selected_cells_by_row[item[0]]:
-                        highlight_cell(idx, j, visible_column_widths, colour_pair_number=25)
-
-                # Visually selected
-                if self.is_selecting:
-                    if self.start_selection <= idx <= self.cursor_pos or self.start_selection >= idx >= self.cursor_pos:
-                        x_interval = range(min(self.start_selection_col, self.selected_column), max(self.start_selection_col, self.selected_column)+1)
-                        for col in x_interval:
-                            highlight_cell(idx, col, visible_column_widths, colour_pair_number=25)
-
-                # Visually deslected
-                if self.is_deselecting:
-                    if self.start_selection >= idx >= self.cursor_pos or self.start_selection <= idx <= self.cursor_pos:
-                        x_interval = range(min(self.start_selection_col, self.selected_column), max(self.start_selection_col, self.selected_column)+1)
-                        for col in x_interval:
-                            highlight_cell(idx, col, visible_column_widths, colour_pair_number=26)
-            # 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)
-                # 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))
-                # 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))
-
-            # Highlight the cursor row and the first char of the selected rows.
-            else:
-                if self.selections[item[0]]:
-                    self.stdscr.addstr(y, max(self.startx-2,0), ' ', curses.color_pair(self.colours_start+1))
-                # 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, max(self.startx-2,0), ' ', curses.color_pair(self.colours_start+1))
-                # Visually deslected
-                if self.is_deselecting:
-                    if self.start_selection >= idx >= self.cursor_pos or self.start_selection <= idx <= self.cursor_pos:
-                        self.stdscr.addstr(y, max(self.startx-2,0), ' ', curses.color_pair(self.colours_start+10))
-
-            if not self.highlights_hide:
-                draw_highlights(l1_highlights, idx, y, item)
-
-            # Draw cursor
-            if idx == self.cursor_pos:
-                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)
-            
-            if not self.highlights_hide:
-                draw_highlights(l2_highlights, idx, y, item)
-
-        ## Display scrollbar
-        if self.scroll_bar and len(self.indexed_items) and len(self.indexed_items) > (self.items_per_page):
-            scroll_bar_length = int(self.items_per_page*self.items_per_page/len(self.indexed_items))
-            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
-            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_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))
-
-        # 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)
-            else:
-                self.stdscr.addstr(0,w-3,"  ", curses.color_pair(self.colours_start+23) | curses.A_BOLD)
-
-        # self.stdscr.refresh()
-
-        ## 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)
-            except:
-                pass
-        elif self.footer_string:
-            footer_string_width = min(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.refresh()
-
-        ## Display infobox
-        if self.display_infobox:
-            self.infobox(self.stdscr, message=self.infobox_items, title=self.infobox_title)
-            # self.stdscr.timeout(2000)  # timeout is set to 50 in order to get the infobox to be displayed so here we reset it to 2000
-        # self.stdscr.refresh()
-
-        # if self.display_infobox:
-        #     # self.stdscr.refresh()
-        #     # self.infobox(self.stdscr, message=self.infobox_items, title=self.infobox_title)
-        #
-        #     infobox_width, infobox_height = w//2, 3*h//5
-        #     infobox_x, infobox_y = w - (infobox_width + 4), 3
-        #     self.infobox_picker.stdscr.mvwin(infobox_y, infobox_x)
-        #     self.infobox_picker.stdscr.resize(infobox_height, infobox_width)
-        #     self.infobox_picker.run()
-        #     self.infobox_picker.stdscr.noutrefresh()
-        # else:
-        #     # self.stdscr.noutrefresh()
-        #     pass
-        #
-        #
-        # if not self.display_only:
-        #     curses.doupdate()
-        #     self.stdscr.refresh()
-        #     pass
-
-
-    # def infobox___(self, stdscr: curses.window, message: list =[], title: str ="Infobox",  colours_end: int = 0, duration: int = 4):
-    #     """ Display non-interactive infobox window. """
-    #
-    #     self.logger.info(f"function: infobox()")
-    #     h, w = stdscr.getmaxyx()
-    #     notification_width, notification_height = w//2, 3*h//5
-    #     message_width = notification_width-5
-    #
-    #     notification_x, notification_y = w-(notification_width+4), 3
-    #     if not message: message = "!!"
-    #     if isinstance(message, str):
-    #         submenu_items = ["  "+message[i*message_width:(i+1)*message_width] for i in range(len(message)//message_width+1)]
-    #     else:
-    #         submenu_items = message
-    #
-    #     notification_remap_keys = { 
-    #         curses.KEY_RESIZE: curses.KEY_F5,
-    #         27: ord('q')
-    #     }
-    #     if len(submenu_items) > notification_height - 2:
-    #         submenu_items = submenu_items[:notification_height-3] + [f"{'....':^{notification_width}}"]
-    #     # while True:
-    #     h, w = stdscr.getmaxyx()
-    #
-    #     submenu_win = self.stdscr.derwin(notification_height, notification_width, 3, w - (notification_width+4))
-    #     infobox_data = {
-    #         "items": submenu_items,
-    #         "colours": notification_colours,
-    #         "colours_start": self.notification_colours_start,
-    #         "disabled_keys": [ord('z'), ord('c')],
-    #         "show_footer": False,
-    #         "top_gap": 0,
-    #         "key_remappings": notification_remap_keys,
-    #         "display_only": True,
-    #         "hidden_columns": [],
-    #         "title": title,
-    #         "reset_colours": False,
-    #     }
-    #     submenu_win.noutrefresh()
-    #     OptionPicker = Picker(submenu_win, **infobox_data)
-    #     return OptionPicker
-
-
-    def infobox(self, stdscr: curses.window, message: str ="", title: str ="Infobox",  colours_end: int = 0, duration: int = 4) -> curses.window:
-        """ Display non-interactive infobox window. """
-
-        self.logger.info(f"function: infobox()")
-        h, w = stdscr.getmaxyx()
-        notification_width, notification_height = w//2, 3*h//5
-        message_width = notification_width-5
-
-        if not message: message = "!!"
-        if isinstance(message, str):
-            submenu_items = ["  "+message[i*message_width:(i+1)*message_width] for i in range(len(message)//message_width+1)]
-        else:
-            submenu_items = message
-
-        notification_remap_keys = { 
-            curses.KEY_RESIZE: curses.KEY_F5,
-            27: ord('q')
-        }
-        if len(submenu_items) > notification_height - 2:
-            submenu_items = submenu_items[:notification_height-3] + [f"{'....':^{notification_width}}"]
-        while True:
-            h, w = stdscr.getmaxyx()
-
-            submenu_win = curses.newwin(notification_height, notification_width, 3, w - (notification_width+4))
-            infobox_data = {
-                "items": submenu_items,
-                "colours": notification_colours,
-                "colours_start": self.notification_colours_start,
-                "disabled_keys": [ord('z'), ord('c')],
-                "show_footer": False,
-                "top_gap": 0,
-                "key_remappings": notification_remap_keys,
-                "display_only": True,
-                "hidden_columns": [],
-                "title": title,
-                "reset_colours": False,
-            }
-
-            OptionPicker = Picker(submenu_win, **infobox_data)
-            s, o, f = OptionPicker.run()
-            if o != "refresh": break
-
-        return submenu_win
-
-    def get_function_data(self) -> dict:
-        self.logger.debug(f"function: get_function_data()")
-        """ Returns a dict of the main variables needed to restore the state of list_pikcer. """
-        function_data = {
-            "selections":                       self.selections,
-            "cell_selections":                  self.cell_selections,
-            "items_per_page":                   self.items_per_page,
-            "current_row":                      self.current_row,
-            "current_page":                     self.current_page,
-            "cursor_pos":                       self.cursor_pos,
-            "colours":                          self.colours,
-            "colour_theme_number":              self.colour_theme_number,
-            "selected_column":                  self.selected_column,
-            "sort_column":                      self.sort_column,
-            "sort_method":                      self.sort_method,
-            "sort_reverse":                     self.sort_reverse,
-            "SORT_METHODS":                     self.SORT_METHODS,
-            "hidden_columns":                   self.hidden_columns,
-            "is_selecting":                     self.is_selecting,
-            "is_deselecting":                   self.is_deselecting,
-            "user_opts":                        self.user_opts,
-            "options_list":                     self.options_list,
-            "user_settings":                    self.user_settings,
-            "separator":                        self.separator,
-            "search_query":                     self.search_query,
-            "search_count":                     self.search_count,
-            "search_index":                     self.search_index,
-            "filter_query":                     self.filter_query,
-            "indexed_items":                    self.indexed_items,
-            "start_selection":                  self.start_selection,
-            "start_selection_col":              self.start_selection_col,
-            "end_selection":                    self.end_selection,
-            "highlights":                       self.highlights,
-            "max_column_width":                 self.max_column_width,
-            "column_indices":                   self.column_indices,
-            "mode_index":                       self.mode_index,
-            "modes":                            self.modes,
-            "title":                            self.title,
-            "display_modes":                    self.display_modes,
-            "require_option":                   self.require_option,
-            "require_option_default":           self.require_option_default,
-            "option_functions":                 self.option_functions,
-            "top_gap":                          self.top_gap,
-            "number_columns":                   self.number_columns,
-            "items":                            self.items,
-            "indexed_items":                    self.indexed_items,
-            "header":                           self.header,
-            "scroll_bar":                       self.scroll_bar,
-            "columns_sort_method":              self.columns_sort_method,
-            "disabled_keys":                    self.disabled_keys,
-            "show_footer":                      self.show_footer,
-            "footer_string":                    self.footer_string,
-            "footer_string_auto_refresh":       self.footer_string_auto_refresh,
-            "footer_string_refresh_function":   self.footer_string_refresh_function,
-            "footer_timer":                     self.footer_timer,
-            "footer_style":                     self.footer_style,
-            "colours_start":                    self.colours_start,
-            "colours_end":                      self.colours_end,
-            "display_only":                     self.display_only,
-            "infobox_items":                    self.infobox_items,
-            "display_infobox":                  self.display_infobox,
-            "infobox_title":                    self.infobox_title,
-            "key_remappings":                   self.key_remappings,
-            "auto_refresh":                     self.auto_refresh,
-            "get_new_data":                     self.get_new_data,
-            "refresh_function":                 self.refresh_function,
-            "timer":                            self.timer,
-            "get_data_startup":                 self.get_data_startup,
-            "get_footer_string_startup":        self.get_footer_string_startup,
-            "editable_columns":                 self.editable_columns,
-            "last_key":                         self.last_key,
-            "centre_in_terminal":               self.centre_in_terminal,
-            "centre_in_terminal_vertical":      self.centre_in_terminal_vertical,
-            "centre_in_cols":                   self.centre_in_cols,
-            "highlight_full_row":               self.highlight_full_row,
-            "cell_cursor":                      self.cell_cursor,
-            "column_widths":                    self.column_widths,
-            "track_entries_upon_refresh":       self.track_entries_upon_refresh,
-            "pin_cursor":                       self.pin_cursor,
-            "id_column":                        self.id_column,
-            "startup_notification":             self.startup_notification,
-            "keys_dict":                        self.keys_dict,
-            "cancel_is_back":                   self.cancel_is_back,
-            "paginate":                         self.paginate,
-            "leftmost_column":                  self.leftmost_column,
-            "leftmost_char":                    self.leftmost_char,
-            "history_filter_and_search" :       self.history_filter_and_search,
-            "history_pipes" :                   self.history_pipes,
-            "history_opts" :                    self.history_opts,
-            "history_edits" :                   self.history_edits,
-            "history_settings":                 self.history_settings,
-            "show_header":                      self.show_header,
-            "show_row_header":                  self.show_row_header,
-            "debug":                            self.debug,
-            "debug_level":                      self.debug_level,
-            "reset_colours":                    self.reset_colours,
-            "unicode_char_width":               self.unicode_char_width,
-        }
-        return function_data
-
-    def set_function_data(self, function_data: dict) -> None:
-        """ Set variables from state dict containing core variables."""
-        self.logger.info(f"function: set_function_data()")
-        variables = self.get_function_data().keys()
-
-        for var in variables:
-            if var in function_data:
-                setattr(self, var, function_data[var])
-
-        reset_colours = bool("colour_theme_number" in function_data)
-        self.initialise_picker_state(reset_colours=reset_colours)
-
-        self.initialise_variables()
-        # if "colour_theme_number" in function_data:
-        #     global COLOURS_SET
-        #     COLOURS_SET = False
-        #     colours_end = set_colours(pick=self.colour_theme_number, start=self.colours_start)
-                
-        # if "items" in function_data: self.items = function_data["items"]
-        # if "header" in function_data: self.header = function_data["header"]
-        # self.indexed_items = function_data["indexed_items"] if "indexed_items" in function_data else []
-
-
-
-    def delete_entries(self) -> None:
-        """ Delete entries from view. """
-
-        self.logger.info(f"function: delete_entries()")
-        # Remove selected items from the list
-        selected_indices = [index for index, selected in self.selections.items() if selected]
-        if not selected_indices:
-            # Remove the currently focused item if nothing is selected
-            selected_indices = [self.indexed_items[self.cursor_pos][0]]
-
-        self.items = [item for i, item in enumerate(self.items) if i not in selected_indices]
-        self.indexed_items = [(i, item) for i, item in enumerate(self.items)]
-        self.selections = {i:False for i in range(len(self.indexed_items))}
-        self.cursor_pos = min(self.cursor_pos, len(self.indexed_items)-1)
-        self.initialise_variables()
-        self.draw_screen(self.indexed_items, self.highlights)
-
-
-    def choose_option(
-            self,
-            stdscr: curses.window,
-            options: list[list[str]] =[],
-            title: str = "Choose option",
-            x:int=0,
-            y:int=0,
-            literal:bool=False,
-            colours_start:int=0,
-            header: list[str] = [],
-            require_option:list = [],
-            option_functions: list = [],
-    ) -> Tuple[dict, str, dict]:
-        """
-        Display input field at x,y
-
-        ---Arguments
-            stdscr: curses screen
-            usrtxt (str): text to be edited by the user
-            title (str): The text to be displayed at the start of the text option picker
-            x (int): prompt begins at (x,y) in the screen given
-            y (int): prompt begins at (x,y) in the screen given
-            colours_start (bool): start index of curses init_pair.
-
-        ---Returns
-            usrtxt, return_code
-            usrtxt: the text inputted by the user
-            return_code: 
-                            0: user hit escape
-                            1: user hit return
-        """
-        self.logger.info(f"function: choose_option()")
-        if options == []: options = [[f"{i}"] for i in range(10)]
-        cursor = 0
-
-        
-        option_picker_data = {
-            "items": options,
-            "colours": notification_colours,
-            "colours_start": self.notification_colours_start,
-            "title":title,
-            "header":header,
-            "hidden_columns":[],
-            "require_option":require_option,
-            "keys_dict": options_keys,
-            "show_footer": False,
-            "cancel_is_back": True,
-            "number_columns": False,
-            "reset_colours": False,
-        }
-        while True:
-            h, w = stdscr.getmaxyx()
-
-            choose_opts_widths = get_column_widths(options, unicode_char_width=self.unicode_char_width)
-            window_width = min(max(sum(choose_opts_widths) + 6, 50) + 6, w)
-            window_height = min(h//2, max(6, len(options)+3))
-
-            submenu_win = curses.newwin(window_height, window_width, (h-window_height)//2, (w-window_width)//2)
-            submenu_win.keypad(True)
-            OptionPicker = Picker(submenu_win, **option_picker_data)
-            s, o, f = OptionPicker.run()
-
-            if o == "refresh": 
-                self.draw_screen(self.indexed_items, self.highlights)
-                continue
-            if s:
-                return {x: options[x] for x in s}, o, f
-            return {}, "", f
-
-
-
-    def notification(self, stdscr: curses.window, message: str="", title:str="Notification", colours_end: int=0, duration:int=4) -> None:
-
-        self.logger.info(f"function: notification()")
-        """ Notification box. """
-        notification_width, notification_height = 50, 7
-        message_width = notification_width-5
-
-        if not message: message = "!!"
-        submenu_items = ["  "+message[i*message_width:(i+1)*message_width] for i in range(len(message)//message_width+1)]
-
-        notification_remap_keys = { 
-            curses.KEY_RESIZE: curses.KEY_F5,
-            27: ord('q')
-        }
-        while True:
-            h, w = stdscr.getmaxyx()
-
-            submenu_win = curses.newwin(notification_height, notification_width, 3, w - (notification_width+4))
-            notification_data = {
-                "items": submenu_items,
-                "title": title,
-                "colours_start": self.notification_colours_start,
-                "show_footer": False,
-                "centre_in_terminal": True,
-                "centre_in_terminal_vertical": True,
-                "centre_in_cols": True,
-                "hidden_columns": [],
-                "keys_dict": notification_keys,
-                "disabled_keys": [ord('z'), ord('c')],
-                "highlight_full_row": True,
-                "top_gap": 0,
-                "cancel_is_back": True,
-                "reset_colours": False,
-
-            }
-            OptionPicker = Picker(submenu_win, **notification_data)
-            s, o, f = OptionPicker.run()
-
-            if o != "refresh": break
-            submenu_win.clear()
-            submenu_win.refresh()
-            del submenu_win
-            stdscr.clear()
-            stdscr.refresh()
-            self.draw_screen(self.indexed_items, self.highlights)
-        # set_colours(colours=get_colours(0))
-
-    def toggle_column_visibility(self, col_index:int) -> None:
-        """ Toggle the visibility of the column at col_index. """
-        self.logger.info(f"function: toggle_column_visibility()")
-        if 0 <= col_index < len(self.items[0]):
-            if col_index in self.hidden_columns:
-                self.hidden_columns.remove(col_index)
-            else:
-                self.hidden_columns.append(col_index)
-
-    def apply_settings(self) -> None:
-        """ 
-        The users settings will be stored in the user_settings variable. This function applies those settings.
-
-        ![0-9]+ show/hide column
-        s[0-9]+ set column focus for sort
-        g[0-9]+ go to index
-        p[0-9]+ go to page
-        nohl    hide search highlights
-        """
-        self.logger.info(f"function: apply_settings()")
-        if self.user_settings:
-            settings = re.split(r'\s+', self.user_settings)
-            for setting in settings:
-                if len(setting) == 0: continue
-
-                if setting[0] == "!" and len(setting) > 1:
-                    if setting[1:].isnumeric():
-                        cols = setting[1:].split(",")
-                        for col in cols:
-                            self.toggle_column_visibility(int(col))
-                    elif setting[1] == "r":
-                        self.auto_refresh = not self.auto_refresh
-                    elif setting[1] == "h":
-                        self.highlights_hide = not self.highlights_hide
-
-                elif setting in ["nhl", "nohl", "nohighlights"]:
-                    # 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 == "ct":
-                    self.centre_in_terminal = not self.centre_in_terminal
-                elif setting == "cc":
-                    self.centre_in_cols = not self.centre_in_cols
-                elif setting == "cv":
-                    self.centre_in_terminal_vertical = not self.centre_in_terminal_vertical
-                elif setting == "arb":
-                    self.insert_row(self.cursor_pos)
-                elif setting == "ara":
-                    self.insert_row(self.cursor_pos+1)
-                elif setting == "aca":
-                    self.insert_column(self.selected_column+1)
-                elif setting == "acb":
-                    self.insert_column(self.selected_column)
-                elif setting.startswith("ir"):
-                    if setting[2:].isnumeric():
-                        num = int(setting[2:])
-                    else:
-                        num = self.cursor_pos
-                    self.insert_row(num)
-                elif setting.startswith("ic"):
-                    if setting[2:].isnumeric():
-                        num = int(setting[2:])
-                    else:
-                        num = self.selected_column
-                    self.insert_column(num)
-
-                elif setting == "modes":
-                    self.display_modes = not self.display_modes
-                elif setting == "cell":
-                    self.cell_cursor = not self.cell_cursor
-                elif setting == "rh":
-                    self.show_row_header = not self.show_row_header
-                elif setting == "header":
-                    self.show_header = not self.show_header
-                elif setting[0] == "":
-                    cols = setting[1:].split(",")
-                elif setting == "footer":
-                    self.show_footer = not self.show_footer
-                    self.initialise_variables()
-                elif setting == "pc":
-                    self.pin_cursor = not self.pin_cursor
-                elif setting == "unicode":
-                    self.unicode_char_width = not self.unicode_char_width
-
-                elif setting.startswith("ft"):
-                    if len(setting) > 2 and setting[2:].isnumeric():
-                        
-                        num = int(setting[2:])
-                        self.footer_style = max(len(self.footer_options)-1, num)
-                        self.footer = self.footer_options[self.footer_style]
-                    else:
-                        self.footer_style = (self.footer_style+1)%len(self.footer_options)
-                        self.footer = self.footer_options[self.footer_style]
-                    self.initialise_variables()
-
-                elif setting.startswith("cwd="):
-                    os.chdir(os.path.expandvars(os.path.expanduser(setting[len("cwd="):])))
-                elif setting.startswith("hl"):
-                    hl_list = setting.split(",")
-                    if len(hl_list) > 1:
-                        hl_list = hl_list[1:]
-                        match = hl_list[0]
-                        if len(hl_list) > 1: 
-                            field = hl_list[1]
-                            if field.isnumeric() and field != "-1":
-                                field = int(field)
-                            else:
-                                field = "all"
-                        else:
-                            field = "all"
-                        if len(hl_list) > 2 and hl_list[2].isnumeric():
-                            colour_pair = int(hl_list[2])
-                        else:
-                            colour_pair = 10
-
-                        highlight = {
-                            "match": match,
-                            "field": field,
-                            "color": colour_pair
-                        }
-                        self.highlights.append(highlight)
-                        
-                        
-                elif setting.startswith("th"):
-                    global COLOURS_SET
-                    if curses.COLORS < 255:
-                        self.notification(self.stdscr, message=f"Theme 4 applied.")
-
-                    elif setting[2:].strip().isnumeric():
-                        COLOURS_SET = False
-                        try:
-                            theme_number = int(setting[2:].strip())
-                            self.colour_theme_number = min(get_theme_count()-1, theme_number)
-                            set_colours(self.colour_theme_number)
-                            self.draw_screen(self.indexed_items, self.highlights)
-                            self.notification(self.stdscr, message=f"Theme {self.colour_theme_number} applied.")
-                        except:
-                            pass
-                    else:
-                        COLOURS_SET = False
-                        self.colour_theme_number = (self.colour_theme_number + 1)%get_theme_count()
-                        # self.colour_theme_number = int(not bool(self.colour_theme_number))
-                        set_colours(self.colour_theme_number)
-                        self.draw_screen(self.indexed_items, self.highlights)
-                        self.notification(self.stdscr, message=f"Theme {self.colour_theme_number} applied.")
-
-                else:
-                    self.user_settings = ""
-                    return None
-
-
-            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()")
-        if command.command_type == "setting":
-            self.user_settings = command.command_value
-            self.apply_settings()
-
-    def redo(self):
-        self.logger.info(f"function: redo()")
-        if len(self.command_stack):
-            self.apply_command(self.command_stack[-1])
-
-    def toggle_item(self, index: int) -> None:
-        """ Toggle selection of item at index. """
-        self.logger.info(f"function: toggle_item()")
-        self.selections[index] = not self.selections[index]
-
-    def select_all(self) -> None:
-        """ Select all in indexed_items. """
-        self.logger.info(f"function: select_all()")
-        for i in range(len(self.indexed_items)):
-            self.selections[self.indexed_items[i][0]] = True
-        for i in self.cell_selections.keys():
-            self.cell_selections[i] = True
-        for row in range(len(self.indexed_items)):
-            self.selected_cells_by_row[row] = list(range(len(self.indexed_items[row][1])))
-
-    def deselect_all(self) -> None:
-        """ Deselect all items in indexed_items. """
-        self.logger.info(f"function: deselect_all()")
-        for i in range(len(self.selections)):
-            self.selections[i] = False
-        for i in self.cell_selections.keys():
-            self.cell_selections[i] = False
-        self.selected_cells_by_row = {}
-
-    def handle_visual_selection(self, selecting:bool = True) -> None:
-        """ Toggle visual selection or deselection. """
-        self.logger.info(f"function: handle_visual_selection()")
-        if not self.is_selecting and not self.is_deselecting and len(self.indexed_items) and len(self.indexed_items[0][1]):
-            self.start_selection = self.cursor_pos
-            self.start_selection_col = self.selected_column
-            if selecting:
-                self.is_selecting = True
-            else:
-                self.is_deselecting = True
-        elif self.is_selecting:
-            # end_selection = indexed_items[current_page * items_per_page + current_row][0]
-            self.end_selection = self.cursor_pos
-            if self.start_selection != -1:
-                start = max(min(self.start_selection, self.end_selection), 0)
-                end = min(max(self.start_selection, self.end_selection), len(self.indexed_items)-1)
-                for i in range(start, end + 1):
-                    if self.indexed_items[i][0] not in self.unselectable_indices:
-                        self.selections[self.indexed_items[i][0]] = True
-            if self.start_selection != -1:
-                ystart = max(min(self.start_selection, self.end_selection), 0)
-                yend = min(max(self.start_selection, self.end_selection), len(self.indexed_items)-1)
-                xstart = min(self.start_selection_col, self.selected_column)
-                xend = max(self.start_selection_col, self.selected_column)
-                for i in range(ystart, yend + 1):
-                    if self.indexed_items[i][0] not in self.unselectable_indices:
-                        row = self.indexed_items[i][0]
-                        if row not in self.selected_cells_by_row:
-                            self.selected_cells_by_row[row] = []
-
-                        for col in range(xstart, xend+1):
-                            cell_index = (row, col)
-                            self.cell_selections[cell_index] = True
-
-                            self.selected_cells_by_row[row].append(col)
-                        # Remove duplicates
-                        self.selected_cells_by_row[row] = list(set(self.selected_cells_by_row[row]))
-
-            self.start_selection = -1
-            self.end_selection = -1
-            self.is_selecting = False
-
-        elif self.is_deselecting:
-            self.end_selection = self.indexed_items[self.cursor_pos][0]
-            self.end_selection = self.cursor_pos
-            if self.start_selection != -1:
-                start = max(min(self.start_selection, self.end_selection), 0)
-                end = min(max(self.start_selection, self.end_selection), len(self.indexed_items)-1)
-                for i in range(start, end + 1):
-                    # selections[i] = False
-                    self.selections[self.indexed_items[i][0]] = False
-            if self.start_selection != -1:
-                ystart = max(min(self.start_selection, self.end_selection), 0)
-                yend = min(max(self.start_selection, self.end_selection), len(self.indexed_items)-1)
-                xstart = min(self.start_selection_col, self.selected_column)
-                xend = max(self.start_selection_col, self.selected_column)
-                for i in range(ystart, yend + 1):
-                    row = self.indexed_items[i][0]
-                    if self.indexed_items[i][0] not in self.unselectable_indices:
-                        if row in self.selected_cells_by_row:
-                            for col in range(xstart, xend+1):
-                                try:
-                                    self.selected_cells_by_row[row].remove(col)
-                                except:
-                                    pass
-                                cell_index = (row, col)
-                                self.cell_selections[cell_index] = False
-                            if self.selected_cells_by_row[row] == []:
-                                del self.selected_cells_by_row[row]
-
-            self.start_selection = -1
-            self.end_selection = -1
-            self.is_deselecting = False
-
-    def cursor_down(self, count=1) -> bool:
-        """ Move cursor down. """
-        self.logger.info(f"function: cursor_down()")
-        if len(self.indexed_items) == 0 or self.cursor_pos == len(self.indexed_items) -1:
-            return False
-        # Returns: whether page is turned
-        new_pos = self.cursor_pos + 1
-        new_pos = min(self.cursor_pos+count, len(self.indexed_items)-1)
-        while True:
-            if self.indexed_items[new_pos][0] in self.unselectable_indices: new_pos+=1
-            else: break
-        self.cursor_pos = new_pos
-        return True
-
-    def cursor_up(self, count=1) -> bool:
-        """ Move cursor up. """
-        self.logger.info(f"function: cursor_up()")
-        # Returns: whether page is turned
-
-        new_pos = max(self.cursor_pos - count, 0)
-        while True:
-            if new_pos < 0: return False
-            elif new_pos in self.unselectable_indices: new_pos -= 1
-            else: break
-        self.cursor_pos = new_pos
-        return True
-
-    def remapped_key(self, key: int, val: int, key_remappings: dict) -> bool:
-        """ Check if key has been remapped to val in key_remappings. """
-        # self.logger.info(f"function: remapped_key()")
-        if key in key_remappings:
-            if key_remappings[key] == val or (isinstance(key_remappings[key], list) and val in key_remappings[key]):
-                return True
-        return False
-
-    def check_key(self, function: str, key: int,  keys_dict: dict) -> bool:
-        """
-        Check if $key is assigned to $function in the keys_dict. 
-            Allows us to redefine functions to different keys in the keys_dict.
-
-        E.g., keys_dict = { $key, "help": ord('?') }, 
-        """
-        if function in keys_dict and key in keys_dict[function]:
-            return True
-        return False
-
-    def copy_dialogue(self) -> None:
-        """ Display dialogue to select how rows/cells should be copied. """
-        self.logger.info(f"function: copy_dialogue()")
-        copy_header = [
-            "Representation",
-            "Columns",
-        ]
-        options = [
-            ["Python list of lists", "Exclude hidden"],
-            ["Python list of lists", "Include hidden"],
-            ["Tab-separated values", "Exclude hidden"],
-            ["Tab-separated values", "Include hidden"],
-            ["Comma-separated values", "Exclude hidden"],
-            ["Comma-separated values", "Include hidden"],
-            ["Custom separator", "Exclude hidden"],
-            ["Custom separator", "Include hidden"],
-        ]
-        require_option = [False, False, False, False, False, False, True, True]
-        s, o, f = self.choose_option(self.stdscr, options=options, title="Copy selected", header=copy_header, require_option=require_option)
-
-
-        funcs = [
-            lambda items, indexed_items, selections, cell_selections, hidden_columns, cell_cursor: copy_to_clipboard(items, indexed_items, selections, cell_selections, hidden_columns, representation="python", copy_hidden_cols=False, cellwise=cell_cursor),
-            lambda items, indexed_items, selections, cell_selections, hidden_columns, cell_cursor: copy_to_clipboard(items, indexed_items, selections, cell_selections, hidden_columns, representation="python", copy_hidden_cols=True, cellwise=cell_cursor),
-            lambda items, indexed_items, selections, cell_selections, hidden_columns, cell_cursor: copy_to_clipboard(items, indexed_items, selections, cell_selections, hidden_columns, representation="tsv", copy_hidden_cols=False, cellwise=cell_cursor),
-            lambda items, indexed_items, selections, cell_selections, hidden_columns, cell_cursor: copy_to_clipboard(items, indexed_items, selections, cell_selections, hidden_columns, representation="tsv", copy_hidden_cols=True, cellwise=cell_cursor),
-            lambda items, indexed_items, selections, cell_selections, hidden_columns, cell_cursor: copy_to_clipboard(items, indexed_items, selections, cell_selections, hidden_columns, representation="csv", copy_hidden_cols=False, cellwise=cell_cursor),
-            lambda items, indexed_items, selections, cell_selections, hidden_columns, cell_cursor: copy_to_clipboard(items, indexed_items, selections, cell_selections, hidden_columns, representation="csv", copy_hidden_cols=True, cellwise=cell_cursor),
-            lambda items, indexed_items, selections, cell_selections, hidden_columns, cell_cursor: copy_to_clipboard(items, indexed_items, selections, cell_selections, hidden_columns, representation="custom_sv", copy_hidden_cols=False, separator=o, cellwise=cell_cursor),
-            lambda items, indexed_items, selections, cell_selections, hidden_columns, cell_cursor: copy_to_clipboard(items, indexed_items, selections, cell_selections, hidden_columns, representation="custom_sv", copy_hidden_cols=True, separator=o, cellwise=cell_cursor),
-        ]
-
-        # Copy items based on selection
-        if s:
-            for idx in s.keys():
-                funcs[idx](self.items, self.indexed_items, self.selections, self.cell_selections, self.hidden_columns, self.cell_cursor)
-    def paste_dialogue(self) -> None:
-        """ Display dialogue to select how to paste from the clipboard. """
-        self.logger.info(f"function: paste_dialogue()")
-        paste_header = [
-            "Representation",
-            "Columns",
-        ]
-        options = [
-            ["Paste values", ""],
-        ]
-        require_option = [False]
-        s, o, f = self.choose_option(self.stdscr, options=options, title="Paste values", header=paste_header, require_option=require_option)
-
-
-        funcs = [
-            lambda items, pasta, paste_row, paste_col: paste_values(items, pasta, paste_row, paste_col)
-        ]
-
-        try:
-            pasta = eval(pyperclip.paste())
-            if type(pasta) == type([]):
-                acceptable_data_type = True
-                for row in pasta:
-                    if type(row) != type([]):
-                        acceptable_data_type = False
-                        break
-
-                    for cell in row:
-                        if cell != None and type(cell) != type(""):
-                            acceptable_data_type = False
-                            break
-                    if not acceptable_data_type:
-                        break
-                if not acceptable_data_type:
-                    self.notification(self.stdscr, message="Error pasting data.")
-                    return None
-
-        except:
-            self.draw_screen(self.indexed_items, self.highlights)
-            self.notification(self.stdscr, message="Error pasting data.")
-            return None
-        if type(pasta) == type([]) and len(pasta) > 0 and type(pasta[0]) == type([]):
-            if s:
-                for idx in s.keys():
-                    return_val, tmp_items = funcs[idx](self.items, pasta, self.cursor_pos, self.selected_column)
-                    if return_val:
-                        cursor_pos = self.cursor_pos
-                        self.items = tmp_items
-                        self.initialise_variables()
-                        self.cursor_pos = cursor_pos
-
-    def save_dialog(self) -> None:
-        """ Display dialogue to select how to save the picker data. """
-        self.logger.info(f"function: save_dialog()")
-        
-        dump_header = []
-        options = [ 
-            ["Save data (pickle)."],
-            ["Save data (csv)."],
-            ["Save data (tsv)."],
-            ["Save data (json)."],
-            ["Save data (feather)."],
-            ["Save data (parquet)."],
-            ["Save data (msgpack)."],
-            ["Save state"]
-        ]
-        # require_option = [True, True, True, True, True, True, True, True]
-        s, o, f = self.choose_option(self.stdscr, options=options, title="Save...", header=dump_header)
-
-
-        funcs = [
-            lambda opts: dump_data(self.get_function_data(), opts),
-            lambda opts: dump_data(self.get_function_data(), opts, format="csv"),
-            lambda opts: dump_data(self.get_function_data(), opts, format="tsv"),
-            lambda opts: dump_data(self.get_function_data(), opts, format="json"),
-            lambda opts: dump_data(self.get_function_data(), opts, format="feather"),
-            lambda opts: dump_data(self.get_function_data(), opts, format="parquet"),
-            lambda opts: dump_data(self.get_function_data(), opts, format="msgpack"),
-            lambda opts: dump_state(self.get_function_data(), opts),
-        ]
-        
-        if s:
-            for idx in s.keys():
-                save_path_entered, save_path = output_file_option_selector(
-                    self.stdscr,
-                    refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights)
-                )
-                if save_path_entered:
-                    return_val = funcs[idx](save_path)
-                    if return_val:
-                        self.notification(self.stdscr, message=return_val, title="Error")
-
-    def load_dialog(self) -> None:
-        """ Display dialogue to select which file to load and in what way it should be loaded. """
-        self.logger.info(f"function: load_dialog()")
-        
-        dump_header = []
-        options = [ 
-            ["Load data (pickle)."],
-        ]
-        s, o, f = self.choose_option(self.stdscr, options=options, title="Open file...", header=dump_header)
-
-
-        funcs = [
-            lambda opts: load_state(opts)
-        ]
-
-        if s:
-            file_to_load = file_picker()
-            if file_to_load:
-                index = list(s.keys())[0]
-                return_val = funcs[index](file_to_load)
-                self.set_function_data(return_val)
-
-                # items = return_val["items"]
-                # header = return_val["header"]
-                self.initialise_variables()
-                self.draw_screen(self.indexed_items, self.highlights)
-                self.notification(self.stdscr, f"{repr(file_to_load)} has been loaded!")
-                # if return_val:
-                #     notification(stdscr, message=return_val, title="Error")
-
-    def set_registers(self):
-        """ Set registers to be sent to the input field. """
-        self.logger.info(f"function: set_registers()")
-        self.registers = {"*": self.indexed_items[self.cursor_pos][1][self.selected_column]} if len(self.indexed_items) and len(self.indexed_items[0][1]) else {}
-
-
-    def fetch_data(self) -> None:
-        """ Refesh data asynchronously. When data has been fetched self.data_ready is set to True. """
-        self.logger.info(f"function: fetch_data()")
-        tmp_items, tmp_header = self.refresh_function()
-        if self.track_entries_upon_refresh:
-            selected_indices = get_selected_indices(self.selections)
-            self.ids = [item[self.id_column] for i, item in enumerate(self.items) if i in selected_indices]
-            self.ids_tuples = [(i, item[self.id_column]) for i, item in enumerate(self.items) if i in selected_indices]
-            self.selected_cells_by_row = get_selected_cells_by_row(self.cell_selections)
-
-            if len(self.indexed_items) > 0 and len(self.indexed_items) >= self.cursor_pos and len(self.indexed_items[0][1]) >= self.id_column:
-                self.cursor_pos_id = self.indexed_items[self.cursor_pos][1][self.id_column]
-                self.cursor_pos_prev = self.cursor_pos
-        with self.data_lock:
-            self.items, self.header = tmp_items, tmp_header
-            self.data_ready = True
-            self.draw_screen(self.indexed_items, self.highlights)
-
-    def save_input_history(self, file_path: str) -> bool:
-        """ Save input field history. Returns True if successful save. """
-        self.logger.info(f"function: save_input_history()")
-        file_path = os.path.expanduser(file_path)
-        history_dict = {
-            "history_filter_and_search" :       self.history_filter_and_search,
-            "history_pipes" :                   self.history_pipes,
-            "history_opts" :                    self.history_opts,
-            "history_edits" :                   self.history_edits,
-            "history_settings":                 self.history_settings,
-        }
-        with open(file_path, 'w') as f:
-            json.dump(history_dict, f)
-
-        return True
-
-    def load_input_history(self, file_path:str) -> bool:
-        """ Load command history. Returns true if successful load. """
-        self.logger.info(f"function: load_input_history()")
-        file_path = os.path.expanduser(file_path)
-        if not os.path.exists(file_path):
-            return False
-        try:
-            with open(file_path, 'r') as f:
-                history_dict = json.load(f)
-
-            if "history_filter_and_search" in history_dict:
-                self.history_filter_and_search = history_dict["history_filter_and_search"]
-            if "history_pipes" in history_dict:
-                self.history_pipes = history_dict["history_pipes"]
-            if "history_opts" in history_dict:
-                self.history_opts = history_dict["history_opts"]
-            if "history_edits" in history_dict:
-                self.history_edits = history_dict["history_edits"]
-            if "history_settings" in history_dict:
-                self.history_settings = history_dict["history_settings"]
-
-        except:
-            return False
-
-        return True
-
-
-    def get_word_list(self) -> list[str]:
-        """ Get a list of all words used in any cell of the picker. Used for completion in search/filter input_field. """
-        self.logger.info(f"function: get_word_list()")
-        translator = str.maketrans('', '', string.punctuation)
-        
-        words = []
-        # Extract words from lists
-        for row in [x[1] for x in self.indexed_items]:
-            for i, cell in enumerate(row):
-                if i != (self.id_column%len(row)):
-                # Split the item into words and strip punctuation from each word
-                    words.extend(word.strip(string.punctuation) for word in cell.split())
-        for cell in self.header:
-            # Split the item into words and strip punctuation from each word
-            words.extend(word.strip(string.punctuation) for word in cell.split())
-        def key_f(s):
-            if len(s):
-                starts_with_char = s[0].isalpha()
-            else:
-                starts_with_char = False
-            return (not starts_with_char, s.lower())
-        # key = lambda s: (s != "" or not s[0].isalpha(), s)
-        words = sorted(list(set(words)), key=key_f)
-        return words
-
-    def insert_row(self, pos: int):
-        """ Insert a blank row at position `pos` """
-        self.logger.info(f"function: insert_row(pos={pos})")
-
-        if self.items != [[]]:
-            row_len = 1
-            if self.header: row_len = len(self.header)
-            elif len(self.items): row_len  = len(self.items[0])
-            # if len(self.indexed_items) == 0:
-            #     insert_at_pos = 0
-            # else:
-            #     insert_at_pos = self.indexed_items[self.cursor_pos][0]
-            self.items = self.items[:pos] + [["" for x in range(row_len)]] + self.items[pos:]
-            if pos <= self.cursor_pos:
-                self.cursor_pos += 1
-            # We are adding a row before so we have to move the cursor down
-            # If there is a filter then we know that an empty row doesn't match
-            current_cursor_pos = self.cursor_pos
-            self.initialise_variables()
-            self.cursor_pos = current_cursor_pos
-        else:
-            self.items = [[""]]
-            self.initialise_variables()
-
-    def insert_column(self, pos:int):
-        """ Insert blank column at `pos`"""
-        self.logger.info(f"function: insert_column(pos={pos})")
-        self.items = [row[:pos]+[""]+row[pos:] for row in self.items]
-        self.header = self.header[:pos] + [""] + self.header[pos:]
-        self.editable_columns = self.editable_columns[:pos] + [self.editable_by_default] + self.editable_columns[pos:]
-        if pos <= self.selected_column:
-            self.selected_column += 1
-        current_cursor_pos = self.cursor_pos
-        self.initialise_variables()
-        self.cursor_pos = current_cursor_pos
-
-
-
-    def run(self) -> Tuple[list[int], str, dict]:
-        """ Run the picker. """
-        self.logger.info(f"function: run()")
-
-        if self.get_footer_string_startup and self.footer_string_refresh_function != None:
-            self.footer_string = self.footer_string_refresh_function()
-
-        self.initialise_variables(get_data=self.get_data_startup)
-
-        self.draw_screen(self.indexed_items, self.highlights)
-
-        initial_time = time.time()
-        initial_time_footer = time.time()-self.footer_timer
-
-        if self.startup_notification:
-            self.notification(self.stdscr, message=self.startup_notification)
-            self.startup_notification = ""
-
-        # curses.curs_set(0)
-        # stdscr.nodelay(1)  # Non-blocking input
-        # stdscr.timeout(2000)  # Set a timeout for getch() to ensure it does not block indefinitely
-        self.stdscr.timeout(max(min(2000, int(self.timer*1000)//2, int(self.footer_timer*1000))//2, 20))  # Set a timeout for getch() to ensure it does not block indefinitely
-        
-        if self.clear_on_start:
-            self.stdscr.clear()
-            self.clear_on_start = False
-        else:
-            self.stdscr.erase()
-
-        self.stdscr.refresh()
-
-        # Initialize colours
-        # Check if terminal supports color
-
-        # Set terminal background color
-        self.stdscr.bkgd(' ', curses.color_pair(self.colours_start+3))  # Apply background color
-        self.draw_screen(self.indexed_items, self.highlights)
-
-        if self.display_only:
-            self.stdscr.refresh()
-            return [], "", {}
-
-        # Main loop
-
-        while True:
-            key = self.stdscr.getch()
-            h, w = self.stdscr.getmaxyx()
-            if key in self.disabled_keys: continue
-            clear_screen=True
-
-            ## Refresh data asyncronously.
-            if self.refreshing_data:
-                self.logger.debug(f"Data refresh check")
-                with self.data_lock:
-                    if self.data_ready:
-                        self.logger.debug(f"Data ready after refresh")
-                        self.initialise_variables()
-
-                        initial_time = time.time()
-
-                        self.draw_screen(self.indexed_items, self.highlights, clear=False)
-
-                        self.refreshing_data = False
-                        self.data_ready = False
-
-            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.refresh()
-                if self.get_new_data and self.refresh_function:
-                    self.refreshing_data = True
-
-                    t = threading.Thread(target=self.fetch_data)
-                    t.start()
-                else:
-                    function_data = self.get_function_data()
-                    return [], "refresh", function_data
-
-            # Refresh data synchronously
-            # if 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.stdscr.addstr(0,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.initialise_variables(get_data=True)
-            #
-            #         initial_time = time.time()
-            #         self.draw_screen(self.indexed_items, self.highlights, clear=False)
-            #     else:
-            #
-            #         function_data = self.get_function_data()
-            #         return [], "refresh", function_data
-
-            if self.footer_string_auto_refresh and ((time.time() - initial_time_footer) > self.footer_timer):
-                self.logger.debug(f"footer_string_auto_refresh")
-                self.footer_string = self.footer_string_refresh_function()
-                initial_time_footer = time.time()
-                self.draw_screen(self.indexed_items, self.highlights)
-
-            if self.check_key("help", key, self.keys_dict):
-                self.logger.info(f"key_function help")
-                self.stdscr.clear()
-                self.stdscr.refresh()
-                help_data = {
-                    # "items": help_lines,
-                    "items": build_help_rows(self.keys_dict),
-                    "title": f"{self.title} Help",
-                    "colours_start": self.help_colours_start,
-                    "colours": help_colours,
-                    "show_footer": True,
-                    "max_selected": 1,
-                    "keys_dict": help_keys,
-                    "disabled_keys": [ord('?'), ord('v'), ord('V'), ord('m'), ord('M'), ord('l'), curses.KEY_ENTER, ord('\n')],
-                    "highlight_full_row": True,
-                    "top_gap": 0,
-                    "paginate": self.paginate,
-                    "centre_in_terminal": True,
-                    "centre_in_terminal_vertical": True,
-                    "hidden_columns": [],
-                    "reset_colours": False,
-
-                }
-                OptionPicker = Picker(self.stdscr, **help_data)
-                s, o, f = OptionPicker.run()
-
-            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
-            elif self.check_key("full_exit", key, self.keys_dict):
-                close_curses(self.stdscr)
-                exit()
-
-            elif self.check_key("settings_input", key, self.keys_dict):
-                self.logger.info(f"Settings input")
-                usrtxt = f"{self.user_settings.strip()} " if self.user_settings else ""
-                field_end_f = lambda: self.stdscr.getmaxyx()[1]-38 if self.show_footer else lambda: self.stdscr.getmaxyx()[1]-3
-                if self.show_footer and self.footer.height >= 2: field_end_f = lambda: self.stdscr.getmaxyx()[1]-38
-                else: field_end_f = lambda: self.stdscr.getmaxyx()[1]-3
-                self.set_registers()
-                usrtxt, return_val = input_field(
-                    self.stdscr,
-                    usrtxt=usrtxt,
-                    field_prefix=" Settings: ",
-                    x=lambda:2,
-                    y=lambda: self.stdscr.getmaxyx()[0]-1,
-                    max_length=field_end_f,
-                    registers=self.registers,
-                    refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights),
-                    history=self.history_settings,
-                    path_auto_complete=True,
-                    formula_auto_complete=False,
-                    function_auto_complete=False,
-                    word_auto_complete=True,
-                    auto_complete_words=["ft", "ct", "cv"]
-                )
-                if return_val:
-                    self.user_settings = usrtxt
-                    self.apply_settings()
-                    self.history_settings.append(usrtxt)
-                    self.user_settings = ""
-            elif self.check_key("toggle_footer", key, self.keys_dict):
-                self.logger.info(f"toggle footer")
-                self.user_settings = "footer"
-                self.apply_settings()
-
-            elif self.check_key("settings_options", key, self.keys_dict):
-                options = []
-                if len(self.items) > 0:
-                    options += [["cv", "Centre rows vertically"]]
-                    options += [["pc", "Pin cursor to row number when data refreshes"]]
-                    options += [["ct", "Centre column-set in terminal"]]
-                    options += [["cc", "Centre values in cells"]]
-                    options += [["!r", "Toggle auto-refresh"]]
-                    options += [["th", "Cycle between themes. (accepts th#)"]]
-                    options += [["nohl", "Toggle highlights"]]
-                    options += [["footer", "Toggle footer"]]
-                    options += [["header", "Toggle header"]]
-                    options += [["rh", "Toggle row header"]]
-                    options += [["modes", "Toggle modes"]]
-                    options += [["ft", "Cycle through footer styles (accepts ft#)"]]
-                    options += [["unicode", "Toggle b/w using len and wcwidth to calculate char width."]]
-                    options += [[f"s{i}", f"Select col. {i}"] for i in range(len(self.items[0]))]
-                    options += [[f"!{i}", f"Toggle col. {i}"] for i in range(len(self.items[0]))]
-                    options += [["ara", "Add empty row after cursor."]]
-                    options += [["arb", "Add empty row before the cursor."]]
-                    options += [["aca", "Add empty column after the selected column."]]
-                    options += [["acb", "Add empty column before the selected column."]]
-
-
-                settings_options_header = ["Key", "Setting"]
-
-                s, o, f = self.choose_option(self.stdscr, options=options, title="Settings", header=settings_options_header)
-                if s:
-                    self.user_settings = " ".join([x[0] for x in s.values()])
-                    self.apply_settings()
-
-            elif self.check_key("redo", key, self.keys_dict):
-                self.redo()
-            # elif self.check_key("move_column_left", key, self.keys_dict):
-            #     tmp1 = self.column_indices[self.selected_column]
-            #     tmp2 = self.column_indices[(self.selected_column-1)%len(self.column_indices)]
-            #     self.column_indices[self.selected_column] = tmp2
-            #     self.column_indices[(self.selected_column-1)%(len(self.column_indices))] = tmp1
-            #     self.selected_column = (self.selected_column-1)%len(self.column_indices)
-            #     # self.notification(self.stdscr, f"{str(self.column_indices)}, {tmp1}, {tmp2}")
-            #     self.initialise_variables()
-            #     self.column_widths = get_column_widths([v[1] for v in self.indexed_items], header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w)
-            #     self.draw_screen(self.indexed_items, self.highlights)
-            #     # self.move_column(direction=-1)
-            #
-            # elif self.check_key("move_column_right", key, self.keys_dict):
-            #     tmp1 = self.column_indices[self.selected_column]
-            #     tmp2 = self.column_indices[(self.selected_column+1)%len(self.column_indices)]
-            #     self.column_indices[self.selected_column] = tmp2
-            #     self.column_indices[(self.selected_column+1)%(len(self.column_indices))] = tmp1
-            #     self.selected_column = (self.selected_column+1)%len(self.column_indices)
-            #     self.initialise_variables()
-            #     self.draw_screen(self.indexed_items, self.highlights)
-            #     # self.move_column(direction=1)
-
-            elif self.check_key("cursor_down", key, self.keys_dict):
-                page_turned = self.cursor_down()
-                if not page_turned: clear_screen = False
-            elif self.check_key("half_page_down", key, self.keys_dict):
-                self.cursor_down(count=self.items_per_page//2)
-                clear_screen = True
-            elif self.check_key("five_down", key, self.keys_dict):
-                clear_screen = False
-                self.cursor_down(count=5)
-                clear_screen = True
-            elif self.check_key("cursor_up", key, self.keys_dict):
-                page_turned = self.cursor_up()
-                if not page_turned: clear_screen = False
-            elif self.check_key("five_up", key, self.keys_dict):
-                # if self.cursor_up(count=5): clear_screen = True
-                self.cursor_up(count=5)
-                clear_screen = True
-            elif self.check_key("half_page_up", key, self.keys_dict):
-                self.cursor_up(count=self.items_per_page//2)
-                clear_screen = True
-
-            elif self.check_key("toggle_select", key, self.keys_dict):
-                if len(self.indexed_items) > 0:
-                    item_index = self.indexed_items[self.cursor_pos][0]
-                    cell_index = (self.indexed_items[self.cursor_pos][0], self.selected_column)
-                    row, col = cell_index
-                    selected_count = sum(self.selections.values())
-                    if self.max_selected == -1 or selected_count >= self.max_selected:
-                        self.toggle_item(item_index)
-
-                        self.cell_selections[cell_index] = not self.cell_selections[cell_index]
-                        ## Set self.selected_cells_by_row
-                        # If any cells in the current row are selected
-                        if row in self.selected_cells_by_row:
-                            # If the current cell is selected then remove it
-                            if col in self.selected_cells_by_row[row]:
-                                # If the current cell is the only cell in the row that is selected then remove the row from the dict
-                                if len(self.selected_cells_by_row[row]) == 1:
-
-                                    del self.selected_cells_by_row[row]
-                                # else remove only the index of the current cell
-                                else:
-                                    self.selected_cells_by_row[row].remove(col)
-                            # If there are cells in the row that are selected then append the current cell to the row
-                            else:
-                                self.selected_cells_by_row[row].append(col)
-                        # Add the a list containing only the current column
-                        else:
-                            self.selected_cells_by_row[row] = [col]
-
-                self.cursor_down()
-            elif self.check_key("select_all", key, self.keys_dict):  # Select all (m or ctrl-a)
-                self.select_all()
-
-            elif self.check_key("select_none", key, self.keys_dict):  # Deselect all (M or ctrl-r)
-                self.deselect_all()
-
-            elif self.check_key("cursor_top", key, self.keys_dict):
-                new_pos = 0
-                while True:
-                    if new_pos in self.unselectable_indices: new_pos+=1
-                    else: break
-                if new_pos < len(self.indexed_items):
-                    self.cursor_pos = new_pos
-
-            elif self.check_key("cursor_bottom", key, self.keys_dict):
-                new_pos = len(self.indexed_items)-1
-                while True:
-                    if new_pos in self.unselectable_indices: new_pos-=1
-                    else: break
-                if new_pos < len(self.items) and new_pos >= 0:
-                    self.cursor_pos = new_pos
-
-            elif self.check_key("enter", key, self.keys_dict):
-                self.logger.info(f"key_function enter")
-                # Print the selected indices if any, otherwise print the current index
-                if self.is_selecting or self.is_deselecting: self.handle_visual_selection()
-                if len(self.items) == 0:
-                    function_data = self.get_function_data()
-                    function_data["last_key"] = key
-                    return [], "", function_data
-                selected_indices = get_selected_indices(self.selections)
-                if not selected_indices and len(self.indexed_items):
-                    selected_indices = [self.indexed_items[self.cursor_pos][0]]
-                
-                options_sufficient = True
-                usrtxt = self.user_opts
-                for index in selected_indices:
-                    if self.require_option[index]:
-                        if self.option_functions[index] != None:
-                            options_sufficient, usrtxt = self.option_functions[index](
-                                stdscr=self.stdscr,
-                                refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights)
-                            )
-                        else:
-                            self.set_registers()
-                            options_sufficient, usrtxt = default_option_input(
-                                self.stdscr,
-                                starting_value=self.user_opts,
-                                registers = self.registers
-                            )
-
-                if options_sufficient:
-                    self.user_opts = usrtxt
-                    self.stdscr.clear()
-                    self.stdscr.refresh()
-                    function_data = self.get_function_data()
-                    function_data["last_key"] = key
-                    return selected_indices, usrtxt, function_data
-            elif self.check_key("page_down", key, self.keys_dict):  # Next page
-                self.cursor_pos = min(len(self.indexed_items) - 1, self.cursor_pos+self.items_per_page)
-
-            elif self.check_key("page_up", key, self.keys_dict):
-                self.cursor_pos = max(0, self.cursor_pos-self.items_per_page)
-
-            elif self.check_key("redraw_screen", key, self.keys_dict):
-                self.logger.info(f"key_function redraw_screen")
-                self.stdscr.clear()
-                self.stdscr.refresh()
-                restrict_curses(self.stdscr)
-                unrestrict_curses(self.stdscr)
-                self.stdscr.clear()
-                self.stdscr.refresh()
-
-                self.draw_screen(self.indexed_items, self.highlights)
-
-            elif self.check_key("cycle_sort_method", key, self.keys_dict):
-                if self.sort_column == self.selected_column:
-                    self.columns_sort_method[self.sort_column] = (self.columns_sort_method[self.sort_column]+1) % len(self.SORT_METHODS)
-                else:
-                    self.sort_column = self.selected_column
-                if len(self.indexed_items) > 0:
-                    current_index = 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 self.items based on new column
-                    self.cursor_pos = [row[0] for row in self.indexed_items].index(current_index)
-
-                self.logger.info(f"key_function cycle_sort_method. (sort_column, sort_method) = ({self.sort_column}, {self.columns_sort_method[self.sort_column]})")
-            elif self.check_key("cycle_sort_method_reverse", key, self.keys_dict):  # Cycle sort method
-                old_sort_column = self.sort_column
-                self.sort_column = self.selected_column
-                self.columns_sort_method[self.sort_column] = (self.columns_sort_method[self.sort_column]-1) % len(self.SORT_METHODS)
-                if len(self.indexed_items) > 0:
-                    current_index = 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 self.items based on new column
-                    self.cursor_pos = [row[0] for row in self.indexed_items].index(current_index)
-                self.logger.info(f"key_function cycle_sort_method. (sort_column, sort_method) = ({self.sort_column}, {self.columns_sort_method[self.sort_column]})")
-
-            elif self.check_key("cycle_sort_order", key, self.keys_dict):  # Toggle sort order
-                self.sort_reverse[self.sort_column] = not self.sort_reverse[self.sort_column]
-                if len(self.indexed_items) > 0:
-                    current_index = 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 self.items based on new column
-                    self.cursor_pos = [row[0] for row in self.indexed_items].index(current_index)
-                self.logger.info(f"key_function cycle_sort_order. (sort_column, sort_method, sort_reverse) = ({self.sort_column}, {self.columns_sort_method[self.sort_column]}, {self.sort_reverse[self.sort_column]})")
-            elif self.check_key("col_select", key, self.keys_dict):
-                col_index = key - ord('0')
-                self.logger.info(f"key_function col_select {col_index}")
-                if 0 <= col_index < len(self.items[0]):
-                    self.sort_column = col_index
-                    if len(self.indexed_items) > 0:
-                        current_index = 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 self.items based on new column
-                        self.cursor_pos = [row[0] for row in self.indexed_items].index(current_index)
-            elif self.check_key("col_select_next", key, self.keys_dict):
-                if len(self.items) > 0 and len(self.items[0]) > 0:
-                    col_index = (self.selected_column +1) % (len(self.items[0]))
-                    self.selected_column = col_index
-                # Flash when we loop back to the first column
-                # if self.selected_column == 0:
-                #     curses.flash()
-                self.logger.info(f"key_function col_select_next {self.selected_column}")
-
-
-                ## 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)
-                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
-                # 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
-                # Otherwise right-justify the cell
-                else:
-                    self.leftmost_char = end_of_cell - display_width
-
-                self.leftmost_char = max(0, min(column_set_width - display_width + 5, self.leftmost_char))
-
-            elif self.check_key("col_select_prev", key, self.keys_dict):
-                if len(self.items) > 0 and len(self.items[0]) > 0:
-                    col_index = (self.selected_column -1) % (len(self.items[0]))
-                    self.selected_column = col_index
-
-                self.logger.info(f"key_function col_select_prev {self.selected_column}")
-                # Flash when we loop back to the last column
-                # if self.selected_column == len(self.column_widths)-1:
-                #     curses.flash()
-
-                ## 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)
-                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
-
-                # 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:
-                    pass
-                # Otherwise left-justify the cell
-                else:
-                    self.leftmost_char = start_of_cell
-
-                self.leftmost_char = max(0, min(column_set_width - display_width + 5, self.leftmost_char))
-
-            elif self.check_key("scroll_right", key, self.keys_dict):
-                self.logger.info(f"key_function scroll_right")
-                if len(self.indexed_items):
-                    row_width = sum(self.column_widths) + len(self.separator)*(len(self.column_widths)-1)
-                    if row_width-self.leftmost_char >= w-self.startx:
-                        self.leftmost_char = self.leftmost_char+5
-
-            elif self.check_key("scroll_left", key, self.keys_dict):
-                self.logger.info(f"key_function scroll_left")
-                self.leftmost_char = max(self.leftmost_char-5, 0)
-
-            elif self.check_key("scroll_far_left", key, self.keys_dict):
-                self.logger.info(f"key_function scroll_far_left")
-                self.leftmost_char = 0
-                self.selected_column = 0
-            
-            elif self.check_key("scroll_far_right", key, self.keys_dict):
-                self.logger.info(f"key_function scroll_far_right")
-                longest_row_str_len = 0
-                rows = self.get_visible_rows()
-                for i in range(len(rows)):
-                    item = rows[i]
-                    row_str = format_row(item, self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols, self.unicode_char_width)
-                    if len(row_str) > longest_row_str_len: longest_row_str_len=len(row_str)
-                # for i in range(len(self.indexed_items)):
-                #     item = self.indexed_items[i]
-                #     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)
-                if len(self.items):
-                    self.selected_column = len(self.items[0])-1
-
-            elif self.check_key("add_column_before", key, self.keys_dict):
-                self.logger.info(f"key_function add_column_before")
-                # self.add_column_before()
-                self.insert_column(self.selected_column)
-
-            elif self.check_key("add_column_after", key, self.keys_dict):
-                self.logger.info(f"key_function add_column_after")
-                # self.add_column_after()
-                self.insert_column(self.selected_column+1)
-
-            elif self.check_key("add_row_before", key, self.keys_dict):
-                self.logger.info(f"key_function add_row_before")
-                # self.add_row_before()
-                self.insert_row(self.cursor_pos)
-
-            elif self.check_key("add_row_after", key, self.keys_dict):
-                self.logger.info(f"key_function add_row_after")
-                # self.add_row_after()
-                self.insert_row(self.cursor_pos+1)
-
-            elif self.check_key("col_hide", key, self.keys_dict):
-                self.logger.info(f"key_function col_hide")
-                d = {'!': 0, '@': 1, '#': 2, '$': 3, '%': 4, '^': 5, '&': 6, '*': 7, '(': 8, ')': 9}
-                d = {s:i for i,s in enumerate(")!@#$%^&*(")}
-                col_index = d[chr(key)]
-                self.toggle_column_visibility(col_index)
-            elif self.check_key("copy", key, self.keys_dict):
-                self.copy_dialogue()
-            elif self.check_key("paste", key, self.keys_dict):
-                self.paste_dialogue()
-            elif self.check_key("save", key, self.keys_dict):
-                self.save_dialog()
-            elif self.check_key("load", key, self.keys_dict):
-                self.load_dialog()
-
-            elif self.check_key("delete", key, self.keys_dict):  # Delete key
-                self.delete_entries()
-
-            elif self.check_key("delete_column", key, self.keys_dict):  # Delete key
-                self.logger.info(f"key_function delete_column")
-                row_len = 1
-                if self.header: row_len = len(self.header)
-                elif len(self.items): row_len  = len(self.items[0])
-                if row_len > 1:
-                    self.items = [row[:self.selected_column] + row[self.selected_column+1:] for row in self.items]
-                    self.header = self.header[:self.selected_column] + self.header[self.selected_column+1:]
-                    self.editable_columns = self.editable_columns[:self.selected_column] + self.editable_columns[self.selected_column+1:]
-                    self.selected_column = min(self.selected_column, row_len-2)
-                elif row_len == 1:
-                    self.items = [[""] for _ in range(len(self.items))]
-                    self.header = [""] if self.header else []
-                    self.editable_columns = []
-                    self.selected_column = min(self.selected_column, row_len-2)
-                self.initialise_variables()
-
-
-
-
-            # elif self.check_key("increase_lines_per_page", key, self.keys_dict):
-            #     self.items_per_page += 1
-            # elif self.check_key("decrease_lines_per_page", key, self.keys_dict):
-            #     if self.items_per_page > 1:
-            #         self.items_per_page -= 1
-
-            elif self.check_key("decrease_column_width", key, self.keys_dict):
-                self.logger.info(f"key_function decrease_column_width")
-                if self.max_column_width > 10:
-                    self.max_column_width -= 10
-                    # 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=2)
-            elif self.check_key("increase_column_width", key, self.keys_dict):
-                self.logger.info(f"key_function increase_column_width")
-                if self.max_column_width < 1000:
-                    self.max_column_width += 10
-                    # 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)
-            elif self.check_key("visual_selection_toggle", key, self.keys_dict):
-                self.logger.info(f"key_function visual_selection_toggle")
-                self.handle_visual_selection()
-
-            elif self.check_key("visual_deselection_toggle", key, self.keys_dict):
-                self.logger.info(f"key_function visual_deselection_toggle")
-                self.handle_visual_selection(selecting=False)
-
-            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)
-
-
-
-            elif self.check_key("filter_input", key, self.keys_dict):
-                self.logger.info(f"key_function filter_input")
-                usrtxt = f"{self.filter_query} " if self.filter_query else ""
-                field_end_f = lambda: self.stdscr.getmaxyx()[1]-38 if self.show_footer else lambda: self.stdscr.getmaxyx()[1]-3
-                if self.show_footer and self.footer.height >= 2: field_end_f = lambda: self.stdscr.getmaxyx()[1]-38
-                else: field_end_f = lambda: self.stdscr.getmaxyx()[1]-3
-                self.set_registers()
-                words = self.get_word_list()
-                usrtxt, return_val = input_field(
-                    self.stdscr,
-                    usrtxt=usrtxt,
-                    field_prefix=" Filter: ",
-                    x=lambda:2,
-                    y=lambda: self.stdscr.getmaxyx()[0]-2,
-                    # max_length=field_end,
-                    max_length=field_end_f,
-                    registers=self.registers,
-                    refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights),
-                    history=self.history_filter_and_search,
-                    path_auto_complete=True,
-                    formula_auto_complete=False,
-                    function_auto_complete=False,
-                    word_auto_complete=True,
-                    auto_complete_words=words,
-                )
-                if return_val:
-                    self.filter_query = usrtxt
-                    self.history_filter_and_search.append(usrtxt)
-
-                    # If the current mode filter has been changed then go back to the first mode
-                    if self.modes and "filter" in self.modes[self.mode_index] and self.modes[self.mode_index]["filter"] not in self.filter_query:
-                        self.mode_index = 0
-                    # elif "filter" in modes[mode_index] and modes[mode_index]["filter"] in filter_query:
-                    #     filter_query.split(modes[mode_index]["filter"])
-
-                    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
-                    if self.columns_sort_method[self.selected_column] != 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
-
-            elif self.check_key("search_input", key, self.keys_dict):
-                self.logger.info(f"key_function search_input")
-                usrtxt = f"{self.search_query} " if self.search_query else ""
-                field_end_f = lambda: self.stdscr.getmaxyx()[1]-38 if self.show_footer else lambda: self.stdscr.getmaxyx()[1]-3
-                if self.show_footer and self.footer.height >= 3: field_end_f = lambda: self.stdscr.getmaxyx()[1]-38
-                else: field_end_f = lambda: self.stdscr.getmaxyx()[1]-3
-                self.set_registers()
-                words = self.get_word_list()
-                usrtxt, return_val = input_field(
-                    self.stdscr,
-                    usrtxt=usrtxt,
-                    field_prefix=" Search: ",
-                    x=lambda:2,
-                    y=lambda: self.stdscr.getmaxyx()[0]-3,
-                    max_length=field_end_f,
-                    registers=self.registers,
-                    refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights),
-                    history=self.history_filter_and_search,
-                    path_auto_complete=True,
-                    formula_auto_complete=False,
-                    function_auto_complete=False,
-                    word_auto_complete=True,
-                    auto_complete_words=words,
-                )
-                if return_val:
-                    self.search_query = usrtxt
-                    self.history_filter_and_search.append(usrtxt)
-                    return_val, tmp_cursor, tmp_index, tmp_count, tmp_highlights = search(
-                        query=self.search_query,
-                        indexed_items=self.indexed_items,
-                        highlights=self.highlights,
-                        cursor_pos=self.cursor_pos,
-                        unselectable_indices=self.unselectable_indices,
-                    )
-                    if return_val:
-                        self.cursor_pos, self.search_index, self.search_count, self.highlights = tmp_cursor, tmp_index, tmp_count, tmp_highlights
-                    else:
-                        self.search_index, self.search_count = 0, 0
-
-            elif self.check_key("continue_search_forward", key, self.keys_dict):
-                self.logger.info(f"key_function continue_search_forward")
-                return_val, tmp_cursor, tmp_index, tmp_count, tmp_highlights = search(
-                    query=self.search_query,
-                    indexed_items=self.indexed_items,
-                    highlights=self.highlights,
-                    cursor_pos=self.cursor_pos,
-                    unselectable_indices=self.unselectable_indices,
-                    continue_search=True,
-                )
-                if return_val:
-                    self.cursor_pos, self.search_index, self.search_count, self.highlights = tmp_cursor, tmp_index, tmp_count, tmp_highlights
-            elif self.check_key("continue_search_backward", key, self.keys_dict):
-                self.logger.info(f"key_function continue_search_backward")
-                return_val, tmp_cursor, tmp_index, tmp_count, tmp_highlights = search(
-                    query=self.search_query,
-                    indexed_items=self.indexed_items,
-                    highlights=self.highlights,
-                    cursor_pos=self.cursor_pos,
-                    unselectable_indices=self.unselectable_indices,
-                    continue_search=True,
-                    reverse=True,
-                )
-                if return_val:
-                    self.cursor_pos, self.search_index, self.search_count, self.highlights = tmp_cursor, tmp_index, tmp_count, tmp_highlights
-            elif self.check_key("cancel", key, self.keys_dict):  # ESC key
-                # order of escapes:
-                # 1. selecting/deslecting
-                # 2. search
-                # 3. filter
-                # 4. if self.cancel_is_back (e.g., notification) then we exit
-                # 4. selecting
-
-                # Cancel visual de/selection
-                if self.is_selecting or self.is_deselecting:
-                    self.start_selection = -1
-                    self.end_selection = -1
-                    self.is_selecting = False
-                    self.is_deselecting = False
-                # Cancel search
-                elif self.search_query:
-                    self.search_query = ""
-                    self.highlights = [highlight for highlight in self.highlights if "type" not in highlight or highlight["type"] != "search" ]
-                # Remove filter
-                elif self.filter_query:
-                    if self.modes and "filter" in self.modes[self.mode_index] and self.modes[self.mode_index]["filter"] in self.filter_query and self.filter_query.strip() != self.modes[self.mode_index]["filter"]:
-                        self.filter_query = self.modes[self.mode_index]["filter"]
-                    # elif "filter" in modes[mode_index]:
-                    else:
-                        self.filter_query = ""
-                        self.mode_index = 0
-                    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
-                    if self.columns_sort_method[self.selected_column] != 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
-                elif self.cancel_is_back:
-                    function_data = self.get_function_data()
-                    function_data["last_key"] = key
-                    return [], "escape", function_data
-
-
-                # else:
-                #     self.search_query = ""
-                #     self.mode_index = 0
-                #     self.highlights = [highlight for highlight in self.highlights if "type" not in highlight or highlight["type"] != "search" ]
-                #     continue
-
-            elif self.check_key("opts_input", key, self.keys_dict):
-                self.logger.info(f"key_function opts_input")
-                usrtxt = f"{self.user_opts} " if self.user_opts else ""
-                field_end_f = lambda: self.stdscr.getmaxyx()[1]-38 if self.show_footer else lambda: self.stdscr.getmaxyx()[1]-3
-                if self.show_footer and self.footer.height >= 1: field_end_f = lambda: self.stdscr.getmaxyx()[1]-38
-                else: field_end_f = lambda: self.stdscr.getmaxyx()[1]-3
-                self.set_registers()
-                words = self.get_word_list()
-                usrtxt, return_val = input_field(
-                    self.stdscr,
-                    usrtxt=usrtxt,
-                    field_prefix=" Opts: ",
-                    x=lambda:2,
-                    y=lambda: self.stdscr.getmaxyx()[0]-1,
-                    max_length=field_end_f,
-                    registers=self.registers,
-                    refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights),
-                    history=self.history_opts,
-                    path_auto_complete=True,
-                    formula_auto_complete=False,
-                    function_auto_complete=True,
-                    word_auto_complete=True,
-                    auto_complete_words=words,
-                )
-                if return_val:
-                    self.user_opts = usrtxt
-                    self.history_opts.append(usrtxt)
-            elif self.check_key("opts_select", key, self.keys_dict):
-                self.logger.info(f"key_function opts_select")
-                s, o, f = self.choose_option(self.stdscr, self.options_list)
-                if self.user_opts.strip(): self.user_opts += " "
-                self.user_opts += " ".join([x for x in s.values()])
-            elif self.check_key("notification_toggle", key, self.keys_dict):
-                self.logger.info(f"key_function notification_toggle")
-                self.notification(self.stdscr, colours_end=self.colours_end)
-
-            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
-            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
-            elif self.check_key("pipe_input", key, self.keys_dict):
-                self.logger.info(f"key_function pipe_input")
-                # usrtxt = "xargs -d '\n' -I{}  "
-                usrtxt = "xargs "
-                field_end_f = lambda: self.stdscr.getmaxyx()[1]-38 if self.show_footer else lambda: self.stdscr.getmaxyx()[1]-3
-                if self.show_footer and self.footer.height >= 2: field_end_f = lambda: self.stdscr.getmaxyx()[1]-38
-                else: field_end_f = lambda: self.stdscr.getmaxyx()[1]-3
-                self.set_registers()
-                
-                # Get list of available shell commands
-                try:
-                    # result = subprocess.run(['compgen', '-c'], capture_output=True, text=True, check=True)
-                    # shell_commands = result.stdout.splitlines()
-                    result = subprocess.run(['ls', '/usr/bin'], capture_output=True, text=True, check=True)
-                    shell_commands = result.stdout.splitlines()
-                except:
-                    shell_commands = []
-                usrtxt, return_val = input_field(
-                    self.stdscr,
-                    usrtxt=usrtxt,
-                    field_prefix=" Command: ",
-                    x=lambda:2,
-                    y=lambda: self.stdscr.getmaxyx()[0]-2,
-                    literal=True,
-                    max_length=field_end_f,
-                    registers=self.registers,
-                    refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights),
-                    history=self.history_pipes,
-                    path_auto_complete=True,
-                    formula_auto_complete=False,
-                    function_auto_complete=False,
-                    word_auto_complete=True,
-                    auto_complete_words=shell_commands,
-                )
-
-                if return_val:
-                    selected_indices = get_selected_indices(self.selections)
-                    self.history_pipes.append(usrtxt)
-                    if not selected_indices:
-                        selected_indices = [self.indexed_items[self.cursor_pos][0]]
-
-                    full_values = [format_row_full(self.items[i], self.hidden_columns) for i in selected_indices]  # Use format_row_full for full data
-                    full_values = [self.items[i][self.selected_column] for i in selected_indices]
-                    if full_values:
-                        command = usrtxt.split()
-                        # command = ['xargs', '-d' , '"\n"' '-I', '{}', 'mpv', '{}']
-                        # command = ['xargs', '-d' , '"\n"' '-I', '{}', 'mpv', '{}']
-                        # command = "xargs -d '\n' -I{} mpv {}"
-
-                        try:
-                            process = subprocess.Popen(command, stdin=subprocess.PIPE, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-
-                            if process.stdin != None:
-                                for value in full_values:
-                                    process.stdin.write((repr(value) + '\n').encode())
-
-                                process.stdin.close()
-
-                                self.notification(self.stdscr, message=f"{len(full_values)} strings piped to {repr(usrtxt)}")
-                        except Exception as e:
-                            self.notification(self.stdscr, message=f"{e}")
-
-
-            elif self.check_key("open", key, self.keys_dict):
-                self.logger.info(f"key_function open")
-                selected_indices = get_selected_indices(self.selections)
-                if not selected_indices:
-                    selected_indices = [self.indexed_items[self.cursor_pos][0]]
-
-                file_names = [self.items[i][self.selected_column] for i in selected_indices]
-                response = openFiles(file_names)
-                if response:
-                    self.notification(self.stdscr, message=response)
-
-
-            elif self.check_key("reset_opts", key, self.keys_dict):
-                self.logger.info(f"key_function reset_opts")
-                self.user_opts = ""
-
-            elif self.check_key("edit", key, self.keys_dict):
-                self.logger.info(f"key_function edit")
-                if len(self.indexed_items) > 0 and self.selected_column >=0 and self.editable_columns[self.selected_column]:
-                    current_val = self.indexed_items[self.cursor_pos][1][self.selected_column]
-                    usrtxt = f"{current_val}"
-                    field_end_f = lambda: self.stdscr.getmaxyx()[1]-38 if self.show_footer else lambda: self.stdscr.getmaxyx()[1]-3
-                    if self.show_footer and self.footer.height >= 2: field_end_f = lambda: self.stdscr.getmaxyx()[1]-38
-                    else: field_end_f = lambda: self.stdscr.getmaxyx()[1]-3
-                    self.set_registers()
-                    words = self.get_word_list()
-                    usrtxt, return_val = input_field(
-                        self.stdscr,
-                        usrtxt=usrtxt,
-                        field_prefix=" Edit value: ",
-                        x=lambda:2,
-                        y=lambda: self.stdscr.getmaxyx()[0]-2,
-                        max_length=field_end_f,
-                        registers=self.registers,
-                        refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights),
-                        history = self.history_edits,
-                        path_auto_complete=True,
-                        formula_auto_complete=True,
-                        function_auto_complete=True,
-                        word_auto_complete=True,
-                        auto_complete_words=words,
-                    )
-                    if return_val:
-                        if usrtxt.startswith("```"):
-                            usrtxt = str(eval(usrtxt[3:]))
-                        self.indexed_items[self.cursor_pos][1][self.selected_column] = usrtxt
-                        self.history_edits.append(usrtxt)
-
-            elif self.check_key("edit_picker", key, self.keys_dict):
-                self.logger.info(f"key_function edit_picker")
-                if len(self.indexed_items) > 0 and self.selected_column >=0 and self.editable_columns[self.selected_column]:
-                    current_val = self.indexed_items[self.cursor_pos][1][self.selected_column]
-                    usrtxt = f"{current_val}"
-                    field_end_f = lambda: self.stdscr.getmaxyx()[1]-38 if self.show_footer else lambda: self.stdscr.getmaxyx()[1]-3
-                    if self.show_footer and self.footer.height >= 2: field_end_f = lambda: self.stdscr.getmaxyx()[1]-38
-                    else: field_end_f = lambda: self.stdscr.getmaxyx()[1]-3
-                    self.set_registers()
-                    words = self.get_word_list()
-                    usrtxt, return_val = input_field(
-                        self.stdscr,
-                        usrtxt=usrtxt,
-                        field_prefix=" Edit value: ",
-                        x=lambda:2,
-                        y=lambda: self.stdscr.getmaxyx()[0]-2,
-                        max_length=field_end_f,
-                        registers=self.registers,
-                        refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights),
-                        history = self.history_edits,
-                        path_auto_complete=True,
-                        formula_auto_complete=True,
-                        function_auto_complete=True,
-                        word_auto_complete=True,
-                        auto_complete_words=words,
-                    )
-                    if return_val:
-                        self.indexed_items[self.cursor_pos][1][self.selected_column] = usrtxt
-                        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
-                self.stdscr.clear()
-                restrict_curses(self.stdscr)
-                self.stdscr.clear()
-                os.system('cls' if os.name == 'nt' else 'clear')
-                globals()['self'] = self  # make the instance available in IPython namespace
-
-                from traitlets.config import Config
-                c = Config()
-                # Doesn't work; Config only works with start_ipython, not embed... but start_ipython causes errors
-                # c.InteractiveShellApp.exec_lines = [
-                #     '%clear'
-                # ]
-                msg = "The active Picker object has variable name self.\n"
-                msg += "\te.g., self.items will display the items in Picker"
-                IPython.embed(header=msg, config=c)
-
-                unrestrict_curses(self.stdscr)
-
-                self.stdscr.clear()
-                self.stdscr.refresh()
-                self.initialise_variables()
-
-
-            # The refresh symbol colour is not updated when the data is retrieved so remains white until a key is pressed.
-            # if key != -1:
-            #     self.draw_screen(self.indexed_items, self.highlights, clear=clear_screen)
-
-
-            self.draw_screen(self.indexed_items, self.highlights, clear=clear_screen)
-
-
-
-def set_colours(pick: int = 0, start: int = 0) -> Optional[int]:
-    """ Initialise curses colour pairs from dictionary. """
-    
-    global COLOURS_SET, notification_colours, help_colours
-    if COLOURS_SET: return None
-    if start == None: start = 0
-    
-
-    if curses.COLORS >= 255:
-        colours = get_colours(pick)
-        notification_colours = get_notification_colours(pick)
-        help_colours = get_help_colours(pick)
-        standard_colours_start, notification_colours_start, help_colours_start = 0, 50, 100
-    else:
-        colours = get_fallback_colours()
-        notification_colours = get_fallback_colours()
-        help_colours = get_fallback_colours()
-        standard_colours_start, help_colours_start, notification_colours_start = 0, 0, 0
-
-    if not colours: return 0
-
-    try:
-        start = standard_colours_start
-        curses.init_pair(start+1, colours['selected_fg'], colours['selected_bg'])
-        curses.init_pair(start+2, colours['unselected_fg'], colours['unselected_bg'])
-        curses.init_pair(start+3, colours['normal_fg'], colours['background'])
-        curses.init_pair(start+4, colours['header_fg'], colours['header_bg'])
-        curses.init_pair(start+5, colours['cursor_fg'], colours['cursor_bg'])
-        curses.init_pair(start+6, colours['normal_fg'], colours['background'])
-        curses.init_pair(start+7, colours['error_fg'], colours['error_bg'])
-        curses.init_pair(start+8, colours['complete_fg'], colours['complete_bg'])
-        curses.init_pair(start+9, colours['active_fg'], colours['active_bg'])
-        curses.init_pair(start+10, colours['search_fg'], colours['search_bg'])
-        curses.init_pair(start+11, colours['waiting_fg'], colours['waiting_bg'])
-        curses.init_pair(start+12, colours['paused_fg'], colours['paused_bg'])
-        curses.init_pair(start+13, colours['active_input_fg'], colours['active_input_bg'])
-        curses.init_pair(start+14, colours['modes_selected_fg'], colours['modes_selected_bg'])
-        curses.init_pair(start+15, colours['modes_unselected_fg'], colours['modes_unselected_bg'])
-        curses.init_pair(start+16, colours['title_fg'], colours['title_bg'])
-        curses.init_pair(start+17, colours['normal_fg'], colours['title_bar'])
-        curses.init_pair(start+18, colours['normal_fg'], colours['scroll_bar_bg'])
-        curses.init_pair(start+19, colours['selected_header_column_fg'], colours['selected_header_column_bg'])
-        curses.init_pair(start+20, colours['footer_fg'], colours['footer_bg'])
-        curses.init_pair(start+21, colours['refreshing_fg'], colours['refreshing_bg'])
-        curses.init_pair(start+22, colours['40pc_fg'], colours['40pc_bg'])
-        curses.init_pair(start+23, colours['refreshing_inactive_fg'], colours['refreshing_inactive_bg'])
-        curses.init_pair(start+24, colours['footer_string_fg'], colours['footer_string_bg'])
-        curses.init_pair(start+25, colours['selected_cell_fg'], colours['selected_cell_bg'])
-        curses.init_pair(start+26, colours['deselecting_cell_fg'], colours['deselecting_cell_bg'])
-
-
-        # notifications 50, infobox 100, help 150
-        # Notification colours
-        colours = notification_colours
-        start = notification_colours_start
-        curses.init_pair(start+1, colours['selected_fg'], colours['selected_bg'])
-        curses.init_pair(start+2, colours['unselected_fg'], colours['unselected_bg'])
-        curses.init_pair(start+3, colours['normal_fg'], colours['background'])
-        curses.init_pair(start+4, colours['header_fg'], colours['header_bg'])
-        curses.init_pair(start+5, colours['cursor_fg'], colours['cursor_bg'])
-        curses.init_pair(start+6, colours['normal_fg'], colours['background'])
-        curses.init_pair(start+7, colours['error_fg'], colours['error_bg'])
-        curses.init_pair(start+8, colours['complete_fg'], colours['complete_bg'])
-        curses.init_pair(start+9, colours['active_fg'], colours['active_bg'])
-        curses.init_pair(start+10, colours['search_fg'], colours['search_bg'])
-        curses.init_pair(start+11, colours['waiting_fg'], colours['waiting_bg'])
-        curses.init_pair(start+12, colours['paused_fg'], colours['paused_bg'])
-        curses.init_pair(start+13, colours['active_input_fg'], colours['active_input_bg'])
-        curses.init_pair(start+14, colours['modes_selected_fg'], colours['modes_selected_bg'])
-        curses.init_pair(start+15, colours['modes_unselected_fg'], colours['modes_unselected_bg'])
-        curses.init_pair(start+16, colours['title_fg'], colours['title_bg'])
-        curses.init_pair(start+17, colours['normal_fg'], colours['title_bar'])
-        curses.init_pair(start+18, colours['normal_fg'], colours['scroll_bar_bg'])
-        curses.init_pair(start+19, colours['selected_header_column_fg'], colours['selected_header_column_bg'])
-        curses.init_pair(start+20, colours['footer_fg'], colours['footer_bg'])
-        curses.init_pair(start+21, colours['refreshing_fg'], colours['refreshing_bg'])
-        curses.init_pair(start+22, colours['40pc_fg'], colours['40pc_bg'])
-        curses.init_pair(start+23, colours['refreshing_inactive_fg'], colours['refreshing_inactive_bg'])
-        curses.init_pair(start+24, colours['footer_string_fg'], colours['footer_string_bg'])
-        curses.init_pair(start+25, colours['selected_cell_fg'], colours['selected_cell_bg'])
-        curses.init_pair(start+26, colours['deselecting_cell_fg'], colours['deselecting_cell_bg'])
-
-        # Help
-        colours = help_colours
-        start = help_colours_start
-        curses.init_pair(start+1, colours['selected_fg'], colours['selected_bg'])
-        curses.init_pair(start+2, colours['unselected_fg'], colours['unselected_bg'])
-        curses.init_pair(start+3, colours['normal_fg'], colours['background'])
-        curses.init_pair(start+4, colours['header_fg'], colours['header_bg'])
-        curses.init_pair(start+5, colours['cursor_fg'], colours['cursor_bg'])
-        curses.init_pair(start+6, colours['normal_fg'], colours['background'])
-        curses.init_pair(start+7, colours['error_fg'], colours['error_bg'])
-        curses.init_pair(start+8, colours['complete_fg'], colours['complete_bg'])
-        curses.init_pair(start+9, colours['active_fg'], colours['active_bg'])
-        curses.init_pair(start+10, colours['search_fg'], colours['search_bg'])
-        curses.init_pair(start+11, colours['waiting_fg'], colours['waiting_bg'])
-        curses.init_pair(start+12, colours['paused_fg'], colours['paused_bg'])
-        curses.init_pair(start+13, colours['active_input_fg'], colours['active_input_bg'])
-        curses.init_pair(start+14, colours['modes_selected_fg'], colours['modes_selected_bg'])
-        curses.init_pair(start+15, colours['modes_unselected_fg'], colours['modes_unselected_bg'])
-        curses.init_pair(start+16, colours['title_fg'], colours['title_bg'])
-        curses.init_pair(start+17, colours['normal_fg'], colours['title_bar'])
-        curses.init_pair(start+18, colours['normal_fg'], colours['scroll_bar_bg'])
-        curses.init_pair(start+19, colours['selected_header_column_fg'], colours['selected_header_column_bg'])
-        curses.init_pair(start+20, colours['footer_fg'], colours['footer_bg'])
-        curses.init_pair(start+21, colours['refreshing_fg'], colours['refreshing_bg'])
-        curses.init_pair(start+22, colours['40pc_fg'], colours['40pc_bg'])
-        curses.init_pair(start+23, colours['refreshing_inactive_fg'], colours['refreshing_inactive_bg'])
-        curses.init_pair(start+24, colours['footer_string_fg'], colours['footer_string_bg'])
-        curses.init_pair(start+25, colours['selected_cell_fg'], colours['selected_cell_bg'])
-        curses.init_pair(start+26, colours['deselecting_cell_fg'], colours['deselecting_cell_bg'])
-    except:
-        pass
-    COLOURS_SET = True
-    return start+21
-
-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('--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')
-    parser.add_argument('--generate', '-g', type=str, help='Pass file to generate data for listpick Picker.')
-    parser.add_argument('-d', dest='delimiter', default='\t', help='Delimiter for rows in the table (default: tab)')
-    parser.add_argument('-t', dest='file_type', choices=['tsv', 'csv', 'json', 'xlsx', 'ods', 'pkl'], help='Type of file (tsv, csv, json, xlsx, ods)')
-    parser.add_argument('--debug', action="store_true", help="Enable debug log.")
-    parser.add_argument('--debug-verbose', action="store_true", help="Enable debug verbose log.")
-    args = parser.parse_args()
-
-
-    function_data = {
-        "items" : [],
-        "header": [],
-        "unselectable_indices" : [],
-        "colours": get_colours(0),
-        "top_gap": 0,
-        "max_column_width": 70,
-    }
-    
-    if args.file:
-        input_arg = args.file
-    elif args.stdin:
-        input_arg = '--stdin'
-    elif args.stdin2:
-        input_arg = '--stdin2'
-    # elif args.filename:
-    #     input_arg = args.filename
-
-    elif args.generate:
-        function_data["refresh_function"] = lambda : generate_picker_data(args.generate)
-        function_data["get_data_startup"] = True
-        function_data["get_new_data"] = True
-        return args, function_data
-    elif args.load:
-        function_data = load_state(args.load)
-        function_data["refresh_function"] = lambda : (load_state(args.load)["items"], load_state(args.load)["header"])
-        function_data["get_new_data"] = True
-        return args, function_data
-
-    else:
-        # print("Error: Please provide input file or use --stdin flag.")
-        print("No data provided. Loading empty Picker.")
-        return args, function_data
-        # sys.exit(1)
-    if args.debug:
-        function_data["debug"] = True
-        function_data["debug_level"] = 1
-
-    if args.debug_verbose:
-        function_data["debug"] = True
-        function_data["debug_level"] = 0
-    
-    if not args.file_type:
-        filetype = guess_file_type(input_arg)
-    else:
-        filetype = args.file_type
-    
-
-    items, header = table_to_list(input_arg, args.delimiter, filetype)
-    function_data["items"] = items
-    if header: function_data["header"] = header
-    return args, function_data
-
-def start_curses() -> curses.window:
-    """ Initialise curses and return curses window. """
-    stdscr = curses.initscr()
-    curses.start_color()
-    curses.use_default_colors() # For terminal theme-recolouring
-    curses.noecho()  # Turn off automatic echoing of keys to the screen
-    curses.cbreak()  # Interpret keystrokes immediately (without requiring Enter)
-    stdscr.keypad(True) # Ensures that arrow and function keys are received as one key by getch
-    curses.raw() # Disable control keys (ctrl-c, ctrl-s, ctrl-q, etc.)
-    curses.curs_set(False)
-
-    return stdscr
-
-def close_curses(stdscr: curses.window) -> None:
-    """ Close curses. """
-    stdscr.keypad(False)
-    curses.nocbreak()
-    curses.noraw()
-    curses.echo()
-    curses.endwin()
-
-def restrict_curses(stdscr: curses.window) -> None:
-    """ Restrict curses for normal input. Used when dropping to ipython. """
-    stdscr.keypad(False)
-    curses.nocbreak()
-    curses.noraw()
-    curses.curs_set(True)
-    curses.echo()
-
-def unrestrict_curses(stdscr: curses.window) -> None:
-    """ Unrestrict curses for terminal input. Used after dropping to ipython. """
-    curses.noecho()  # Turn off automatic echoing of keys to the screen
-    curses.cbreak()  # Interpret keystrokes immediately (without requiring Enter)
-    stdscr.keypad(True)
-    curses.raw() # Disable control keys (ctrl-c, ctrl-s, ctrl-q, etc.)
-    curses.curs_set(False)
-
-def main() -> None:
-    """ Main function when listpick is executed. Deals with command line arguments and starts a Picker. """
-    args, function_data = parse_arguments()
-
-    try:
-        if function_data["items"] == []:
-            function_data["items"] = test_items
-            function_data["highlights"] = test_highlights
-            function_data["header"] = test_header
-    except:
-        pass
-        
-    function_data["colour_theme_number"] = 3
-    function_data["modes"]  = [ 
-        {
-            'filter': '',
-            'sort': 0,
-            'name': 'All',
-        },
-        {
-            'filter': '--2 miss',
-            'name': 'miss',
-        },
-        {
-            'filter': '--2 mp4',
-            'name': 'mp4',
-        },
-    ]
-    highlights = [
-        {
-            "field": 1,
-            "match": "a",
-            "color": 8,
-        }
-    ]
-    function_data["cell_cursor"] = True
-    function_data["display_modes"] = True
-    function_data["centre_in_cols"] = True
-    function_data["show_row_header"] = True
-    function_data["keys_dict"] = picker_keys
-    function_data["id_column"] = -1
-    function_data["track_entries_upon_refresh"] = True
-    function_data["centre_in_terminal_vertical"] = True
-    function_data["highlight_full_row"] = True
-    function_data["pin_cursor"] = True
-    function_data["display_infobox"] = True
-    function_data["infobox_items"] = [["1"], ["2"], ["3"]]
-    function_data["infobox_title"] = "Title"
-    function_data["footer_string"] = "Title"
-    function_data["highlights"] = highlights
-    function_data["show_footer"] = False
-
-
-    # function_data["debug"] = True
-    # function_data["debug_level"] = 1
-    stdscr = start_curses()
-    # h, w = stdscr.getmaxyx()
-    # win = stdscr.derwin(h, w//2, 0, 0)
-    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)
-        app.set_function_data(function_data)
-        app.splash_screen("Listpick is loading your data...")
-        app.load_input_history("~/.config/listpick/cmdhist.json")
-        app.run()
-
-        app.save_input_history("~/.config/listpick/cmdhist.json")
-    except Exception as e:
-        print(e)
-
-    # Clean up
-    close_curses(stdscr)
-
-if __name__ == '__main__':
-    main()