Modified OutputTrap to accept a file-like object and use it instead of

SyncOutputTrap.

IPython/frontend/prefilterfrontend.py

@@ -1,157 +1,158 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.sync_output_trap import SyncOutputTrap
+from IPython.kernel.core.file_like import FileLike
+from IPython.kernel.core.output_trap import OutputTrap
 
 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 ; 
-    printf \\"\\\\n\\"; 
-    printf \\"press a key to close\\" ; 
-    printf \\"\x1b]0;%s (finished -- press a key to close)\x07\\" ;
-    read foo;"\'
-    """  % (command, command, command) )
+    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 = SyncOutputTrap(write_out=self.write,
-                                                write_err=self.write)
+        self.shell.output_trap = OutputTrap(
+                                out=FileLike(write_callback=self.write),
+                                err=FileLike(write_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/file_like.py

@@ -1,67 +1,49 b''
 # encoding: utf-8
 
-""" Redirects stdout/stderr to given write methods."""
+""" File like object that redirects its write calls to a given callback."""
 
 __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 IPython.kernel.core.output_trap import OutputTrap 
 
 class FileLike(object):
     """ FileLike object that redirects all write to a callback.
 
         Only the write-related methods are implemented, as well as those
         required to read a StringIO.
     """
     closed = False
 
-    def __init__(self, write):
-        self.write = write
+    def __init__(self, write_callback):
+        self.write = write_callback
 
     def flush(self):
         pass
 
     def close(self):
         pass
 
     def writelines(self, lines):
         for line in lines:
             self.write(line)
 
     def isatty(self):
         return False
 
     def getvalue(self):
         return ''
 
+    def reset(self):
+        pass
 
-class SyncOutputTrap(OutputTrap):
-    """ Object which redirect text sent to stdout and stderr to write
-        callbacks.
-    """
-    
-    def __init__(self, write_out, write_err):
-        # Store callbacks
-        self.out = FileLike(write_out)
-        self.err = FileLike(write_err)
-
-        # Boolean to check if the stdout/stderr hook is set.
-        self.out_set = False
-        self.err_set = False
-
-    def clear(self):
-        """ Clear out the buffers.
-        """
+    def truncate(self):
         pass
 
+

IPython/kernel/core/output_trap.py

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