Lib/code.py

   1 """Utilities needed to emulate Python's interactive interpreter.
   2
   3 """
   4
   5 # Inspired by similar code by Jeff Epler and Fredrik Lundh.
   6
   7
   8 import sys
   9 import traceback
  10 from codeop import CommandCompiler, compile_command
  11
  12 __all__ = ["InteractiveInterpreter", "InteractiveConsole", "interact",
  13            "compile_command"]
  14
  15 class InteractiveInterpreter:
  16     """Base class for InteractiveConsole.
  17
  18     This class deals with parsing and interpreter state (the user's
  19     namespace); it doesn't deal with input buffering or prompting or
  20     input file naming (the filename is always passed in explicitly).
  21
  22     """
  23
  24     def __init__(self, locals=None):
  25         """Constructor.
  26
  27         The optional 'locals' argument specifies the dictionary in
  28         which code will be executed; it defaults to a newly created
  29         dictionary with key "__name__" set to "__console__" and key
  30         "__doc__" set to None.
  31
  32         """
  33         if locals is None:
  34             locals = {"__name__": "__console__", "__doc__": None}
  35         self.locals = locals
  36         self.compile = CommandCompiler()
  37
  38     def runsource(self, source, filename="<input>", symbol="single"):
  39         """Compile and run some source in the interpreter.
  40
  41         Arguments are as for compile_command().
  42
  43         One several things can happen:
  44
  45         1) The input is incorrect; compile_command() raised an
  46         exception (SyntaxError or OverflowError).  A syntax traceback
  47         will be printed by calling the showsyntaxerror() method.
  48
  49         2) The input is incomplete, and more input is required;
  50         compile_command() returned None.  Nothing happens.
  51
  52         3) The input is complete; compile_command() returned a code
  53         object.  The code is executed by calling self.runcode() (which
  54         also handles run-time exceptions, except for SystemExit).
  55
  56         The return value is True in case 2, False in the other cases (unless
  57         an exception is raised).  The return value can be used to
  58         decide whether to use sys.ps1 or sys.ps2 to prompt the next
  59         line.
  60
  61         """
  62         try:
  63             code = self.compile(source, filename, symbol)
  64         except (OverflowError, SyntaxError, ValueError):
  65             # Case 1
  66             self.showsyntaxerror(filename)
  67             return False
  68
  69         if code is None:
  70             # Case 2
  71             return True
  72
  73         # Case 3
  74         self.runcode(code)
  75         return False
  76
  77     def runcode(self, code):
  78         """Execute a code object.
  79
  80         When an exception occurs, self.showtraceback() is called to
  81         display a traceback.  All exceptions are caught except
  82         SystemExit, which is reraised.
  83
  84         A note about KeyboardInterrupt: this exception may occur
  85         elsewhere in this code, and may not always be caught.  The
  86         caller should be prepared to deal with it.
  87
  88         """
  89         try:
  90             exec(code, self.locals)
  91         except SystemExit:
  92             raise
  93         except:
  94             self.showtraceback()
  95
  96     def showsyntaxerror(self, filename=None):
  97         """Display the syntax error that just occurred.
  98
  99         This doesn't display a stack trace because there isn't one.
 100
 101         If a filename is given, it is stuffed in the exception instead
 102         of what was there before (because Python's parser always uses
 103         "<string>" when reading from a string).
 104
 105         The output is written by self.write(), below.
 106
 107         """
 108         type, value, sys.last_traceback = sys.exc_info()
 109         sys.last_type = type
 110         sys.last_value = value
 111         if filename and type is SyntaxError:
 112             # Work hard to stuff the correct filename in the exception
 113             try:
 114                 msg, (dummy_filename, lineno, offset, line) = value.args
 115             except ValueError:
 116                 # Not the format we expect; leave it alone
 117                 pass
 118             else:
 119                 # Stuff in the right filename
 120                 value = SyntaxError(msg, (filename, lineno, offset, line))
 121                 sys.last_value = value
 122         lines = traceback.format_exception_only(type, value)
 123         self.write(''.join(lines))
 124
 125     def showtraceback(self):
 126         """Display the exception that just occurred.
 127
 128         We remove the first stack item because it is our own code.
 129
 130         The output is written by self.write(), below.
 131
 132         """
 133         try:
 134             type, value, tb = sys.exc_info()
 135             sys.last_type = type
 136             sys.last_value = value
 137             sys.last_traceback = tb
 138             tblist = traceback.extract_tb(tb)
 139             del tblist[:1]
 140             lines = traceback.format_list(tblist)
 141             if lines:
 142                 lines.insert(0, "Traceback (most recent call last):\n")
 143             lines.extend(traceback.format_exception_only(type, value))
 144         finally:
 145             tblist = tb = None
 146         self.write(''.join(lines))
 147
 148     def write(self, data):
 149         """Write a string.
 150
 151         The base implementation writes to sys.stderr; a subclass may
 152         replace this with a different implementation.
 153
 154         """
 155         sys.stderr.write(data)
 156
 157
 158 class InteractiveConsole(InteractiveInterpreter):
 159     """Closely emulate the behavior of the interactive Python interpreter.
 160
 161     This class builds on InteractiveInterpreter and adds prompting
 162     using the familiar sys.ps1 and sys.ps2, and input buffering.
 163
 164     """
 165
 166     def __init__(self, locals=None, filename="<console>"):
 167         """Constructor.
 168
 169         The optional locals argument will be passed to the
 170         InteractiveInterpreter base class.
 171
 172         The optional filename argument should specify the (file)name
 173         of the input stream; it will show up in tracebacks.
 174
 175         """
 176         InteractiveInterpreter.__init__(self, locals)
 177         self.filename = filename
 178         self.resetbuffer()
 179
 180     def resetbuffer(self):
 181         """Reset the input buffer."""
 182         self.buffer = []
 183
 184     def interact(self, banner=None):
 185         """Closely emulate the interactive Python console.
 186
 187         The optional banner argument specifies the banner to print
 188         before the first interaction; by default it prints a banner
 189         similar to the one printed by the real Python interpreter,
 190         followed by the current class name in parentheses (so as not
 191         to confuse this with the real interpreter -- since it's so
 192         close!).
 193
 194         """
 195         try:
 196             sys.ps1
 197         except AttributeError:
 198             sys.ps1 = ">>> "
 199         try:
 200             sys.ps2
 201         except AttributeError:
 202             sys.ps2 = "... "
 203         cprt = 'Type "help", "copyright", "credits" or "license" for more information.'
 204         if banner is None:
 205             self.write("Python %s on %s\n%s\n(%s)\n" %
 206                        (sys.version, sys.platform, cprt,
 207                         self.__class__.__name__))
 208         else:
 209             self.write("%s\n" % str(banner))
 210         more = 0
 211         while 1:
 212             try:
 213                 if more:
 214                     prompt = sys.ps2
 215                 else:
 216                     prompt = sys.ps1
 217                 try:
 218                     line = self.raw_input(prompt)
 219                 except EOFError:
 220                     self.write("\n")
 221                     break
 222                 else:
 223                     more = self.push(line)
 224             except KeyboardInterrupt:
 225                 self.write("\nKeyboardInterrupt\n")
 226                 self.resetbuffer()
 227                 more = 0
 228
 229     def push(self, line):
 230         """Push a line to the interpreter.
 231
 232         The line should not have a trailing newline; it may have
 233         internal newlines.  The line is appended to a buffer and the
 234         interpreter's runsource() method is called with the
 235         concatenated contents of the buffer as source.  If this
 236         indicates that the command was executed or invalid, the buffer
 237         is reset; otherwise, the command is incomplete, and the buffer
 238         is left as it was after the line was appended.  The return
 239         value is 1 if more input is required, 0 if the line was dealt
 240         with in some way (this is the same as runsource()).
 241
 242         """
 243         self.buffer.append(line)
 244         source = "\n".join(self.buffer)
 245         more = self.runsource(source, self.filename)
 246         if not more:
 247             self.resetbuffer()
 248         return more
 249
 250     def raw_input(self, prompt=""):
 251         """Write a prompt and read a line.
 252
 253         The returned line does not include the trailing newline.
 254         When the user enters the EOF key sequence, EOFError is raised.
 255
 256         The base implementation uses the built-in function
 257         input(); a subclass may replace this with a different
 258         implementation.
 259
 260         """
 261         return input(prompt)
 262
 263
 264
 265 def interact(banner=None, readfunc=None, local=None):
 266     """Closely emulate the interactive Python interpreter.
 267
 268     This is a backwards compatible interface to the InteractiveConsole
 269     class.  When readfunc is not specified, it attempts to import the
 270     readline module to enable GNU readline if it is available.
 271
 272     Arguments (all optional, all default to None):
 273
 274     banner -- passed to InteractiveConsole.interact()
 275     readfunc -- if not None, replaces InteractiveConsole.raw_input()
 276     local -- passed to InteractiveInterpreter.__init__()
 277
 278     """
 279     console = InteractiveConsole(local)
 280     if readfunc is not None:
 281         console.raw_input = readfunc
 282     else:
 283         try:
 284             import readline
 285         except ImportError:
 286             pass
 287     console.interact(banner)
 288
 289
 290 if __name__ == '__main__':
 291     import pdb
 292     pdb.run("interact()\n")