add check_version utility

using LooseVersion and explicitly catching TypeError, rather than the NumericalVersion subclass.

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 NumericalVersion as V
+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 V(PySide.__version__) < V('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 V(QtCore.PYQT_VERSION_STR) < V('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 V(QtCore.PYQT_VERSION_STR) < V('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 V(PySide.__version__) < V('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,88 +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 NumericalVersion as V
+from IPython.utils.version import check_version
 
 matplotlib = sys.modules.get('matplotlib')
-if matplotlib and V(matplotlib.__version__) <= V('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
 

IPython/utils/version.py

@@ -1,56 +1,69 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
 #-----------------------------------------------------------------------------
 
 class NumericalVersion(LooseVersion):
     """A version of LooseVersion that is *always* comparable
     
     String elements (of any kind!) are interpreted as infinite.
     Since these are generally only on development branches,
     that is fairly safe, even though technically 1.0a1 should be less than 1.0.
     """
     def parse (self, vstring):
         # I've given up on thinking I can reconstruct the version string
         # from the parsed tuple -- so I just store the string here for
         # use by __str__
         self.vstring = vstring
         components = filter(lambda x: x and x != '.',
                             self.component_re.split(vstring))
         for i in range(len(components)):
             try:
                 components[i] = int(components[i])
             except ValueError:
                 # this is the only change
                 components[i] = float('inf')
 
         self.version = components
 
 def version_tuple(vs):
     """Return a tuple of numbers from a version string.
     
     'dev' 'a', 'etc' are transformed to float('inf'),
     so they will always compare positively to any
     regular integer element.
     """
     return tuple(NumericalVersion(vs).version)
     
+#
+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
+    
  No newline at end of file