BUG: QtKernelManagerMixin does not define PyQt4-safe signals.

IPython/frontend/qt/base_kernelmanager.py

@@ -1,258 +1,260 b''
 """ Defines a KernelManager that provides signals and slots.
 """
 
 # System library imports.
 from IPython.external.qt import QtCore
 
 # IPython imports.
-from IPython.utils.traitlets import Type
-from util import SuperQObject
+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()
 
     #---------------------------------------------------------------------------
     # EmbeddedChannel 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)
     object_info_reply = QtCore.Signal(object)
     history_reply = QtCore.Signal(object)
 
     # Emitted when the first reply comes back.
     first_reply = QtCore.Signal()
 
     # Used by the first_reply signal logic to determine if a reply is the
     # first.
     _handlers_called = False
 
     #---------------------------------------------------------------------------
     # 'ShellSocketChannel' 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, None)
         if signal:
             signal.emit(msg)
 
         if not self._handlers_called:
             self.first_reply.emit()
             self._handlers_called = True
 
     #---------------------------------------------------------------------------
     # 'QtShellChannelMixin' interface
     #---------------------------------------------------------------------------
 
     def reset_first_reply(self):
         """ Reset the first_reply signal to fire again on the next reply.
         """
         self._handlers_called = False
 
 
 class QtSubChannelMixin(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 'pyin' is received.
     pyin_received = QtCore.Signal(object)
 
     # Emitted when a message of type 'pyout' is received.
     pyout_received = QtCore.Signal(object)
 
     # Emitted when a message of type 'pyerr' is received.
     pyerr_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)
 
     #---------------------------------------------------------------------------
     # 'SubSocketChannel' 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(QtSubChannelMixin, 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)
 
     #---------------------------------------------------------------------------
     # 'StdInSocketChannel' 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)
 
     #---------------------------------------------------------------------------
     # 'HBSocketChannel' 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 QtKernelManagerMixin(object):
+class QtKernelManagerMixin(HasTraits, SuperQObject):
     """ A KernelManager that provides signals and slots.
     """
 
+    __metaclass__ = MetaQObjectHasTraits
+
     # Emitted when the kernel manager has started listening.
     started_kernel = QtCore.Signal()
 
     # Emitted when the kernel manager has started listening.
     started_channels = QtCore.Signal()
 
     # Emitted when the kernel manager has stopped listening.
     stopped_channels = QtCore.Signal()
 
     # Use Qt-specific channel classes that emit signals.
     sub_channel_class = Type(QtSubChannelMixin)
     shell_channel_class = Type(QtShellChannelMixin)
     stdin_channel_class = Type(QtStdInChannelMixin)
     hb_channel_class = Type(QtHBChannelMixin)
 
     #---------------------------------------------------------------------------
     # 'KernelManager' interface
     #---------------------------------------------------------------------------
 
     #------ Kernel process management ------------------------------------------
 
     def start_kernel(self, *args, **kw):
         """ Reimplemented for proper heartbeat management.
         """
         if self._shell_channel is not None:
             self._shell_channel.reset_first_reply()
         super(QtKernelManagerMixin, self).start_kernel(*args, **kw)
         self.started_kernel.emit()
 
     #------ Channel management -------------------------------------------------
 
     def start_channels(self, *args, **kw):
         """ Reimplemented to emit signal.
         """
         super(QtKernelManagerMixin, self).start_channels(*args, **kw)
         self.started_channels.emit()
 
     def stop_channels(self):
         """ Reimplemented to emit signal.
         """
         super(QtKernelManagerMixin, self).stop_channels()
         self.stopped_channels.emit()
 
     @property
     def shell_channel(self):
         """ Reimplemented for proper heartbeat management.
         """
         if self._shell_channel is None:
             self._shell_channel = super(QtKernelManagerMixin,self).shell_channel
             self._shell_channel.first_reply.connect(self._first_reply)
         return self._shell_channel
 
     #---------------------------------------------------------------------------
     # Protected interface
     #---------------------------------------------------------------------------
 
     def _first_reply(self):
         """ Unpauses the heartbeat channel when the first reply is received on
             the execute channel. Note that this will *not* start the heartbeat
             channel if it is not already running!
         """
         if self._hb_channel is not None:
             self._hb_channel.unpause()

IPython/frontend/qt/embedded_kernelmanager.py

@@ -1,37 +1,33 b''
 """ Defines an embedded KernelManager that provides signals and slots.
 """
 
 # Local imports.
 from IPython.embedded.kernelmanager import \
     ShellEmbeddedChannel, SubEmbeddedChannel, StdInEmbeddedChannel, \
     HBEmbeddedChannel, EmbeddedKernelManager
 from IPython.utils.traitlets import Type
 from base_kernelmanager import QtShellChannelMixin, QtSubChannelMixin, \
     QtStdInChannelMixin, QtHBChannelMixin, QtKernelManagerMixin
-from util import MetaQObjectHasTraits, SuperQObject
 
 
 class QtShellEmbeddedChannel(QtShellChannelMixin, ShellEmbeddedChannel):
     pass
 
 class QtSubEmbeddedChannel(QtSubChannelMixin, SubEmbeddedChannel):
     pass
 
 class QtStdInEmbeddedChannel(QtStdInChannelMixin, StdInEmbeddedChannel):
     pass
 
 class QtHBEmbeddedChannel(QtHBChannelMixin, HBEmbeddedChannel):
     pass
 
 
-class QtEmbeddedKernelManager(QtKernelManagerMixin,
-                              EmbeddedKernelManager, SuperQObject):
+class QtEmbeddedKernelManager(QtKernelManagerMixin, EmbeddedKernelManager):
     """ An embedded KernelManager that provides signals and slots.
     """
 
-    __metaclass__ = MetaQObjectHasTraits
-
     sub_channel_class = Type(QtSubEmbeddedChannel)
     shell_channel_class = Type(QtShellEmbeddedChannel)
     stdin_channel_class = Type(QtStdInEmbeddedChannel)
     hb_channel_class = Type(QtHBEmbeddedChannel)

IPython/frontend/qt/kernelmanager.py

@@ -1,35 +1,32 b''
 """ Defines a KernelManager that provides signals and slots.
 """
 
 # Local imports.
 from IPython.utils.traitlets import Type
 from IPython.zmq.kernelmanager import ShellSocketChannel, SubSocketChannel, \
     StdInSocketChannel, HBSocketChannel, KernelManager
 from base_kernelmanager import QtShellChannelMixin, QtSubChannelMixin, \
     QtStdInChannelMixin, QtHBChannelMixin, QtKernelManagerMixin
-from util import MetaQObjectHasTraits, SuperQObject
 
 
 class QtShellSocketChannel(QtShellChannelMixin, ShellSocketChannel):
     pass
 
 class QtSubSocketChannel(QtSubChannelMixin, SubSocketChannel):
     pass
 
 class QtStdInSocketChannel(QtStdInChannelMixin, StdInSocketChannel):
     pass
 
 class QtHBSocketChannel(QtHBChannelMixin, HBSocketChannel):
     pass
 
 
-class QtKernelManager(QtKernelManagerMixin, KernelManager, SuperQObject):
+class QtKernelManager(QtKernelManagerMixin, KernelManager):
     """ A KernelManager that provides signals and slots.
     """
 
-    __metaclass__ = MetaQObjectHasTraits
-
     sub_channel_class = Type(QtSubSocketChannel)
     shell_channel_class = Type(QtShellSocketChannel)
     stdin_channel_class = Type(QtStdInSocketChannel)
     hb_channel_class = Type(QtHBSocketChannel)

IPython/frontend/qt/util.py

@@ -1,106 +1,106 b''
 """ Defines miscellaneous Qt-related helper classes and functions.
 """
 
 # Standard library imports.
 import inspect
 
 # System library imports.
 from IPython.external.qt import QtCore, QtGui
 
 # IPython imports.
 from IPython.utils.traitlets import HasTraits, TraitType
 
 #-----------------------------------------------------------------------------
 # Metaclasses
 #-----------------------------------------------------------------------------
 
 MetaHasTraits = type(HasTraits)
 MetaQObject = type(QtCore.QObject)
 
 class MetaQObjectHasTraits(MetaQObject, MetaHasTraits):
     """ A metaclass that inherits from the metaclasses of HasTraits and QObject.
 
     Using this metaclass allows a class to inherit from both HasTraits and
     QObject. Using SuperQObject instead of QObject is highly recommended. See
     QtKernelManager for an example.
     """
     def __new__(mcls, name, bases, classdict):
         # FIXME: this duplicates the code from MetaHasTraits.
         # I don't think a super() call will help me here.
         for k,v in classdict.iteritems():
             if isinstance(v, TraitType):
                 v.name = k
             elif inspect.isclass(v):
                 if issubclass(v, TraitType):
                     vinst = v()
                     vinst.name = k
                     classdict[k] = vinst
         cls = MetaQObject.__new__(mcls, name, bases, classdict)
         return cls
 
     def __init__(mcls, name, bases, classdict):
         # Note: super() did not work, so we explicitly call these.
         MetaQObject.__init__(mcls, name, bases, classdict)
         MetaHasTraits.__init__(mcls, name, bases, classdict)
 
 #-----------------------------------------------------------------------------
 # Classes
 #-----------------------------------------------------------------------------
 
 class SuperQObject(QtCore.QObject):
     """ Permits the use of super() in class hierarchies that contain QObject.
 
     Unlike QObject, SuperQObject does not accept a QObject parent. If it did,
     super could not be emulated properly (all other classes in the heierarchy
     would have to accept the parent argument--they don't, of course, because
     they don't inherit QObject.)
 
     This class is primarily useful for attaching signals to existing non-Qt
-    classes. See QtKernelManager for an example.
+    classes. See QtKernelManagerMixin for an example.
     """
 
     def __new__(cls, *args, **kw):
         # We initialize QObject as early as possible. Without this, Qt complains
         # if SuperQObject is not the first class in the super class list.
         inst = QtCore.QObject.__new__(cls)
         QtCore.QObject.__init__(inst)
         return inst
 
     def __init__(self, *args, **kw):
         # Emulate super by calling the next method in the MRO, if there is one.
         mro = self.__class__.mro()
         for qt_class in QtCore.QObject.mro():
             mro.remove(qt_class)
         next_index = mro.index(SuperQObject) + 1
         if next_index < len(mro):
             mro[next_index].__init__(self, *args, **kw)
 
 #-----------------------------------------------------------------------------
 # Functions
 #-----------------------------------------------------------------------------
 
 def get_font(family, fallback=None):
     """Return a font of the requested family, using fallback as alternative.
 
     If a fallback is provided, it is used in case the requested family isn't
     found.  If no fallback is given, no alternative is chosen and Qt's internal
     algorithms may automatically choose a fallback font.
 
     Parameters
     ----------
     family : str
       A font name.
     fallback : str
       A font name.
 
     Returns
     -------
     font : QFont object
     """
     font = QtGui.QFont(family)
     # Check whether we got what we wanted using QFontInfo, since exactMatch()
     # is overly strict and returns false in too many cases.
     font_info = QtGui.QFontInfo(font)
     if fallback is not None and font_info.family() != family:
         font = QtGui.QFont(fallback)
     return font