Merge pull request #2179 from dopplershift/pylab-switch

Enable switching %pylab mode between inline and a single gui mode in a single notebook.

With this merge, `%pylab` can be called interactively to toggle inline/GUI (matplotlib floating windows) mode.  After initializing `%pylab inline`, now one can call `%pylab` without arguments to activate the default GUI or ask for a specific one as usual.

IPython will detect if a different GUI is requested if one was already activated and will refuse to do so (to prevent multiple event loops from running concurrently, which often leads to problems).

docs/examples/tests/pylab-switch/Pylab Switching.ipynb

@@ -0,0 +1,108 b''
+{
+ "metadata": {
+  "name": "Pylab Switching"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "# Should pop up a GUI window\n",
+      "%pylab qt\n",
+      "plot([1,2,3])"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "\n",
+        "Welcome to pylab, a matplotlib-based Python environment [backend: Qt4Agg].\n",
+        "For more information, type 'help(pylab)'.\n"
+       ]
+      },
+      {
+       "output_type": "pyout",
+       "prompt_number": 3,
+       "text": [
+        "[<matplotlib.lines.Line2D at 0x4566850>]"
+       ]
+      }
+     ],
+     "prompt_number": 3
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "# Should make an inline figure\n",
+      "%pylab inline\n",
+      "plot([1,2,3])"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "\n",
+        "Welcome to pylab, a matplotlib-based Python environment [backend: module://IPython.zmq.pylab.backend_inline].\n",
+        "For more information, type 'help(pylab)'.\n"
+       ]
+      },
+      {
+       "output_type": "pyout",
+       "prompt_number": 4,
+       "text": [
+        "[<matplotlib.lines.Line2D at 0x4830ad0>]"
+       ]
+      },
+      {
+       "output_type": "display_data",
+       "png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAD9CAYAAACoXlzKAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nsLADgMuwsAOAy7CwA4DL/BdtJN59CWl7cgAAAABJRU5ErkJggg==\n"
+      }
+     ],
+     "prompt_number": 4
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "# New GUI window--should *NOT* have the visual settings of inline\n",
+      "%pylab qt\n",
+      "plot([1,2,3])"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "\n",
+        "Welcome to pylab, a matplotlib-based Python environment [backend: Qt4Agg].\n",
+        "For more information, type 'help(pylab)'.\n"
+       ]
+      },
+      {
+       "output_type": "pyout",
+       "prompt_number": 11,
+       "text": [
+        "[<matplotlib.lines.Line2D at 0x5253850>]"
+       ]
+      }
+     ],
+     "prompt_number": 11
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
  No newline at end of file

IPython/core/interactiveshell.py

@@ -423,6 +423,9 b' class InteractiveShell(SingletonConfigurable):'
     # Private interface
     _post_execute = Instance(dict)
 
+    # Tracks any GUI loop loaded for pylab
+    pylab_gui_select = None
+
     def __init__(self, config=None, ipython_dir=None, profile_dir=None,
                  user_module=None, user_ns=None,
                  custom_exceptions=((), None)):

IPython/core/pylabtools.py

@@ -174,13 +174,16 b' def select_figure_format(shell, fmt):'
 #-----------------------------------------------------------------------------
 
 
-def find_gui_and_backend(gui=None):
+def find_gui_and_backend(gui=None, gui_select=None):
     """Given a gui string return the gui and mpl backend.
 
     Parameters
     ----------
     gui : str
         Can be one of ('tk','gtk','wx','qt','qt4','inline').
+    gui_select : str
+        Can be one of ('tk','gtk','wx','qt','qt4','inline').
+        This is any gui already selected by the shell.
 
     Returns
     -------
@@ -198,6 +201,13 b' def find_gui_and_backend(gui=None):'
         # In this case, we need to find what the appropriate gui selection call
         # should be for IPython, so we can activate inputhook accordingly
         gui = backend2gui.get(backend, None)
+
+        # If we have already had a gui active, we need it and inline are the
+        # ones allowed.
+        if gui_select and gui != gui_select:
+            gui = gui_select
+            backend = backends[gui]
+
     return gui, backend
 
 
@@ -205,23 +215,20 b' def activate_matplotlib(backend):'
     """Activate the given backend and set interactive to True."""
 
     import matplotlib
-    if backend.startswith('module://'):
-        # Work around bug in matplotlib: matplotlib.use converts the
-        # backend_id to lowercase even if a module name is specified!
-        matplotlib.rcParams['backend'] = backend
-    else:
-        matplotlib.use(backend)
     matplotlib.interactive(True)
 
+    # Matplotlib had a bug where even switch_backend could not force
+    # the rcParam to update. This needs to be set *before* the module
+    # magic of switch_backend().
+    matplotlib.rcParams['backend'] = backend
+
+    import matplotlib.pyplot
+    matplotlib.pyplot.switch_backend(backend)
+
     # This must be imported last in the matplotlib series, after
     # backend/interactivity choices have been made
     import matplotlib.pylab as pylab
 
-    # XXX For now leave this commented out, but depending on discussions with
-    # mpl-dev, we may be able to allow interactive switching...
-    #import matplotlib.pyplot
-    #matplotlib.pyplot.switch_backend(backend)
-
     pylab.show._needmain = False
     # We need to detect at runtime whether show() is called by the user.
     # For this, we wrap it into a decorator which adds a 'called' flag.
@@ -272,6 +279,7 b' def configure_inline_support(shell, backend, user_ns=None):'
         from IPython.zmq.pylab.backend_inline import InlineBackend
     except ImportError:
         return
+    from matplotlib import pyplot
 
     user_ns = shell.user_ns if user_ns is None else user_ns
     
@@ -282,12 +290,23 b' def configure_inline_support(shell, backend, user_ns=None):'
 
     if backend == backends['inline']:
         from IPython.zmq.pylab.backend_inline import flush_figures
-        from matplotlib import pyplot
         shell.register_post_execute(flush_figures)
+
+        # Save rcParams that will be overwrittern
+        shell._saved_rcParams = dict()
+        for k in cfg.rc:
+            shell._saved_rcParams[k] = pyplot.rcParams[k]
         # load inline_rc
         pyplot.rcParams.update(cfg.rc)
         # Add 'figsize' to pyplot and to the user's namespace
         user_ns['figsize'] = pyplot.figsize = figsize
+    else:
+        from IPython.zmq.pylab.backend_inline import flush_figures
+        if flush_figures in shell._post_execute:
+            shell._post_execute.pop(flush_figures)
+        if hasattr(shell, '_saved_rcParams'):
+            pyplot.rcParams.update(shell._saved_rcParams)
+            del shell._saved_rcParams
 
     # Setup the default figure format
     fmt = cfg.figure_format
@@ -321,7 +340,18 b' def pylab_activate(user_ns, gui=None, import_all=True, shell=None):'
     The actual gui used (if not given as input, it was obtained from matplotlib
     itself, and will be needed next to configure IPython's gui integration.
     """
-    gui, backend = find_gui_and_backend(gui)
+    pylab_gui_select = shell.pylab_gui_select if shell is not None else None
+    # Try to find the appropriate gui and backend for the settings
+    gui, backend = find_gui_and_backend(gui, pylab_gui_select)
+    if shell is not None and gui != 'inline':
+        # If we have our first gui selection, store it
+        if pylab_gui_select is None:
+            shell.pylab_gui_select = gui
+        # Otherwise if they are different
+        elif gui != pylab_gui_select:
+            print ('Warning: Cannot change to a different GUI toolkit: %s.'
+                    ' Using %s instead.' % (gui, pylab_gui_select))
+            gui, backend = find_gui_and_backend(pylab_gui_select)
     activate_matplotlib(backend)
     import_pylab(user_ns, import_all)
     if shell is not None:

IPython/core/tests/test_pylabtools.py

@@ -61,3 +61,79 b' def test_import_pylab():'
     pt.import_pylab(ns, import_all=False)
     nt.assert_true('plt' in ns)
     nt.assert_equal(ns['np'], np)
+
+
+class TestPylabSwitch(object):
+    class Shell(object):
+        pylab_gui_select = None
+
+    def setup(self):
+        import matplotlib
+        def act_mpl(backend):
+            matplotlib.rcParams['backend'] = backend
+
+        # Save rcParams since they get modified
+        self._saved_rcParams = matplotlib.rcParams
+        matplotlib.rcParams = dict(backend='Qt4Agg')
+
+        # Mock out functions
+        self._save_am = pt.activate_matplotlib
+        pt.activate_matplotlib = act_mpl
+        self._save_ip = pt.import_pylab
+        pt.import_pylab = lambda *a,**kw:None
+        self._save_cis = pt.configure_inline_support
+        pt.configure_inline_support = lambda *a,**kw:None
+
+    def teardown(self):
+        pt.activate_matplotlib = self._save_am
+        pt.import_pylab = self._save_ip
+        pt.configure_inline_support = self._save_cis
+        import matplotlib
+        matplotlib.rcParams = self._saved_rcParams
+
+    def test_qt(self):
+        s = self.Shell()
+        gui = pt.pylab_activate(dict(), None, False, s)
+        nt.assert_equal(gui, 'qt')
+        nt.assert_equal(s.pylab_gui_select, 'qt')
+
+        gui = pt.pylab_activate(dict(), 'inline', False, s)
+        nt.assert_equal(gui, 'inline')
+        nt.assert_equal(s.pylab_gui_select, 'qt')
+
+        gui = pt.pylab_activate(dict(), 'qt', False, s)
+        nt.assert_equal(gui, 'qt')
+        nt.assert_equal(s.pylab_gui_select, 'qt')
+
+        gui = pt.pylab_activate(dict(), 'inline', False, s)
+        nt.assert_equal(gui, 'inline')
+        nt.assert_equal(s.pylab_gui_select, 'qt')
+
+        gui = pt.pylab_activate(dict(), None, False, s)
+        nt.assert_equal(gui, 'qt')
+        nt.assert_equal(s.pylab_gui_select, 'qt')
+
+    def test_inline(self):
+        s = self.Shell()
+        gui = pt.pylab_activate(dict(), 'inline', False, s)
+        nt.assert_equal(gui, 'inline')
+        nt.assert_equal(s.pylab_gui_select, None)
+
+        gui = pt.pylab_activate(dict(), 'inline', False, s)
+        nt.assert_equal(gui, 'inline')
+        nt.assert_equal(s.pylab_gui_select, None)
+
+        gui = pt.pylab_activate(dict(), 'qt', False, s)
+        nt.assert_equal(gui, 'qt')
+        nt.assert_equal(s.pylab_gui_select, 'qt')
+
+    def test_qt_gtk(self):
+        s = self.Shell()
+        gui = pt.pylab_activate(dict(), 'qt', False, s)
+        nt.assert_equal(gui, 'qt')
+        nt.assert_equal(s.pylab_gui_select, 'qt')
+
+        gui = pt.pylab_activate(dict(), 'gtk', False, s)
+        nt.assert_equal(gui, 'qt')
+        nt.assert_equal(s.pylab_gui_select, 'qt')
+

IPython/zmq/eventloops.py

@@ -218,6 +218,6 b' def enable_gui(gui, kernel=None):'
                 " and no IPython Application with a kernel appears to be running."
             )
     loop = loop_map[gui]
-    if kernel.eventloop is not None and kernel.eventloop is not loop:
+    if loop and kernel.eventloop is not None and kernel.eventloop is not loop:
         raise RuntimeError("Cannot activate multiple GUI eventloops")
     kernel.eventloop = loop

IPython/zmq/ipkernel.py

@@ -254,8 +254,6 b' class Kernel(Configurable):'
                 self.eventloop = None
                 break
         self.log.info("exiting eventloop")
-        # if eventloop exits, IOLoop should stop
-        ioloop.IOLoop.instance().stop()
 
     def start(self):
         """register dispatchers for streams"""