Clean up code, names, and docstrings.

IPython/frontend/_process/__init__.py

@@ -0,0 +1,19
+"""
+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
+# 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

@@ -1,55 +1,55
 # encoding: utf-8
 """
 Object for encapsulating process execution by using callbacks for stdout, 
 stderr and stdin.
 """
 __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
 #-------------------------------------------------------------------------------
-from killable_process import Popen, PIPE
+from killableprocess import Popen, PIPE
 from threading import Thread
 from time import sleep
 
 class PipedProcess(Thread):
 
     def __init__(self, command_string, out_callback, 
                         end_callback=None,):
         self.command_string = command_string
         self.out_callback = out_callback
         self.end_callback = end_callback
         Thread.__init__(self)
     
 
     def run(self):
         """ Start the process and hook up the callbacks.
         """
         process = Popen((self.command_string + ' 2>&1', ), shell=True,
                                 universal_newlines=True,
                                 stdout=PIPE, stdin=PIPE, )
         self.process = process
         while True:
             out_char = process.stdout.read(1)
             if out_char == '':
                 if process.poll() is not None:
                     # The process has finished
                     break
                 else:
                     # The process is not giving any interesting
                     # output. No use polling it immediatly.
                     sleep(0.1)
             else:
                 self.out_callback(out_char)
 
         if self.end_callback is not None:
             self.end_callback()
     
 

IPython/frontend/asyncfrontendbase.py

@@ -1,93 +1,92
 """
 Base front end class for all async frontends.
 """
 __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 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
 
 from IPython.kernel.engineservice import IEngineCore
 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:]
 
 
 
 
 class AsyncFrontEndBase(FrontEndBase):
     """
     Overrides FrontEndBase to wrap execute in a deferred result.
     All callbacks are made as callbacks on the deferred result.
     """
     
     implements(IFrontEnd)
     classProvides(IFrontEndFactory)
     
     def __init__(self, engine=None, history=None):
         assert(engine==None or IEngineCore.providedBy(engine))
         self.engine = IEngineCore(engine)
         if history is None:
                 self.history = FrontEndHistory(input_cache=[''])
         else:
             self.history = history
     
     
     def execute(self, block, blockID=None):
         """Execute the block and return the deferred result.
         
         Parameters:
             block : {str, AST}
             blockID : any
                 Caller may provide an ID to identify this block. 
                 result['blockID'] := blockID
         
         Result:
             Deferred result of self.interpreter.execute
         """
         
         if(not self.is_complete(block)):
             return Failure(Exception("Block is not compilable"))
         
         if(blockID == None):
             blockID = uuid.uuid4() #random UUID
         
         d = self.engine.execute(block)
         d.addCallback(self._add_history, block=block)
         d.addCallbacks(self._add_block_id_for_result,
                 errback=self._add_block_id_for_failure,
                 callbackArgs=(blockID,),
                 errbackArgs=(blockID,))
         d.addBoth(self.update_cell_prompt, blockID=blockID)
         d.addCallbacks(self.render_result, 
             errback=self.render_error)
         
         return d
     
 

IPython/frontend/frontendbase.py

@@ -1,351 +1,365
 # encoding: utf-8
 # -*- test-case-name: IPython.frontend.tests.test_frontendbase -*-
 """
 frontendbase provides an interface and base class for GUI frontends for 
 IPython.kernel/IPython.kernel.core.
 
 Frontend implementations will likely want to subclass FrontEndBase. 
 
 Author: Barry Wark
 """
 __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
+from zopeinterface import Interface, Attribute, implements, classProvides
 
 from IPython.kernel.core.history import FrontEndHistory
 from IPython.kernel.core.util import Bunch
 
 ##############################################################################
 # TEMPORARY!!! fake configuration, while we decide whether to use tconfig or
 # not
 
 rc = Bunch()
 rc.prompt_in1 = r'In [$number]:  '
 rc.prompt_in2 = r'...'
 rc.prompt_out = r'Out [$number]:  '
 
 ##############################################################################
+# Interface definitions
+##############################################################################
 
 class IFrontEndFactory(Interface):
     """Factory interface for frontends."""
     
     def __call__(engine=None, history=None):
         """
         Parameters:
         interpreter : IPython.kernel.engineservice.IEngineCore
         """
         
         pass
 
 
-
 class IFrontEnd(Interface):
     """Interface for frontends. All methods return t.i.d.Deferred"""
     
     Attribute("input_prompt_template", "string.Template instance\
                 substituteable with execute result.")
     Attribute("output_prompt_template", "string.Template instance\
                 substituteable with execute result.")
     Attribute("continuation_prompt_template", "string.Template instance\
                 substituteable with execute result.")
     
     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
         """
         
         pass
     
-    
     def render_result(result):
         """Render the result of an execute call. Implementors may choose the
          method of rendering.
         For example, a notebook-style frontend might render a Chaco plot 
         inline.
         
         Parameters:
             result : dict (result of IEngineBase.execute )
                 blockID = result['blockID']
         
         Result:
             Output of frontend rendering
         """
         
         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
         """
         pass
     
     def output_prompt(number=''):
         """Returns the output prompt by subsituting into 
         self.output_prompt_template
         """
         
         pass
     
     def continuation_prompt():
         """Returns the continuation prompt by subsituting into 
         self.continuation_prompt_template
         """
         
         pass
     
     def is_complete(block):
         """Returns True if block is complete, False otherwise."""
         
         pass
     
     def compile_ast(block):
         """Compiles block to an _ast.AST"""
         
         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"""
         pass
     
     def get_history_next():
         """Returns the next block in the history."""
         
         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):
     """
     FrontEndBase manages the state tasks for a CLI frontend:
         - Input and output history management
         - Input/continuation and output prompt generation
         
     Some issues (due to possibly unavailable engine):
         - How do we get the current cell number for the engine?
         - How do we handle completions?
     """
     
     history_cursor = 0
     
     current_indent_level = 0
     
     
     input_prompt_template = string.Template(rc.prompt_in1)
     output_prompt_template = string.Template(rc.prompt_out)
     continuation_prompt_template = string.Template(rc.prompt_in2)
     
     def __init__(self, shell=None, history=None):
         self.shell = shell
         if history is None:
                 self.history = FrontEndHistory(input_cache=[''])
         else:
             self.history = history
         
     
     def input_prompt(self, number=''):
         """Returns the current input prompt
         
         It would be great to use ipython1.core.prompts.Prompt1 here
         """
         return self.input_prompt_template.safe_substitute({'number':number})
     
     
     def continuation_prompt(self):
         """Returns the current continuation prompt"""
         
         return self.continuation_prompt_template.safe_substitute()
     
     def output_prompt(self, number=''):
         """Returns the output prompt for result"""
         
         return self.output_prompt_template.safe_substitute({'number':number})
     
     
     def is_complete(self, block):
         """Determine if block is complete.
         
         Parameters
         block : string
         
         Result 
         True if block can be sent to the engine without compile errors.
         False otherwise.
         """
         
         try:
             ast = self.compile_ast(block)
         except:
             return False
         
         lines = block.split('\n')
         return (len(lines)==1 or str(lines[-1])=='')
     
     
     def compile_ast(self, block):
         """Compile block to an AST
         
         Parameters:
             block : str
         
         Result:
             AST
         
         Throws:
             Exception if block cannot be compiled
         """
         
         return compile(block, "<string>", "exec", _ast.PyCF_ONLY_AST)
     
     
     def execute(self, block, blockID=None):
         """Execute the block and return the result.
         
         Parameters:
             block : {str, AST}
             blockID : any
                 Caller may provide an ID to identify this block. 
                 result['blockID'] := blockID
         
         Result:
             Deferred result of self.interpreter.execute
         """
         
         if(not self.is_complete(block)):
             raise Exception("Block is not compilable")
         
         if(blockID == None):
             blockID = uuid.uuid4() #random UUID
         
         try:
             result = self.shell.execute(block)
         except Exception,e:
             e = self._add_block_id_for_failure(e, blockID=blockID)
             e = self.update_cell_prompt(e, blockID=blockID)
             e = self.render_error(e)
         else:
             result = self._add_block_id_for_result(result, blockID=blockID)
             result = self.update_cell_prompt(result, blockID=blockID)
             result = self.render_result(result)
         
         return result
     
     
     def _add_block_id_for_result(self, result, blockID):
         """Add the blockID to result or failure. Unfortunatley, we have to 
         treat failures differently than result dicts.
         """
         
         result['blockID'] = blockID
         
         return result
     
     def _add_block_id_for_failure(self, failure, blockID):
         """_add_block_id_for_failure"""
         
         failure.blockID = blockID
         return failure
     
     
     def _add_history(self, result, block=None):
         """Add block to the history"""
         
         assert(block != None)
         self.history.add_items([block])
         self.history_cursor += 1
         
         return result
     
     
     def get_history_previous(self, current_block):
         """ Returns previous history string and decrement history cursor.
         """
         command = self.history.get_history_item(self.history_cursor - 1)
         
         if command is not None:
             if(self.history_cursor+1 == len(self.history.input_cache)):
                 self.history.input_cache[self.history_cursor] = current_block
             self.history_cursor -= 1
         return command
     
     
     def get_history_next(self):
         """ Returns next history string and increment history cursor.
         """
         command = self.history.get_history_item(self.history_cursor+1)
         
         if command is not None:
             self.history_cursor += 1
         return command
     
     ###
     # Subclasses probably want to override these methods...
     ###
     
     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.
         """
         
         return result
     
     
     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,176 +1,207
 """
-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.
 """
 __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 re
 
 import IPython
 
 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)):
         test_prefix = ref[:size+1]
         for string in strings[1:]:
             if not string.startswith(test_prefix):
                 return prefix
         prefix = test_prefix
 
     return prefix
 
 #-------------------------------------------------------------------------------
 # 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.
     prompt_number = 1
 
     # To bootstrap
     last_result = dict(number=0)
 
     #--------------------------------------------------------------------------
-    # Public API
+    # FrontEndBase interface
     #--------------------------------------------------------------------------
 
     def __init__(self, shell=None, history=None):
         if shell is None:
             shell = Interpreter()
         FrontEndBase.__init__(self, shell=shell, history=history)
         
         #FIXME: print banner.
         banner = """IPython1 %s -- An enhanced Interactive Python.""" \
                             % IPython.__version__
 
 
     def complete(self, line):
         """Complete line in engine's user_ns
         
         Parameters
         ----------
         line : string
         
         Result
         ------
         The replacement for the line and the list of possible completions.
         """
         completions = self.shell.complete(line)
         complete_sep =  re.compile('[\s\{\}\[\]\(\)\=]')
         if completions:
             prefix = common_prefix(completions) 
             residual = complete_sep.split(line)[:-1]
             line = line[:-len(residual)] + prefix
         return line, completions 
  
 
     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']:
             self.write("%s%s\n" % ( 
                             self.output_prompt % result['number'],
                             result['display']['pprint']
                             ) )
        
 
     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)):
             return False
         else:
             # Add line returns here, to make sure that the statement is
             # complete.
             return FrontEndBase.is_complete(self, string.rstrip() + '\n\n')
     
 
     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
         # Create a false result, in case there is an exception
         self.last_result = dict(number=self.prompt_number)
         try:
             self.history.input_cache[-1] = raw_string.rstrip()
             result = self.shell.execute(python_string)
             self.last_result = result
             self.render_result(result)
         except:
             self.show_traceback()
         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
             terminal back in a shape where it is usable.
         """
         self.prompt_number += 1
         self.new_prompt(self.prompt % (self.last_result['number'] + 1))
         # Start a new empty history entry
         self._add_history(None, '')
         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.
         """
         current_buffer = self.get_current_edit_buffer()
         cleaned_buffer = self.prefilter_input(current_buffer)
         if self.is_complete(cleaned_buffer):
             self.execute(cleaned_buffer, raw_string=current_buffer)
         else:
             self.write(self._get_indent_string(
                             current_buffer[:-1]))
             if current_buffer[:-1].split('\n')[-1].rstrip().endswith(':'):
                 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())
         indent_string = '\t'*(indent_chars // 4) + \
                             ' '*(indent_chars % 4)
 
         return indent_string
  
     

IPython/frontend/prefilterfrontend.py

@@ -1,162 +1,192
 """
 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)
         # 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')
         self.shell.output_trap = RedirectorOutputTrap(
                             out_callback=self.write,
                             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()
 
 
     def execute(self, python_string, raw_string=None):
         self.capture_output()
         LineFrontEndBase.execute(self, python_string,
                                     raw_string=raw_string)
         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.
         """
         self.__old_cout_write = Term.cout.write
         self.__old_err_write = Term.cerr.write
         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
         sys.stdout = self.__old_stdout
         sys.stderr = self.__old_stderr
         pydoc.help.output = self.__old_help_output 
 
 
     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
+
+
+    #--------------------------------------------------------------------------
+    # 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.
         """
         self.ipython0.atexit_operations()
 

IPython/frontend/wx/console_widget.py

@@ -1,441 +1,441
 # 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'
 
     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._configure_scintilla()
 
         # FIXME: we need to retrieve this from the interpreter.
         self.prompt = \
             '\n\x01\x1b[0;34m\x02In [\x01\x1b[1;34m\x02%i\x01\x1b[0;34m\x02]: \x01\x1b[0m\x02'
         self.new_prompt(self.prompt % 1)
 
         self.Bind(wx.EVT_KEY_DOWN, self._on_key_down)
         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.
         """
         # 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 give 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 replace_current_edit_buffer(self, text):
         """ Replace currently entered command line with given text.
         """
         self.SetSelection(self.current_prompt_pos, self.GetLength())
         self.ReplaceSelection(text)
         self.GotoPos(self.GetLength())
     
     
     def get_current_edit_buffer(self):
         """ Returns the text in current edit buffer.
         """
         current_edit_buffer = self.GetTextRange(self.current_prompt_pos,
                                                 self.GetLength())
         current_edit_buffer = current_edit_buffer.replace(LINESEP, '\n')
         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):
         # FIXME: This is non Wx specific and needs to be moved into
         # the base class.
         current_buffer = self.get_current_edit_buffer()
         
         self.write('\n')
         max_len = len(max(possibilities, key=len)) + 1
         
         #now we check how much symbol we can put on a line...
         chars_per_line = self.GetSize()[0]/self.GetCharWidth()
         symbols_per_line = max(1, chars_per_line/max_len)
 
         pos = 1
         buf = []
         for symbol in possibilities:
             if pos < symbols_per_line:
                 buf.append(symbol.ljust(max_len))
                 pos += 1
             else:
                 buf.append(symbol.rstrip() + '\n')
                 pos = 1
         self.write(''.join(buf))
         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):
         """ 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.replace_current_edit_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 get_current_edit_buffer filters this 
                 # out.
                 if sys.platform == 'win32':
                     self.replace_current_edit_buffer(
                                 self.get_current_edit_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/wx_frontend.py

@@ -1,408 +1,438
 # encoding: utf-8 -*- test-case-name:
 # FIXME: Need to add tests.
 # ipython1.frontend.cocoa.tests.test_cocoa_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
 #-------------------------------------------------------------------------------
 
-
-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
 
 _RUNNING_BUFFER_MARKER = 31
 _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'
 
     # 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)
 
     #--------------------------------------------------------------------------
     # 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()
 
     #--------------------------------------------------------------------------
     # 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 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)
 
+
+    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", 
         line = self.get_current_edit_buffer()
         new_line, completions = self.complete(line)
         if len(completions)>1:
             self.write_completion(completions)
         self.replace_current_edit_buffer(new_line)
         if self.debug:
             print >>sys.__stdout__, completions 
 
 
     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.get_current_edit_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):
+    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:
             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 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'
         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)
         # 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)
 
 
     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()
         PrefilterFrontEnd.show_traceback(self)
         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.
         """
         # 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 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 (
                 ( event.KeyCode<256 and
                   event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN, wx.MOD_SHIFT))
                     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)
+                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 (
                     ( 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.get_current_edit_buffer())
                 if new_buffer is not None:
                     self.replace_current_edit_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.replace_current_edit_buffer(new_buffer)
             # Tab-completion
             elif event.KeyCode == ord('\t'):
                 last_line = self.get_current_edit_buffer().split('\n')[-1]
                 if not re.match(r'^\s*$', last_line):
                     self.do_completion()
                 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)
+            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.
         """
         print >>sys.__stderr__, 'End of 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/sync_traceback_trap.py

@@ -1,41 +1,45
 # encoding: utf-8
 
 """Object to manage sys.excepthook().
 
 Synchronous version: prints errors when called.
 """
 
 __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
 #-------------------------------------------------------------------------------
 from traceback_trap import TracebackTrap
 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