sys.displayhook is now managed dynamically by display_trap.

IPython/core/display_trap.py

@@ -0,0 +1,62 b''
+#!/usr/bin/env python
+# encoding: utf-8
+"""
+A context manager for handling sys.displayhook.
+
+Authors:
+
+* Robert Kern
+* Brian Granger
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2008-2009  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.core.component import Component
+
+#-----------------------------------------------------------------------------
+# Classes and functions
+#-----------------------------------------------------------------------------
+
+
+class DisplayTrap(Component):
+    """Object to manage sys.displayhook.
+
+    This came from IPython.core.kernel.display_hook, but is simplified
+    (no callbacks or formatters) until more of the core is refactored.
+    """
+
+    def __init__(self, parent, hook):
+        super(DisplayTrap, self).__init__(parent, None, None)
+
+        self.hook = hook
+        self.old_hook = None
+
+    def __enter__(self):
+        self.set()
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.unset()
+        return True
+
+    def set(self):
+        """Set the hook."""
+        if sys.displayhook is not self.hook:
+            self.old_hook = sys.displayhook
+            sys.displayhook = self.hook
+
+    def unset(self):
+        """Unset the hook."""
+        sys.displayhook = self.old_hook
+

IPython/core/builtin_trap.py

@@ -38,8 +38,8 b' BuiltinUndefined = BuiltinUndefined()'
 class BuiltinTrap(Component):
     shell = Instance('IPython.core.iplib.InteractiveShell')
 
-    def __init__(self, parent, name=None, config=None):
-        super(BuiltinTrap, self).__init__(parent, name, config)
+    def __init__(self, parent):
+        super(BuiltinTrap, self).__init__(parent, None, None)
         # Don't just grab parent!!!
         self.shell = Component.get_instances(root=self.root,
             klass='IPython.core.iplib.InteractiveShell')[0]

IPython/core/embed.py

@@ -26,6 +26,7 b' Notes'
 from __future__ import with_statement
 
 import sys
+from contextlib import nested
 
 from IPython.core import ultratb
 from IPython.core.iplib import InteractiveShell
@@ -67,9 +68,6 b' class InteractiveShellEmbed(InteractiveShell):'
                  banner1=None, banner2=None,
                  custom_exceptions=((),None), exit_msg=''):
 
-        # First we need to save the state of sys.displayhook and
-        # sys.ipcompleter so we can restore it when we are done.
-        self.save_sys_displayhook()
         self.save_sys_ipcompleter()
 
         super(InteractiveShellEmbed,self).__init__(
@@ -78,7 +76,6 b' class InteractiveShellEmbed(InteractiveShell):'
             banner1=banner1, banner2=banner2, 
             custom_exceptions=custom_exceptions)
 
-        self.save_sys_displayhook_embed()
         self.exit_msg = exit_msg
         self.define_magic("kill_embedded", kill_embedded)
 
@@ -88,17 +85,11 b' class InteractiveShellEmbed(InteractiveShell):'
                                              mode=self.xmode,
                                              call_pdb=self.pdb)
 
-        self.restore_sys_displayhook()
         self.restore_sys_ipcompleter()
 
     def init_sys_modules(self):
         pass
 
-    def save_sys_displayhook(self):
-        # sys.displayhook is a global, we need to save the user's original
-        # Don't rely on __displayhook__, as the user may have changed that.
-        self.sys_displayhook_orig = sys.displayhook
-
     def save_sys_ipcompleter(self):
         """Save readline completer status."""
         try:
@@ -107,9 +98,6 b' class InteractiveShellEmbed(InteractiveShell):'
         except:
             pass # not nested with IPython        
 
-    def restore_sys_displayhook(self):
-        sys.displayhook = self.sys_displayhook_orig
-
     def restore_sys_ipcompleter(self):
         """Restores the readline completer which was in place.
 
@@ -122,12 +110,6 b' class InteractiveShellEmbed(InteractiveShell):'
         except:
             pass
 
-    def save_sys_displayhook_embed(self):
-        self.sys_displayhook_embed = sys.displayhook
-
-    def restore_sys_displayhook_embed(self):
-        sys.displayhook = self.sys_displayhook_embed
-
     def __call__(self, header='', local_ns=None, global_ns=None, dummy=None,
                  stack_depth=1):
         """Activate the interactive interpreter.
@@ -161,8 +143,6 b' class InteractiveShellEmbed(InteractiveShell):'
         if dummy or (dummy != 0 and self.dummy_mode):
             return
 
-        self.restore_sys_displayhook_embed()
-
         if self.has_readline:
             self.set_completer()
 
@@ -180,8 +160,6 b' class InteractiveShellEmbed(InteractiveShell):'
         if self.exit_msg is not None:
             print self.exit_msg
             
-        # Restore global systems (display, completion)
-        self.restore_sys_displayhook()
         self.restore_sys_ipcompleter()
 
     def mainloop(self,header='',local_ns=None,global_ns=None,stack_depth=0):
@@ -240,7 +218,7 b' class InteractiveShellEmbed(InteractiveShell):'
         # actually completes using the frame's locals/globals
         self.set_completer_frame()
 
-        with self.builtin_trap:
+        with nested(self.builtin_trap, self.display_trap):
             self.interact(header)
         
             # now, purge out the user namespace from anything we might have added

IPython/core/iplib.py

@@ -33,6 +33,7 b' import shutil'
 import string
 import sys
 import tempfile
+from contextlib import nested
 
 from IPython.core import ultratb
 from IPython.core import debugger, oinspect
@@ -41,6 +42,7 b' from IPython.core import history as ipcorehist'
 from IPython.core import prefilter
 from IPython.core.autocall import IPyAutocall
 from IPython.core.builtin_trap import BuiltinTrap
+from IPython.core.display_trap import DisplayTrap
 from IPython.core.fakemodule import FakeModule, init_fakemod_dict
 from IPython.core.logger import Logger
 from IPython.core.magic import Magic
@@ -940,13 +942,7 b' class InteractiveShell(Component, Magic):'
             pass
 
     def init_displayhook(self):
-        # I don't like assigning globally to sys, because it means when
-        # embedding instances, each embedded instance overrides the previous
-        # choice. But sys.displayhook seems to be called internally by exec,
-        # so I don't see a way around it.  We first save the original and then
-        # overwrite it.
-        self.sys_displayhook = sys.displayhook
-        sys.displayhook = self.outputcache
+        self.display_trap = DisplayTrap(self, self.outputcache)
 
     def init_reload_doctest(self):
         # Do a proper resetting of doctest, including the necessary displayhook
@@ -1061,7 +1057,6 b' class InteractiveShell(Component, Magic):'
         self._orig_sys_module_state['stdin'] = sys.stdin
         self._orig_sys_module_state['stdout'] = sys.stdout
         self._orig_sys_module_state['stderr'] = sys.stderr
-        self._orig_sys_module_state['displayhook'] = sys.displayhook
         self._orig_sys_module_state['excepthook'] = sys.excepthook
         try:
             self._orig_sys_modules_main_name = self.user_ns['__name__']
@@ -1251,7 +1246,7 b' class InteractiveShell(Component, Magic):'
             error("Magic function `%s` not found." % magic_name)
         else:
             magic_args = self.var_expand(magic_args,1)
-            with self.builtin_trap:
+            with nested(self.builtin_trap, self.display_trap):
                 return fn(magic_args)
             # return result
 
@@ -1348,7 +1343,7 b' class InteractiveShell(Component, Magic):'
 
     def ex(self, cmd):
         """Execute a normal python statement in user namespace."""
-        with self.builtin_trap:
+        with nested(self.builtin_trap, self.display_trap):
             exec cmd in self.user_global_ns, self.user_ns
 
     def ev(self, expr):
@@ -1356,7 +1351,7 b' class InteractiveShell(Component, Magic):'
 
         Returns the result of evaluation
         """
-        with self.builtin_trap:
+        with nested(self.builtin_trap, self.display_trap):
             return eval(expr, self.user_global_ns, self.user_ns)
 
     def getoutput(self, cmd):
@@ -1688,6 +1683,8 b' class InteractiveShell(Component, Magic):'
                 try:
                     f = file(err.filename)
                     try:
+                        # This should be inside a display_trap block and I 
+                        # think it is.
                         sys.displayhook(f.read())
                     finally:
                         f.close()
@@ -1805,7 +1802,7 b' class InteractiveShell(Component, Magic):'
         internally created default banner.
         """
         
-        with self.builtin_trap:
+        with nested(self.builtin_trap, self.display_trap):
             if self.c:  # Emulate Python's -c option
                 self.exec_init_cmd()
 
@@ -2237,7 +2234,7 b' class InteractiveShell(Component, Magic):'
         lines = lines.splitlines()
         more = 0
 
-        with self.builtin_trap:
+        with nested(self.builtin_trap, self.display_trap):
             for line in lines:
                 # skip blank lines so we don't mess up the prompt counter, but do
                 # NOT skip even a blank line if we are in a code block (more is

IPython/core/ultratb.py

@@ -69,7 +69,8 b' possible inclusion in future releases.'
 #  the file COPYING, distributed as part of this software.
 #*****************************************************************************
 
-# Required modules
+from __future__ import with_statement
+
 import inspect
 import keyword
 import linecache
@@ -92,6 +93,7 b' from inspect import getsourcefile, getfile, getmodule,\\'
 # Modified pdb which doesn't damage IPython's readline handling
 from IPython.utils import PyColorize
 from IPython.core import debugger, ipapi
+from IPython.core.display_trap import DisplayTrap
 from IPython.utils.ipstruct import Struct
 from IPython.core.excolors import exception_colors
 from IPython.utils.genutils import Term,uniq_stable,error,info
@@ -848,8 +850,8 b' class VerboseTB(TBTools):'
                     self.color_scheme_table.active_scheme_name)
             # the system displayhook may have changed, restore the original
             # for pdb
-            dhook = sys.displayhook
-            sys.displayhook = sys.__displayhook__
+            display_trap = DisplayTrap(None, sys.__displayhook__)
+            with display_trap:
             self.pdb.reset()
             # Find the right frame so we don't pop up inside ipython itself
             if hasattr(self,'tb'):
@@ -858,13 +860,10 b' class VerboseTB(TBTools):'
                 etb = self.tb = sys.last_traceback
             while self.tb.tb_next is not None:
                 self.tb = self.tb.tb_next
-            try:
                 if etb and etb.tb_next:
                     etb = etb.tb_next
                 self.pdb.botframe = etb.tb_frame
                 self.pdb.interaction(self.tb.tb_frame, self.tb)
-            finally:
-                sys.displayhook = dhook
             
         if hasattr(self,'tb'):
             del self.tb