"""Attempt to extract command from the attribute segments of a line.

for seg in attr_segs:

if seg[0] <= mouse_x < seg[1]:

attributes = seg[2] if isinstance(seg[2], list) else [seg[2]]

for attr in attributes:

if isinstance(attr, debugger_cli_common.MenuItem):

"""Vertical ScrollBar for Curses-based CLI.

BASE_ATTR = cli_shared.COLOR_BLACK + "_on_" + cli_shared.COLOR_WHITE

def __init__(self,

min_x,

min_y,

max_x,

max_y,

scroll_position,

output_num_rows):

"""Constructor of ScrollBar.

self._min_x = min_x

self._min_y = min_y

self._max_x = max_x

self._max_y = max_y

self._scroll_position = scroll_position

self._output_num_rows = output_num_rows

self._scroll_bar_height = max_y - min_y + 1

if self._max_x < self._min_x:

raise ValueError("Insufficient width for ScrollBar (%d)" %

(self._max_x - self._min_x + 1))

if self._max_y < self._min_y + 3:

raise ValueError("Insufficient height for ScrollBar (%d)" %

(self._max_y - self._min_y + 1))

def _block_y(self, screen_coord_sys=False):

"""Get the 0-based y coordinate of the scroll block.

rel_block_y = int(

float(self._scroll_position) / (self._output_num_rows - 1) *

(self._scroll_bar_height - 3)) + 1

return rel_block_y + self._min_y if screen_coord_sys else rel_block_y

def layout(self):

"""Get the RichTextLines layout of the scroll bar.

width = self._max_x - self._min_x + 1

empty_line = " " * width

foreground_font_attr_segs = [(0, width, self.BASE_ATTR)]

if self._output_num_rows > 1:

block_y = self._block_y()

if width == 1:

up_text = "U"

down_text = "D"

elif width == 2:

up_text = "UP"

down_text = "DN"

elif width == 3:

up_text = "UP "

down_text = "DN "

else:

up_text = " UP "

down_text = "DOWN"

layout = debugger_cli_common.RichTextLines(

[up_text], font_attr_segs={0: [(0, width, self.BASE_ATTR)]})

for i in xrange(1, self._scroll_bar_height - 1):

font_attr_segs = foreground_font_attr_segs if i == block_y else None

layout.append(empty_line, font_attr_segs=font_attr_segs)

layout.append(down_text, font_attr_segs=foreground_font_attr_segs)

else:

layout = debugger_cli_common.RichTextLines(

[empty_line] * self._scroll_bar_height)

return layout

def get_click_command(self, mouse_y):

# TODO(cais): Support continuous scrolling when the mouse button is held

# down.

if self._output_num_rows <= 1:

return None

elif mouse_y == self._min_y:

return _SCROLL_UP_A_LINE

elif mouse_y == self._max_y:

return _SCROLL_DOWN_A_LINE

elif (mouse_y > self._block_y(screen_coord_sys=True) and

mouse_y < self._max_y):

return _SCROLL_DOWN

elif (mouse_y < self._block_y(screen_coord_sys=True) and

mouse_y > self._min_y):

return _SCROLL_UP

else:

"""Curses-based Command-line UI.

CLI_TERMINATOR_KEY = 7 # Terminator key for input text box.

CLI_TAB_KEY = ord("\t")

BACKSPACE_KEY = ord("\b")

REGEX_SEARCH_PREFIX = "/"

TENSOR_INDICES_NAVIGATION_PREFIX = "@"

_NAVIGATION_FORWARD_COMMAND = "next"

_NAVIGATION_BACK_COMMAND = "prev"

# Limit screen width to work around the limitation of the curses library that

# it may return invalid x coordinates for large values.

_SCREEN_WIDTH_LIMIT = 220

# Possible Enter keys. 343 is curses key code for the num-pad Enter key when

# num lock is off.

CLI_CR_KEYS = [ord("\n"), ord("\r"), 343]

_KEY_MAP = {

127: curses.KEY_BACKSPACE, # Backspace

curses.KEY_DC: 4, # Delete

}

_FOREGROUND_COLORS = {

cli_shared.COLOR_WHITE: curses.COLOR_WHITE,

cli_shared.COLOR_RED: curses.COLOR_RED,

cli_shared.COLOR_GREEN: curses.COLOR_GREEN,

cli_shared.COLOR_YELLOW: curses.COLOR_YELLOW,

cli_shared.COLOR_BLUE: curses.COLOR_BLUE,

cli_shared.COLOR_CYAN: curses.COLOR_CYAN,

cli_shared.COLOR_MAGENTA: curses.COLOR_MAGENTA,

cli_shared.COLOR_BLACK: curses.COLOR_BLACK,

}

_BACKGROUND_COLORS = {

"transparent": -1,

cli_shared.COLOR_WHITE: curses.COLOR_WHITE,

cli_shared.COLOR_BLACK: curses.COLOR_BLACK,

}

# Font attribute for search and highlighting.

_SEARCH_HIGHLIGHT_FONT_ATTR = (

cli_shared.COLOR_BLACK + "_on_" + cli_shared.COLOR_WHITE)

_ARRAY_INDICES_COLOR_PAIR = (

cli_shared.COLOR_BLACK + "_on_" + cli_shared.COLOR_WHITE)

_ERROR_TOAST_COLOR_PAIR = (

cli_shared.COLOR_RED + "_on_" + cli_shared.COLOR_WHITE)

_INFO_TOAST_COLOR_PAIR = (

cli_shared.COLOR_BLUE + "_on_" + cli_shared.COLOR_WHITE)

_STATUS_BAR_COLOR_PAIR = (

cli_shared.COLOR_BLACK + "_on_" + cli_shared.COLOR_WHITE)

_UI_WAIT_COLOR_PAIR = (

cli_shared.COLOR_MAGENTA + "_on_" + cli_shared.COLOR_WHITE)

_NAVIGATION_WARNING_COLOR_PAIR = (

cli_shared.COLOR_RED + "_on_" + cli_shared.COLOR_WHITE)

_UI_WAIT_MESSAGE = "Processing..."

_single_instance_lock = threading.Lock()

def __init__(self, on_ui_exit=None):

"""Constructor of CursesUI.

base_ui.BaseUI.__init__(self, on_ui_exit=on_ui_exit)

self._screen_init()

self._screen_refresh_size()

# TODO(cais): Error out if the size of the screen is too small.

# Initialize some UI component size and locations.

self._init_layout()

self._command_history_store = debugger_cli_common.CommandHistory()

# Active list of command history, used in history navigation.

# _command_handler_registry holds all the history commands the CLI has

# received, up to a size limit. _active_command_history is the history

# currently being navigated in, e.g., using the Up/Down keys. The latter

# can be different from the former during prefixed or regex-based history

# navigation, e.g., when user enter the beginning of a command and hit Up.

self._active_command_history = []

# Pointer to the current position in the history sequence.

# 0 means it is a new command being keyed in.

self._command_pointer = 0

self._command_history_limit = 100

self._pending_command = ""

self._nav_history = curses_widgets.CursesNavigationHistory(10)

# State related to screen output.

self._output_pad = None

self._output_pad_row = 0

self._output_array_pointer_indices = None

self._curr_unwrapped_output = None

self._curr_wrapped_output = None

try:

# Register signal handler for SIGINT.

signal.signal(signal.SIGINT, self._interrupt_handler)

except ValueError:

# Running in a child thread, can't catch signals.

pass

self.register_command_handler(

"mouse",

self._mouse_mode_command_handler,

"Get or set the mouse mode of this CLI: (on|off)",

prefix_aliases=["m"])

def _init_layout(self):

"""Initialize the layout of UI components.

# NamedTuple for rectangular locations on screen

self.rectangle = collections.namedtuple("rectangle",

"top left bottom right")

# Height of command text box

self._command_textbox_height = 2

self._title_row = 0

# Row index of the Navigation Bar (i.e., the bar that contains forward and

# backward buttons and displays the current command line).

self._nav_bar_row = 1

# Top row index of the output pad.

# A "pad" is a curses object that holds lines of text and not limited to

# screen size. It can be rendered on the screen partially with scroll

# parameters specified.

self._output_top_row = 2

# Number of rows that the output pad has.

self._output_num_rows = (

self._max_y - self._output_top_row - self._command_textbox_height - 1)

# Row index of scroll information line: Taking into account the zero-based

# row indexing and the command textbox area under the scroll information

# row.

self._output_scroll_row = self._max_y - 1 - self._command_textbox_height

# Tab completion bottom row.

self._candidates_top_row = self._output_scroll_row - 4

self._candidates_bottom_row = self._output_scroll_row - 1

# Maximum number of lines the candidates display can have.

self._candidates_max_lines = int(self._output_num_rows / 2)

self.max_output_lines = 10000

# Regex search state.

self._curr_search_regex = None

self._unwrapped_regex_match_lines = []

# Size of view port on screen, which is always smaller or equal to the

# screen size.

self._output_pad_screen_height = self._output_num_rows - 1

self._output_pad_screen_width = self._max_x - 2

self._output_pad_screen_location = self.rectangle(

top=self._output_top_row,

left=0,

bottom=self._output_top_row + self._output_num_rows,

right=self._output_pad_screen_width)

def _screen_init(self):

"""Screen initialization.

# If the terminal type is color-ready, enable it.

if os.getenv("COLORTERM") in _COLOR_READY_COLORTERMS:

os.environ["TERM"] = _COLOR_ENABLED_TERM

self._stdscr = curses.initscr()

self._command_window = None

self._screen_color_init()

def _screen_color_init(self):

"""Initialization of screen colors."""

curses.start_color()

curses.use_default_colors()

self._color_pairs = {}

color_index = 0

# Prepare color pairs.

for fg_color in self._FOREGROUND_COLORS:

for bg_color in self._BACKGROUND_COLORS:

color_index += 1

curses.init_pair(color_index, self._FOREGROUND_COLORS[fg_color],

self._BACKGROUND_COLORS[bg_color])

color_name = fg_color

if bg_color != "transparent":

color_name += "_on_" + bg_color

self._color_pairs[color_name] = curses.color_pair(color_index)

# Try getting color(s) available only under 256-color support.

try:

color_index += 1

curses.init_pair(color_index, 245, -1)

self._color_pairs[cli_shared.COLOR_GRAY] = curses.color_pair(color_index)

except curses.error:

# Use fall-back color(s):

self._color_pairs[cli_shared.COLOR_GRAY] = (

self._color_pairs[cli_shared.COLOR_GREEN])

# A_BOLD or A_BLINK is not really a "color". But place it here for

# convenience.

self._color_pairs["bold"] = curses.A_BOLD

self._color_pairs["blink"] = curses.A_BLINK

self._color_pairs["underline"] = curses.A_UNDERLINE

# Default color pair to use when a specified color pair does not exist.

self._default_color_pair = self._color_pairs[cli_shared.COLOR_WHITE]

def _screen_launch(self, enable_mouse_on_start):

"""Launch the curses screen."""

curses.noecho()

curses.cbreak()

self._stdscr.keypad(1)

self._mouse_enabled = enable_mouse_on_start

self._screen_set_mousemask()

self._screen_create_command_window()

def _screen_create_command_window(self):

"""Create command window according to screen size."""

if self._command_window:

del self._command_window

self._command_window = curses.newwin(

self._command_textbox_height, self._max_x - len(self.CLI_PROMPT),

self._max_y - self._command_textbox_height, len(self.CLI_PROMPT))

def _screen_refresh(self):

self._stdscr.refresh()

def _screen_terminate(self):

"""Terminate the curses screen."""

self._stdscr.keypad(0)

curses.nocbreak()

curses.echo()

curses.endwin()

try:

# Remove SIGINT handler.

signal.signal(signal.SIGINT, signal.SIG_DFL)

except ValueError:

# Can't catch signals unless you're the main thread.

pass

def run_ui(self,

init_command=None,

title=None,

title_color=None,

enable_mouse_on_start=True):

"""Run the CLI: See the doc of base_ui.BaseUI.run_ui for more details."""

# Only one instance of the Curses UI can be running at a time, since

# otherwise they would try to both read from the same keystrokes, and write

# to the same screen.

self._single_instance_lock.acquire()

self._screen_launch(enable_mouse_on_start=enable_mouse_on_start)

# Optional initial command.

if init_command is not None:

self._dispatch_command(init_command)

if title is not None:

self._title(title, title_color=title_color)

# CLI main loop.

exit_token = self._ui_loop()

if self._on_ui_exit:

self._on_ui_exit()

self._screen_terminate()

self._single_instance_lock.release()

return exit_token

def get_help(self):

return self._command_handler_registry.get_help()

def _addstr(self, *args):

try:

self._stdscr.addstr(*args)

except curses.error:

pass

def _refresh_pad(self, pad, *args):

try:

pad.refresh(*args)

except curses.error:

pass

def _screen_create_command_textbox(self, existing_command=None):

"""Create command textbox on screen.

# Display the tfdbg prompt.

self._addstr(self._max_y - self._command_textbox_height, 0,

self.CLI_PROMPT, curses.A_BOLD)

self._stdscr.refresh()

self._command_window.clear()

# Command text box.

self._command_textbox = textpad.Textbox(

self._command_window, insert_mode=True)

# Enter existing command.

self._auto_key_in(existing_command)

def _ui_loop(self):

"""Command-line UI loop.

while True:

# Enter history command if pointer is in history (> 0):

if self._command_pointer > 0:

existing_command = self._active_command_history[-self._command_pointer]

else:

existing_command = self._pending_command

self._screen_create_command_textbox(existing_command)

try:

command, terminator, pending_command_changed = self._get_user_command()

except debugger_cli_common.CommandLineExit as e:

return e.exit_token

if not command and terminator != self.CLI_TAB_KEY:

continue

if terminator in self.CLI_CR_KEYS or terminator == curses.KEY_MOUSE:

exit_token = self._dispatch_command(command)

if exit_token is not None:

return exit_token

elif terminator == self.CLI_TAB_KEY:

tab_completed = self._tab_complete(command)

self._pending_command = tab_completed

self._cmd_ptr = 0

elif pending_command_changed:

self._pending_command = command

return

def _get_user_command(self):

"""Get user command from UI.

# First, reset textbox state variables.

self._textbox_curr_terminator = None

self._textbox_pending_command_changed = False

command = self._screen_get_user_command()

command = self._strip_terminator(command)

return (command, self._textbox_curr_terminator,

self._textbox_pending_command_changed)

def _screen_get_user_command(self):

return self._command_textbox.edit(validate=self._on_textbox_keypress)

def _strip_terminator(self, command):

if not command:

return command

for v in self.CLI_CR_KEYS:

if v < 256:

command = command.replace(chr(v), "")

return command.strip()

def _screen_refresh_size(self):

self._max_y, self._max_x = self._stdscr.getmaxyx()

if self._max_x > self._SCREEN_WIDTH_LIMIT:

self._max_x = self._SCREEN_WIDTH_LIMIT

def _navigate_screen_output(self, command):

"""Navigate in screen output history.

if command == self._NAVIGATION_FORWARD_COMMAND:

if self._nav_history.can_go_forward():

item = self._nav_history.go_forward()

scroll_position = item.scroll_position

else:

self._toast("At the LATEST in navigation history!",

color=self._NAVIGATION_WARNING_COLOR_PAIR)

return

else:

if self._nav_history.can_go_back():

item = self._nav_history.go_back()

scroll_position = item.scroll_position

else:

self._toast("At the OLDEST in navigation history!",

color=self._NAVIGATION_WARNING_COLOR_PAIR)

return

self._display_output(item.screen_output)

if scroll_position != 0:

self._scroll_output(_SCROLL_TO_LINE_INDEX, line_index=scroll_position)

def _dispatch_command(self, command):

"""Dispatch user command.

if self._output_pad:

self._toast(self._UI_WAIT_MESSAGE, color=self._UI_WAIT_COLOR_PAIR)

if command in self.CLI_EXIT_COMMANDS:

# Explicit user command-triggered exit: EXPLICIT_USER_EXIT as the exit

# token.

return debugger_cli_common.EXPLICIT_USER_EXIT

elif (command == self._NAVIGATION_FORWARD_COMMAND or

command == self._NAVIGATION_BACK_COMMAND):

self._navigate_screen_output(command)

return

if command:

self._command_history_store.add_command(command)

if (command.startswith(self.REGEX_SEARCH_PREFIX) and

self._curr_unwrapped_output):

if len(command) > len(self.REGEX_SEARCH_PREFIX):

# Command is like "/regex". Perform regex search.

regex = command[len(self.REGEX_SEARCH_PREFIX):]

self._curr_search_regex = regex

self._display_output(self._curr_unwrapped_output, highlight_regex=regex)

elif self._unwrapped_regex_match_lines:

# Command is "/". Continue scrolling down matching lines.

self._display_output(

self._curr_unwrapped_output,

is_refresh=True,

highlight_regex=self._curr_search_regex)

self._command_pointer = 0

self._pending_command = ""

return

elif command.startswith(self.TENSOR_INDICES_NAVIGATION_PREFIX):

indices_str = command[1:].strip()

if indices_str:

try:

indices = command_parser.parse_indices(indices_str)

omitted, line_index, _, _ = tensor_format.locate_tensor_element(

self._curr_wrapped_output, indices)

if not omitted:

self._scroll_output(

_SCROLL_TO_LINE_INDEX, line_index=line_index)

except Exception as e: # pylint: disable=broad-except

self._error_toast(str(e))

else:

self._error_toast("Empty indices.")

return

try:

prefix, args, output_file_path = self._parse_command(command)

except SyntaxError as e:

self._error_toast(str(e))

return

if not prefix:

# Empty command: take no action. Should not exit.

return

# Take into account scroll bar width.

screen_info = {"cols": self._max_x - 2}

exit_token = None

if self._command_handler_registry.is_registered(prefix):

try:

screen_output = self._command_handler_registry.dispatch_command(

prefix, args, screen_info=screen_info)

except debugger_cli_common.CommandLineExit as e:

exit_token = e.exit_token

else:

screen_output = debugger_cli_common.RichTextLines([

self.ERROR_MESSAGE_PREFIX + "Invalid command prefix \"%s\"" % prefix

])

# Clear active command history. Until next up/down history navigation

# occurs, it will stay empty.

self._active_command_history = []

if exit_token is not None:

return exit_token

self._nav_history.add_item(command, screen_output, 0)

self._display_output(screen_output)

if output_file_path:

try:

screen_output.write_to_file(output_file_path)

self._info_toast("Wrote output to %s" % output_file_path)

except Exception: # pylint: disable=broad-except

self._error_toast("Failed to write output to %s" % output_file_path)

self._command_pointer = 0

self._pending_command = ""

def _screen_gather_textbox_str(self):

"""Gather the text string in the command text box.

txt = self._command_textbox.gather()

return txt.strip()

def _on_textbox_keypress(self, x):

"""Text box key validator: Callback of key strokes.

if not isinstance(x, int):

raise TypeError("Key validator expected type int, received type %s" %

type(x))

if x in self.CLI_CR_KEYS:

# Make Enter key the terminator

self._textbox_curr_terminator = x

return self.CLI_TERMINATOR_KEY

elif x == self.CLI_TAB_KEY:

self._textbox_curr_terminator = self.CLI_TAB_KEY

return self.CLI_TERMINATOR_KEY

elif x == curses.KEY_PPAGE:

self._scroll_output(_SCROLL_UP_A_LINE)

return x

elif x == curses.KEY_NPAGE:

self._scroll_output(_SCROLL_DOWN_A_LINE)

return x

elif x == curses.KEY_HOME:

self._scroll_output(_SCROLL_HOME)

return x

elif x == curses.KEY_END:

self._scroll_output(_SCROLL_END)

return x

elif x in [curses.KEY_UP, curses.KEY_DOWN]:

# Command history navigation.

if not self._active_command_history:

hist_prefix = self._screen_gather_textbox_str()

self._active_command_history = (

self._command_history_store.lookup_prefix(

hist_prefix, self._command_history_limit))

if self._active_command_history:

if x == curses.KEY_UP:

if self._command_pointer < len(self._active_command_history):

self._command_pointer += 1

elif x == curses.KEY_DOWN:

if self._command_pointer > 0:

self._command_pointer -= 1

else:

self._command_pointer = 0

self._textbox_curr_terminator = x

# Force return from the textbox edit(), so that the textbox can be

# redrawn with a history command entered.

return self.CLI_TERMINATOR_KEY

elif x == curses.KEY_RESIZE:

# Respond to terminal resize.

self._screen_refresh_size()

self._init_layout()

self._screen_create_command_window()

self._redraw_output()

# Force return from the textbox edit(), so that the textbox can be

# redrawn.

return self.CLI_TERMINATOR_KEY

elif x == curses.KEY_MOUSE and self._mouse_enabled:

try:

_, mouse_x, mouse_y, _, mouse_event_type = self._screen_getmouse()

except curses.error:

mouse_event_type = None

if mouse_event_type == curses.BUTTON1_RELEASED:

# Logic for mouse-triggered scrolling.

if mouse_x >= self._max_x - 2:

scroll_command = self._scroll_bar.get_click_command(mouse_y)

if scroll_command is not None:

self._scroll_output(scroll_command)

return x

else:

command = self._fetch_hyperlink_command(mouse_x, mouse_y)

if command:

self._screen_create_command_textbox()

exit_token = self._dispatch_command(command)

if exit_token is not None:

raise debugger_cli_common.CommandLineExit(exit_token=exit_token)

else:

# Mark the pending command as modified.

self._textbox_pending_command_changed = True

# Invalidate active command history.

self._command_pointer = 0

self._active_command_history = []

return self._KEY_MAP.get(x, x)

def _screen_getmouse(self):

return curses.getmouse()

def _redraw_output(self):

if self._curr_unwrapped_output is not None:

self._display_nav_bar()

self._display_main_menu(self._curr_unwrapped_output)

self._display_output(self._curr_unwrapped_output, is_refresh=True)

def _fetch_hyperlink_command(self, mouse_x, mouse_y):

output_top = self._output_top_row

if self._main_menu_pad:

output_top += 1

if mouse_y == self._nav_bar_row and self._nav_bar:

# Click was in the nav bar.

return _get_command_from_line_attr_segs(mouse_x,

self._nav_bar.font_attr_segs[0])

elif mouse_y == self._output_top_row and self._main_menu_pad:

# Click was in the menu bar.

return _get_command_from_line_attr_segs(mouse_x,

self._main_menu.font_attr_segs[0])

else:

absolute_mouse_y = mouse_y + self._output_pad_row - output_top

if absolute_mouse_y in self._curr_wrapped_output.font_attr_segs:

return _get_command_from_line_attr_segs(

mouse_x, self._curr_wrapped_output.font_attr_segs[absolute_mouse_y])

def _title(self, title, title_color=None):

"""Display title.

# Pad input title str with "-" and space characters to make it pretty.

self._title_line = "--- %s " % title

if len(self._title_line) < self._max_x:

self._title_line += "-" * (self._max_x - len(self._title_line))

self._screen_draw_text_line(

self._title_row, self._title_line, color=title_color)

def _auto_key_in(self, command, erase_existing=False):

"""Automatically key in a command to the command Textbox.

if erase_existing:

self._erase_existing_command()

command = command or ""

for c in command:

self._command_textbox.do_command(ord(c))

def _erase_existing_command(self):

"""Erase existing text in command textpad."""

existing_len = len(self._command_textbox.gather())

for _ in xrange(existing_len):

self._command_textbox.do_command(self.BACKSPACE_KEY)

def _screen_draw_text_line(self, row, line, attr=curses.A_NORMAL, color=None):

"""Render a line of text on the screen.

if not isinstance(row, int):

raise TypeError("Invalid type in row")

if len(line) > self._max_x:

line = line[:self._max_x]

color_pair = (self._default_color_pair if color is None else

self._color_pairs[color])

self._addstr(row, 0, line, color_pair | attr)

self._screen_refresh()

def _screen_new_output_pad(self, rows, cols):

"""Generate a new pad on the screen.

return curses.newpad(rows, cols)

def _screen_display_output(self, output):

"""Actually render text output on the screen.

# Wrap the output lines according to screen width.

self._curr_wrapped_output, wrapped_line_indices = (

debugger_cli_common.wrap_rich_text_lines(output, self._max_x - 2))