scipy 1.15.3__cp312-cp312-win_amd64.whl → 1.16.0rc2__cp312-cp312-win_amd64.whl

scipy/_lib/tests/test__util.py

@@ -2,25 +2,26 @@ from multiprocessing import Pool
 from multiprocessing.pool import Pool as PWL
 import re
 import math
+import functools
 from fractions import Fraction
 
 import numpy as np
 from numpy.testing import assert_equal, assert_
 import pytest
 from pytest import raises as assert_raises
-import hypothesis.extra.numpy as npst
-from hypothesis import given, strategies, reproduce_failure  # noqa: F401
-from scipy.conftest import array_api_compatible, skip_xp_invalid_arg
+from scipy.conftest import skip_xp_invalid_arg
 
-from scipy._lib._array_api import (xp_assert_equal, xp_assert_close, is_numpy,
-                                   xp_copy, is_array_api_strict)
+from scipy._lib._array_api import xp_assert_equal, is_numpy
 from scipy._lib._util import (_aligned_zeros, check_random_state, MapWrapper,
                               getfullargspec_no_self, FullArgSpec,
                               rng_integers, _validate_int, _rename_parameter,
-                              _contains_nan, _rng_html_rewrite, _lazywhere)
+                              _contains_nan, _rng_html_rewrite, _workers_wrapper)
+import scipy._lib.array_api_extra as xpx
+from scipy._lib.array_api_extra.testing import lazy_xp_function
 from scipy import cluster, interpolate, linalg, optimize, sparse, spatial, stats
 
-skip_xp_backends = pytest.mark.skip_xp_backends
+
+lazy_xp_function(_contains_nan)
 
 
 @pytest.mark.slow
@@ -147,6 +148,36 @@ def test_mapwrapper_parallel():
         assert_equal(list(out), out_arg)
 
 
+@_workers_wrapper
+def user_of_workers(x, b=1, workers=None):
+    assert workers is not None
+    assert isinstance(workers, MapWrapper)
+    return np.array(list(workers(np.sin, x * b)))
+
+
+def test__workers_wrapper():
+    arr = np.linspace(0, np.pi)
+    req = np.sin(arr * 2.0)
+
+    with Pool(2) as p:
+        v = user_of_workers(arr, workers=p.map, b=2)
+        assert_equal(v, req)
+
+    v = user_of_workers(arr, workers=None, b=2)
+    assert_equal(v, req)
+
+    v = user_of_workers(arr, workers=2, b=2)
+    assert_equal(v, req)
+
+    # assess if decorator works with partial functions
+    part_f = functools.partial(user_of_workers, b=2)
+    assert_equal(part_f(arr), req)
+
+    with Pool(2) as p:
+        part_f = functools.partial(user_of_workers, b=2, workers=p.map)
+        assert_equal(part_f(arr), req)
+
+
 def test_rng_integers():
     rng = np.random.RandomState()
 
@@ -296,86 +327,103 @@ class TestRenameParameter:
                     self.old_keyword_deprecated(new=10, old=10)
 
 
-class TestContainsNaNTest:
-
+class TestContainsNaN:
     def test_policy(self):
         data = np.array([1, 2, 3, np.nan])
 
-        contains_nan, nan_policy = _contains_nan(data, nan_policy="propagate")
-        assert contains_nan
-        assert nan_policy == "propagate"
-
-        contains_nan, nan_policy = _contains_nan(data, nan_policy="omit")
-        assert contains_nan
-        assert nan_policy == "omit"
+        assert _contains_nan(data)  # default policy is "propagate"
+        assert _contains_nan(data, nan_policy="propagate")
+        assert _contains_nan(data, nan_policy="omit")
+        assert not _contains_nan(data[:3])
+        assert not _contains_nan(data[:3], nan_policy="propagate")
+        assert not _contains_nan(data[:3], nan_policy="omit")
 
-        msg = "The input contains nan values"
-        with pytest.raises(ValueError, match=msg):
+        with pytest.raises(ValueError, match="The input contains nan values"):
             _contains_nan(data, nan_policy="raise")
+        assert not _contains_nan(data[:3], nan_policy="raise")
 
-        msg = "nan_policy must be one of"
-        with pytest.raises(ValueError, match=msg):
+        with pytest.raises(ValueError, match="nan_policy must be one of"):
             _contains_nan(data, nan_policy="nan")
 
     def test_contains_nan(self):
-        data1 = np.array([1, 2, 3])
-        assert not _contains_nan(data1)[0]
-
-        data2 = np.array([1, 2, 3, np.nan])
-        assert _contains_nan(data2)[0]
-
-        data3 = np.array([np.nan, 2, 3, np.nan])
-        assert _contains_nan(data3)[0]
-
-        data4 = np.array([[1, 2], [3, 4]])
-        assert not _contains_nan(data4)[0]
-
-        data5 = np.array([[1, 2], [3, np.nan]])
-        assert _contains_nan(data5)[0]
+        # Special case: empty array
+        assert not _contains_nan(np.array([], dtype=float))
+
+        # Integer arrays cannot contain NaN
+        assert not _contains_nan(np.array([1, 2, 3]))
+        assert not _contains_nan(np.array([[1, 2], [3, 4]]))
+        
+        assert not _contains_nan(np.array([1., 2., 3.]))
+        assert not _contains_nan(np.array([1., 2.j, 3.]))
+        assert _contains_nan(np.array([1., 2.j, np.nan]))
+        assert _contains_nan(np.array([1., 2., np.nan]))
+        assert _contains_nan(np.array([np.nan, 2., np.nan]))
+        assert not _contains_nan(np.array([[1., 2.], [3., 4.]]))
+        assert _contains_nan(np.array([[1., 2.], [3., np.nan]]))
 
     @skip_xp_invalid_arg
     def test_contains_nan_with_strings(self):
         data1 = np.array([1, 2, "3", np.nan])  # converted to string "nan"
-        assert not _contains_nan(data1)[0]
+        assert not _contains_nan(data1)
 
         data2 = np.array([1, 2, "3", np.nan], dtype='object')
-        assert _contains_nan(data2)[0]
+        assert _contains_nan(data2)
 
         data3 = np.array([["1", 2], [3, np.nan]])  # converted to string "nan"
-        assert not _contains_nan(data3)[0]
+        assert not _contains_nan(data3)
 
         data4 = np.array([["1", 2], [3, np.nan]], dtype='object')
-        assert _contains_nan(data4)[0]
+        assert _contains_nan(data4)
 
-    @skip_xp_backends('jax.numpy',
-                      reason="JAX arrays do not support item assignment")
-    @pytest.mark.usefixtures("skip_xp_backends")
-    @array_api_compatible
+    @pytest.mark.skip_xp_backends(eager_only=True,
+                                  reason="lazy backends tested separately")
     @pytest.mark.parametrize("nan_policy", ['propagate', 'omit', 'raise'])
     def test_array_api(self, xp, nan_policy):
         rng = np.random.default_rng(932347235892482)
         x0 = rng.random(size=(2, 3, 4))
         x = xp.asarray(x0)
-        x_nan = xp_copy(x, xp=xp)
-        x_nan[1, 2, 1] = np.nan
+        assert not _contains_nan(x, nan_policy)
 
-        contains_nan, nan_policy_out = _contains_nan(x, nan_policy=nan_policy)
-        assert not contains_nan
-        assert nan_policy_out == nan_policy
+        x = xpx.at(x)[1, 2, 1].set(np.nan)
 
         if nan_policy == 'raise':
-            message = 'The input contains...'
-            with pytest.raises(ValueError, match=message):
-                _contains_nan(x_nan, nan_policy=nan_policy)
+            with pytest.raises(ValueError, match="The input contains nan values"):
+                _contains_nan(x, nan_policy)
         elif nan_policy == 'omit' and not is_numpy(xp):
-            message = "`nan_policy='omit' is incompatible..."
-            with pytest.raises(ValueError, match=message):
-                _contains_nan(x_nan, nan_policy=nan_policy)
+            with pytest.raises(ValueError, match="nan_policy='omit' is incompatible"):
+                _contains_nan(x, nan_policy)
+            assert _contains_nan(x, nan_policy, xp_omit_okay=True)
         elif nan_policy == 'propagate':
-            contains_nan, nan_policy_out = _contains_nan(
-                x_nan, nan_policy=nan_policy)
-            assert contains_nan
-            assert nan_policy_out == nan_policy
+            assert _contains_nan(x, nan_policy)
+
+    @pytest.mark.skip_xp_backends("numpy", reason="lazy backends only")
+    @pytest.mark.skip_xp_backends("cupy", reason="lazy backends only")
+    @pytest.mark.skip_xp_backends("array_api_strict", reason="lazy backends only")
+    @pytest.mark.skip_xp_backends("torch", reason="lazy backends only")
+    def test_array_api_lazy(self, xp):
+        rng = np.random.default_rng(932347235892482)
+        x0 = rng.random(size=(2, 3, 4))
+        x = xp.asarray(x0)
+
+        xp_assert_equal(_contains_nan(x), xp.asarray(False))
+        xp_assert_equal(_contains_nan(x, "propagate"), xp.asarray(False))
+        xp_assert_equal(_contains_nan(x, "omit", xp_omit_okay=True), xp.asarray(False))
+        # Lazy arrays don't support "omit" and "raise" policies
+        match = "not supported for lazy arrays"
+        with pytest.raises(TypeError, match=match):
+            _contains_nan(x, "omit")
+        with pytest.raises(TypeError, match=match):
+            _contains_nan(x, "raise")
+
+        x = xpx.at(x)[1, 2, 1].set(np.nan)
+
+        xp_assert_equal(_contains_nan(x), xp.asarray(True))
+        xp_assert_equal(_contains_nan(x, "propagate"), xp.asarray(True))
+        xp_assert_equal(_contains_nan(x, "omit", xp_omit_okay=True), xp.asarray(True))
+        with pytest.raises(TypeError, match=match):
+            _contains_nan(x, "omit")
+        with pytest.raises(TypeError, match=match):
+            _contains_nan(x, "raise")
 
 
 def test__rng_html_rewrite():
@@ -591,67 +639,3 @@ class TestTransitionToRNG:
         res3 = method(self, **{arg_name: None})
         assert_equal(res2, res1)
         assert_equal(res3, res1)
-
-
-class TestLazywhere:
-    n_arrays = strategies.integers(min_value=1, max_value=3)
-    rng_seed = strategies.integers(min_value=1000000000, max_value=9999999999)
-    dtype = strategies.sampled_from((np.float32, np.float64))
-    p = strategies.floats(min_value=0, max_value=1)
-    data = strategies.data()
-
-    @pytest.mark.fail_slow(10)
-    @pytest.mark.filterwarnings('ignore::RuntimeWarning')  # overflows, etc.
-    @skip_xp_backends('jax.numpy',
-                      reason="JAX arrays do not support item assignment")
-    @pytest.mark.usefixtures("skip_xp_backends")
-    @array_api_compatible
-    @given(n_arrays=n_arrays, rng_seed=rng_seed, dtype=dtype, p=p, data=data)
-    @pytest.mark.thread_unsafe
-    def test_basic(self, n_arrays, rng_seed, dtype, p, data, xp):
-        mbs = npst.mutually_broadcastable_shapes(num_shapes=n_arrays+1,
-                                                 min_side=0)
-        input_shapes, result_shape = data.draw(mbs)
-        cond_shape, *shapes = input_shapes
-        elements = {'allow_subnormal': False}  # cupy/cupy#8382
-        fillvalue = xp.asarray(data.draw(npst.arrays(dtype=dtype, shape=tuple(),
-                                                     elements=elements)))
-        float_fillvalue = float(fillvalue)
-        arrays = [xp.asarray(data.draw(npst.arrays(dtype=dtype, shape=shape)))
-                  for shape in shapes]
-
-        def f(*args):
-            return sum(arg for arg in args)
-
-        def f2(*args):
-            return sum(arg for arg in args) / 2
-
-        rng = np.random.default_rng(rng_seed)
-        cond = xp.asarray(rng.random(size=cond_shape) > p)
-
-        res1 = _lazywhere(cond, arrays, f, fillvalue)
-        res2 = _lazywhere(cond, arrays, f, f2=f2)
-        if not is_array_api_strict(xp):
-            res3 = _lazywhere(cond, arrays, f, float_fillvalue)
-
-        # Ensure arrays are at least 1d to follow sane type promotion rules.
-        # This can be removed when minimum supported NumPy is 2.0
-        if xp == np:
-            cond, fillvalue, *arrays = np.atleast_1d(cond, fillvalue, *arrays)
-
-        ref1 = xp.where(cond, f(*arrays), fillvalue)
-        ref2 = xp.where(cond, f(*arrays), f2(*arrays))
-        if not is_array_api_strict(xp):
-            # Array API standard doesn't currently define behavior when fillvalue is a
-            # Python scalar. When it does, test can be run with array_api_strict, too.
-            ref3 = xp.where(cond, f(*arrays), float_fillvalue)
-
-        if xp == np:  # because we ensured arrays are at least 1d
-            ref1 = ref1.reshape(result_shape)
-            ref2 = ref2.reshape(result_shape)
-            ref3 = ref3.reshape(result_shape)
-
-        xp_assert_close(res1, ref1, rtol=2e-16)
-        xp_assert_equal(res2, ref2)
-        if not is_array_api_strict(xp):
-            xp_assert_equal(res3, ref3)

scipy/_lib/tests/test_array_api.py

@@ -1,14 +1,19 @@
+import re
+
 import numpy as np
 import pytest
 
-from scipy.conftest import array_api_compatible
 from scipy._lib._array_api import (
     _GLOBAL_CONFIG, array_namespace, _asarray, xp_copy, xp_assert_equal, is_numpy,
-    np_compat, xp_default_dtype
+    np_compat, xp_default_dtype, xp_result_type, is_torch
 )
+from scipy._lib import array_api_extra as xpx
 from scipy._lib._array_api_no_0d import xp_assert_equal as xp_assert_equal_no_0d
+from scipy._lib.array_api_extra.testing import lazy_xp_function
+
 
-skip_xp_backends = pytest.mark.skip_xp_backends
+lazy_xp_function(_asarray)
+lazy_xp_function(xp_copy)
 
 
 @pytest.mark.skipif(not _GLOBAL_CONFIG["SCIPY_ARRAY_API"],
@@ -25,7 +30,6 @@ class TestArrayAPI:
         assert 'array_api_compat.numpy' in xp.__name__
         _GLOBAL_CONFIG["SCIPY_ARRAY_API"] = True
 
-    @array_api_compatible
     def test_asarray(self, xp):
         x, y = _asarray([0, 1, 2], xp=xp), _asarray(np.arange(3), xp=xp)
         ref = xp.asarray([0, 1, 2])
@@ -48,32 +52,67 @@ class TestArrayAPI:
         with pytest.raises(TypeError, match=msg):
             array_namespace('abc')
 
-    def test_array_likes(self):
-        # should be no exceptions
-        array_namespace([0, 1, 2])
-        array_namespace(1, 2, 3)
-        array_namespace(1)
+    @pytest.mark.skip_xp_backends(np_only=True, reason="Array-likes")
+    def test_array_likes(self, xp):
+        """Test that if all parameters of array_namespace are Array-likes,
+        the output is array_api_compat.numpy
+        """
+        assert array_namespace([0, 1, 2]) is xp
+        assert array_namespace((0, 1, 2)) is xp
+        assert array_namespace(1, 2, 3) is xp
+        assert array_namespace(1) is xp
+        assert array_namespace(np.int64(1)) is xp
+        assert array_namespace([0, 1, 2], 3) is xp
+        assert array_namespace() is xp
+        assert array_namespace(None) is xp
+        assert array_namespace(1, None) is xp
+        assert array_namespace(None, 1) is xp
+
+        # This only works when xp is numpy!
+        assert array_namespace(np.asarray([1, 2]), [3, 4]) is xp
+        assert array_namespace(np.int64(1), [3, 4]) is xp
+
+    def test_array_and_array_likes_mix(self, xp):
+        """Test that if there is at least one Array API object among
+        the parameters of array_namespace, and all other parameters
+        are scalars, the output is its namespace.
+
+        If there are non-scalar Array-Likes, raise as in array-api-compat.
+        """
+        x = xp.asarray(1)
+        assert array_namespace(x) is xp
+        assert array_namespace(x, 1) is xp
+        assert array_namespace(1, x) is xp
+        assert array_namespace(None, x) is xp
+
+        if not is_numpy(xp):
+            with pytest.raises(TypeError, match="Multiple namespaces"):
+                array_namespace(x, [1, 2])
+            with pytest.raises(TypeError, match="Multiple namespaces"):
+                array_namespace(x, np.int64(1))
+
+    def test_array_api_extra_hook(self):
+        """Test that the `array_namespace` function used by
+        array-api-extra has been overridden by scipy
+        """
+        msg = "only boolean and numerical dtypes are supported"
+        with pytest.raises(TypeError, match=msg):
+            xpx.atleast_nd("abc", ndim=0)
 
-    @skip_xp_backends('jax.numpy',
-                      reason="JAX arrays do not support item assignment")
-    @pytest.mark.usefixtures("skip_xp_backends")
-    @array_api_compatible
     def test_copy(self, xp):
         for _xp in [xp, None]:
             x = xp.asarray([1, 2, 3])
             y = xp_copy(x, xp=_xp)
             # with numpy we'd want to use np.shared_memory, but that's not specified
             # in the array-api
-            x[0] = 10
-            x[1] = 11
-            x[2] = 12
-
-            assert x[0] != y[0]
-            assert x[1] != y[1]
-            assert x[2] != y[2]
             assert id(x) != id(y)
-
-    @array_api_compatible
+            try:
+                y[0] = 10
+            except (TypeError, ValueError):
+                pass
+            else:
+                assert x[0] != y[0]
+    
     @pytest.mark.parametrize('dtype', ['int32', 'int64', 'float32', 'float64'])
     @pytest.mark.parametrize('shape', [(), (3,)])
     def test_strict_checks(self, xp, dtype, shape):
@@ -85,11 +124,19 @@ class TestArrayAPI:
 
         kwarg_names = ["check_namespace", "check_dtype", "check_shape", "check_0d"]
         options = dict(zip(kwarg_names, [True, False, False, False]))
-        if xp == np:
+        if is_numpy(xp):
             xp_assert_equal(x, y, **options)
         else:
-            with pytest.raises(AssertionError, match="Namespaces do not match."):
+            with pytest.raises(
+                AssertionError,
+                match="Namespace of desired array does not match",
+            ):
                 xp_assert_equal(x, y, **options)
+            with pytest.raises(
+                AssertionError,
+                match="Namespace of actual and desired arrays do not match",
+            ):
+                xp_assert_equal(y, x, **options)
 
         options = dict(zip(kwarg_names, [False, True, False, False]))
         if y.dtype.name in str(x.dtype):
@@ -112,12 +159,8 @@ class TestArrayAPI:
             with pytest.raises(AssertionError, match="Array-ness does not match."):
                 xp_assert_equal(x, y, **options)
 
-
-    @array_api_compatible
+    @pytest.mark.skip_xp_backends(np_only=True, reason="Scalars only exist in NumPy")
     def test_check_scalar(self, xp):
-        if not is_numpy(xp):
-            pytest.skip("Scalars only exist in NumPy")
-
         # identity always passes
         xp_assert_equal(xp.float64(0), xp.float64(0))
         xp_assert_equal(xp.asarray(0.), xp.asarray(0.))
@@ -147,12 +190,8 @@ class TestArrayAPI:
         # as an alternative to `check_0d=False`, explicitly expect scalar
         xp_assert_equal(xp.float64(0), xp.asarray(0.)[()])
 
-
-    @array_api_compatible
+    @pytest.mark.skip_xp_backends(np_only=True, reason="Scalars only exist in NumPy")
     def test_check_scalar_no_0d(self, xp):
-        if not is_numpy(xp):
-            pytest.skip("Scalars only exist in NumPy")
-
         # identity passes, if first argument is not 0d (or check_0d=True)
         xp_assert_equal_no_0d(xp.float64(0), xp.float64(0))
         xp_assert_equal_no_0d(xp.float64(0), xp.float64(0), check_0d=True)
@@ -186,6 +225,98 @@ class TestArrayAPI:
         xp_assert_equal_no_0d(0., xp.asarray(0.))
         xp_assert_equal_no_0d(42, xp.asarray(42))
 
-    @array_api_compatible
     def test_default_dtype(self, xp):
         assert xp_default_dtype(xp) == xp.asarray(1.).dtype
+
+
+scalars = [1, 1., 1. + 1j]
+lists = [[1], [1.], [1. + 1j]]
+types = ('int8 int16 int32 int64 '
+         'uint8 uint16 uint32 uint64 '
+         'float32 float64 complex64 complex128').split()
+arrays = [np.asarray([1], dtype=getattr(np, t)) for t in types]
+
+
+def convert_type(x, xp):
+    # Convert NumPy array to xp-array
+    # Convert string to indicated dtype from xp
+    # Return Python scalars unchanged
+    if isinstance(x, np.ndarray):
+        return xp.asarray(x)
+    elif isinstance(x, str):
+        return getattr(xp, x)
+    return x
+
+
+def is_inexact(x, xp):
+    # Determine whether `x` is of inexact (real of complex floating) dtype
+    x = xp.asarray(x) if np.isscalar(x) or isinstance(x, list) else x
+    dtype = getattr(x, 'dtype', x)
+    return xp.isdtype(dtype, ('real floating', 'complex floating'))
+
+
+@pytest.mark.parametrize('x', scalars + lists + types + arrays)
+@pytest.mark.parametrize('y', scalars + lists + types + arrays)
+def test_xp_result_type_no_force(x, y, xp):
+    # When force_floating==False (default), behavior of `xp_result_type`
+    # should match that of `xp.result_type` on the same arguments after
+    # converting lists to arrays of type `xp`.
+    x = convert_type(x, xp)
+    y = convert_type(y, xp)
+    x_ref = xp.asarray(x) if isinstance(x, list) else x
+    y_ref = xp.asarray(y) if isinstance(y, list) else y
+
+    try:
+        dtype_ref = xp.result_type(x_ref, y_ref)
+        expected_error = None
+    except Exception as e:
+        expected_error = (type(e), str(e))
+
+    if expected_error is not None:
+        with pytest.raises(expected_error[0], match=re.escape(expected_error[1])):
+            xp_result_type(x, y, xp=xp)
+        return
+
+    dtype_res = xp_result_type(x, y, xp=xp)
+    assert dtype_res == dtype_ref
+
+
+@pytest.mark.parametrize('x', scalars + lists + types + arrays)
+@pytest.mark.parametrize('y', scalars + lists + types + arrays)
+def test_xp_result_type_force_floating(x, y, xp):
+    # When `force_floating==True`, behavior of `xp_result_type`
+    # should match that of `xp.result_type` with `1.0` appended to the set of
+    # arguments (after converting lists to arrays of type `xp`).
+    # If this raises a `TypeError`, which is the case when the result
+    # type is not defined by the standard, the result type should be
+    # the result type of any inexact (real or complex floating) arguments
+    # and the default floating point type.
+    if (is_torch(xp) and not(isinstance(x, str) or isinstance(y, str))
+            and np.isscalar(x) and np.isscalar(y)):
+        pytest.skip("See 3/27/2024 comment at  data-apis/array-api-compat#277")
+
+    x = convert_type(x, xp)
+    y = convert_type(y, xp)
+    x_ref = xp.asarray(x) if isinstance(x, list) else x
+    y_ref = xp.asarray(y) if isinstance(y, list) else y
+
+    expected_error = None
+    try:
+        dtype_ref = xp.result_type(x_ref, y_ref, 1.0)
+    except TypeError:
+        args = []
+        if is_inexact(x_ref, xp):
+            args.append(x_ref)
+        if is_inexact(y_ref, xp):
+            args.append(y_ref)
+        dtype_ref = xp.result_type(*args, xp.asarray(1.0))
+    except Exception as e:
+        expected_error = (type(e), str(e))
+
+    if expected_error is not None:
+        with pytest.raises(expected_error[0], match=expected_error[1]):
+            xp_result_type(x, y, xp=xp)
+        return
+
+    dtype_res = xp_result_type(x, y, force_floating=True, xp=xp)
+    assert dtype_res == dtype_ref

scipy/_lib/tests/test_bunch.py

@@ -127,6 +127,13 @@ class TestMakeTupleBunch:
         assert_equal(Foo.__module__, m)
         assert_equal(foo.__module__, m)
 
+    def test_passes_polars_checks(self):
+        # gh-22450
+        Square = _make_tuple_bunch('Square', ['width', 'height'])
+        assert hasattr(Square, '_replace')
+        assert hasattr(Square, '_field_defaults')
+
+
     # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     # Argument validation
     # - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

scipy/_lib/tests/test_ccallback.py

@@ -9,12 +9,6 @@ from scipy._lib import _ccallback_c as _test_ccallback_cython
 from scipy._lib import _test_ccallback
 from scipy._lib._ccallback import LowLevelCallable
 
-try:
-    import cffi
-    HAVE_CFFI = True
-except ImportError:
-    HAVE_CFFI = False
-
 
 ERROR_VALUE = 2.0
 
@@ -29,8 +23,7 @@ def callback_python(a, user_data=None):
         return a + user_data
 
 def _get_cffi_func(base, signature):
-    if not HAVE_CFFI:
-        pytest.skip("cffi not installed")
+    cffi = pytest.importorskip("cffi")
 
     # Get function address
     voidp = ctypes.cast(base, ctypes.c_void_p)
@@ -48,8 +41,7 @@ def _get_ctypes_data():
 
 
 def _get_cffi_data():
-    if not HAVE_CFFI:
-        pytest.skip("cffi not installed")
+    cffi = pytest.importorskip("cffi")
     ffi = cffi.FFI()
     return ffi.new('double *', 2.0)
 

scipy/_lib/tests/test_public_api.py

@@ -357,6 +357,7 @@ def test_api_importable():
                           ('scipy.integrate.odepack', None),
                           ('scipy.integrate.quadpack', None),
                           ('scipy.integrate.vode', None),
+                          ('scipy.interpolate.dfitpack', None),
                           ('scipy.interpolate.fitpack', None),
                           ('scipy.interpolate.fitpack2', None),
                           ('scipy.interpolate.interpolate', None),
@@ -412,9 +413,21 @@ def test_api_importable():
                           ('scipy.signal.ltisys', None),
                           ('scipy.signal.signaltools', None),
                           ('scipy.signal.spectral', None),
+                          ('scipy.signal.spline', None),
                           ('scipy.signal.waveforms', None),
                           ('scipy.signal.wavelets', None),
                           ('scipy.signal.windows.windows', 'windows'),
+                          ('scipy.sparse.base', None),
+                          ('scipy.sparse.bsr', None),
+                          ('scipy.sparse.compressed', None),
+                          ('scipy.sparse.construct', None),
+                          ('scipy.sparse.coo', None),
+                          ('scipy.sparse.csc', None),
+                          ('scipy.sparse.csr', None),
+                          ('scipy.sparse.data', None),
+                          ('scipy.sparse.dia', None),
+                          ('scipy.sparse.dok', None),
+                          ('scipy.sparse.extract', None),
                           ('scipy.sparse.lil', None),
                           ('scipy.sparse.linalg.dsolve', 'linalg'),
                           ('scipy.sparse.linalg.eigen', 'linalg'),