Backport PR #2831: avoid string version comparisons in external.qt

We have learned from pyzmq that one should *always* parse version strings
before comparing them.

IPython/utils/version.py

@@ -0,0 +1,35 b''
+# encoding: utf-8
+"""
+Utilities for version comparison
+
+It is a bit ridiculous that we need these.
+"""
+
+#-----------------------------------------------------------------------------
+#  Copyright (C) 2013  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
+#-----------------------------------------------------------------------------
+
+from distutils.version import LooseVersion
+
+#-----------------------------------------------------------------------------
+# Code
+#-----------------------------------------------------------------------------
+
+def check_version(v, check):
+    """check version string v >= check
+
+    If dev/prerelease tags result in TypeError for string-number comparison,
+    it is assumed that the dependency is satisfied.
+    Users on dev branches are responsible for keeping their own packages up to date.
+    """
+    try:
+        return LooseVersion(v) >= LooseVersion(check)
+    except TypeError:
+        return True

IPython/external/qt.py

@@ -1,81 +1,81 b''
 """ A Qt API selector that can be used to switch between PyQt and PySide.
 
 This uses the ETS 4.0 selection pattern of:
 PySide first, PyQt with API v2. second.
 
 Do not use this if you need PyQt with the old QString/QVariant API.
 """
 
 import os
-
+from IPython.utils.version import check_version
 # Available APIs.
 QT_API_PYQT = 'pyqt'
 QT_API_PYSIDE = 'pyside'
 
 def prepare_pyqt4():
     # For PySide compatibility, use the new-style string API that automatically
     # converts QStrings to Unicode Python strings. Also, automatically unpack
     # QVariants to their underlying objects.
     import sip
     sip.setapi('QString', 2)
     sip.setapi('QVariant', 2)
 
 # Select Qt binding, using the QT_API environment variable if available.
 QT_API = os.environ.get('QT_API')
 if QT_API is None:
     pyside_found = False
     try:
         import PySide
-        if PySide.__version__ < '1.0.3':
+        if not check_version(PySide.__version__, '1.0.3'):
             # old PySide, fallback on PyQt
             raise ImportError
         # we can't import an incomplete pyside and pyqt4
         # this will cause a crash in sip (#1431)
         # check for complete presence before importing
         import imp
         imp.find_module("QtCore", PySide.__path__)
         imp.find_module("QtGui", PySide.__path__)
         imp.find_module("QtSvg", PySide.__path__)
         pyside_found = True
         from PySide import QtCore, QtGui, QtSvg
         QT_API = QT_API_PYSIDE
     except ImportError:
         try:
             prepare_pyqt4()
             import PyQt4
             from PyQt4 import QtCore, QtGui, QtSvg
             if pyside_found:
                 print "WARNING: PySide installation incomplete and PyQt4 " \
                       "present.\nThis will likely crash, please install " \
                       "PySide completely, remove PySide or PyQt4 or set " \
                       "the QT_API environment variable to pyqt or pyside"
-            if QtCore.PYQT_VERSION_STR < '4.7':
+            if not check_version(QtCore.PYQT_VERSION_STR, '4.7'):
                 # PyQt 4.6 has issues with null strings returning as None
                 raise ImportError
             QT_API = QT_API_PYQT
         except ImportError:
             raise ImportError('Cannot import PySide >= 1.0.3 or PyQt4 >= 4.7')
 
 elif QT_API == QT_API_PYQT:
     # Note: This must be called *before* PyQt4 is imported.
     prepare_pyqt4()
 
 # Now peform the imports.
 if QT_API == QT_API_PYQT:
     from PyQt4 import QtCore, QtGui, QtSvg
-    if QtCore.PYQT_VERSION_STR < '4.7':
+    if not check_version(QtCore.PYQT_VERSION_STR, '4.7'):
         raise ImportError("IPython requires PyQt4 >= 4.7, found %s"%QtCore.PYQT_VERSION_STR)
 
     # Alias PyQt-specific functions for PySide compatibility.
     QtCore.Signal = QtCore.pyqtSignal
     QtCore.Slot = QtCore.pyqtSlot
 
 elif QT_API == QT_API_PYSIDE:
     import PySide
-    if PySide.__version__ < '1.0.3':
+    if not check_version(PySide.__version__, '1.0.3'):
         raise ImportError("IPython requires PySide >= 1.0.3, found %s"%PySide.__version__)
     from PySide import QtCore, QtGui, QtSvg
 
 else:
     raise RuntimeError('Invalid Qt API %r, valid values are: %r or %r' %
                        (QT_API, QT_API_PYQT, QT_API_PYSIDE))

IPython/external/qt_for_kernel.py

@@ -1,87 +1,88 b''
 """ Import Qt in a manner suitable for an IPython kernel.
 
 This is the import used for the `gui=qt` or `pylab=qt` initialization.
 
 Import Priority:
 
 if matplotlib has been imported and doesn't support v2 (<= 1.0.1):
     use PyQt4 @v1
 
 Next, ask ETS' QT_API env variable
 
 if QT_API not set:
     ask matplotlib via rcParams['backend.qt4']
     if it said PyQt:
         use PyQt4 @v1
     elif it said PySide:
         use PySide
 
     else: (matplotlib said nothing)
         # this is the default path - nobody told us anything
         try:
             PyQt @v1
         except:
             fallback on PySide
 else:
     use PyQt @v2 or PySide, depending on QT_API
     because ETS doesn't work with PyQt @v1.
 
 """
 
 import os
 import sys
 
 from IPython.utils.warn import warn
+from IPython.utils.version import check_version
 
 matplotlib = sys.modules.get('matplotlib')
-if matplotlib and matplotlib.__version__ <= '1.0.1':
+if matplotlib and not check_version(matplotlib.__version__, '1.0.2'):
     # 1.0.1 doesn't support pyside or v2, so stick with PyQt @v1,
     # and ignore everything else
     from PyQt4 import QtCore, QtGui
 else:
     # ask QT_API ETS variable *first*
     QT_API = os.environ.get('QT_API', None)
     if QT_API is None:
         # QT_API not set, ask matplotlib if it was imported (e.g. `pylab=qt`)
         if matplotlib:
             mpqt = matplotlib.rcParams.get('backend.qt4', None)
         else:
             mpqt = None
         if mpqt is None:
             # matplotlib not imported or had nothing to say.
             try:
                 # default to unconfigured PyQt4
                 from PyQt4 import QtCore, QtGui
             except ImportError:
                 # fallback on PySide
                 try:
                     from PySide import QtCore, QtGui
                 except ImportError:
                     raise ImportError('Cannot import PySide or PyQt4')
         elif mpqt.lower() == 'pyqt4':
             # import PyQt4 unconfigured
             from PyQt4 import QtCore, QtGui
         elif mpqt.lower() == 'pyside':
             from PySide import QtCore, QtGui
         else:
             raise ImportError("unhandled value for backend.qt4 from matplotlib: %r"%mpqt)
     else:
         # QT_API specified, use PySide or PyQt+v2 API from external.qt
         # this means ETS is likely to be used, which requires v2
         try:
             from IPython.external.qt import QtCore, QtGui
         except ValueError as e:
             if 'API' in str(e):
                 # PyQt4 already imported, and APIv2 couldn't be set
                 # Give more meaningful message, and warn instead of raising
                 warn("""
     Assigning the ETS variable `QT_API=pyqt` implies PyQt's v2 API for
     QString and QVariant, but PyQt has already been imported
     with v1 APIs.  You should unset QT_API to work with PyQt4
     in its default mode.
 """)
                 # allow it to still work
                 from PyQt4 import QtCore, QtGui
             else:
                 raise