IPython/qt/inprocess.py

""" 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.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 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)
    hb_channel_class = Type(QtInProcessHBChannel)

class QtInProcessKernelManager(QtKernelManagerMixin, InProcessKernelManager):
    client_class = __module__ + '.QtInProcessKernelClient'