| """Utilities needed to emulate Python's interactive interpreter. |
| |
| """ |
| |
| # Inspired by similar code by Jeff Epler and Fredrik Lundh. |
| |
| |
| import sys |
| import traceback |
| |
| |
| |
| |
| |
| |
| |
| |
| #START --------------------------- from codeop import CommandCompiler, compile_command |
| #START --------------------------- from codeop import CommandCompiler, compile_command |
| #START --------------------------- from codeop import CommandCompiler, compile_command |
| #START --------------------------- from codeop import CommandCompiler, compile_command |
| #START --------------------------- from codeop import CommandCompiler, compile_command |
| r"""Utilities to compile possibly incomplete Python source code. |
| |
| This module provides two interfaces, broadly similar to the builtin |
| function compile(), which take program text, a filename and a 'mode' |
| and: |
| |
| - Return code object if the command is complete and valid |
| - Return None if the command is incomplete |
| - Raise SyntaxError, ValueError or OverflowError if the command is a |
| syntax error (OverflowError and ValueError can be produced by |
| malformed literals). |
| |
| Approach: |
| |
| First, check if the source consists entirely of blank lines and |
| comments; if so, replace it with 'pass', because the built-in |
| parser doesn't always do the right thing for these. |
| |
| Compile three times: as is, with \n, and with \n\n appended. If it |
| compiles as is, it's complete. If it compiles with one \n appended, |
| we expect more. If it doesn't compile either way, we compare the |
| error we get when compiling with \n or \n\n appended. If the errors |
| are the same, the code is broken. But if the errors are different, we |
| expect more. Not intuitive; not even guaranteed to hold in future |
| releases; but this matches the compiler's behavior from Python 1.4 |
| through 2.2, at least. |
| |
| Caveat: |
| |
| It is possible (but not likely) that the parser stops parsing with a |
| successful outcome before reaching the end of the source; in this |
| case, trailing symbols may be ignored instead of causing an error. |
| For example, a backslash followed by two newlines may be followed by |
| arbitrary garbage. This will be fixed once the API for the parser is |
| better. |
| |
| The two interfaces are: |
| |
| compile_command(source, filename, symbol): |
| |
| Compiles a single command in the manner described above. |
| |
| CommandCompiler(): |
| |
| Instances of this class have __call__ methods identical in |
| signature to compile_command; the difference is that if the |
| instance compiles program text containing a __future__ statement, |
| the instance 'remembers' and compiles all subsequent program texts |
| with the statement in force. |
| |
| The module also provides another class: |
| |
| Compile(): |
| |
| Instances of this class act like the built-in function compile, |
| but with 'memory' in the sense described above. |
| """ |
| |
| import __future__ |
| |
| _features = [getattr(__future__, fname) |
| for fname in __future__.all_feature_names] |
| |
| __all__ = ["compile_command", "Compile", "CommandCompiler"] |
| |
| PyCF_DONT_IMPLY_DEDENT = 0x200 # Matches pythonrun.h |
| |
| def _maybe_compile(compiler, source, filename, symbol): |
| # Check for source consisting of only blank lines and comments |
| for line in source.split("\n"): |
| line = line.strip() |
| if line and line[0] != '#': |
| break # Leave it alone |
| else: |
| if symbol != "eval": |
| source = "pass" # Replace it with a 'pass' statement |
| |
| err = err1 = err2 = None |
| code = code1 = code2 = None |
| |
| try: |
| code = compiler(source, filename, symbol) |
| except SyntaxError, err: |
| pass |
| |
| try: |
| code1 = compiler(source + "\n", filename, symbol) |
| except SyntaxError, err1: |
| pass |
| |
| try: |
| code2 = compiler(source + "\n\n", filename, symbol) |
| except SyntaxError, err2: |
| pass |
| |
| if code: |
| return code |
| if not code1 and repr(err1) == repr(err2): |
| raise SyntaxError, err1 |
| |
| def _compile(source, filename, symbol): |
| return compile(source, filename, symbol, PyCF_DONT_IMPLY_DEDENT) |
| |
| def compile_command(source, filename="<input>", symbol="single"): |
| r"""Compile a command and determine whether it is incomplete. |
| |
| Arguments: |
| |
| source -- the source string; may contain \n characters |
| filename -- optional filename from which source was read; default |
| "<input>" |
| symbol -- optional grammar start symbol; "single" (default) or "eval" |
| |
| Return value / exceptions raised: |
| |
| - Return a code object if the command is complete and valid |
| - Return None if the command is incomplete |
| - Raise SyntaxError, ValueError or OverflowError if the command is a |
| syntax error (OverflowError and ValueError can be produced by |
| malformed literals). |
| """ |
| return _maybe_compile(_compile, source, filename, symbol) |
| |
| class Compile: |
| """Instances of this class behave much like the built-in compile |
| function, but if one is used to compile text containing a future |
| statement, it "remembers" and compiles all subsequent program texts |
| with the statement in force.""" |
| def __init__(self): |
| self.flags = PyCF_DONT_IMPLY_DEDENT |
| |
| def __call__(self, source, filename, symbol): |
| codeob = compile(source, filename, symbol, self.flags, 1) |
| for feature in _features: |
| if codeob.co_flags & feature.compiler_flag: |
| self.flags |= feature.compiler_flag |
| return codeob |
| |
| class CommandCompiler: |
| """Instances of this class have __call__ methods identical in |
| signature to compile_command; the difference is that if the |
| instance compiles program text containing a __future__ statement, |
| the instance 'remembers' and compiles all subsequent program texts |
| with the statement in force.""" |
| |
| def __init__(self,): |
| self.compiler = Compile() |
| |
| def __call__(self, source, filename="<input>", symbol="single"): |
| r"""Compile a command and determine whether it is incomplete. |
| |
| Arguments: |
| |
| source -- the source string; may contain \n characters |
| filename -- optional filename from which source was read; |
| default "<input>" |
| symbol -- optional grammar start symbol; "single" (default) or |
| "eval" |
| |
| Return value / exceptions raised: |
| |
| - Return a code object if the command is complete and valid |
| - Return None if the command is incomplete |
| - Raise SyntaxError, ValueError or OverflowError if the command is a |
| syntax error (OverflowError and ValueError can be produced by |
| malformed literals). |
| """ |
| return _maybe_compile(self.compiler, source, filename, symbol) |
| |
| #END --------------------------- from codeop import CommandCompiler, compile_command |
| #END --------------------------- from codeop import CommandCompiler, compile_command |
| #END --------------------------- from codeop import CommandCompiler, compile_command |
| #END --------------------------- from codeop import CommandCompiler, compile_command |
| #END --------------------------- from codeop import CommandCompiler, compile_command |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| __all__ = ["InteractiveInterpreter", "InteractiveConsole", "interact", |
| "compile_command"] |
| |
| def softspace(file, newvalue): |
| oldvalue = 0 |
| try: |
| oldvalue = file.softspace |
| except AttributeError: |
| pass |
| try: |
| file.softspace = newvalue |
| except (AttributeError, TypeError): |
| # "attribute-less object" or "read-only attributes" |
| pass |
| return oldvalue |
| |
| 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 |
| self.compile = CommandCompiler() |
| |
| 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 True in case 2, False 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 = self.compile(source, filename, symbol) |
| except (OverflowError, SyntaxError, ValueError): |
| # Case 1 |
| self.showsyntaxerror(filename) |
| return False |
| |
| if code is None: |
| # Case 2 |
| return True |
| |
| # Case 3 |
| self.runcode(code) |
| return False |
| |
| 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() |
| else: |
| if softspace(sys.stdout, 0): |
| sys.stdout.write('\n') |
| |
| 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 |
| value = SyntaxError(msg, (filename, lineno, offset, line)) |
| sys.last_value = value |
| 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 (most recent call 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 #@UndefinedVariable |
| except AttributeError: |
| sys.ps1 = ">>> " |
| try: |
| sys.ps2 #@UndefinedVariable |
| except AttributeError: |
| sys.ps2 = "... " |
| cprt = 'Type "help", "copyright", "credits" or "license" for more information.' |
| if banner is None: |
| self.write("Python %s on %s\n%s\n(%s)\n" % |
| (sys.version, sys.platform, cprt, |
| self.__class__.__name__)) |
| else: |
| self.write("%s\n" % str(banner)) |
| more = 0 |
| while 1: |
| try: |
| if more: |
| prompt = sys.ps2 #@UndefinedVariable |
| else: |
| prompt = sys.ps1 #@UndefinedVariable |
| try: |
| line = self.raw_input(prompt) |
| # Can be None if sys.stdin was redefined |
| encoding = getattr(sys.stdin, "encoding", None) |
| if encoding and not isinstance(line, unicode): |
| line = line.decode(encoding) |
| 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 = "\n".join(self.buffer) |
| 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 ImportError: |
| pass |
| console.interact(banner) |
| |
| |
| if __name__ == '__main__': |
| import pdb |
| pdb.run("interact()\n") |
