Simplify HBChannel inheritance

IPython/kernel/blocking/channels.py

@@ -11,11 +11,6 b' try:'
 except ImportError:
     from Queue import Queue, Empty  # Py 2
 
-from IPython.kernel.channelsabc import ShellChannelABC, IOPubChannelABC, \
-    StdInChannelABC
-from IPython.kernel.channels import  HBChannel,\
-    make_iopub_socket, make_shell_socket, make_stdin_socket,\
-    InvalidPortNumber, major_protocol_version
 from IPython.utils.py3compat import string_types, iteritems
 
 # some utilities to validate message structure, these might get moved elsewhere
@@ -121,15 +116,3 b' class ZMQSocketChannel(object):'
     def start(self):
         pass
 
-
-
-class BlockingHBChannel(HBChannel):
-
-    # This kernel needs quicker monitoring, shorten to 1 sec.
-    # less than 0.5s is unreliable, and will get occasional
-    # false reports of missed beats.
-    time_to_dead = 1.
-
-    def call_handlers(self, since_last_heartbeat):
-        """ Pause beating on missed heartbeat. """
-        pass

IPython/kernel/blocking/client.py

@@ -11,8 +11,9 b' except ImportError:'
     from Queue import Empty  # Python 2
 
 from IPython.utils.traitlets import Type
+from IPython.kernel.channels import HBChannel
 from IPython.kernel.client import KernelClient
-from .channels import ZMQSocketChannel, BlockingHBChannel
+from .channels import ZMQSocketChannel
 
 class BlockingKernelClient(KernelClient):
     def wait_for_ready(self):
@@ -35,4 +36,4 b' class BlockingKernelClient(KernelClient):'
     shell_channel_class = Type(ZMQSocketChannel)
     iopub_channel_class = Type(ZMQSocketChannel)
     stdin_channel_class = Type(ZMQSocketChannel)
-    hb_channel_class = Type(BlockingHBChannel)
+    hb_channel_class = Type(HBChannel)

IPython/kernel/channels.py

@@ -210,7 +210,7 b' class HBChannel(ZMQSocketChannel):'
     as appropriate.
     """
 
-    time_to_dead = 3.0
+    time_to_dead = 1.
     socket = None
     poller = None
     _running = None
@@ -332,7 +332,7 b' class HBChannel(ZMQSocketChannel):'
         so that some logic must be done to ensure that the application level
         handlers are called in the application thread.
         """
-        raise NotImplementedError('call_handlers must be defined in a subclass.')
+        pass
 
 
 HBChannelABC.register(HBChannel)

IPython/kernel/inprocess/channels.py

@@ -62,15 +62,26 b' class InProcessChannel(object):'
 
 
 
-class InProcessHBChannel(InProcessChannel):
+class InProcessHBChannel(object):
     """See `IPython.kernel.channels.HBChannel` for docstrings."""
 
     time_to_dead = 3.0
 
-    def __init__(self, *args, **kwds):
-        super(InProcessHBChannel, self).__init__(*args, **kwds)
+    def __init__(self, client=None):
+        super(InProcessHBChannel, self).__init__()
+        self.client = client
+        self._is_alive = False
         self._pause = True
 
+    def is_alive(self):
+        return self._is_alive
+
+    def start(self):
+        self._is_alive = True
+
+    def stop(self):
+        self._is_alive = False
+
     def pause(self):
         self._pause = True
 

IPython/qt/client.py

@@ -19,11 +19,21 b' from IPython.kernel.channels import HBChannel,\\'
     make_shell_socket, make_iopub_socket, make_stdin_socket
 from IPython.kernel import KernelClient
 
-from .kernel_mixins import (QtHBChannelMixin, QtKernelClientMixin)
+from .kernel_mixins import QtKernelClientMixin
 from .util import SuperQObject
 
-class QtHBChannel(QtHBChannelMixin, HBChannel):
-    pass
+class QtHBChannel(SuperQObject, HBChannel):
+    # A longer timeout than the base class
+    time_to_dead = 3.0
+
+    # Emitted when the kernel has died.
+    kernel_died = QtCore.Signal(object)
+
+    def call_handlers(self, since_last_heartbeat):
+        """ Reimplemented to emit signals instead of making callbacks.
+        """
+        # Emit the generic signal.
+        self.kernel_died.emit(since_last_heartbeat)
 
 from IPython.core.release import kernel_protocol_version_info
 

IPython/qt/inprocess.py

@@ -10,16 +10,13 b' from IPython.kernel.inprocess.channels import InProcessChannel'
 
 from IPython.utils.traitlets import Type
 from .kernel_mixins import ( ChannelQObject,
-    QtHBChannelMixin, QtKernelClientMixin,
+    QtKernelClientMixin,
     QtKernelManagerMixin,
 )
 
 class QtInProcessChannel(ChannelQObject, InProcessChannel):
     pass
 
-class QtInProcessHBChannel(QtHBChannelMixin, InProcessHBChannel):
-    pass
-
 class QtInProcessKernelClient(QtKernelClientMixin, InProcessKernelClient):
     """ An in-process KernelManager with signals and slots.
     """
@@ -27,7 +24,7 b' class QtInProcessKernelClient(QtKernelClientMixin, InProcessKernelClient):'
     iopub_channel_class = Type(QtInProcessChannel)
     shell_channel_class = Type(QtInProcessChannel)
     stdin_channel_class = Type(QtInProcessChannel)
-    hb_channel_class = Type(QtInProcessHBChannel)
+    hb_channel_class = Type(InProcessHBChannel)
 
 class QtInProcessKernelManager(QtKernelManagerMixin, InProcessKernelManager):
     client_class = __module__ + '.QtInProcessKernelClient'

IPython/qt/kernel_mixins.py

@@ -53,17 +53,6 b' class ChannelQObject(SuperQObject):'
         self.process_events()
 
 
-class QtHBChannelMixin(ChannelQObject):
-
-    # Emitted when the kernel has died.
-    kernel_died = QtCore.Signal(object)
-
-    def call_handlers(self, since_last_heartbeat):
-        """ Reimplemented to emit signals instead of making callbacks.
-        """
-        self.kernel_died.emit(since_last_heartbeat)
-
-
 class QtKernelRestarterMixin(MetaQObjectHasTraits('NewBase', (HasTraits, SuperQObject), {})):
 
     _timer = None