"""pexpect_helper provides a wrapper around the pexpect module. This module exposes a single class SpawnedProc, which wraps pexpect.spawn(). This exposes a pseudo-tty, which fish or another process may talk to. The send() function may be used to send data to fish, and the expect_* family of functions may be used to match what is output to the tty. Example usage: sp = SpawnedProc() # this launches fish sp.expect_prompt() # wait for a prompt sp.sendline("echo hello world") sp.expect_prompt("hello world") """ from __future__ import print_function import inspect import os import os.path import re import sys import time import pexpect # Default timeout for failing to match. TIMEOUT_SECS = 5 UNEXPECTED_SUCCESS = object() def get_prompt_re(counter): """Return a regular expression for matching a with a given prompt counter.""" return re.compile( r"""(?:\r\n?|^) # beginning of line (?:\x1b[\d\[KB(m]*)* # optional colors (?:\[.\]\ )? # optional vi mode prompt """ + (r"prompt\ %d>" % counter) # prompt with counter + r""" (?:\x1b[\d\[KB(m]*)* # optional colors """, re.VERBOSE, ) def get_callsite(): """Return a triple (filename, line_number, line_text) of the call site location.""" callstack = inspect.getouterframes(inspect.currentframe()) for f in callstack: # Skip call sites from this file. if inspect.getmodule(f.frame) is Message.MODULE: continue # Skip functions which have a truthy callsite_skip attribute. if getattr(f.function, "callsite_skip", False): continue return (os.path.basename(f.filename), f.lineno, f.code_context) return ("Unknown", -1, "") def escape(s): """Escape the string 's' to make it human-understandable.""" res = [] for c in s: if c == "\n": res.append("\\n") elif c == "\r": res.append("\\r") elif c == "\t": res.append("\\t") elif c.isprintable(): res.append(c) else: res.append("\\x{:02x}".format(ord(c))) return "".join(res) def pexpect_error_type(err): """Return a human-readable description of a pexpect error type.""" if isinstance(err, pexpect.EOF): return "EOF" elif isinstance(err, pexpect.TIMEOUT): return "timeout" elif err is UNEXPECTED_SUCCESS: return "unexpected success" else: return "unknown error" class Message(object): """Some text either sent-to or received-from the spawned proc. Attributes: dir: the message direction, either DIR_INPUT or DIR_OUTPUT filename: the name of the file from which the message was sent text: the text of the messages when: a timestamp of when the message was sent """ # Input is input into fish shell ("sent data"). DIR_INPUT = " INPUT" # Output means output from fish shell ("received data"). DIR_OUTPUT = "OUTPUT" MODULE = sys.modules[__name__] def __init__(self, dir, text, when): """Construct from a direction, message text and timestamp.""" self.dir = dir self.filename, self.lineno, _ = get_callsite() self.text = text self.when = when @staticmethod def sent_input(text, when): """Return an input message with the given text.""" return Message(Message.DIR_INPUT, text, when) @staticmethod def received_output(text, when): """Return a output message with the given text.""" return Message(Message.DIR_OUTPUT, text, when) class SpawnedProc(object): """A process, talking to our ptty. This wraps pexpect.spawn. Attributes: colorize: whether error messages should have ANSI color escapes messages: list of Message sent and received, in-order start_time: the timestamp of the first message, or None if none yet spawn: the pexpect.spawn value prompt_counter: the index of the prompt. This cooperates with the fish_prompt function to ensure that each printed prompt is distinct. """ def __init__( self, name="fish", timeout=TIMEOUT_SECS, env=os.environ.copy(), **kwargs ): """Construct from a name, timeout, and environment. Args: name: the name of the executable to launch, as a key into the environment dictionary. By default this is 'fish' but may be other executables. timeout: A timeout to pass to pexpect. This indicates how long to wait before giving up on some expected output. env: a string->string dictionary, describing the environment variables. """ if name not in env: raise ValueError("'%s' variable not found in environment" % name) exe_path = env.get(name) self.colorize = sys.stdout.isatty() or env.get("FISH_FORCE_COLOR", "0") == "1" self.messages = [] self.start_time = None self.spawn = pexpect.spawn( exe_path, env=env, encoding="utf-8", timeout=timeout, **kwargs ) self.spawn.delaybeforesend = None self.prompt_counter = 0 def time_since_first_message(self): """Return a delta in seconds since the first message, or 0 if this is the first.""" now = time.monotonic() if not self.start_time: self.start_time = now return now - self.start_time def send(self, s): """Cover over pexpect.spawn.send(). Send the given string to the tty, returning the number of bytes written. """ res = self.spawn.send(s) when = self.time_since_first_message() self.messages.append(Message.sent_input(s, when)) return res def sendline(self, s): """Cover over pexpect.spawn.sendline(). Send the given string + linesep to the tty, returning the number of bytes written. """ return self.send(s + os.linesep) def expect_re(self, pat, pat_desc=None, unmatched=None, shouldfail=False, **kwargs): """Cover over pexpect.spawn.expect(). Consume all "new" output of self.spawn until the given pattern is matched, or the timeout is reached. Note that output between the current position and the location of the match is consumed as well. The pattern is typically a regular expression in string form, but may also be any of the types accepted by pexpect.spawn.expect(). If the 'unmatched' parameter is given, it is printed as part of the error message of any failure. On failure, this prints an error and exits. """ try: self.spawn.expect(pat, **kwargs) when = self.time_since_first_message() self.messages.append( Message.received_output(self.spawn.match.group(), when) ) # When a match is found, # spawn.match is the MatchObject that produced it. # This can be used to check what exactly was matched. if shouldfail: err = UNEXPECTED_SUCCESS if not pat_desc: pat_desc = str(pat) self.report_exception_and_exit(pat_desc, unmatched, err) return self.spawn.match except pexpect.ExceptionPexpect as err: if shouldfail: return True if not pat_desc: pat_desc = str(pat) self.report_exception_and_exit(pat_desc, unmatched, err) def expect_str(self, s, **kwargs): """Cover over expect_re() which accepts a literal string.""" return self.expect_re(re.escape(s), **kwargs) def expect_prompt(self, *args, increment=True, **kwargs): """Convenience function which matches some text and then a prompt. Match the given positional arguments as expect_re, and then look for a prompt. If increment is set, then this should be a new prompt and the prompt counter should be bumped; otherwise this is not a new prompt. Returns None on success, and exits on failure. Example: sp.sendline("echo hello world") sp.expect_prompt("hello world") """ if args: self.expect_re(*args, **kwargs) if increment: self.prompt_counter += 1 self.expect_re( get_prompt_re(self.prompt_counter), pat_desc="prompt %d" % self.prompt_counter, ) def report_exception_and_exit(self, pat, unmatched, err): """Things have gone badly. We have an exception 'err', some pexpect.ExceptionPexpect. Report it to stdout, along with the offending call site. If 'unmatched' is set, print it to stdout. """ colors = self.colors() failtype = pexpect_error_type(err) fmtkeys = {"failtype": failtype, "pat": escape(pat)} fmtkeys.update(**colors) filename, lineno, code_context = get_callsite() fmtkeys["filename"] = filename fmtkeys["lineno"] = lineno fmtkeys["code"] = "\n".join(code_context) if unmatched: print( "{RED}Error: {NORMAL}{BOLD}{unmatched}{RESET}".format( unmatched=unmatched, **fmtkeys ) ) print( "{RED}Failed to match pattern:{NORMAL} {BOLD}{pat}{RESET}".format(**fmtkeys) ) print( "{filename}:{lineno}: {BOLD}{failtype}{RESET} from {code}".format(**fmtkeys) ) print("") print("{CYAN}Escaped buffer:{RESET}".format(**colors)) print(escape(self.spawn.before)) print("") print("{CYAN}When written to the tty, this looks like:{RESET}".format(**colors)) print("{CYAN}<-------{RESET}".format(**colors)) sys.stdout.write(self.spawn.before) sys.stdout.flush() print("{RESET}\n{CYAN}------->{RESET}".format(**colors)) print("") # Show the last 10 messages. print("Last 10 messages:") delta = None for m in self.messages[-10:]: etext = escape(m.text) timestamp = m.when * 1000.0 # Use relative timestamps and add a sign. # This assumes a max length of 10^10 milliseconds (115 days) for the initial timestamp, # and 11.5 days for the delta. if delta: timestamp -= delta timestampstr = "{timestamp:+10.2f} ms".format(timestamp=timestamp) else: timestampstr = "{timestamp:10.2f} ms".format(timestamp=timestamp) delta = m.when * 1000.0 print( "{dir} {timestampstr} (Line {lineno}): {BOLD}{etext}{RESET}".format( dir=m.dir, timestampstr=timestampstr, filename=m.filename, lineno=m.lineno, etext=etext, **colors ) ) print("") sys.exit(1) def sleep(self, secs): """Cover over time.sleep().""" time.sleep(secs) def colors(self): """Return a dictionary mapping color names to ANSI escapes""" def ansic(n): """Return either an ANSI escape sequence for a color, or empty string.""" return "\033[%dm" % n if self.colorize else "" return { "RESET": ansic(0), "BOLD": ansic(1), "NORMAL": ansic(39), "BLACK": ansic(30), "RED": ansic(31), "GREEN": ansic(32), "YELLOW": ansic(33), "BLUE": ansic(34), "MAGENTA": ansic(35), "CYAN": ansic(36), "LIGHTGRAY": ansic(37), "DARKGRAY": ansic(90), "LIGHTRED": ansic(91), "LIGHTGREEN": ansic(92), "LIGHTYELLOW": ansic(93), "LIGHTBLUE": ansic(94), "LIGHTMAGENTA": ansic(95), "LIGHTCYAN": ansic(96), "WHITE": ansic(97), } def control(char: str) -> str: """ Returns the char sent when control is pressed along the given key. """ assert len(char) == 1 char = char.lower() if ord("a") <= ord(char) <= ord("z"): return chr(ord(char) - ord("a") + 1) return chr({ "@": 0, "`": 0, "[": 27, "{": 27, "\\": 28, "|": 28, "]": 29, "}": 29, "^": 30, "~": 30, "_": 31, "?": 127, }[char])