listpick 0.1.4.0__py3-none-any.whl

list_picker/utils/searching.py

@@ -0,0 +1,76 @@
+#!/bin/python
+import re
+from typing import Tuple
+from list_picker.utils.search_and_filter_utils import apply_filter, tokenise
+
+def search(query: str, indexed_items: list[Tuple[int, list[str]]], highlights: list[dict]=[], cursor_pos:int=0, unselectable_indices:list=[], reverse:bool=False, continue_search:bool=False) -> Tuple[bool, int, int, int, list[dict]]:
+    """
+    Search the indexed items and see which rows match 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
+
+    ---Returns: a tuple consisting of the following
+        return_val:     True if search item found
+        cursor_pos:     The position of the next search match
+        search_index:   If there are x matches then search_index tells us we are on the nth out of x
+        search_count:   The number of matches
+        highlights:     Adds the search highlights to the existing highlights list 
+                            I.e.,, we append the following to the highlights list to be displayed in draw_screen
+                            {
+                                "match": token,
+                                "field": "all",
+                                "color": 10,
+                                "type": "search",
+                            }
+
+    """
+    
+    # Clear previous search highlights
+
+    highlights = [highlight for highlight in highlights if "type" not in highlight or highlight["type"] != "search" ]
+
+
+
+
+
+    # Ensure we are searching from our current position forwards
+    searchables =  list(range(cursor_pos+1, len(indexed_items))) + list(range(cursor_pos+1))
+    if reverse:
+        searchables =  (list(range(cursor_pos, len(indexed_items))) + list(range(cursor_pos)))[::-1]
+
+    invert_filter = False
+    case_sensitive = False
+    filters = tokenise(query)
+
+    if not filters: return False, cursor_pos, 0,0,highlights
+    found = False
+    search_count = 0
+    search_list = []
+    
+    for i in searchables:
+        # if apply_filter(indexed_items[i][1]):
+        if apply_filter(indexed_items[i][1], filters, add_highlights=True, highlights=highlights):
+            new_pos = i
+            if new_pos in unselectable_indices: continue
+            search_count += 1
+            search_list.append(i)
+            
+            if not found:
+                cursor_pos = new_pos
+                found = True
+            # break
+            # return False
+            # for i in range(diff):
+            #     cursor_down()
+            # break
+    if search_list:
+        search_index = sorted(search_list).index(cursor_pos)+1
+    else:
+        search_index = 0
+
+    return bool(search_list), cursor_pos, search_index, search_count, highlights
+

list_picker/utils/sorting.py

@@ -0,0 +1,120 @@
+import re
+from datetime import datetime
+from typing import Tuple
+
+def parse_numerical(value: str) -> float:
+    """ Match first number in string and return it as a float. If not number then return INF. """
+    try:
+        match = re.search(r'(\d+(\.\d+)?)', value)
+        if match:
+            return float(match.group(1))
+        return float('inf')  # Default for non-numerical values
+    except ValueError:
+        return float('inf')
+
+def parse_size(value: str) -> float:
+    """ Match size in string and return it as a float. If no match then return INF."""
+    size_units = {
+        'B': 1,
+        'KB': 1024,
+        'MB': 1024**2,
+        'GB': 1024**3,
+        'TB': 1024**4,
+        'PB': 1024**5,
+        'K': 1024,
+        'M': 1024**2,
+        'G': 1024**3,
+        'T': 1024**4,
+        'P': 1024**5
+    }
+    
+    match = re.search(r'(\d+(\.\d+)?)(\s*([KMGTPEB][B]?)\s*)', value, re.IGNORECASE)
+    
+    if match:
+        number = float(match.group(1))
+        unit = match.group(4).upper() if match.group(4) else 'B'
+        unit = re.sub(r'[^\w]', '', unit)  # Remove non-alphanumeric characters
+        return number * size_units.get(unit, 1)
+    return float('inf')  # Default for non-size values
+
+def time_to_seconds(time_str: str) -> float:
+    """Convert a time string to total seconds."""
+    if time_str.strip().upper() == "INF":
+        return float('inf')  # Assign infinity for "INF"
+
+    time_units = {
+        'year': 365 * 24 * 3600,
+        'years': 365 * 24 * 3600,
+        'day': 24 * 3600,
+        'days': 24 * 3600,
+        'hour': 3600,
+        'hours': 3600,
+        'minute': 60,
+        'minutes': 60,
+        'sec': 1,
+        'secs': 1,
+        's': 1,
+        'min': 60,
+    }
+    
+    total_seconds = 0
+    try:
+        tokens = time_str.split()
+        for i in range(0, len(tokens), 2):
+            if i + 1 < len(tokens):
+                num = int(tokens[i])
+                unit = tokens[i + 1]
+                total_seconds += num * time_units.get(unit, 0)
+    except:
+        return float('inf')
+
+
+    return total_seconds
+
+def time_sort(time_str: str) -> datetime:
+    """ If there is a date in the string then convert it to strptime. If no match then return 00:00 (as datetime)."""
+    formats = [
+        "%Y-%m-%d %H:%M",     # "2021-03-16 15:30"
+        "%Y-%m-%d",           # "2021-03-16"
+        "%Y/%m/%d",           # "2021/03/16"
+        "%d/%m/%Y",           # "05/03/2024"
+        "%A %d %b %Y %H:%M:%S",  # "Saturday 01 Feb 2025 21:19:47"
+        "%a %d %b %Y %H:%M:%S",  # "Sat 01 Feb 2025 21:19:47"
+        "%d/%m/%Y",           # "10/12/2023"
+        "%d/%m/%y",            # "1/1/23"
+        "%H:%M",               # "04:30"
+        "%H:%M:%S",               # "04:30:23"
+    ]
+    
+    for fmt in formats:
+        try:
+            return datetime.strptime(time_str, fmt)
+        except ValueError:
+            pass
+    
+    return datetime.strptime("00:00", "%H:%M")
+
+def sort_items(indexed_items: list[Tuple[int,list[str]]], sort_method:int=0, sort_column:int=0, sort_reverse:bool=False):
+    """ Sort indexed_items based on the sort_method on sort_column. """
+    SORT_METHODS = ['original', 'lexical', 'LEXICAL', 'alphanum', 'ALPHANUM', 'time', 'numerical', 'size']
+    if sort_column is not None:
+        try:
+            if SORT_METHODS[sort_method] == 'numerical':
+                indexed_items.sort(key=lambda x: parse_numerical(x[1][sort_column]), reverse=sort_reverse)
+            elif SORT_METHODS[sort_method] == 'original':
+                indexed_items.sort(key=lambda x: x[0], reverse=sort_reverse)
+            elif SORT_METHODS[sort_method] == 'lexical':
+                # indexed_items.sort(key=lambda x: x[1][sort_column].lower(), reverse=sort_reverse)
+                indexed_items.sort(key=lambda x: (1 if x[1][sort_column].strip() == "" else 0, x[1][sort_column].lower()), reverse=sort_reverse)
+            elif SORT_METHODS[sort_method] == 'LEXICAL':
+                indexed_items.sort(key=lambda x: (1 if x[1][sort_column].strip() == "" else 0, x[1][sort_column]), reverse=sort_reverse)
+            elif SORT_METHODS[sort_method] == 'alphanum':
+                indexed_items.sort(key=lambda x: (1 if x[1][sort_column].strip() == "" else 0, "".join([chr(ord('z')+ord(c)) if not c.isalnum() else c.lower() for c in x[1][sort_column]])))
+            elif SORT_METHODS[sort_method] == 'time':
+                indexed_items.sort(key=lambda x:time_sort(x[1][sort_column]))
+            elif SORT_METHODS[sort_method] == 'ALPHANUM':
+                indexed_items.sort(key=lambda x: (1 if x[1][sort_column].strip() == "" else 0, "".join([chr(ord('z')+ord(c)) if not c.isalnum() else c for c in x[1][sort_column]])))
+            elif SORT_METHODS[sort_method] == 'size':
+                indexed_items.sort(key=lambda x: parse_size(x[1][sort_column]), reverse=sort_reverse)
+        except IndexError:
+            pass  # Handle cases where sort_column is out of range

list_picker/utils/table_to_list_of_lists.py

@@ -0,0 +1,188 @@
+#!/bin/python
+import sys
+import csv
+import json
+import pandas as pd
+from openpyxl import load_workbook
+from io import StringIO
+import argparse
+from typing import Tuple, Iterable, Optional
+import dill as pickle
+import os
+
+def read_file_content(file_path: str) -> str:
+    """ Read lines from file. """
+    with open(file_path, 'r') as file:
+        return file.read()
+
+def strip_whitespace(item: Iterable) -> Iterable:
+    """ Strip whitespace from string or from list of strings. """
+    if isinstance(item, list):
+        return [strip_whitespace(sub_item) for sub_item in item]
+    elif isinstance(item, str):
+        return item.strip()
+    else:
+        return item
+
+
+
+def table_to_list(input_arg: str, delimiter:str='\t', file_type:Optional[str]=None) -> Tuple[list[list[str]], list[str]]:
+    """ 
+    Convert data string to list. The input_arg
+    Currently accepts: csv, tsv, json, xlsx, ods
+    """
+    table_data = []
+
+    def parse_csv_like(data:str, delimiter:str) -> list[list[str]]:
+        """ Convert value-separated data (e.g., CSV or TSV) to list of lists. """
+
+        try:
+            reader = csv.reader(StringIO(data), delimiter=delimiter)
+            return [row for row in reader], []
+        except Exception as e:
+            print(f"Error reading CSV-like input: {e}")
+            return [], []
+
+    def csv_string_to_list(csv_string:str) -> list[list[str]]:
+        """ Convert csv string to list of lists using csv.reader. """
+        f = StringIO(csv_string)
+        reader = csv.reader(f, skipinitialspace=True)
+        return [row for row in reader], []
+
+    if file_type == 'csv' or delimiter in [',']:
+        try:
+            if input_arg == '--stdin':
+                input_data = sys.stdin.read()
+            elif input_arg == '--stdin2':
+                input_count = int(sys.stdin.readline())
+                input_data = "\n".join([sys.stdin.readline().strip() for i in range(input_count)])
+            else:
+                input_data = read_file_content(input_arg)
+            table_data = csv_string_to_list(input_data)
+            table_data = strip_whitespace(table_data)
+            return table_data, []
+        except Exception as e:
+            print(f"Error reading CSV/TSV input: {e}")
+            return [], []
+
+    elif file_type == 'tsv':
+        try:
+            if input_arg == '--stdin':
+                input_data = sys.stdin.read()
+            elif input_arg == '--stdin2':
+                input_count = int(sys.stdin.readline())
+                input_data = "\n".join([sys.stdin.readline().strip() for i in range(input_count)])
+            else:
+                input_data = read_file_content(input_arg)
+            
+            # Adjust delimiter for TSV or CSV
+            if file_type == 'tsv' or delimiter == '\t':
+                delimiter = '\t'
+            else:
+                delimiter = ','
+            
+            table_data = parse_csv_like(input_data, delimiter)
+            table_data = strip_whitespace(table_data)
+            return table_data, []
+        except Exception as e:
+            print(f"Error reading CSV/TSV input: {e}")
+            return [], []
+
+    elif file_type == 'json':
+        try:
+            if input_arg == '--stdin':
+                input_data = sys.stdin.read()
+            elif input_arg == '--stdin2':
+                input_count = int(sys.stdin.readline())
+                input_data = "\n".join([sys.stdin.readline() for i in range(input_count)])
+            else:
+                input_data = read_file_content(input_arg)
+            
+            table_data = json.loads(input_data)
+            return table_data, []
+        except json.JSONDecodeError as e:
+            print(f"Error decoding JSON input: {e}")
+            return [], []
+        except FileNotFoundError as e:
+            print(f"File not found: {e}")
+            return [], []
+
+    elif file_type == 'xlsx':
+        try:
+            if input_arg == '--stdin':
+                input_data = sys.stdin.read()
+                with open('temp.xlsx', 'wb') as f:
+                    f.write(input_data.encode())
+            elif input_arg == '--stdin2':
+                input_count = int(sys.stdin.readline())
+                input_data = "\n".join([sys.stdin.readline() for i in range(input_count)])
+                with open('temp.xlsx', 'wb') as f:
+                    f.write(input_data.encode())
+            else:
+                input_data = read_file_content(input_arg)
+                with open('temp.xlsx', 'wb') as f:
+                    f.write(input_data.encode())
+            
+            wb = load_workbook(filename='temp.xlsx')
+            sheet = wb.active
+            for row in sheet.iter_rows(values_only=True):
+                table_data.append(list(row))
+            return table_data, []
+        except Exception as e:
+            print(f"Error loading Excel file: {e}")
+            return [], []
+
+    elif file_type == 'ods':
+        try:
+            df = pd.read_excel(input_arg, engine='odf')
+            table_data = df.values.tolist()
+            return table_data, []
+        except Exception as e:
+            print(f"Error loading ODS file: {e}")
+            return [], []
+    elif file_type == 'pkl':
+        with open(os.path.expandvars(os.path.expanduser(input_arg)), 'rb') as f:
+            loaded_data = pickle.load(f)
+        items = loaded_data["items"] if "items" in loaded_data else []
+        header = loaded_data["header"] if "header" in loaded_data else []
+        return items, header
+
+    if input_arg == '--stdin':
+        input_data = sys.stdin.read()
+    elif input_arg == '--stdin2':
+        input_count = int(sys.stdin.readline())
+        input_data = "\n".join([sys.stdin.readline() for i in range(input_count)])
+    else:
+        input_data = read_file_content(input_arg)
+    
+    table_data = parse_csv_like(input_data, delimiter)
+
+    return table_data, []
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Convert table to list of lists.')
+    parser.add_argument('-i', dest='file', help='File containing the table to be converted')
+    parser.add_argument('--stdin', action='store_true', help='Table passed on stdin')
+    parser.add_argument('--stdin2', action='store_true', help='Table passed on stdin')
+    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'], help='Type of file (tsv, csv, json, xlsx, ods)')
+    
+    args = parser.parse_args()
+    
+    if args.file:
+        input_arg = args.file
+    elif args.stdin:
+        input_arg = '--stdin'
+    elif args.stdin2:
+        input_arg = '--stdin2'
+    else:
+        print("Error: Please provide input file or use --stdin option.")
+        sys.exit(1)
+    
+    table_data = table_to_list(input_arg, args.delimiter, args.file_type)
+    # print(table_data)
+
+    len(table_data[0])
+    for row in table_data:
+        if len(row) != len(table_data[0]):
+            print(len(row), row)

list_picker/utils/utils.py

@@ -0,0 +1,251 @@
+#!/bin/python
+from wcwidth import wcwidth, wcswidth
+from math import log10
+import subprocess
+import tempfile
+
+def truncate_to_display_width(text: str, max_column_width: int, centre=False) -> str:
+    """ 
+    Truncate and/or pad text to max_column_width using wcwidth to ensure visual width is correct 
+        with foreign character sets. 
+
+    Return: The truncated and/or padded string which has a visual length of max_column_width. 
+        If centre=True then the string is centred, if applicable.
+
+    """
+    result = ''
+    width = 0
+    for char in text:
+        w = wcwidth(char)
+        if w < 0:
+            continue
+        if width + w > max_column_width:
+            break
+        result += char
+        width += w
+    # Pad if it's shorter
+    padding = max_column_width - wcswidth(result)
+    # return result + ' ' * padding
+    if centre:
+        result = ' '*(padding//2) + result + ' '*(padding//2 + padding%2)
+    else:
+        result = result + ' ' * padding 
+    return result
+
+def format_row_full(row: list[str], hidden_columns:list = []) -> str:
+    """ Format list of strings as a tab-separated single string. No hidden columns. """
+    return '\t'.join(str(row[i]) for i in range(len(row)) if i not in hidden_columns)
+
+def format_full_row(row:str) -> str:
+    """ Format list of strings as a tab-separated single string. Includes hidden columns. """
+    return '\t'.join(row)
+
+
+def format_row(row: list[str], hidden_columns: list, column_widths: list[int], separator: str, centre:bool=False) -> str:
+    """ Format list of strings as a single string. Requires separator string and the maximum width of the columns. """
+    row_str = ""
+    for i, cell in enumerate(row):
+        if i in hidden_columns: continue
+        val = truncate_to_display_width(str(cell), column_widths[i], centre)
+        row_str += val + separator
+    return row_str
+    # return row_str.strip()
+
+def get_column_widths(items: list[list[str]], header: list[str]=[], max_column_width:int=70, number_columns:bool=True) -> list[int]:
+    """ Calculate maximum width of each column with clipping. """
+    if len(items) == 0: return [0]
+    assert len(items) > 0
+    widths = [max(wcswidth(str(row[i])) for row in items) for i in range(len(items[0]))]
+    if header:
+        header_widths = [wcswidth(str(h))+int(log10(i+1))+3*int(number_columns) for i, h in enumerate(header)]
+        return [min(max_column_width, max(widths[i], header_widths[i])) for i in range(len(header))]
+    return [min(max_column_width, width) for width in widths]
+
+def get_mode_widths(item_list: list[str]) -> list[int]:
+    """ Calculate the maximum width of modes with clipping. """
+    widths = [wcswidth(str(row)) for row in item_list]
+    return widths
+
+def intStringToExponentString(n: str) -> str:
+    """ Return exponent representation of integer. E.g., 1234 -> ¹²³⁴ """
+    n = str(n)
+    digitdict = { "0" : "⁰", "1" : "¹", "2" : "²", "3" : "³", "4" : "⁴", "5" : "⁵", "6" : "⁶", "7" : "⁷", "8" : "⁸", "9" : "⁹"}
+    return "".join([digitdict[char] for char in n])
+
+def convert_seconds(seconds:int, long_format:bool=False) -> str:
+    """ Convert seconds to human readable format. E.g., 60*60*24*3+62=772262 -> 3d2m2s """
+    if isinstance(seconds, str):
+        seconds = int(seconds)
+
+    # Calculate years, days, hours, minutes, and seconds
+    years = seconds // (365 * 24 * 3600)
+    days = (seconds % (365 * 24 * 3600)) // (24 * 3600)
+    hours = (seconds % (24 * 3600)) // 3600
+    minutes = (seconds % 3600) // 60
+    remaining_seconds = seconds % 60
+
+    # Long format = years, days, hours, minutes, seconds
+    if long_format:
+        human_readable = []
+        if years > 0:
+            human_readable.append(f"{years} year{'s' if years > 1 else ''}")
+        if days > 0:
+            human_readable.append(f"{days} day{'s' if days > 1 else ''}")
+        if hours > 0:
+            human_readable.append(f"{hours} hour{'s' if hours > 1 else ''}")
+        if minutes > 0:
+            human_readable.append(f"{minutes} minute{'s' if minutes > 1 else ''}")
+        if remaining_seconds > 0 or not human_readable:
+            human_readable.append(f"{remaining_seconds} second{'s' if remaining_seconds != 1 else ''}")
+        return ', '.join(human_readable)
+    else:
+        # Compact format = y, d, h, m, s
+        compact_parts = []
+        if years > 0:
+            compact_parts.append(f"{years}y")
+        if days > 0:
+            compact_parts.append(f"{days}d")
+        if hours > 0:
+            compact_parts.append(f"{hours}h")
+        if minutes > 0:
+            compact_parts.append(f"{minutes}m")
+        if remaining_seconds > 0 or not compact_parts:
+            compact_parts.append(f"{remaining_seconds}s")
+        return ''.join(compact_parts)
+
+def convert_percentage_to_ascii_bar(p:int, chars:int=8) -> str:
+    """ Convert percentage to an ascii status bar of length chars. """
+
+    done = "█"
+    notdone = "▒"
+    return done * int(p / 100 * chars) + (chars-(int(p / 100 * chars)))*notdone
+    return "[" + "=" * int(p / 100 * chars) + ">" + " " * (chars - int(p / 100 * chars) - 1) + "]"
+
+
+def get_selected_indices(selections: dict[int, bool]) -> list[int]:
+    """ Return a list of indices which are True in the selections dictionary. """
+
+    # selected_indices = [items[i] for i, selected in selections.values() if selected]
+    selected_indices = [i for i, selected in selections.items() if selected]
+    return selected_indices
+
+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. """
+    selected_values = [items[i] for i, selected in selections.items() if selected]
+    return selected_values
+
+def format_size(n:int) -> str:
+    """
+    Convert bytes to a human-readable format. E.g., 8*1024*1024*3 -> 8MB
+    
+    Args:
+        n (int): The number of bytes to convert.
+        
+    Returns:
+        str: A string representing the bytes in a more human-readable form.
+    """
+    if n < 0:
+        raise ValueError("Number must be non-negative")
+    
+    symbols = ('B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB')
+    prefix = {}
+    for i, symbol in enumerate(symbols):
+        prefix[symbol] = 1 << (i * 10)
+        
+    if n == 0:
+        return "0B"
+    
+    symbol, value = "B", 0
+    for symbol in reversed(symbols):
+        if n >= prefix[symbol]:
+            value = float(n) / prefix[symbol]
+            break
+    
+    return f"{value:.1f}{symbol}"
+
+
+def openFiles(files: list[str]) -> str:
+    """
+    Opens multiple files using their associated applications.
+        Get mime types
+        Get default application for each mime type
+        Open all files; files with the same default application will be opened in one instance
+
+    Args:
+        files (list[str]): A list of file paths.
+
+    Returns:
+        str
+    """
+    def get_mime_types(files):
+        types = {}
+
+        for file in files:
+            resp = subprocess.run(f"xdg-mime query filetype {file}", stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
+            ftype = resp.stdout.decode("utf-8").strip()
+            if ftype in types:
+                types[ftype] += [file]
+            else:
+                types[ftype] = [file]
+
+        return types
+
+    def get_applications(types):
+        apps = {}
+
+        for t in types:
+            resp = subprocess.run(f"xdg-mime query default {t}", stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)
+            app = resp.stdout.decode("utf-8").strip()
+            if app in apps:
+                apps[app] += [t]
+            else:
+                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])
+
+    types = get_mime_types(files)
+    apps = get_applications(types.keys())
+
+    apps_files = {}
+    for app, filetypes in apps.items():
+        flist = []
+        for filetype in filetypes:
+            flist += types[filetype]
+        apps_files[app] = flist
+
+    for app, files in apps_files.items():
+        files_str = ' '.join(files)
+        result = subprocess.Popen(f"gio launch /usr/share/applications/{app} {files_str}", shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)
+        # if result.stderr: 
+        #     return result.stderr.read().decode("utf-8").strip()
+    return ""
+
+def file_picker() -> str:
+    """ Run file picker (yazi by default) and return the path of the file picked. If no file is picked an empty string is returned. """
+
+    with tempfile.NamedTemporaryFile(delete=False) as tmpfile:
+        subprocess.run(f"yazi --chooser-file={tmpfile.name}", shell=True)
+
+        lines = tmpfile.readlines()
+        if lines:
+            filename = lines[0].decode("utf-8").strip()
+            return filename
+        else:
+            return ""
+
+            
+def dir_picker() -> str:
+    """ Run dir picker (yazi by default) and return the path of the directory one is in upon exit. """
+
+    with tempfile.NamedTemporaryFile(delete=False) as tmpfile:
+        subprocess.run(f"yazi --cwd-file={tmpfile.name}", shell=True)
+
+        lines = tmpfile.readlines()
+        if lines:
+            filename = lines[0].decode("utf-8").strip()
+            return filename
+        else:
+            return ""