enable %gui/%pylab magics in the Kernel

This isn't as significant as it looks, as it's principally a big
dedent in zmq.ipkernel.  All the single-method Kernel subclasses were just dedented, and are used as functions.  This lets them be plugged into the existing kernel's event loop.

The enable_pylab and magic_gui methods in zmqshell only differ from the originals in the source of the enable_gui function, and the change of the default pylab backend to inline, from matplotlib autodetect.

IPython/lib/pylabtools.py

@@ -289,7 +289,7 b' def import_pylab(user_ns, backend, import_all=True, shell=None):'
             exec s in shell.user_ns_hidden
 
 
-def pylab_activate(user_ns, gui=None, import_all=True):
+def pylab_activate(user_ns, gui=None, import_all=True, shell=None):
     """Activate pylab mode in the user's namespace.
 
     Loads and initializes numpy, matplotlib and friends for interactive use.
@@ -312,7 +312,7 b' def pylab_activate(user_ns, gui=None, import_all=True):'
     """
     gui, backend = find_gui_and_backend(gui)
     activate_matplotlib(backend)
-    import_pylab(user_ns, backend, import_all)
+    import_pylab(user_ns, backend, import_all, shell)
 
     print """
 Welcome to pylab, a matplotlib-based Python environment [backend: %s].

IPython/zmq/ipkernel.py

@@ -22,6 +22,7 b' import sys'
 import time
 import traceback
 import logging
+
 # System library imports.
 import zmq
 
@@ -38,7 +39,7 b' from IPython.utils import py3compat'
 from IPython.utils.jsonutil import json_clean
 from IPython.lib import pylabtools
 from IPython.utils.traitlets import (
-    List, Instance, Float, Dict, Bool, Int, Unicode, CaselessStrEnum
+    Any, List, Instance, Float, Dict, Bool, Int, Unicode, CaselessStrEnum
 )
 
 from entry_point import base_launch_kernel
@@ -58,6 +59,9 b' class Kernel(Configurable):'
     # Kernel interface
     #---------------------------------------------------------------------------
 
+    # attribute to override with a GUI
+    eventloop = Any(None)
+
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
     session = Instance(Session)
     shell_socket = Instance('zmq.Socket')
@@ -164,7 +168,8 b' class Kernel(Configurable):'
         """
         poller = zmq.Poller()
         poller.register(self.shell_socket, zmq.POLLIN)
-        while True:
+        # loop while self.eventloop has not been overridden
+        while self.eventloop is None:
             try:
                 # scale by extra factor of 10, because there is no
                 # reason for this to be anything less than ~ 0.1s
@@ -181,6 +186,13 b' class Kernel(Configurable):'
             except KeyboardInterrupt:
                 # Ctrl-C shouldn't crash the kernel
                 io.raw_print("KeyboardInterrupt caught in kernel")
+        if self.eventloop is not None:
+            try:
+                self.eventloop(self)
+            except KeyboardInterrupt:
+                # Ctrl-C shouldn't crash the kernel
+                io.raw_print("KeyboardInterrupt caught in kernel")
+
 
     def record_ports(self, ports):
         """Record the ports that this kernel is using.
@@ -496,36 +508,35 b' class Kernel(Configurable):'
             time.sleep(0.01)
 
 
-class QtKernel(Kernel):
-    """A Kernel subclass with Qt support."""
+#------------------------------------------------------------------------------
+# Eventloops for integrating the Kernel into different GUIs
+#------------------------------------------------------------------------------
 
-    def start(self):
-        """Start a kernel with QtPy4 event loop integration."""
+
+def loop_qt4(kernel):
+    """Start a kernel with PyQt4 event loop integration."""
 
         from IPython.external.qt_for_kernel import QtCore
         from IPython.lib.guisupport import get_app_qt4, start_event_loop_qt4
 
-        self.app = get_app_qt4([" "])
-        self.app.setQuitOnLastWindowClosed(False)
-        self.timer = QtCore.QTimer()
-        self.timer.timeout.connect(self.do_one_iteration)
+    kernel.app = get_app_qt4([" "])
+    kernel.app.setQuitOnLastWindowClosed(False)
+    kernel.timer = QtCore.QTimer()
+    kernel.timer.timeout.connect(kernel.do_one_iteration)
         # Units for the timer are in milliseconds
-        self.timer.start(1000*self._poll_interval)
-        start_event_loop_qt4(self.app)
+    kernel.timer.start(1000*kernel._poll_interval)
+    start_event_loop_qt4(kernel.app)
 
 
-class WxKernel(Kernel):
-    """A Kernel subclass with Wx support."""
-
-    def start(self):
+def loop_wx(kernel):
         """Start a kernel with wx event loop support."""
 
         import wx
         from IPython.lib.guisupport import start_event_loop_wx
 
-        doi = self.do_one_iteration
+    doi = kernel.do_one_iteration
          # Wx uses milliseconds
-        poll_interval = int(1000*self._poll_interval)
+    poll_interval = int(1000*kernel._poll_interval)
 
         # We have to put the wx.Timer in a wx.Frame for it to fire properly.
         # We make the Frame hidden when we create it in the main app below.
@@ -551,20 +562,17 b' class WxKernel(Kernel):'
 
         # The redirect=False here makes sure that wx doesn't replace
         # sys.stdout/stderr with its own classes.
-        self.app = IPWxApp(redirect=False)
-        start_event_loop_wx(self.app)
-
+    kernel.app = IPWxApp(redirect=False)
+    start_event_loop_wx(kernel.app)
 
-class TkKernel(Kernel):
-    """A Kernel subclass with Tk support."""
 
-    def start(self):
-        """Start a Tk enabled event loop."""
+def loop_tk(kernel):
+    """Start a kernel with the Tk event loop."""
 
         import Tkinter
-        doi = self.do_one_iteration
+    doi = kernel.do_one_iteration
         # Tk uses milliseconds
-        poll_interval = int(1000*self._poll_interval)
+    poll_interval = int(1000*kernel._poll_interval)
         # For Tkinter, we create a Tk object and call its withdraw method.
         class Timer(object):
             def __init__(self, func):
@@ -580,43 +588,37 b' class TkKernel(Kernel):'
                 self.on_timer()  # Call it once to get things going.
                 self.app.mainloop()
 
-        self.timer = Timer(doi)
-        self.timer.start()
-
+    kernel.timer = Timer(doi)
+    kernel.timer.start()
 
-class GTKKernel(Kernel):
-    """A Kernel subclass with GTK support."""
 
-    def start(self):
+def loop_gtk(kernel):
         """Start the kernel, coordinating with the GTK event loop"""
         from .gui.gtkembed import GTKEmbed
 
-        gtk_kernel = GTKEmbed(self)
+    gtk_kernel = GTKEmbed(kernel)
         gtk_kernel.start()
 
 
-class OSXKernel(TkKernel):
-    """A Kernel subclass with Cocoa support via the matplotlib OSX backend."""
-    
-    def start(self):
+def loop_cocoa(kernel):
         """Start the kernel, coordinating with the Cocoa CFRunLoop event loop
         via the matplotlib MacOSX backend.
         """
         import matplotlib
         if matplotlib.__version__ < '1.1.0':
-            self.log.warn(
+        kernel.log.warn(
             "MacOSX backend in matplotlib %s doesn't have a Timer, "
             "falling back on Tk for CFRunLoop integration.  Note that "
             "even this won't work if Tk is linked against X11 instead of "
             "Cocoa (e.g. EPD).  To use the MacOSX backend in the kernel, "
             "you must use matplotlib >= 1.1.0, or a native libtk."
             )
-            return TkKernel.start(self)
+        return loop_tk(kernel)
         
         from matplotlib.backends.backend_macosx import TimerMac, show
         
         # scale interval for sec->ms
-        poll_interval = int(1000*self._poll_interval)
+    poll_interval = int(1000*kernel._poll_interval)
         
         real_excepthook = sys.excepthook
         def handle_int(etype, value, tb):
@@ -630,7 +632,7 b' class OSXKernel(TkKernel):'
         def doi():
             # restore excepthook during IPython code
             sys.excepthook = real_excepthook
-            self.do_one_iteration()
+        kernel.do_one_iteration()
             # and back:
             sys.excepthook = handle_int
         
@@ -641,7 +643,7 b' class OSXKernel(TkKernel):'
         # but still need a Poller for when there are no active windows,
         # during which time mainloop() returns immediately
         poller = zmq.Poller()
-        poller.register(self.shell_socket, zmq.POLLIN)
+    poller.register(kernel.shell_socket, zmq.POLLIN)
         
         while True:
             try:
@@ -655,7 +657,7 b' class OSXKernel(TkKernel):'
                     # use poller if mainloop returned (no windows)
                     # scale by extra factor of 10, since it's a real poll
                     poller.poll(10*poll_interval)
-                    self.do_one_iteration()
+                kernel.do_one_iteration()
                 except:
                     raise
             except KeyboardInterrupt:
@@ -665,6 +667,28 b' class OSXKernel(TkKernel):'
                 # ensure excepthook is restored
                 sys.excepthook = real_excepthook
 
+# mapping of keys to loop functions
+loop_map = {
+    'qt' : loop_qt4,
+    'qt4': loop_qt4,
+    'inline': None,
+    'osx': loop_cocoa,
+    'wx' : loop_wx,
+    'tk' : loop_tk,
+    'gtk': loop_gtk,
+}
+
+def enable_gui(gui, kernel=None):
+    """Enable integration with a give GUI"""
+    if kernel is None:
+        kernel = IPKernelApp.instance().kernel
+    if gui not in loop_map:
+        raise ValueError("GUI %r not supported" % gui)
+    loop = loop_map[gui]
+    if kernel.eventloop is not None and kernel.eventloop is not loop:
+        raise RuntimeError("Cannot activate multiple GUI eventloops")
+    kernel.eventloop = loop
+
 
 #-----------------------------------------------------------------------------
 # Aliases and Flags for the IPKernelApp
@@ -715,37 +739,21 b' class IPKernelApp(KernelApp, InteractiveShellApp):'
     def init_kernel(self):
         kernel_factory = Kernel
 
-        kernel_map = {
-            'qt' : QtKernel,
-            'qt4': QtKernel,
-            'inline': Kernel,
-            'osx': OSXKernel,
-            'wx' : WxKernel,
-            'tk' : TkKernel,
-            'gtk': GTKKernel,
-        }
-
         if self.pylab:
             key = None if self.pylab == 'auto' else self.pylab
             gui, backend = pylabtools.find_gui_and_backend(key)
-            kernel_factory = kernel_map.get(gui)
-            if kernel_factory is None:
-                raise ValueError('GUI is not supported: %r' % gui)
-            pylabtools.activate_matplotlib(backend)
 
         kernel = kernel_factory(config=self.config, session=self.session,
                                 shell_socket=self.shell_socket,
                                 iopub_socket=self.iopub_socket,
                                 stdin_socket=self.stdin_socket,
-                                log=self.log
+                                log=self.log,
         )
         self.kernel = kernel
         kernel.record_ports(self.ports)
 
         if self.pylab:
-            import_all = self.pylab_import_all
-            pylabtools.import_pylab(kernel.shell.user_ns, backend, import_all,
-                                    shell=kernel.shell)
+            kernel.shell.enable_pylab(gui, import_all=self.pylab_import_all)
 
     def init_shell(self):
         self.shell = self.kernel.shell

IPython/zmq/zmqshell.py

@@ -31,6 +31,7 b' from IPython.core.displaypub import DisplayPublisher'
 from IPython.core.macro import Macro
 from IPython.core.magic import MacroToEdit
 from IPython.core.payloadpage import install_payload_page
+from IPython.lib import pylabtools
 from IPython.lib.kernel import (
     get_connection_file, get_connection_info, connect_qtconsole
 )
@@ -389,13 +390,65 b' class ZMQInteractiveShell(InteractiveShell):'
         }
         self.payload_manager.write_payload(payload)
 
-    def magic_gui(self, *args, **kwargs):
-        raise NotImplementedError(
-            'Kernel GUI support is not implemented yet, except for --pylab.')
+    def magic_gui(self, parameter_s=''):
+        """Enable or disable IPython GUI event loop integration.
+
+        %gui [GUINAME]
+
+        This magic replaces IPython's threaded shells that were activated
+        using the (pylab/wthread/etc.) command line flags.  GUI toolkits
+        can now be enabled at runtime and keyboard
+        interrupts should work without any problems.  The following toolkits
+        are supported:  wxPython, PyQt4, PyGTK, Cocoa, and Tk::
+
+            %gui wx      # enable wxPython event loop integration
+            %gui qt4|qt  # enable PyQt4 event loop integration
+            %gui gtk     # enable PyGTK event loop integration
+            %gui OSX     # enable Cocoa event loop integration (requires matplotlib 1.1)
+            %gui tk      # enable Tk event loop integration
+
+        WARNING:  after any of these has been called you can simply create
+        an application object, but DO NOT start the event loop yourself, as
+        we have already handled that.
+        """
+        from IPython.zmq.ipkernel import enable_gui
+        opts, arg = self.parse_options(parameter_s, '')
+        if arg=='': arg = None
+        return enable_gui(arg)
+
+    def enable_pylab(self, gui=None, import_all=True):
+        """Activate pylab support at runtime.
+
+        This turns on support for matplotlib, preloads into the interactive
+        namespace all of numpy and pylab, and configures IPython to correcdtly
+        interact with the GUI event loop.  The GUI backend to be used can be
+        optionally selected with the optional :param:`gui` argument.
+
+        Parameters
+        ----------
+        gui : optional, string [default: inline]
+
+          If given, dictates the choice of matplotlib GUI backend to use
+          (should be one of IPython's supported backends, 'inline', 'qt', 'osx',
+          'tk', or 'gtk'), otherwise we use the default chosen by matplotlib
+          (as dictated by the matplotlib build-time options plus the user's
+          matplotlibrc configuration file).
+        """
+        from IPython.zmq.ipkernel import enable_gui
+        # We want to prevent the loading of pylab to pollute the user's
+        # namespace as shown by the %who* magics, so we execute the activation
+        # code in an empty namespace, and we update *both* user_ns and
+        # user_ns_hidden with this information.
+        ns = {}
+        # override default to inline, from auto-detect
+        gui = pylabtools.pylab_activate(ns, gui or 'inline', import_all, self)
+        self.user_ns.update(ns)
+        self.user_ns_hidden.update(ns)
+        # Now we must activate the gui pylab wants to use, and fix %run to take
+        # plot updates into account
+        enable_gui(gui)
+        self.magic_run = self._pylab_magic_run
 
-    def magic_pylab(self, *args, **kwargs):
-        raise NotImplementedError(
-            'pylab support must be enabled in command line options.')
 
     # A few magics that are adapted to the specifics of using pexpect and a
     # remote terminal