Better traceback support.

IPython/kernel/core/sync_traceback_trap.py

@@ -0,0 +1,41 b''
+# 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):
+        TracebackTrap.__init__(self, formatters=formatters)
+        if sync_formatter is None:
+            sync_formatter = ColorTB(color_scheme='LightBG')
+        self.sync_formatter = sync_formatter
+
+
+    def hook(self, *args):
+        """ This method actually implements the hook.
+        """
+        self.args = args
+        
+        print self.sync_formatters(*self.args)
+
+
+        
+

IPython/frontend/piped_process.py

@@ -1,48 +1,55 b''
 # 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 subprocess 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 == '' and process.poll() is not None:
-                break
-            self.out_callback(out_char)
+            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/prefilterfrontend.py

@@ -1,163 +1,162 b''
 """
 Frontend class that uses IPython0 to prefilter the inputs.
 
 Using the IPython0 mechanism gives us access to the magics.
 """
 __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.ultraTB import ColorTB
 from IPython.genutils import Term
 import pydoc
 
 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):
     
     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=[ColorTB(color_scheme='LightBG'), ]
+                        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
 
 
     def show_traceback(self):
         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 
  
 
     def do_exit(self):
         """ Exit the shell, cleanup and save the history.
         """
         self.ipython0.atexit_operations()