| """Utilities needed to emulate Python's interactive interpreter. |
| |
| """ |
| |
| # Inspired by similar code by Jeff Epler and Fredrik Lundh. |
| |
| |
| import sys |
| import string |
| import traceback |
| from codeop import compile_command |
| |
| |
| class InteractiveInterpreter: |
| """Base class for InteractiveConsole. |
| |
| This class deals with parsing and interpreter state (the user's |
| namespace); it doesn't deal with input buffering or prompting or |
| input file naming (the filename is always passed in explicitly). |
| |
| """ |
| |
| def __init__(self, locals=None): |
| """Constructor. |
| |
| The optional 'locals' argument specifies the dictionary in |
| which code will be executed; it defaults to a newly created |
| dictionary with key "__name__" set to "__console__" and key |
| "__doc__" set to None. |
| |
| """ |
| if locals is None: |
| locals = {"__name__": "__console__", "__doc__": None} |
| self.locals = locals |
| |
| def runsource(self, source, filename="<input>", symbol="single"): |
| """Compile and run some source in the interpreter. |
| |
| Arguments are as for compile_command(). |
| |
| One several things can happen: |
| |
| 1) The input is incorrect; compile_command() raised an |
| exception (SyntaxError or OverflowError). A syntax traceback |
| will be printed by calling the showsyntaxerror() method. |
| |
| 2) The input is incomplete, and more input is required; |
| compile_command() returned None. Nothing happens. |
| |
| 3) The input is complete; compile_command() returned a code |
| object. The code is executed by calling self.runcode() (which |
| also handles run-time exceptions, except for SystemExit). |
| |
| The return value is 1 in case 2, 0 in the other cases (unless |
| an exception is raised). The return value can be used to |
| decide whether to use sys.ps1 or sys.ps2 to prompt the next |
| line. |
| |
| """ |
| try: |
| code = compile_command(source, filename, symbol) |
| except (OverflowError, SyntaxError): |
| # Case 1 |
| self.showsyntaxerror(filename) |
| return 0 |
| |
| if code is None: |
| # Case 2 |
| return 1 |
| |
| # Case 3 |
| self.runcode(code) |
| return 0 |
| |
| def runcode(self, code): |
| """Execute a code object. |
| |
| When an exception occurs, self.showtraceback() is called to |
| display a traceback. All exceptions are caught except |
| SystemExit, which is reraised. |
| |
| A note about KeyboardInterrupt: this exception may occur |
| elsewhere in this code, and may not always be caught. The |
| caller should be prepared to deal with it. |
| |
| """ |
| try: |
| exec code in self.locals |
| except SystemExit: |
| raise |
| except: |
| self.showtraceback() |
| |
| def showsyntaxerror(self, filename=None): |
| """Display the syntax error that just occurred. |
| |
| This doesn't display a stack trace because there isn't one. |
| |
| If a filename is given, it is stuffed in the exception instead |
| of what was there before (because Python's parser always uses |
| "<string>" when reading from a string). |
| |
| The output is written by self.write(), below. |
| |
| """ |
| type, value, sys.last_traceback = sys.exc_info() |
| sys.last_type = type |
| sys.last_value = value |
| if filename and type is SyntaxError: |
| # Work hard to stuff the correct filename in the exception |
| try: |
| msg, (dummy_filename, lineno, offset, line) = value |
| except: |
| # Not the format we expect; leave it alone |
| pass |
| else: |
| # Stuff in the right filename |
| try: |
| # Assume SyntaxError is a class exception |
| value = SyntaxError(msg, (filename, lineno, offset, line)) |
| except: |
| # If that failed, assume SyntaxError is a string |
| value = msg, (filename, lineno, offset, line) |
| list = traceback.format_exception_only(type, value) |
| map(self.write, list) |
| |
| def showtraceback(self): |
| """Display the exception that just occurred. |
| |
| We remove the first stack item because it is our own code. |
| |
| The output is written by self.write(), below. |
| |
| """ |
| try: |
| type, value, tb = sys.exc_info() |
| sys.last_type = type |
| sys.last_value = value |
| sys.last_traceback = tb |
| tblist = traceback.extract_tb(tb) |
| del tblist[:1] |
| list = traceback.format_list(tblist) |
| if list: |
| list.insert(0, "Traceback (innermost last):\n") |
| list[len(list):] = traceback.format_exception_only(type, value) |
| finally: |
| tblist = tb = None |
| map(self.write, list) |
| |
| def write(self, data): |
| """Write a string. |
| |
| The base implementation writes to sys.stderr; a subclass may |
| replace this with a different implementation. |
| |
| """ |
| sys.stderr.write(data) |
| |
| |
| class InteractiveConsole(InteractiveInterpreter): |
| """Closely emulate the behavior of the interactive Python interpreter. |
| |
| This class builds on InteractiveInterpreter and adds prompting |
| using the familiar sys.ps1 and sys.ps2, and input buffering. |
| |
| """ |
| |
| def __init__(self, locals=None, filename="<console>"): |
| """Constructor. |
| |
| The optional locals argument will be passed to the |
| InteractiveInterpreter base class. |
| |
| The optional filename argument should specify the (file)name |
| of the input stream; it will show up in tracebacks. |
| |
| """ |
| InteractiveInterpreter.__init__(self, locals) |
| self.filename = filename |
| self.resetbuffer() |
| |
| def resetbuffer(self): |
| """Reset the input buffer.""" |
| self.buffer = [] |
| |
| def interact(self, banner=None): |
| """Closely emulate the interactive Python console. |
| |
| The optional banner argument specify the banner to print |
| before the first interaction; by default it prints a banner |
| similar to the one printed by the real Python interpreter, |
| followed by the current class name in parentheses (so as not |
| to confuse this with the real interpreter -- since it's so |
| close!). |
| |
| """ |
| try: |
| sys.ps1 |
| except AttributeError: |
| sys.ps1 = ">>> " |
| try: |
| sys.ps2 |
| except AttributeError: |
| sys.ps2 = "... " |
| if banner is None: |
| self.write("Python %s on %s\n%s\n(%s)\n" % |
| (sys.version, sys.platform, sys.copyright, |
| self.__class__.__name__)) |
| else: |
| self.write("%s\n" % str(banner)) |
| more = 0 |
| while 1: |
| try: |
| if more: |
| prompt = sys.ps2 |
| else: |
| prompt = sys.ps1 |
| try: |
| line = self.raw_input(prompt) |
| except EOFError: |
| self.write("\n") |
| break |
| else: |
| more = self.push(line) |
| except KeyboardInterrupt: |
| self.write("\nKeyboardInterrupt\n") |
| self.resetbuffer() |
| more = 0 |
| |
| def push(self, line): |
| """Push a line to the interpreter. |
| |
| The line should not have a trailing newline; it may have |
| internal newlines. The line is appended to a buffer and the |
| interpreter's runsource() method is called with the |
| concatenated contents of the buffer as source. If this |
| indicates that the command was executed or invalid, the buffer |
| is reset; otherwise, the command is incomplete, and the buffer |
| is left as it was after the line was appended. The return |
| value is 1 if more input is required, 0 if the line was dealt |
| with in some way (this is the same as runsource()). |
| |
| """ |
| self.buffer.append(line) |
| source = string.join(self.buffer, "\n") |
| more = self.runsource(source, self.filename) |
| if not more: |
| self.resetbuffer() |
| return more |
| |
| def raw_input(self, prompt=""): |
| """Write a prompt and read a line. |
| |
| The returned line does not include the trailing newline. |
| When the user enters the EOF key sequence, EOFError is raised. |
| |
| The base implementation uses the built-in function |
| raw_input(); a subclass may replace this with a different |
| implementation. |
| |
| """ |
| return raw_input(prompt) |
| |
| |
| def interact(banner=None, readfunc=None, local=None): |
| """Closely emulate the interactive Python interpreter. |
| |
| This is a backwards compatible interface to the InteractiveConsole |
| class. When readfunc is not specified, it attempts to import the |
| readline module to enable GNU readline if it is available. |
| |
| Arguments (all optional, all default to None): |
| |
| banner -- passed to InteractiveConsole.interact() |
| readfunc -- if not None, replaces InteractiveConsole.raw_input() |
| local -- passed to InteractiveInterpreter.__init__() |
| |
| """ |
| console = InteractiveConsole(local) |
| if readfunc is not None: |
| console.raw_input = readfunc |
| else: |
| try: |
| import readline |
| except: |
| pass |
| console.interact(banner) |
| |
| |
| if __name__ == '__main__': |
| interact() |