Make the OS-level stdout/stderr capture work in the frontends.

IPython/frontend/prefilterfrontend.py

@@ -1,158 +1,149 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.file_like import FileLike
-from IPython.kernel.core.output_trap import OutputTrap
+from IPython.kernel.core.redirector_output_trap import RedirectorOutputTrap
 
 from IPython.genutils import Term
 import pydoc
 
 #-------------------------------------------------------------------------------
 # Utility functions (temporary, should be moved out of here)
 #-------------------------------------------------------------------------------
 import os
 def xterm_system(command):
     """ Run a command in a separate console window.
     """
     os.system(("""xterm -title "%s" -e \'/bin/sh -c "%s ; """
                """echo; echo press enter to close ; """
 #               """echo \\"\x1b]0;%s (finished -- press enter to close)\x07\\" ;
                """read foo;"\' """)  % (command, command) )
 
 #-------------------------------------------------------------------------------
 # 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 = xterm_system
-        # Redefine a serie of magics to avoid os.system:
-        # FIXME: I am redefining way too much magics.
-        for alias_name, (_, alias_value) in \
-                    _ip.IP.shell.alias_table.iteritems():
-            magic = lambda s : _ip.magic('sx %s %s' % (alias_value, s))
-            setattr(_ip.IP, 'magic_%s' % alias_name, magic)
-        # FIXME: I should create a real file-like object dedicated to this
-        # terminal
-        self.shell.output_trap = OutputTrap(
-                                out=FileLike(write_callback=self.write),
-                                err=FileLike(write_callback=self.write),
+        self.shell.output_trap = RedirectorOutputTrap(
+                            out_callback=self.write,
+                            err_callback=self.write,
                                             )
         # 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 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()
 

IPython/kernel/core/redirector_output_trap.py

@@ -1,79 +1,93 b''
 # encoding: utf-8
 
 """ 
 Trap stdout/stderr, including at the OS level. Calls a callback with
 the output each time Python tries to write to the stdout or stderr.
 """
 
 __docformat__ = "restructuredtext en"
 
 #-------------------------------------------------------------------------------
 #  Copyright (C) 2008  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-------------------------------------------------------------------------------
 
 #-------------------------------------------------------------------------------
 # Imports
 #-------------------------------------------------------------------------------
 
 from fd_redirector import FDRedirector, STDOUT, STDERR
 
 from IPython.kernel.core.file_like import FileLike
 from IPython.kernel.core.output_trap import OutputTrap
 
 class RedirectorOutputTrap(OutputTrap):
     """ Object which can trap text sent to stdout and stderr.
     """
 
     #------------------------------------------------------------------------
     # OutputTrap interface.
     #------------------------------------------------------------------------
     def __init__(self, out_callback, err_callback):
         # Callback invoked on write to stdout and stderr 
         self.out_callback = out_callback
         self.err_callback = err_callback
 
         # File descriptor redirectors, to capture non-Python
         # output.
         self.out_redirector = FDRedirector(STDOUT)
         self.err_redirector = FDRedirector(STDERR)
 
         # Call the base class with file like objects that will trigger
         # our callbacks
         OutputTrap.__init__(self, out=FileLike(self.on_out_write),
                                   err=FileLike(self.on_err_write), )
 
 
     def set(self):
         """ Set the hooks: set the redirectors and call the base class.
         """
         self.out_redirector.start()
         #self.err_redirector.start()
         OutputTrap.set(self)
 
 
     def unset(self):
         """ Remove the hooks: call the base class and stop the
             redirectors.
         """
         OutputTrap.unset(self)
+        # Flush the redirectors before stopping them
+        self.on_out_write('')
         self.err_redirector.stop()
+        self.on_err_write('')
         self.out_redirector.stop()
 
 
     #------------------------------------------------------------------------
     # Callbacks for synchronous output 
     #------------------------------------------------------------------------
     def on_out_write(self, string):
         """ Callback called when there is some Python output on stdout.
         """
+        try:
         self.out_callback(self.out_redirector.getvalue() + string)
+        except:
+            # If tracebacks are happening and we can't see them, it is
+            # quasy impossible to debug
+            self.unset()
+            raise
 
     def on_err_write(self, string):
         """ Callback called when there is some Python output on stderr.
         """
+        try:
         self.err_callback(self.err_redirector.getvalue() + string)
-
+        except:
+            # If tracebacks are happening and we can't see them, it is
+            # quasy impossible to debug
+            self.unset()
+            raise