listpick 0.1.4.0__py3-none-any.whl

list_picker/ui/list_picker_colours.py

@@ -0,0 +1,258 @@
+#!/bin/python
+import curses
+
+"""
+Define colour options for list_picker, help, and notification
+"""
+def get_theme_count() -> int:
+    col_list = []
+    i = 0
+    for i in range(100):
+        x = get_colours(i)
+        if x in col_list:
+            break
+        col_list.append(x)
+    return i
+
+
+def get_colours(pick:int=0) -> dict[str, int]:
+    """ Define colour options for list_picker. """
+    colours = [
+        ### Green header, green title, green modes, purple selected, blue cursor
+    {
+        'background': 232,
+        'normal_fg': 253,
+        'unselected_bg': 232,
+        'unselected_fg': 253,
+        'cursor_bg': 25,
+        'cursor_fg': 253,
+        'selected_bg': 135,
+        'selected_fg': 253,
+        'header_bg': 253,
+        'header_fg': 232,
+        'error_bg': 232,
+        'error_fg': curses.COLOR_RED,
+        'complete_bg': 232,
+        'complete_fg': 82,
+        'waiting_bg': 232,
+        'waiting_fg': curses.COLOR_YELLOW,
+        'active_bg': 232,
+        'active_fg': 33,
+        'paused_bg': 232,
+        'paused_fg': 244,
+        'search_bg': 162,
+        'search_fg': 253,
+        'active_input_bg': 253,
+        'active_input_fg': 28,
+        'modes_selected_bg': 28,
+        'modes_selected_fg': 253,
+        'modes_unselected_bg': 253,
+        'modes_unselected_fg': 232,
+        'title_bar': 28,
+        'title_bg': 28,
+        'title_fg': 253,
+        'scroll_bar_bg': 247,
+        'selected_header_column_bg': 247,
+        'selected_header_column_fg': 232,
+        'footer_bg': 28,
+        'footer_fg': 253,
+        'refreshing_bg': 28,
+        'refreshing_fg': 253,
+        'refreshing_inactive_bg': 28,
+        'refreshing_inactive_fg': 232,
+        '40pc_bg': 232,
+        '40pc_fg': 166,
+        'footer_string_bg': 28,
+        'footer_string_fg': 253,
+    },
+        ### Black and white
+    {
+        'background': 232,
+        'normal_fg': 253,
+        'unselected_bg': 232,
+        'unselected_fg': 253,
+        'cursor_bg': 253,
+        'cursor_fg': 232,
+        'selected_bg': 253,
+        'selected_fg': 232,
+        'header_bg': 253,
+        'header_fg': 232,
+        'error_bg': 232,
+        'error_fg': 253,
+        'complete_bg': 232,
+        'complete_fg': 253,
+        'waiting_bg': 232,
+        'waiting_fg': 253,
+        'active_bg': 232,
+        'active_fg': 253,
+        'paused_bg': 232,
+        'paused_fg': 253,
+        'search_bg': 253,
+        'search_fg': 232,
+        'active_input_bg': 232,
+        'active_input_fg': 253,
+        'modes_selected_bg': 253,
+        'modes_selected_fg': 232,
+        'modes_unselected_bg': 232,
+        'modes_unselected_fg': 253,
+        'title_bar': 232,
+        'title_bg': 253,
+        'title_fg': 232,
+        'scroll_bar_bg': 253,
+        'selected_header_column_bg': 232,
+        'selected_header_column_fg': 253,
+        'footer_bg': 253,
+        'footer_fg': 232,
+        'refreshing_bg': 253,
+        'refreshing_fg': 232,
+        'refreshing_inactive_bg': 232,
+        'refreshing_inactive_fg': 253,
+        '40pc_bg': 232,
+        '40pc_fg': 253,
+        'footer_string_bg': 253,
+        'footer_string_fg': 232,
+    },
+        ### Blue header, blue title, blue modes, purple selected, green cursor
+    {
+        'background': 232,
+        'normal_fg': 253,
+        'unselected_bg': 232,
+        'unselected_fg': 253,
+        'cursor_bg': 28,
+        'cursor_fg': 253,
+        'selected_bg': 135,
+        'selected_fg': 253,
+        'header_bg': 253,
+        'header_fg': 232,
+        'error_bg': 232,
+        'error_fg': curses.COLOR_RED,
+        'complete_bg': 232,
+        'complete_fg': 82,
+        'waiting_bg': 232,
+        'waiting_fg': curses.COLOR_YELLOW,
+        'active_bg': 232,
+        'active_fg': 33,
+        'paused_bg': 232,
+        'paused_fg': 244,
+        'search_bg': 162,
+        'search_fg': 253,
+        'active_input_bg': 253,
+        'active_input_fg': 25,
+        'modes_selected_bg': 25,
+        'modes_selected_fg': 253,
+        'modes_unselected_bg': 253,
+        'modes_unselected_fg': 232,
+        'title_bar': 25,
+        'title_bg': 25,
+        'title_fg': 253,
+        'scroll_bar_bg': 247,
+        'selected_header_column_bg': 247,
+        'selected_header_column_fg': 232,
+        'footer_bg': 25,
+        'footer_fg': 253,
+        'refreshing_bg': 25,
+        'refreshing_fg': 253,
+        'refreshing_inactive_bg': 25,
+        'refreshing_inactive_fg': 232,
+        '40pc_bg': 232,
+        '40pc_fg': 166,
+        'footer_string_bg': 25,
+        'footer_string_fg': 253,
+    },
+        ### Purple header, purple title, white modes, green selected, blue cursor
+    {
+        'background': 232,
+        'normal_fg': 253,
+        'unselected_bg': 232,
+        'unselected_fg': 253,
+        'cursor_bg': 57,
+        'cursor_fg': 253,
+        'selected_bg': 135,
+        'selected_fg': 253,
+        'header_bg': 253,
+        'header_fg': 232,
+        'error_bg': 232,
+        'error_fg': curses.COLOR_RED,
+        'complete_bg': 232,
+        'complete_fg': 82,
+        'waiting_bg': 232,
+        'waiting_fg': curses.COLOR_YELLOW,
+        'active_bg': 232,
+        'active_fg': 33,
+        'paused_bg': 232,
+        'paused_fg': 244,
+        'search_bg': 162,
+        'search_fg': 253,
+        'active_input_bg': 253,
+        'active_input_fg': 57,
+        'modes_selected_bg': 57,
+        'modes_selected_fg': 253,
+        'modes_unselected_bg': 253,
+        'modes_unselected_fg': 232,
+        'title_bar': 57,
+        'title_bg': 57,
+        'title_fg': 253,
+        'scroll_bar_bg': 247,
+        'selected_header_column_bg': 247,
+        'selected_header_column_fg': 232,
+        'footer_bg': 57,
+        'footer_fg': 253,
+        'refreshing_bg': 57,
+        'refreshing_fg': 253,
+        'refreshing_inactive_bg': 57,
+        'refreshing_inactive_fg': 232,
+        '40pc_bg': 232,
+        '40pc_fg': 166,
+        'footer_string_bg': 57,
+        'footer_string_fg': 253,
+    },
+    ]
+    for colour in colours:
+        colour["20pc_bg"] = colour["background"]
+        colour["40pc_bg"] = colour["background"]
+        colour["60pc_bg"] = colour["background"]
+        colour["80pc_bg"] = colour["background"]
+        colour["100pc_bg"] = colour["background"]
+        colour["error_bg"] = colour["background"]
+        colour["complete_bg"] = colour["background"]
+        colour["waiting_bg"] = colour["background"]
+        colour["active_bg"] = colour["background"]
+        colour["paused_bg"] = colour["background"]
+        colour["paused_bg"] = colour["background"]
+        # colour["search_bg"] = colour["background"]
+    if pick > len(colours) - 1:
+        return colours[0]
+    return colours[pick]
+
+def get_help_colours(pick: int=0) -> dict:
+    colours = [get_colours(i) for i in range(get_theme_count())]
+    for i in range(len(colours)):
+        colours[i]['cursor_bg'] = 235
+        colours[i]['cursor_fg'] = 253
+        colours[i]['selected_bg'] = 25
+        colours[i]['selected_fg'] = 253
+
+    if pick > len(colours) - 1:
+        return colours[0]
+    return colours[pick]
+
+
+def get_notification_colours(pick:int=0) -> dict:
+    colours = [get_colours(i) for i in range(get_theme_count())]
+    for i in range(len(colours)):
+        colours[i]['background'] = 237
+        colours[i]['unselected_bg'] = 237
+        colours[i]['cursor_bg'] = 237
+        colours[i]['selected_bg'] = 237
+
+    # Black and white
+    colours[1]['background'] = 237
+    colours[1]['unselected_bg'] = 237
+    colours[1]['cursor_bg'] = 237
+    colours[1]['cursor_fg'] = 253
+    colours[1]['selected_bg'] = 237
+    colours[1]['selected_fg'] = 253
+
+    if pick > len(colours) - 1:
+        return colours[0]
+    return colours[pick]

list_picker/utils/clipboard_operations.py

@@ -0,0 +1,33 @@
+#!/bin/python
+import pyperclip
+from typing import Tuple
+
+"""
+representation: python, tab-separated, comma-separated, current view
+rows: selected, all, filtered
+columns: all, not hidden
+"""
+
+def copy_to_clipboard(items: list[list[str]], indexed_items: list[Tuple[int, list[str]]], selections: dict, hidden_columns: set, representation: str="python", copy_hidden_cols: bool = False, separator="\t") -> None:
+    """ 
+    Copy selected items to clipboard.
+
+    representation (str): The representation of the rows that should be copied.
+                            accepted values: python, csv, tsv, current view, custom_sv
+
+    """
+    selected_indices = [i for i, selected in selections.items() if selected]
+    rows_to_copy = [item for i, item in enumerate(items) if i in selected_indices]
+    formatted_items = [[cell for i, cell in enumerate(item) if i not in hidden_columns or copy_hidden_cols] for item in rows_to_copy]
+    if representation == "python":
+        pyperclip.copy(repr(formatted_items))
+    elif representation == "tsv":
+        pyperclip.copy("\n".join(["\t".join(row) for row in formatted_items]))
+    elif representation == "csv":
+        pyperclip.copy("\n".join([",".join(row) for row in formatted_items]))
+    elif representation == "custom_sv":
+        # Ensure that escapes are interpreted properly in separator
+        separator = bytes(separator, "utf-8").decode("unicode_escape")
+        pyperclip.copy("\n".join([separator.join(row) for row in formatted_items]))
+    # elif representation == "current_view":
+    #     pyperclip.copy("\n".join([format_row(row, hidden_columns, column_widths, separator, centre_in_cols) for row in formatted_items]))

list_picker/utils/dump.py

@@ -0,0 +1,78 @@
+#!/bin/python
+import os
+import dill as pickle
+
+def make_list_unique(l:list) -> list:
+    result = []
+    for i in l:
+        if i not in result:
+            result.append(i)
+        else:
+            result[-1] += f'_({len(result)-1})'
+            result.append(i)
+    return result
+
+def dump_state(function_data:dict, file_path:str) -> None:
+    """ Dump state of list picker to file. """
+    exclude_keys =  ["refresh_function", "get_data_startup", "get_new_data", "auto_refresh"]
+    function_data = {key: val for key, val in function_data.items() if key not in exclude_keys}
+    with open(os.path.expandvars(os.path.expanduser(file_path)), 'wb') as f:
+        pickle.dump(function_data, f)
+
+def dump_data(function_data:dict, file_path:str, format="pickle") -> str:
+    """ Dump data from list_picker. Returns whether there was an error. """
+    include_keys = ["items", "header"]
+    function_data = {key: val for key, val in function_data.items() if key in include_keys }
+
+    try:
+        if format == "pickle":
+            with open(os.path.expandvars(os.path.expanduser(file_path)), 'wb') as f:
+                pickle.dump(function_data, f)
+        elif format == "csv":
+            import csv
+            with open(os.path.expandvars(os.path.expanduser(file_path)), mode='w', newline='') as f:
+                writer = csv.writer(f)
+                for row in [function_data["header"]] + function_data["items"]:
+                    writer.writerow(row)
+        elif format == "tsv":
+            import csv
+            with open(os.path.expandvars(os.path.expanduser(file_path)), mode='w', newline='') as f:
+                writer = csv.writer(f, delimiter='\t')
+                for row in [function_data["header"]] + function_data["items"]:
+                    writer.writerow(row)
+
+        elif format == "json":
+            import json
+            with open(os.path.expandvars(os.path.expanduser(file_path)), mode='w') as f:
+                json.dump([function_data["header"]]+ function_data["items"], f, indent=4)
+
+        elif format == "feather":
+            import pyarrow as pa
+            import pandas as pd
+            import pyarrow.feather as feather
+            table = pa.Table.from_pandas(pd.DataFrame(function_data["items"], columns=make_list_unique(function_data["header"])))
+            feather.write_feather(table, os.path.expandvars(os.path.expanduser(file_path)))
+            
+        elif format == "parquet":
+            import pyarrow as pa
+            import pyarrow.parquet as pq
+            import pandas as pd
+            table = pa.Table.from_pandas(pd.DataFrame(function_data["items"], columns=make_list_unique(function_data["header"])))
+
+            pq.write_table(table, os.path.expandvars(os.path.expanduser(file_path)))
+        elif format == "msgpack":
+            import msgpack as mp
+            with open(os.path.expandvars(os.path.expanduser(file_path)), mode='wb') as f:
+                mp.dump([function_data["header"]]+ function_data["items"], f)
+    except Exception as e:
+        return str(e)
+    return ""
+
+            
+
+def load_state(file_path:str) -> dict:
+    """ Load list_picker state from dump. """
+    with open(os.path.expandvars(os.path.expanduser(file_path)), 'rb') as f:
+        loaded_data = pickle.load(f)
+    return loaded_data
+

list_picker/utils/filtering.py

@@ -0,0 +1,32 @@
+#!/bin/python
+import re
+from typing import Tuple
+from list_picker.utils.search_and_filter_utils import apply_filter, tokenise
+import os
+
+def filter_items(items: list[list[str]], indexed_items: list[Tuple[int, list[str]]], query: str) -> list[Tuple[int, list[str]]]:
+    """ 
+    Filter items based on the query.
+
+    Accepts:
+        regular expressions
+        --# to specify column to match
+        --i to specify case-sensitivity (it is case insensitive by default)
+        --v to specify inverse match
+
+    E.g.,
+
+        --1 query       matches query in the 1 column
+
+
+    Returns indexed_items, which is a list of tuples; each tuple consists of the index and the data of the matching row in the original items list. 
+    """
+
+
+    invert_filter = False
+    case_sensitive = False
+
+    filters = tokenise(query)
+
+    indexed_items = [(i, item) for i, item in enumerate(items) if apply_filter(item, filters)]
+    return indexed_items

list_picker/utils/generate_data.py

@@ -0,0 +1,74 @@
+import subprocess
+import os
+from typing import Tuple, Callable
+import toml
+
+def generate_columns(funcs: list, files: list) -> list[list[str]]:
+    """
+    Takes a list of functions and a list of files. Each function is run for each file and a list of lists is returned.
+    """
+    items = []
+    for file in files:
+        item = []
+        for func in funcs:
+            item.append(func(file))
+        items.append(item)
+        
+    return items
+
+def command_to_func(command: str) -> Callable:
+    """
+    Convert a command string to a function that will run the command.
+
+    E.g.,
+        mediainfo {} | grep -i format
+        mediainfo {} | grep -i format | head -n 1 | awk '{{print $3}}'
+    """
+    
+    func = lambda arg: subprocess.run(command.format(repr(arg)), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stdout.decode("utf-8")
+    return func
+
+def load_environment(envs:dict):
+    """
+    Load environment variables from an envs dict.
+    """
+
+    if "cwd" in envs:
+        os.chdir(os.path.expandvars(os.path.expanduser(envs["cwd"])))
+
+
+def read_toml(file_path) -> Tuple[dict, list, list]:
+    """
+    Read toml file and return the environment, commands and header sections.
+    """
+    with open(file_path, 'r') as file:
+        config = toml.load(file)
+
+    environment = config['environment'] if 'environment' in config else {}
+    data = config['data'] if 'data' in config else {}
+    commands = [command.strip() for command in data['commands']] if 'commands' in data else []
+    header = [header for header in data['header']]  if 'header' in data else []
+    return environment, commands, header
+    
+def generate_list_picker_data(file_path: str) -> Tuple[list[list[str]], list[str]]:
+    """
+    Generate data for list picker based upon the toml file commands.
+    """
+    environment, commands, header = read_toml(file_path)
+    lines = commands
+
+    if environment:
+        load_environment(environment)
+
+    arg_command = lines[0]
+    args = subprocess.run(arg_command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stdout.decode("utf-8").split("\n")
+    args = [arg.strip() for arg in args if arg]
+    
+    commands_list = [line.strip() for line in lines[1:]]
+    command_funcs = [command_to_func(command) for command in commands_list]
+    items = generate_columns(command_funcs, args)
+    items = [[args[i]] + items[i] for i in range(len(args))]
+    items = [[cell.strip() for cell in item] for item in items]
+
+    return items, header
+    

list_picker/utils/options_selectors.py

@@ -0,0 +1,67 @@
+#!/bin/python
+import curses
+from typing import Tuple
+from list_picker.ui.input_field import input_field
+from list_picker.utils.utils import dir_picker
+
+def default_option_input(stdscr: curses.window, refresh_screen_function=None, starting_value:str="", field_name:str="Opts", registers={}) -> Tuple[bool, str]:
+    # notification(stdscr, message=f"opt required for {index}")
+    usrtxt = f"{starting_value} " if starting_value else ""
+    h, w = stdscr.getmaxyx()
+    # field_end = w-38 if show_footer else w-3
+    field_end = w-3
+    field_end_f = lambda: stdscr.getmaxyx()[1]-3
+    usrtxt, return_val = input_field(
+        stdscr,
+        usrtxt=usrtxt,
+        field_name=field_name,
+        x=lambda:2,
+        y=lambda: stdscr.getmaxyx()[0]-1,
+        max_length=field_end_f,
+        registers=registers,
+    )
+    if return_val: return True, usrtxt
+    else: return False, starting_value
+
+
+def default_option_selector(stdscr: curses.window, refresh_screen_function=None, starting_value:str="", field_name:str="Opts", registers={}) -> Tuple[bool, str]:
+    # notification(stdscr, message=f"opt required for {index}")
+    usrtxt = f"{starting_value} " if starting_value else ""
+    h, w = stdscr.getmaxyx()
+    # field_end = w-38 if show_footer else w-3
+    field_end = w-3
+    field_end_f = lambda: stdscr.getmaxyx()[1]-3
+    usrtxt, return_val = input_field(
+        stdscr,
+        usrtxt=usrtxt,
+        field_name=field_name,
+        x=lambda:2,
+        y=lambda: stdscr.getmaxyx()[0]-1,
+        max_length=field_end_f,
+        registers=registers,
+    )
+    if return_val: return True, usrtxt
+    else: return False, starting_value
+
+
+def output_file_option_selector(stdscr:curses.window, refresh_screen_function, registers={}) -> Tuple[bool, str]:
+    s = dir_picker()
+
+    stdscr.clear()
+    stdscr.refresh()
+    refresh_screen_function()
+    usrtxt = f"{s}/"
+    h, w = stdscr.getmaxyx()
+    # field_end = w-38 if show_footer else w-3
+    field_end_f = lambda: stdscr.getmaxyx()[1]-3
+    usrtxt, return_val = input_field(
+        stdscr,
+        usrtxt=usrtxt,
+        field_name="Save as",
+        x=lambda:2,
+        y=lambda: stdscr.getmaxyx()[0]-1,
+        max_length=field_end_f,
+        registers=registers,
+    )
+    if return_val: return True, usrtxt
+    else: return False, ""

list_picker/utils/search_and_filter_utils.py

@@ -0,0 +1,79 @@
+import re
+
+def apply_filter(row: list[str], filters: dict, case_sensitive: bool = False, add_highlights:bool = False, highlights: list=[]) -> bool:
+    """ Checks if row matches the filter. """
+    for col, filter_list in filters.items():
+        for filter in filter_list:
+            if case_sensitive or (filter != filter.lower()):
+                pattern = re.compile(filter)
+            else:
+                pattern = re.compile(filter, re.IGNORECASE)
+            if col == -1:  # Apply filter to all columns
+                if not any(pattern.search(str(item)) for item in row):
+                    return False
+                # return not invert_filter
+            elif col >= len(row) or col < 0:
+                return False
+            else:
+                cell_value = str(row[col])
+                if not pattern.search(str(cell_value)):
+                    return False
+                # return invert_filter
+
+    if add_highlights:
+        for col, filter_list in filters.items():
+            for filter in filter_list:
+                hcol = "all" if col == -1 else col
+                highlights.append({
+                    "match": filter,
+                    "field": hcol,
+                    "color": 10,
+                    "type": "search",
+                })
+    
+    return True
+
+
+def tokenise(query:str) -> dict:
+    """ Convert query into dict consisting of filters. '--1  """
+    filters = {}
+
+    # tokens = re.split(r'(\s+--\d+|\s+--i)', query)
+    # tokens = re.split(r'((\s+|^)--\w)', query)
+    tokens = re.split(r'\s+', query)
+    tokens = [token.strip() for token in tokens if token.strip()]  # Remove empty tokens
+    i = 0
+    while i < len(tokens):
+        token = tokens[i]
+        if token:
+            if token.startswith("--"):
+                flag = token
+                if flag == '--v':
+                    invert_filter = True 
+                    i += 1
+                elif flag == '--i':
+                    case_sensitive = True
+                    i += 1
+                else:
+                    if i+1 >= len(tokens):
+                        break
+                    col = int(flag[2:])
+                    arg = tokens[i+1].strip()
+                    try:
+                        i+=2
+                        re.compile(arg)
+                        if col in filters: filters[col].append(arg)
+                        else: filters[col] = [arg]
+                    except:
+                        pass
+            else:
+                try:
+                    i += 1
+                    re.compile(token)
+                    if -1 in filters: filters[-1].append(token)
+                    else: filters[-1] = [token]
+                except:
+                    pass
+        else:
+            i += 1
+    return filters