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

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

   309 if __name__ == '__main__':

   310     import pdb

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