Address more comments

Author: lithomas1

scipy/fft/tests/test_real_transforms.py

@@ -6,7 +6,7 @@
 from scipy.fft import dct, idct, dctn, idctn, dst, idst, dstn, idstn
 import scipy.fft as fft
 from scipy import fftpack
-from scipy._lib._array_api import xp_assert_close
+from scipy._lib._array_api import xp_copy, xp_assert_close
 
 skip_xp_backends = pytest.mark.skip_xp_backends
 
@@ -195,10 +195,9 @@ def test_orthogonalize_noop(func, type, norm, xp):
 @skip_xp_backends(cpu_only=True)
 @pytest.mark.parametrize("norm", ["backward", "ortho", "forward"])
 def test_orthogonalize_dct1(norm, xp):
-    x_np = np.random.rand(100)
-    x = xp.asarray(x_np)
+    x = xp.asarray(np.random.rand(100))
 
-    x2 = xp.asarray(x_np.copy())
+    x2 = xp_copy(x, xp=xp)
     x2[0] *= SQRT_2
     x2[-1] *= SQRT_2
 
@@ -230,9 +229,8 @@ def test_orthogonalize_dcst2(func, norm, xp):
 @pytest.mark.parametrize("norm", ["backward", "ortho", "forward"])
 @pytest.mark.parametrize("func", [dct, dst])
 def test_orthogonalize_dcst3(func, norm, xp):
-    x_np = np.random.rand(100)
-    x = xp.asarray(x_np)
-    x2 = xp.asarray(x_np.copy())
+    x = xp.asarray(np.random.rand(100))
+    x2 = xp_copy(x, xp=xp)
     x2[0 if func == dct else -1] *= SQRT_2
 
     y1 = func(x, type=3, norm=norm, orthogonalize=True)

scipy/ndimage/_morphology.py

@@ -36,7 +36,7 @@
 from . import _nd_image
 from . import _filters
 
-from scipy._lib._array_api import is_dask, array_namespace
+from scipy._lib.array_api_compat.array_api_compat import is_dask_array
 
 __all__ = ['iterate_structure', 'generate_binary_structure', 'binary_erosion',
            'binary_dilation', 'binary_opening', 'binary_closing',
@@ -222,7 +222,7 @@ def _binary_erosion(input, structure, iterations, mask, output,
     except TypeError as e:
         raise TypeError('iterations parameter should be an integer') from e
 
-    if is_dask(array_namespace(input)):
+    if is_dask_array(input):
         # Note: If you create an dask array with ones
         # it does a stride trick where it makes an array
         # (with stride 0) using a scalar
@@ -1802,6 +1802,7 @@ def morphological_laplace(input, size=None, footprint=None, structure=None,
     """
     tmp1 = grey_dilation(input, size, footprint, structure, None, mode,
                          cval, origin, axes=axes)
+    input = np.asarray(input)
     if isinstance(output, np.ndarray):
         grey_erosion(input, size, footprint, structure, output, mode,
                      cval, origin, axes=axes)
@@ -1812,7 +1813,6 @@ def morphological_laplace(input, size=None, footprint=None, structure=None,
         tmp2 = grey_erosion(input, size, footprint, structure, None, mode,
                             cval, origin, axes=axes)
         np.add(tmp1, tmp2, tmp2)
-        input = np.asarray(input)
         np.subtract(tmp2, input, tmp2)
         np.subtract(tmp2, input, tmp2)
         return tmp2

scipy/ndimage/tests/test_filters.py

@@ -191,7 +191,7 @@ def test_correlate01(self, xp):
 
     @xfail_xp_backends('cupy', reason="Differs by a factor of two?")
     @skip_xp_backends("jax.numpy", reason="output array is read-only.")
-    @skip_xp_backends("dask.array", reason="wrong answer")
+    @xfail_xp_backends("dask.array", reason="wrong answer")
     def test_correlate01_overlap(self, xp):
         array = xp.reshape(xp.arange(256), (16, 16))
         weights = xp.asarray([2])
@@ -881,7 +881,7 @@ def test_gauss06(self, xp):
         assert_array_almost_equal(output1, output2)
 
     @skip_xp_backends("jax.numpy", reason="output array is read-only.")
-    @skip_xp_backends("dask.array", reason="wrong result")
+    @xfail_xp_backends("dask.array", reason="output keyword not handled properly")
     def test_gauss_memory_overlap(self, xp):
         input = xp.arange(100 * 100, dtype=xp.float32)
         input = xp.reshape(input, (100, 100))
@@ -1228,7 +1228,7 @@ def test_prewitt01(self, dtype, xp):
         assert_array_almost_equal(t, output)
 
     @skip_xp_backends("jax.numpy", reason="output array is read-only.")
-    @skip_xp_backends("dask.array", reason="output array is read-only.")
+    @xfail_xp_backends("dask.array", reason="output array is read-only.")
     @pytest.mark.parametrize('dtype', types + complex_types)
     def test_prewitt02(self, dtype, xp):
         if is_torch(xp) and dtype in ("uint16", "uint32", "uint64"):
@@ -1838,9 +1838,7 @@ def test_rank06(self, xp):
     @skip_xp_backends("jax.numpy",
         reason="assignment destination is read-only",
     )
-    @xfail_xp_backends("dask.array",
-        reason="wrong answer",
-    )
+    @xfail_xp_backends("dask.array", reason="wrong answer")
     def test_rank06_overlap(self, xp):
         array = xp.asarray([[3, 2, 5, 1, 4],
                             [5, 8, 3, 7, 1],
@@ -2647,7 +2645,7 @@ def test_gaussian_radius_invalid(xp):
 
 
 @skip_xp_backends("jax.numpy", reason="output array is read-only")
-@skip_xp_backends("dask.array", reason="wrong answer")
+@xfail_xp_backends("dask.array", reason="wrong answer")
 class TestThreading:
     def check_func_thread(self, n, fun, args, out):
         from threading import Thread

scipy/ndimage/tests/test_measurements.py

@@ -548,17 +548,16 @@ def test_value_indices02(xp):
         ndimage.value_indices(data)
 
 
-@skip_xp_backends("dask.array", reason="len on data-dependent output shapes")
 def test_value_indices03(xp):
     "Test different input array shapes, from 1-D to 4-D"
     for shape in [(36,), (18, 2), (3, 3, 4), (3, 3, 2, 2)]:
         a = xp.asarray((12*[1]+12*[2]+12*[3]), dtype=xp.int32)
         a = xp.reshape(a, shape)
 
-        trueKeys = xp.unique_values(a)
+        # convert to numpy to prevent issues with data-dependent shapes
+        # from unique for dask
+        trueKeys = np.asarray(xp.unique_values(a))
         vi = ndimage.value_indices(a)
-        # TODO: list(trueKeys) needs len of trueKeys
-        # (which is unknown for dask since it is the result of an unique call)
         assert list(vi.keys()) == list(trueKeys)
         for k in [int(x) for x in trueKeys]:
             trueNdx = xp.nonzero(a == k)

scipy/ndimage/tests/test_morphology.py

@@ -2315,7 +2315,6 @@ def test_grey_erosion01(self, xp):
                                               [5, 5, 3, 3, 1]]))
 
     @skip_xp_backends("jax.numpy", reason="output array is read-only.")
-    @skip_xp_backends("dask.array", reason="output array is read-only.")
     @xfail_xp_backends("cupy", reason="https://github.com/cupy/cupy/issues/8398")
     def test_grey_erosion01_overlap(self, xp):
 
@@ -2521,6 +2520,8 @@ def test_white_tophat01(self, xp):
         tmp = ndimage.grey_opening(array, footprint=footprint,
                                    structure=structure)
         expected = array - tmp
+        # array created by xp.zeros is non-writeable for dask
+        # and jax
         output = xp.zeros(array.shape, dtype=array.dtype)
         ndimage.white_tophat(array, footprint=footprint,
                              structure=structure, output=output)
@@ -2574,6 +2575,8 @@ def test_white_tophat04(self, xp):
         structure = xp.asarray(structure)
 
         # Check that type mismatch is properly handled
+        # This output array is read-only for dask and jax
+        # TODO: investigate why for dask?
         output = xp.empty_like(array, dtype=xp.float64)
         ndimage.white_tophat(array, structure=structure, output=output)
 
@@ -2588,6 +2591,7 @@ def test_black_tophat01(self, xp):
         tmp = ndimage.grey_closing(array, footprint=footprint,
                                    structure=structure)
         expected = tmp - array
+        # This output array is read-only for dask and jax
         output = xp.zeros(array.shape, dtype=array.dtype)
         ndimage.black_tophat(array, footprint=footprint,
                              structure=structure, output=output)

scipy/signal/tests/test_signaltools.py

@@ -2452,7 +2452,6 @@ def decimal(self, dt, xp):
             dt = np.cdouble
 
         # emulate np.finfo(dt).precision for complex64 and complex128
-        # note: unwrapped dask has no finfo
         prec = {64: 15, 32: 6}[xp.finfo(dt).bits]
         return int(2 * prec / 3)
 

scipy/signal/tests/test_windows.py

@@ -9,8 +9,8 @@
 from scipy.fft import fft
 from scipy.signal import windows, get_window, resample
 from scipy._lib._array_api import (
-     xp_assert_close, xp_assert_equal, array_namespace, is_dask,
-     is_torch, is_jax, is_cupy, assert_array_almost_equal, SCIPY_DEVICE,
+     xp_assert_close, xp_assert_equal, array_namespace, is_torch, is_jax, is_cupy,
+     assert_array_almost_equal, SCIPY_DEVICE,
 )
 
 skip_xp_backends = pytest.mark.skip_xp_backends
@@ -852,16 +852,12 @@ def test_lanczos(self, xp):
                         get_window('sinc', 6, xp=xp))
 
 
+@skip_xp_backends("dask.array", reason="https://github.com/dask/dask/issues/2620")
 def test_windowfunc_basics(xp):
     for window_name, params in window_funcs:
         window = getattr(windows, window_name)
         if is_jax(xp) and window_name in ['taylor', 'chebwin']:
             pytest.skip(reason=f'{window_name = }: item assignment')
-        if is_dask(xp):
-            # https://github.com/dask/dask/issues/2620
-            pytest.skip(
-                reason="dask doesn't support FFT along axis containing multiple chunks"
-            )
         if window_name in ['dpss']:
             if is_cupy(xp):
                 pytest.skip(reason='dpss window is not implemented for cupy')