Cleanup naming and organization of channels.

* Change remaining use of "sub" to "iopub".
* Use consistent naming of channel classes across zmq, inprocess
  and qt.
* Move BlockingChannelMixin to zmq.blockingkernelmanager.

IPython/frontend/qt/base_frontend_mixin.py

@@ -30,7 +30,7 class BaseFrontendMixin(object):
             old_manager.stopped_channels.disconnect(self._stopped_channels)
 
             # Disconnect the old kernel manager's channels.
-            old_manager.sub_channel.message_received.disconnect(self._dispatch)
+            old_manager.iopub_channel.message_received.disconnect(self._dispatch)
             old_manager.shell_channel.message_received.disconnect(self._dispatch)
             old_manager.stdin_channel.message_received.disconnect(self._dispatch)
             old_manager.hb_channel.kernel_died.disconnect(
@@ -51,7 +51,7 class BaseFrontendMixin(object):
         kernel_manager.stopped_channels.connect(self._stopped_channels)
 
         # Connect the new kernel manager's channels.
-        kernel_manager.sub_channel.message_received.connect(self._dispatch)
+        kernel_manager.iopub_channel.message_received.connect(self._dispatch)
         kernel_manager.shell_channel.message_received.connect(self._dispatch)
         kernel_manager.stdin_channel.message_received.connect(self._dispatch)
         kernel_manager.hb_channel.kernel_died.connect(self._handle_kernel_died)

IPython/frontend/qt/base_kernelmanager.py

@@ -69,7 +69,7 class QtShellChannelMixin(ChannelQObject):
     _handlers_called = False
 
     #---------------------------------------------------------------------------
-    # 'ShellSocketChannel' interface
+    # 'ShellChannel' interface
     #---------------------------------------------------------------------------
 
     def call_handlers(self, msg):
@@ -98,7 +98,7 class QtShellChannelMixin(ChannelQObject):
         self._handlers_called = False
 
 
-class QtSubChannelMixin(ChannelQObject):
+class QtIOPubChannelMixin(ChannelQObject):
 
     # Emitted when any message is received.
     message_received = QtCore.Signal(object)
@@ -126,7 +126,7 class QtSubChannelMixin(ChannelQObject):
     shutdown_reply_received = QtCore.Signal(object)
 
     #---------------------------------------------------------------------------
-    # 'SubSocketChannel' interface
+    # 'IOPubChannel' interface
     #---------------------------------------------------------------------------
 
     def call_handlers(self, msg):
@@ -145,7 +145,7 class QtSubChannelMixin(ChannelQObject):
     def flush(self):
         """ Reimplemented to ensure that signals are dispatched immediately.
         """
-        super(QtSubChannelMixin, self).flush()
+        super(QtIOPubChannelMixin, self).flush()
         QtCore.QCoreApplication.instance().processEvents()
 
 
@@ -158,7 +158,7 class QtStdInChannelMixin(ChannelQObject):
     input_requested = QtCore.Signal(object)
 
     #---------------------------------------------------------------------------
-    # 'StdInSocketChannel' interface
+    # 'StdInChannel' interface
     #---------------------------------------------------------------------------
 
     def call_handlers(self, msg):
@@ -179,7 +179,7 class QtHBChannelMixin(ChannelQObject):
     kernel_died = QtCore.Signal(object)
 
     #---------------------------------------------------------------------------
-    # 'HBSocketChannel' interface
+    # 'HBChannel' interface
     #---------------------------------------------------------------------------
 
     def call_handlers(self, since_last_heartbeat):
@@ -205,7 +205,7 class QtKernelManagerMixin(HasTraits, SuperQObject):
     stopped_channels = QtCore.Signal()
 
     # Use Qt-specific channel classes that emit signals.
-    sub_channel_class = Type(QtSubChannelMixin)
+    iopub_channel_class = Type(QtIOPubChannelMixin)
     shell_channel_class = Type(QtShellChannelMixin)
     stdin_channel_class = Type(QtStdInChannelMixin)
     hb_channel_class = Type(QtHBChannelMixin)

IPython/frontend/qt/console/frontend_widget.py

@@ -396,7 +396,7 class FrontendWidget(HistoryConsoleWidget, BaseFrontendMixin):
         if info and info.kind == 'user' and not self._hidden:
             # Make sure that all output from the SUB channel has been processed
             # before writing a new prompt.
-            self.kernel_manager.sub_channel.flush()
+            self.kernel_manager.iopub_channel.flush()
 
             # Reset the ANSI style information to prevent bad text in stdout
             # from messing up our colors. We're not a true terminal so we're
@@ -431,7 +431,7 class FrontendWidget(HistoryConsoleWidget, BaseFrontendMixin):
 
         # Make sure that all output from the SUB channel has been processed
         # before entering readline mode.
-        self.kernel_manager.sub_channel.flush()
+        self.kernel_manager.iopub_channel.flush()
 
         def callback(line):
             self.kernel_manager.stdin_channel.input(line)

IPython/frontend/qt/inprocess_kernelmanager.py

@@ -3,23 +3,23
 
 # Local imports.
 from IPython.inprocess.kernelmanager import \
-    ShellInProcessChannel, SubInProcessChannel, StdInInProcessChannel, \
-    HBInProcessChannel, InProcessKernelManager
+    InProcessShellChannel, InProcessIOPubChannel, InProcessStdInChannel, \
+    InProcessHBChannel, InProcessKernelManager
 from IPython.utils.traitlets import Type
-from base_kernelmanager import QtShellChannelMixin, QtSubChannelMixin, \
+from base_kernelmanager import QtShellChannelMixin, QtIOPubChannelMixin, \
     QtStdInChannelMixin, QtHBChannelMixin, QtKernelManagerMixin
 
 
-class QtShellInProcessChannel(QtShellChannelMixin, ShellInProcessChannel):
+class QtInProcessShellChannel(QtShellChannelMixin, InProcessShellChannel):
     pass
 
-class QtSubInProcessChannel(QtSubChannelMixin, SubInProcessChannel):
+class QtInProcessIOPubChannel(QtIOPubChannelMixin, InProcessIOPubChannel):
     pass
 
-class QtStdInInProcessChannel(QtStdInChannelMixin, StdInInProcessChannel):
+class QtInProcessStdInChannel(QtStdInChannelMixin, InProcessStdInChannel):
     pass
 
-class QtHBInProcessChannel(QtHBChannelMixin, HBInProcessChannel):
+class QtInProcessHBChannel(QtHBChannelMixin, InProcessHBChannel):
     pass
 
 
@@ -27,7 +27,7 class QtInProcessKernelManager(QtKernelManagerMixin, InProcessKernelManager):
     """ An in-process KernelManager with signals and slots.
     """
 
-    sub_channel_class = Type(QtSubInProcessChannel)
-    shell_channel_class = Type(QtShellInProcessChannel)
-    stdin_channel_class = Type(QtStdInInProcessChannel)
-    hb_channel_class = Type(QtHBInProcessChannel)
+    iopub_channel_class = Type(QtInProcessIOPubChannel)
+    shell_channel_class = Type(QtInProcessShellChannel)
+    stdin_channel_class = Type(QtInProcessStdInChannel)
+    hb_channel_class = Type(QtInProcessHBChannel)

IPython/frontend/qt/kernelmanager.py

@@ -3,22 +3,22
 
 # Local imports.
 from IPython.utils.traitlets import Type
-from IPython.zmq.kernelmanager import ShellSocketChannel, SubSocketChannel, \
-    StdInSocketChannel, HBSocketChannel, KernelManager
-from base_kernelmanager import QtShellChannelMixin, QtSubChannelMixin, \
+from IPython.zmq.kernelmanager import ShellChannel, IOPubChannel, \
+    StdInChannel, HBChannel, KernelManager
+from base_kernelmanager import QtShellChannelMixin, QtIOPubChannelMixin, \
     QtStdInChannelMixin, QtHBChannelMixin, QtKernelManagerMixin
 
 
-class QtShellSocketChannel(QtShellChannelMixin, ShellSocketChannel):
+class QtShellChannel(QtShellChannelMixin, ShellChannel):
     pass
 
-class QtSubSocketChannel(QtSubChannelMixin, SubSocketChannel):
+class QtIOPubChannel(QtIOPubChannelMixin, IOPubChannel):
     pass
 
-class QtStdInSocketChannel(QtStdInChannelMixin, StdInSocketChannel):
+class QtStdInChannel(QtStdInChannelMixin, StdInChannel):
     pass
 
-class QtHBSocketChannel(QtHBChannelMixin, HBSocketChannel):
+class QtHBChannel(QtHBChannelMixin, HBChannel):
     pass
 
 
@@ -26,7 +26,7 class QtKernelManager(QtKernelManagerMixin, KernelManager):
     """ A KernelManager that provides signals and slots.
     """
 
-    sub_channel_class = Type(QtSubSocketChannel)
-    shell_channel_class = Type(QtShellSocketChannel)
-    stdin_channel_class = Type(QtStdInSocketChannel)
-    hb_channel_class = Type(QtHBSocketChannel)
+    iopub_channel_class = Type(QtIOPubChannel)
+    shell_channel_class = Type(QtShellChannel)
+    stdin_channel_class = Type(QtStdInChannel)
+    hb_channel_class = Type(QtHBChannel)

IPython/frontend/terminal/console/interactiveshell.py

@@ -211,8 +211,8 class ZMQTerminalInteractiveShell(TerminalInteractiveShell):
            sub_msg:  message receive from kernel in the sub socket channel
                      capture by kernel manager.
         """
-        while self.km.sub_channel.msg_ready():
-            sub_msg = self.km.sub_channel.get_msg()
+        while self.km.iopub_channel.msg_ready():
+            sub_msg = self.km.iopub_channel.get_msg()
             msg_type = sub_msg['header']['msg_type']
             parent = sub_msg["parent_header"]
             if (not parent) or self.session_id == parent['session']:

IPython/inprocess/blockingkernelmanager.py

@@ -21,51 +21,22 from threading import Event
 # Local imports.
 from IPython.utils.io import raw_print
 from IPython.utils.traitlets import Type
-from kernelmanager import InProcessKernelManager, ShellInProcessChannel, \
-    SubInProcessChannel, StdInInProcessChannel
+from kernelmanager import InProcessKernelManager, InProcessShellChannel, \
+    InProcessIOPubChannel, InProcessStdInChannel
+from IPython.zmq.blockingkernelmanager import BlockingChannelMixin
 
-#-----------------------------------------------------------------------------
-# Utility classes
-#-----------------------------------------------------------------------------
-
-class BlockingChannelMixin(object):
-    
-    def __init__(self, *args, **kwds):
-        super(BlockingChannelMixin, self).__init__(*args, **kwds)
-        self._in_queue = Queue.Queue()
-        
-    def call_handlers(self, msg):
-        self._in_queue.put(msg)
-        
-    def get_msg(self, block=True, timeout=None):
-        """ Gets a message if there is one that is ready. """
-        return self._in_queue.get(block, timeout)
-        
-    def get_msgs(self):
-        """ Get all messages that are currently ready. """
-        msgs = []
-        while True:
-            try:
-                msgs.append(self.get_msg(block=False))
-            except Queue.Empty:
-                break
-        return msgs
-    
-    def msg_ready(self):
-        """ Is there a message that has been received? """
-        return not self._in_queue.empty()
 
 #-----------------------------------------------------------------------------
 # Blocking kernel manager
 #-----------------------------------------------------------------------------
 
-class BlockingShellInProcessChannel(BlockingChannelMixin, ShellInProcessChannel):
+class BlockingInProcessShellChannel(BlockingChannelMixin, InProcessShellChannel):
     pass
 
-class BlockingSubInProcessChannel(BlockingChannelMixin, SubInProcessChannel):
+class BlockingInProcessIOPubChannel(BlockingChannelMixin, InProcessIOPubChannel):
     pass
 
-class BlockingStdInInProcessChannel(BlockingChannelMixin, StdInInProcessChannel):
+class BlockingInProcessStdInChannel(BlockingChannelMixin, InProcessStdInChannel):
     
     def call_handlers(self, msg):
         """ Overridden for the in-process channel.
@@ -82,6 +53,6 class BlockingStdInInProcessChannel(BlockingChannelMixin, StdInInProcessChannel)
 class BlockingInProcessKernelManager(InProcessKernelManager):
 
     # The classes to use for the various channels.
-    shell_channel_class = Type(BlockingShellInProcessChannel)
-    sub_channel_class = Type(BlockingSubInProcessChannel)
-    stdin_channel_class = Type(BlockingStdInInProcessChannel)
+    shell_channel_class = Type(BlockingInProcessShellChannel)
+    iopub_channel_class = Type(BlockingInProcessIOPubChannel)
+    stdin_channel_class = Type(BlockingInProcessStdInChannel)

IPython/inprocess/ipkernel.py

@@ -123,7 +123,7 class InProcessKernel(Kernel):
         """
         ident, msg = self.session.recv(self.iopub_socket, copy=False)
         for frontend in self.frontends:
-            frontend.sub_channel.call_handlers(msg)
+            frontend.iopub_channel.call_handlers(msg)
         
     #------ Trait initializers -----------------------------------------------
 

IPython/inprocess/kernelmanager.py

@@ -71,7 +71,7 class InProcessChannel(object):
         raise NotImplementedError
 
 
-class ShellInProcessChannel(InProcessChannel):
+class InProcessShellChannel(InProcessChannel):
     """The DEALER channel for issues request/replies to the kernel.
     """
 
@@ -240,7 +240,7 class ShellInProcessChannel(InProcessChannel):
         self.call_handlers_later(reply_msg)
 
 
-class SubInProcessChannel(InProcessChannel):
+class InProcessIOPubChannel(InProcessChannel):
     """The SUB channel which listens for messages that the kernel publishes. 
     """
 
@@ -252,7 +252,7 class SubInProcessChannel(InProcessChannel):
         pass
 
 
-class StdInInProcessChannel(InProcessChannel):
+class InProcessStdInChannel(InProcessChannel):
     """ A reply channel to handle raw_input requests that the kernel makes. """
 
     def input(self, string):
@@ -264,13 +264,13 class StdInInProcessChannel(InProcessChannel):
         kernel.raw_input_str = string
 
 
-class HBInProcessChannel(InProcessChannel):
+class InProcessHBChannel(InProcessChannel):
     """ A dummy heartbeat channel. """
 
     time_to_dead = 3.0
 
     def __init__(self, *args, **kwds):
-        super(HBInProcessChannel, self).__init__(*args, **kwds)
+        super(InProcessHBChannel, self).__init__(*args, **kwds)
         self._pause = True
 
     def pause(self):
@@ -310,14 +310,14 class InProcessKernelManager(HasTraits):
     kernel = Instance('IPython.inprocess.ipkernel.InProcessKernel')
 
     # The classes to use for the various channels.
-    shell_channel_class = Type(ShellInProcessChannel)
-    sub_channel_class = Type(SubInProcessChannel)
-    stdin_channel_class = Type(StdInInProcessChannel)
-    hb_channel_class = Type(HBInProcessChannel)
+    shell_channel_class = Type(InProcessShellChannel)
+    iopub_channel_class = Type(InProcessIOPubChannel)
+    stdin_channel_class = Type(InProcessStdInChannel)
+    hb_channel_class = Type(InProcessHBChannel)
 
     # Protected traits.
     _shell_channel = Any
-    _sub_channel = Any
+    _iopub_channel = Any
     _stdin_channel = Any
     _hb_channel = Any
 
@@ -331,7 +331,7 class InProcessKernelManager(HasTraits):
         if shell:
             self.shell_channel.start()
         if sub:
-            self.sub_channel.start()
+            self.iopub_channel.start()
         if stdin:
             self.stdin_channel.start()
             self.shell_channel.allow_stdin = True
@@ -345,8 +345,8 class InProcessKernelManager(HasTraits):
         """
         if self.shell_channel.is_alive():
             self.shell_channel.stop()
-        if self.sub_channel.is_alive():
-            self.sub_channel.stop()
+        if self.iopub_channel.is_alive():
+            self.iopub_channel.stop()
         if self.stdin_channel.is_alive():
             self.stdin_channel.stop()
         if self.hb_channel.is_alive():
@@ -355,7 +355,7 class InProcessKernelManager(HasTraits):
     @property
     def channels_running(self):
         """ Are any of the channels created and running? """
-        return (self.shell_channel.is_alive() or self.sub_channel.is_alive() or
+        return (self.shell_channel.is_alive() or self.iopub_channel.is_alive() or
                 self.stdin_channel.is_alive() or self.hb_channel.is_alive())
 
     #--------------------------------------------------------------------------
@@ -421,11 +421,11 class InProcessKernelManager(HasTraits):
         return self._shell_channel
 
     @property
-    def sub_channel(self):
+    def iopub_channel(self):
         """Get the SUB socket channel object."""
-        if self._sub_channel is None:
-            self._sub_channel = self.sub_channel_class(self)
-        return self._sub_channel
+        if self._iopub_channel is None:
+            self._iopub_channel = self.iopub_channel_class(self)
+        return self._iopub_channel
 
     @property
     def stdin_channel(self):

IPython/inprocess/tests/test_kernel.py

@@ -80,7 +80,7 def get_stream_message(kernel_manager, timeout=5):
     """ Gets a single stream message synchronously from the sub channel.
     """
     while True:
-        msg = kernel_manager.sub_channel.get_msg(timeout=timeout)
+        msg = kernel_manager.iopub_channel.get_msg(timeout=timeout)
         if msg['header']['msg_type'] == 'stream':
             return msg
 

IPython/zmq/blockingkernelmanager.py

@@ -13,26 +13,56 Useful for test suites and blocking terminal interfaces.
 # Imports
 #-----------------------------------------------------------------------------
 
-# Local imports.
-from IPython.inprocess.blockingkernelmanager import BlockingChannelMixin
 from IPython.utils.traitlets import Type
-from kernelmanager import KernelManager, SubSocketChannel, HBSocketChannel, \
-    ShellSocketChannel, StdInSocketChannel
+from kernelmanager import KernelManager, IOPubChannel, HBChannel, \
+    ShellChannel, StdInChannel
 
 #-----------------------------------------------------------------------------
 # Blocking kernel manager
 #-----------------------------------------------------------------------------
 
-class BlockingSubSocketChannel(BlockingChannelMixin, SubSocketChannel):
+
+class BlockingChannelMixin(object):
+    
+    def __init__(self, *args, **kwds):
+        super(BlockingChannelMixin, self).__init__(*args, **kwds)
+        self._in_queue = Queue.Queue()
+        
+    def call_handlers(self, msg):
+        self._in_queue.put(msg)
+        
+    def get_msg(self, block=True, timeout=None):
+        """ Gets a message if there is one that is ready. """
+        return self._in_queue.get(block, timeout)
+        
+    def get_msgs(self):
+        """ Get all messages that are currently ready. """
+        msgs = []
+        while True:
+            try:
+                msgs.append(self.get_msg(block=False))
+            except Queue.Empty:
+                break
+        return msgs
+    
+    def msg_ready(self):
+        """ Is there a message that has been received? """
+        return not self._in_queue.empty()
+
+
+class BlockingIOPubChannel(BlockingChannelMixin, IOPubChannel):
     pass
 
-class BlockingShellSocketChannel(BlockingChannelMixin, ShellSocketChannel):
+
+class BlockingShellChannel(BlockingChannelMixin, ShellChannel):
     pass
 
-class BlockingStdInSocketChannel(BlockingChannelMixin, StdInSocketChannel):
+
+class BlockingStdInChannel(BlockingChannelMixin, StdInChannel):
     pass
 
-class BlockingHBSocketChannel(HBSocketChannel):
+
+class BlockingHBChannel(HBChannel):
     
     # This kernel needs quicker monitoring, shorten to 1 sec.
     # less than 0.5s is unreliable, and will get occasional
@@ -43,11 +73,12 class BlockingHBSocketChannel(HBSocketChannel):
         """ Pause beating on missed heartbeat. """
         pass
 
+
 class BlockingKernelManager(KernelManager):
     
     # The classes to use for the various channels.
-    shell_channel_class = Type(BlockingShellSocketChannel)
-    sub_channel_class = Type(BlockingSubSocketChannel)
-    stdin_channel_class = Type(BlockingStdInSocketChannel)
-    hb_channel_class = Type(BlockingHBSocketChannel)
+    shell_channel_class = Type(BlockingShellChannel)
+    iopub_channel_class = Type(BlockingIOPubChannel)
+    stdin_channel_class = Type(BlockingStdInChannel)
+    hb_channel_class = Type(BlockingHBChannel)
   

IPython/zmq/kernelmanager.py

@@ -180,7 +180,7 class ZMQSocketChannel(Thread):
     
 
 
-class ShellSocketChannel(ZMQSocketChannel):
+class ShellChannel(ZMQSocketChannel):
     """The DEALER channel for issues request/replies to the kernel.
     """
 
@@ -189,7 +189,7 class ShellSocketChannel(ZMQSocketChannel):
     allow_stdin = True
 
     def __init__(self, context, session, address):
-        super(ShellSocketChannel, self).__init__(context, session, address)
+        super(ShellChannel, self).__init__(context, session, address)
         self.ioloop = ioloop.IOLoop()
 
     def run(self):
@@ -207,7 +207,7 class ShellSocketChannel(ZMQSocketChannel):
 
     def stop(self):
         self.ioloop.stop()
-        super(ShellSocketChannel, self).stop()
+        super(ShellChannel, self).stop()
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
@@ -389,12 +389,12 class ShellSocketChannel(ZMQSocketChannel):
 
 
 
-class SubSocketChannel(ZMQSocketChannel):
+class IOPubChannel(ZMQSocketChannel):
     """The SUB channel which listens for messages that the kernel publishes.
     """
 
     def __init__(self, context, session, address):
-        super(SubSocketChannel, self).__init__(context, session, address)
+        super(IOPubChannel, self).__init__(context, session, address)
         self.ioloop = ioloop.IOLoop()
 
     def run(self):
@@ -413,7 +413,7 class SubSocketChannel(ZMQSocketChannel):
 
     def stop(self):
         self.ioloop.stop()
-        super(SubSocketChannel, self).stop()
+        super(IOPubChannel, self).stop()
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
@@ -455,13 +455,13 class SubSocketChannel(ZMQSocketChannel):
         self._flushed = True
 
 
-class StdInSocketChannel(ZMQSocketChannel):
+class StdInChannel(ZMQSocketChannel):
     """A reply channel to handle raw_input requests that the kernel makes."""
 
     msg_queue = None
 
     def __init__(self, context, session, address):
-        super(StdInSocketChannel, self).__init__(context, session, address)
+        super(StdInChannel, self).__init__(context, session, address)
         self.ioloop = ioloop.IOLoop()
 
     def run(self):
@@ -480,7 +480,7 class StdInSocketChannel(ZMQSocketChannel):
 
     def stop(self):
         self.ioloop.stop()
-        super(StdInSocketChannel, self).stop()
+        super(StdInChannel, self).stop()
 
     def call_handlers(self, msg):
         """This method is called in the ioloop thread when a message arrives.
@@ -499,7 +499,7 class StdInSocketChannel(ZMQSocketChannel):
         self._queue_send(msg)
 
 
-class HBSocketChannel(ZMQSocketChannel):
+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
@@ -515,7 +515,7 class HBSocketChannel(ZMQSocketChannel):
     _beating = None
 
     def __init__(self, context, session, address):
-        super(HBSocketChannel, self).__init__(context, session, address)
+        super(HBChannel, self).__init__(context, session, address)
         self._running = False
         self._pause =True
         self.poller = zmq.Poller()
@@ -622,7 +622,7 class HBSocketChannel(ZMQSocketChannel):
 
     def stop(self):
         self._running = False
-        super(HBSocketChannel, self).stop()
+        super(HBChannel, self).stop()
 
     def call_handlers(self, since_last_heartbeat):
         """This method is called in the ioloop thread when a message arrives.
@@ -678,15 +678,15 class KernelManager(Configurable):
     hb_port = Integer(0)
 
     # The classes to use for the various channels.
-    shell_channel_class = Type(ShellSocketChannel)
-    sub_channel_class = Type(SubSocketChannel)
-    stdin_channel_class = Type(StdInSocketChannel)
-    hb_channel_class = Type(HBSocketChannel)
+    shell_channel_class = Type(ShellChannel)
+    iopub_channel_class = Type(IOPubChannel)
+    stdin_channel_class = Type(StdInChannel)
+    hb_channel_class = Type(HBChannel)
 
     # Protected traits.
     _launch_args = Any
     _shell_channel = Any
-    _sub_channel = Any
+    _iopub_channel = Any
     _stdin_channel = Any
     _hb_channel = Any
     _connection_file_written=Bool(False)
@@ -709,7 +709,7 class KernelManager(Configurable):
         if shell:
             self.shell_channel.start()
         if sub:
-            self.sub_channel.start()
+            self.iopub_channel.start()
         if stdin:
             self.stdin_channel.start()
             self.shell_channel.allow_stdin = True
@@ -723,8 +723,8 class KernelManager(Configurable):
         """
         if self.shell_channel.is_alive():
             self.shell_channel.stop()
-        if self.sub_channel.is_alive():
-            self.sub_channel.stop()
+        if self.iopub_channel.is_alive():
+            self.iopub_channel.stop()
         if self.stdin_channel.is_alive():
             self.stdin_channel.stop()
         if self.hb_channel.is_alive():
@@ -733,7 +733,7 class KernelManager(Configurable):
     @property
     def channels_running(self):
         """Are any of the channels created and running?"""
-        return (self.shell_channel.is_alive() or self.sub_channel.is_alive() or
+        return (self.shell_channel.is_alive() or self.iopub_channel.is_alive() or
                 self.stdin_channel.is_alive() or self.hb_channel.is_alive())
 
     #--------------------------------------------------------------------------
@@ -1007,14 +1007,14 class KernelManager(Configurable):
         return self._shell_channel
 
     @property
-    def sub_channel(self):
+    def iopub_channel(self):
         """Get the SUB socket channel object."""
-        if self._sub_channel is None:
-            self._sub_channel = self.sub_channel_class(self.context,
+        if self._iopub_channel is None:
+            self._iopub_channel = self.iopub_channel_class(self.context,
                                                        self.session,
                                                        self._make_url(self.iopub_port),
             )
-        return self._sub_channel
+        return self._iopub_channel
 
     @property
     def stdin_channel(self):

IPython/zmq/tests/test_message_spec.py

@@ -48,7 +48,7 def teardown():
 
 def flush_channels():
     """flush any messages waiting on the queue"""
-    for channel in (KM.shell_channel, KM.sub_channel):
+    for channel in (KM.shell_channel, KM.iopub_channel):
         while True:
             try:
                 msg = channel.get_msg(block=True, timeout=0.1)
@@ -61,7 +61,7 def flush_channels():
 def execute(code='', **kwargs):
     """wrapper for doing common steps for validating an execution request"""
     shell = KM.shell_channel
-    sub = KM.sub_channel
+    sub = KM.iopub_channel
     
     msg_id = shell.execute(code=code, **kwargs)
     reply = shell.get_msg(timeout=2)
@@ -310,23 +310,23 def test_execute_silent():
     msg_id, reply = execute(code='x=1', silent=True)
     
     # flush status=idle
-    status = KM.sub_channel.get_msg(timeout=2)
+    status = KM.iopub_channel.get_msg(timeout=2)
     for tst in validate_message(status, 'status', msg_id):
         yield tst
     nt.assert_equal(status['content']['execution_state'], 'idle')
 
-    yield nt.assert_raises(Empty, KM.sub_channel.get_msg, timeout=0.1)
+    yield nt.assert_raises(Empty, KM.iopub_channel.get_msg, timeout=0.1)
     count = reply['execution_count']
     
     msg_id, reply = execute(code='x=2', silent=True)
     
     # flush status=idle
-    status = KM.sub_channel.get_msg(timeout=2)
+    status = KM.iopub_channel.get_msg(timeout=2)
     for tst in validate_message(status, 'status', msg_id):
         yield tst
     yield nt.assert_equal(status['content']['execution_state'], 'idle')
     
-    yield nt.assert_raises(Empty, KM.sub_channel.get_msg, timeout=0.1)
+    yield nt.assert_raises(Empty, KM.iopub_channel.get_msg, timeout=0.1)
     count_2 = reply['execution_count']
     yield nt.assert_equal(count_2, count)
 
@@ -339,7 +339,7 def test_execute_error():
     yield nt.assert_equal(reply['status'], 'error')
     yield nt.assert_equal(reply['ename'], 'ZeroDivisionError')
     
-    pyerr = KM.sub_channel.get_msg(timeout=2)
+    pyerr = KM.iopub_channel.get_msg(timeout=2)
     for tst in validate_message(pyerr, 'pyerr', msg_id):
         yield tst
 
@@ -475,7 +475,7 def test_stream():
 
     msg_id, reply = execute("print('hi')")
 
-    stdout = KM.sub_channel.get_msg(timeout=2)
+    stdout = KM.iopub_channel.get_msg(timeout=2)
     for tst in validate_message(stdout, 'stream', msg_id):
         yield tst
     content = stdout['content']
@@ -489,7 +489,7 def test_display_data():
 
     msg_id, reply = execute("from IPython.core.display import display; display(1)")
     
-    display = KM.sub_channel.get_msg(timeout=2)
+    display = KM.iopub_channel.get_msg(timeout=2)
     for tst in validate_message(display, 'display_data', parent=msg_id):
         yield tst
     data = display['content']['data']