Collapse Qt in-process channel classes together

IPython/kernel/inprocess/channels.py

@@ -1,196 +1,111 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
 
     #--------------------------------------------------------------------------
     # Channel interface
     #--------------------------------------------------------------------------
 
     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
+
     #--------------------------------------------------------------------------
     # InProcessChannel interface
     #--------------------------------------------------------------------------
 
     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 InProcessShellChannel(InProcessChannel):
     """See `IPython.kernel.channels.ShellChannel` for docstrings."""
 
     # flag for whether execute requests should be allowed to call raw_input
     allow_stdin = True
-    proxy_methods = [
-        'execute',
-        'complete',
-        'inspect',
-        'history',
-        'shutdown',
-        'kernel_info',
-    ]
-
-    #--------------------------------------------------------------------------
-    # ShellChannel interface
-    #--------------------------------------------------------------------------
-
-    def execute(self, code, silent=False, store_history=True,
-                user_expressions={}, allow_stdin=None):
-        if allow_stdin is None:
-            allow_stdin = self.allow_stdin
-        content = dict(code=code, silent=silent, store_history=store_history,
-                       user_expressions=user_expressions,
-                       allow_stdin=allow_stdin)
-        msg = self.client.session.msg('execute_request', content)
-        self._dispatch_to_kernel(msg)
-        return msg['header']['msg_id']
-
-    def complete(self, code, cursor_pos=None):
-        if cursor_pos is None:
-            cursor_pos = len(code)
-        content = dict(code=code, cursor_pos=cursor_pos)
-        msg = self.client.session.msg('complete_request', content)
-        self._dispatch_to_kernel(msg)
-        return msg['header']['msg_id']
-
-    def inspect(self, code, cursor_pos=None, detail_level=0):
-        if cursor_pos is None:
-            cursor_pos = len(code)
-        content = dict(code=code, cursor_pos=cursor_pos,
-            detail_level=detail_level,
-        )
-        msg = self.client.session.msg('inspect_request', content)
-        self._dispatch_to_kernel(msg)
-        return msg['header']['msg_id']
-
-    def history(self, raw=True, output=False, hist_access_type='range', **kwds):
-        content = dict(raw=raw, output=output,
-                       hist_access_type=hist_access_type, **kwds)
-        msg = self.client.session.msg('history_request', content)
-        self._dispatch_to_kernel(msg)
-        return msg['header']['msg_id']
-
-    def shutdown(self, restart=False):
-        # FIXME: What to do here?
-        raise NotImplementedError('Cannot shutdown in-process kernel')
-
-    def kernel_info(self):
-        """Request kernel info."""
-        msg = self.client.session.msg('kernel_info_request')
-        self._dispatch_to_kernel(msg)
-        return msg['header']['msg_id']
-
-    #--------------------------------------------------------------------------
-    # Protected interface
-    #--------------------------------------------------------------------------
-
-    def _dispatch_to_kernel(self, msg):
-        """ Send a message to the kernel and handle a reply.
-        """
-        kernel = self.client.kernel
-        if kernel is None:
-            raise RuntimeError('Cannot send request. No kernel exists.')
-
-        stream = DummySocket()
-        self.client.session.send(stream, msg)
-        msg_parts = stream.recv_multipart()
-        kernel.dispatch_shell(stream, msg_parts)
-
-        idents, reply_msg = self.client.session.recv(stream, copy=False)
-        self.call_handlers_later(reply_msg)
-
 
 class InProcessIOPubChannel(InProcessChannel):
     """See `IPython.kernel.channels.IOPubChannel` for docstrings."""
 
-    def flush(self, timeout=1.0):
-        pass
-
 
 class InProcessStdInChannel(InProcessChannel):
     """See `IPython.kernel.channels.StdInChannel` for docstrings."""
 
-    proxy_methods = ['input']
-
-    def input(self, string):
-        kernel = self.client.kernel
-        if kernel is None:
-            raise RuntimeError('Cannot send input reply. No kernel exists.')
-        kernel.raw_input_str = string
 
 
 class InProcessHBChannel(InProcessChannel):
     """See `IPython.kernel.channels.HBChannel` for docstrings."""
 
     time_to_dead = 3.0
 
     def __init__(self, *args, **kwds):
         super(InProcessHBChannel, self).__init__(*args, **kwds)
         self._pause = True
 
     def pause(self):
         self._pause = True
 
     def unpause(self):
         self._pause = False
 
     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

@@ -1,87 +1,158 b''
 """A client for in-process kernels."""
 
 #-----------------------------------------------------------------------------
 #  Copyright (C) 2012  The IPython Development Team
 #
 #  Distributed under the terms of the BSD License.  The full license is in
 #  the file COPYING, distributed as part of this software.
 #-----------------------------------------------------------------------------
 
 #-----------------------------------------------------------------------------
 # Imports
 #-----------------------------------------------------------------------------
 
 # IPython imports
+from IPython.kernel.inprocess.socket import DummySocket
 from IPython.utils.traitlets import Type, Instance
 from IPython.kernel.clientabc import KernelClientABC
 from IPython.kernel.client import KernelClient
 
 # Local imports
 from .channels import (
     InProcessShellChannel,
     InProcessIOPubChannel,
     InProcessHBChannel,
     InProcessStdInChannel,
 
 )
 
 #-----------------------------------------------------------------------------
 # Main kernel Client class
 #-----------------------------------------------------------------------------
 
 class InProcessKernelClient(KernelClient):
     """A client for an in-process kernel.
 
     This class implements the interface of
     `IPython.kernel.clientabc.KernelClientABC` and allows
     (asynchronous) frontends to be used seamlessly with an in-process kernel.
 
     See `IPython.kernel.client.KernelClient` for docstrings.
     """
 
     # The classes to use for the various channels.
     shell_channel_class = Type(InProcessShellChannel)
     iopub_channel_class = Type(InProcessIOPubChannel)
     stdin_channel_class = Type(InProcessStdInChannel)
     hb_channel_class = Type(InProcessHBChannel)
 
     kernel = Instance('IPython.kernel.inprocess.ipkernel.InProcessKernel')
 
     #--------------------------------------------------------------------------
     # Channel management methods
     #--------------------------------------------------------------------------
 
     def start_channels(self, *args, **kwargs):
         super(InProcessKernelClient, self).start_channels(self)
         self.kernel.frontends.append(self)
 
     @property
     def shell_channel(self):
         if self._shell_channel is None:
             self._shell_channel = self.shell_channel_class(self)
         return self._shell_channel
 
     @property
     def iopub_channel(self):
         if self._iopub_channel is None:
             self._iopub_channel = self.iopub_channel_class(self)
         return self._iopub_channel
 
     @property
     def stdin_channel(self):
         if self._stdin_channel is None:
             self._stdin_channel = self.stdin_channel_class(self)
         return self._stdin_channel
 
     @property
     def hb_channel(self):
         if self._hb_channel is None:
             self._hb_channel = self.hb_channel_class(self)
         return self._hb_channel
 
+    # Methods for sending specific messages
+    # -------------------------------------
+
+    def execute(self, code, silent=False, store_history=True,
+                user_expressions={}, allow_stdin=None):
+        if allow_stdin is None:
+            allow_stdin = self.allow_stdin
+        content = dict(code=code, silent=silent, store_history=store_history,
+                       user_expressions=user_expressions,
+                       allow_stdin=allow_stdin)
+        msg = self.session.msg('execute_request', content)
+        self._dispatch_to_kernel(msg)
+        return msg['header']['msg_id']
+
+    def complete(self, code, cursor_pos=None):
+        if cursor_pos is None:
+            cursor_pos = len(code)
+        content = dict(code=code, cursor_pos=cursor_pos)
+        msg = self.session.msg('complete_request', content)
+        self._dispatch_to_kernel(msg)
+        return msg['header']['msg_id']
+
+    def inspect(self, code, cursor_pos=None, detail_level=0):
+        if cursor_pos is None:
+            cursor_pos = len(code)
+        content = dict(code=code, cursor_pos=cursor_pos,
+            detail_level=detail_level,
+        )
+        msg = self.session.msg('inspect_request', content)
+        self._dispatch_to_kernel(msg)
+        return msg['header']['msg_id']
+
+    def history(self, raw=True, output=False, hist_access_type='range', **kwds):
+        content = dict(raw=raw, output=output,
+                       hist_access_type=hist_access_type, **kwds)
+        msg = self.session.msg('history_request', content)
+        self._dispatch_to_kernel(msg)
+        return msg['header']['msg_id']
+
+    def shutdown(self, restart=False):
+        # FIXME: What to do here?
+        raise NotImplementedError('Cannot shutdown in-process kernel')
+
+    def kernel_info(self):
+        """Request kernel info."""
+        msg = self.session.msg('kernel_info_request')
+        self._dispatch_to_kernel(msg)
+        return msg['header']['msg_id']
+
+    def input(self, string):
+        if self.kernel is None:
+            raise RuntimeError('Cannot send input reply. No kernel exists.')
+        self.kernel.raw_input_str = string
+
+
+    def _dispatch_to_kernel(self, msg):
+        """ Send a message to the kernel and handle a reply.
+        """
+        kernel = self.kernel
+        if kernel is None:
+            raise RuntimeError('Cannot send request. No kernel exists.')
+
+        stream = DummySocket()
+        self.session.send(stream, msg)
+        msg_parts = stream.recv_multipart()
+        kernel.dispatch_shell(stream, msg_parts)
+
+        idents, reply_msg = self.session.recv(stream, copy=False)
+        self.shell_channel.call_handlers_later(reply_msg)
+
 
 #-----------------------------------------------------------------------------
 # ABC Registration
 #-----------------------------------------------------------------------------
 
 KernelClientABC.register(InProcessKernelClient)

IPython/qt/inprocess.py

@@ -1,115 +1,33 b''
 """ Defines an in-process KernelManager with signals and slots.
 """
 
 # Local imports.
 from IPython.external.qt import QtCore
 from IPython.kernel.inprocess import (
-    InProcessShellChannel, InProcessIOPubChannel, InProcessStdInChannel,
     InProcessHBChannel, InProcessKernelClient, InProcessKernelManager,
 )
+from IPython.kernel.inprocess.channels import InProcessChannel
 
 from IPython.utils.traitlets import Type
 from .kernel_mixins import ( ChannelQObject,
     QtHBChannelMixin, QtKernelClientMixin,
     QtKernelManagerMixin,
 )
 
-
-class QtInProcessShellChannel(ChannelQObject, InProcessShellChannel):
-    # Emitted when a reply has been received for the corresponding request type.
-    execute_reply = QtCore.Signal(object)
-    complete_reply = QtCore.Signal(object)
-    inspect_reply = QtCore.Signal(object)
-    history_reply = QtCore.Signal(object)
-    kernel_info_reply = QtCore.Signal(object)
-
-    def call_handlers(self, msg):
-        """ Reimplemented to emit signals instead of making callbacks.
-        """
-        # Emit the generic signal.
-        self.message_received.emit(msg)
-
-        # Emit signals for specialized message types.
-        msg_type = msg['header']['msg_type']
-        if msg_type == 'kernel_info_reply':
-            self._handle_kernel_info_reply(msg)
-
-        signal = getattr(self, msg_type, None)
-        if signal:
-            signal.emit(msg)
-
-class QtInProcessIOPubChannel(ChannelQObject, InProcessIOPubChannel):
-    # Emitted when a message of type 'stream' is received.
-    stream_received = QtCore.Signal(object)
-
-    # Emitted when a message of type 'execute_input' is received.
-    execute_input_received = QtCore.Signal(object)
-
-    # Emitted when a message of type 'execute_result' is received.
-    execute_result_received = QtCore.Signal(object)
-
-    # Emitted when a message of type 'error' is received.
-    error_received = QtCore.Signal(object)
-
-    # Emitted when a message of type 'display_data' is received
-    display_data_received = QtCore.Signal(object)
-
-    # Emitted when a crash report message is received from the kernel's
-    # last-resort sys.excepthook.
-    crash_received = QtCore.Signal(object)
-
-    # Emitted when a shutdown is noticed.
-    shutdown_reply_received = QtCore.Signal(object)
-
-    #---------------------------------------------------------------------------
-    # 'IOPubChannel' interface
-    #---------------------------------------------------------------------------
-
-    def call_handlers(self, msg):
-        """ Reimplemented to emit signals instead of making callbacks.
-        """
-        # Emit the generic signal.
-        self.message_received.emit(msg)
-        # Emit signals for specialized message types.
-        msg_type = msg['header']['msg_type']
-        signal = getattr(self, msg_type + '_received', None)
-        if signal:
-            signal.emit(msg)
-        elif msg_type in ('stdout', 'stderr'):
-            self.stream_received.emit(msg)
-
-    def flush(self):
-        """ Reimplemented to ensure that signals are dispatched immediately.
-        """
-        super(QtInProcessIOPubChannel, self).flush()
-        QtCore.QCoreApplication.instance().processEvents()
-
-class QtInProcessStdInChannel(ChannelQObject, InProcessStdInChannel):
-    # Emitted when an input request is received.
-    input_requested = QtCore.Signal(object)
-
-    def call_handlers(self, msg):
-        """ Reimplemented to emit signals instead of making callbacks.
-        """
-        # Emit the generic signal.
-        self.message_received.emit(msg)
-
-        # Emit signals for specialized message types.
-        msg_type = msg['header']['msg_type']
-        if msg_type == 'input_request':
-            self.input_requested.emit(msg)
+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(QtInProcessIOPubChannel)
-    shell_channel_class = Type(QtInProcessShellChannel)
-    stdin_channel_class = Type(QtInProcessStdInChannel)
+    iopub_channel_class = Type(QtInProcessChannel)
+    shell_channel_class = Type(QtInProcessChannel)
+    stdin_channel_class = Type(QtInProcessChannel)
     hb_channel_class = Type(QtInProcessHBChannel)
 
 class QtInProcessKernelManager(QtKernelManagerMixin, InProcessKernelManager):
     client_class = __module__ + '.QtInProcessKernelClient'

IPython/qt/kernel_mixins.py

@@ -1,104 +1,105 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)
 
-    #---------------------------------------------------------------------------
-    # Channel interface
-    #---------------------------------------------------------------------------
-
     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()
 
-    #---------------------------------------------------------------------------
-    # 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 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()