Merge pull request #441 from matthew-brett/fix-travis-tests

MRG: change to get travis tests passing again.

Exclude shim module from flake8 tests.

Adapt to new numpy 1.12 memmap behavior.

Author: matthew-brett

nibabel/pydicom_compat.py

@@ -13,6 +13,9 @@
 * dicom_test : test decorator that skips test if dicom not available.
 """
 
+# Module does (apparently) unused imports; stop flake8 complaining
+# flake8: noqa
+
 import numpy as np
 
 have_dicom = True

nibabel/testing/__init__.py

@@ -29,6 +29,8 @@
 data_path = abspath(pjoin(dirname(__file__), '..', 'tests', 'data'))
 
 
+from .np_features import VIRAL_MEMMAP
+
 def assert_dt_equal(a, b):
     """ Assert two numpy dtype specifiers are equal
 

nibabel/testing/np_features.py

@@ -0,0 +1,19 @@
+""" Look for changes in numpy behavior over versions
+"""
+
+import numpy as np
+
+
+def _memmap_after_ufunc():
+    """ Return True if ufuncs on memmap arrays always return memmap arrays
+
+    This should be True for numpy < 1.12, False otherwise.
+    """
+    with open(__file__, 'rb') as fobj:
+        mm_arr = np.memmap(fobj, mode='r', shape=(10,), dtype=np.uint8)
+        mm_preserved = isinstance(mm_arr + 1, np.memmap)
+    return mm_preserved
+
+
+# True if ufunc on memmap always returns a memmap
+VIRAL_MEMMAP = _memmap_after_ufunc()

nibabel/tests/test_arrayproxy.py

@@ -23,6 +23,7 @@
 from numpy.testing import assert_array_equal, assert_array_almost_equal
 from nose.tools import (assert_true, assert_false, assert_equal,
                         assert_not_equal, assert_raises)
+from nibabel.testing import VIRAL_MEMMAP
 
 from .test_fileslice import slicer_samples
 
@@ -182,10 +183,37 @@ def test_mmap():
     check_mmap(hdr, hdr.get_data_offset(), ArrayProxy)
 
 
-def check_mmap(hdr, offset, proxy_class, check_mode=True):
+def check_mmap(hdr, offset, proxy_class,
+               has_scaling=False,
+               unscaled_is_view=True):
+    """ Assert that array proxies return memory maps as expected
+
+    Parameters
+    ----------
+    hdr : object
+        Image header instance
+    offset : int
+        Offset in bytes of image data in file (that we will write)
+    proxy_class : class
+        Class of image array proxy to test
+    has_scaling : {False, True}
+        True if the `hdr` says to apply scaling to the output data, False
+        otherwise.
+    unscaled_is_view : {True, False}
+        True if getting the unscaled data returns a view of the array.  If
+        False, then type of returned array will depend on whether numpy has the
+        old viral (< 1.12) memmap behavior (returns memmap) or the new behavior
+        (returns ndarray).  See: https://github.com/numpy/numpy/pull/7406
+    """
     shape = hdr.get_data_shape()
     arr = np.arange(np.prod(shape), dtype=hdr.get_data_dtype()).reshape(shape)
     fname = 'test.bin'
+    # Whether unscaled array memory backed by memory map (regardless of what
+    # numpy says).
+    unscaled_really_mmap = unscaled_is_view
+    # Whether scaled array memory backed by memory map (regardless of what
+    # numpy says).
+    scaled_really_mmap = unscaled_really_mmap and not has_scaling
     with InTemporaryDirectory():
         with open(fname, 'wb') as fobj:
             fobj.write(b' ' * offset)
@@ -205,13 +233,17 @@ def check_mmap(hdr, offset, proxy_class, check_mode=True):
             prox = proxy_class(fname, hdr, **kwargs)
             unscaled = prox.get_unscaled()
             back_data = np.asanyarray(prox)
+            unscaled_is_mmap = isinstance(unscaled, np.memmap)
+            back_is_mmap =  isinstance(back_data, np.memmap)
             if expected_mode is None:
-                assert_false(isinstance(unscaled, np.memmap))
-                assert_false(isinstance(back_data, np.memmap))
+                assert_false(unscaled_is_mmap)
+                assert_false(back_is_mmap)
             else:
-                assert_true(isinstance(unscaled, np.memmap))
-                assert_true(isinstance(back_data, np.memmap))
-                if check_mode:
+                assert_equal(unscaled_is_mmap,
+                             VIRAL_MEMMAP or unscaled_really_mmap)
+                assert_equal(back_is_mmap,
+                             VIRAL_MEMMAP or scaled_really_mmap)
+                if scaled_really_mmap:
                     assert_equal(back_data.mode, expected_mode)
             del prox, back_data
             # Check that mmap is keyword-only

nibabel/tests/test_parrec.py

@@ -728,15 +728,18 @@ def test_parrec_proxy():
     # Test PAR / REC proxy class, including mmap flags
     shape = (10, 20, 30, 5)
     hdr = FakeHeader(shape, np.int32)
-    check_mmap(hdr, 0, PARRECArrayProxy, check_mode=False)
+    check_mmap(hdr, 0, PARRECArrayProxy,
+               has_scaling=True,
+               unscaled_is_view=False)
 
 
 class TestPARRECImage(tsi.MmapImageMixin):
     image_class = PARRECImage
     check_mmap_mode = False
 
-    def write_image(self):
-        return parrec.load(EG_PAR), EG_PAR
+    def get_disk_image(self):
+        # The example image does have image scaling to apply
+        return parrec.load(EG_PAR), EG_PAR, True
 
 
 def test_bitpix():

nibabel/tests/test_spatialimages.py

@@ -24,7 +24,8 @@
 from numpy.testing import assert_array_equal, assert_array_almost_equal
 
 from .test_helpers import bytesio_round_trip
-from ..testing import clear_and_catch_warnings, suppress_warnings
+from ..testing import (clear_and_catch_warnings, suppress_warnings,
+                       VIRAL_MEMMAP)
 from ..tmpdirs import InTemporaryDirectory
 from .. import load as top_load
 
@@ -340,23 +341,34 @@ class MmapImageMixin(object):
     #: whether to test mode of returned memory map
     check_mmap_mode = True
 
-    def write_image(self):
-        """ Return an image and an image filname to test against
+    def get_disk_image(self):
+        """ Return image, image filename, and flag for required scaling
+
+        Subclasses can do anything to return an image, including loading a
+        pre-existing image from disk.
+
+        Returns
+        -------
+        img : class:`SpatialImage` instance
+        fname : str
+            Image filename.
+        has_scaling : bool
+            True if the image array has scaling to apply to the raw image array
+            data, False otherwise.
         """
         img_klass = self.image_class
         shape = (3, 4, 2)
         data = np.arange(np.prod(shape), dtype=np.int16).reshape(shape)
         img = img_klass(data, None)
         fname = 'test' + img_klass.files_types[0][1]
         img.to_filename(fname)
-        return img, fname
+        return img, fname, False
 
     def test_load_mmap(self):
         # Test memory mapping when loading images
         img_klass = self.image_class
         with InTemporaryDirectory():
-            # This should have no scaling, can be mmapped
-            img, fname = self.write_image()
+            img, fname, has_scaling = self.get_disk_image()
             file_map = img.file_map.copy()
             for func, param1 in ((img_klass.from_filename, fname),
                                  (img_klass.load, fname),
@@ -371,6 +383,13 @@ def test_load_mmap(self):
                         ('c', 'c'),
                         ('r', 'r'),
                         (False, None)):
+                    # If the image has scaling, then numpy 1.12 will not return
+                    # a memmap, regardless of the input flags.  Previous
+                    # numpies returned a memmap object, even though the array
+                    # has no mmap memory backing.  See:
+                    # https://github.com/numpy/numpy/pull/7406
+                    if has_scaling and not VIRAL_MEMMAP:
+                        expected_mode = None
                     kwargs = {}
                     if mmap is not None:
                         kwargs['mmap'] = mmap