Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package python-scipy for openSUSE:Factory checked in at 2025-10-09 14:59:53 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-scipy (Old) and /work/SRC/openSUSE:Factory/.python-scipy.new.11973 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-scipy" Thu Oct 9 14:59:53 2025 rev:84 rq:1309767 version:1.16.2 Changes: -------- --- /work/SRC/openSUSE:Factory/python-scipy/python-scipy.changes 2025-10-02 19:19:14.888066344 +0200 +++ /work/SRC/openSUSE:Factory/.python-scipy.new.11973/python-scipy.changes 2025-10-09 15:00:00.438260176 +0200 @@ -1,0 +2,5 @@ +Tue Oct 7 15:11:36 UTC 2025 - Nico Krapp <[email protected]> + +- Add pytest-run-parallel-compat.patch to fix tests with Python 3.14 + +------------------------------------------------------------------- New: ---- pytest-run-parallel-compat.patch ----------(New B)---------- New: - Add pytest-run-parallel-compat.patch to fix tests with Python 3.14 ----------(New E)---------- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-scipy.spec ++++++ --- /var/tmp/diff_new_pack.5e2l9h/_old 2025-10-09 15:00:01.510305163 +0200 +++ /var/tmp/diff_new_pack.5e2l9h/_new 2025-10-09 15:00:01.514305331 +0200 @@ -54,6 +54,8 @@ Source0: https://files.pythonhosted.org/packages/source/s/scipy/scipy-%{version}.tar.gz # Create with pooch: `python3 scipy-%%{version}/scipy/datasets/_download_all.py scipy-datasets/scipy-data; tar czf scipy-datasets.tar.gz scipy-datasets` Source1: scipy-datasets.tar.gz +# PATCH-FIX-UPSTREAM pytest-run-parallel-compat.patch https://github.com/scipy/scipy/pull/23305 +Patch0: pytest-run-parallel-compat.patch BuildRequires: %{python_module Cython >= 3.0.8 with %python-Cython < 3.2} BuildRequires: %{python_module devel >= 3.11} BuildRequires: %{python_module meson-python >= 0.15.0 with %python-meson-python < 0.21} ++++++ pytest-run-parallel-compat.patch ++++++ >From cde31bc9630313bacf98f6b2ea7234bbb24ea5e4 Mon Sep 17 00:00:00 2001 From: crusaderky <[email protected]> Date: Wed, 9 Jul 2025 15:44:35 +0100 Subject: [PATCH] TST: linalg: make `test_expm_multiply` frendierly to pytest-run-parallel --- .../sparse/linalg/tests/test_expm_multiply.py | 90 +++++++++---------- 1 file changed, 40 insertions(+), 50 deletions(-) Index: scipy-1.16.2/scipy/sparse/linalg/tests/test_expm_multiply.py =================================================================== --- scipy-1.16.2.orig/scipy/sparse/linalg/tests/test_expm_multiply.py +++ scipy-1.16.2/scipy/sparse/linalg/tests/test_expm_multiply.py @@ -24,18 +24,13 @@ COMPLEX_DTYPES = (np.complex64, np.compl DTYPES = REAL_DTYPES + COMPLEX_DTYPES -def estimated(func): +def estimated_warns(): """If trace is estimated, it should warn. We warn that estimation of trace might impact performance. All result have to be correct nevertheless! - """ - def wrapped(*args, **kwds): - with pytest.warns(UserWarning, - match="Trace of LinearOperator not available"): - return func(*args, **kwds) - return wrapped + return pytest.warns(UserWarning, match="Trace of LinearOperator not available") def less_than_or_close(a, b): @@ -81,73 +76,68 @@ class TestExpmActionSimple: assert_(less_than_or_close(estimated, exact)) assert_(less_than_or_close(exact, 3*estimated)) - @pytest.mark.thread_unsafe def test_expm_multiply(self): - np.random.seed(1234) + rng = np.random.default_rng(1234) n = 40 k = 3 nsamples = 10 for i in range(nsamples): - A = scipy.linalg.inv(np.random.randn(n, n)) - B = np.random.randn(n, k) + A = scipy.linalg.inv(rng.standard_normal((n, n))) + B = rng.standard_normal((n, k)) observed = expm_multiply(A, B) expected = np.dot(sp_expm(A), B) assert_allclose(observed, expected) - observed = estimated(expm_multiply)(aslinearoperator(A), B) + with estimated_warns(): + observed = expm_multiply(aslinearoperator(A), B) assert_allclose(observed, expected) traceA = np.trace(A) observed = expm_multiply(aslinearoperator(A), B, traceA=traceA) assert_allclose(observed, expected) - @pytest.mark.thread_unsafe def test_matrix_vector_multiply(self): - np.random.seed(1234) + rng = np.random.default_rng(1234) n = 40 nsamples = 10 for i in range(nsamples): - A = scipy.linalg.inv(np.random.randn(n, n)) - v = np.random.randn(n) + A = scipy.linalg.inv(rng.standard_normal((n, n))) + v = rng.standard_normal(n) observed = expm_multiply(A, v) expected = np.dot(sp_expm(A), v) assert_allclose(observed, expected) - observed = estimated(expm_multiply)(aslinearoperator(A), v) + with estimated_warns(): + observed = expm_multiply(aslinearoperator(A), v) assert_allclose(observed, expected) - @pytest.mark.thread_unsafe def test_scaled_expm_multiply(self): - np.random.seed(1234) + rng = np.random.default_rng(1234) n = 40 k = 3 nsamples = 10 for i, t in product(range(nsamples), [0.2, 1.0, 1.5]): with np.errstate(invalid='ignore'): - A = scipy.linalg.inv(np.random.randn(n, n)) - B = np.random.randn(n, k) + A = scipy.linalg.inv(rng.standard_normal((n, n))) + B = rng.standard_normal((n, k)) observed = _expm_multiply_simple(A, B, t=t) expected = np.dot(sp_expm(t*A), B) assert_allclose(observed, expected) - observed = estimated(_expm_multiply_simple)( - aslinearoperator(A), B, t=t - ) + with estimated_warns(): + observed = _expm_multiply_simple(aslinearoperator(A), B, t=t) assert_allclose(observed, expected) - @pytest.mark.thread_unsafe def test_scaled_expm_multiply_single_timepoint(self): - np.random.seed(1234) + rng = np.random.default_rng(1234) t = 0.1 n = 5 k = 2 - A = np.random.randn(n, n) - B = np.random.randn(n, k) + A = rng.standard_normal((n, n)) + B = rng.standard_normal((n, k)) observed = _expm_multiply_simple(A, B, t=t) expected = sp_expm(t*A).dot(B) assert_allclose(observed, expected) - observed = estimated(_expm_multiply_simple)( - aslinearoperator(A), B, t=t - ) + with estimated_warns(): + observed = _expm_multiply_simple(aslinearoperator(A), B, t=t) assert_allclose(observed, expected) - @pytest.mark.thread_unsafe def test_sparse_expm_multiply(self): rng = np.random.default_rng(1234) n = 40 @@ -165,10 +155,10 @@ class TestExpmActionSimple: " CSC matrix format") expected = sp_expm(A).dot(B) assert_allclose(observed, expected) - observed = estimated(expm_multiply)(aslinearoperator(A), B) + with estimated_warns(): + observed = expm_multiply(aslinearoperator(A), B) assert_allclose(observed, expected) - @pytest.mark.thread_unsafe def test_complex(self): A = np.array([ [1j, 1j], @@ -179,7 +169,8 @@ class TestExpmActionSimple: 1j * np.exp(1j) + 1j * (1j*np.cos(1) - np.sin(1)), 1j * np.exp(1j)], dtype=complex) assert_allclose(observed, expected) - observed = estimated(expm_multiply)(aslinearoperator(A), B) + with estimated_warns(): + observed = expm_multiply(aslinearoperator(A), B) assert_allclose(observed, expected) @@ -211,21 +202,20 @@ class TestExpmActionInterval: for solution, t in zip(X, samples): assert_allclose(solution, sp_expm(t*A).dot(target)) - @pytest.mark.thread_unsafe @pytest.mark.fail_slow(20) def test_expm_multiply_interval_vector(self): - np.random.seed(1234) + rng = np.random.default_rng(1234) interval = {'start': 0.1, 'stop': 3.2, 'endpoint': True} for num, n in product([14, 13, 2], [1, 2, 5, 20, 40]): - A = scipy.linalg.inv(np.random.randn(n, n)) - v = np.random.randn(n) + A = scipy.linalg.inv(rng.standard_normal((n, n))) + v = rng.standard_normal(n) samples = np.linspace(num=num, **interval) X = expm_multiply(A, v, num=num, **interval) for solution, t in zip(X, samples): assert_allclose(solution, sp_expm(t*A).dot(v)) # test for linear operator with unknown trace -> estimate trace - Xguess = estimated(expm_multiply)(aslinearoperator(A), v, - num=num, **interval) + with estimated_warns(): + Xguess = expm_multiply(aslinearoperator(A), v, num=num, **interval) # test for linear operator with given trace Xgiven = expm_multiply(aslinearoperator(A), v, num=num, **interval, traceA=np.trace(A)) @@ -239,20 +229,19 @@ class TestExpmActionInterval: assert_allclose(sol_given, correct) assert_allclose(sol_wrong, correct) - @pytest.mark.thread_unsafe @pytest.mark.fail_slow(20) def test_expm_multiply_interval_matrix(self): - np.random.seed(1234) + rng = np.random.default_rng(1234) interval = {'start': 0.1, 'stop': 3.2, 'endpoint': True} for num, n, k in product([14, 13, 2], [1, 2, 5, 20, 40], [1, 2]): - A = scipy.linalg.inv(np.random.randn(n, n)) - B = np.random.randn(n, k) + A = scipy.linalg.inv(rng.standard_normal((n, n))) + B = rng.standard_normal((n, k)) samples = np.linspace(num=num, **interval) X = expm_multiply(A, B, num=num, **interval) for solution, t in zip(X, samples): assert_allclose(solution, sp_expm(t*A).dot(B)) - X = estimated(expm_multiply)(aslinearoperator(A), B, num=num, - **interval) + with estimated_warns(): + X = expm_multiply(aslinearoperator(A), B, num=num, **interval) for solution, t in zip(X, samples): assert_allclose(solution, sp_expm(t*A).dot(B)) @@ -324,7 +313,6 @@ class TestExpmActionInterval: raise Exception(msg) [email protected]_unsafe @pytest.mark.parametrize("dtype_a", DTYPES) @pytest.mark.parametrize("dtype_b", DTYPES) @pytest.mark.parametrize("b_is_matrix", [False, True]) @@ -349,7 +337,8 @@ def test_expm_multiply_dtype(dtype_a, dt # single application sol_mat = expm_multiply(A, B) - sol_op = estimated(expm_multiply)(aslinearoperator(A), B) + with estimated_warns(): + sol_op = expm_multiply(aslinearoperator(A), B) direct_sol = np.dot(sp_expm(A), B) assert_allclose_(sol_mat, direct_sol) assert_allclose_(sol_op, direct_sol) @@ -360,7 +349,8 @@ def test_expm_multiply_dtype(dtype_a, dt interval = {'start': 0.1, 'stop': 3.2, 'num': 13, 'endpoint': True} samples = np.linspace(**interval) X_mat = expm_multiply(A, B, **interval) - X_op = estimated(expm_multiply)(aslinearoperator(A), B, **interval) + with estimated_warns(): + X_op = expm_multiply(aslinearoperator(A), B, **interval) for sol_mat, sol_op, t in zip(X_mat, X_op, samples): direct_sol = sp_expm(t*A).dot(B) assert_allclose_(sol_mat, direct_sol)
