Isolate the displayhook created by ipython0. This fixes a test not

passing due to the side-effects of testing the prefilterfrontend.

IPython/frontend/prefilterfrontend.py

@@ -1,192 +1,203 b''
 """
 Frontend class that uses IPython0 to prefilter the inputs.
 
 Using the IPython0 mechanism gives us access to the magics.
 
 This is a transitory class, used here to do the transition between
 ipython0 and ipython1. This class is meant to be short-lived as more
 functionnality is abstracted out of ipython0 in reusable functions and
 is added on the interpreter. This class can be a used to guide this
 refactoring.
 """
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 import sys
 
 from linefrontendbase import LineFrontEndBase, common_prefix
 
 from IPython.ipmaker import make_IPython
 from IPython.ipapi import IPApi
 from IPython.kernel.core.redirector_output_trap import RedirectorOutputTrap
 
 from IPython.kernel.core.sync_traceback_trap import SyncTracebackTrap
 
 from IPython.genutils import Term
 import pydoc
 import os
 
 
 def mk_system_call(system_call_function, command):
     """ given a os.system replacement, and a leading string command,
         returns a function that will execute the command with the given
         argument string.
     """
     def my_system_call(args):
         system_call_function("%s %s" % (command, args))
     return my_system_call
 
 #-------------------------------------------------------------------------------
 # Frontend class using ipython0 to do the prefiltering. 
 #-------------------------------------------------------------------------------
 class PrefilterFrontEnd(LineFrontEndBase):
     """ Class that uses ipython0 to do prefilter the input, do the
     completion and the magics.
 
     The core trick is to use an ipython0 instance to prefilter the
     input, and share the namespace between the interpreter instance used
     to execute the statements and the ipython0 used for code
     completion...
     """
     
     def __init__(self, *args, **kwargs):
         LineFrontEndBase.__init__(self, *args, **kwargs)
+        self.save_output_hooks()
         # Instanciate an IPython0 interpreter to be able to use the
         # prefiltering.
         self.ipython0 = make_IPython()
         # Set the pager:
         self.ipython0.set_hook('show_in_pager', 
                     lambda s, string: self.write("\n"+string))
         self.ipython0.write = self.write
         self._ip = _ip = IPApi(self.ipython0)
         # XXX: Hack: mix the two namespaces
         self.shell.user_ns = self.ipython0.user_ns
         self.shell.user_global_ns = self.ipython0.user_global_ns
         # Make sure the raw system call doesn't get called, as we don't
         # have a stdin accessible.
         self._ip.system = self.system_call
         # XXX: Muck around with magics so that they work better
         # in our environment
         self.ipython0.magic_ls = mk_system_call(self.system_call, 
                                                             'ls -CF')
+        # And now clean up the mess created by ipython0
+        self.release_output()
         self.shell.output_trap = RedirectorOutputTrap(
                             out_callback=self.write,
                             err_callback=self.write,
                                             )
         self.shell.traceback_trap = SyncTracebackTrap(
                         formatters=self.shell.traceback_trap.formatters,
                             )
-        # Capture and release the outputs, to make sure all the
-        # shadow variables are set
-        self.capture_output()
-        self.release_output()
 
     #--------------------------------------------------------------------------
     # FrontEndBase interface 
     #--------------------------------------------------------------------------
 
     def show_traceback(self):
         """ Use ipython0 to capture the last traceback and display it.
         """
         self.capture_output()
         self.ipython0.showtraceback()
         self.release_output()
 
 
     def execute(self, python_string, raw_string=None):
         self.capture_output()
         LineFrontEndBase.execute(self, python_string,
                                     raw_string=raw_string)
         self.release_output()
 
 
+    def save_output_hooks(self):
+        """ Store all the output hooks we can think of, to be able to
+        restore them. 
+        
+        We need to do this early, as starting the ipython0 instance will
+        screw ouput hooks.
+        """
+        self.__old_cout_write = Term.cout.write
+        self.__old_cerr_write = Term.cerr.write
+        self.__old_stdout = sys.stdout
+        self.__old_stderr= sys.stderr
+        self.__old_help_output = pydoc.help.output
+        self.__old_display_hook = sys.displayhook
+
+
     def capture_output(self):
         """ Capture all the output mechanisms we can think of.
         """
-        self.__old_cout_write = Term.cout.write
-        self.__old_err_write = Term.cerr.write
+        self.save_output_hooks()
         Term.cout.write = self.write
         Term.cerr.write = self.write
-        self.__old_stdout = sys.stdout
-        self.__old_stderr= sys.stderr
         sys.stdout = Term.cout
         sys.stderr = Term.cerr
-        self.__old_help_output = pydoc.help.output
         pydoc.help.output = self.shell.output_trap.out
 
 
     def release_output(self):
         """ Release all the different captures we have made.
         """
         Term.cout.write = self.__old_cout_write
-        Term.cerr.write = self.__old_err_write
+        Term.cerr.write = self.__old_cerr_write
         sys.stdout = self.__old_stdout
         sys.stderr = self.__old_stderr
         pydoc.help.output = self.__old_help_output 
+        sys.displayhook = self.__old_display_hook 
 
 
     def complete(self, line):
         word = line.split('\n')[-1].split(' ')[-1]
         completions = self.ipython0.complete(word)
         # FIXME: The proper sort should be done in the complete method.
         key = lambda x: x.replace('_', '')
         completions.sort(key=key)
         if completions:
             prefix = common_prefix(completions) 
             line = line[:-len(word)] + prefix
         return line, completions 
  
     
     #--------------------------------------------------------------------------
     # LineFrontEndBase interface 
     #--------------------------------------------------------------------------
 
     def prefilter_input(self, input_string):
         """ Using IPython0 to prefilter the commands to turn them
         in executable statements that are valid Python strings.
         """
         input_string = LineFrontEndBase.prefilter_input(self, input_string)
         filtered_lines = []
         # The IPython0 prefilters sometime produce output. We need to
         # capture it.
         self.capture_output()
         self.last_result = dict(number=self.prompt_number)
         try:
             for line in input_string.split('\n'):
                 filtered_lines.append(self.ipython0.prefilter(line, False))
         except:
             # XXX: probably not the right thing to do.
             self.ipython0.showsyntaxerror()
             self.after_execute()
         finally:
             self.release_output()
 
         filtered_string = '\n'.join(filtered_lines)
         return filtered_string
 
 
     #--------------------------------------------------------------------------
     # PrefilterFrontEnd interface 
     #--------------------------------------------------------------------------
  
     def system_call(self, command_string):
         """ Allows for frontend to define their own system call, to be
             able capture output and redirect input.
         """
         return os.system(command_string)
 
 
     def do_exit(self):
         """ Exit the shell, cleanup and save the history.
         """
         self.ipython0.atexit_operations()
 

IPython/frontend/tests/test_prefilterfrontend.py

@@ -1,129 +1,130 b''
 # encoding: utf-8
 """
 Test process execution and IO redirection.
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is
 #  in the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 from IPython.frontend.prefilterfrontend import PrefilterFrontEnd
 from cStringIO import StringIO
 import string
+import sys
 
 class TestPrefilterFrontEnd(PrefilterFrontEnd):
     
     input_prompt_template = string.Template('')
     output_prompt_template = string.Template('')
 
     def __init__(self):
         self.out = StringIO()
         PrefilterFrontEnd.__init__(self)
 
     def write(self, string):
        self.out.write(string) 
 
     def _on_enter(self):
         self.input_buffer += '\n'
         PrefilterFrontEnd._on_enter(self)
 
 
 def test_execution():
     """ Test execution of a command.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'print 1\n'
     f._on_enter()
     assert f.out.getvalue() == '1\n'
 
 
 def test_multiline():
     """ Test execution of a multiline command.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'if True:'
     f._on_enter()
     f.input_buffer += 'print 1'
     f._on_enter()
     assert f.out.getvalue() == ''
     f._on_enter()
     assert f.out.getvalue() == '1\n'
     f = TestPrefilterFrontEnd()
     f.input_buffer='(1 +'
     f._on_enter()
     f.input_buffer += '0)'
     f._on_enter()
     assert f.out.getvalue() == ''
     f._on_enter()
     assert f.out.getvalue() == '1\n'
 
 
 def test_capture():
     """ Test the capture of output in different channels.
     """
     # Test on the OS-level stdout, stderr.
     f = TestPrefilterFrontEnd()
     f.input_buffer = \
             'import os; out=os.fdopen(1, "w"); out.write("1") ; out.flush()'
     f._on_enter()
     assert f.out.getvalue() == '1'
     f = TestPrefilterFrontEnd()
     f.input_buffer = \
             'import os; out=os.fdopen(2, "w"); out.write("1") ; out.flush()'
     f._on_enter()
     assert f.out.getvalue() == '1'
 
      
 def test_magic():
     """ Test the magic expansion and history.
     
         This test is fairly fragile and will break when magics change.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer += '%who\n'
     f._on_enter()
     assert f.out.getvalue() == 'Interactive namespace is empty.\n'
 
 
 def test_help():
     """ Test object inspection.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer += "def f():"
     f._on_enter()
     f.input_buffer += "'foobar'"
     f._on_enter()
     f.input_buffer += "pass"
     f._on_enter()
     f._on_enter()
     f.input_buffer += "f?"
     f._on_enter()
     assert f.out.getvalue().split()[-1] == 'foobar' 
 
 
 def test_completion():
     """ Test command-line completion.
     """
     f = TestPrefilterFrontEnd()
     f.input_buffer = 'zzza = 1'
     f._on_enter()
     f.input_buffer = 'zzzb = 2'
     f._on_enter()
     f.input_buffer = 'zz'
     f.complete_current_input()
     assert f.out.getvalue() == '\nzzza zzzb '
     assert f.input_buffer == 'zzz'
 
 
 if __name__ == '__main__':
     test_magic()
     test_help()
     test_execution()
     test_multiline()
     test_capture()
     test_completion()

IPython/frontend/wx/console_widget.py

@@ -1,415 +1,413 b''
 # encoding: utf-8
 """
 A Wx widget to act as a console and input commands.
 
 This widget deals with prompts and provides an edit buffer
 restricted to after the last prompt.
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is
 #  in the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import wx
 import wx.stc  as  stc
 
 from wx.py import editwindow
 import sys
 LINESEP = '\n'
 if sys.platform == 'win32':
     LINESEP = '\n\r'
 
 import re
 
 # FIXME: Need to provide an API for non user-generated display on the
 # screen: this should not be editable by the user.
 
 _DEFAULT_SIZE = 10
 
 _DEFAULT_STYLE = {
     'stdout'      : 'fore:#0000FF',
     'stderr'      : 'fore:#007f00',
     'trace'       : 'fore:#FF0000',
 
     'default'     : 'size:%d' % _DEFAULT_SIZE,
     'bracegood'   : 'fore:#FFFFFF,back:#0000FF,bold',
     'bracebad'    : 'fore:#000000,back:#FF0000,bold',
 
     # properties for the various Python lexer styles
     'comment'       : 'fore:#007F00',
     'number'        : 'fore:#007F7F',
     'string'        : 'fore:#7F007F,italic',
     'char'          : 'fore:#7F007F,italic',
     'keyword'       : 'fore:#00007F,bold',
     'triple'        : 'fore:#7F0000',
     'tripledouble'  : 'fore:#7F0000',
     'class'         : 'fore:#0000FF,bold,underline',
     'def'           : 'fore:#007F7F,bold',
     'operator'      : 'bold'
     }
 
 # new style numbers
 _STDOUT_STYLE = 15
 _STDERR_STYLE = 16
 _TRACE_STYLE  = 17
 
 
 # system colors
 #SYS_COLOUR_BACKGROUND = wx.SystemSettings.GetColour(wx.SYS_COLOUR_BACKGROUND)
 
 #-------------------------------------------------------------------------------
 # The console widget class
 #-------------------------------------------------------------------------------
 class ConsoleWidget(editwindow.EditWindow):
     """ Specialized styled text control view for console-like workflow.
 
         This widget is mainly interested in dealing with the prompt and
         keeping the cursor inside the editing line.
     """
 
     # This is where the title captured from the ANSI escape sequences are
     # stored.
     title = 'Console'
 
     # The buffer being edited.
     def _set_input_buffer(self, string):
         self.SetSelection(self.current_prompt_pos, self.GetLength())
         self.ReplaceSelection(string)
         self.GotoPos(self.GetLength())
 
     def _get_input_buffer(self):
         """ Returns the text in current edit buffer.
         """
         input_buffer = self.GetTextRange(self.current_prompt_pos,
                                                 self.GetLength())
         input_buffer = input_buffer.replace(LINESEP, '\n')
         return input_buffer
 
     input_buffer = property(_get_input_buffer, _set_input_buffer)
 
     style = _DEFAULT_STYLE.copy()
 
     # Translation table from ANSI escape sequences to color. Override
     # this to specify your colors.
     ANSI_STYLES = {'0;30': [0, 'BLACK'],            '0;31': [1, 'RED'],
                    '0;32': [2, 'GREEN'],            '0;33': [3, 'BROWN'],
                    '0;34': [4, 'BLUE'],             '0;35': [5, 'PURPLE'],
                    '0;36': [6, 'CYAN'],             '0;37': [7, 'LIGHT GREY'],
                    '1;30': [8, 'DARK GREY'],        '1;31': [9, 'RED'],
                    '1;32': [10, 'SEA GREEN'],       '1;33': [11, 'YELLOW'],
                    '1;34': [12, 'LIGHT BLUE'],      '1;35':
                                                      [13, 'MEDIUM VIOLET RED'],
                    '1;36': [14, 'LIGHT STEEL BLUE'], '1;37': [15, 'YELLOW']}
 
     # The color of the carret (call _apply_style() after setting)
     carret_color = 'BLACK'
     
     #--------------------------------------------------------------------------
     # Public API
     #--------------------------------------------------------------------------
     
     def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, 
                         size=wx.DefaultSize, style=0, ):
         editwindow.EditWindow.__init__(self, parent, id, pos, size, style)
         self._configure_scintilla()
 
         self.Bind(wx.EVT_KEY_DOWN, self._on_key_down)
         self.Bind(wx.EVT_KEY_UP, self._on_key_up)
     
 
     def write(self, text, refresh=True):
         """ Write given text to buffer, while translating the ansi escape
             sequences.
         """
         # XXX: do not put print statements to sys.stdout/sys.stderr in 
         # this method, the print statements will call this method, as 
         # you will end up with an infinit loop
-        if self.debug:
-            print >>sys.__stderr__, text
         title = self.title_pat.split(text)
         if len(title)>1:
             self.title = title[-2]
 
         text = self.title_pat.sub('', text)
         segments = self.color_pat.split(text)
         segment = segments.pop(0)
         self.GotoPos(self.GetLength())
         self.StartStyling(self.GetLength(), 0xFF)
         try:
             self.AppendText(segment)
         except UnicodeDecodeError:
             # XXX: Do I really want to skip the exception?
             pass
         
         if segments:
             for ansi_tag, text in zip(segments[::2], segments[1::2]):
                 self.StartStyling(self.GetLength(), 0xFF)
                 try:
                     self.AppendText(text)
                 except UnicodeDecodeError:
                     # XXX: Do I really want to skip the exception?
                     pass
 
                 if ansi_tag not in self.ANSI_STYLES:
                     style = 0
                 else:
                     style = self.ANSI_STYLES[ansi_tag][0]
 
                 self.SetStyling(len(text), style) 
                 
         self.GotoPos(self.GetLength())
         if refresh:
             wx.Yield()
 
    
     def new_prompt(self, prompt):
         """ Prints a prompt at start of line, and move the start of the
             current block there.
 
             The prompt can be given with ascii escape sequences.
         """
         self.write(prompt)
         # now we update our cursor giving end of prompt
         self.current_prompt_pos = self.GetLength()
         self.current_prompt_line = self.GetCurrentLine()
         wx.Yield()
         self.EnsureCaretVisible()
 
 
     def scroll_to_bottom(self):
         maxrange = self.GetScrollRange(wx.VERTICAL)
         self.ScrollLines(maxrange)
 
 
     def pop_completion(self, possibilities, offset=0):
         """ Pops up an autocompletion menu. Offset is the offset
             in characters of the position at which the menu should
             appear, relativ to the cursor.
         """
         self.AutoCompSetIgnoreCase(False)
         self.AutoCompSetAutoHide(False)
         self.AutoCompSetMaxHeight(len(possibilities))
         self.AutoCompShow(offset, " ".join(possibilities))
 
 
     def get_line_width(self):
         """ Return the width of the line in characters.
         """
         return self.GetSize()[0]/self.GetCharWidth()
 
 
     #--------------------------------------------------------------------------
     # Private API
     #--------------------------------------------------------------------------
     
     def _apply_style(self):
         """ Applies the colors for the different text elements and the
             carret.
         """
         self.SetCaretForeground(self.carret_color)
 
         #self.StyleClearAll()
         self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT,  
                           "fore:#FF0000,back:#0000FF,bold")
         self.StyleSetSpec(stc.STC_STYLE_BRACEBAD,
                           "fore:#000000,back:#FF0000,bold")
 
         for style in self.ANSI_STYLES.values():
             self.StyleSetSpec(style[0], "bold,fore:%s" % style[1])
 
    
     def _configure_scintilla(self):
         self.SetEOLMode(stc.STC_EOL_LF)
 
         # Ctrl"+" or Ctrl "-" can be used to zoomin/zoomout the text inside 
         # the widget
         self.CmdKeyAssign(ord('+'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMIN)
         self.CmdKeyAssign(ord('-'), stc.STC_SCMOD_CTRL, stc.STC_CMD_ZOOMOUT)
         # Also allow Ctrl Shift "=" for poor non US keyboard users. 
         self.CmdKeyAssign(ord('='), stc.STC_SCMOD_CTRL|stc.STC_SCMOD_SHIFT, 
                                             stc.STC_CMD_ZOOMIN)
         
         #self.CmdKeyAssign(stc.STC_KEY_PRIOR, stc.STC_SCMOD_SHIFT,
         #                                    stc.STC_CMD_PAGEUP)
 
         #self.CmdKeyAssign(stc.STC_KEY_NEXT, stc.STC_SCMOD_SHIFT,
         #                                    stc.STC_CMD_PAGEDOWN)
 
         # Keys: we need to clear some of the keys the that don't play
         # well with a console.
         self.CmdKeyClear(ord('D'), stc.STC_SCMOD_CTRL)
         self.CmdKeyClear(ord('L'), stc.STC_SCMOD_CTRL)
         self.CmdKeyClear(ord('T'), stc.STC_SCMOD_CTRL)
 
 
         self.SetEOLMode(stc.STC_EOL_CRLF)
         self.SetWrapMode(stc.STC_WRAP_CHAR)
         self.SetWrapMode(stc.STC_WRAP_WORD)
         self.SetBufferedDraw(True)
         self.SetUseAntiAliasing(True)
         self.SetLayoutCache(stc.STC_CACHE_PAGE)
         self.SetUndoCollection(False)
         self.SetUseTabs(True)
         self.SetIndent(4)
         self.SetTabWidth(4)
 
         self.EnsureCaretVisible()
         # we don't want scintilla's autocompletion to choose 
         # automaticaly out of a single choice list, as we pop it up
         # automaticaly
         self.AutoCompSetChooseSingle(False)
         self.AutoCompSetMaxHeight(10)
 
         self.SetMargins(3, 3) #text is moved away from border with 3px
         # Suppressing Scintilla margins
         self.SetMarginWidth(0, 0)
         self.SetMarginWidth(1, 0)
         self.SetMarginWidth(2, 0)
 
         self._apply_style()
 
         # Xterm escape sequences
         self.color_pat = re.compile('\x01?\x1b\[(.*?)m\x02?')
         self.title_pat = re.compile('\x1b]0;(.*?)\x07')
 
         #self.SetEdgeMode(stc.STC_EDGE_LINE)
         #self.SetEdgeColumn(80)
 
         # styles
         p = self.style
         self.StyleSetSpec(stc.STC_STYLE_DEFAULT, p['default'])
         self.StyleClearAll()
         self.StyleSetSpec(_STDOUT_STYLE, p['stdout'])
         self.StyleSetSpec(_STDERR_STYLE, p['stderr'])
         self.StyleSetSpec(_TRACE_STYLE, p['trace'])
 
         self.StyleSetSpec(stc.STC_STYLE_BRACELIGHT, p['bracegood'])
         self.StyleSetSpec(stc.STC_STYLE_BRACEBAD, p['bracebad'])
         self.StyleSetSpec(stc.STC_P_COMMENTLINE, p['comment'])
         self.StyleSetSpec(stc.STC_P_NUMBER, p['number'])
         self.StyleSetSpec(stc.STC_P_STRING, p['string'])
         self.StyleSetSpec(stc.STC_P_CHARACTER, p['char'])
         self.StyleSetSpec(stc.STC_P_WORD, p['keyword'])
         self.StyleSetSpec(stc.STC_P_WORD2, p['keyword'])
         self.StyleSetSpec(stc.STC_P_TRIPLE, p['triple'])
         self.StyleSetSpec(stc.STC_P_TRIPLEDOUBLE, p['tripledouble'])
         self.StyleSetSpec(stc.STC_P_CLASSNAME, p['class'])
         self.StyleSetSpec(stc.STC_P_DEFNAME, p['def'])
         self.StyleSetSpec(stc.STC_P_OPERATOR, p['operator'])
         self.StyleSetSpec(stc.STC_P_COMMENTBLOCK, p['comment'])
 
 
     def _on_key_down(self, event, skip=True):
         """ Key press callback used for correcting behavior for 
             console-like interfaces: the cursor is constraint to be after
             the last prompt.
 
             Return True if event as been catched.
         """
         catched = True
         # Intercept some specific keys.
         if event.KeyCode == ord('L') and event.ControlDown() :
             self.scroll_to_bottom()
         elif event.KeyCode == ord('K') and event.ControlDown() :
             self.input_buffer = ''
         elif event.KeyCode == wx.WXK_PAGEUP and event.ShiftDown():
             self.ScrollPages(-1)
         elif event.KeyCode == wx.WXK_PAGEDOWN and event.ShiftDown():
             self.ScrollPages(1)
         elif event.KeyCode == wx.WXK_UP and event.ShiftDown():
             self.ScrollLines(-1)
         elif event.KeyCode == wx.WXK_DOWN and event.ShiftDown():
             self.ScrollLines(1)
         else:
             catched = False
 
         if self.AutoCompActive():
             event.Skip()
         else:
             if event.KeyCode in (13, wx.WXK_NUMPAD_ENTER) and \
                         event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN):
                 catched = True
                 self.CallTipCancel()
                 self.write('\n')
                 # Under windows scintilla seems to be doing funny stuff to the 
                 # line returns here, but the getter for input_buffer filters 
                 # this out.
                 if sys.platform == 'win32':
                     self.input_buffer = self.input_buffer
                 self._on_enter()
 
             elif event.KeyCode == wx.WXK_HOME:
                 if event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN):
                     self.GotoPos(self.current_prompt_pos)
                     catched = True
 
                 elif event.Modifiers in  (wx.MOD_SHIFT, wx.MOD_WIN) :
                     # FIXME: This behavior is not ideal: if the selection
                     # is already started, it will jump.
                     self.SetSelectionStart(self.current_prompt_pos) 
                     self.SetSelectionEnd(self.GetCurrentPos())
                     catched = True
 
             elif event.KeyCode == wx.WXK_UP:
                 if self.GetCurrentLine() > self.current_prompt_line:
                     if self.GetCurrentLine() == self.current_prompt_line + 1 \
                             and self.GetColumn(self.GetCurrentPos()) < \
                                 self.GetColumn(self.current_prompt_pos):
                         self.GotoPos(self.current_prompt_pos)
                     else:
                         event.Skip()
                 catched = True
 
             elif event.KeyCode in (wx.WXK_LEFT, wx.WXK_BACK):
                 if self.GetCurrentPos() > self.current_prompt_pos:
                     event.Skip()
                 catched = True
 
             if skip and not catched:
                 # Put the cursor back in the edit region
                 if self.GetCurrentPos() < self.current_prompt_pos:
                     self.GotoPos(self.current_prompt_pos)
                 else:
                     event.Skip()
 
         return catched
 
 
     def _on_key_up(self, event, skip=True):
         """ If cursor is outside the editing region, put it back.
         """
         event.Skip()
         if self.GetCurrentPos() < self.current_prompt_pos:
             self.GotoPos(self.current_prompt_pos)
 
 
 
 if __name__ == '__main__':
     # Some simple code to test the console widget.
     class MainWindow(wx.Frame):
         def __init__(self, parent, id, title):
             wx.Frame.__init__(self, parent, id, title, size=(300,250))
             self._sizer = wx.BoxSizer(wx.VERTICAL)
             self.console_widget = ConsoleWidget(self)
             self._sizer.Add(self.console_widget, 1, wx.EXPAND)
             self.SetSizer(self._sizer)
             self.SetAutoLayout(1)
             self.Show(True)
 
     app = wx.PySimpleApp()
     w = MainWindow(None, wx.ID_ANY, 'ConsoleWidget')
     w.SetSize((780, 460))
     w.Show()
 
     app.MainLoop()
 
 

IPython/frontend/wx/ipythonx.py

@@ -1,78 +1,78 b''
 """
 Entry point for a simple application giving a graphical frontend to
 ipython.
 """
 
 import wx
 from wx_frontend import WxController
 import __builtin__
 
 class IPythonXController(WxController):
     """ Sub class of WxController that adds some application-specific
         bindings.
     """
 
-    debug = False
+    debug = True
 
     def __init__(self, *args, **kwargs):
         WxController.__init__(self, *args, **kwargs)
         self.ipython0.ask_exit = self.do_exit
 
 
     def _on_key_down(self, event, skip=True):
         # Intercept Ctrl-D to quit
         if event.KeyCode == ord('D') and event.ControlDown() and \
                 self.input_buffer == '' and \
                 self._input_state == 'readline':
             wx.CallAfter(self.ask_exit)
         else:
             WxController._on_key_down(self, event, skip=skip) 
 
 
     def ask_exit(self):
         """ Ask the user whether to exit.
         """
         self.write('\n')
         self.capture_output()
         self.ipython0.shell.exit()
         self.release_output()
         wx.Yield()
         if not self.ipython0.exit_now:
             self.new_prompt(self.input_prompt_template.substitute(
                                 number=self.last_result['number'] + 1))
  
 
     def do_exit(self):
         """ Exits the interpreter, kills the windows.
         """
         WxController.do_exit(self)
         self.release_output()
         wx.CallAfter(wx.Exit)
 
 
 
 class IPythonX(wx.Frame):
     """ Main frame of the IPythonX app.
     """
 
     def __init__(self, parent, id, title):
         wx.Frame.__init__(self, parent, id, title, size=(300,250))
         self._sizer = wx.BoxSizer(wx.VERTICAL)
         self.shell = IPythonXController(self)
         self._sizer.Add(self.shell, 1, wx.EXPAND)
         self.SetSizer(self._sizer)
         self.SetAutoLayout(1)
         self.Show(True)
 
 
 def main():
     app = wx.PySimpleApp()
     frame = IPythonX(None, wx.ID_ANY, 'IPythonX')
     frame.shell.SetFocus()
     frame.shell.app = app
     frame.SetSize((680, 460))
 
     app.MainLoop()
 
 if __name__ == '__main__':
     main()

IPython/frontend/wx/wx_frontend.py

@@ -1,451 +1,465 b''
 # encoding: utf-8 -*- test-case-name:
 # FIXME: Need to add tests.
 # ipython1.frontend.wx.tests.test_wx_frontend -*-
 
 """Classes to provide a Wx frontend to the
 IPython.kernel.core.interpreter.
 
 This class inherits from ConsoleWidget, that provides a console-like
 widget to provide a text-rendering widget suitable for a terminal.
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #       Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 # Major library imports
 import re
 import __builtin__
 from time import sleep
 import sys
 from threading import Lock
 import string
 
 import wx
 from wx import stc
 
 # Ipython-specific imports.
 from IPython.frontend._process import PipedProcess
 from console_widget import ConsoleWidget
 from IPython.frontend.prefilterfrontend import PrefilterFrontEnd
 
 #-------------------------------------------------------------------------------
 # Constants 
 #-------------------------------------------------------------------------------
 
-#_COMMAND_BG = '#FAFAF1' # Nice green
-_RUNNING_BUFFER_BG = '#FDFFD3' # Nice yellow
+_COMPLETE_BUFFER_BG = '#FAFAF1' # Nice green
+_INPUT_BUFFER_BG = '#FDFFD3' # Nice yellow
 _ERROR_BG = '#FFF1F1' # Nice red
 
-_RUNNING_BUFFER_MARKER = 31
+_COMPLETE_BUFFER_MARKER = 31
 _ERROR_MARKER = 30
+_INPUT_MARKER = 29
 
 prompt_in1 = \
         '\n\x01\x1b[0;34m\x02In [\x01\x1b[1;34m\x02$number\x01\x1b[0;34m\x02]: \x01\x1b[0m\x02'
 
 prompt_out = \
     '\x01\x1b[0;31m\x02Out[\x01\x1b[1;31m\x02$number\x01\x1b[0;31m\x02]: \x01\x1b[0m\x02'
 
 #-------------------------------------------------------------------------------
 # Classes to implement the Wx frontend
 #-------------------------------------------------------------------------------
 class WxController(ConsoleWidget, PrefilterFrontEnd):
     """Classes to provide a Wx frontend to the
     IPython.kernel.core.interpreter.
 
     This class inherits from ConsoleWidget, that provides a console-like
     widget to provide a text-rendering widget suitable for a terminal.
     """
 
     output_prompt_template = string.Template(prompt_out)
 
     input_prompt_template = string.Template(prompt_in1)
 
     # Print debug info on what is happening to the console.
     debug = True
 
     # The title of the terminal, as captured through the ANSI escape
     # sequences.
     def _set_title(self, title):
             return self.Parent.SetTitle(title)
 
     def _get_title(self):
             return self.Parent.GetTitle()
 
     title = property(_get_title, _set_title)
 
 
     # The buffer being edited.
     # We are duplicating the defination here because of multiple
     # inheritence
     def _set_input_buffer(self, string):
         return ConsoleWidget._set_input_buffer(self, string)
 
     def _get_input_buffer(self):
         """ Returns the text in current edit buffer.
         """
         return ConsoleWidget._get_input_buffer(self)
 
     input_buffer = property(_get_input_buffer, _set_input_buffer)
 
 
     #--------------------------------------------------------------------------
     # Private Attributes
     #--------------------------------------------------------------------------
 
     # A flag governing the behavior of the input. Can be:
     #
     #       'readline' for readline-like behavior with a prompt 
     #            and an edit buffer.
     #       'subprocess' for sending the raw input directly to a
     #           subprocess.
     #       'buffering' for buffering of the input, that will be used
     #           when the input state switches back to another state.
     _input_state = 'readline'
 
     # Attribute to store reference to the pipes of a subprocess, if we
     # are running any.
     _running_process = False
 
     # A queue for writing fast streams to the screen without flooding the
     # event loop
     _out_buffer = []
 
     # A lock to lock the _out_buffer to make sure we don't empty it
     # while it is being swapped
     _out_buffer_lock = Lock()
 
+    _markers = dict()
+
     #--------------------------------------------------------------------------
     # Public API
     #--------------------------------------------------------------------------
  
     def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition,
                  size=wx.DefaultSize, style=wx.CLIP_CHILDREN,
                  *args, **kwds):
         """ Create Shell instance.
         """
         ConsoleWidget.__init__(self, parent, id, pos, size, style)
         PrefilterFrontEnd.__init__(self)
 
-        # Marker for running buffer.
-        self.MarkerDefine(_RUNNING_BUFFER_MARKER, stc.STC_MARK_BACKGROUND,
-                                background=_RUNNING_BUFFER_BG)
+        # Marker for complete buffer.
+        self.MarkerDefine(_COMPLETE_BUFFER_MARKER, stc.STC_MARK_BACKGROUND,
+                                background=_COMPLETE_BUFFER_BG)
+        # Marker for current input buffer.
+        self.MarkerDefine(_INPUT_MARKER, stc.STC_MARK_BACKGROUND,
+                                background=_INPUT_BUFFER_BG)
         # Marker for tracebacks.
         self.MarkerDefine(_ERROR_MARKER, stc.STC_MARK_BACKGROUND,
                                 background=_ERROR_BG)
 
         # A time for flushing the write buffer
         BUFFER_FLUSH_TIMER_ID = 100
         self._buffer_flush_timer = wx.Timer(self, BUFFER_FLUSH_TIMER_ID)
         wx.EVT_TIMER(self, BUFFER_FLUSH_TIMER_ID, self._buffer_flush)
 
+        # Inject self in namespace, for debug
+        if self.debug:
+            self.shell.user_ns['self'] = self
+
 
     def raw_input(self, prompt):
         """ A replacement from python's raw_input.
         """
         self.new_prompt(prompt)
         self.waiting = True
         self.__old_on_enter = self._on_enter
         def my_on_enter():
             self.waiting = False
         self._on_enter = my_on_enter
         # XXX: Busy waiting, ugly.
         while self.waiting:
             wx.Yield()
             sleep(0.1)
         self._on_enter = self.__old_on_enter
         self._input_state = 'buffering'
         return self.input_buffer.rstrip('\n')
 
 
     def system_call(self, command_string):
         self._input_state = 'subprocess'
         self._running_process = PipedProcess(command_string, 
                     out_callback=self.buffered_write,
                     end_callback = self._end_system_call)
         self._running_process.start()
         # XXX: another one of these polling loops to have a blocking
         # call
         wx.Yield()
         while self._running_process:
             wx.Yield()
             sleep(0.1)
         # Be sure to flush the buffer.
         self._buffer_flush(event=None)
 
 
     def do_calltip(self):
         """ Analyse current and displays useful calltip for it.
         """
         if self.debug:
             print >>sys.__stdout__, "do_calltip" 
         separators =  re.compile('[\s\{\}\[\]\(\)\= ,:]')
         symbol = self.input_buffer
         symbol_string = separators.split(symbol)[-1]
         base_symbol_string = symbol_string.split('.')[0]
         if base_symbol_string in self.shell.user_ns:
             symbol = self.shell.user_ns[base_symbol_string]
         elif base_symbol_string in self.shell.user_global_ns:
             symbol = self.shell.user_global_ns[base_symbol_string]
         elif base_symbol_string in __builtin__.__dict__:
             symbol = __builtin__.__dict__[base_symbol_string]
         else:
             return False
         for name in symbol_string.split('.')[1:] + ['__doc__']:
             symbol = getattr(symbol, name)
         try:
             self.AutoCompCancel()
             wx.Yield()
             self.CallTipShow(self.GetCurrentPos(), symbol)
         except:
             # The retrieve symbol couldn't be converted to a string
             pass
 
 
     def _popup_completion(self, create=False):
         """ Updates the popup completion menu if it exists. If create is 
             true, open the menu.
         """
         if self.debug:
             print >>sys.__stdout__, "_popup_completion", 
         line = self.input_buffer
         if (self.AutoCompActive() and not line[-1] == '.') \
                     or create==True:
             suggestion, completions = self.complete(line)
             offset=0
             if completions:
                 complete_sep =  re.compile('[\s\{\}\[\]\(\)\= ,:]')
                 residual = complete_sep.split(line)[-1]
                 offset = len(residual)
                 self.pop_completion(completions, offset=offset)
                 if self.debug:
                     print >>sys.__stdout__, completions 
 
 
     def buffered_write(self, text):
         """ A write method for streams, that caches the stream in order
             to avoid flooding the event loop.
 
             This can be called outside of the main loop, in separate
             threads.
         """
         self._out_buffer_lock.acquire()
         self._out_buffer.append(text)
         self._out_buffer_lock.release()
         if not self._buffer_flush_timer.IsRunning():
             wx.CallAfter(self._buffer_flush_timer.Start, 100)  # milliseconds
 
 
     #--------------------------------------------------------------------------
     # LineFrontEnd interface 
     #--------------------------------------------------------------------------
  
     def execute(self, python_string, raw_string=None):
         self._input_state = 'buffering'
         self.CallTipCancel()
         self._cursor = wx.BusyCursor()
         if raw_string is None:
             raw_string = python_string
         end_line = self.current_prompt_line \
                         + max(1,  len(raw_string.split('\n'))-1)
         for i in range(self.current_prompt_line, end_line):
-            self.MarkerAdd(i, _RUNNING_BUFFER_MARKER)
+            if i in self._markers:
+                self.MarkerDeleteHandle(self._markers[i])
+            self._markers[i] = self.MarkerAdd(i, _COMPLETE_BUFFER_MARKER)
         # Update the display:
         wx.Yield()
         self.GotoPos(self.GetLength())
         PrefilterFrontEnd.execute(self, python_string, raw_string=raw_string)
 
 
     def capture_output(self):
         self.__old_raw_input = __builtin__.raw_input
         __builtin__.raw_input = self.raw_input
         PrefilterFrontEnd.capture_output(self)
         
     
     def release_output(self):
         __builtin__.raw_input = self.__old_raw_input
-        PrefilterFrontEnd.capture_output(self)
+        PrefilterFrontEnd.release_output(self)
 
 
     def after_execute(self):
         PrefilterFrontEnd.after_execute(self)
         # Clear the wait cursor
         if hasattr(self, '_cursor'):
             del self._cursor
 
 
     def show_traceback(self):
         start_line = self.GetCurrentLine()
         PrefilterFrontEnd.show_traceback(self)
         wx.Yield()
         for i in range(start_line, self.GetCurrentLine()):
-            self.MarkerAdd(i, _ERROR_MARKER)
+            self._markers[i] = self.MarkerAdd(i, _ERROR_MARKER)
 
     
     #--------------------------------------------------------------------------
     # ConsoleWidget interface 
     #--------------------------------------------------------------------------
 
     def new_prompt(self, prompt):
         """ Display a new prompt, and start a new input buffer.
         """
         self._input_state = 'readline'
         ConsoleWidget.new_prompt(self, prompt)
 
 
     def write(self, *args, **kwargs):
         # Avoid multiple inheritence, be explicit about which
         # parent method class gets called
         ConsoleWidget.write(self, *args, **kwargs)
 
 
     def _on_key_down(self, event, skip=True):
         """ Capture the character events, let the parent
             widget handle them, and put our logic afterward.
         """
         # FIXME: This method needs to be broken down in smaller ones.
         current_line_number = self.GetCurrentLine()
         if event.KeyCode in (ord('c'), ord('C')) and event.ControlDown():
             # Capture Control-C
             if self._input_state == 'subprocess':
                 if self.debug:
                     print >>sys.__stderr__, 'Killing running process'
                 self._running_process.process.kill()
             elif self._input_state == 'buffering':
                 if self.debug:
                     print >>sys.__stderr__, 'Raising KeyboardInterrupt'
                 raise KeyboardInterrupt
                 # XXX: We need to make really sure we
                 # get back to a prompt.
         elif self._input_state == 'subprocess' and (
                 ( event.KeyCode<256 and
                         not event.ControlDown() )
                     or 
                 ( event.KeyCode in (ord('d'), ord('D')) and
                   event.ControlDown())):
             #  We are running a process, we redirect keys.
             ConsoleWidget._on_key_down(self, event, skip=skip)
             char = chr(event.KeyCode)
             # Deal with some inconsistency in wx keycodes:
             if char == '\r':
                 char = '\n'
             elif not event.ShiftDown():
                 char = char.lower()
             if event.ControlDown() and event.KeyCode in (ord('d'), ord('D')):
                 char = '\04'
             self._running_process.process.stdin.write(char)
             self._running_process.process.stdin.flush()
         elif event.KeyCode in (ord('('), 57):
             # Calltips
             event.Skip()
             self.do_calltip()
         elif self.AutoCompActive():
             event.Skip()
             if event.KeyCode in (wx.WXK_BACK, wx.WXK_DELETE): 
                 wx.CallAfter(self._popup_completion, create=True)
             elif not event.KeyCode in (wx.WXK_UP, wx.WXK_DOWN, wx.WXK_LEFT,
                             wx.WXK_RIGHT):
                 wx.CallAfter(self._popup_completion)
         else:
             # Up history
             if event.KeyCode == wx.WXK_UP and (
                     ( current_line_number == self.current_prompt_line and
                         event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN) ) 
                     or event.ControlDown() ):
                 new_buffer = self.get_history_previous(
                                             self.input_buffer)
                 if new_buffer is not None:
                     self.input_buffer = new_buffer
                     if self.GetCurrentLine() > self.current_prompt_line:
                         # Go to first line, for seemless history up.
                         self.GotoPos(self.current_prompt_pos)
             # Down history
             elif event.KeyCode == wx.WXK_DOWN and (
                     ( current_line_number == self.LineCount -1 and
                         event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN) ) 
                     or event.ControlDown() ):
                 new_buffer = self.get_history_next()
                 if new_buffer is not None:
                     self.input_buffer = new_buffer
             # Tab-completion
             elif event.KeyCode == ord('\t'):
                 last_line = self.input_buffer.split('\n')[-1]
                 if not re.match(r'^\s*$', last_line):
                     self.complete_current_input()
                 else:
                     event.Skip()
             else:
                 ConsoleWidget._on_key_down(self, event, skip=skip)
 
 
     def _on_key_up(self, event, skip=True):
         """ Called when any key is released.
         """
         if event.KeyCode in (59, ord('.')):
             # Intercepting '.'
             event.Skip()
             self._popup_completion(create=True)
         else:
             ConsoleWidget._on_key_up(self, event, skip=skip)
 
 
     def _on_enter(self):
         """ Called on return key down, in readline input_state.
         """
         if self.debug:
             print >>sys.__stdout__, repr(self.input_buffer)
+        i = self.GetLineCount()
+        self._markers[i] = self.MarkerAdd(i, _INPUT_MARKER)
         PrefilterFrontEnd._on_enter(self)
 
 
     #--------------------------------------------------------------------------
     # Private API
     #--------------------------------------------------------------------------
  
     def _end_system_call(self):
         """ Called at the end of a system call.
         """
         self._input_state = 'buffering'
         self._running_process = False
 
 
     def _buffer_flush(self, event):
         """ Called by the timer to flush the write buffer.
             
             This is always called in the mainloop, by the wx timer.
         """
         self._out_buffer_lock.acquire()
         _out_buffer = self._out_buffer
         self._out_buffer = []
         self._out_buffer_lock.release()
         self.write(''.join(_out_buffer), refresh=False)
         self._buffer_flush_timer.Stop()
 
 
 if __name__ == '__main__':
     class MainWindow(wx.Frame):
         def __init__(self, parent, id, title):
             wx.Frame.__init__(self, parent, id, title, size=(300,250))
             self._sizer = wx.BoxSizer(wx.VERTICAL)
             self.shell = WxController(self)
             self._sizer.Add(self.shell, 1, wx.EXPAND)
             self.SetSizer(self._sizer)
             self.SetAutoLayout(1)
             self.Show(True)
 
     app = wx.PySimpleApp()
     frame = MainWindow(None, wx.ID_ANY, 'Ipython')
     frame.shell.SetFocus()
     frame.SetSize((680, 460))
     self = frame.shell
 
     app.MainLoop()
 

IPython/kernel/core/output_trap.py

@@ -1,105 +1,107 b''
 # encoding: utf-8
 
 """ Trap stdout/stderr."""
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 import sys
 from cStringIO import StringIO
 
 
 class OutputTrap(object):
     """ Object which can trap text sent to stdout and stderr.
     """
 
     def __init__(self, out=None, err=None):
         # Filelike objects to store stdout/stderr text.
         if out is None:
             self.out = StringIO()
         else:
             self.out = out
         if err is None:
             self.err = StringIO()
         else:
             self.err = err
 
         # Boolean to check if the stdout/stderr hook is set.
         self.out_set = False
         self.err_set = False
 
     @property
     def out_text(self):
         """ Return the text currently in the stdout buffer.
         """
         return self.out.getvalue()
 
     @property
     def err_text(self):
         """ Return the text currently in the stderr buffer.
         """
         return self.err.getvalue()
 
     def set(self):
         """ Set the hooks.
         """
 
         if sys.stdout is not self.out:
             self._out_save = sys.stdout
             sys.stdout = self.out
             self.out_set = True
 
         if sys.stderr is not self.err:
             self._err_save = sys.stderr
             sys.stderr = self.err
             self.err_set = True
 
     def unset(self):
         """ Remove the hooks.
         """
 
-        sys.stdout = self._out_save
+        if self.out_set:
+            sys.stdout = self._out_save
         self.out_set = False
 
-        sys.stderr = self._err_save
+        if self.err_set:
+            sys.stderr = self._err_save
         self.err_set = False
 
     def clear(self):
         """ Clear out the buffers.
         """
 
         self.out.reset()
         self.out.truncate()
 
         self.err.reset()
         self.err.truncate()
 
     def add_to_message(self, message):
         """ Add the text from stdout and stderr to the message from the
         interpreter to its listeners.
 
         Parameters
         ----------
         message : dict
         """
 
         out_text = self.out_text
         if out_text:
             message['stdout'] = out_text
 
         err_text = self.err_text
         if err_text:
             message['stderr'] = err_text