Remove some big unhelpful comment blocks

IPython/qt/kernel_mixins.py

@@ -1,217 +1,196 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()
 
-    #---------------------------------------------------------------------------
-    # 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 process_events(self):
         """ Process any pending GUI events.
         """
         QtCore.QCoreApplication.instance().processEvents()
 
 
 class QtShellChannelMixin(ChannelQObject):
 
     # Emitted when any message is received.
     message_received = QtCore.Signal(object)
 
     # 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)
 
-    #---------------------------------------------------------------------------
-    # 'ShellChannel' 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']
         if msg_type == 'kernel_info_reply':
             self._handle_kernel_info_reply(msg)
         
         signal = getattr(self, msg_type, None)
         if signal:
             signal.emit(msg)
 
 
 class QtIOPubChannelMixin(ChannelQObject):
 
     # Emitted when any message is received.
     message_received = QtCore.Signal(object)
 
     # 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)
 
     def flush(self):
         """ Reimplemented to ensure that signals are dispatched immediately.
         """
         super(QtIOPubChannelMixin, self).flush()
         QtCore.QCoreApplication.instance().processEvents()
 
 
 class QtStdInChannelMixin(ChannelQObject):
 
     # Emitted when any message is received.
     message_received = QtCore.Signal(object)
 
     # Emitted when an input request is received.
     input_requested = QtCore.Signal(object)
 
-    #---------------------------------------------------------------------------
-    # 'StdInChannel' 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']
         if msg_type == 'input_request':
             self.input_requested.emit(msg)
 
 
 class QtHBChannelMixin(ChannelQObject):
 
     # Emitted when the kernel has died.
     kernel_died = QtCore.Signal(object)
 
-    #---------------------------------------------------------------------------
-    # 'HBChannel' interface
-    #---------------------------------------------------------------------------
-
     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)
 
 
 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()
 
     # Use Qt-specific channel classes that emit signals.
     iopub_channel_class = Type(QtIOPubChannelMixin)
     shell_channel_class = Type(QtShellChannelMixin)
     stdin_channel_class = Type(QtStdInChannelMixin)
     hb_channel_class = Type(QtHBChannelMixin)
 
     #---------------------------------------------------------------------------
     # '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()