Minor work on the GUI support in the kernel.

IPython/lib/guisupport.py

@@ -1,140 +1,143 b''
 #!/usr/bin/env python
 # coding: utf-8
 """
 Support for creating GUI apps and starting event loops.
 
 IPython's GUI integration allows interative plotting and GUI usage in IPython
 session. IPython has two different types of GUI integration:
 
 1. The terminal based IPython supports GUI event loops through Python's
    PyOS_InputHook. PyOS_InputHook is a hook that Python calls periodically
    whenever raw_input is waiting for a user to type code. We implement GUI
    support in the terminal by setting PyOS_InputHook to a function that 
    iterates the event loop for a short while. It is important to note that
    in this situation, the real GUI event loop is NOT run in the normal
    manner, so you can't use the normal means to detect that it is running.
 2. In the two process IPython kernel/frontend, the GUI event loop is run in 
    the kernel. In this case, the event loop is run in the normal manner by
    calling the function or method of the GUI toolkit that starts the event
    loop.
 
 In addition to starting the GUI event loops in one of these two ways, IPython
 will *always* create an appropriate GUI application object when GUi
 integration is enabled.
 
 If you want your GUI apps to run in IPython you need to do two things:
 
 1. Test to see if there is already an existing main application object. If
    there is, you should use it. If there is not an existing application object
    you should create one.
 2. Test to see if the GUI event loop is running. If it is, you should not
    start it. If the event loop is not running you may start it.
 
 This module contains functions for each toolkit that perform these things
 in a consistent manner. Because of how PyOS_InputHook runs the event loop
 you cannot detect if the event loop is running using the traditional calls
 (such as ``wx.GetApp.IsMainLoopRunning()`` in wxPython). If PyOS_InputHook is
 set These methods will return a false negative. That is, they will say the
 event loop is not running, when is actually is. To work around this limitation
 we proposed the following informal protocol:
 
 * Whenever someone starts the event loop, they *must* set the ``_in_event_loop``
   attribute of the main application object to ``True``. This should be done
   regardless of how the event loop is actually run.
 * Whenever someone stops the event loop, they *must* set the ``_in_event_loop``
   attribute of the main application object to ``False``.
 * If you want to see if the event loop is running, you *must* use ``hasattr``
   to see if ``_in_event_loop`` attribute has been set. If it is set, you
   *must* use its value. If it has not been set, you can query the toolkit
   in the normal manner.
+* If you want GUI support and no one else has created an application or
+  started the event loop you *must* do this. We don't want projects to 
+  attempt to defer these things to someone else if they themselves need it.
 
 The functions below implement this logic for each GUI toolkit. If you need
 to create custom application subclasses, you will likely have to modify this
 code for your own purposes. This code can be copied into your own project
 so you don't have to depend on IPython.
 
 """
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2008-2010  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
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # wx
 #-----------------------------------------------------------------------------
 
 def get_app_wx(*args, **kwargs):
     """Create a new wx app or return an exiting one."""
     import wx
     app = wx.GetApp()
     if app is None:
         app = wx.PySimpleApp(*args, **kwargs)
     return app
 
 def is_event_loop_running_wx(app=None):
     """Is the wx event loop running."""
     if app is None:
         app = get_app_wx()
     if hasattr(app, '_in_event_loop'):
         return app._in_event_loop
     else:
         return app.IsMainLoopRunning()
 
 def start_event_loop_wx(app=None):
     """Start the wx event loop in a consistent manner."""
     if app is None:
         app = get_app_wx()
     if not is_event_loop_running_wx(app):
         app._in_event_loop = True
         app.MainLoop()
         app._in_event_loop = False
     else:
         app._in_event_loop = True
 
 #-----------------------------------------------------------------------------
 # qt4
 #-----------------------------------------------------------------------------
 
 def get_app_qt4(*args, **kwargs):
     """Create a new qt4 app or return an existing one."""
     from PyQt4 import QtGui
     app = QtGui.QApplication.instance()
     if app is None:
         app = QtGui.QApplication(*args, **kwargs)
     return app
 
 def is_event_loop_running_qt4(app=None):
     """Is the qt4 event loop running."""
     if app is None:
         app = get_app_qt4()
     if hasattr(app, '_in_event_loop'):
         return app._in_event_loop
     else:
         # Does qt4 provide a other way to detect this?
         return False
 
 def start_event_loop_qt4(app=None):
     """Start the qt4 event loop in a consistent manner."""
     if app is None:
         app = get_app_qt4()
     if not is_event_loop_running_qt4(app):
         app._in_event_loop = True
         app.exec_()
         app._in_event_loop = False
     else:
         app._in_event_loop = True
 
 #-----------------------------------------------------------------------------
 # Tk
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # gtk
 #-----------------------------------------------------------------------------

IPython/zmq/ipkernel.py

@@ -1,456 +1,459 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
 #-----------------------------------------------------------------------------
 from __future__ import print_function
 
 # Standard library imports.
 import __builtin__
 import sys
 import time
 import traceback
 
 # System library imports.
 import zmq
 
 # Local imports.
 from IPython.config.configurable import Configurable
 from IPython.utils import io
 from IPython.lib import pylabtools
 from IPython.utils.traitlets import Instance
 from entry_point import base_launch_kernel, make_argument_parser, make_kernel, \
     start_kernel
 from iostream import OutStream
 from session import Session, Message
 from zmqshell import ZMQInteractiveShell
 
 #-----------------------------------------------------------------------------
 # Main kernel class
 #-----------------------------------------------------------------------------
 
 class Kernel(Configurable):
 
     #---------------------------------------------------------------------------
     # Kernel interface
     #---------------------------------------------------------------------------
 
     shell = Instance('IPython.core.interactiveshell.InteractiveShellABC')
     session = Instance(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
 
         # TMP - hack while developing
         self.shell._reply_content = None
 
         # Build dict of handlers for message types
         msg_types = [ 'execute_request', 'complete_request', 
                       'object_info_request', 'prompt_request',
                       'history_request' ]
         self.handlers = {}
         for msg_type in msg_types:
             self.handlers[msg_type] = getattr(self, msg_type)
 
     def do_one_iteration(self):
         try:
             ident = self.reply_socket.recv(zmq.NOBLOCK)
         except zmq.ZMQError, e:
             if e.errno == zmq.EAGAIN:
                 return
             else:
                 raise
         # FIXME: Bug in pyzmq/zmq?
         # assert self.reply_socket.rcvmore(), "Missing message part."
         msg = self.reply_socket.recv_json()
         omsg = Message(msg)
         io.raw_print('\n')
         io.raw_print(omsg)
         handler = self.handlers.get(omsg.msg_type, None)
         if handler is None:
             io.raw_print_err("UNKNOWN MESSAGE TYPE:", omsg)
         else:
             handler(ident, omsg)
 
     def start(self):
         """ Start the kernel main loop.
         """
         while True:
             time.sleep(0.05)
             self.do_one_iteration()
 
 
     #---------------------------------------------------------------------------
     # Kernel request handlers
     #---------------------------------------------------------------------------
 
     def execute_request(self, ident, parent):
         try:
             code = parent[u'content'][u'code']
         except:
             io.raw_print_err("Got bad msg: ")
             io.raw_print_err(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 and out streams.
             self.shell.displayhook.set_parent(parent)
             sys.stdout.set_parent(parent)
             sys.stderr.set_parent(parent)
 
             # FIXME: runlines calls the exception handler itself.  We should
             # clean this up.
             self.shell._reply_content = None
             self.shell.runlines(code)
         except:
             # FIXME: this code right now isn't being used yet by default,
             # because the runlines() call above directly fires off exception
             # reporting.  This code, therefore, is only active in the scenario
             # where runlines itself has an unhandled exception.  We need to
             # uniformize this, for all exception construction to come from a
             # single location in the codbase.
             etype, evalue, tb = sys.exc_info()
             tb_list = traceback.format_exception(etype, evalue, tb)
             reply_content = self.shell._showtraceback(etype, evalue, tb_list)
         else:
             payload = self.shell.payload_manager.read_payload()
             # Be agressive about clearing the payload because we don't want
             # it to sit in memory until the next execute_request comes in.
             self.shell.payload_manager.clear_payload()
             reply_content = { 'status' : 'ok', 'payload' : payload }
 
         # 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,
                        'input_sep'     : self.shell.displayhook.input_sep}
         reply_content['next_prompt'] = next_prompt
 
         # TMP - fish exception info out of shell, possibly left there by
         # runlines
         if self.shell._reply_content is not None:
             reply_content.update(self.shell._reply_content)
 
         # 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)
         io.raw_print(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 complete_request(self, ident, parent):
         txt, matches = self._complete(parent)
         matches = {'matches' : matches,
                    'matched_text' : txt,
                    'status' : 'ok'}
         completion_msg = self.session.send(self.reply_socket, 'complete_reply',
                                            matches, parent, ident)
         io.raw_print(completion_msg)
 
     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)
         io.raw_print(msg)
 
     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,
                    'input_sep'     : self.shell.displayhook.input_sep}
         msg = self.session.send(self.reply_socket, 'prompt_reply',
                                 content, parent, ident)
         io.raw_print(msg)
 
     def history_request(self, ident, parent):
         output = parent['content']['output']
         index = parent['content']['index']
         raw = parent['content']['raw']
         hist = self.shell.get_history(index=index, raw=raw, output=output)
         content = {'history' : hist}
         msg = self.session.send(self.reply_socket, 'history_reply',
                                 content, parent, ident)
         io.raw_print(msg)
         
     #---------------------------------------------------------------------------
     # Protected interface
     #---------------------------------------------------------------------------
 
     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()
             io.raw_print("Aborting:\n", Message(msg))
             msg_type = msg['msg_type']
             reply_type = msg_type.split('_')[0] + '_reply'
             reply_msg = self.session.msg(reply_type, {'status' : 'aborted'}, msg)
             io.raw_print(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 _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:
             io.raw_print_err("Got bad raw_input reply: ")
             io.raw_print_err(Message(parent))
             value = ''
         return value
     
     def _complete(self, msg):
         c = msg['content']
         try:
             cpos = int(c['cursor_pos'])
         except:
             # If we don't get something that we can convert to an integer, at
             # least attempt the completion guessing the cursor is at the end of
             # the text, if there's any, and otherwise of the line
             cpos = len(c['text'])
             if cpos==0:
                 cpos = len(c['line'])
         return self.shell.complete(c['text'], c['line'], cpos)
 
     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, []
 
 
 class QtKernel(Kernel):
     """A Kernel subclass with Qt support."""
 
     def start(self):
         """Start a kernel with QtPy4 event loop integration."""
 
         from PyQt4 import QtGui, QtCore
-        self.app = QtGui.QApplication([])
+        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)
         self.timer.start(50)
-        self.app.exec_()
-
+        start_event_loop_qt4(self.app)
 
 class WxKernel(Kernel):
     """A Kernel subclass with Wx support."""
 
     def start(self):
         """Start a kernel with wx event loop support."""
 
         import wx
+        from IPython.lib.guisupport import start_event_loop_wx
         doi = self.do_one_iteration
 
         # 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.
         class TimerFrame(wx.Frame):
             def __init__(self, func):
                 wx.Frame.__init__(self, None, -1)
                 self.timer = wx.Timer(self)
                 self.timer.Start(50)
                 self.Bind(wx.EVT_TIMER, self.on_timer)
                 self.func = func
             def on_timer(self, event):
                 self.func()
 
         # We need a custom wx.App to create our Frame subclass that has the
         # wx.Timer to drive the ZMQ event loop.
         class IPWxApp(wx.App):
             def OnInit(self):
                 self.frame = TimerFrame(doi)
                 self.frame.Show(False)
                 return True
 
         # The redirect=False here makes sure that wx doesn't replace
         # sys.stdout/stderr with its own classes.
         self.app = IPWxApp(redirect=False)
-        self.app.MainLoop()
+        start_event_loop_wx(self.app)
 
 
 class TkKernel(Kernel):
     """A Kernel subclass with Tk support."""
 
     def start(self):
         """Start a Tk enabled event loop."""
 
         import Tkinter
         doi = self.do_one_iteration
 
         # For Tkinter, we create a Tk object and call its withdraw method.
         class Timer(object):
             def __init__(self, func):
                 self.app = Tkinter.Tk()
                 self.app.withdraw()
                 self.func = func
             def on_timer(self):
                 self.func()
                 self.app.after(50, self.on_timer)
             def start(self):
                 self.on_timer()  # Call it once to get things going.
                 self.app.mainloop()
 
         self.timer = Timer(doi)
         self.timer.start()
 
 #-----------------------------------------------------------------------------
 # Kernel main and launch functions
 #-----------------------------------------------------------------------------
 
 def launch_kernel(xrep_port=0, pub_port=0, req_port=0, independent=False,
                   pylab=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.
 
     pylab : bool or string, optional (default False)
         If not False, the kernel will be launched with pylab enabled. If a
         string is passed, matplotlib will use the specified backend. Otherwise,
         matplotlib's default backend will be used.
 
     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.
     """
     extra_arguments = []
     if pylab:
         extra_arguments.append('--pylab')
         if isinstance(pylab, basestring):
             extra_arguments.append(pylab)
     return base_launch_kernel('from IPython.zmq.ipkernel import main; main()',
                               xrep_port, pub_port, req_port, independent, 
                               extra_arguments)
 
 def main():
     """ The IPython kernel main entry point.
     """
     parser = make_argument_parser()
     parser.add_argument('--pylab', type=str, metavar='GUI', nargs='?', 
                         const='auto', help = \
 "Pre-load matplotlib and numpy for interactive use. If GUI is not \
 given, the GUI backend is matplotlib's, otherwise use one of: \
 ['tk', 'gtk', 'qt', 'wx', 'payload-svg'].")
     namespace = parser.parse_args()
 
     kernel_class = Kernel
 
     _kernel_classes = {
         'qt' : QtKernel,
         'qt4' : QtKernel,
         'payload-svg':Kernel,
         'wx' : WxKernel,
         'tk' : TkKernel
     }
     if namespace.pylab:
         if namespace.pylab == 'auto':
             gui, backend = pylabtools.find_gui_and_backend()
         else:
             gui, backend = pylabtools.find_gui_and_backend(namespace.pylab)
         kernel_class = _kernel_classes.get(gui)
         if kernel_class is None:
             raise ValueError('GUI is not supported: %r' % gui)
         pylabtools.activate_matplotlib(backend)
 
     kernel = make_kernel(namespace, kernel_class, OutStream)
 
     if namespace.pylab:
         pylabtools.import_pylab(kernel.shell.user_ns)
 
     start_kernel(namespace, kernel)
 
 if __name__ == '__main__':
     main()