Collapse inprocess channel classes together

IPython/kernel/inprocess/__init__.py

@@ -1,7 +1,5 b''
 from .channels import (
-    InProcessShellChannel,
-    InProcessIOPubChannel,
-    InProcessStdInChannel,
+    InProcessChannel,
     InProcessHBChannel,
 )
 

IPython/kernel/inprocess/blocking.py

@@ -21,16 +21,14 b' from IPython.utils.traitlets import Type'
 
 # Local imports
 from .channels import (
-    InProcessShellChannel,
-    InProcessIOPubChannel,
-    InProcessStdInChannel,
+    InProcessChannel,
 )
 from .client import InProcessKernelClient
 
-class BlockingChannelMixin(object):
+class BlockingInProcessChannel(InProcessChannel):
 
     def __init__(self, *args, **kwds):
-        super(BlockingChannelMixin, self).__init__(*args, **kwds)
+        super(BlockingInProcessChannel, self).__init__(*args, **kwds)
         self._in_queue = Queue()
 
     def call_handlers(self, msg):
@@ -58,14 +56,8 b' class BlockingChannelMixin(object):'
         """ Is there a message that has been received? """
         return not self._in_queue.empty()
 
-class BlockingInProcessShellChannel(BlockingChannelMixin, InProcessShellChannel):
-    pass
-
-class BlockingInProcessIOPubChannel(BlockingChannelMixin, InProcessIOPubChannel):
-    pass
-
-class BlockingInProcessStdInChannel(BlockingChannelMixin, InProcessStdInChannel):
 
+class BlockingInProcessStdInChannel(BlockingInProcessChannel):
     def call_handlers(self, msg):
         """ Overridden for the in-process channel.
 
@@ -76,11 +68,27 b' class BlockingInProcessStdInChannel(BlockingChannelMixin, InProcessStdInChannel)'
             _raw_input = self.client.kernel._sys_raw_input
             prompt = msg['content']['prompt']
             raw_print(prompt, end='')
-            self.input(_raw_input())
+            self.client.input(_raw_input())
 
 class BlockingInProcessKernelClient(InProcessKernelClient):
 
     # The classes to use for the various channels.
-    shell_channel_class = Type(BlockingInProcessShellChannel)
-    iopub_channel_class = Type(BlockingInProcessIOPubChannel)
+    shell_channel_class = Type(BlockingInProcessChannel)
+    iopub_channel_class = Type(BlockingInProcessChannel)
     stdin_channel_class = Type(BlockingInProcessStdInChannel)
+
+    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

IPython/kernel/inprocess/channels.py

@@ -23,10 +23,6 b' class InProcessChannel(object):'
         self.client = client
         self._is_alive = False
 
-    #--------------------------------------------------------------------------
-    # Channel interface
-    #--------------------------------------------------------------------------
-
     def is_alive(self):
         return self._is_alive
 
@@ -46,9 +42,6 b' class InProcessChannel(object):'
     def flush(self, timeout=1.0):
         pass
 
-    #--------------------------------------------------------------------------
-    # InProcessChannel interface
-    #--------------------------------------------------------------------------
 
     def call_handlers_later(self, *args, **kwds):
         """ Call the message handlers later.
@@ -68,20 +61,6 b' class InProcessChannel(object):'
         raise NotImplementedError
 
 
-class InProcessShellChannel(InProcessChannel):
-    """See `IPython.kernel.channels.ShellChannel` for docstrings."""
-
-    # flag for whether execute requests should be allowed to call raw_input
-    allow_stdin = True
-
-class InProcessIOPubChannel(InProcessChannel):
-    """See `IPython.kernel.channels.IOPubChannel` for docstrings."""
-
-
-class InProcessStdInChannel(InProcessChannel):
-    """See `IPython.kernel.channels.StdInChannel` for docstrings."""
-
-
 
 class InProcessHBChannel(InProcessChannel):
     """See `IPython.kernel.channels.HBChannel` for docstrings."""
@@ -101,11 +80,5 b' class InProcessHBChannel(InProcessChannel):'
     def is_beating(self):
         return not self._pause
 
-#-----------------------------------------------------------------------------
-# ABC Registration
-#-----------------------------------------------------------------------------
 
-ShellChannelABC.register(InProcessShellChannel)
-IOPubChannelABC.register(InProcessIOPubChannel)
 HBChannelABC.register(InProcessHBChannel)
-StdInChannelABC.register(InProcessStdInChannel)

IPython/kernel/inprocess/client.py

@@ -19,10 +19,8 b' from IPython.kernel.client import KernelClient'
 
 # Local imports
 from .channels import (
-    InProcessShellChannel,
-    InProcessIOPubChannel,
+    InProcessChannel,
     InProcessHBChannel,
-    InProcessStdInChannel,
 
 )
 
@@ -41,9 +39,9 b' class InProcessKernelClient(KernelClient):'
     """
 
     # The classes to use for the various channels.
-    shell_channel_class = Type(InProcessShellChannel)
-    iopub_channel_class = Type(InProcessIOPubChannel)
-    stdin_channel_class = Type(InProcessStdInChannel)
+    shell_channel_class = Type(InProcessChannel)
+    iopub_channel_class = Type(InProcessChannel)
+    stdin_channel_class = Type(InProcessChannel)
     hb_channel_class = Type(InProcessHBChannel)
 
     kernel = Instance('IPython.kernel.inprocess.ipkernel.InProcessKernel')

IPython/kernel/inprocess/tests/test_kernel.py

@@ -26,6 +26,7 b' class InProcessKernelTestCase(unittest.TestCase):'
         self.km.start_kernel()
         self.kc = BlockingInProcessKernelClient(kernel=self.km.kernel)
         self.kc.start_channels()
+        self.kc.wait_for_ready()
 
     @skipif_not_matplotlib
     def test_pylab(self):

IPython/kernel/inprocess/tests/test_kernelmanager.py

@@ -51,6 +51,7 b' class InProcessKernelManagerTestCase(unittest.TestCase):'
         km.start_kernel()
         kc = BlockingInProcessKernelClient(kernel=km.kernel)
         kc.start_channels()
+        kc.wait_for_ready()
         kc.execute('foo = 1')
         self.assertEquals(km.kernel.shell.user_ns['foo'], 1)
 
@@ -61,6 +62,7 b' class InProcessKernelManagerTestCase(unittest.TestCase):'
         km.start_kernel()
         kc = BlockingInProcessKernelClient(kernel=km.kernel)
         kc.start_channels()
+        kc.wait_for_ready()
         km.kernel.shell.push({'my_bar': 0, 'my_baz': 1})
         kc.complete('my_ba', 5)
         msg = kc.get_shell_msg()
@@ -75,6 +77,7 b' class InProcessKernelManagerTestCase(unittest.TestCase):'
         km.start_kernel()
         kc = BlockingInProcessKernelClient(kernel=km.kernel)
         kc.start_channels()
+        kc.wait_for_ready()
         km.kernel.shell.user_ns['foo'] = 1
         kc.inspect('foo')
         msg = kc.get_shell_msg()
@@ -91,6 +94,7 b' class InProcessKernelManagerTestCase(unittest.TestCase):'
         km.start_kernel()
         kc = BlockingInProcessKernelClient(kernel=km.kernel)
         kc.start_channels()
+        kc.wait_for_ready()
         kc.execute('%who')
         kc.history(hist_access_type='tail', n=1)
         msg = kc.shell_channel.get_msgs()[-1]