use QSocketNotifier, not poll

avoids having to disable App Nap outright.

Also use appnope context manager to disable App Nap on OS X 10.9 while processing events.

Adds IPKernel._darwin_app_nap flag, so that working with App Nap can be disabled, in case appnope causes problems for some.

App Nap is just disabled outright on wx.

IPython/kernel/zmq/eventloops.py

@@ -16,10 +16,10 b''
 
 import sys
 
-# System library imports.
+# System library imports
 import zmq
 
-# Local imports.
+# Local imports
 from IPython.config.application import Application
 from IPython.utils import io
 
@@ -28,18 +28,40 b' from IPython.utils import io'
 # Eventloops for integrating the Kernel into different GUIs
 #------------------------------------------------------------------------------
 
+def _on_os_x_10_9():
+    import platform
+    from distutils.version import LooseVersion as V
+    return sys.platform == 'darwin' and V(platform.mac_ver()[0]) >= V('10.9')
+
+def _notify_stream_qt(kernel, stream):
+    
+    from IPython.external.qt_for_kernel import QtCore
+    
+    if _on_os_x_10_9() and kernel._darwin_app_nap:
+        from IPython.external.appnope import nope_scope as context
+    else:
+        from IPython.core.interactiveshell import no_op_context as context
+        
+    def process_stream_events():
+        while stream.getsockopt(zmq.EVENTS) & zmq.POLLIN:
+            with context():
+                kernel.do_one_iteration()
+    
+    fd = stream.getsockopt(zmq.FD)
+    notifier = QtCore.QSocketNotifier(fd, QtCore.QSocketNotifier.Read, kernel.app)
+    notifier.activated.connect(process_stream_events)
+
 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
 
     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
-    kernel.timer.start(1000*kernel._poll_interval)
+    
+    for s in kernel.shell_streams:
+        _notify_stream_qt(kernel, s)
+    
     start_event_loop_qt4(kernel.app)
 
 
@@ -49,6 +71,12 b' def loop_wx(kernel):'
     import wx
     from IPython.lib.guisupport import start_event_loop_wx
 
+    if _on_os_x_10_9() and kernel._darwin_app_nap:
+        # we don't hook up App Nap contexts for Wx,
+        # just disable it outright.
+        from IPython.external.appnope import nope
+        nope()
+
     doi = kernel.do_one_iteration
      # Wx uses milliseconds
     poll_interval = int(1000*kernel._poll_interval)

IPython/kernel/zmq/ipkernel.py

@@ -32,7 +32,7 b' from IPython.utils.py3compat import builtin_mod, unicode_type, string_types'
 from IPython.utils.jsonutil import json_clean
 from IPython.utils.traitlets import (
     Any, Instance, Float, Dict, List, Set, Integer, Unicode,
-    Type
+    Type, Bool,
 )
 
 from .serialize import serialize_object, unpack_apply_message
@@ -91,9 +91,15 b' class Kernel(Configurable):'
     def _ident_default(self):
         return unicode_type(uuid.uuid4())
 
-
     # Private interface
     
+    _darwin_app_nap = Bool(True, config=True,
+        help="""Whether to use appnope for compatiblity with OS X App Nap.
+        
+        Only affects OS X >= 10.9.
+        """
+    )
+
     # Time to sleep after flushing the stdout/err buffers in each execute
     # cycle.  While this introduces a hard limit on the minimal latency of the
     # execute cycle, it helps prevent output synchronization problems for

IPython/kernel/zmq/kernelapp.py

@@ -425,12 +425,6 b' class IPKernelApp(BaseIPythonApplication, InteractiveShellApp):'
         self.shell = self.kernel.shell
         self.shell.configurables.append(self)
     
-    def init_osx(self):
-        if sys.platform != 'darwin':
-            return
-        from IPython.utils.darwin import disable_app_nap
-        self._activity = disable_app_nap(self.log.warn)
-    
     @catch_config_error
     def initialize(self, argv=None):
         super(IPKernelApp, self).initialize(argv)
@@ -445,7 +439,6 b' class IPKernelApp(BaseIPythonApplication, InteractiveShellApp):'
         self.write_connection_file()
         self.init_io()
         self.init_signal()
-        self.init_osx()
         self.init_kernel()
         # shell init steps
         self.init_path()