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 def 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 

    28 class 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 

   174 class 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                 except EOFError:

   236                     self.write("\n")

   237                     break

   238                 else:

   239                     more = self.push(line)

   240             except KeyboardInterrupt:

   241                 self.write("\nKeyboardInterrupt\n")

   242                 self.resetbuffer()

   243                 more = 0

   244 

   245     def push(self, line):

   246         """Push a line to the interpreter.

   247 

   248         The line should not have a trailing newline; it may have

   249         internal newlines.  The line is appended to a buffer and the

   250         interpreter's runsource() method is called with the

   251         concatenated contents of the buffer as source.  If this

   252         indicates that the command was executed or invalid, the buffer

   253         is reset; otherwise, the command is incomplete, and the buffer

   254         is left as it was after the line was appended.  The return

   255         value is 1 if more input is required, 0 if the line was dealt

   256         with in some way (this is the same as runsource()).

   257 

   258         """

   259         self.buffer.append(line)

   260         source = "\n".join(self.buffer)

   261         more = self.runsource(source, self.filename)

   262         if not more:

   263             self.resetbuffer()

   264         return more

   265 

   266     def raw_input(self, prompt=""):

   267         """Write a prompt and read a line.

   268 

   269         The returned line does not include the trailing newline.

   270         When the user enters the EOF key sequence, EOFError is raised.

   271 

   272         The base implementation uses the built-in function

   273         raw_input(); a subclass may replace this with a different

   274         implementation.

   275 

   276         """

   277         return raw_input(prompt)

   278 

   279 

   280 def interact(banner=None, readfunc=None, local=None):

   281     """Closely emulate the interactive Python interpreter.

   282 

   283     This is a backwards compatible interface to the InteractiveConsole

   284     class.  When readfunc is not specified, it attempts to import the

   285     readline module to enable GNU readline if it is available.

   286 

   287     Arguments (all optional, all default to None):

   288 

   289     banner -- passed to InteractiveConsole.interact()

   290     readfunc -- if not None, replaces InteractiveConsole.raw_input()

   291     local -- passed to InteractiveInterpreter.__init__()

   292 

   293     """

   294     console = InteractiveConsole(local)

   295     if readfunc is not None:

   296         console.raw_input = readfunc

   297     else:

   298         try:

   299             import readline

   300         except ImportError:

   301             pass

   302     console.interact(banner)

   303 

   304 

   305 if __name__ == '__main__':

   306     import pdb

   307     pdb.run("interact()\n")