Clean up code, names, and docstrings.

IPython/frontend/_process/__init__.py

@@ -0,0 +1,19 b''
+"""
+Package for dealing for process execution in a callback environment, in a
+portable way.
+
+killable_process.py is a wrapper of subprocess.Popen that allows the
+subprocess and its children to be killed in a reliable way, including
+under windows.
+
+winprocess.py is required by killable_process.py to kill processes under
+windows.
+
+piped_process.py wraps process execution with callbacks to print output,
+in a non-blocking way. It can be used to interact with a subprocess in eg
+a GUI event loop.
+"""
+
+from pipedprocess import PipedProcess
+
+

IPython/frontend/zopeinterface.py

@@ -0,0 +1,34 b''
+# encoding: utf-8
+# -*- test-case-name: IPython.frontend.tests.test_frontendbase -*-
+"""
+zope.interface mock. If zope is installed, this module provides a zope
+interface classes, if not it provides mocks for them.
+
+Classes provided: 
+Interface, Attribute, implements, classProvides
+"""
+__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 string
+import uuid
+import _ast
+
+try:
+    from zope.interface import Interface, Attribute, implements, classProvides
+except ImportError:
+    #zope.interface is not available
+    Interface = object
+    def Attribute(name, doc): pass
+    def implements(interface): pass
+    def classProvides(interface): pass
+

IPython/frontend/_process/pipedprocess.py

@@ -15,7 +15,7 b' __docformat__ = "restructuredtext en"'
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
-from killable_process import Popen, PIPE
+from killableprocess import Popen, PIPE
 from threading import Thread
 from time import sleep
 

IPython/frontend/asyncfrontendbase.py

@@ -18,14 +18,11 b' import uuid'
 
 try:
     from zope.interface import Interface, Attribute, implements, classProvides
-except ImportError:
-    #zope.interface is not available
-    Interface = object
-    def Attribute(name, doc): pass
-    def implements(interface): pass
-    def classProvides(interface): pass
-
-
+except ImportError, e:
+    e.message = """%s
+________________________________________________________________________________
+zope.interface is required to run asynchronous frontends.""" % e.message
+    e.args = (e.message, ) + e.args[1:]
 
 from frontendbase import FrontEndBase, IFrontEnd, IFrontEndFactory
 
@@ -34,9 +31,11 b' from IPython.kernel.core.history import FrontEndHistory'
 
 try:
     from twisted.python.failure import Failure
-except ImportError:
-    #Twisted not available
-    Failure = Exception
+except ImportError, e:
+    e.message = """%s
+________________________________________________________________________________
+twisted is required to run asynchronous frontends.""" % e.message
+    e.args = (e.message, ) + e.args[1:]
 
 
 

IPython/frontend/frontendbase.py

@@ -24,14 +24,7 b' import string'
 import uuid
 import _ast
 
-try:
-    from zope.interface import Interface, Attribute, implements, classProvides
-except ImportError:
-    #zope.interface is not available
-    Interface = object
-    def Attribute(name, doc): pass
-    def implements(interface): pass
-    def classProvides(interface): pass
+from zopeinterface import Interface, Attribute, implements, classProvides
 
 from IPython.kernel.core.history import FrontEndHistory
 from IPython.kernel.core.util import Bunch
@@ -46,6 +39,8 b" rc.prompt_in2 = r'...'"
 rc.prompt_out = r'Out [$number]:  '
 
 ##############################################################################
+# Interface definitions
+##############################################################################
 
 class IFrontEndFactory(Interface):
     """Factory interface for frontends."""
@@ -59,7 +54,6 b' class IFrontEndFactory(Interface):'
         pass
 
 
-
 class IFrontEnd(Interface):
     """Interface for frontends. All methods return t.i.d.Deferred"""
     
@@ -72,9 +66,10 b' class IFrontEnd(Interface):'
     
     def update_cell_prompt(result, blockID=None):
         """Subclass may override to update the input prompt for a block. 
-        Since this method will be called as a 
-        twisted.internet.defer.Deferred's callback/errback,
-        implementations should return result when finished.
+
+        In asynchronous frontends, this method will be called as a
+        twisted.internet.defer.Deferred's callback/errback.
+        Implementations should thus return result when finished.
         
         Result is a result dict in case of success, and a
         twisted.python.util.failure.Failure in case of an error
@@ -82,7 +77,6 b' class IFrontEnd(Interface):'
         
         pass
     
-    
     def render_result(result):
         """Render the result of an execute call. Implementors may choose the
          method of rendering.
@@ -100,16 +94,17 b' class IFrontEnd(Interface):'
         pass
     
     def render_error(failure):
-        """Subclasses must override to render the failure. Since this method 
-        will be called as a twisted.internet.defer.Deferred's callback, 
-        implementations should return result when finished.
+        """Subclasses must override to render the failure. 
+        
+        In asynchronous frontend, since this method will be called as a
+        twisted.internet.defer.Deferred's callback. Implementations
+        should thus return result when finished.
         
         blockID = failure.blockID
         """
         
         pass
     
-    
     def input_prompt(number=''):
         """Returns the input prompt by subsituting into 
         self.input_prompt_template
@@ -140,7 +135,6 b' class IFrontEnd(Interface):'
         
         pass
     
-    
     def get_history_previous(current_block):
         """Returns the block previous in  the history. Saves currentBlock if
         the history_cursor is currently at the end of the input history"""
@@ -151,6 +145,20 b' class IFrontEnd(Interface):'
         
         pass
     
+    def complete(self, line):
+        """Returns the list of possible completions, and the completed
+            line.
+
+        The input argument is the full line to be completed. This method
+        returns both the line completed as much as possible, and the list
+        of further possible completions (full words).
+        """
+        pass
+
+
+##############################################################################
+# Base class for all the frontends. 
+##############################################################################
 
 class FrontEndBase(object):
     """
@@ -321,6 +329,8 b' class FrontEndBase(object):'
     
     def update_cell_prompt(self, result, blockID=None):
         """Subclass may override to update the input prompt for a block. 
+
+        This method only really makes sens in asyncrhonous frontend.
         Since this method will be called as a 
         twisted.internet.defer.Deferred's callback, implementations should 
         return result when finished.
@@ -330,18 +340,22 b' class FrontEndBase(object):'
     
     
     def render_result(self, result):
-        """Subclasses must override to render result. Since this method will
-        be called as a twisted.internet.defer.Deferred's callback, 
-        implementations should return result when finished.
+        """Subclasses must override to render result. 
+        
+        In asynchronous frontends, this method will be called as a
+        twisted.internet.defer.Deferred's callback. Implementations
+        should thus return result when finished.
         """
         
         return result
     
     
     def render_error(self, failure):
-        """Subclasses must override to render the failure. Since this method 
-        will be called as a twisted.internet.defer.Deferred's callback, 
-        implementations should return result when finished.
+        """Subclasses must override to render the failure. 
+        
+        In asynchronous frontends, this method will be called as a
+        twisted.internet.defer.Deferred's callback. Implementations
+        should thus return result when finished.
         """
         
         return failure

IPython/frontend/linefrontendbase.py

@@ -1,5 +1,6 b''
 """
-Base front end class for all line-oriented frontends.
+Base front end class for all line-oriented frontends, rather than
+block-oriented.
 
 Currently this focuses on synchronous frontends.
 """
@@ -23,6 +24,9 b' from frontendbase import FrontEndBase'
 from IPython.kernel.core.interpreter import Interpreter
 
 def common_prefix(strings):
+    """ Given a list of strings, return the common prefix between all
+        these strings.
+    """
     ref = strings[0]
     prefix = ''
     for size in range(len(ref)):
@@ -38,6 +42,10 b' def common_prefix(strings):'
 # Base class for the line-oriented front ends
 #-------------------------------------------------------------------------------
 class LineFrontEndBase(FrontEndBase):
+    """ Concrete implementation of the FrontEndBase class. This is meant
+    to be the base class behind all the frontend that are line-oriented,
+    rather than block-oriented.
+    """
     
     # We need to keep the prompt number, to be able to increment
     # it when there is an exception.
@@ -47,7 +55,7 b' class LineFrontEndBase(FrontEndBase):'
     last_result = dict(number=0)
 
     #--------------------------------------------------------------------------
-    # Public API
+    # FrontEndBase interface
     #--------------------------------------------------------------------------
 
     def __init__(self, shell=None, history=None):
@@ -81,6 +89,9 b' class LineFrontEndBase(FrontEndBase):'
  
 
     def render_result(self, result):
+        """ Frontend-specific rendering of the result of a calculation
+        that has been sent to an engine.
+        """
         if 'stdout' in result and result['stdout']:
             self.write('\n' + result['stdout'])
         if 'display' in result and result['display']:
@@ -91,20 +102,25 b' class LineFrontEndBase(FrontEndBase):'
        
 
     def render_error(self, failure):
+        """ Frontend-specific rendering of error. 
+        """
         self.insert_text('\n\n'+str(failure)+'\n\n')
         return failure
 
 
-    def prefilter_input(self, string):
-        string = string.replace('\r\n', '\n')
-        string = string.replace('\t', 4*' ')
-        # Clean the trailing whitespace
-        string = '\n'.join(l.rstrip()  for l in string.split('\n'))
-        return string
-
-
     def is_complete(self, string):
+        """ Check if a string forms a complete, executable set of
+        commands.
+
+        For the line-oriented frontend, multi-line code is not executed
+        as soon as it is complete: the users has to enter two line
+        returns.
+        """
         if string in ('', '\n'):
+            # Prefiltering, eg through ipython0, may return an empty
+            # string although some operations have been accomplished. We
+            # thus want to consider an empty string as a complete
+            # statement.
             return True
         elif ( len(self.get_current_edit_buffer().split('\n'))>2 
                         and not re.findall(r"\n[\t ]*\n[\t ]*$", string)):
@@ -116,8 +132,8 b' class LineFrontEndBase(FrontEndBase):'
     
 
     def execute(self, python_string, raw_string=None):
-        """ Send the python_string to the interpreter, stores the
-            raw_string in the history and starts a new prompt.
+        """ Stores the raw_string in the history, and sends the
+        python string to the interpreter.
         """
         if raw_string is None:
             raw_string = python_string
@@ -133,6 +149,18 b' class LineFrontEndBase(FrontEndBase):'
         finally:
             self.after_execute()
 
+    #--------------------------------------------------------------------------
+    # LineFrontEndBase interface
+    #--------------------------------------------------------------------------
+
+    def prefilter_input(self, string):
+        """ Priflter the input to turn it in valid python.
+        """
+        string = string.replace('\r\n', '\n')
+        string = string.replace('\t', 4*' ')
+        # Clean the trailing whitespace
+        string = '\n'.join(l.rstrip()  for l in string.split('\n'))
+        return string
 
     def after_execute(self):
         """ All the operations required after an execution to put the
@@ -145,6 +173,10 b' class LineFrontEndBase(FrontEndBase):'
         self.history_cursor = len(self.history.input_cache) - 1
 
 
+    #--------------------------------------------------------------------------
+    # Private API
+    #--------------------------------------------------------------------------
+ 
     def _on_enter(self):
         """ Called when the return key is pressed in a line editing
             buffer.
@@ -160,11 +192,10 b' class LineFrontEndBase(FrontEndBase):'
                 self.write('\t')
 
 
-    #--------------------------------------------------------------------------
-    # Private API
-    #--------------------------------------------------------------------------
- 
     def _get_indent_string(self, string):
+        """ Return the string of whitespace that prefixes a line. Used to
+        add the right amount of indendation when creating a new line.
+        """
         string = string.replace('\t', ' '*4)
         string = string.split('\n')[-1]
         indent_chars = len(string) - len(string.lstrip())

IPython/frontend/prefilterfrontend.py

@@ -2,6 +2,12 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"
 
@@ -27,6 +33,8 b' 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,
@@ -41,6 +49,14 b' def mk_system_call(system_call_function, command):'
 # 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)
@@ -67,38 +83,20 b' class PrefilterFrontEnd(LineFrontEndBase):'
                             err_callback=self.write,
                                             )
         self.shell.traceback_trap = SyncTracebackTrap(
-                        formatters=self.shell.traceback_trap.formatters
+                        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()
 
-    
-    def prefilter_input(self, input_string):
-        """ Using IPython0 to prefilter the commands.
-        """
-        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
-
+    #--------------------------------------------------------------------------
+    # 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()
@@ -111,13 +109,6 b' class PrefilterFrontEnd(LineFrontEndBase):'
         self.release_output()
 
 
-    def system_call(self, command):
-        """ Allows for frontend to define their own system call, to be
-            able capture output and redirect input.
-        """
-        return os.system(command, args)
-
-
     def capture_output(self):
         """ Capture all the output mechanisms we can think of.
         """
@@ -154,6 +145,45 b' class PrefilterFrontEnd(LineFrontEndBase):'
             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
+
+
+    #--------------------------------------------------------------------------
+    # PrefilterLineFrontEnd 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.

IPython/frontend/wx/console_widget.py

@@ -76,6 +76,8 b' class ConsoleWidget(editwindow.EditWindow):'
         keeping the cursor inside the editing line.
     """
 
+    # This is where the title captured from the ANSI escape sequences are
+    # stored.
     title = 'Console'
 
     style = _DEFAULT_STYLE.copy()
@@ -102,7 +104,7 b' class ConsoleWidget(editwindow.EditWindow):'
     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._configure_scintilla()
 
         # FIXME: we need to retrieve this from the interpreter.
         self.prompt = \
@@ -113,87 +115,6 b' class ConsoleWidget(editwindow.EditWindow):'
         self.Bind(wx.EVT_KEY_UP, self._on_key_up)
     
 
-    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 write(self, text, refresh=True):
         """ Write given text to buffer, while translating the ansi escape
             sequences.
@@ -270,24 +191,20 b' class ConsoleWidget(editwindow.EditWindow):'
         return current_edit_buffer
 
 
-    #--------------------------------------------------------------------------
-    # Private API
-    #--------------------------------------------------------------------------
-    
-    def _apply_style(self):
-        """ Applies the colors for the different text elements and the
-            carret.
-        """
-        self.SetCaretForeground(self.carret_color)
+    def scroll_to_bottom(self):
+        maxrange = self.GetScrollRange(wx.VERTICAL)
+        self.ScrollLines(maxrange)
 
-        #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 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 write_completion(self, possibilities):
@@ -315,21 +232,105 b' class ConsoleWidget(editwindow.EditWindow):'
         self.new_prompt(self.prompt % (self.last_result['number'] + 1))
         self.replace_current_edit_buffer(current_buffer)
 
-
-    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.
+    #--------------------------------------------------------------------------
+    # Private API
+    #--------------------------------------------------------------------------
+    
+    def _apply_style(self):
+        """ Applies the colors for the different text elements and the
+            carret.
         """
-        self.AutoCompSetIgnoreCase(False)
-        self.AutoCompSetAutoHide(False)
-        self.AutoCompSetMaxHeight(len(possibilities))
-        self.AutoCompShow(offset, " ".join(possibilities))
+        self.SetCaretForeground(self.carret_color)
 
-    
-    def scroll_to_bottom(self):
-        maxrange = self.GetScrollRange(wx.VERTICAL)
-        self.ScrollLines(maxrange)
+        #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):
@@ -418,7 +419,6 b' class ConsoleWidget(editwindow.EditWindow):'
 
 
 
-
 if __name__ == '__main__':
     # Some simple code to test the console widget.
     class MainWindow(wx.Frame):

IPython/frontend/wx/wx_frontend.py

@@ -5,6 +5,8 b''
 """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"
@@ -20,21 +22,25 b' __docformat__ = "restructuredtext en"'
 # Imports
 #-------------------------------------------------------------------------------
 
-
-import wx
+# Major library imports
 import re
-from wx import stc
-from console_widget import ConsoleWidget
 import __builtin__
 from time import sleep
 import sys
-import signal
-
 from threading import Lock
 
-from IPython.frontend.piped_process import PipedProcess
+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
 _ERROR_BG = '#FFF1F1' # Nice red
@@ -46,7 +52,14 b' _ERROR_MARKER = 30'
 # Classes to implement the Wx frontend
 #-------------------------------------------------------------------------------
 class WxController(PrefilterFrontEnd, ConsoleWidget):
+    """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.
+    """
 
+    # FIXME: this shouldn't be there.
     output_prompt = \
     '\x01\x1b[0;31m\x02Out[\x01\x1b[1;31m\x02%i\x01\x1b[0;31m\x02]: \x01\x1b[0m\x02'
 
@@ -55,7 +68,6 b' class WxController(PrefilterFrontEnd, ConsoleWidget):'
 
     # The title of the terminal, as captured through the ANSI escape
     # sequences.
-
     def _set_title(self, title):
             return self.Parent.SetTitle(title)
 
@@ -114,8 +126,43 b' class WxController(PrefilterFrontEnd, ConsoleWidget):'
         self._buffer_flush_timer = wx.Timer(self, BUFFER_FLUSH_TIMER_ID)
         wx.EVT_TIMER(self, BUFFER_FLUSH_TIMER_ID, self._buffer_flush)
 
+
+    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.get_current_edit_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_completion(self):
-        """ Do code completion. 
+        """ Do code completion on current line. 
         """
         if self.debug:
             print >>sys.__stdout__, "do_completion", 
@@ -129,6 +176,8 b' class WxController(PrefilterFrontEnd, ConsoleWidget):'
 
 
     def do_calltip(self):
+        """ Analyse current and displays useful calltip for it.
+        """
         if self.debug:
             print >>sys.__stdout__, "do_calltip" 
         separators =  re.compile('[\s\{\}\[\]\(\)\= ,:]')
@@ -154,12 +203,12 b' class WxController(PrefilterFrontEnd, ConsoleWidget):'
             pass
 
 
-    def popup_completion(self, create=False):
+    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", 
+            print >>sys.__stdout__, "_popup_completion", 
         line = self.get_current_edit_buffer()
         if (self.AutoCompActive() and not line[-1] == '.') \
                     or create==True:
@@ -174,28 +223,23 b' class WxController(PrefilterFrontEnd, ConsoleWidget):'
                     print >>sys.__stdout__, completions 
 
 
-    def new_prompt(self, prompt):
-        self._input_state = 'readline'
-        ConsoleWidget.new_prompt(self, prompt)
-
+    def buffered_write(self, text):
+        """ A write method for streams, that caches the stream in order
+            to avoid flooding the event loop.
 
-    def raw_input(self, prompt):
-        """ A replacement from python's raw_input.
+            This can be called outside of the main loop, in separate
+            threads.
         """
-        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.get_current_edit_buffer().rstrip('\n')
-        
+        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'
@@ -226,39 +270,10 b' class WxController(PrefilterFrontEnd, ConsoleWidget):'
 
     def after_execute(self):
         PrefilterFrontEnd.after_execute(self)
+        # Clear the wait cursor
         if hasattr(self, '_cursor'):
             del self._cursor
 
-    
-    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 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
-
 
     def show_traceback(self):
         start_line = self.GetCurrentLine()
@@ -266,12 +281,19 b' class WxController(PrefilterFrontEnd, ConsoleWidget):'
         wx.Yield()
         for i in range(start_line, self.GetCurrentLine()):
             self.MarkerAdd(i, _ERROR_MARKER)
-            
 
+    
     #--------------------------------------------------------------------------
-    # Private API
+    # 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 _on_key_down(self, event, skip=True):
         """ Capture the character events, let the parent
             widget handle them, and put our logic afterward.
@@ -286,8 +308,8 b' class WxController(PrefilterFrontEnd, ConsoleWidget):'
                 self._running_process.process.kill()
             elif self._input_state == 'buffering':
                 if self.debug:
-                    print >>sys.__stderr__, 'Raising KeyboardException'
-                raise KeyboardException
+                    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 (
@@ -315,10 +337,10 b' class WxController(PrefilterFrontEnd, ConsoleWidget):'
         elif self.AutoCompActive():
             event.Skip()
             if event.KeyCode in (wx.WXK_BACK, wx.WXK_DELETE): 
-                wx.CallAfter(self.popup_completion, create=True)
+                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)
+                wx.CallAfter(self._popup_completion)
         else:
             # Up history
             if event.KeyCode == wx.WXK_UP and (
@@ -352,20 +374,28 b' class WxController(PrefilterFrontEnd, ConsoleWidget):'
 
 
     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)
+            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.get_current_edit_buffer())
         PrefilterFrontEnd._on_enter(self)
 
 
+    #--------------------------------------------------------------------------
+    # Private API
+    #--------------------------------------------------------------------------
+ 
     def _end_system_call(self):
         """ Called at the end of a system call.
         """

IPython/kernel/core/sync_traceback_trap.py

@@ -22,19 +22,23 b' from IPython.ultraTB import ColorTB'
 
 class SyncTracebackTrap(TracebackTrap):
 
-    def __init__(self, sync_formatter=None, formatters=None):
+    def __init__(self, sync_formatter=None, formatters=None,
+                                                    raiseException=True):
         TracebackTrap.__init__(self, formatters=formatters)
         if sync_formatter is None:
             sync_formatter = ColorTB(color_scheme='LightBG')
         self.sync_formatter = sync_formatter
+        self.raiseException = raiseException
 
 
     def hook(self, *args):
         """ This method actually implements the hook.
         """
         self.args = args
-        
-        print self.sync_formatter(*self.args)
+        if not self.raiseException:
+            print self.sync_formatter(*self.args)
+        else:
+            raise