Simplify HBChannel inheritance

IPython/kernel/blocking/channels.py

@@ -1,135 +1,118 b''
 """Blocking channels
 
 Useful for test suites and blocking terminal interfaces.
 """
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 try:
     from queue import Queue, Empty  # Py 3
 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
 # if they prove to have more generic utility
 
 def validate_string_list(lst):
     """Validate that the input is a list of strings.
 
     Raises ValueError if not."""
     if not isinstance(lst, list):
         raise ValueError('input %r must be a list' % lst)
     for x in lst:
         if not isinstance(x, string_types):
             raise ValueError('element %r in list must be a string' % x)
 
 
 def validate_string_dict(dct):
     """Validate that the input is a dict with string keys and values.
 
     Raises ValueError if not."""
     for k,v in iteritems(dct):
         if not isinstance(k, string_types):
             raise ValueError('key %r in dict must be a string' % k)
         if not isinstance(v, string_types):
             raise ValueError('value %r in dict must be a string' % v)
 
 
 class ZMQSocketChannel(object):
     """A ZMQ socket in a simple blocking API"""
     session = None
     socket = None
     stream = None
     _exiting = False
     proxy_methods = []
 
     def __init__(self, socket, session, loop=None):
         """Create a channel.
 
         Parameters
         ----------
         socket : :class:`zmq.Socket`
             The ZMQ socket to use.
         session : :class:`session.Session`
             The session to use.
         loop
             Unused here, for other implementations
         """
         super(ZMQSocketChannel, self).__init__()
 
         self.socket = socket
         self.session = session
 
     def _recv(self, **kwargs):
         msg = self.socket.recv_multipart(**kwargs)
         ident,smsg = self.session.feed_identities(msg)
         return self.session.deserialize(smsg)
 
     def get_msg(self, block=True, timeout=None):
         """ Gets a message if there is one that is ready. """
         if block:
             if timeout is not None:
                 timeout *= 1000  # seconds to ms
             ready = self.socket.poll(timeout)
         else:
             ready = self.socket.poll(timeout=0)
 
         if ready:
             return self._recv()
         else:
             raise Empty
 
     def get_msgs(self):
         """ Get all messages that are currently ready. """
         msgs = []
         while True:
             try:
                 msgs.append(self.get_msg(block=False))
             except Empty:
                 break
         return msgs
 
     def msg_ready(self):
         """ Is there a message that has been received? """
         return bool(self.socket.poll(timeout=0))
 
     def close(self):
         if self.socket is not None:
             try:
                 self.socket.close(linger=0)
             except Exception:
                 pass
             self.socket = None
     stop =  close
 
     def is_alive(self):
         return (self.socket is not None)
 
     def _queue_send(self, msg):
         """Pass a message to the ZMQ socket to send
         """
         self.session.send(self.socket, msg)
 
     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

@@ -1,38 +1,39 b''
 """Implements a fully blocking kernel client.
 
 Useful for test suites and blocking terminal interfaces.
 """
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 try:
     from queue import Empty  # Python 3
 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):
         # Wait for kernel info reply on shell channel
         while True:
             msg = self.shell_channel.get_msg(block=True)
             if msg['msg_type'] == 'kernel_info_reply':
                 self._handle_kernel_info_reply(msg)
                 break
 
         # Flush IOPub channel
         while True:
             try:
                 msg = self.iopub_channel.get_msg(block=True, timeout=0.2)
                 print(msg['msg_type'])
             except Empty:
                 break
 
     # The classes to use for the various channels
     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

@@ -1,338 +1,338 b''
 """Base classes to manage a Client's interaction with a running kernel"""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from __future__ import absolute_import
 
 import atexit
 import errno
 from threading import Thread
 import time
 
 import zmq
 # import ZMQError in top-level namespace, to avoid ugly attribute-error messages
 # during garbage collection of threads at exit:
 from zmq import ZMQError
 from zmq.eventloop import ioloop, zmqstream
 
 from IPython.core.release import kernel_protocol_version_info
 
 from .channelsabc import (
     ShellChannelABC, IOPubChannelABC,
     HBChannelABC, StdInChannelABC,
 )
 from IPython.utils.py3compat import string_types, iteritems
 
 #-----------------------------------------------------------------------------
 # Constants and exceptions
 #-----------------------------------------------------------------------------
 
 major_protocol_version = kernel_protocol_version_info[0]
 
 class InvalidPortNumber(Exception):
     pass
 
 #-----------------------------------------------------------------------------
 # Utility functions
 #-----------------------------------------------------------------------------
 
 # some utilities to validate message structure, these might get moved elsewhere
 # if they prove to have more generic utility
 
 def validate_string_list(lst):
     """Validate that the input is a list of strings.
 
     Raises ValueError if not."""
     if not isinstance(lst, list):
         raise ValueError('input %r must be a list' % lst)
     for x in lst:
         if not isinstance(x, string_types):
             raise ValueError('element %r in list must be a string' % x)
 
 
 def validate_string_dict(dct):
     """Validate that the input is a dict with string keys and values.
 
     Raises ValueError if not."""
     for k,v in iteritems(dct):
         if not isinstance(k, string_types):
             raise ValueError('key %r in dict must be a string' % k)
         if not isinstance(v, string_types):
             raise ValueError('value %r in dict must be a string' % v)
 
 
 #-----------------------------------------------------------------------------
 # ZMQ Socket Channel classes
 #-----------------------------------------------------------------------------
 
 class ZMQSocketChannel(Thread):
     """The base class for the channels that use ZMQ sockets."""
     context = None
     session = None
     socket = None
     ioloop = None
     stream = None
     _address = None
     _exiting = False
     proxy_methods = []
 
     def __init__(self, context, session, address):
         """Create a channel.
 
         Parameters
         ----------
         context : :class:`zmq.Context`
             The ZMQ context to use.
         session : :class:`session.Session`
             The session to use.
         address : zmq url
             Standard (ip, port) tuple that the kernel is listening on.
         """
         super(ZMQSocketChannel, self).__init__()
         self.daemon = True
 
         self.context = context
         self.session = session
         if isinstance(address, tuple):
             if address[1] == 0:
                 message = 'The port number for a channel cannot be 0.'
                 raise InvalidPortNumber(message)
             address = "tcp://%s:%i" % address
         self._address = address
         atexit.register(self._notice_exit)
 
     def _notice_exit(self):
         self._exiting = True
 
     def _run_loop(self):
         """Run my loop, ignoring EINTR events in the poller"""
         while True:
             try:
                 self.ioloop.start()
             except ZMQError as e:
                 if e.errno == errno.EINTR:
                     continue
                 else:
                     raise
             except Exception:
                 if self._exiting:
                     break
                 else:
                     raise
             else:
                 break
 
     def stop(self):
         """Stop the channel's event loop and join its thread.
 
         This calls :meth:`~threading.Thread.join` and returns when the thread
         terminates. :class:`RuntimeError` will be raised if
         :meth:`~threading.Thread.start` is called again.
         """
         if self.ioloop is not None:
             self.ioloop.stop()
         self.join()
         self.close()
     
     def close(self):
         if self.ioloop is not None:
             try:
                 self.ioloop.close(all_fds=True)
             except Exception:
                 pass
         if self.socket is not None:
             try:
                 self.socket.close(linger=0)
             except Exception:
                 pass
             self.socket = None
 
     @property
     def address(self):
         """Get the channel's address as a zmq url string.
 
         These URLS have the form: 'tcp://127.0.0.1:5555'.
         """
         return self._address
 
     def _queue_send(self, msg):
         """Queue a message to be sent from the IOLoop's thread.
 
         Parameters
         ----------
         msg : message to send
 
         This is threadsafe, as it uses IOLoop.add_callback to give the loop's
         thread control of the action.
         """
         def thread_send():
             self.session.send(self.stream, msg)
         self.ioloop.add_callback(thread_send)
 
     def _handle_recv(self, msg):
         """Callback for stream.on_recv.
 
         Unpacks message, and calls handlers with it.
         """
         ident,smsg = self.session.feed_identities(msg)
         msg = self.session.deserialize(smsg)
         self.call_handlers(msg)
 
 
 def make_shell_socket(context, identity, address):
     socket = context.socket(zmq.DEALER)
     socket.linger = 1000
     socket.setsockopt(zmq.IDENTITY, identity)
     socket.connect(address)
     return socket
 
 def make_iopub_socket(context, identity, address):
     socket = context.socket(zmq.SUB)
     socket.linger = 1000
     socket.setsockopt(zmq.SUBSCRIBE,b'')
     socket.setsockopt(zmq.IDENTITY, identity)
     socket.connect(address)
     return socket
 
 def make_stdin_socket(context, identity, address):
     socket = context.socket(zmq.DEALER)
     socket.linger = 1000
     socket.setsockopt(zmq.IDENTITY, identity)
     socket.connect(address)
     return socket
 
 class HBChannel(ZMQSocketChannel):
     """The heartbeat channel which monitors the kernel heartbeat.
 
     Note that the heartbeat channel is paused by default. As long as you start
     this channel, the kernel manager will ensure that it is paused and un-paused
     as appropriate.
     """
 
-    time_to_dead = 3.0
+    time_to_dead = 1.
     socket = None
     poller = None
     _running = None
     _pause = None
     _beating = None
 
     def __init__(self, context, session, address):
         super(HBChannel, self).__init__(context, session, address)
         self._running = False
         self._pause =True
         self.poller = zmq.Poller()
 
     def _create_socket(self):
         if self.socket is not None:
             # close previous socket, before opening a new one
             self.poller.unregister(self.socket)
             self.socket.close()
         self.socket = self.context.socket(zmq.REQ)
         self.socket.linger = 1000
         self.socket.connect(self.address)
 
         self.poller.register(self.socket, zmq.POLLIN)
 
     def _poll(self, start_time):
         """poll for heartbeat replies until we reach self.time_to_dead.
 
         Ignores interrupts, and returns the result of poll(), which
         will be an empty list if no messages arrived before the timeout,
         or the event tuple if there is a message to receive.
         """
 
         until_dead = self.time_to_dead - (time.time() - start_time)
         # ensure poll at least once
         until_dead = max(until_dead, 1e-3)
         events = []
         while True:
             try:
                 events = self.poller.poll(1000 * until_dead)
             except ZMQError as e:
                 if e.errno == errno.EINTR:
                     # ignore interrupts during heartbeat
                     # this may never actually happen
                     until_dead = self.time_to_dead - (time.time() - start_time)
                     until_dead = max(until_dead, 1e-3)
                     pass
                 else:
                     raise
             except Exception:
                 if self._exiting:
                     break
                 else:
                     raise
             else:
                 break
         return events
 
     def run(self):
         """The thread's main activity.  Call start() instead."""
         self._create_socket()
         self._running = True
         self._beating = True
 
         while self._running:
             if self._pause:
                 # just sleep, and skip the rest of the loop
                 time.sleep(self.time_to_dead)
                 continue
 
             since_last_heartbeat = 0.0
             # io.rprint('Ping from HB channel') # dbg
             # no need to catch EFSM here, because the previous event was
             # either a recv or connect, which cannot be followed by EFSM
             self.socket.send(b'ping')
             request_time = time.time()
             ready = self._poll(request_time)
             if ready:
                 self._beating = True
                 # the poll above guarantees we have something to recv
                 self.socket.recv()
                 # sleep the remainder of the cycle
                 remainder = self.time_to_dead - (time.time() - request_time)
                 if remainder > 0:
                     time.sleep(remainder)
                 continue
             else:
                 # nothing was received within the time limit, signal heart failure
                 self._beating = False
                 since_last_heartbeat = time.time() - request_time
                 self.call_handlers(since_last_heartbeat)
                 # and close/reopen the socket, because the REQ/REP cycle has been broken
                 self._create_socket()
                 continue
 
     def pause(self):
         """Pause the heartbeat."""
         self._pause = True
 
     def unpause(self):
         """Unpause the heartbeat."""
         self._pause = False
 
     def is_beating(self):
         """Is the heartbeat running and responsive (and not paused)."""
         if self.is_alive() and not self._pause and self._beating:
             return True
         else:
             return False
 
     def stop(self):
         """Stop the channel's event loop and join its thread."""
         self._running = False
         super(HBChannel, self).stop()
 
     def call_handlers(self, since_last_heartbeat):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         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

@@ -1,84 +1,95 b''
 """A kernel client for in-process kernels."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from IPython.kernel.channelsabc import (
     ShellChannelABC, IOPubChannelABC,
     HBChannelABC, StdInChannelABC,
 )
 
 from .socket import DummySocket
 
 #-----------------------------------------------------------------------------
 # Channel classes
 #-----------------------------------------------------------------------------
 
 class InProcessChannel(object):
     """Base class for in-process channels."""
     proxy_methods = []
 
     def __init__(self, client=None):
         super(InProcessChannel, self).__init__()
         self.client = client
         self._is_alive = False
 
     def is_alive(self):
         return self._is_alive
 
     def start(self):
         self._is_alive = True
 
     def stop(self):
         self._is_alive = False
 
     def call_handlers(self, msg):
         """ This method is called in the main thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         """
         raise NotImplementedError('call_handlers must be defined in a subclass.')
 
     def flush(self, timeout=1.0):
         pass
 
 
     def call_handlers_later(self, *args, **kwds):
         """ Call the message handlers later.
 
         The default implementation just calls the handlers immediately, but this
         method exists so that GUI toolkits can defer calling the handlers until
         after the event loop has run, as expected by GUI frontends.
         """
         self.call_handlers(*args, **kwds)
 
     def process_events(self):
         """ Process any pending GUI events.
 
         This method will be never be called from a frontend without an event
         loop (e.g., a terminal frontend).
         """
         raise NotImplementedError
 
 
 
-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
 
     def unpause(self):
         self._pause = False
 
     def is_beating(self):
         return not self._pause
 
 
 HBChannelABC.register(InProcessHBChannel)

IPython/qt/client.py

@@ -1,270 +1,280 b''
 """ Defines a KernelClient that provides signals and slots.
 """
 import atexit
 import errno
 from threading import Thread
 import time
 
 import zmq
 # import ZMQError in top-level namespace, to avoid ugly attribute-error messages
 # during garbage collection of threads at exit:
 from zmq import ZMQError
 from zmq.eventloop import ioloop, zmqstream
 
 from IPython.external.qt import QtCore
 
 # Local imports
 from IPython.utils.traitlets import Type, Instance
 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
 
 from IPython.kernel.channelsabc import (
     ShellChannelABC, IOPubChannelABC, StdInChannelABC,
 )
 from IPython.utils.py3compat import string_types, iteritems
 
 major_protocol_version = kernel_protocol_version_info[0]
 
 class InvalidPortNumber(Exception):
     pass
 
 # some utilities to validate message structure, these might get moved elsewhere
 # if they prove to have more generic utility
 
 
 def validate_string_dict(dct):
     """Validate that the input is a dict with string keys and values.
 
     Raises ValueError if not."""
     for k,v in iteritems(dct):
         if not isinstance(k, string_types):
             raise ValueError('key %r in dict must be a string' % k)
         if not isinstance(v, string_types):
             raise ValueError('value %r in dict must be a string' % v)
 
 
 
 class QtZMQSocketChannel(SuperQObject):
     """A ZMQ socket emitting a Qt signal when a message is received."""
     session = None
     socket = None
     ioloop = None
     stream = None
 
     message_received = QtCore.Signal(object)
 
     #---------------------------------------------------------------------------
     # InProcessChannel interface
     #---------------------------------------------------------------------------
 
     def call_handlers_later(self, *args, **kwds):
         """ Call the message handlers later.
         """
         do_later = lambda: self.call_handlers(*args, **kwds)
         QtCore.QTimer.singleShot(0, do_later)
 
     def process_events(self):
         """ Process any pending GUI events.
         """
         QtCore.QCoreApplication.instance().processEvents()
 
     def __init__(self, socket, session, loop):
         """Create a channel.
 
         Parameters
         ----------
         socket : :class:`zmq.Socket`
             The ZMQ socket to use.
         session : :class:`session.Session`
             The session to use.
         loop
             A pyzmq ioloop to connect the socket to using a ZMQStream
         """
         super(QtZMQSocketChannel, self).__init__()
 
         self.socket = socket
         self.session = session
         self.ioloop = loop
 
         self.stream = zmqstream.ZMQStream(self.socket, self.ioloop)
         self.stream.on_recv(self._handle_recv)
 
     _is_alive = False
     def is_alive(self):
         return self._is_alive
 
     def start(self):
         self._is_alive = True
 
     def stop(self):
         self._is_alive = False
 
     def close(self):
         if self.socket is not None:
             try:
                 self.socket.close(linger=0)
             except Exception:
                 pass
             self.socket = None
 
     def _queue_send(self, msg):
         """Queue a message to be sent from the IOLoop's thread.
 
         Parameters
         ----------
         msg : message to send
 
         This is threadsafe, as it uses IOLoop.add_callback to give the loop's
         thread control of the action.
         """
         def thread_send():
             self.session.send(self.stream, msg)
         self.ioloop.add_callback(thread_send)
 
     def _handle_recv(self, msg):
         """Callback for stream.on_recv.
 
         Unpacks message, and calls handlers with it.
         """
         ident,smsg = self.session.feed_identities(msg)
         msg = self.session.deserialize(smsg)
         self.call_handlers(msg)
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
 
         Subclasses should override this method to handle incoming messages.
         It is important to remember that this method is called in the thread
         so that some logic must be done to ensure that the application level
         handlers are called in the application thread.
         """
         # Emit the generic signal.
         self.message_received.emit(msg)
 
     def flush(self, timeout=1.0):
         """Immediately processes all pending messages on this channel.
 
         This is only used for the IOPub channel.
 
         Callers should use this method to ensure that :meth:`call_handlers`
         has been called for all messages that have been received on the
         0MQ SUB socket of this channel.
 
         This method is thread safe.
 
         Parameters
         ----------
         timeout : float, optional
             The maximum amount of time to spend flushing, in seconds. The
             default is one second.
         """
         # We do the IOLoop callback process twice to ensure that the IOLoop
         # gets to perform at least one full poll.
         stop_time = time.time() + timeout
         for i in range(2):
             self._flushed = False
             self.ioloop.add_callback(self._flush)
             while not self._flushed and time.time() < stop_time:
                 time.sleep(0.01)
 
     def _flush(self):
         """Callback for :method:`self.flush`."""
         self.stream.flush()
         self._flushed = True
 
 
 class IOLoopThread(Thread):
     """Run a pyzmq ioloop in a thread to send and receive messages
     """
     def __init__(self, loop):
         super(IOLoopThread, self).__init__()
         self.daemon = True
         atexit.register(self._notice_exit)
         self.ioloop = loop or ioloop.IOLoop()
 
     def _notice_exit(self):
         self._exiting = True
 
     def run(self):
         """Run my loop, ignoring EINTR events in the poller"""
         while True:
             try:
                 self.ioloop.start()
             except ZMQError as e:
                 if e.errno == errno.EINTR:
                     continue
                 else:
                     raise
             except Exception:
                 if self._exiting:
                     break
                 else:
                     raise
             else:
                 break
 
     def stop(self):
         """Stop the channel's event loop and join its thread.
 
         This calls :meth:`~threading.Thread.join` and returns when the thread
         terminates. :class:`RuntimeError` will be raised if
         :meth:`~threading.Thread.start` is called again.
         """
         if self.ioloop is not None:
             self.ioloop.stop()
         self.join()
         self.close()
 
     def close(self):
         if self.ioloop is not None:
             try:
                 self.ioloop.close(all_fds=True)
             except Exception:
                 pass
 
 
 class QtKernelClient(QtKernelClientMixin, KernelClient):
     """ A KernelClient that provides signals and slots.
     """
 
     _ioloop = None
     @property
     def ioloop(self):
         if self._ioloop is None:
             self._ioloop = ioloop.IOLoop()
         return self._ioloop
 
     ioloop_thread = Instance(IOLoopThread)
 
     def start_channels(self, shell=True, iopub=True, stdin=True, hb=True):
         if shell:
             self.shell_channel.message_received.connect(self._check_kernel_info_reply)
 
         self.ioloop_thread = IOLoopThread(self.ioloop)
         self.ioloop_thread.start()
 
         super(QtKernelClient, self).start_channels(shell, iopub, stdin, hb)
 
     def _check_kernel_info_reply(self, msg):
         if msg['msg_type'] == 'kernel_info_reply':
             self._handle_kernel_info_reply(msg)
             self.shell_channel.message_received.disconnect(self._check_kernel_info_reply)
 
     def stop_channels(self):
         super(QtKernelClient, self).stop_channels()
         if self.ioloop_thread.is_alive():
             self.ioloop_thread.stop()
 
     iopub_channel_class = Type(QtZMQSocketChannel)
     shell_channel_class = Type(QtZMQSocketChannel)
     stdin_channel_class = Type(QtZMQSocketChannel)
     hb_channel_class = Type(QtHBChannel)

IPython/qt/inprocess.py

@@ -1,33 +1,30 b''
 """ Defines an in-process KernelManager with signals and slots.
 """
 
 # Local imports.
 from IPython.external.qt import QtCore
 from IPython.kernel.inprocess import (
     InProcessHBChannel, InProcessKernelClient, InProcessKernelManager,
 )
 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.
     """
 
     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

@@ -1,105 +1,94 b''
 """Defines a KernelManager that provides signals and slots."""
 
 # Copyright (c) IPython Development Team.
 # Distributed under the terms of the Modified BSD License.
 
 from IPython.external.qt import QtCore
 
 from IPython.utils.traitlets import HasTraits, Type
 from .util import MetaQObjectHasTraits, SuperQObject
 
 
 class ChannelQObject(SuperQObject):
 
     # Emitted when the channel is started.
     started = QtCore.Signal()
 
     # Emitted when the channel is stopped.
     stopped = QtCore.Signal()
 
     # Emitted when any message is received.
     message_received = QtCore.Signal(object)
 
     def start(self):
         """ Reimplemented to emit signal.
         """
         super(ChannelQObject, self).start()
         self.started.emit()
 
     def stop(self):
         """ Reimplemented to emit signal.
         """
         super(ChannelQObject, self).stop()
         self.stopped.emit()
 
     def call_handlers_later(self, *args, **kwds):
         """ Call the message handlers later.
         """
         do_later = lambda: self.call_handlers(*args, **kwds)
         QtCore.QTimer.singleShot(0, do_later)
 
     def call_handlers(self, msg):
         self.message_received.emit(msg)
 
     def process_events(self):
         """ Process any pending GUI events.
         """
         QtCore.QCoreApplication.instance().processEvents()
 
     def flush(self):
         """ Reimplemented to ensure that signals are dispatched immediately.
         """
         super(ChannelQObject, self).flush()
         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
 
 
 class QtKernelManagerMixin(MetaQObjectHasTraits('NewBase', (HasTraits, SuperQObject), {})):
     """ A KernelClient that provides signals and slots.
     """
 
     kernel_restarted = QtCore.Signal()
 
 
 class QtKernelClientMixin(MetaQObjectHasTraits('NewBase', (HasTraits, SuperQObject), {})):
     """ A KernelClient that provides signals and slots.
     """
 
     # Emitted when the kernel client has started listening.
     started_channels = QtCore.Signal()
 
     # Emitted when the kernel client has stopped listening.
     stopped_channels = QtCore.Signal()
 
     #---------------------------------------------------------------------------
     # 'KernelClient' interface
     #---------------------------------------------------------------------------
 
     #------ Channel management -------------------------------------------------
 
     def start_channels(self, *args, **kw):
         """ Reimplemented to emit signal.
         """
         super(QtKernelClientMixin, self).start_channels(*args, **kw)
         self.started_channels.emit()
 
     def stop_channels(self):
         """ Reimplemented to emit signal.
         """
         super(QtKernelClientMixin, self).stop_channels()
         self.stopped_channels.emit()