TEST: Suppress expected warnings

Author: effigies

nibabel/tests/test_analyze.py

@@ -734,9 +734,11 @@ def test_data_hdr_cache(self):
         assert_array_equal(np.asanyarray(img2.dataobj), data)
         # now check read_img_data function - here we do see the changed
         # header
-        sc_data = read_img_data(img2)
+        with pytest.deprecated_call():
+            sc_data = read_img_data(img2)
         assert sc_data.shape == (3, 2, 2)
-        us_data = read_img_data(img2, prefer='unscaled')
+        with pytest.deprecated_call():
+            us_data = read_img_data(img2, prefer='unscaled')
         assert us_data.shape == (3, 2, 2)
 
     def test_affine_44(self):

nibabel/tests/test_deprecated.py

@@ -2,6 +2,7 @@
 """
 
 import warnings
+import pytest
 
 from nibabel import pkg_info
 from nibabel.deprecated import (ModuleProxy, FutureWarningMixin,
@@ -77,6 +78,7 @@ def func():
     try:
         pkg_info.cmp_pkg_version.__defaults__ = ('2.0dev',)
         # No error, even though version is dev version of current
-        assert func() == 99
+        with pytest.deprecated_call():
+            assert func() == 99
     finally:
         pkg_info.cmp_pkg_version.__defaults__ = ('2.0',)

nibabel/tests/test_ecat.py

@@ -239,6 +239,11 @@ def test_isolation(self):
         aff[0, 0] = 99
         assert not np.all(img.affine == aff)
 
+    def test_get_affine_deprecated(self):
+        with pytest.deprecated_call():
+            aff = self.img.get_affine()
+        assert np.array_equal(aff, self.img.affine)
+
     def test_float_affine(self):
         # Check affines get converted to float
         img_klass = self.image_class
@@ -248,9 +253,9 @@ def test_float_affine(self):
                                          self.img.get_subheaders(),
                                          self.img.get_mlist())
         img = img_klass(arr, aff.astype(np.float32), hdr, sub_hdr, mlist)
-        assert img.get_affine().dtype == np.dtype(np.float64)
+        assert img.affine.dtype == np.dtype(np.float64)
         img = img_klass(arr, aff.astype(np.int16), hdr, sub_hdr, mlist)
-        assert img.get_affine().dtype == np.dtype(np.float64)
+        assert img.affine.dtype == np.dtype(np.float64)
 
     def test_data_regression(self):
         # Test whether data read has changed since 1.3.0

nibabel/tests/test_image_api.py

@@ -26,6 +26,7 @@
 import warnings
 from functools import partial
 from itertools import product
+from contextlib import nullcontext
 import pathlib
 
 import numpy as np
@@ -56,6 +57,11 @@
 from .test_parrec import EXAMPLE_IMAGES as PARREC_EXAMPLE_IMAGES
 from .test_brikhead import EXAMPLE_IMAGES as AFNI_EXAMPLE_IMAGES
 
+
+def maybe_deprecated(meth_name):
+    return pytest.deprecated_call() if meth_name =='get_data' else nullcontext()
+
+
 class GenericImageAPI(ValidateAPI):
     """ General image validation API """
     # Whether this image type can do scaling of data
@@ -221,14 +227,17 @@ def validate_data_interface(self, imaker, params):
                 self._check_proxy_interface(imaker, meth_name)
             else:  # Array image
                 self._check_array_interface(imaker, meth_name)
+            method = getattr(img, meth_name)
             # Data shape is same as image shape
-            assert img.shape == getattr(img, meth_name)().shape
+            with maybe_deprecated(meth_name):
+                assert img.shape == method().shape
             # Data ndim is same as image ndim
-            assert img.ndim == getattr(img, meth_name)().ndim
+            with maybe_deprecated(meth_name):
+                assert img.ndim == method().ndim
             # Values to get_data caching parameter must be 'fill' or
             # 'unchanged'
-            with pytest.raises(ValueError):
-                img.get_data(caching='something')
+            with maybe_deprecated(meth_name), pytest.raises(ValueError):
+                method(caching='something')
         # dataobj is read only
         fake_data = np.zeros(img.shape).astype(img.get_data_dtype())
         with pytest.raises(AttributeError):
@@ -251,11 +260,13 @@ def _check_proxy_interface(self, imaker, meth_name):
         assert not img.in_memory
         # Load with caching='unchanged'
         method = getattr(img, meth_name)
-        data = method(caching='unchanged')
+        with maybe_deprecated(meth_name):
+            data = method(caching='unchanged')
         # Still not cached
         assert not img.in_memory
         # Default load, does caching
-        data = method()
+        with maybe_deprecated(meth_name):
+            data = method()
         # Data now cached. in_memory is True if either of the get_data
         # or get_fdata caches are not-None
         assert img.in_memory
@@ -267,30 +278,36 @@ def _check_proxy_interface(self, imaker, meth_name):
         # integers, but lets assume that's not true here.
         assert_array_equal(proxy_data, data)
         # Now caching='unchanged' does nothing, returns cached version
-        data_again = method(caching='unchanged')
+        with maybe_deprecated(meth_name):
+            data_again = method(caching='unchanged')
         assert data is data_again
         # caching='fill' does nothing because the cache is already full
-        data_yet_again = method(caching='fill')
+        with maybe_deprecated(meth_name):
+            data_yet_again = method(caching='fill')
         assert data is data_yet_again
         # changing array data does not change proxy data, or reloaded
         # data
         data[:] = 42
         assert_array_equal(proxy_data, proxy_copy)
         assert_array_equal(np.asarray(img.dataobj), proxy_copy)
         # It does change the result of get_data
-        assert_array_equal(method(), 42)
+        with maybe_deprecated(meth_name):
+            assert_array_equal(method(), 42)
         # until we uncache
         img.uncache()
         # Which unsets in_memory
         assert not img.in_memory
-        assert_array_equal(method(), proxy_copy)
+        with maybe_deprecated(meth_name):
+            assert_array_equal(method(), proxy_copy)
         # Check caching='fill' does cache data
         img = imaker()
         method = getattr(img, meth_name)
         assert not img.in_memory
-        data = method(caching='fill')
+        with maybe_deprecated(meth_name):
+            data = method(caching='fill')
         assert img.in_memory
-        data_again = method()
+        with maybe_deprecated(meth_name):
+            data_again = method()
         assert data is data_again
         # Check the interaction of caching with get_data, get_fdata.
         # Caching for `get_data` should have no effect on caching for
@@ -300,14 +317,17 @@ def _check_proxy_interface(self, imaker, meth_name):
         # Load using the other data fetch method
         other_name = set(self.meth_names).difference({meth_name}).pop()
         other_method = getattr(img, other_name)
-        other_data = other_method()
+        with maybe_deprecated(other_name):
+            other_data = other_method()
         # We get the original data, not the modified cache
         assert_array_equal(proxy_data, other_data)
         assert not np.all(data == other_data)
         # We can modify the other cache, without affecting the first
         other_data[:] = 44
-        assert_array_equal(other_method(), 44)
-        assert not np.all(method() == other_method())
+        with maybe_deprecated(other_name):
+            assert_array_equal(other_method(), 44)
+        with pytest.deprecated_call():
+            assert not np.all(method() == other_method())
         if meth_name != 'get_fdata':
             return
         # Check that caching refreshes for new floating point type.
@@ -353,31 +373,34 @@ def _check_array_caching(self, imaker, meth_name, caching):
                          partial(method, caching=caching))
         assert isinstance(img.dataobj, np.ndarray)
         assert img.in_memory
-        data = get_data_func()
+        with maybe_deprecated(meth_name):
+            data = get_data_func()
         # Returned data same object as underlying dataobj if using
         # old ``get_data`` method, or using newer ``get_fdata``
         # method, where original array was float64.
         arr_dtype = img.dataobj.dtype
         dataobj_is_data = arr_dtype == np.float64 or method == img.get_data
         # Set something to the output array.
         data[:] = 42
-        get_result_changed = np.all(get_data_func() == 42)
-        assert (get_result_changed ==
-                     (dataobj_is_data or caching != 'unchanged'))
+        with maybe_deprecated(meth_name):
+            get_result_changed = np.all(get_data_func() == 42)
+        assert get_result_changed == (dataobj_is_data or caching != 'unchanged')
         if dataobj_is_data:
             assert data is img.dataobj
             # Changing array data changes
             # data
             assert_array_equal(np.asarray(img.dataobj), 42)
             # Uncache has no effect
             img.uncache()
-            assert_array_equal(get_data_func(), 42)
+            with maybe_deprecated(meth_name):
+                assert_array_equal(get_data_func(), 42)
         else:
             assert not data is img.dataobj
             assert not np.all(np.asarray(img.dataobj) == 42)
             # Uncache does have an effect
             img.uncache()
-            assert not np.all(get_data_func() == 42)
+            with maybe_deprecated(meth_name):
+                assert not np.all(get_data_func() == 42)
         # in_memory is always true for array images, regardless of
         # cache state.
         img.uncache()
@@ -390,7 +413,8 @@ def _check_array_caching(self, imaker, meth_name, caching):
         if arr_dtype not in float_types:
             return
         for float_type in float_types:
-            data = get_data_func(dtype=float_type)
+            with maybe_deprecated(meth_name):
+                data = get_data_func(dtype=float_type)
             assert (data is img.dataobj) == (arr_dtype == float_type)
 
     def validate_data_deprecated(self, imaker, params):
@@ -711,7 +735,7 @@ class TestMinc1API(ImageHeaderAPI):
 
 class TestMinc2API(TestMinc1API):
 
-    def __init__(self):
+    def setup(self):
         if not have_h5py:
             raise unittest.SkipTest('Need h5py for these tests')
 

nibabel/tests/test_image_load_save.py

@@ -13,6 +13,7 @@
 from os.path import dirname, join as pjoin
 from tempfile import mkdtemp
 import pathlib
+import logging
 
 import numpy as np
 
@@ -42,7 +43,7 @@ def round_trip(img):
     return Nifti1Image.from_bytes(img.to_bytes())
 
 
-def test_conversion_spatialimages():
+def test_conversion_spatialimages(caplog):
     shape = (2, 4, 6)
     affine = np.diag([1, 2, 3, 1])
     klasses = [klass for klass in all_image_classes
@@ -57,7 +58,9 @@ def test_conversion_spatialimages():
             for w_class in klasses:
                 if not w_class.makeable:
                     continue
-                img2 = w_class.from_image(img)
+                # Suppress header field mismatch reports
+                with caplog.at_level(logging.CRITICAL):
+                    img2 = w_class.from_image(img)
                 assert_array_equal(img2.get_fdata(), data)
                 assert_array_equal(img2.affine, affine)
 
@@ -271,7 +274,8 @@ def test_analyze_detection():
     # Test detection of Analyze, Nifti1 and Nifti2
     # Algorithm is as described in loadsave:which_analyze_type
     def wat(hdr):
-        return nils.which_analyze_type(hdr.binaryblock)
+        with pytest.deprecated_call():
+            return nils.which_analyze_type(hdr.binaryblock)
     n1_hdr = Nifti1Header(b'\0' * 348, check=False)
     assert wat(n1_hdr) is None
     n1_hdr['sizeof_hdr'] = 540
@@ -300,14 +304,15 @@ def wat(hdr):
 
 def test_guessed_image_type():
     # Test whether we can guess the image type from example files
-    assert nils.guessed_image_type(pjoin(DATA_PATH, 'example4d.nii.gz')) == Nifti1Image
-    assert nils.guessed_image_type(pjoin(DATA_PATH, 'nifti1.hdr')) == Nifti1Pair
-    assert nils.guessed_image_type(pjoin(DATA_PATH, 'example_nifti2.nii.gz')) == Nifti2Image
-    assert nils.guessed_image_type(pjoin(DATA_PATH, 'nifti2.hdr')) == Nifti2Pair
-    assert nils.guessed_image_type(pjoin(DATA_PATH, 'tiny.mnc')) == Minc1Image
-    assert nils.guessed_image_type(pjoin(DATA_PATH, 'small.mnc')) == Minc2Image
-    assert nils.guessed_image_type(pjoin(DATA_PATH, 'test.mgz')) == MGHImage
-    assert nils.guessed_image_type(pjoin(DATA_PATH, 'analyze.hdr')) == Spm2AnalyzeImage
+    with pytest.deprecated_call():
+        assert nils.guessed_image_type(pjoin(DATA_PATH, 'example4d.nii.gz')) == Nifti1Image
+        assert nils.guessed_image_type(pjoin(DATA_PATH, 'nifti1.hdr')) == Nifti1Pair
+        assert nils.guessed_image_type(pjoin(DATA_PATH, 'example_nifti2.nii.gz')) == Nifti2Image
+        assert nils.guessed_image_type(pjoin(DATA_PATH, 'nifti2.hdr')) == Nifti2Pair
+        assert nils.guessed_image_type(pjoin(DATA_PATH, 'tiny.mnc')) == Minc1Image
+        assert nils.guessed_image_type(pjoin(DATA_PATH, 'small.mnc')) == Minc2Image
+        assert nils.guessed_image_type(pjoin(DATA_PATH, 'test.mgz')) == MGHImage
+        assert nils.guessed_image_type(pjoin(DATA_PATH, 'analyze.hdr')) == Spm2AnalyzeImage
 
 
 def test_fail_save():

nibabel/tests/test_loadsave.py

@@ -42,13 +42,15 @@ def test_read_img_data():
             fpath = pathlib.Path(fpath)
         img = load(fpath)
         data = img.get_fdata()
-        data2 = read_img_data(img)
+        with pytest.deprecated_call():
+            data2 = read_img_data(img)
         assert_array_equal(data, data2)
         # These examples have null scaling - assert prefer=unscaled is the same
         dao = img.dataobj
         if hasattr(dao, 'slope') and hasattr(img.header, 'raw_data_from_fileobj'):
             assert (dao.slope, dao.inter) == (1, 0)
-            assert_array_equal(read_img_data(img, prefer='unscaled'), data)
+            with pytest.deprecated_call():
+                assert_array_equal(read_img_data(img, prefer='unscaled'), data)
         # Assert all caps filename works as well
         with TemporaryDirectory() as tmpdir:
             up_fpath = pjoin(tmpdir, str(fname).upper())
@@ -86,21 +88,22 @@ def test_read_img_data_nifti():
             img = img_class(data, np.eye(4))
             img.set_data_dtype(out_dtype)
             # No filemap => error
-            with pytest.raises(ImageFileError):
+            with pytest.deprecated_call(), pytest.raises(ImageFileError):
                 read_img_data(img)
             # Make a filemap
             froot = f'an_image_{i}'
             img.file_map = img.filespec_to_file_map(froot)
             # Trying to read from this filemap will generate an error because
             # we are going to read from files that do not exist
-            with pytest.raises(IOError):
+            with pytest.deprecated_call(), pytest.raises(IOError):
                 read_img_data(img)
             img.to_file_map()
             # Load - now the scaling and offset correctly applied
             img_fname = img.file_map['image'].filename
             img_back = load(img_fname)
             data_back = img_back.get_fdata()
-            assert_array_equal(data_back, read_img_data(img_back))
+            with pytest.deprecated_call():
+                assert_array_equal(data_back, read_img_data(img_back))
             # This is the same as if we loaded the image and header separately
             hdr_fname = (img.file_map['header'].filename
                          if 'header' in img.file_map else img_fname)
@@ -112,15 +115,17 @@ def test_read_img_data_nifti():
             # Unscaled is the same as returned from raw_data_from_fileobj
             with open(img_fname, 'rb') as fobj:
                 unscaled_back = hdr_back.raw_data_from_fileobj(fobj)
-            assert_array_equal(unscaled_back,
-                               read_img_data(img_back, prefer='unscaled'))
+            with pytest.deprecated_call():
+                assert_array_equal(unscaled_back, read_img_data(img_back, prefer='unscaled'))
             # If we futz with the scaling in the header, the result changes
-            assert_array_equal(data_back, read_img_data(img_back))
+            with pytest.deprecated_call():
+                assert_array_equal(data_back, read_img_data(img_back))
             has_inter = hdr_back.has_data_intercept
             old_slope = hdr_back['scl_slope']
             old_inter = hdr_back['scl_inter'] if has_inter else 0
             est_unscaled = (data_back - old_inter) / old_slope
-            actual_unscaled = read_img_data(img_back, prefer='unscaled')
+            with pytest.deprecated_call():
+                actual_unscaled = read_img_data(img_back, prefer='unscaled')
             assert_almost_equal(est_unscaled, actual_unscaled)
             img_back.header['scl_slope'] = 2.1
             if has_inter:
@@ -129,11 +134,13 @@ def test_read_img_data_nifti():
             else:
                 new_inter = 0
             # scaled scaling comes from new parameters in header
-            assert np.allclose(actual_unscaled * 2.1 + new_inter,
-                                    read_img_data(img_back))
+            with pytest.deprecated_call():
+                assert np.allclose(actual_unscaled * 2.1 + new_inter,
+                                   read_img_data(img_back))
             # Unscaled array didn't change
-            assert_array_equal(actual_unscaled,
-                               read_img_data(img_back, prefer='unscaled'))
+            with pytest.deprecated_call():
+                assert_array_equal(actual_unscaled,
+                                   read_img_data(img_back, prefer='unscaled'))
             # Check the offset too
             img.header.set_data_offset(1024)
             # Delete arrays still pointing to file, so Windows can re-use
@@ -144,12 +151,14 @@ def test_read_img_data_nifti():
                 fobj.write(b'\x00\x00')
             img_back = load(img_fname)
             data_back = img_back.get_fdata()
-            assert_array_equal(data_back, read_img_data(img_back))
+            with pytest.deprecated_call():
+                assert_array_equal(data_back, read_img_data(img_back))
             img_back.header.set_data_offset(1026)
             # Check we pick up new offset
             exp_offset = np.zeros((data.size,), data.dtype) + old_inter
             exp_offset[:-1] = np.ravel(data_back, order='F')[1:]
             exp_offset = np.reshape(exp_offset, shape, order='F')
-            assert_array_equal(exp_offset, read_img_data(img_back))
+            with pytest.deprecated_call():
+                assert_array_equal(exp_offset, read_img_data(img_back))
             # Delete stuff that might hold onto file references
             del img, img_back, data_back