listpick 0.1.15.19__py3-none-any.whl → 0.1.16.17__py3-none-any.whl

listpick/ui/keys.py

@@ -51,8 +51,8 @@ picker_keys = {
     "continue_search_forward":          [ord('n')],
     "continue_search_backward":         [ord('N')],
     "cancel":                           [27], # Escape key
-    "opts_input":                       [ord(':')],
-    "opts_select":                      [ord('o')],
+    "opts_input":                       [keycodes.META_o],
+    # "opts_select":                      [ord('+')],
     "mode_next":                        [9], # Tab key
     "mode_prev":                        [353], # Shift+Tab key
     "pipe_input":                       [ord('|')],
@@ -62,13 +62,14 @@ picker_keys = {
     "col_select_prev":                             [ord('<')], 
     "col_hide":                         [ord('!'), ord('@'), ord('#'), ord('$'), ord('%'), ord('^'), ord('&'), ord('*'), ord('('), ord(')')],
     "edit":                             [ord('e')],
-    "edit_picker":                      [ord('E')],
+    # "edit_picker":                      [ord('E')],
+    "edit_nvim":                        [ord('E')],
     "edit_ipython":                     [5], # Ctrl+e
     "copy":                             [ord('y')],
     "paste":                             [ord('p')],
     "save":                             [19, ord('D')],  # Ctrl+s
     "load":                             [15], # Ctrl+o
-    "open":                             [ord('O')], 
+    # "open":                             [ord('O')], 
     "toggle_footer":                    [ord('_')], 
     "notification_toggle":              [ord('z')],
     "redo":                             [ord('.')],
@@ -90,6 +91,8 @@ picker_keys = {
     # "sheet_prev":                           [],
     "toggle_right_pane":                             [ord("'")], 
     "cycle_right_pane":                             [ord('"')], 
+    "toggle_left_pane":                             [ord(";")], 
+    "cycle_left_pane":                             [ord(':')], 
 }
 
 
@@ -104,8 +107,8 @@ help_keys = {
     "page_down":                        [curses.KEY_NPAGE, 6],
     "cursor_bottom":                    [ord('G'), curses.KEY_END],
     "cursor_top":                       [ord('g'), curses.KEY_HOME],
-    "five_up":                          [ord('K')],
-    "five_down":                        [ord('J')],
+    "five_up":                          [ord('K'), keycodes.META_k],
+    "five_down":                        [ord('J'), keycodes.META_j],
     "redraw_screen":                    [12], # Ctrl+l
     "cycle_sort_method":                [ord('s')],
     "cycle_sort_method_reverse":        [ord('S')],
@@ -235,8 +238,8 @@ edit_menu_keys = {
     "continue_search_forward":          [ord('n'), ord('i')],
     "continue_search_backward":         [ord('N'), ord('I')],
     "cancel":                           [27], # Escape key
-    "opts_input":                       [ord(':')],
-    "opts_select":                      [ord('o')],
+    "opts_input":                       [keycodes.META_o],
+    # "opts_select":                      [ord('+')],
     "mode_next":                        [9], # Tab key
     "mode_prev":                        [353], # Shift+Tab key
     "pipe_input":                       [ord('|')],
@@ -246,11 +249,14 @@ edit_menu_keys = {
     "col_select_prev":                             [ord('<'), ord('h')], 
     "col_hide":                         [ord('!'), ord('@'), ord('#'), ord('$'), ord('%'), ord('^'), ord('&'), ord('*'), ord('('), ord(')')],
     "edit":                             [ord('e')],
-    "edit_picker":                      [ord('E')],
+    "edit_nvim":                        [ord('E')],
     "edit_ipython":                     [5], # Ctrl+e
     "copy":                             [ord('y')],
     "save":                             [19, ord('D')],  # Ctrl+s
     "load":                             [ord('L'), 15], # Ctrl+o
-    "open":                             [ord('O')], 
+    # "open":                             [ord('O')], 
     "toggle_footer":                    [ord('_')], 
+    "visual_selection_toggle":          [ord('v')],
+    "visual_deselection_toggle":        [ord('V')],
+    "toggle_select":                    [ord(' ')],
 }

listpick/ui/picker_colours.py

@@ -294,6 +294,61 @@ def get_colours(pick:int=0) -> Dict[str, int]:
         'active_column_bg': curses.COLOR_BLACK,
         'active_column_fg': curses.COLOR_WHITE,
     },
+        ### (6) Use default colors for bg
+    # {
+    #     'background': -1,
+    #     'normal_fg': -1,
+    #     'unselected_bg': -1,
+    #     'unselected_fg': -1,
+    #     'cursor_bg': 21,
+    #     'cursor_fg': -1,
+    #     'selected_bg': 54,
+    #     'selected_fg': -1,
+    #     'header_bg': 255,
+    #     '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': -1,
+    #     'paused_fg': 244,
+    #     'search_bg': 162,
+    #     'search_fg': -1,
+    #     'active_input_bg': -1,
+    #     'active_input_fg': 232,
+    #     'modes_selected_bg': 232,
+    #     'modes_selected_fg': -1,
+    #     'modes_unselected_bg': 255,
+    #     'modes_unselected_fg': 232,
+    #     'title_bar': 232,
+    #     'title_bg': 232,
+    #     'title_fg': -1,
+    #     'scroll_bar_bg': 247,
+    #     'selected_header_column_bg': 232,
+    #     'selected_header_column_fg': -1,
+    #     'unselected_header_column_bg': -1,
+    #     'unselected_header_column_fg': -1,
+    #     'footer_bg': 232,
+    #     'footer_fg': -1,
+    #     'refreshing_bg': 232,
+    #     'refreshing_fg': -1,
+    #     'refreshing_inactive_bg': 232,
+    #     'refreshing_inactive_fg': 232,
+    #     '40pc_bg': 232,
+    #     '40pc_fg': 166,
+    #     'footer_string_bg': 232,
+    #     'footer_string_fg': -1,
+    #     'selected_cell_bg': 54,
+    #     'selected_cell_fg': -1,
+    #     'deselecting_cell_bg': 162,
+    #     'deselecting_cell_fg': -1,
+    #     'active_column_bg': 234,
+    #     'active_column_fg': -1,
+    # },
     ]
     for colour in colours:
         colour["20pc_bg"] = colour["background"]

listpick/utils/generate_data.py

@@ -15,8 +15,45 @@ import toml
 import logging
 
 logger = logging.getLogger('picker_log')
+import concurrent.futures
+import re
 
 def generate_columns(funcs: list, files: list) -> list[list[str]]:
+    """
+    Takes a list of functions and a list of files. 
+    Tasks are run in parallel using concurrent.futures.
+    """
+    logger.info("function: generate_columns (generate_data.py)")
+    
+    results = []
+    # Create a future object for each combination of func and file
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        futures = [[executor.submit(func, file) for func in funcs] for file in files]
+        
+        for file_futures in futures:
+            result = [future.result() for future in file_futures]
+            results.append(result)
+    return results
+
+
+def generate_columns_multithread(funcs: list, files: list) -> list[list[str]]:
+    """
+    Takes a list of functions and a list of files. 
+    Tasks are run in parallel using concurrent.futures.
+    """
+    logger.info("function: generate_columns (generate_data.py)")
+    
+    results = []
+    # Create a future object for each combination of func and file
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        futures = [[executor.submit(func, file) for func in funcs] for file in files]
+        
+        for file_futures in futures:
+            result = [future.result() for future in file_futures]
+            results.append(result)
+    return results
+
+def generate_columns_single_thread(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.
     """
@@ -30,7 +67,7 @@ def generate_columns(funcs: list, files: list) -> list[list[str]]:
             except:
                 item.append("")
         items.append(item)
-        
+
     return items
 
 def command_to_func(command: str) -> Callable:
@@ -43,7 +80,7 @@ def command_to_func(command: str) -> Callable:
     """
     logger.info("function: command_to_func (generate_data.py)")
     
-    func = lambda arg: subprocess.run(command.format(repr(arg)), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stdout.decode("utf-8")
+    func = lambda arg: subprocess.run(replace_braces(command, repr(arg)), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stdout.decode("utf-8").strip()
     return func
 
 def load_environment(envs:dict):
@@ -55,6 +92,12 @@ def load_environment(envs:dict):
     if "cwd" in envs:
         os.chdir(os.path.expandvars(os.path.expanduser(envs["cwd"])))
 
+def replace_braces(text, s):
+    text = re.sub(r'\{\{(.*?)\}\}', r'@@\1@@', text)
+    text = re.sub(r'\{\}', s, text)
+    text = re.sub(r'@@(.*?)@@', r'{{\1}}', text)
+    return text
+
 
 def read_toml(file_path) -> Tuple[dict, list, list]:
     """

listpick/utils/generate_data_multiprocessing.py

@@ -0,0 +1,10 @@
+#!/bin/python
+# -*- coding: utf-8 -*-
+"""
+generate_data_utils.py
+
+Author: GrimAndGreedy
+License: MIT
+"""
+
+from listpick.utils.generate_data_utils import ProcessSafePriorityQueue

listpick/utils/generate_data_multithreaded.py

@@ -0,0 +1,234 @@
+#!/bin/python
+# -*- coding: utf-8 -*-
+"""
+generate_data_multithreaded.py
+Generate data for listpick Picker.
+
+
+1. Read toml file.
+2. Set environment variables.
+3. Get files from first command.
+4. Create items with "..." for cells to be filled.
+5. Create a priority queue which determines which cells are to be filled first.
+6. Create a queue updater which increases the priorty of cells which are on screen which does so each second.
+7. Create threads to start generating data for cells.
+
+Author: GrimAndGreedy
+License: MIT
+"""
+
+import subprocess
+import os
+from typing import Tuple, Callable
+import toml
+import logging
+import threading
+from queue import PriorityQueue
+import time
+import re
+import shlex
+
+logger = logging.getLogger('picker_log')
+
+def generate_columns_worker(
+    funcs: list,
+    files: list,
+    items: list[list[str]],
+    getting_data: threading.Event,
+    task_queue: PriorityQueue,
+    completed_cells: set,
+    state: dict,
+) -> None:
+    """ Get a task from the priorty queue and fill the data for that cell."""
+    while task_queue.qsize() > 0 and not state["thread_stop_event"].is_set():
+        _, (i, j) = task_queue.get()
+
+        if (i, j) in completed_cells:
+            task_queue.task_done()
+            continue
+            
+        if state["thread_stop_event"].is_set():
+            with task_queue.mutex:
+                task_queue.queue.clear()
+
+        generate_cell(
+            func=funcs[j],
+            file=files[i],
+            items=items,
+            row=i,
+            col=j+1,
+            state=state,
+        )
+        completed_cells.add((i, j))
+        task_queue.task_done()
+    getting_data.set()
+
+def generate_cell(func: Callable, file: str, items: list[list[str]], row: int, col: int, state: dict) -> None:
+    """
+    Takes a function, file and a file and then sets items[row][col] to the result.
+    """
+    if not state["thread_stop_event"].is_set():
+        try:
+            result = func(file).strip()
+            if not state["thread_stop_event"].is_set():
+                items[row][col] = result
+        except Exception as e:
+            pass
+            # import pyperclip
+            # pyperclip.copy(f"({row}, {col}): len(items)={len(items)}, len(items[0])={len(items[0])} {e}")
+
+def update_queue(task_queue: PriorityQueue, visible_rows_indices: list[int], rows: int, cols: int, state: dict):
+    """ Increase the priority of getting the data for the cells that are currently visible. """
+    while task_queue.qsize() > 0:
+        time.sleep(0.1)
+        if state["thread_stop_event"].is_set():
+            with task_queue.mutex:
+                task_queue.queue.clear()
+            break 
+        for row in visible_rows_indices:
+            for col in range(cols):
+                if state["generate_data_for_hidden_columns"] == False and col+1 in state["hidden_columns"]: continue
+                if 0 <= row < rows:
+                    task_queue.put((1, (row, col)))
+
+        # Delay
+        time.sleep(0.9)
+
+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}}'
+    """
+    logger.info("function: command_to_func (generate_data.py)")
+    
+    func = lambda arg: subprocess.run(replace_braces(command, arg), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stdout.decode("utf-8").strip()
+    return func
+
+def load_environment(envs:dict):
+    """
+    Load environment variables from an envs dict.
+    """
+    logger.info("function: load_environment (generate_data.py)")
+
+    if "cwd" in envs:
+        os.chdir(os.path.expandvars(os.path.expanduser(envs["cwd"])))
+
+def replace_braces(text, s):
+    text = re.sub(r'\{\{(.*?)\}\}', r'@@\1@@', text)
+    text = re.sub(r'\{\}', shlex.quote(s), text)
+    text = re.sub(r'@@(.*?)@@', r'{{\1}}', text)
+    return text
+
+def read_toml(file_path) -> Tuple[dict, list, list]:
+    """
+    Read toml file and return the environment, commands and header sections.
+    """
+    logger.info("function: read_toml (generate_data.py)")
+    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_picker_data_from_file(
+    file_path: str,
+    items,
+    header,
+    visible_rows_indices,
+    getting_data,
+    state,
+
+) -> None:
+    """
+    Generate data for Picker based upon the toml file commands.
+    """
+    logger.info("function: generate_picker_data (generate_data.py)")
+
+
+    environment, lines, hdr = read_toml(file_path)
+
+    # Load any environment variables from the toml file
+    if environment:
+        load_environment(environment)
+
+
+    # Get list of files to be displayed in the first column.
+    get_files_command = lines[0]
+    files = subprocess.run(get_files_command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).stdout.decode("utf-8").strip().split("\n")
+    files = [file.strip() for file in files if files]
+    
+    commands_list = [line.strip() for line in lines[1:]]
+    command_funcs = [command_to_func(command) for command in commands_list]
+
+    generate_picker_data(
+        files = files,
+        column_functions = command_funcs,
+        data_header = hdr,
+        items = items,
+        picker_header = header,
+        visible_rows_indices = visible_rows_indices,
+        getting_data = getting_data,
+        state=state,
+    )
+
+def generate_picker_data(
+    files: list[str],
+    column_functions: list[Callable],
+    data_header,
+    items,
+    picker_header,
+    visible_rows_indices,
+    getting_data,
+    state,
+) -> None:
+    """
+    Generate data from a list of files and a list of column functions which will be used to 
+        generate subsequent columns.
+
+    This function is performed asynchronously with os.cpu_count() threads.
+
+    data_header: header list to be set for the picker
+    picker_header: the picker header will be passed in so that it can be set for the class
+
+    """
+    logger.info("function: generate_picker_data (generate_data.py)")
+
+    items.clear()
+    items.extend([[file] + ["..." for _ in column_functions] for file in files])
+    picker_header[:] = data_header
+
+
+    task_queue = state["data_generation_queue"]
+    for i in range(len(files)):
+        for j in range(len(column_functions)):
+            if state["generate_data_for_hidden_columns"] == False and j+1 in state["hidden_columns"]: continue
+            task_queue.put((10, (i, j)))
+
+    num_workers = os.cpu_count()
+    if num_workers in [None, -1]: num_workers = 4
+    if num_workers == None or num_workers < 1: num_workers = 1
+    completed_cells = set()
+
+    for _ in range(num_workers):
+        gen_items_thread = threading.Thread(
+            target=generate_columns_worker,
+            args=(column_functions, files, items, getting_data, task_queue, completed_cells, state),
+        )
+        state["threads"].append(gen_items_thread)
+        gen_items_thread.daemon = True
+        gen_items_thread.start()
+
+    update_queue_thread = threading.Thread(
+        target=update_queue,
+        args=(task_queue, visible_rows_indices, len(files), len(column_functions), state),
+    )
+    state["threads"].append(update_queue_thread)
+    update_queue_thread.daemon = True
+    update_queue_thread.start()

listpick/utils/generate_data_utils.py

@@ -0,0 +1,43 @@
+#!/bin/python
+# -*- coding: utf-8 -*-
+"""
+generate_data_utils.py
+
+Author: GrimAndGreedy
+License: MIT
+"""
+
+def sort_priority_first(element):
+    return element[0]
+
+class ProcessSafePriorityQueue:
+    def __init__(self, manager):
+        self.data = manager.list()
+        self.lock = manager.Lock()
+
+    def put(self, item):
+        with self.lock:
+            self.data.append(item)
+            self.data.sort(key=sort_priority_first)
+
+    def get(self, timeout=None):
+        start = time.time()
+        while True:
+            with self.lock:
+                if self.data:
+                    return self.data.pop(0)
+            if timeout is not None and (time.time() - start) > timeout:
+                raise IndexError("get timeout")
+            time.sleep(0.01)
+
+    def qsize(self):
+        with self.lock:
+            return len(self.data)
+
+    def empty(self):
+        with self.lock:
+            return len(self.data) == 0
+
+    def clear(self):
+        with self.lock:
+            self.data[:] = []

listpick/utils/user_input.py

@@ -1,11 +1,17 @@
 from listpick.utils import keycodes
 import os, tty, select, curses
+import termios
 
 def open_tty():
     """ Return a file descriptor for the tty that we are opening"""
     tty_fd = os.open('/dev/tty', os.O_RDONLY)
+    old_terminal_settings = termios.tcgetattr(tty_fd)
     tty.setraw(tty_fd)
-    return tty_fd
+    return tty_fd, old_terminal_settings
+
+def restore_terminal_settings(tty_fd, old_settings):
+    """ Restore the terminal to its previous state """
+    termios.tcsetattr(tty_fd, termios.TCSADRAIN, old_settings)
 
 def get_char(tty_fd, timeout: float = 0.2, secondary: bool = False) -> int:
     """ Get character from a tty_fd with a timeout. """

listpick/utils/utils.py

@@ -14,9 +14,14 @@ import tempfile
 import os
 from typing import Tuple, Dict
 import logging
+import shlex
+from collections import defaultdict
+import time
 
 logger = logging.getLogger('picker_log')
 
+
+
 def clip_left(text, n):
     """
     Clips the first `n` display-width characters from the left of the input string.
@@ -98,7 +103,12 @@ def format_row(row: list[str], hidden_columns: list, column_widths: list[int], s
 
 def get_column_widths(items: list[list[str]], header: list[str]=[], max_column_width:int=70, number_columns:bool=True, max_total_width=-1, separator = "    ", unicode_char_width: bool = True) -> list[int]:
     """ Calculate maximum width of each column with clipping. """
-    if len(items) == 0: return [0]
+    if len(items) == 0 and len(header) == 0: return [0]
+    elif len(items) == 0:
+        header_widths = [wcswidth(f"{i}. {str(h)}") if number_columns else wcswidth(str(h)) for i, h in enumerate(header)]
+        col_widths =  [min(max_column_width, header_widths[i]) for i in range(len(header))]
+        return col_widths
+
     assert len(items) > 0
     widths = [max(wcswidth(str(row[i])) for row in items) for i in range(len(items[0]))]
     # widths = [max(len(str(row[i])) for row in items) for i in range(len(items[0]))]
@@ -204,17 +214,11 @@ def get_selected_cells(cell_selections: Dict[Tuple[int, int], bool]) -> list[Tup
 def get_selected_cells_by_row(cell_selections: dict[tuple[int, int], bool]) -> dict[int, list[int]]:
     """ {0: [1,2], 9: [1] }"""
     
-    d = {}
-    try:
-        for tup in cell_selections.keys():
-            if cell_selections[tup]:
-                if tup[0] in d:
-                    d[tup[0]].append(tup[1])
-                else:
-                    d[tup[0]] = [tup[1]]
-    except:
-        pass
-    return d
+    d = defaultdict(list)
+    for (row, col), selected in cell_selections.items():
+        if selected:
+            d[row].append(col)
+    return dict(d)
 
 def get_selected_values(items: list[list[str]], selections: dict[int, bool]) -> list[list[str]]:
     """ Return a list of rows based on wich are True in the selections dictionary. """
@@ -290,9 +294,7 @@ def openFiles(files: list[str]) -> str:
                 apps[app] = [t]
 
         return apps
-    for i in range(len(files)):
-        if ' ' in files[i] and files[i][0] not in ["'", '"']:
-            files[i] = repr(files[i])
+    files = [shlex.quote(file) for file in files]
 
     types = get_mime_types(files)
     apps = get_applications(types.keys())