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