NF: add min version argumemt to optpkg and test

Add ability to specify minimum version of package when asking for an
optional package.

Author: matthew-brett

nibabel/optpkg.py

@@ -1,4 +1,7 @@
 """ Routines to support optional packages """
+from distutils.version import LooseVersion
+
+from .externals.six import string_types, callable
 
 try:
     import nose
@@ -10,7 +13,17 @@
 from .tripwire import TripWire
 
 
-def optional_package(name, trip_msg=None):
+def _check_pkg_version(pkg, min_version):
+    # Default version checking function
+    if isinstance(min_version, string_types):
+        min_version = LooseVersion(min_version)
+    try:
+        return min_version <= pkg.__version__
+    except AttributeError:
+        return False
+
+
+def optional_package(name, trip_msg=None, min_version=None):
     """ Return package-like thing and module setup for package `name`
 
     Parameters
@@ -19,8 +32,14 @@ def optional_package(name, trip_msg=None):
         package name
     trip_msg : None or str
         message to give when someone tries to use the return package, but we
-        could not import it, and have returned a TripWire object instead.
-        Default message if None.
+        could not import it at an acceptable version, and have returned a
+        TripWire object instead. Default message if None.
+    min_version : None or str or LooseVersion or callable
+        If None, do not specify a minimum version.  If str, convert to a
+        `distutils.version.LooseVersion`.  If str or LooseVersion` compare to
+        version of package `name` with ``min_version <= pkg.__version__``.   If
+        callable, accepts imported ``pkg`` as argument, and returns value of
+        callable is True for acceptable package versions, False otherwise.
 
     Returns
     -------
@@ -66,6 +85,12 @@ def optional_package(name, trip_msg=None):
     >>> hasattr(subpkg, 'dirname')
     True
     """
+    if callable(min_version):
+        check_version = min_version
+    elif min_version is None:
+        check_version = lambda pkg: True
+    else:
+        check_version = lambda pkg: _check_pkg_version(pkg, min_version)
     # fromlist=[''] results in submodule being returned, rather than the top
     # level module.  See help(__import__)
     fromlist = [''] if '.' in name else []
@@ -75,7 +100,15 @@ def optional_package(name, trip_msg=None):
         pass
     else:  # import worked
         # top level module
-        return pkg, True, lambda: None
+        if check_version(pkg):
+            return pkg, True, lambda: None
+        # Failed version check
+        if trip_msg is None:
+            if callable(min_version):
+                trip_msg = 'Package %s fails version check' % min_version
+            else:
+                trip_msg = ('These functions need %s version >= %s' %
+                            (name, min_version))
     if trip_msg is None:
         trip_msg = ('We need package %s for these functions, but '
                     '``import %s`` raised an ImportError'

nibabel/tests/test_optpkg.py

@@ -0,0 +1,70 @@
+""" Testing optpkg module
+"""
+
+import types
+import sys
+from distutils.version import LooseVersion
+
+from nose import SkipTest
+from nose.tools import (assert_true, assert_false, assert_raises,
+                        assert_equal)
+
+
+from nibabel.optpkg import optional_package
+from nibabel.tripwire import TripWire, TripWireError
+
+
+def assert_good(pkg_name, min_version=None):
+    pkg, have_pkg, setup = optional_package(pkg_name, min_version=min_version)
+    assert_true(have_pkg)
+    assert_equal(sys.modules[pkg_name], pkg)
+    assert_equal(setup(), None)
+
+
+def assert_bad(pkg_name, min_version=None):
+    pkg, have_pkg, setup = optional_package(pkg_name, min_version=min_version)
+    assert_false(have_pkg)
+    assert_true(isinstance(pkg, TripWire))
+    assert_raises(TripWireError, getattr, pkg, 'a_method')
+    assert_raises(SkipTest, setup)
+
+
+def test_basic():
+    # We always have os
+    assert_good('os')
+    # Subpackage
+    assert_good('os.path')
+    # We never have package _not_a_package
+    assert_bad('_not_a_package')
+
+
+def test_versions():
+    fake_name = '_a_fake_package'
+    fake_pkg = types.ModuleType(fake_name)
+    assert_false('fake_pkg' in sys.modules)
+    # Not inserted yet
+    assert_bad(fake_name)
+    try:
+        sys.modules[fake_name] = fake_pkg
+        # No __version__ yet
+        assert_good(fake_name)  # With no version check
+        assert_bad(fake_name, '1.0')
+        # We can make an arbitrary callable to check version
+        assert_good(fake_name, lambda pkg: True)
+        # Now add a version
+        fake_pkg.__version__ = '2.0'
+        # We have fake_pkg > 1.0
+        for min_ver in (None, '1.0', LooseVersion('1.0'), lambda pkg: True):
+            assert_good(fake_name, min_ver)
+        # We never have fake_pkg > 100.0
+        for min_ver in ('100.0', LooseVersion('100.0'), lambda pkg: False):
+            assert_bad(fake_name, min_ver)
+        # Check error string for bad version
+        pkg, _, _ = optional_package(fake_name, min_version='3.0')
+        try:
+            pkg.some_method
+        except TripWireError as err:
+            assert_equal(str(err),
+                         'These functions need _a_fake_package version >= 3.0')
+    finally:
+        del sys.modules[fake_name]