Maintenance: fix CI test errors (#366)

* np.bool8 is deprecated, use np.bool_ instead

* Remove runtime warning check from pytest imread tests

* Update pytest fixtures (class syntax may no longer be supported in the way we use it here)

* pytest.warns no longer accepts None as input

* These examples no longer produce a warning, index.ndim is not greater than 1

* pytest.skip reason needs to be an unnamed argument

---------

Co-authored-by: jakirkham <jakirkham@gmail.com>

dask_image/ndmorph/_utils.py

@@ -26,7 +26,7 @@ def _get_structure(image, structure):
             raise RuntimeError(
                 "`structure` must have the same rank as `image`."
             )
-        if not issubclass(structure.dtype.type, np.bool8):
+        if not issubclass(structure.dtype.type, np.bool_):
             structure = (structure != 0)
     else:
         raise TypeError("`structure` must be an array.")
@@ -59,9 +59,9 @@ def _get_mask(image, mask):
     if isinstance(mask, (np.ndarray, da.Array)):
         if mask.shape != image.shape:
             raise RuntimeError("`mask` must have the same shape as `image`.")
-        if not issubclass(mask_type, np.bool8):
+        if not issubclass(mask_type, np.bool_):
             mask = (mask != 0)
-    elif issubclass(mask_type, np.bool8):
+    elif issubclass(mask_type, np.bool_):
         mask = bool(mask)
     else:
         raise TypeError("`mask` must be a Boolean or an array.")

tests/test_dask_image/test_imread/test_core.py

@@ -33,17 +33,17 @@ def test_errs_imread(err_type, nframes):
     ]
 )
 @pytest.mark.parametrize(
-    "nframes, shape, runtime_warning",
+    "nframes, shape",
     [
-        (1, (1, 4, 3), None),
-        (-1, (1, 4, 3), None),
-        (3, (1, 4, 3), "`nframes` larger than"),
-        (1, (5, 4, 3), None),
-        (2, (5, 4, 3), "`nframes` does not nicely divide"),
-        (1, (10, 5, 4, 3), None),
-        (5, (10, 5, 4, 3), None),
-        (10, (10, 5, 4, 3), None),
-        (-1, (10, 5, 4, 3), None),
+        (1, (1, 4, 3)),
+        (-1, (1, 4, 3)),
+        (3, (1, 4, 3)),
+        (1, (5, 4, 3)),
+        (2, (5, 4, 3)),
+        (1, (10, 5, 4, 3)),
+        (5, (10, 5, 4, 3)),
+        (10, (10, 5, 4, 3)),
+        (-1, (10, 5, 4, 3)),
     ]
 )
 @pytest.mark.parametrize(
@@ -61,7 +61,7 @@ def test_errs_imread(err_type, nframes):
         False,
     ]
 )
-def test_tiff_imread(tmpdir, seed, nframes, shape, runtime_warning, dtype, is_pathlib_Path):  # noqa: E501
+def test_tiff_imread(tmpdir, seed, nframes, shape, dtype, is_pathlib_Path):  # noqa: E501
     np.random.seed(seed)
 
     dirpth = tmpdir.mkdir("test_imread")
@@ -77,12 +77,9 @@ def test_tiff_imread(tmpdir, seed, nframes, shape, runtime_warning, dtype, is_pa
     with tifffile.TiffWriter(fn) as fh:
         for i in range(len(a)):
             fh.save(a[i], contiguous=True)
-
-    with pytest.warns(None if runtime_warning is None
-                      else RuntimeWarning, match=runtime_warning):
-        if is_pathlib_Path:
-            fn = pathlib.Path(fn)
-        d = dask_image.imread.imread(fn, nframes=nframes)
+    if is_pathlib_Path:
+        fn = pathlib.Path(fn)
+    d = dask_image.imread.imread(fn, nframes=nframes)
 
     if nframes == -1:
         nframes = shape[0]

tests/test_dask_image/test_ndfilters/test__threshold.py

@@ -5,6 +5,62 @@
 
 from dask_image.ndfilters import threshold_local
 
+@pytest.fixture
+def simple_test_image():
+    image = da.from_array(np.array(
+        [[0, 0, 1, 3, 5],
+         [0, 1, 4, 3, 4],
+         [1, 2, 5, 4, 1],
+         [2, 4, 5, 2, 1],
+         [4, 5, 1, 0, 0]], dtype=int), chunks=(5, 5))
+    return image
+
+
+# ==================================================
+# Test Threshold Filters
+# ==================================================
+
+@pytest.mark.parametrize('block_size', [
+    3,
+    [3, 3],
+    np.array([3, 3]),
+    da.from_array(np.array([3, 3]), chunks=1),
+    da.from_array(np.array([3, 3]), chunks=2),
+])
+def test_threshold_local_gaussian(simple_test_image, block_size):
+    ref = np.array(
+        [[False, False, False, False,  True],
+            [False, False,  True, False,  True],
+            [False, False,  True,  True, False],
+            [False,  True,  True, False, False],
+            [True,  True, False, False, False]]
+    )
+    out = threshold_local(simple_test_image, block_size, method='gaussian')
+    assert_equal(ref, (simple_test_image > out).compute())
+
+    out = threshold_local(simple_test_image, block_size, method='gaussian',
+                            param=1./3.)
+    assert_equal(ref, (simple_test_image > out).compute())
+
+
+@pytest.mark.parametrize('block_size', [
+    3,
+    [3, 3],
+    np.array([3, 3]),
+    da.from_array(np.array([3, 3]), chunks=1),
+    da.from_array(np.array([3, 3]), chunks=2),
+])
+def test_threshold_local_mean(simple_test_image, block_size):
+    ref = np.array(
+        [[False, False, False, False,  True],
+            [False, False,  True, False,  True],
+            [False, False,  True,  True, False],
+            [False,  True,  True, False, False],
+            [True,  True, False, False, False]]
+    )
+    out = threshold_local(simple_test_image, block_size, method='mean')
+    assert_equal(ref, (simple_test_image > out).compute())
+
 
 @pytest.mark.parametrize('block_size', [
     3,
@@ -13,99 +69,54 @@
     da.from_array(np.array([3, 3]), chunks=1),
     da.from_array(np.array([3, 3]), chunks=2),
 ])
-class TestSimpleImage:
-    def setup(self):
-        self.image = da.from_array(np.array(
-            [[0, 0, 1, 3, 5],
-             [0, 1, 4, 3, 4],
-             [1, 2, 5, 4, 1],
-             [2, 4, 5, 2, 1],
-             [4, 5, 1, 0, 0]], dtype=int), chunks=(5, 5))
-
-    def test_threshold_local_gaussian(self, block_size):
-        ref = np.array(
-            [[False, False, False, False,  True],
-             [False, False,  True, False,  True],
-             [False, False,  True,  True, False],
-             [False,  True,  True, False, False],
-             [True,  True, False, False, False]]
-        )
-        out = threshold_local(self.image, block_size, method='gaussian')
-        assert_equal(ref, (self.image > out).compute())
-
-        out = threshold_local(self.image, block_size, method='gaussian',
-                              param=1./3.)
-        assert_equal(ref, (self.image > out).compute())
-
-    def test_threshold_local_mean(self, block_size):
-        ref = np.array(
-            [[False, False, False, False,  True],
-             [False, False,  True, False,  True],
-             [False, False,  True,  True, False],
-             [False,  True,  True, False, False],
-             [True,  True, False, False, False]]
-        )
-        out = threshold_local(self.image, block_size, method='mean')
-        assert_equal(ref, (self.image > out).compute())
-
-    def test_threshold_local_median(self, block_size):
-        ref = np.array(
-            [[False, False, False, False,  True],
-             [False, False,  True, False, False],
-             [False, False,  True, False, False],
-             [False, False,  True,  True, False],
-             [False,  True, False, False, False]]
-        )
-        out = threshold_local(self.image, block_size, method='median')
-        assert_equal(ref, (self.image > out).compute())
-
-
-class TestGenericFilter:
-    def setup(self):
-        self.image = da.from_array(np.array(
-            [[0, 0, 1, 3, 5],
-             [0, 1, 4, 3, 4],
-             [1, 2, 5, 4, 1],
-             [2, 4, 5, 2, 1],
-             [4, 5, 1, 0, 0]], dtype=int), chunks=(5, 5))
-
-    def test_threshold_local_generic(self):
-        ref = np.array(
-            [[1.,  7., 16., 29., 37.],
-             [5., 14., 23., 30., 30.],
-             [13., 24., 30., 29., 21.],
-             [25., 29., 28., 19., 10.],
-             [34., 31., 23., 10.,  4.]]
-        )
-        unchanged = threshold_local(self.image, 1, method='generic', param=sum)
-        out = threshold_local(self.image, 3, method='generic', param=sum)
-        assert np.allclose(unchanged.compute(), self.image.compute())
-        assert np.allclose(out.compute(), ref)
-
-    def test_threshold_local_generic_invalid(self):
-        expected_error_message = "Must include a valid function to use as "
-        "the 'param' keyword argument."
-        with pytest.raises(ValueError) as e:
-            threshold_local(self.image, 3, method='generic', param='sum')
-            assert e == expected_error_message
-
-
-class TestInvalidArguments:
-    def setup(self):
-        self.image = da.from_array(np.array(
-            [[0, 0, 1, 3, 5],
-             [0, 1, 4, 3, 4],
-             [1, 2, 5, 4, 1],
-             [2, 4, 5, 2, 1],
-             [4, 5, 1, 0, 0]], dtype=int), chunks=(5, 5))
-
-    @pytest.mark.parametrize("method, block_size, error_type", [
-        ('median', np.nan, TypeError),
-    ])
-    def test_nan_blocksize(self, method, block_size, error_type):
-        with pytest.raises(error_type):
-            threshold_local(self.image, block_size, method=method)
-
-    def test_invalid_threshold_method(self):
-        with pytest.raises(ValueError):
-            threshold_local(self.image, 3, method='invalid')
+def test_threshold_local_median(simple_test_image, block_size):
+    ref = np.array(
+        [[False, False, False, False,  True],
+            [False, False,  True, False, False],
+            [False, False,  True, False, False],
+            [False, False,  True,  True, False],
+            [False,  True, False, False, False]]
+    )
+    out = threshold_local(simple_test_image, block_size, method='median')
+    assert_equal(ref, (simple_test_image > out).compute())
+
+
+# ==================================================
+# Test Generic Filters
+# ==================================================
+
+def test_threshold_local_generic(simple_test_image):
+    ref = np.array(
+        [[1.,  7., 16., 29., 37.],
+         [5., 14., 23., 30., 30.],
+         [13., 24., 30., 29., 21.],
+         [25., 29., 28., 19., 10.],
+         [34., 31., 23., 10.,  4.]]
+    )
+    unchanged = threshold_local(simple_test_image, 1, method='generic', param=sum)
+    out = threshold_local(simple_test_image, 3, method='generic', param=sum)
+    assert np.allclose(unchanged.compute(), simple_test_image.compute())
+    assert np.allclose(out.compute(), ref)
+
+def test_threshold_local_generic_invalid(simple_test_image):
+    expected_error_message = "Must include a valid function to use as "
+    "the 'param' keyword argument."
+    with pytest.raises(ValueError) as e:
+        threshold_local(simple_test_image, 3, method='generic', param='sum')
+        assert e == expected_error_message
+
+
+# ==================================================
+# Test Invalid Arguments
+# ==================================================
+
+@pytest.mark.parametrize("method, block_size, error_type", [
+    ('median', np.nan, TypeError),
+])
+def test_nan_blocksize(simple_test_image, method, block_size, error_type):
+    with pytest.raises(error_type):
+        threshold_local(simple_test_image, block_size, method=method)
+
+def test_invalid_threshold_method(simple_test_image):
+    with pytest.raises(ValueError):
+        threshold_local(simple_test_image, 3, method='invalid')

tests/test_dask_image/test_ndinterp/test_spline_filter.py

@@ -172,7 +172,7 @@ def test_spline_filter1d_general(
     axis,
 ):
     if axis == 1 and n < 2:
-        pytest.skip(msg="skip axis=1 for 1d signals")
+        pytest.skip("skip axis=1 for 1d signals")
 
     validate_spline_filter(
         n=n,

tests/test_dask_image/test_ndmeasure/test__utils.py

@@ -55,8 +55,6 @@ def test__norm_input_labels_index():
 
 @pytest.mark.parametrize(
     "shape, chunks, ind", [
-        ((15, 16), (4, 5), 1),
-        ((15, 16), (4, 5), [1]),
         ((15, 16), (4, 5), [[1, 2, 3, 4]]),
         ((15, 16), (4, 5), [[1, 2], [3, 4]]),
         ((15, 16), (4, 5), [[[1], [2], [3], [4]]]),
@@ -78,7 +76,7 @@ def test__norm_input_labels_index_warn(shape, chunks, ind):
     ind = np.array(ind)
     d_ind = da.from_array(ind, chunks=1)
 
-    with pytest.warns(None) as w:
+    with pytest.warns(FutureWarning) as w:
         dask_image.ndmeasure._utils._norm_input_labels_index(
             d, d_lbls, d_ind
         )

tests/test_dask_image/test_ndmorph/test__utils.py

@@ -129,7 +129,7 @@ def test__get_iterations(expected, iterations):
 @pytest.mark.parametrize(
     "expected, a",
     [
-        (np.bool8, False),
+        (np.bool_, False),
         (np.int_, 2),
         (np.float64, 3.1),
         (np.complex128, 1 + 2j),
@@ -150,12 +150,12 @@ def test__get_dtype(expected, a):
         (
             True,
             da.arange(2, dtype=bool, chunks=(2,)),
-            np.bool8(True)
+            np.bool_(True)
         ),
         (
             False,
             da.arange(2, dtype=bool, chunks=(2,)),
-            np.bool8(False)
+            np.bool_(False)
         ),
         (
             np.arange(2, dtype=bool),