#!/usr/bin/env python3 import argparse import copy import ctypes import io import locale import os import platform import re import shlex import signal import string import subprocess import sys from locale import getlocale from types import FrameType from typing import ( Any, Callable, Dict, Iterable, Iterator, List, Match, Optional, Pattern, Sequence, Set, TextIO, Tuple, Union, cast, ) try: import termios except ImportError as e: raise NotImplementedError('"{}" is currently not supported.'.format(platform.system())) from e __author__ = "Ingo Meyer" __email__ = "i.meyer@fz-juelich.de" __copyright__ = "Copyright © 2021 Forschungszentrum Jülich GmbH. All rights reserved." __license__ = "MIT" __version_info__ = (1, 6, 6) __version__ = ".".join(map(str, __version_info__)) DEFAULT_ACCEPT_KEYS = ("enter",) DEFAULT_CLEAR_MENU_ON_EXIT = True DEFAULT_CLEAR_SCREEN = False DEFAULT_CYCLE_CURSOR = True DEFAULT_EXIT_ON_SHORTCUT = True DEFAULT_MENU_CURSOR = "> " DEFAULT_MENU_CURSOR_STYLE = ("fg_red", "bold") DEFAULT_MENU_HIGHLIGHT_STYLE = ("standout",) DEFAULT_MULTI_SELECT = False DEFAULT_MULTI_SELECT_CURSOR = "[*] " DEFAULT_MULTI_SELECT_CURSOR_BRACKETS_STYLE = ("fg_gray",) DEFAULT_MULTI_SELECT_CURSOR_STYLE = ("fg_yellow", "bold") DEFAULT_MULTI_SELECT_KEYS = (" ", "tab") DEFAULT_MULTI_SELECT_SELECT_ON_ACCEPT = True DEFAULT_PREVIEW_BORDER = True DEFAULT_PREVIEW_SIZE = 0.25 DEFAULT_PREVIEW_TITLE = "preview" DEFAULT_QUIT_KEYS = ("escape", "q", "ctrl-g") DEFAULT_SEARCH_CASE_SENSITIVE = False DEFAULT_SEARCH_HIGHLIGHT_STYLE = ("fg_black", "bg_yellow", "bold") DEFAULT_SEARCH_KEY = "/" DEFAULT_SHORTCUT_BRACKETS_HIGHLIGHT_STYLE = ("fg_gray",) DEFAULT_SHORTCUT_KEY_HIGHLIGHT_STYLE = ("fg_blue",) DEFAULT_SHOW_MULTI_SELECT_HINT = False DEFAULT_SHOW_SEARCH_HINT = False DEFAULT_SHOW_SHORTCUT_HINTS = False DEFAULT_SHOW_SHORTCUT_HINTS_IN_STATUS_BAR = True DEFAULT_STATUS_BAR_BELOW_PREVIEW = False DEFAULT_STATUS_BAR_STYLE = ("fg_yellow", "bg_black") MIN_VISIBLE_MENU_ENTRIES_COUNT = 3 class InvalidParameterCombinationError(Exception): pass class InvalidStyleError(Exception): pass class NoMenuEntriesError(Exception): pass class PreviewCommandFailedError(Exception): pass class UnknownMenuEntryError(Exception): pass def get_locale() -> str: user_locale = locale.getlocale()[1] if user_locale is None: return "ascii" else: return user_locale.lower() def wcswidth(text: str) -> int: if not hasattr(wcswidth, "libc"): try: if platform.system() == "Darwin": wcswidth.libc = ctypes.cdll.LoadLibrary("libSystem.dylib") # type: ignore else: wcswidth.libc = ctypes.cdll.LoadLibrary("libc.so.6") # type: ignore except OSError: wcswidth.libc = None # type: ignore if wcswidth.libc is not None: # type: ignore try: user_locale = get_locale() # First replace any null characters with the unicode replacement character (U+FFFD) since they cannot be # passed in a `c_wchar_p` encoded_text = text.replace("\0", "\uFFFD").encode(encoding=user_locale, errors="replace") return wcswidth.libc.wcswidth( # type: ignore ctypes.c_wchar_p(encoded_text.decode(encoding=user_locale)), len(encoded_text) ) except AttributeError: pass return len(text) def static_variables(**variables: Any) -> Callable[[Callable[..., Any]], Callable[..., Any]]: def decorator(f: Callable[..., Any]) -> Callable[..., Any]: for key, value in variables.items(): setattr(f, key, value) return f return decorator class BoxDrawingCharacters: if getlocale()[1] == "UTF-8": # Unicode box characters horizontal = "─" vertical = "│" upper_left = "┌" upper_right = "┐" lower_left = "└" lower_right = "┘" else: # ASCII box characters horizontal = "-" vertical = "|" upper_left = "+" upper_right = "+" lower_left = "+" lower_right = "+" class TerminalMenu: class Search: def __init__( self, menu_entries: Iterable[str], search_text: Optional[str] = None, case_senitive: bool = False, show_search_hint: bool = False, ): self._menu_entries = menu_entries self._case_sensitive = case_senitive self._show_search_hint = show_search_hint self._matches = [] # type: List[Tuple[int, Match[str]]] self._search_regex = None # type: Optional[Pattern[str]] self._change_callback = None # type: Optional[Callable[[], None]] # Use the property setter since it has some more logic self.search_text = search_text def _update_matches(self) -> None: if self._search_regex is None: self._matches = [] else: matches = [] for i, menu_entry in enumerate(self._menu_entries): match_obj = self._search_regex.search(menu_entry) if match_obj: matches.append((i, match_obj)) self._matches = matches @property def matches(self) -> List[Tuple[int, Match[str]]]: return list(self._matches) @property def search_regex(self) -> Optional[Pattern[str]]: return self._search_regex @property def search_text(self) -> Optional[str]: return self._search_text @search_text.setter def search_text(self, text: Optional[str]) -> None: self._search_text = text search_text = self._search_text self._search_regex = None while search_text and self._search_regex is None: try: self._search_regex = re.compile(search_text, flags=re.IGNORECASE if not self._case_sensitive else 0) except re.error: search_text = search_text[:-1] self._update_matches() if self._change_callback: self._change_callback() @property def change_callback(self) -> Optional[Callable[[], None]]: return self._change_callback @change_callback.setter def change_callback(self, callback: Optional[Callable[[], None]]) -> None: self._change_callback = callback @property def occupied_lines_count(self) -> int: if not self and not self._show_search_hint: return 0 else: return 1 def __bool__(self) -> bool: return self._search_text is not None def __contains__(self, menu_index: int) -> bool: return any(i == menu_index for i, _ in self._matches) def __len__(self) -> int: return wcswidth(self._search_text) if self._search_text is not None else 0 class Selection: def __init__(self, preselected_indices: Optional[Iterable[int]] = None): self._selected_menu_indices = set(preselected_indices) if preselected_indices is not None else set() def clear(self) -> None: self._selected_menu_indices.clear() def add(self, menu_index: int) -> None: self[menu_index] = True def remove(self, menu_index: int) -> None: self[menu_index] = False def toggle(self, menu_index: int) -> bool: self[menu_index] = menu_index not in self._selected_menu_indices return self[menu_index] def __bool__(self) -> bool: return bool(self._selected_menu_indices) def __contains__(self, menu_index: int) -> bool: return menu_index in self._selected_menu_indices def __getitem__(self, menu_index: int) -> bool: return menu_index in self._selected_menu_indices def __setitem__(self, menu_index: int, is_selected: bool) -> None: if is_selected: self._selected_menu_indices.add(menu_index) else: self._selected_menu_indices.remove(menu_index) def __iter__(self) -> Iterator[int]: return iter(self._selected_menu_indices) @property def selected_menu_indices(self) -> Tuple[int, ...]: return tuple(sorted(self._selected_menu_indices)) class View: def __init__( self, menu_entries: Iterable[str], search: "TerminalMenu.Search", selection: "TerminalMenu.Selection", viewport: "TerminalMenu.Viewport", cycle_cursor: bool = True, skip_indices: List[int] = [], ): self._menu_entries = list(menu_entries) self._search = search self._selection = selection self._viewport = viewport self._cycle_cursor = cycle_cursor self._active_displayed_index = None # type: Optional[int] self._skip_indices = skip_indices self.update_view() def update_view(self) -> None: if self._search and self._search.search_text != "": self._displayed_index_to_menu_index = tuple(i for i, match_obj in self._search.matches) else: self._displayed_index_to_menu_index = tuple(range(len(self._menu_entries))) self._menu_index_to_displayed_index = { menu_index: displayed_index for displayed_index, menu_index in enumerate(self._displayed_index_to_menu_index) } self._active_displayed_index = 0 if self._displayed_index_to_menu_index else None self._viewport.num_displayed_menu_entries = len(self._displayed_index_to_menu_index) self._viewport.search_lines_count = self._search.occupied_lines_count self._viewport.keep_visible(self._active_displayed_index) def increment_active_index(self) -> None: if self._active_displayed_index is not None: if self._active_displayed_index + 1 < self._viewport.num_displayed_menu_entries: self._active_displayed_index += 1 elif self._cycle_cursor: self._active_displayed_index = 0 self._viewport.keep_visible(self._active_displayed_index) if self._displayed_index_to_menu_index[self._active_displayed_index] in self._skip_indices: self.increment_active_index() def decrement_active_index(self) -> None: if self._active_displayed_index is not None: if self._active_displayed_index > 0: self._active_displayed_index -= 1 elif self._cycle_cursor: self._active_displayed_index = self._viewport.num_displayed_menu_entries - 1 self._viewport.keep_visible(self._active_displayed_index) if self._displayed_index_to_menu_index[self._active_displayed_index] in self._skip_indices: self.decrement_active_index() def page_down(self) -> None: if self._active_displayed_index is None: return self._viewport.page_down() self._active_displayed_index = min( self._active_displayed_index + self._viewport.size, self._viewport.num_displayed_menu_entries - 1 ) def page_up(self) -> None: if self._active_displayed_index is None: return self._viewport.page_up() self._active_displayed_index = max(self._active_displayed_index - self._viewport.size, 0) def is_visible(self, menu_index: int) -> bool: return menu_index in self._menu_index_to_displayed_index and ( self._viewport.lower_index <= self._menu_index_to_displayed_index[menu_index] <= self._viewport.upper_index ) def convert_menu_index_to_displayed_index(self, menu_index: int) -> Optional[int]: if menu_index in self._menu_index_to_displayed_index: return self._menu_index_to_displayed_index[menu_index] else: return None def convert_displayed_index_to_menu_index(self, displayed_index: int) -> int: return self._displayed_index_to_menu_index[displayed_index] @property def active_menu_index(self) -> Optional[int]: if self._active_displayed_index is not None: return self._displayed_index_to_menu_index[self._active_displayed_index] else: return None @active_menu_index.setter def active_menu_index(self, value: int) -> None: self.active_displayed_index = self._menu_index_to_displayed_index[value] @property def active_displayed_index(self) -> Optional[int]: return self._active_displayed_index @active_displayed_index.setter def active_displayed_index(self, value: int) -> None: self._active_displayed_index = value self._viewport.keep_visible(self._active_displayed_index) @property def max_displayed_index(self) -> int: return self._viewport.num_displayed_menu_entries - 1 @property def displayed_selected_indices(self) -> List[int]: return [ self._menu_index_to_displayed_index[selected_index] for selected_index in self._selection if selected_index in self._menu_index_to_displayed_index ] def __bool__(self) -> bool: return self._active_displayed_index is not None def __iter__(self) -> Iterator[Tuple[int, int, str]]: for displayed_index, menu_index in enumerate(self._displayed_index_to_menu_index): if self._viewport.lower_index <= displayed_index <= self._viewport.upper_index: yield (displayed_index, menu_index, self._menu_entries[menu_index]) class Viewport: def __init__( self, num_displayed_menu_entries: int, title_lines_count: int, status_bar_lines_count: int, preview_lines_count: int, search_lines_count: int, ): self._num_displayed_menu_entries = num_displayed_menu_entries self._title_lines_count = title_lines_count self._status_bar_lines_count = status_bar_lines_count # Use the property setter since it has some more logic self.preview_lines_count = preview_lines_count self.search_lines_count = search_lines_count self._num_lines = self._calculate_num_lines() self._viewport = (0, min(self._num_displayed_menu_entries, self._num_lines) - 1) self.keep_visible(cursor_position=None, refresh_terminal_size=False) def _calculate_num_lines(self) -> int: return ( TerminalMenu._num_lines() - self._title_lines_count - self._status_bar_lines_count - self._preview_lines_count - self._search_lines_count ) def keep_visible(self, cursor_position: Optional[int], refresh_terminal_size: bool = True) -> None: # Treat `cursor_position=None` like `cursor_position=0` if cursor_position is None: cursor_position = 0 if refresh_terminal_size: self.update_terminal_size() if self._viewport[0] <= cursor_position <= self._viewport[1]: # Cursor is already visible return if cursor_position < self._viewport[0]: scroll_num = cursor_position - self._viewport[0] else: scroll_num = cursor_position - self._viewport[1] self._viewport = (self._viewport[0] + scroll_num, self._viewport[1] + scroll_num) def page_down(self) -> None: self.scroll(self.size) def page_up(self) -> None: self.scroll(-self.size) def scroll(self, number_of_lines: int) -> None: if number_of_lines < 0: scroll_num = max(-self._viewport[0], number_of_lines) else: scroll_num = min(max(0, self._num_displayed_menu_entries - self._viewport[1] - 1), number_of_lines) self._viewport = (self._viewport[0] + scroll_num, self._viewport[1] + scroll_num) def update_terminal_size(self) -> None: num_lines = self._calculate_num_lines() if num_lines != self._num_lines: # First let the upper index grow or shrink upper_index = min(num_lines, self._num_displayed_menu_entries) - 1 # Then, use as much space as possible for the `lower_index` lower_index = max(0, upper_index - num_lines) self._viewport = (lower_index, upper_index) self._num_lines = num_lines @property def lower_index(self) -> int: return self._viewport[0] @property def upper_index(self) -> int: return self._viewport[1] @property def viewport(self) -> Tuple[int, int]: return self._viewport @property def size(self) -> int: return self._viewport[1] - self._viewport[0] + 1 @property def num_displayed_menu_entries(self) -> int: return self._num_displayed_menu_entries @num_displayed_menu_entries.setter def num_displayed_menu_entries(self, num_displayed_menu_entries: int) -> None: self._num_displayed_menu_entries = num_displayed_menu_entries @property def title_lines_count(self) -> int: return self._title_lines_count @property def status_bar_lines_count(self) -> int: return self._status_bar_lines_count @status_bar_lines_count.setter def status_bar_lines_count(self, value: int) -> None: self._status_bar_lines_count = value @property def preview_lines_count(self) -> int: return self._preview_lines_count @preview_lines_count.setter def preview_lines_count(self, value: int) -> None: self._preview_lines_count = min( value if value >= 3 else 0, TerminalMenu._num_lines() - self._title_lines_count - self._status_bar_lines_count - MIN_VISIBLE_MENU_ENTRIES_COUNT, ) @property def search_lines_count(self) -> int: return self._search_lines_count @search_lines_count.setter def search_lines_count(self, value: int) -> None: self._search_lines_count = value @property def must_scroll(self) -> bool: return self._num_displayed_menu_entries > self._num_lines _codename_to_capname = { "bg_black": "setab 0", "bg_blue": "setab 4", "bg_cyan": "setab 6", "bg_gray": "setab 7", "bg_green": "setab 2", "bg_purple": "setab 5", "bg_red": "setab 1", "bg_yellow": "setab 3", "bold": "bold", "clear": "clear", "colors": "colors", "cursor_down": "cud1", "cursor_invisible": "civis", "cursor_left": "cub1", "cursor_right": "cuf1", "cursor_up": "cuu1", "cursor_visible": "cnorm", "delete_line": "dl1", "down": "kcud1", "end": "kend", "enter_application_mode": "smkx", "exit_application_mode": "rmkx", "fg_black": "setaf 0", "fg_blue": "setaf 4", "fg_cyan": "setaf 6", "fg_gray": "setaf 7", "fg_green": "setaf 2", "fg_purple": "setaf 5", "fg_red": "setaf 1", "fg_yellow": "setaf 3", "home": "khome", "italics": "sitm", "page_down": "knp", "page_up": "kpp", "reset_attributes": "sgr0", "standout": "smso", "underline": "smul", "up": "kcuu1", } _name_to_control_character = { "backspace": "", # Is assigned later in `self._init_backspace_control_character` "ctrl-a": "\001", "ctrl-b": "\002", "ctrl-e": "\005", "ctrl-f": "\006", "ctrl-g": "\007", "ctrl-j": "\012", "ctrl-k": "\013", "ctrl-n": "\016", "ctrl-p": "\020", "enter": "\015", "escape": "\033", "tab": "\t", } _codenames = tuple(_codename_to_capname.keys()) _codename_to_terminal_code = None # type: Optional[Dict[str, str]] _terminal_code_to_codename = None # type: Optional[Dict[str, str]] def __init__( self, menu_entries: Iterable[str], *, accept_keys: Iterable[str] = DEFAULT_ACCEPT_KEYS, clear_menu_on_exit: bool = DEFAULT_CLEAR_MENU_ON_EXIT, clear_screen: bool = DEFAULT_CLEAR_SCREEN, cursor_index: Optional[int] = None, cycle_cursor: bool = DEFAULT_CYCLE_CURSOR, exit_on_shortcut: bool = DEFAULT_EXIT_ON_SHORTCUT, menu_cursor: Optional[str] = DEFAULT_MENU_CURSOR, menu_cursor_style: Optional[Iterable[str]] = DEFAULT_MENU_CURSOR_STYLE, menu_highlight_style: Optional[Iterable[str]] = DEFAULT_MENU_HIGHLIGHT_STYLE, multi_select: bool = DEFAULT_MULTI_SELECT, multi_select_cursor: str = DEFAULT_MULTI_SELECT_CURSOR, multi_select_cursor_brackets_style: Optional[Iterable[str]] = DEFAULT_MULTI_SELECT_CURSOR_BRACKETS_STYLE, multi_select_cursor_style: Optional[Iterable[str]] = DEFAULT_MULTI_SELECT_CURSOR_STYLE, multi_select_empty_ok: bool = False, multi_select_keys: Optional[Iterable[str]] = DEFAULT_MULTI_SELECT_KEYS, multi_select_select_on_accept: bool = DEFAULT_MULTI_SELECT_SELECT_ON_ACCEPT, preselected_entries: Optional[Iterable[Union[str, int]]] = None, preview_border: bool = DEFAULT_PREVIEW_BORDER, preview_command: Optional[Union[str, Callable[[str], str]]] = None, preview_size: float = DEFAULT_PREVIEW_SIZE, preview_title: str = DEFAULT_PREVIEW_TITLE, quit_keys: Iterable[str] = DEFAULT_QUIT_KEYS, raise_error_on_interrupt: bool = False, search_case_sensitive: bool = DEFAULT_SEARCH_CASE_SENSITIVE, search_highlight_style: Optional[Iterable[str]] = DEFAULT_SEARCH_HIGHLIGHT_STYLE, search_key: Optional[str] = DEFAULT_SEARCH_KEY, shortcut_brackets_highlight_style: Optional[Iterable[str]] = DEFAULT_SHORTCUT_BRACKETS_HIGHLIGHT_STYLE, shortcut_key_highlight_style: Optional[Iterable[str]] = DEFAULT_SHORTCUT_KEY_HIGHLIGHT_STYLE, show_multi_select_hint: bool = DEFAULT_SHOW_MULTI_SELECT_HINT, show_multi_select_hint_text: Optional[str] = None, show_search_hint: bool = DEFAULT_SHOW_SEARCH_HINT, show_search_hint_text: Optional[str] = None, show_shortcut_hints: bool = DEFAULT_SHOW_SHORTCUT_HINTS, show_shortcut_hints_in_status_bar: bool = DEFAULT_SHOW_SHORTCUT_HINTS_IN_STATUS_BAR, skip_empty_entries: bool = False, status_bar: Optional[Union[str, Iterable[str], Callable[[str], str]]] = None, status_bar_below_preview: bool = DEFAULT_STATUS_BAR_BELOW_PREVIEW, status_bar_style: Optional[Iterable[str]] = DEFAULT_STATUS_BAR_STYLE, title: Optional[Union[str, Iterable[str]]] = None ): def check_for_terminal_environment() -> None: if "TERM" not in os.environ or os.environ["TERM"] == "": if "PYCHARM_HOSTED" in os.environ: raise NotImplementedError( "simple-term-menu does not work in the PyCharm output console. Use a terminal instead (Alt + " 'F12) or activate "Emulate terminal in output console".' ) raise NotImplementedError("simple-term-menu can only be used in a terminal emulator") def extract_shortcuts_menu_entries_and_preview_arguments( entries: Iterable[str], ) -> Tuple[List[str], List[Optional[str]], List[Optional[str]], List[int]]: separator_pattern = re.compile(r"([^\\])\|") escaped_separator_pattern = re.compile(r"\\\|") menu_entry_pattern = re.compile(r"^(?:\[(\S)\]\s*)?([^\x1F]+)(?:\x1F([^\x1F]*))?") shortcut_keys = [] # type: List[Optional[str]] menu_entries = [] # type: List[str] preview_arguments = [] # type: List[Optional[str]] skip_indices = [] # type: List[int] for idx, entry in enumerate(entries): if entry is None or (entry == "" and skip_empty_entries): shortcut_keys.append(None) menu_entries.append("") preview_arguments.append(None) skip_indices.append(idx) else: unit_separated_entry = escaped_separator_pattern.sub("|", separator_pattern.sub("\\1\x1F", entry)) match_obj = menu_entry_pattern.match(unit_separated_entry) # this is none in case the entry was an emtpy string which # will be interpreted as a separator assert match_obj is not None shortcut_key = match_obj.group(1) display_text = match_obj.group(2) preview_argument = match_obj.group(3) shortcut_keys.append(shortcut_key) menu_entries.append(display_text) preview_arguments.append(preview_argument) return menu_entries, shortcut_keys, preview_arguments, skip_indices def convert_preselected_entries_to_indices( preselected_indices_or_entries: Iterable[Union[str, int]] ) -> Set[int]: menu_entry_to_indices = {} # type: Dict[str, Set[int]] for menu_index, menu_entry in enumerate(self._menu_entries): menu_entry_to_indices.setdefault(menu_entry, set()) menu_entry_to_indices[menu_entry].add(menu_index) preselected_indices = set() for item in preselected_indices_or_entries: if isinstance(item, int): if 0 <= item < len(self._menu_entries): preselected_indices.add(item) else: raise IndexError( "Error: {} is outside the allowable range of 0..{}.".format( item, len(self._menu_entries) - 1 ) ) elif isinstance(item, str): try: preselected_indices.update(menu_entry_to_indices[item]) except KeyError as e: raise UnknownMenuEntryError('Pre-selection "{}" is not a valid menu entry.'.format(item)) from e else: raise ValueError('"preselected_entries" must either contain integers or strings.') return preselected_indices def setup_title_or_status_bar_lines( title_or_status_bar: Optional[Union[str, Iterable[str]]], show_shortcut_hints: bool, menu_entries: Iterable[str], shortcut_keys: Iterable[Optional[str]], shortcut_hints_in_parentheses: bool, ) -> Tuple[str, ...]: if title_or_status_bar is None: lines = [] # type: List[str] elif isinstance(title_or_status_bar, str): lines = title_or_status_bar.split("\n") else: lines = list(title_or_status_bar) if show_shortcut_hints: shortcut_hints_line = self._get_shortcut_hints_line( menu_entries, shortcut_keys, shortcut_hints_in_parentheses ) if shortcut_hints_line is not None: lines.append(shortcut_hints_line) return tuple(lines) check_for_terminal_environment() ( self._menu_entries, self._shortcut_keys, self._preview_arguments, self._skip_indices, ) = extract_shortcuts_menu_entries_and_preview_arguments(menu_entries) self._shortcuts_defined = any(key is not None for key in self._shortcut_keys) self._accept_keys = tuple(accept_keys) self._clear_menu_on_exit = clear_menu_on_exit self._clear_screen = clear_screen self._cycle_cursor = cycle_cursor self._multi_select_empty_ok = multi_select_empty_ok self._exit_on_shortcut = exit_on_shortcut self._menu_cursor = menu_cursor if menu_cursor is not None else "" self._menu_cursor_style = tuple(menu_cursor_style) if menu_cursor_style is not None else () self._menu_highlight_style = tuple(menu_highlight_style) if menu_highlight_style is not None else () self._multi_select = multi_select self._multi_select_cursor = multi_select_cursor self._multi_select_cursor_brackets_style = ( tuple(multi_select_cursor_brackets_style) if multi_select_cursor_brackets_style is not None else () ) self._multi_select_cursor_style = ( tuple(multi_select_cursor_style) if multi_select_cursor_style is not None else () ) self._multi_select_keys = tuple(multi_select_keys) if multi_select_keys is not None else () self._multi_select_select_on_accept = multi_select_select_on_accept if preselected_entries and not self._multi_select: raise InvalidParameterCombinationError( "Multi-select mode must be enabled when preselected entries are given." ) self._preselected_indices = ( convert_preselected_entries_to_indices(preselected_entries) if preselected_entries is not None else None ) self._preview_border = preview_border self._preview_command = preview_command self._preview_size = preview_size self._preview_title = preview_title self._quit_keys = tuple(quit_keys) self._raise_error_on_interrupt = raise_error_on_interrupt self._search_case_sensitive = search_case_sensitive self._search_highlight_style = tuple(search_highlight_style) if search_highlight_style is not None else () self._search_key = search_key self._shortcut_brackets_highlight_style = ( tuple(shortcut_brackets_highlight_style) if shortcut_brackets_highlight_style is not None else () ) self._shortcut_key_highlight_style = ( tuple(shortcut_key_highlight_style) if shortcut_key_highlight_style is not None else () ) self._show_search_hint = show_search_hint self._show_search_hint_text = show_search_hint_text self._show_shortcut_hints = show_shortcut_hints self._show_shortcut_hints_in_status_bar = show_shortcut_hints_in_status_bar self._status_bar_func = None # type: Optional[Callable[[str], str]] self._status_bar_lines = None # type: Optional[Tuple[str, ...]] if callable(status_bar): self._status_bar_func = status_bar else: self._status_bar_lines = setup_title_or_status_bar_lines( status_bar, show_shortcut_hints and show_shortcut_hints_in_status_bar, self._menu_entries, self._shortcut_keys, False, ) self._status_bar_below_preview = status_bar_below_preview self._status_bar_style = tuple(status_bar_style) if status_bar_style is not None else () self._title_lines = setup_title_or_status_bar_lines( title, show_shortcut_hints and not show_shortcut_hints_in_status_bar, self._menu_entries, self._shortcut_keys, True, ) self._show_multi_select_hint = show_multi_select_hint self._show_multi_select_hint_text = show_multi_select_hint_text self._chosen_accept_key = None # type: Optional[str] self._chosen_menu_index = None # type: Optional[int] self._chosen_menu_indices = None # type: Optional[Tuple[int, ...]] self._paint_before_next_read = False self._previous_displayed_menu_height = None # type: Optional[int] self._reading_next_key = False self._search = self.Search( self._menu_entries, case_senitive=self._search_case_sensitive, show_search_hint=self._show_search_hint, ) self._selection = self.Selection(self._preselected_indices) self._viewport = self.Viewport( len(self._menu_entries), len(self._title_lines), len(self._status_bar_lines) if self._status_bar_lines is not None else 0, 0, 0, ) self._view = self.View( self._menu_entries, self._search, self._selection, self._viewport, self._cycle_cursor, self._skip_indices ) if cursor_index and 0 < cursor_index < len(self._menu_entries): self._view.active_menu_index = cursor_index self._search.change_callback = self._view.update_view self._old_term = None # type: Optional[List[Union[int, List[bytes]]]] self._new_term = None # type: Optional[List[Union[int, List[bytes]]]] self._tty_in = None # type: Optional[TextIO] self._tty_out = None # type: Optional[TextIO] self._user_locale = get_locale() self._check_for_valid_styles() # backspace can be queried from the terminal database but is unreliable, query the terminal directly instead self._init_backspace_control_character() self._add_missing_control_characters_for_keys(self._accept_keys) self._add_missing_control_characters_for_keys(self._quit_keys) self._init_terminal_codes() @staticmethod def _get_shortcut_hints_line( menu_entries: Iterable[str], shortcut_keys: Iterable[Optional[str]], shortcut_hints_in_parentheses: bool, ) -> Optional[str]: shortcut_hints_line = ", ".join( "[{}]: {}".format(shortcut_key, menu_entry) for shortcut_key, menu_entry in zip(shortcut_keys, menu_entries) if shortcut_key is not None ) if shortcut_hints_line != "": if shortcut_hints_in_parentheses: return "(" + shortcut_hints_line + ")" else: return shortcut_hints_line return None @staticmethod def _get_keycode_for_key(key: str) -> str: if len(key) == 1: # One letter keys represent themselves return key alt_modified_regex = re.compile(r"[Aa]lt-(\S)") ctrl_modified_regex = re.compile(r"[Cc]trl-(\S)") match_obj = alt_modified_regex.match(key) if match_obj: return "\033" + match_obj.group(1) match_obj = ctrl_modified_regex.match(key) if match_obj: # Ctrl + key is interpreted by terminals as the ascii code of that key minus 64 ctrl_code_ascii = ord(match_obj.group(1).upper()) - 64 if ctrl_code_ascii < 0: # Interpret negative ascii codes as unsigned 7-Bit integers ctrl_code_ascii = ctrl_code_ascii & 0x80 - 1 return chr(ctrl_code_ascii) raise ValueError('Cannot interpret the given key "{}".'.format(key)) @classmethod def _init_backspace_control_character(self) -> None: try: with open("/dev/tty", "r") as tty: stty_output = subprocess.check_output(["stty", "-a"], universal_newlines=True, stdin=tty) name_to_keycode_regex = re.compile(r"^\s*(\S+)\s*=\s*\^(\S+)\s*$") for field in stty_output.split(";"): match_obj = name_to_keycode_regex.match(field) if not match_obj: continue name, ctrl_code = match_obj.group(1), match_obj.group(2) if name != "erase": continue self._name_to_control_character["backspace"] = self._get_keycode_for_key("ctrl-" + ctrl_code) return except subprocess.CalledProcessError: pass # Backspace control character could not be queried, assume `` (is most often used) self._name_to_control_character["backspace"] = "\177" @classmethod def _add_missing_control_characters_for_keys(cls, keys: Iterable[str]) -> None: for key in keys: if key not in cls._name_to_control_character and key not in string.ascii_letters: cls._name_to_control_character[key] = cls._get_keycode_for_key(key) @classmethod def _init_terminal_codes(cls) -> None: if cls._codename_to_terminal_code is not None: return supported_colors = int(cls._query_terminfo_database("colors")) cls._codename_to_terminal_code = { codename: ( cls._query_terminfo_database(codename) if not (codename.startswith("bg_") or codename.startswith("fg_")) or supported_colors >= 8 else "" ) for codename in cls._codenames } cls._codename_to_terminal_code.update(cls._name_to_control_character) cls._terminal_code_to_codename = { terminal_code: codename for codename, terminal_code in cls._codename_to_terminal_code.items() } @classmethod def _query_terminfo_database(cls, codename: str) -> str: if codename in cls._codename_to_capname: capname = cls._codename_to_capname[codename] else: capname = codename try: return subprocess.check_output(["tput"] + capname.split(), universal_newlines=True) except subprocess.CalledProcessError as e: # The return code 1 indicates a missing terminal capability if e.returncode == 1: return "" raise e @classmethod def _num_lines(self) -> int: return int(self._query_terminfo_database("lines")) @classmethod def _num_cols(self) -> int: return int(self._query_terminfo_database("cols")) def _check_for_valid_styles(self) -> None: invalid_styles = [] for style_tuple in ( self._menu_cursor_style, self._menu_highlight_style, self._search_highlight_style, self._shortcut_key_highlight_style, self._shortcut_brackets_highlight_style, self._status_bar_style, self._multi_select_cursor_brackets_style, self._multi_select_cursor_style, ): for style in style_tuple: if style not in self._codename_to_capname: invalid_styles.append(style) if invalid_styles: if len(invalid_styles) == 1: raise InvalidStyleError('The style "{}" does not exist.'.format(invalid_styles[0])) else: raise InvalidStyleError('The styles ("{}") do not exist.'.format('", "'.join(invalid_styles))) def _init_term(self) -> None: # pylint: disable=unsubscriptable-object assert self._codename_to_terminal_code is not None self._tty_in = open("/dev/tty", "r", encoding=self._user_locale) self._tty_out = open("/dev/tty", "w", encoding=self._user_locale, errors="replace") self._old_term = termios.tcgetattr(self._tty_in.fileno()) self._new_term = termios.tcgetattr(self._tty_in.fileno()) # set the terminal to: no line-buffering, no echo and no to translation (so sends instead # of and since generates ) self._new_term[3] = cast(int, self._new_term[3]) & ~termios.ICANON & ~termios.ECHO & ~termios.ICRNL self._new_term[0] = cast(int, self._new_term[0]) & ~termios.ICRNL # Set the timings for an unbuffered read: Return immediately after at least one character has arrived and don't # wait for further characters cast(List[bytes], self._new_term[6])[termios.VMIN] = b"\x01" cast(List[bytes], self._new_term[6])[termios.VTIME] = b"\x00" termios.tcsetattr( self._tty_in.fileno(), termios.TCSAFLUSH, cast(List[Union[int, List[Union[bytes, int]]]], self._new_term) ) # Enter terminal application mode to get expected escape codes for arrow keys self._tty_out.write(self._codename_to_terminal_code["enter_application_mode"]) self._tty_out.write(self._codename_to_terminal_code["cursor_invisible"]) if self._clear_screen: self._tty_out.write(self._codename_to_terminal_code["clear"]) def _reset_term(self) -> None: # pylint: disable=unsubscriptable-object assert self._codename_to_terminal_code is not None assert self._tty_in is not None assert self._tty_out is not None assert self._old_term is not None termios.tcsetattr( self._tty_out.fileno(), termios.TCSAFLUSH, cast(List[Union[int, List[Union[bytes, int]]]], self._old_term) ) self._tty_out.write(self._codename_to_terminal_code["cursor_visible"]) self._tty_out.write(self._codename_to_terminal_code["exit_application_mode"]) if self._clear_screen: self._tty_out.write(self._codename_to_terminal_code["clear"]) self._tty_in.close() self._tty_out.close() def _paint_menu(self) -> None: def get_status_bar_lines() -> Tuple[str, ...]: def get_multi_select_hint() -> str: def get_string_from_keys(keys: Sequence[str]) -> str: string_to_key = { " ": "space", } keys_string = ", ".join( "<" + string_to_key.get(accept_key, accept_key) + ">" for accept_key in keys ) return keys_string accept_keys_string = get_string_from_keys(self._accept_keys) multi_select_keys_string = get_string_from_keys(self._multi_select_keys) if self._show_multi_select_hint_text is not None: return self._show_multi_select_hint_text.format( multi_select_keys=multi_select_keys_string, accept_keys=accept_keys_string ) else: return "Press {} for multi-selection and {} to {}accept".format( multi_select_keys_string, accept_keys_string, "select and " if self._multi_select_select_on_accept else "", ) if self._status_bar_func is not None and self._view.active_menu_index is not None: status_bar_lines = tuple( self._status_bar_func(self._menu_entries[self._view.active_menu_index]).strip().split("\n") ) if self._show_shortcut_hints and self._show_shortcut_hints_in_status_bar: shortcut_hints_line = self._get_shortcut_hints_line(self._menu_entries, self._shortcut_keys, False) if shortcut_hints_line is not None: status_bar_lines += (shortcut_hints_line,) elif self._status_bar_lines is not None: status_bar_lines = self._status_bar_lines else: status_bar_lines = tuple() if self._multi_select and self._show_multi_select_hint: status_bar_lines += (get_multi_select_hint(),) return status_bar_lines def apply_style( style_iterable: Optional[Iterable[str]] = None, reset: bool = True, file: Optional[TextIO] = None ) -> None: # pylint: disable=unsubscriptable-object assert self._codename_to_terminal_code is not None assert self._tty_out is not None if file is None: file = self._tty_out if reset or style_iterable is None: file.write(self._codename_to_terminal_code["reset_attributes"]) if style_iterable is not None: for style in style_iterable: file.write(self._codename_to_terminal_code[style]) def print_menu_entries() -> int: # pylint: disable=unsubscriptable-object assert self._codename_to_terminal_code is not None assert self._tty_out is not None all_cursors_width = wcswidth(self._menu_cursor) + ( wcswidth(self._multi_select_cursor) if self._multi_select else 0 ) current_menu_block_displayed_height = 0 # sum all written lines num_cols = self._num_cols() if self._title_lines: self._tty_out.write( len(self._title_lines) * self._codename_to_terminal_code["cursor_up"] + "\r" + "\n".join( (title_line[:num_cols] + (num_cols - wcswidth(title_line)) * " ") for title_line in self._title_lines ) + "\n" ) shortcut_string_len = 4 if self._shortcuts_defined else 0 displayed_index = -1 for displayed_index, menu_index, menu_entry in self._view: current_shortcut_key = self._shortcut_keys[menu_index] self._tty_out.write(all_cursors_width * self._codename_to_terminal_code["cursor_right"]) if self._shortcuts_defined: if current_shortcut_key is not None: apply_style(self._shortcut_brackets_highlight_style) self._tty_out.write("[") apply_style(self._shortcut_key_highlight_style) self._tty_out.write(current_shortcut_key) apply_style(self._shortcut_brackets_highlight_style) self._tty_out.write("]") apply_style() else: self._tty_out.write(3 * " ") self._tty_out.write(" ") if menu_index == self._view.active_menu_index: apply_style(self._menu_highlight_style) if self._search and self._search.search_text != "": match_obj = self._search.matches[displayed_index][1] self._tty_out.write( menu_entry[: min(match_obj.start(), num_cols - all_cursors_width - shortcut_string_len)] ) apply_style(self._search_highlight_style) self._tty_out.write( menu_entry[ match_obj.start() : min(match_obj.end(), num_cols - all_cursors_width - shortcut_string_len) ] ) apply_style() if menu_index == self._view.active_menu_index: apply_style(self._menu_highlight_style) self._tty_out.write( menu_entry[match_obj.end() : num_cols - all_cursors_width - shortcut_string_len] ) else: self._tty_out.write(menu_entry[: num_cols - all_cursors_width - shortcut_string_len]) if menu_index == self._view.active_menu_index: apply_style() self._tty_out.write((num_cols - wcswidth(menu_entry) - all_cursors_width - shortcut_string_len) * " ") if displayed_index < self._viewport.upper_index: self._tty_out.write("\n") empty_menu_lines = self._viewport.upper_index - displayed_index self._tty_out.write( max(0, empty_menu_lines - 1) * (num_cols * " " + "\n") + min(1, empty_menu_lines) * (num_cols * " ") ) self._tty_out.write("\r" + (self._viewport.size - 1) * self._codename_to_terminal_code["cursor_up"]) current_menu_block_displayed_height += self._viewport.size - 1 # sum all written lines return current_menu_block_displayed_height def print_search_line(current_menu_height: int) -> int: # pylint: disable=unsubscriptable-object assert self._codename_to_terminal_code is not None assert self._tty_out is not None current_menu_block_displayed_height = 0 num_cols = self._num_cols() if self._search or self._show_search_hint: self._tty_out.write((current_menu_height + 1) * self._codename_to_terminal_code["cursor_down"]) if self._search: assert self._search.search_text is not None self._tty_out.write( ( (self._search_key if self._search_key is not None else DEFAULT_SEARCH_KEY) + self._search.search_text )[:num_cols] ) self._tty_out.write((num_cols - len(self._search) - 1) * " ") elif self._show_search_hint: if self._show_search_hint_text is not None: search_hint = self._show_search_hint_text.format(key=self._search_key)[:num_cols] elif self._search_key is not None: search_hint = '(Press "{key}" to search)'.format(key=self._search_key)[:num_cols] else: search_hint = "(Press any letter key to search)"[:num_cols] self._tty_out.write(search_hint) self._tty_out.write((num_cols - wcswidth(search_hint)) * " ") if self._search or self._show_search_hint: self._tty_out.write("\r" + (current_menu_height + 1) * self._codename_to_terminal_code["cursor_up"]) current_menu_block_displayed_height = 1 return current_menu_block_displayed_height def print_status_bar(current_menu_height: int, status_bar_lines: Tuple[str, ...]) -> int: # pylint: disable=unsubscriptable-object assert self._codename_to_terminal_code is not None assert self._tty_out is not None current_menu_block_displayed_height = 0 # sum all written lines num_cols = self._num_cols() if status_bar_lines: self._tty_out.write((current_menu_height + 1) * self._codename_to_terminal_code["cursor_down"]) apply_style(self._status_bar_style) self._tty_out.write( "\r" + "\n".join( (status_bar_line[:num_cols] + (num_cols - wcswidth(status_bar_line)) * " ") for status_bar_line in status_bar_lines ) + "\r" ) apply_style() self._tty_out.write( (current_menu_height + len(status_bar_lines)) * self._codename_to_terminal_code["cursor_up"] ) current_menu_block_displayed_height += len(status_bar_lines) return current_menu_block_displayed_height def print_preview(current_menu_height: int, preview_max_num_lines: int) -> int: # pylint: disable=unsubscriptable-object assert self._codename_to_terminal_code is not None assert self._tty_out is not None if self._preview_command is None or preview_max_num_lines < 3: return 0 def get_preview_string() -> Optional[str]: assert self._preview_command is not None if self._view.active_menu_index is None: return None preview_argument = ( self._preview_arguments[self._view.active_menu_index] if self._preview_arguments[self._view.active_menu_index] is not None else self._menu_entries[self._view.active_menu_index] ) if preview_argument == "": return None if isinstance(self._preview_command, str): try: preview_process = subprocess.Popen( [cmd_part.format(preview_argument) for cmd_part in shlex.split(self._preview_command)], stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) assert preview_process.stdout is not None preview_string = ( io.TextIOWrapper(preview_process.stdout, encoding=self._user_locale, errors="replace") .read() .strip() ) except subprocess.CalledProcessError as e: raise PreviewCommandFailedError( e.stderr.decode(encoding=self._user_locale, errors="replace").strip() ) from e else: preview_string = self._preview_command(preview_argument) if preview_argument is not None else "" return preview_string @static_variables( # Regex taken from https://stackoverflow.com/a/14693789/5958465 ansi_escape_regex=re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])"), # Modified version of https://stackoverflow.com/a/2188410/5958465 ansi_sgr_regex=re.compile(r"\x1B\[[;\d]*m"), ) def strip_ansi_codes_except_styling(string: str) -> str: stripped_string = strip_ansi_codes_except_styling.ansi_escape_regex.sub( # type: ignore lambda match_obj: ( match_obj.group(0) if strip_ansi_codes_except_styling.ansi_sgr_regex.match(match_obj.group(0)) # type: ignore else "" ), string, ) return cast(str, stripped_string) @static_variables( regular_text_regex=re.compile(r"([^\x1B]+)(.*)"), ansi_escape_regex=re.compile(r"(\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]))(.*)"), ) def limit_string_with_escape_codes(string: str, max_len: int) -> Tuple[str, int]: if max_len <= 0: return "", 0 string_parts = [] string_len = 0 while string: regular_text_match = limit_string_with_escape_codes.regular_text_regex.match(string) # type: ignore if regular_text_match is not None: regular_text = regular_text_match.group(1) regular_text_len = wcswidth(regular_text) if string_len + regular_text_len > max_len: string_parts.append(regular_text[: max_len - string_len]) string_len = max_len break string_parts.append(regular_text) string_len += regular_text_len string = regular_text_match.group(2) else: ansi_escape_match = limit_string_with_escape_codes.ansi_escape_regex.match( # type: ignore string ) if ansi_escape_match is not None: # Adopt the ansi escape code but do not count its length ansi_escape_code_text = ansi_escape_match.group(1) string_parts.append(ansi_escape_code_text) string = ansi_escape_match.group(2) else: # It looks like an escape code (starts with escape), but it is something else # -> skip the escape character and continue the loop string_parts.append("\x1B") string = string[1:] return "".join(string_parts), string_len num_cols = self._num_cols() try: preview_string = get_preview_string() if preview_string is not None: preview_string = strip_ansi_codes_except_styling(preview_string) except PreviewCommandFailedError as e: preview_string = "The preview command failed with error message:\n\n" + str(e) self._tty_out.write(current_menu_height * self._codename_to_terminal_code["cursor_down"]) if preview_string is not None: self._tty_out.write(self._codename_to_terminal_code["cursor_down"] + "\r") if self._preview_border: self._tty_out.write( ( BoxDrawingCharacters.upper_left + (2 * BoxDrawingCharacters.horizontal + " " + self._preview_title)[: num_cols - 3] + " " + (num_cols - wcswidth(self._preview_title) - 6) * BoxDrawingCharacters.horizontal + BoxDrawingCharacters.upper_right )[:num_cols] + "\n" ) # `finditer` can be used as a generator version of `str.join` for i, line in enumerate( match.group(0) for match in re.finditer(r"^.*$", preview_string, re.MULTILINE) ): if i >= preview_max_num_lines - (2 if self._preview_border else 0): preview_num_lines = preview_max_num_lines break limited_line, limited_line_len = limit_string_with_escape_codes( line, num_cols - (3 if self._preview_border else 0) ) self._tty_out.write( ( ((BoxDrawingCharacters.vertical + " ") if self._preview_border else "") + limited_line + self._codename_to_terminal_code["reset_attributes"] + max(num_cols - limited_line_len - (3 if self._preview_border else 0), 0) * " " + (BoxDrawingCharacters.vertical if self._preview_border else "") ) ) else: preview_num_lines = i + (3 if self._preview_border else 1) if self._preview_border: self._tty_out.write( "\n" + ( BoxDrawingCharacters.lower_left + (num_cols - 2) * BoxDrawingCharacters.horizontal + BoxDrawingCharacters.lower_right )[:num_cols] ) self._tty_out.write("\r") else: preview_num_lines = 0 self._tty_out.write( (current_menu_height + preview_num_lines) * self._codename_to_terminal_code["cursor_up"] ) return preview_num_lines def delete_old_menu_lines(displayed_menu_height: int) -> None: # pylint: disable=unsubscriptable-object assert self._codename_to_terminal_code is not None assert self._tty_out is not None if ( self._previous_displayed_menu_height is not None and self._previous_displayed_menu_height > displayed_menu_height ): self._tty_out.write((displayed_menu_height + 1) * self._codename_to_terminal_code["cursor_down"]) self._tty_out.write( (self._previous_displayed_menu_height - displayed_menu_height) * self._codename_to_terminal_code["delete_line"] ) self._tty_out.write((displayed_menu_height + 1) * self._codename_to_terminal_code["cursor_up"]) def position_cursor() -> None: # pylint: disable=unsubscriptable-object assert self._codename_to_terminal_code is not None assert self._tty_out is not None if self._view.active_displayed_index is None: return cursor_width = wcswidth(self._menu_cursor) for displayed_index in range(self._viewport.lower_index, self._viewport.upper_index + 1): if displayed_index == self._view.active_displayed_index: apply_style(self._menu_cursor_style) self._tty_out.write(self._menu_cursor) apply_style() else: self._tty_out.write(cursor_width * " ") self._tty_out.write("\r") if displayed_index < self._viewport.upper_index: self._tty_out.write(self._codename_to_terminal_code["cursor_down"]) self._tty_out.write((self._viewport.size - 1) * self._codename_to_terminal_code["cursor_up"]) def print_multi_select_column() -> None: # pylint: disable=unsubscriptable-object assert self._codename_to_terminal_code is not None assert self._tty_out is not None if not self._multi_select: return def prepare_multi_select_cursors() -> Tuple[str, str]: bracket_characters = "([{<)]}>" bracket_style_escape_codes_io = io.StringIO() multi_select_cursor_style_escape_codes_io = io.StringIO() reset_codes_io = io.StringIO() apply_style(self._multi_select_cursor_brackets_style, file=bracket_style_escape_codes_io) apply_style(self._multi_select_cursor_style, file=multi_select_cursor_style_escape_codes_io) apply_style(file=reset_codes_io) bracket_style_escape_codes = bracket_style_escape_codes_io.getvalue() multi_select_cursor_style_escape_codes = multi_select_cursor_style_escape_codes_io.getvalue() reset_codes = reset_codes_io.getvalue() cursor_with_brackets_only = re.sub( r"[^{}]".format(re.escape(bracket_characters)), " ", self._multi_select_cursor ) cursor_with_brackets_only_styled = re.sub( r"[{}]+".format(re.escape(bracket_characters)), lambda match_obj: bracket_style_escape_codes + match_obj.group(0) + reset_codes, cursor_with_brackets_only, ) cursor_styled = re.sub( r"[{brackets}]+|[^{brackets}\s]+".format(brackets=re.escape(bracket_characters)), lambda match_obj: ( bracket_style_escape_codes if match_obj.group(0)[0] in bracket_characters else multi_select_cursor_style_escape_codes ) + match_obj.group(0) + reset_codes, self._multi_select_cursor, ) return cursor_styled, cursor_with_brackets_only_styled if not self._view: return checked_multi_select_cursor, unchecked_multi_select_cursor = prepare_multi_select_cursors() cursor_width = wcswidth(self._menu_cursor) displayed_selected_indices = self._view.displayed_selected_indices displayed_index = 0 for displayed_index, _, _ in self._view: self._tty_out.write("\r" + cursor_width * self._codename_to_terminal_code["cursor_right"]) if displayed_index in self._skip_indices: self._tty_out.write("") elif displayed_index in displayed_selected_indices: self._tty_out.write(checked_multi_select_cursor) else: self._tty_out.write(unchecked_multi_select_cursor) if displayed_index < self._viewport.upper_index: self._tty_out.write(self._codename_to_terminal_code["cursor_down"]) self._tty_out.write("\r") self._tty_out.write( (displayed_index + (1 if displayed_index < self._viewport.upper_index else 0)) * self._codename_to_terminal_code["cursor_up"] ) # pylint: disable=unsubscriptable-object assert self._codename_to_terminal_code is not None assert self._tty_out is not None displayed_menu_height = 0 # sum all written lines status_bar_lines = get_status_bar_lines() self._viewport.status_bar_lines_count = len(status_bar_lines) if self._preview_command is not None: self._viewport.preview_lines_count = int(self._preview_size * self._num_lines()) preview_max_num_lines = self._viewport.preview_lines_count self._viewport.keep_visible(self._view.active_displayed_index) displayed_menu_height += print_menu_entries() displayed_menu_height += print_search_line(displayed_menu_height) if not self._status_bar_below_preview: displayed_menu_height += print_status_bar(displayed_menu_height, status_bar_lines) if self._preview_command is not None: displayed_menu_height += print_preview(displayed_menu_height, preview_max_num_lines) if self._status_bar_below_preview: displayed_menu_height += print_status_bar(displayed_menu_height, status_bar_lines) delete_old_menu_lines(displayed_menu_height) position_cursor() if self._multi_select: print_multi_select_column() self._previous_displayed_menu_height = displayed_menu_height self._tty_out.flush() def _clear_menu(self) -> None: # pylint: disable=unsubscriptable-object assert self._codename_to_terminal_code is not None assert self._previous_displayed_menu_height is not None assert self._tty_out is not None if self._clear_menu_on_exit: if self._title_lines: self._tty_out.write(len(self._title_lines) * self._codename_to_terminal_code["cursor_up"]) self._tty_out.write(len(self._title_lines) * self._codename_to_terminal_code["delete_line"]) self._tty_out.write( (self._previous_displayed_menu_height + 1) * self._codename_to_terminal_code["delete_line"] ) else: self._tty_out.write( (self._previous_displayed_menu_height + 1) * self._codename_to_terminal_code["cursor_down"] ) self._tty_out.flush() def _read_next_key(self, ignore_case: bool = True) -> str: # pylint: disable=unsubscriptable-object,unsupported-membership-test assert self._terminal_code_to_codename is not None assert self._tty_in is not None # Needed for asynchronous handling of terminal resize events self._reading_next_key = True if self._paint_before_next_read: self._paint_menu() self._paint_before_next_read = False # blocks until any amount of bytes is available code = os.read(self._tty_in.fileno(), 80).decode("utf-8", errors="ignore") self._reading_next_key = False if code in self._terminal_code_to_codename: return self._terminal_code_to_codename[code] elif ignore_case: return code.lower() else: return code def show(self) -> Optional[Union[int, Tuple[int, ...]]]: def init_signal_handling() -> None: # `SIGWINCH` is send on terminal resizes def handle_sigwinch(signum: int, frame: Optional[FrameType]) -> None: # pylint: disable=unused-argument if self._reading_next_key: self._paint_menu() else: self._paint_before_next_read = True signal.signal(signal.SIGWINCH, handle_sigwinch) def reset_signal_handling() -> None: signal.signal(signal.SIGWINCH, signal.SIG_DFL) def remove_letter_keys(menu_action_to_keys: Dict[str, Set[Optional[str]]]) -> None: letter_keys = frozenset(string.ascii_lowercase) | frozenset(" ") for keys in menu_action_to_keys.values(): keys -= letter_keys # pylint: disable=unsubscriptable-object assert self._codename_to_terminal_code is not None self._init_term() if self._preselected_indices is None: self._selection.clear() self._chosen_accept_key = None self._chosen_menu_indices = None self._chosen_menu_index = None assert self._tty_out is not None if self._title_lines: # `print_menu` expects the cursor on the first menu item -> reserve one line for the title self._tty_out.write(len(self._title_lines) * self._codename_to_terminal_code["cursor_down"]) menu_was_interrupted = False try: init_signal_handling() menu_action_to_keys = { "menu_up": set(("up", "ctrl-k", "ctrl-p", "k")), "menu_down": set(("down", "ctrl-j", "ctrl-n", "j")), "menu_page_up": set(("page_up", "ctrl-b")), "menu_page_down": set(("page_down", "ctrl-f")), "menu_start": set(("home", "ctrl-a")), "menu_end": set(("end", "ctrl-e")), "accept": set(self._accept_keys), "multi_select": set(self._multi_select_keys), "quit": set(self._quit_keys), "search_start": set((self._search_key,)), "backspace": set(("backspace",)), } # type: Dict[str, Set[Optional[str]]] while True: self._paint_menu() current_menu_action_to_keys = copy.deepcopy(menu_action_to_keys) next_key = self._read_next_key(ignore_case=False) if self._search or self._search_key is None: remove_letter_keys(current_menu_action_to_keys) else: next_key = next_key.lower() if self._search_key is not None and not self._search and next_key in self._shortcut_keys: shortcut_menu_index = self._shortcut_keys.index(next_key) if self._exit_on_shortcut: self._selection.add(shortcut_menu_index) break else: if self._multi_select: self._selection.toggle(shortcut_menu_index) else: self._view.active_menu_index = shortcut_menu_index elif next_key in current_menu_action_to_keys["menu_up"]: self._view.decrement_active_index() elif next_key in current_menu_action_to_keys["menu_down"]: self._view.increment_active_index() elif next_key in current_menu_action_to_keys["menu_page_up"]: self._view.page_up() elif next_key in current_menu_action_to_keys["menu_page_down"]: self._view.page_down() elif next_key in current_menu_action_to_keys["menu_start"]: self._view.active_displayed_index = 0 elif next_key in current_menu_action_to_keys["menu_end"]: self._view.active_displayed_index = self._view.max_displayed_index elif self._multi_select and next_key in current_menu_action_to_keys["multi_select"]: if self._view.active_menu_index is not None: self._selection.toggle(self._view.active_menu_index) elif next_key in current_menu_action_to_keys["accept"]: if self._view.active_menu_index is not None: if ( self._multi_select_select_on_accept or self._multi_select is False or (not self._selection and self._multi_select_empty_ok is False) ): self._selection.add(self._view.active_menu_index) self._chosen_accept_key = next_key break elif next_key in current_menu_action_to_keys["quit"]: if not self._search: menu_was_interrupted = True break else: self._search.search_text = None elif not self._search: if next_key in current_menu_action_to_keys["search_start"] or ( self._search_key is None and next_key == DEFAULT_SEARCH_KEY ): self._search.search_text = "" elif self._search_key is None: self._search.search_text = next_key else: assert self._search.search_text is not None if next_key in ("backspace",): if self._search.search_text != "": self._search.search_text = self._search.search_text[:-1] else: self._search.search_text = None elif wcswidth(next_key) >= 0 and not ( next_key in current_menu_action_to_keys["search_start"] and self._search.search_text == "" ): # Only append `next_key` if it is a printable character and the first character is not the # `search_start` key self._search.search_text += next_key except KeyboardInterrupt as e: if self._raise_error_on_interrupt: raise e menu_was_interrupted = True finally: reset_signal_handling() self._clear_menu() self._reset_term() if not menu_was_interrupted: chosen_menu_indices = self._selection.selected_menu_indices if chosen_menu_indices: if self._multi_select: self._chosen_menu_indices = chosen_menu_indices else: self._chosen_menu_index = chosen_menu_indices[0] return self._chosen_menu_indices if self._multi_select else self._chosen_menu_index @property def chosen_accept_key(self) -> Optional[str]: return self._chosen_accept_key @property def chosen_menu_entry(self) -> Optional[str]: return self._menu_entries[self._chosen_menu_index] if self._chosen_menu_index is not None else None @property def chosen_menu_entries(self) -> Optional[Tuple[str, ...]]: return ( tuple(self._menu_entries[menu_index] for menu_index in self._chosen_menu_indices) if self._chosen_menu_indices is not None else None ) @property def chosen_menu_index(self) -> Optional[int]: return self._chosen_menu_index @property def chosen_menu_indices(self) -> Optional[Tuple[int, ...]]: return self._chosen_menu_indices class AttributeDict(dict): # type: ignore def __getattr__(self, attr: str) -> Any: return self[attr] def __setattr__(self, attr: str, value: Any) -> None: self[attr] = value def get_argumentparser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser( formatter_class=argparse.RawDescriptionHelpFormatter, description=""" %(prog)s creates simple interactive menus in the terminal and returns the selected entry as exit code. """, ) parser.add_argument( "-s", "--case-sensitive", action="store_true", dest="case_sensitive", help="searches are case sensitive" ) parser.add_argument( "-X", "--no-clear-menu-on-exit", action="store_false", dest="clear_menu_on_exit", help="do not clear the menu on exit", ) parser.add_argument( "-l", "--clear-screen", action="store_true", dest="clear_screen", help="clear the screen before the menu is shown", ) parser.add_argument( "--cursor", action="store", dest="cursor", default=DEFAULT_MENU_CURSOR, help='menu cursor (default: "%(default)s")', ) parser.add_argument( "-i", "--cursor-index", action="store", dest="cursor_index", type=int, default=0, help="initially selected item index", ) parser.add_argument( "--cursor-style", action="store", dest="cursor_style", default=",".join(DEFAULT_MENU_CURSOR_STYLE), help='style for the menu cursor as comma separated list (default: "%(default)s")', ) parser.add_argument("-C", "--no-cycle", action="store_false", dest="cycle", help="do not cycle the menu selection") parser.add_argument( "-E", "--no-exit-on-shortcut", action="store_false", dest="exit_on_shortcut", help="do not exit on shortcut keys", ) parser.add_argument( "--highlight-style", action="store", dest="highlight_style", default=",".join(DEFAULT_MENU_HIGHLIGHT_STYLE), help='style for the selected menu entry as comma separated list (default: "%(default)s")', ) parser.add_argument( "-m", "--multi-select", action="store_true", dest="multi_select", help="Allow the selection of multiple entries (implies `--stdout`)", ) parser.add_argument( "--multi-select-cursor", action="store", dest="multi_select_cursor", default=DEFAULT_MULTI_SELECT_CURSOR, help='multi-select menu cursor (default: "%(default)s")', ) parser.add_argument( "--multi-select-cursor-brackets-style", action="store", dest="multi_select_cursor_brackets_style", default=",".join(DEFAULT_MULTI_SELECT_CURSOR_BRACKETS_STYLE), help='style for brackets of the multi-select menu cursor as comma separated list (default: "%(default)s")', ) parser.add_argument( "--multi-select-cursor-style", action="store", dest="multi_select_cursor_style", default=",".join(DEFAULT_MULTI_SELECT_CURSOR_STYLE), help='style for the multi-select menu cursor as comma separated list (default: "%(default)s")', ) parser.add_argument( "--multi-select-keys", action="store", dest="multi_select_keys", default=",".join(DEFAULT_MULTI_SELECT_KEYS), help=('key for toggling a selected item in a multi-selection (default: "%(default)s", '), ) parser.add_argument( "--multi-select-no-select-on-accept", action="store_false", dest="multi_select_select_on_accept", help=( "do not select the currently highlighted menu item when the accept key is pressed " "(it is still selected if no other item was selected before)" ), ) parser.add_argument( "--multi-select-empty-ok", action="store_true", dest="multi_select_empty_ok", help=("when used together with --multi-select-no-select-on-accept allows returning no selection at all"), ) parser.add_argument( "-p", "--preview", action="store", dest="preview_command", help=( "Command to generate a preview for the selected menu entry. " '"{}" can be used as placeholder for the menu text. ' 'If the menu entry has a data component (separated by "|"), this is used instead.' ), ) parser.add_argument( "--no-preview-border", action="store_false", dest="preview_border", help="do not draw a border around the preview window", ) parser.add_argument( "--preview-size", action="store", dest="preview_size", type=float, default=DEFAULT_PREVIEW_SIZE, help='maximum height of the preview window in fractions of the terminal height (default: "%(default)s")', ) parser.add_argument( "--preview-title", action="store", dest="preview_title", default=DEFAULT_PREVIEW_TITLE, help='title of the preview window (default: "%(default)s")', ) parser.add_argument( "--search-highlight-style", action="store", dest="search_highlight_style", default=",".join(DEFAULT_SEARCH_HIGHLIGHT_STYLE), help='style of matched search patterns (default: "%(default)s")', ) parser.add_argument( "--search-key", action="store", dest="search_key", default=DEFAULT_SEARCH_KEY, help=( 'key to start a search (default: "%(default)s", ' '"none" is treated a special value which activates the search on any letter key)' ), ) parser.add_argument( "--shortcut-brackets-highlight-style", action="store", dest="shortcut_brackets_highlight_style", default=",".join(DEFAULT_SHORTCUT_BRACKETS_HIGHLIGHT_STYLE), help='style of brackets enclosing shortcut keys (default: "%(default)s")', ) parser.add_argument( "--shortcut-key-highlight-style", action="store", dest="shortcut_key_highlight_style", default=",".join(DEFAULT_SHORTCUT_KEY_HIGHLIGHT_STYLE), help='style of shortcut keys (default: "%(default)s")', ) parser.add_argument( "--show-multi-select-hint", action="store_true", dest="show_multi_select_hint", help="show a multi-select hint in the status bar", ) parser.add_argument( "--show-multi-select-hint-text", action="store", dest="show_multi_select_hint_text", help=( "Custom text which will be shown as multi-select hint. Use the placeholders {multi_select_keys} and " "{accept_keys} if appropriately." ), ) parser.add_argument( "--show-search-hint", action="store_true", dest="show_search_hint", help="show a search hint in the search line", ) parser.add_argument( "--show-search-hint-text", action="store", dest="show_search_hint_text", help=( "Custom text which will be shown as search hint. Use the placeholders {key} for the search key " "if appropriately." ), ) parser.add_argument( "--show-shortcut-hints", action="store_true", dest="show_shortcut_hints", help="show shortcut hints in the status bar", ) parser.add_argument( "--show-shortcut-hints-in-title", action="store_false", dest="show_shortcut_hints_in_status_bar", default=True, help="show shortcut hints in the menu title", ) parser.add_argument( "--skip-empty-entries", action="store_true", dest="skip_empty_entries", help="Interpret an empty string in menu entries as an empty menu entry", ) parser.add_argument( "-b", "--status-bar", action="store", dest="status_bar", help="status bar text", ) parser.add_argument( "-d", "--status-bar-below-preview", action="store_true", dest="status_bar_below_preview", help="show the status bar below the preview window if any", ) parser.add_argument( "--status-bar-style", action="store", dest="status_bar_style", default=",".join(DEFAULT_STATUS_BAR_STYLE), help='style of the status bar lines (default: "%(default)s")', ) parser.add_argument( "--stdout", action="store_true", dest="stdout", help=( "Print the selected menu index or indices to stdout (in addition to the exit status). " 'Multiple indices are separated by ";".' ), ) parser.add_argument("-t", "--title", action="store", dest="title", help="menu title") parser.add_argument( "-V", "--version", action="store_true", dest="print_version", help="print the version number and exit" ) parser.add_argument("entries", action="store", nargs="*", help="the menu entries to show") group = parser.add_mutually_exclusive_group() group.add_argument( "-r", "--preselected_entries", action="store", dest="preselected_entries", help="Comma separated list of strings matching menu items to start pre-selected in a multi-select menu.", ) group.add_argument( "-R", "--preselected_indices", action="store", dest="preselected_indices", help="Comma separated list of numeric indexes of menu items to start pre-selected in a multi-select menu.", ) return parser def parse_arguments() -> AttributeDict: parser = get_argumentparser() args = AttributeDict({key: value for key, value in vars(parser.parse_args()).items()}) if not args.print_version and not args.entries: raise NoMenuEntriesError("No menu entries given!") if args.skip_empty_entries: args.entries = [entry if entry != "None" else None for entry in args.entries] if args.cursor_style != "": args.cursor_style = tuple(args.cursor_style.split(",")) else: args.cursor_style = None if args.highlight_style != "": args.highlight_style = tuple(args.highlight_style.split(",")) else: args.highlight_style = None if args.search_highlight_style != "": args.search_highlight_style = tuple(args.search_highlight_style.split(",")) else: args.search_highlight_style = None if args.shortcut_key_highlight_style != "": args.shortcut_key_highlight_style = tuple(args.shortcut_key_highlight_style.split(",")) else: args.shortcut_key_highlight_style = None if args.shortcut_brackets_highlight_style != "": args.shortcut_brackets_highlight_style = tuple(args.shortcut_brackets_highlight_style.split(",")) else: args.shortcut_brackets_highlight_style = None if args.status_bar_style != "": args.status_bar_style = tuple(args.status_bar_style.split(",")) else: args.status_bar_style = None if args.multi_select_cursor_brackets_style != "": args.multi_select_cursor_brackets_style = tuple(args.multi_select_cursor_brackets_style.split(",")) else: args.multi_select_cursor_brackets_style = None if args.multi_select_cursor_style != "": args.multi_select_cursor_style = tuple(args.multi_select_cursor_style.split(",")) else: args.multi_select_cursor_style = None if args.multi_select_keys != "": args.multi_select_keys = tuple(args.multi_select_keys.split(",")) else: args.multi_select_keys = None if args.search_key.lower() == "none": args.search_key = None if args.show_shortcut_hints_in_status_bar: args.show_shortcut_hints = True if args.multi_select: args.stdout = True if args.preselected_entries is not None: args.preselected = list(args.preselected_entries.split(",")) elif args.preselected_indices is not None: args.preselected = list(map(int, args.preselected_indices.split(","))) else: args.preselected = None return args def main() -> None: try: args = parse_arguments() except SystemExit: sys.exit(0) # Error code 0 is the error case in this program except NoMenuEntriesError as e: print(str(e), file=sys.stderr) sys.exit(0) if args.print_version: print("{}, version {}".format(os.path.basename(sys.argv[0]), __version__)) sys.exit(0) try: terminal_menu = TerminalMenu( menu_entries=args.entries, clear_menu_on_exit=args.clear_menu_on_exit, clear_screen=args.clear_screen, cursor_index=args.cursor_index, cycle_cursor=args.cycle, exit_on_shortcut=args.exit_on_shortcut, menu_cursor=args.cursor, menu_cursor_style=args.cursor_style, menu_highlight_style=args.highlight_style, multi_select=args.multi_select, multi_select_cursor=args.multi_select_cursor, multi_select_cursor_brackets_style=args.multi_select_cursor_brackets_style, multi_select_cursor_style=args.multi_select_cursor_style, multi_select_empty_ok=args.multi_select_empty_ok, multi_select_keys=args.multi_select_keys, multi_select_select_on_accept=args.multi_select_select_on_accept, preselected_entries=args.preselected, preview_border=args.preview_border, preview_command=args.preview_command, preview_size=args.preview_size, preview_title=args.preview_title, search_case_sensitive=args.case_sensitive, search_highlight_style=args.search_highlight_style, search_key=args.search_key, shortcut_brackets_highlight_style=args.shortcut_brackets_highlight_style, shortcut_key_highlight_style=args.shortcut_key_highlight_style, show_multi_select_hint=args.show_multi_select_hint, show_multi_select_hint_text=args.show_multi_select_hint_text, show_search_hint=args.show_search_hint, show_search_hint_text=args.show_search_hint_text, show_shortcut_hints=args.show_shortcut_hints, show_shortcut_hints_in_status_bar=args.show_shortcut_hints_in_status_bar, skip_empty_entries=args.skip_empty_entries, status_bar=args.status_bar, status_bar_below_preview=args.status_bar_below_preview, status_bar_style=args.status_bar_style, title=args.title, ) except (InvalidParameterCombinationError, InvalidStyleError, UnknownMenuEntryError) as e: print(str(e), file=sys.stderr) sys.exit(0) chosen_entries = terminal_menu.show() if chosen_entries is None: sys.exit(0) else: if isinstance(chosen_entries, Iterable): if args.stdout: print(",".join(str(entry + 1) for entry in chosen_entries)) sys.exit(chosen_entries[0] + 1) else: chosen_entry = chosen_entries if args.stdout: print(chosen_entry + 1) sys.exit(chosen_entry + 1) if __name__ == "__main__": main()