Prompt messages are now implemented for both in/out prompts.

IPython/core/displayhook.py

@@ -1,289 +1,288 b''
 # -*- coding: utf-8 -*-
 """Displayhook for IPython.
 
 Authors:
 
 * Fernando Perez
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #       Copyright (C) 2008-2010 The IPython Development Team
 #       Copyright (C) 2001-2007 Fernando Perez <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import __builtin__
 from pprint import PrettyPrinter
 pformat = PrettyPrinter().pformat
 
 from IPython.config.configurable import Configurable
 from IPython.core import prompts
 import IPython.utils.generics
 import IPython.utils.io
-from IPython.utils.traitlets import Instance
+from IPython.utils.traitlets import Instance, Int
 from IPython.utils.warn import warn
 
 #-----------------------------------------------------------------------------
 # Main displayhook class
 #-----------------------------------------------------------------------------
 
 # TODO: The DisplayHook class should be split into two classes, one that
 # manages the prompts and their synchronization and another that just does the
 # displayhook logic and calls into the prompt manager.
 
 # TODO: Move the various attributes (cache_size, colors, input_sep,
 # output_sep, output_sep2, ps1, ps2, ps_out, pad_left). Some of these are also
 # attributes of InteractiveShell. They should be on ONE object only and the
 # other objects should ask that one object for their values.
 
 class DisplayHook(Configurable):
     """The custom IPython displayhook to replace sys.displayhook.
 
     This class does many things, but the basic idea is that it is a callable
     that gets called anytime user code returns a value.
 
     Currently this class does more than just the displayhook logic and that
     extra logic should eventually be moved out of here.
     """
 
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
+    # Each call to the In[] prompt raises it by 1, even the first.
+    prompt_count = Int(0)
 
     def __init__(self, shell=None, cache_size=1000,
                  colors='NoColor', input_sep='\n',
                  output_sep='\n', output_sep2='',
                  ps1 = None, ps2 = None, ps_out = None, pad_left=True,
                  config=None):
         super(DisplayHook, self).__init__(shell=shell, config=config)
 
         cache_size_min = 3
         if cache_size <= 0:
             self.do_full_cache = 0
             cache_size = 0
         elif cache_size < cache_size_min:
             self.do_full_cache = 0
             cache_size = 0
             warn('caching was disabled (min value for cache size is %s).' %
                  cache_size_min,level=3)
         else:
             self.do_full_cache = 1
 
         self.cache_size = cache_size
         self.input_sep = input_sep
 
         # we need a reference to the user-level namespace
         self.shell = shell
 
         # Set input prompt strings and colors
         if cache_size == 0:
             if ps1.find('%n') > -1 or ps1.find(r'\#') > -1 \
                    or ps1.find(r'\N') > -1:
                 ps1 = '>>> '
             if ps2.find('%n') > -1 or ps2.find(r'\#') > -1 \
                    or ps2.find(r'\N') > -1:
                 ps2 = '... '
         self.ps1_str = self._set_prompt_str(ps1,'In [\\#]: ','>>> ')
         self.ps2_str = self._set_prompt_str(ps2,'   .\\D.: ','... ')
         self.ps_out_str = self._set_prompt_str(ps_out,'Out[\\#]: ','')
 
         self.color_table = prompts.PromptColors
         self.prompt1 = prompts.Prompt1(self,sep=input_sep,prompt=self.ps1_str,
                                pad_left=pad_left)
         self.prompt2 = prompts.Prompt2(self,prompt=self.ps2_str,pad_left=pad_left)
         self.prompt_out = prompts.PromptOut(self,sep='',prompt=self.ps_out_str,
                                     pad_left=pad_left)
         self.set_colors(colors)
 
-        # other more normal stuff
-        # b/c each call to the In[] prompt raises it by 1, even the first.
-        self.prompt_count = 0
         # Store the last prompt string each time, we need it for aligning
         # continuation and auto-rewrite prompts
         self.last_prompt = ''
         self.output_sep = output_sep
         self.output_sep2 = output_sep2
         self._,self.__,self.___ = '','',''
         self.pprint_types = map(type,[(),[],{}])
 
         # these are deliberately global:
         to_user_ns = {'_':self._,'__':self.__,'___':self.___}
         self.shell.user_ns.update(to_user_ns)
 
     def _set_prompt_str(self,p_str,cache_def,no_cache_def):
         if p_str is None:
             if self.do_full_cache:
                 return cache_def
             else:
                 return no_cache_def
         else:
             return p_str
                 
     def set_colors(self, colors):
         """Set the active color scheme and configure colors for the three
         prompt subsystems."""
 
         # FIXME: This modifying of the global prompts.prompt_specials needs
         # to be fixed. We need to refactor all of the prompts stuff to use
         # proper configuration and traits notifications.
         if colors.lower()=='nocolor':
             prompts.prompt_specials = prompts.prompt_specials_nocolor
         else:
             prompts.prompt_specials = prompts.prompt_specials_color
         
         self.color_table.set_active_scheme(colors)
         self.prompt1.set_colors()
         self.prompt2.set_colors()
         self.prompt_out.set_colors()
 
     #-------------------------------------------------------------------------
     # Methods used in __call__. Override these methods to modify the behavior
     # of the displayhook.
     #-------------------------------------------------------------------------
 
     def check_for_underscore(self):
         """Check if the user has set the '_' variable by hand."""
         # If something injected a '_' variable in __builtin__, delete
         # ipython's automatic one so we don't clobber that.  gettext() in
         # particular uses _, so we need to stay away from it.
         if '_' in __builtin__.__dict__:
             try:
                 del self.shell.user_ns['_']
             except KeyError:
                 pass
 
     def quiet(self):
         """Should we silence the display hook because of ';'?"""
         # do not print output if input ends in ';'
         try:
             if self.shell.input_hist[self.prompt_count].endswith(';\n'):
                 return True
         except IndexError:
             # some uses of ipshellembed may fail here
             pass
         return False
 
     def start_displayhook(self):
         """Start the displayhook, initializing resources."""
         pass
 
     def write_output_prompt(self):
         """Write the output prompt."""
         # Use write, not print which adds an extra space.
         IPython.utils.io.Term.cout.write(self.output_sep)
         outprompt = str(self.prompt_out)
         if self.do_full_cache:
             IPython.utils.io.Term.cout.write(outprompt)
 
     # TODO: Make this method an extension point. The previous implementation
     # has both a result_display hook as well as a result_display generic
     # function to customize the repr on a per class basis. We need to rethink
     # the hooks mechanism before doing this though.
     def compute_result_repr(self, result):
         """Compute and return the repr of the object to be displayed.
 
         This method only compute the string form of the repr and should NOT
         actual print or write that to a stream. This method may also transform
         the result itself, but the default implementation passes the original
         through.
         """
         try:
             if self.shell.pprint:
                 result_repr = pformat(result)
                 if '\n' in result_repr:
                     # So that multi-line strings line up with the left column of
                     # the screen, instead of having the output prompt mess up
                     # their first line.
                     result_repr = '\n' + result_repr
             else:
                 result_repr = repr(result)
         except TypeError:
             # This happens when result.__repr__ doesn't return a string,
             # such as when it returns None.
             result_repr = '\n'
         return result, result_repr
 
     def write_result_repr(self, result_repr):
         # We want to print because we want to always make sure we have a 
         # newline, even if all the prompt separators are ''. This is the
         # standard IPython behavior.
         print >>IPython.utils.io.Term.cout, result_repr
 
     def update_user_ns(self, result):
         """Update user_ns with various things like _, __, _1, etc."""
 
         # Avoid recursive reference when displaying _oh/Out
         if result is not self.shell.user_ns['_oh']:
             if len(self.shell.user_ns['_oh']) >= self.cache_size and self.do_full_cache:
                 warn('Output cache limit (currently '+
                       `self.cache_size`+' entries) hit.\n'
                      'Flushing cache and resetting history counter...\n'
                      'The only history variables available will be _,__,___ and _1\n'
                      'with the current result.')
 
                 self.flush()
             # Don't overwrite '_' and friends if '_' is in __builtin__ (otherwise
             # we cause buggy behavior for things like gettext).
             if '_' not in __builtin__.__dict__:
                 self.___ = self.__
                 self.__ = self._
                 self._ = result
                 self.shell.user_ns.update({'_':self._,'__':self.__,'___':self.___})
 
             # hackish access to top-level  namespace to create _1,_2... dynamically
             to_main = {}
             if self.do_full_cache:
                 new_result = '_'+`self.prompt_count`
                 to_main[new_result] = result
                 self.shell.user_ns.update(to_main)
                 self.shell.user_ns['_oh'][self.prompt_count] = result
 
     def log_output(self, result):
         """Log the output."""
         if self.shell.logger.log_output:
             self.shell.logger.log_write(repr(result),'output')
 
     def finish_displayhook(self):
         """Finish up all displayhook activities."""
         IPython.utils.io.Term.cout.write(self.output_sep2)
         IPython.utils.io.Term.cout.flush()
 
     def __call__(self, result=None):
         """Printing with history cache management.
         
         This is invoked everytime the interpreter needs to print, and is
         activated by setting the variable sys.displayhook to it.
         """
         self.check_for_underscore()
         if result is not None and not self.quiet():
             self.start_displayhook()
             self.write_output_prompt()
             result, result_repr = self.compute_result_repr(result)
             self.write_result_repr(result_repr)
             self.update_user_ns(result)
             self.log_output(result)
             self.finish_displayhook()
 
     def flush(self):
         if not self.do_full_cache:
             raise ValueError,"You shouldn't have reached the cache flush "\
                   "if full caching is not enabled!"
         # delete auto-generated vars from global namespace
         
         for n in range(1,self.prompt_count + 1):
             key = '_'+`n`
             try:
                 del self.shell.user_ns[key]
             except: pass
         self.shell.user_ns['_oh'].clear()
         
         if '_' not in __builtin__.__dict__:
             self.shell.user_ns.update({'_':None,'__':None, '___':None})
         import gc
         gc.collect() # xxx needed?
 

IPython/core/prompts.py

@@ -1,437 +1,444 b''
 # -*- coding: utf-8 -*-
 """Classes for handling input/output prompts.
 
 Authors:
 
 * Fernando Perez
 * Brian Granger
 """
 
 #-----------------------------------------------------------------------------
 #       Copyright (C) 2008-2010 The IPython Development Team
 #       Copyright (C) 2001-2007 Fernando Perez <[e-mail]>
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 import os
 import re
 import socket
 import sys
 
 from IPython.core import release
 from IPython.external.Itpl import ItplNS
 from IPython.utils import coloransi
 
 #-----------------------------------------------------------------------------
 # Color schemes for prompts
 #-----------------------------------------------------------------------------
 
 PromptColors = coloransi.ColorSchemeTable()
 InputColors = coloransi.InputTermColors  # just a shorthand
 Colors = coloransi.TermColors  # just a shorthand
 
 PromptColors.add_scheme(coloransi.ColorScheme(
     'NoColor',
     in_prompt  = InputColors.NoColor,  # Input prompt
     in_number  = InputColors.NoColor,  # Input prompt number
     in_prompt2 = InputColors.NoColor, # Continuation prompt
     in_normal  = InputColors.NoColor,  # color off (usu. Colors.Normal)
     
     out_prompt = Colors.NoColor, # Output prompt
     out_number = Colors.NoColor, # Output prompt number
 
     normal = Colors.NoColor  # color off (usu. Colors.Normal)
     ))
 
 # make some schemes as instances so we can copy them for modification easily:
 __PColLinux =  coloransi.ColorScheme(
     'Linux',
     in_prompt  = InputColors.Green,
     in_number  = InputColors.LightGreen,
     in_prompt2 = InputColors.Green,
     in_normal  = InputColors.Normal,  # color off (usu. Colors.Normal)
 
     out_prompt = Colors.Red,
     out_number = Colors.LightRed,
 
     normal = Colors.Normal
     )
 # Don't forget to enter it into the table!
 PromptColors.add_scheme(__PColLinux)
 
 # Slightly modified Linux for light backgrounds
 __PColLightBG  = __PColLinux.copy('LightBG')
 
 __PColLightBG.colors.update(
     in_prompt  = InputColors.Blue,
     in_number  = InputColors.LightBlue,
     in_prompt2 = InputColors.Blue
 )
 PromptColors.add_scheme(__PColLightBG)
 
 del Colors,InputColors
 
 #-----------------------------------------------------------------------------
 # Utilities
 #-----------------------------------------------------------------------------
 
 def multiple_replace(dict, text):
     """ Replace in 'text' all occurences of any key in the given
     dictionary by its corresponding value.  Returns the new string."""
 
     # Function by Xavier Defrang, originally found at:
     # http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/81330
 
     # Create a regular expression  from the dictionary keys
     regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
     # For each match, look-up corresponding value in dictionary
     return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text)
 
 #-----------------------------------------------------------------------------
 # Special characters that can be used in prompt templates, mainly bash-like
 #-----------------------------------------------------------------------------
 
 # If $HOME isn't defined (Windows), make it an absurd string so that it can
 # never be expanded out into '~'.  Basically anything which can never be a
 # reasonable directory name will do, we just want the $HOME -> '~' operation
 # to become a no-op.  We pre-compute $HOME here so it's not done on every
 # prompt call.
 
 # FIXME:
 
 # - This should be turned into a class which does proper namespace management,
 # since the prompt specials need to be evaluated in a certain namespace.
 # Currently it's just globals, which need to be managed manually by code
 # below.
 
 # - I also need to split up the color schemes from the prompt specials
 # somehow.  I don't have a clean design for that quite yet.
 
 HOME = os.environ.get("HOME","//////:::::ZZZZZ,,,~~~")
 
 # We precompute a few more strings here for the prompt_specials, which are
 # fixed once ipython starts.  This reduces the runtime overhead of computing
 # prompt strings.
 USER           = os.environ.get("USER")
 HOSTNAME       = socket.gethostname()
 HOSTNAME_SHORT = HOSTNAME.split(".")[0]
 ROOT_SYMBOL    = "$#"[os.name=='nt' or os.getuid()==0]
 
 prompt_specials_color = {
     # Prompt/history count
     '%n' : '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
     r'\#': '${self.col_num}' '${self.cache.prompt_count}' '${self.col_p}',
     # Just the prompt counter number, WITHOUT any coloring wrappers, so users
     # can get numbers displayed in whatever color they want.
     r'\N': '${self.cache.prompt_count}',
 
     # Prompt/history count, with the actual digits replaced by dots.  Used
     # mainly in continuation prompts (prompt_in2)
     #r'\D': '${"."*len(str(self.cache.prompt_count))}',
 
     # More robust form of the above expression, that uses the __builtin__
     # module.  Note that we can NOT use __builtins__ (note the 's'), because
     # that can either be a dict or a module, and can even mutate at runtime,
     # depending on the context (Python makes no guarantees on it).  In
     # contrast, __builtin__ is always a module object, though it must be
     # explicitly imported.
     r'\D': '${"."*__builtin__.len(__builtin__.str(self.cache.prompt_count))}',
 
     # Current working directory
     r'\w': '${os.getcwd()}',
     # Current time
     r'\t' : '${time.strftime("%H:%M:%S")}',
     # Basename of current working directory.
     # (use os.sep to make this portable across OSes)
     r'\W' : '${os.getcwd().split("%s")[-1]}' % os.sep,
     # These X<N> are an extension to the normal bash prompts.  They return
     # N terms of the path, after replacing $HOME with '~'
     r'\X0': '${os.getcwd().replace("%s","~")}' % HOME,
     r'\X1': '${self.cwd_filt(1)}',
     r'\X2': '${self.cwd_filt(2)}',
     r'\X3': '${self.cwd_filt(3)}',
     r'\X4': '${self.cwd_filt(4)}',
     r'\X5': '${self.cwd_filt(5)}',
     # Y<N> are similar to X<N>, but they show '~' if it's the directory
     # N+1 in the list.  Somewhat like %cN in tcsh.
     r'\Y0': '${self.cwd_filt2(0)}',
     r'\Y1': '${self.cwd_filt2(1)}',
     r'\Y2': '${self.cwd_filt2(2)}',
     r'\Y3': '${self.cwd_filt2(3)}',
     r'\Y4': '${self.cwd_filt2(4)}',
     r'\Y5': '${self.cwd_filt2(5)}',
     # Hostname up to first .
     r'\h': HOSTNAME_SHORT,
     # Full hostname
     r'\H': HOSTNAME,
     # Username of current user
     r'\u': USER,
     # Escaped '\'
     '\\\\': '\\',
     # Newline
     r'\n': '\n',
     # Carriage return
     r'\r': '\r',
     # Release version
     r'\v': release.version,
     # Root symbol ($ or #)
     r'\$': ROOT_SYMBOL,
     }
 
 # A copy of the prompt_specials dictionary but with all color escapes removed,
 # so we can correctly compute the prompt length for the auto_rewrite method.
 prompt_specials_nocolor = prompt_specials_color.copy()
 prompt_specials_nocolor['%n'] = '${self.cache.prompt_count}'
 prompt_specials_nocolor[r'\#'] = '${self.cache.prompt_count}'
 
 # Add in all the InputTermColors color escapes as valid prompt characters.
 # They all get added as \\C_COLORNAME, so that we don't have any conflicts
 # with a color name which may begin with a letter used by any other of the
 # allowed specials.  This of course means that \\C will never be allowed for
 # anything else.
 input_colors = coloransi.InputTermColors
 for _color in dir(input_colors):
     if _color[0] != '_':
         c_name = r'\C_'+_color
         prompt_specials_color[c_name] = getattr(input_colors,_color)
         prompt_specials_nocolor[c_name] = ''
 
 # we default to no color for safety.  Note that prompt_specials is a global
 # variable used by all prompt objects.
 prompt_specials = prompt_specials_nocolor
 
 #-----------------------------------------------------------------------------
 # More utilities
 #-----------------------------------------------------------------------------
 
 def str_safe(arg):
     """Convert to a string, without ever raising an exception.
 
     If str(arg) fails, <ERROR: ... > is returned, where ... is the exception
     error message."""
 
     try:
         out = str(arg)
     except UnicodeError:
         try:
             out = arg.encode('utf_8','replace')
         except Exception,msg:
             # let's keep this little duplication here, so that the most common
             # case doesn't suffer from a double try wrapping.
             out = '<ERROR: %s>' % msg
     except Exception,msg:
         out = '<ERROR: %s>' % msg
         #raise  # dbg
     return out
 
 #-----------------------------------------------------------------------------
 # Prompt classes
 #-----------------------------------------------------------------------------
 
 class BasePrompt(object):
     """Interactive prompt similar to Mathematica's."""
 
     def _get_p_template(self):
         return self._p_template
 
     def _set_p_template(self,val):
         self._p_template = val
         self.set_p_str()
 
     p_template = property(_get_p_template,_set_p_template,
                           doc='Template for prompt string creation')
 
     def __init__(self, cache, sep, prompt, pad_left=False):
 
         # Hack: we access information about the primary prompt through the
         # cache argument.  We need this, because we want the secondary prompt
         # to be aligned with the primary one.  Color table info is also shared
         # by all prompt classes through the cache.  Nice OO spaghetti code!
         self.cache = cache
         self.sep = sep
         
         # regexp to count the number of spaces at the end of a prompt
         # expression, useful for prompt auto-rewriting
         self.rspace = re.compile(r'(\s*)$')
         # Flag to left-pad prompt strings to match the length of the primary
         # prompt
         self.pad_left = pad_left
 
         # Set template to create each actual prompt (where numbers change).
         # Use a property
         self.p_template = prompt
         self.set_p_str()
 
     def set_p_str(self):
         """ Set the interpolating prompt strings.
 
         This must be called every time the color settings change, because the
         prompt_specials global may have changed."""
 
         import os,time  # needed in locals for prompt string handling
         loc = locals()
         try:
             self.p_str = ItplNS('%s%s%s' %
                                 ('${self.sep}${self.col_p}',
                                  multiple_replace(prompt_specials, self.p_template),
                                  '${self.col_norm}'),self.cache.shell.user_ns,loc)
     
             self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
                                                          self.p_template),
                                         self.cache.shell.user_ns,loc)
         except:
             print "Illegal prompt template (check $ usage!):",self.p_template
             self.p_str = self.p_template
             self.p_str_nocolor = self.p_template
 
     def write(self, msg):
         sys.stdout.write(msg)
         return ''
 
     def __str__(self):
         """Return a string form of the prompt.
 
         This for is useful for continuation and output prompts, since it is
         left-padded to match lengths with the primary one (if the
         self.pad_left attribute is set)."""
 
         out_str = str_safe(self.p_str)
         if self.pad_left:
             # We must find the amount of padding required to match lengths,
             # taking the color escapes (which are invisible on-screen) into
             # account.
             esc_pad = len(out_str) - len(str_safe(self.p_str_nocolor))
             format = '%%%ss' % (len(str(self.cache.last_prompt))+esc_pad)
             return format % out_str
         else:
             return out_str
 
     # these path filters are put in as methods so that we can control the
     # namespace where the prompt strings get evaluated
     def cwd_filt(self, depth):
         """Return the last depth elements of the current working directory.
 
         $HOME is always replaced with '~'.
         If depth==0, the full path is returned."""
 
         cwd = os.getcwd().replace(HOME,"~")
         out = os.sep.join(cwd.split(os.sep)[-depth:])
         if out:
             return out
         else:
             return os.sep
 
     def cwd_filt2(self, depth):
         """Return the last depth elements of the current working directory.
 
         $HOME is always replaced with '~'.
         If depth==0, the full path is returned."""
 
         full_cwd = os.getcwd()
         cwd = full_cwd.replace(HOME,"~").split(os.sep)
         if '~' in cwd and len(cwd) == depth+1:
             depth += 1
         drivepart = ''
         if sys.platform == 'win32' and len(cwd) > depth:
             drivepart = os.path.splitdrive(full_cwd)[0]
         out = drivepart + '/'.join(cwd[-depth:])
 
         if out:
             return out
         else:
             return os.sep
 
     def __nonzero__(self):
         """Implement boolean behavior.
 
         Checks whether the p_str attribute is non-empty"""
 
         return bool(self.p_template)
 
 
 class Prompt1(BasePrompt):
     """Input interactive prompt similar to Mathematica's."""
 
     def __init__(self, cache, sep='\n', prompt='In [\\#]: ', pad_left=True):
         BasePrompt.__init__(self, cache, sep, prompt, pad_left)
 
     def set_colors(self):
         self.set_p_str()
         Colors = self.cache.color_table.active_colors # shorthand
         self.col_p = Colors.in_prompt
         self.col_num = Colors.in_number
         self.col_norm = Colors.in_normal
         # We need a non-input version of these escapes for the '--->'
         # auto-call prompts used in the auto_rewrite() method.
         self.col_p_ni = self.col_p.replace('\001','').replace('\002','') 
         self.col_norm_ni = Colors.normal        
-        
+
+    def peek_next_prompt(self):
+        """Get the next prompt, but don't increment the counter."""
+        self.cache.prompt_count += 1
+        next_prompt = str_safe(self.p_str)
+        self.cache.prompt_count -= 1
+        return next_prompt
+
     def __str__(self):
         self.cache.prompt_count += 1
         self.cache.last_prompt = str_safe(self.p_str_nocolor).split('\n')[-1]
         return str_safe(self.p_str)
 
     def auto_rewrite(self):
         """Print a string of the form '--->' which lines up with the previous
         input string. Useful for systems which re-write the user input when
         handling automatically special syntaxes."""
 
         curr = str(self.cache.last_prompt)
         nrspaces = len(self.rspace.search(curr).group())
         return '%s%s>%s%s' % (self.col_p_ni,'-'*(len(curr)-nrspaces-1),
                               ' '*nrspaces,self.col_norm_ni)
 
 
 class PromptOut(BasePrompt):
     """Output interactive prompt similar to Mathematica's."""
 
     def __init__(self, cache, sep='', prompt='Out[\\#]: ', pad_left=True):
         BasePrompt.__init__(self, cache, sep, prompt, pad_left)
         if not self.p_template:
             self.__str__ = lambda: ''
 
     def set_colors(self):
         self.set_p_str()
         Colors = self.cache.color_table.active_colors # shorthand
         self.col_p = Colors.out_prompt
         self.col_num = Colors.out_number
         self.col_norm = Colors.normal
 
 
 class Prompt2(BasePrompt):
     """Interactive continuation prompt."""
     
     def __init__(self, cache, prompt='   .\\D.: ', pad_left=True):
         self.cache = cache
         self.p_template = prompt
         self.pad_left = pad_left
         self.set_p_str()
 
     def set_p_str(self):
         import os,time  # needed in locals for prompt string handling
         loc = locals()
         self.p_str = ItplNS('%s%s%s' %
                             ('${self.col_p2}',
                              multiple_replace(prompt_specials, self.p_template),
                              '$self.col_norm'),
                             self.cache.shell.user_ns,loc)
         self.p_str_nocolor = ItplNS(multiple_replace(prompt_specials_nocolor,
                                                      self.p_template),
                                     self.cache.shell.user_ns,loc)
 
     def set_colors(self):
         self.set_p_str()
         Colors = self.cache.color_table.active_colors
         self.col_p2 = Colors.in_prompt2
         self.col_norm = Colors.in_normal
         # FIXME (2004-06-16) HACK: prevent crashes for users who haven't
         # updated their prompt_in2 definitions.  Remove eventually.
         self.col_p = Colors.out_prompt
         self.col_num = Colors.out_number
 

IPython/frontend/qt/console/frontend_widget.py

@@ -1,384 +1,385 b''
 # Standard library imports
 import signal
 import sys
 
 # System library imports
 from pygments.lexers import PythonLexer
 from PyQt4 import QtCore, QtGui
 import zmq
 
 # Local imports
 from IPython.core.inputsplitter import InputSplitter
 from call_tip_widget import CallTipWidget
 from completion_lexer import CompletionLexer
 from console_widget import HistoryConsoleWidget
 from pygments_highlighter import PygmentsHighlighter
 
 
 class FrontendHighlighter(PygmentsHighlighter):
     """ A PygmentsHighlighter that can be turned on and off and that ignores
         prompts.
     """
 
     def __init__(self, frontend):
         super(FrontendHighlighter, self).__init__(frontend._control.document())
         self._current_offset = 0
         self._frontend = frontend
         self.highlighting_on = False
 
     def highlightBlock(self, qstring):
         """ Highlight a block of text. Reimplemented to highlight selectively.
         """
         if not self.highlighting_on:
             return
 
         # The input to this function is unicode string that may contain
         # paragraph break characters, non-breaking spaces, etc. Here we acquire
         # the string as plain text so we can compare it.
         current_block = self.currentBlock()
         string = self._frontend._get_block_plain_text(current_block)
 
         # Decide whether to check for the regular or continuation prompt.
         if current_block.contains(self._frontend._prompt_pos):
             prompt = self._frontend._prompt
         else:
             prompt = self._frontend._continuation_prompt
 
         # Don't highlight the part of the string that contains the prompt.
         if string.startswith(prompt):
             self._current_offset = len(prompt)
             qstring.remove(0, len(prompt))
         else:
             self._current_offset = 0
 
         PygmentsHighlighter.highlightBlock(self, qstring)
 
     def setFormat(self, start, count, format):
         """ Reimplemented to highlight selectively.
         """
         start += self._current_offset
         PygmentsHighlighter.setFormat(self, start, count, format)
 
 
 class FrontendWidget(HistoryConsoleWidget):
     """ A Qt frontend for a generic Python kernel.
     """
    
     # Emitted when an 'execute_reply' is received from the kernel.
     executed = QtCore.pyqtSignal(object)
 
     #---------------------------------------------------------------------------
     # 'object' interface
     #---------------------------------------------------------------------------
     
     def __init__(self, *args, **kw):
         super(FrontendWidget, self).__init__(*args, **kw)
 
         # FrontendWidget protected variables.
         self._call_tip_widget = CallTipWidget(self._control)
         self._completion_lexer = CompletionLexer(PythonLexer())
         self._hidden = True
         self._highlighter = FrontendHighlighter(self)
         self._input_splitter = InputSplitter(input_mode='replace')
         self._kernel_manager = None
 
         # Configure the ConsoleWidget.
         self.tab_width = 4
         self._set_continuation_prompt('... ')
 
         # Connect signal handlers.
         document = self._control.document()
         document.contentsChange.connect(self._document_contents_change)
 
     #---------------------------------------------------------------------------
     # 'QWidget' interface
     #---------------------------------------------------------------------------
 
     def focusOutEvent(self, event):
         """ Reimplemented to hide calltips.
         """
         self._call_tip_widget.hide()
         super(FrontendWidget, self).focusOutEvent(event)
 
     def keyPressEvent(self, event):
         """ Reimplemented to allow calltips to process events and to send
             signals to the kernel.
         """
         if self._executing and event.key() == QtCore.Qt.Key_C and \
                 self._control_down(event.modifiers()):
             self._interrupt_kernel()
         else:
             if self._call_tip_widget.isVisible():
                 self._call_tip_widget.keyPressEvent(event)
             super(FrontendWidget, self).keyPressEvent(event)
 
     #---------------------------------------------------------------------------
     # 'ConsoleWidget' abstract interface
     #---------------------------------------------------------------------------
 
     def _is_complete(self, source, interactive):
         """ Returns whether 'source' can be completely processed and a new
             prompt created. When triggered by an Enter/Return key press,
             'interactive' is True; otherwise, it is False.
         """
         complete = self._input_splitter.push(source.expandtabs(4))
         if interactive:
             complete = not self._input_splitter.push_accepts_more()
         return complete
 
     def _execute(self, source, hidden):
         """ Execute 'source'. If 'hidden', do not show any output.
         """
         self.kernel_manager.xreq_channel.execute(source)
         self._hidden = hidden
         
     def _prompt_started_hook(self):
         """ Called immediately after a new prompt is displayed.
         """
         if not self._reading:
             self._highlighter.highlighting_on = True
 
             # Auto-indent if this is a continuation prompt.
             if self._get_prompt_cursor().blockNumber() != \
                     self._get_end_cursor().blockNumber():
                 spaces = self._input_splitter.indent_spaces
                 self._append_plain_text('\t' * (spaces / self.tab_width))
                 self._append_plain_text(' ' * (spaces % self.tab_width))
 
     def _prompt_finished_hook(self):
         """ Called immediately after a prompt is finished, i.e. when some input
             will be processed and a new prompt displayed.
         """
         if not self._reading:
             self._highlighter.highlighting_on = False
 
     def _tab_pressed(self):
         """ Called when the tab key is pressed. Returns whether to continue
             processing the event.
         """
         self._keep_cursor_in_buffer()
         cursor = self._get_cursor()
         return not self._complete()
 
     #---------------------------------------------------------------------------
     # 'FrontendWidget' interface
     #---------------------------------------------------------------------------
 
     def execute_file(self, path, hidden=False):
         """ Attempts to execute file with 'path'. If 'hidden', no output is
             shown.
         """
         self.execute('execfile("%s")' % path, hidden=hidden)
 
     def _get_kernel_manager(self):
         """ Returns the current kernel manager.
         """
         return self._kernel_manager
 
     def _set_kernel_manager(self, kernel_manager):
         """ Disconnect from the current kernel manager (if any) and set a new
             kernel manager.
         """
         # Disconnect the old kernel manager, if necessary.
         if self._kernel_manager is not None:
             self._kernel_manager.started_channels.disconnect(
                 self._started_channels)
             self._kernel_manager.stopped_channels.disconnect(
                 self._stopped_channels)
 
             # Disconnect the old kernel manager's channels.
             sub = self._kernel_manager.sub_channel
             xreq = self._kernel_manager.xreq_channel
             rep = self._kernel_manager.rep_channel
             sub.message_received.disconnect(self._handle_sub)
             xreq.execute_reply.disconnect(self._handle_execute_reply)
             xreq.complete_reply.disconnect(self._handle_complete_reply)
             xreq.object_info_reply.disconnect(self._handle_object_info_reply)
             rep.input_requested.disconnect(self._handle_req)
 
             # Handle the case where the old kernel manager is still listening.
             if self._kernel_manager.channels_running:
                 self._stopped_channels()
 
         # Set the new kernel manager.
         self._kernel_manager = kernel_manager
         if kernel_manager is None:
             return
 
         # Connect the new kernel manager.
         kernel_manager.started_channels.connect(self._started_channels)
         kernel_manager.stopped_channels.connect(self._stopped_channels)
 
         # Connect the new kernel manager's channels.
         sub = kernel_manager.sub_channel
         xreq = kernel_manager.xreq_channel
         rep = kernel_manager.rep_channel
         sub.message_received.connect(self._handle_sub)
         xreq.execute_reply.connect(self._handle_execute_reply)
         xreq.complete_reply.connect(self._handle_complete_reply)
         xreq.object_info_reply.connect(self._handle_object_info_reply)
         rep.input_requested.connect(self._handle_req)
         
         # Handle the case where the kernel manager started channels before
         # we connected.
         if kernel_manager.channels_running:
             self._started_channels()
 
     kernel_manager = property(_get_kernel_manager, _set_kernel_manager)
 
     #---------------------------------------------------------------------------
     # 'FrontendWidget' protected interface
     #---------------------------------------------------------------------------
 
     def _call_tip(self):
         """ Shows a call tip, if appropriate, at the current cursor location.
         """
         # Decide if it makes sense to show a call tip
         cursor = self._get_cursor()
         cursor.movePosition(QtGui.QTextCursor.Left)
         document = self._control.document()
         if document.characterAt(cursor.position()).toAscii() != '(':
             return False
         context = self._get_context(cursor)
         if not context:
             return False
 
         # Send the metadata request to the kernel
         name = '.'.join(context)
         self._calltip_id = self.kernel_manager.xreq_channel.object_info(name)
         self._calltip_pos = self._get_cursor().position()
         return True
 
     def _complete(self):
         """ Performs completion at the current cursor location.
         """
         # Decide if it makes sense to do completion
         context = self._get_context()
         if not context:
             return False
 
         # Send the completion request to the kernel
         text = '.'.join(context)
         self._complete_id = self.kernel_manager.xreq_channel.complete(
             text, self.input_buffer_cursor_line, self.input_buffer)
         self._complete_pos = self._get_cursor().position()
         return True
 
     def _get_banner(self):
         """ Gets a banner to display at the beginning of a session.
         """
         banner = 'Python %s on %s\nType "help", "copyright", "credits" or ' \
             '"license" for more information.'
         return banner % (sys.version, sys.platform)
 
     def _get_context(self, cursor=None):
         """ Gets the context at the current cursor location.
         """
         if cursor is None:
             cursor = self._get_cursor()
         cursor.movePosition(QtGui.QTextCursor.StartOfLine, 
                             QtGui.QTextCursor.KeepAnchor)
         text = str(cursor.selection().toPlainText())
         return self._completion_lexer.get_context(text)
 
     def _interrupt_kernel(self):
         """ Attempts to the interrupt the kernel.
         """
         if self.kernel_manager.has_kernel:
             self.kernel_manager.signal_kernel(signal.SIGINT)
         else:
             self._append_plain_text('Kernel process is either remote or '
                                     'unspecified. Cannot interrupt.\n')
 
     def _show_interpreter_prompt(self):
         """ Shows a prompt for the interpreter.
         """
         self._show_prompt('>>> ')
 
     #------ Signal handlers ----------------------------------------------------
 
     def _started_channels(self):
         """ Called when the kernel manager has started listening.
         """
         self._reset()
         self._append_plain_text(self._get_banner())
         self._show_interpreter_prompt()
 
     def _stopped_channels(self):
         """ Called when the kernel manager has stopped listening.
         """
         # FIXME: Print a message here?
         pass
 
     def _document_contents_change(self, position, removed, added):
         """ Called whenever the document's content changes. Display a calltip
             if appropriate.
         """
         # Calculate where the cursor should be *after* the change:
         position += added
 
         document = self._control.document()
         if position == self._get_cursor().position():
             self._call_tip()
 
     def _handle_req(self, req):
         # Make sure that all output from the SUB channel has been processed
         # before entering readline mode.
         self.kernel_manager.sub_channel.flush()
 
         def callback(line):
             self.kernel_manager.rep_channel.input(line)
         self._readline(req['content']['prompt'], callback=callback)
 
     def _handle_sub(self, omsg):
         if self._hidden:
             return
         handler = getattr(self, '_handle_%s' % omsg['msg_type'], None)
         if handler is not None:
             handler(omsg)
 
     def _handle_pyout(self, omsg):
         self._append_plain_text(omsg['content']['data'] + '\n')
 
     def _handle_stream(self, omsg):
         self._append_plain_text(omsg['content']['data'])
         self._control.moveCursor(QtGui.QTextCursor.End)
         
     def _handle_execute_reply(self, reply):
         if self._hidden:
             return
 
         # Make sure that all output from the SUB channel has been processed
         # before writing a new prompt.
         self.kernel_manager.sub_channel.flush()
 
+        # TODO: The reply now has the next_prompt and prompt_number keys.
         status = reply['content']['status']
         if status == 'error':
             self._handle_execute_error(reply)
         elif status == 'aborted':
             text = "ERROR: ABORTED\n"
             self._append_plain_text(text)
         self._hidden = True
         self._show_interpreter_prompt()
         self.executed.emit(reply)
 
     def _handle_execute_error(self, reply):
         content = reply['content']
         traceback = ''.join(content['traceback'])
         self._append_plain_text(traceback)
 
     def _handle_complete_reply(self, rep):
         cursor = self._get_cursor()
         if rep['parent_header']['msg_id'] == self._complete_id and \
                 cursor.position() == self._complete_pos:
             text = '.'.join(self._get_context())
             cursor.movePosition(QtGui.QTextCursor.Left, n=len(text))
             self._complete_with_items(cursor, rep['content']['matches'])
 
     def _handle_object_info_reply(self, rep):
         cursor = self._get_cursor()
         if rep['parent_header']['msg_id'] == self._calltip_id and \
                 cursor.position() == self._calltip_pos:
             doc = rep['content']['docstring']
             if doc:
                 self._call_tip_widget.show_docstring(doc)

IPython/zmq/ipkernel.py

@@ -1,369 +1,383 b''
 #!/usr/bin/env python
 """A simple interactive kernel that talks to a frontend over 0MQ.
 
 Things to do:
 
 * Implement `set_parent` logic. Right before doing exec, the Kernel should
   call set_parent on all the PUB objects with the message about to be executed.
 * Implement random port and security key logic.
 * Implement control messages.
 * Implement event loop and poll version.
 """
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # Standard library imports.
 import __builtin__
-from code import CommandCompiler
 import os
 import sys
 import time
 import traceback
 
 # System library imports.
 import zmq
 
 # Local imports.
 from IPython.config.configurable import Configurable
 from IPython.zmq.zmqshell import ZMQInteractiveShell
 from IPython.external.argparse import ArgumentParser
 from IPython.utils.traitlets import Instance
 from IPython.zmq.session import Session, Message
-from completer import KernelCompleter
 from iostream import OutStream
-from displayhook import DisplayHook
 from exitpoller import ExitPollerUnix, ExitPollerWindows
 
 #-----------------------------------------------------------------------------
 # Main kernel class
 #-----------------------------------------------------------------------------
 
 class Kernel(Configurable):
 
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
     session = Instance('IPython.zmq.session.Session')
     reply_socket = Instance('zmq.Socket')
     pub_socket = Instance('zmq.Socket')
     req_socket = Instance('zmq.Socket')
 
     def __init__(self, **kwargs):
         super(Kernel, self).__init__(**kwargs)
 
         # Initialize the InteractiveShell subclass
         self.shell = ZMQInteractiveShell.instance()
         self.shell.displayhook.session = self.session
         self.shell.displayhook.pub_socket = self.pub_socket
 
         # Build dict of handlers for message types
         msg_types = [ 'execute_request', 'complete_request', 
-                      'object_info_request' ]
+                      'object_info_request', 'prompt_request' ]
         self.handlers = {}
         for msg_type in msg_types:
             self.handlers[msg_type] = getattr(self, msg_type)
 
     def abort_queue(self):
         while True:
             try:
                 ident = self.reply_socket.recv(zmq.NOBLOCK)
             except zmq.ZMQError, e:
                 if e.errno == zmq.EAGAIN:
                     break
             else:
                 assert self.reply_socket.rcvmore(), "Unexpected missing message part."
                 msg = self.reply_socket.recv_json()
             print>>sys.__stdout__, "Aborting:"
             print>>sys.__stdout__, Message(msg)
             msg_type = msg['msg_type']
             reply_type = msg_type.split('_')[0] + '_reply'
             reply_msg = self.session.msg(reply_type, {'status' : 'aborted'}, msg)
             print>>sys.__stdout__, Message(reply_msg)
             self.reply_socket.send(ident,zmq.SNDMORE)
             self.reply_socket.send_json(reply_msg)
             # We need to wait a bit for requests to come in. This can probably
             # be set shorter for true asynchronous clients.
             time.sleep(0.1)
 
     def execute_request(self, ident, parent):
         try:
             code = parent[u'content'][u'code']
         except:
             print>>sys.__stderr__, "Got bad msg: "
             print>>sys.__stderr__, Message(parent)
             return
         pyin_msg = self.session.msg(u'pyin',{u'code':code}, parent=parent)
         self.pub_socket.send_json(pyin_msg)
 
         try:
             # Replace raw_input. Note that is not sufficient to replace 
             # raw_input in the user namespace.
             raw_input = lambda prompt='': self.raw_input(prompt, ident, parent)
             __builtin__.raw_input = raw_input
 
             # Set the parent message of the display hook.
             self.shell.displayhook.set_parent(parent)
 
             self.shell.runlines(code)
             # exec comp_code in self.user_ns, self.user_ns
         except:
             etype, evalue, tb = sys.exc_info()
             tb = traceback.format_exception(etype, evalue, tb)
             exc_content = {
                 u'status' : u'error',
                 u'traceback' : tb,
                 u'ename' : unicode(etype.__name__),
                 u'evalue' : unicode(evalue)
             }
             exc_msg = self.session.msg(u'pyerr', exc_content, parent)
             self.pub_socket.send_json(exc_msg)
             reply_content = exc_content
         else:
             reply_content = {'status' : 'ok'}
-            
+
+        # Compute the prompt information
+        prompt_number = self.shell.displayhook.prompt_count
+        reply_content['prompt_number'] = prompt_number        
+        prompt_string = self.shell.displayhook.prompt1.peek_next_prompt()
+        next_prompt = {'prompt_string' : prompt_string,
+                       'prompt_number' : prompt_number+1}
+        reply_content['next_prompt'] = next_prompt
+
         # Flush output before sending the reply.
         sys.stderr.flush()
         sys.stdout.flush()
 
         # Send the reply.
         reply_msg = self.session.msg(u'execute_reply', reply_content, parent)
         print>>sys.__stdout__, Message(reply_msg)
         self.reply_socket.send(ident, zmq.SNDMORE)
         self.reply_socket.send_json(reply_msg)
         if reply_msg['content']['status'] == u'error':
             self.abort_queue()
 
     def raw_input(self, prompt, ident, parent):
         # Flush output before making the request.
         sys.stderr.flush()
         sys.stdout.flush()
 
         # Send the input request.
         content = dict(prompt=prompt)
         msg = self.session.msg(u'input_request', content, parent)
         self.req_socket.send_json(msg)
 
         # Await a response.
         reply = self.req_socket.recv_json()
         try:
             value = reply['content']['value']
         except:
             print>>sys.__stderr__, "Got bad raw_input reply: "
             print>>sys.__stderr__, Message(parent)
             value = ''
         return value
 
     def complete_request(self, ident, parent):
         matches = {'matches' : self.complete(parent),
                    'status' : 'ok'}
         completion_msg = self.session.send(self.reply_socket, 'complete_reply',
                                            matches, parent, ident)
         print >> sys.__stdout__, completion_msg
 
     def complete(self, msg):
         return self.shell.complete(msg.content.line)
 
     def object_info_request(self, ident, parent):
         context = parent['content']['oname'].split('.')
         object_info = self.object_info(context)
         msg = self.session.send(self.reply_socket, 'object_info_reply',
                                 object_info, parent, ident)
         print >> sys.__stdout__, msg
 
     def object_info(self, context):
         symbol, leftover = self.symbol_from_context(context)
         if symbol is not None and not leftover:
             doc = getattr(symbol, '__doc__', '')
         else:
             doc = ''
         object_info = dict(docstring = doc)
         return object_info
 
     def symbol_from_context(self, context):
         if not context:
             return None, context
 
         base_symbol_string = context[0]
         symbol = self.shell.user_ns.get(base_symbol_string, None)
         if symbol is None:
             symbol = __builtin__.__dict__.get(base_symbol_string, None)
         if symbol is None:
             return None, context
 
         context = context[1:]
         for i, name in enumerate(context):
             new_symbol = getattr(symbol, name, None)
             if new_symbol is None:
                 return symbol, context[i:]
             else:
                 symbol = new_symbol
 
         return symbol, []
 
+    def prompt_request(self, ident, parent):
+        prompt_number = self.shell.displayhook.prompt_count
+        prompt_string = self.shell.displayhook.prompt1.peek_next_prompt()
+        content = {'prompt_string' : prompt_string,
+                   'prompt_number' : prompt_number+1}
+        msg = self.session.send(self.reply_socket, 'prompt_reply',
+                                content, parent, ident)
+        print >> sys.__stdout__, msg
+
     def start(self):
         while True:
             ident = self.reply_socket.recv()
             assert self.reply_socket.rcvmore(), "Missing message part."
             msg = self.reply_socket.recv_json()
             omsg = Message(msg)
             print>>sys.__stdout__
             print>>sys.__stdout__, omsg
             handler = self.handlers.get(omsg.msg_type, None)
             if handler is None:
                 print >> sys.__stderr__, "UNKNOWN MESSAGE TYPE:", omsg
             else:
                 handler(ident, omsg)
 
 #-----------------------------------------------------------------------------
 # Kernel main and launch functions
 #-----------------------------------------------------------------------------
 
 def bind_port(socket, ip, port):
     """ Binds the specified ZMQ socket. If the port is less than zero, a random
     port is chosen. Returns the port that was bound.
     """
     connection = 'tcp://%s' % ip
     if port <= 0:
         port = socket.bind_to_random_port(connection)
     else:
         connection += ':%i' % port
         socket.bind(connection)
     return port
 
 
 def main():
     """ Main entry point for launching a kernel.
     """
     # Parse command line arguments.
     parser = ArgumentParser()
     parser.add_argument('--ip', type=str, default='127.0.0.1',
                         help='set the kernel\'s IP address [default: local]')
     parser.add_argument('--xrep', type=int, metavar='PORT', default=0,
                         help='set the XREP channel port [default: random]')
     parser.add_argument('--pub', type=int, metavar='PORT', default=0,
                         help='set the PUB channel port [default: random]')
     parser.add_argument('--req', type=int, metavar='PORT', default=0,
                         help='set the REQ channel port [default: random]')
     if sys.platform == 'win32':
         parser.add_argument('--parent', type=int, metavar='HANDLE', 
                             default=0, help='kill this process if the process '
                             'with HANDLE dies')
     else:
         parser.add_argument('--parent', action='store_true', 
                             help='kill this process if its parent dies')
     namespace = parser.parse_args()
 
     # Create a context, a session, and the kernel sockets.
     print >>sys.__stdout__, "Starting the kernel..."
     context = zmq.Context()
     session = Session(username=u'kernel')
 
     reply_socket = context.socket(zmq.XREP)
     xrep_port = bind_port(reply_socket, namespace.ip, namespace.xrep)
     print >>sys.__stdout__, "XREP Channel on port", xrep_port
 
     pub_socket = context.socket(zmq.PUB)
     pub_port = bind_port(pub_socket, namespace.ip, namespace.pub)
     print >>sys.__stdout__, "PUB Channel on port", pub_port
 
     req_socket = context.socket(zmq.XREQ)
     req_port = bind_port(req_socket, namespace.ip, namespace.req)
     print >>sys.__stdout__, "REQ Channel on port", req_port
 
     # Redirect input streams. This needs to be done before the Kernel is done
     # because currently the Kernel creates a ZMQInteractiveShell, which
     # holds references to sys.stdout and sys.stderr.
     sys.stdout = OutStream(session, pub_socket, u'stdout')
     sys.stderr = OutStream(session, pub_socket, u'stderr')
 
     # Create the kernel.
     kernel = Kernel(
         session=session, reply_socket=reply_socket,
         pub_socket=pub_socket, req_socket=req_socket
     )
 
     # Configure this kernel/process to die on parent termination, if necessary.
     if namespace.parent:
         if sys.platform == 'win32':
             poller = ExitPollerWindows(namespace.parent)
         else:
             poller = ExitPollerUnix()
         poller.start()
 
     # Start the kernel mainloop.
     kernel.start()
 
 
 def launch_kernel(xrep_port=0, pub_port=0, req_port=0, independent=False):
     """ Launches a localhost kernel, binding to the specified ports.
 
     Parameters
     ----------
     xrep_port : int, optional
         The port to use for XREP channel.
 
     pub_port : int, optional
         The port to use for the SUB channel.
 
     req_port : int, optional
         The port to use for the REQ (raw input) channel.
 
     independent : bool, optional (default False) 
         If set, the kernel process is guaranteed to survive if this process
         dies. If not set, an effort is made to ensure that the kernel is killed
         when this process dies. Note that in this case it is still good practice
         to kill kernels manually before exiting.
 
     Returns
     -------
     A tuple of form:
         (kernel_process, xrep_port, pub_port, req_port)
     where kernel_process is a Popen object and the ports are integers.
     """
     import socket
     from subprocess import Popen
 
     # Find open ports as necessary.
     ports = []
     ports_needed = int(xrep_port <= 0) + int(pub_port <= 0) + int(req_port <= 0)
     for i in xrange(ports_needed):
         sock = socket.socket()
         sock.bind(('', 0))
         ports.append(sock)
     for i, sock in enumerate(ports):
         port = sock.getsockname()[1]
         sock.close()
         ports[i] = port
     if xrep_port <= 0:
         xrep_port = ports.pop(0)
     if pub_port <= 0:
         pub_port = ports.pop(0)
     if req_port <= 0:
         req_port = ports.pop(0)
         
     # Spawn a kernel.
     command = 'from IPython.zmq.ipkernel import main; main()'
     arguments = [ sys.executable, '-c', command, '--xrep', str(xrep_port), 
                   '--pub', str(pub_port), '--req', str(req_port) ]
     if independent:
         if sys.platform == 'win32':
             proc = Popen(['start', '/b'] + arguments, shell=True)
         else:
             proc = Popen(arguments, preexec_fn=lambda: os.setsid())
     else:
         if sys.platform == 'win32':
             from _subprocess import DuplicateHandle, GetCurrentProcess, \
                 DUPLICATE_SAME_ACCESS
             pid = GetCurrentProcess()
             handle = DuplicateHandle(pid, pid, pid, 0, 
                                      True, # Inheritable by new  processes.
                                      DUPLICATE_SAME_ACCESS)
             proc = Popen(arguments + ['--parent', str(int(handle))])
         else:
             proc = Popen(arguments + ['--parent'])
 
     return proc, xrep_port, pub_port, req_port
     
 
 if __name__ == '__main__':
     main()

IPython/zmq/zmqshell.py

@@ -1,72 +1,72 b''
 import sys
 from subprocess import Popen, PIPE
 
 from IPython.core.interactiveshell import (
     InteractiveShell, InteractiveShellABC
 )
 from IPython.core.displayhook import DisplayHook
 from IPython.utils.traitlets import Instance, Type, Dict
 from IPython.zmq.session import extract_header
 
 
-class ZMQDisplayTrap(DisplayHook):
+class ZMQDisplayHook(DisplayHook):
 
     session = Instance('IPython.zmq.session.Session')
     pub_socket = Instance('zmq.Socket')
     parent_header = Dict({})
 
     def set_parent(self, parent):
         """Set the parent for outbound messages."""
         self.parent_header = extract_header(parent)
 
     def start_displayhook(self):
         self.msg = self.session.msg(u'pyout', {}, parent=self.parent_header)
 
     def write_output_prompt(self):
         """Write the output prompt."""
         if self.do_full_cache:
             self.msg['content']['output_sep'] = self.output_sep
             self.msg['content']['prompt_string'] = str(self.prompt_out)
             self.msg['content']['prompt_number'] = self.prompt_count
             self.msg['content']['output_sep2'] = self.output_sep2
 
     def write_result_repr(self, result_repr):
         self.msg['content']['data'] = result_repr
 
     def finish_displayhook(self):
         """Finish up all displayhook activities."""
         self.pub_socket.send_json(self.msg)
         self.msg = None
 
 
 class ZMQInteractiveShell(InteractiveShell):
     """A subclass of InteractiveShell for ZMQ."""
 
-    displayhook_class = Type(ZMQDisplayTrap)
+    displayhook_class = Type(ZMQDisplayHook)
 
     def system(self, cmd):
         cmd = self.var_expand(cmd, depth=2)
         sys.stdout.flush()
         sys.stderr.flush()
         p = Popen(cmd, shell=True, stdout=PIPE, stderr=PIPE)
         for line in p.stdout.read().split('\n'):
             if len(line) > 0:
                 print line
         for line in p.stderr.read().split('\n'):
             if len(line) > 0:
                 print line
         p.wait()
 
     def init_io(self):
         # This will just use sys.stdout and sys.stderr. If you want to
         # override sys.stdout and sys.stderr themselves, you need to do that
         # *before* instantiating this class, because Term holds onto 
         # references to the underlying streams.
         import IPython.utils.io
         Term = IPython.utils.io.IOTerm()
         IPython.utils.io.Term = Term
 
 InteractiveShellABC.register(ZMQInteractiveShell)