PageRenderTime 195ms CodeModel.GetById 90ms app.highlight 17ms RepoModel.GetById 84ms app.codeStats 0ms

/Lib/code.py

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