From: Colin Watson Date: Sun, 19 Oct 2025 02:05:19 +0100 Subject: Stop using private sklearn.utils._testing Forwarded: https://github.com/trevorstephens/gplearn/pull/305 Bug-Debian: https://bugs.debian.org/1117991 Last-Update: 2025-10-19 --- gplearn/tests/test_examples.py | 2 +- gplearn/tests/test_fitness.py | 40 +++++----- gplearn/tests/test_functions.py | 85 +++++++-------------- gplearn/tests/test_genetic.py | 165 ++++++++++++++++++++++++++-------------- gplearn/tests/test_utils.py | 8 +- 5 files changed, 158 insertions(+), 142 deletions(-) diff --git a/gplearn/tests/test_examples.py b/gplearn/tests/test_examples.py index f4f3f89..7bf5b2a 100644 --- a/gplearn/tests/test_examples.py +++ b/gplearn/tests/test_examples.py @@ -6,13 +6,13 @@ import numpy as np +from numpy.testing import assert_almost_equal from sklearn.datasets import load_diabetes, load_breast_cancer from sklearn.datasets import make_moons, make_circles, make_classification from sklearn.linear_model import Ridge from sklearn.metrics import roc_auc_score from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler -from sklearn.utils._testing import assert_almost_equal from sklearn.utils.validation import check_random_state from gplearn.genetic import SymbolicClassifier, SymbolicRegressor diff --git a/gplearn/tests/test_fitness.py b/gplearn/tests/test_fitness.py index a189126..4046b73 100644 --- a/gplearn/tests/test_fitness.py +++ b/gplearn/tests/test_fitness.py @@ -7,9 +7,9 @@ import pickle import numpy as np +import pytest from sklearn.datasets import load_diabetes, load_breast_cancer from sklearn.metrics import mean_absolute_error -from sklearn.utils._testing import assert_raises from sklearn.utils.validation import check_random_state from gplearn.genetic import SymbolicRegressor, SymbolicClassifier @@ -35,35 +35,27 @@ def test_validate_fitness(): # Check arg count checks _ = make_fitness(function=_mean_square_error, greater_is_better=True) # non-bool greater_is_better - assert_raises(ValueError, - make_fitness, - function=_mean_square_error, - greater_is_better='Sure') - assert_raises(ValueError, - make_fitness, - function=_mean_square_error, - greater_is_better=1) + with pytest.raises(ValueError): + make_fitness(function=_mean_square_error, greater_is_better='Sure') + with pytest.raises(ValueError): + make_fitness(function=_mean_square_error, greater_is_better=1) # non-bool wrap - assert_raises(ValueError, - make_fitness, - function=_mean_square_error, - greater_is_better=True, wrap='f') + with pytest.raises(ValueError): + make_fitness(function=_mean_square_error, + greater_is_better=True, + wrap='f') # Check arg count tests def bad_fun1(x1, x2): return 1.0 - assert_raises(ValueError, - make_fitness, - function=bad_fun1, - greater_is_better=True) + with pytest.raises(ValueError): + make_fitness(function=bad_fun1, greater_is_better=True) # Check return type tests def bad_fun2(x1, x2, w): return 'ni' - assert_raises(ValueError, - make_fitness, - function=bad_fun2, - greater_is_better=True) + with pytest.raises(ValueError): + make_fitness(function=bad_fun2, greater_is_better=True) def _custom_metric(y, y_pred, w): """Calculate the root mean square error.""" @@ -211,11 +203,13 @@ def test_parallel_custom_metric(): random_state=0, n_jobs=2) est.fit(diabetes.data, diabetes.target) - assert_raises(AttributeError, pickle.dumps, est) + with pytest.raises(AttributeError): + pickle.dumps(est) # Single threaded will also fail in non-interactive sessions est = SymbolicRegressor(generations=2, metric=custom_metric, random_state=0) est.fit(diabetes.data, diabetes.target) - assert_raises(AttributeError, pickle.dumps, est) + with pytest.raises(AttributeError): + pickle.dumps(est) diff --git a/gplearn/tests/test_functions.py b/gplearn/tests/test_functions.py index 5b4df74..8053e7c 100644 --- a/gplearn/tests/test_functions.py +++ b/gplearn/tests/test_functions.py @@ -7,9 +7,9 @@ import pickle import numpy as np +import pytest from numpy import maximum from sklearn.datasets import load_diabetes, load_breast_cancer -from sklearn.utils._testing import assert_raises from sklearn.utils.validation import check_random_state from gplearn.functions import _protected_sqrt, make_function @@ -36,79 +36,48 @@ def test_validate_function(): # Check arity tests _ = make_function(function=_protected_sqrt, name='sqrt', arity=1) # non-integer arity - assert_raises(ValueError, - make_function, - function=_protected_sqrt, - name='sqrt', - arity='1') - assert_raises(ValueError, - make_function, - function=_protected_sqrt, - name='sqrt', - arity=1.0) + with pytest.raises(ValueError): + make_function(function=_protected_sqrt, name='sqrt', arity='1') + with pytest.raises(ValueError): + make_function(function=_protected_sqrt, name='sqrt', arity=1.0) # non-bool wrap - assert_raises(ValueError, - make_function, - function=_protected_sqrt, - name='sqrt', - arity=1, - wrap='f') + with pytest.raises(ValueError): + make_function(function=_protected_sqrt, name='sqrt', arity=1, wrap='f') # non-matching arity - assert_raises(ValueError, - make_function, - function=_protected_sqrt, - name='sqrt', - arity=2) - assert_raises(ValueError, - make_function, - function=maximum, - name='max', - arity=1) + with pytest.raises(ValueError): + make_function(function=_protected_sqrt, name='sqrt', arity=2) + with pytest.raises(ValueError): + make_function(function=maximum, name='max', arity=1) # Check name test - assert_raises(ValueError, - make_function, - function=_protected_sqrt, - name=2, - arity=1) + with pytest.raises(ValueError): + make_function(function=_protected_sqrt, name=2, arity=1) # Check return type tests def bad_fun1(x1, x2): return 'ni' - assert_raises(ValueError, - make_function, - function=bad_fun1, - name='ni', - arity=2) + with pytest.raises(ValueError): + make_function(function=bad_fun1, name='ni', arity=2) # Check return shape tests def bad_fun2(x1): return np.ones((2, 1)) - assert_raises(ValueError, - make_function, - function=bad_fun2, - name='ni', - arity=1) + with pytest.raises(ValueError): + make_function(function=bad_fun2, name='ni', arity=1) # Check closure for negatives test def _unprotected_sqrt(x1): with np.errstate(divide='ignore', invalid='ignore'): return np.sqrt(x1) - assert_raises(ValueError, - make_function, - function=_unprotected_sqrt, - name='sqrt', - arity=1) + with pytest.raises(ValueError): + make_function(function=_unprotected_sqrt, name='sqrt', arity=1) # Check closure for zeros test def _unprotected_div(x1, x2): with np.errstate(divide='ignore', invalid='ignore'): return np.divide(x1, x2) - assert_raises(ValueError, - make_function, - function=_unprotected_div, - name='div', - arity=2) + with pytest.raises(ValueError): + make_function(function=_unprotected_div, name='div', arity=2) def test_function_in_program(): @@ -160,14 +129,16 @@ def test_parallel_custom_function(): random_state=0, n_jobs=2) est.fit(diabetes.data, diabetes.target) - assert_raises(AttributeError, pickle.dumps, est) + with pytest.raises(AttributeError): + pickle.dumps(est) # Single threaded will also fail in non-interactive sessions est = SymbolicRegressor(generations=2, function_set=['add', 'sub', 'mul', 'div', logical], random_state=0) est.fit(diabetes.data, diabetes.target) - assert_raises(AttributeError, pickle.dumps, est) + with pytest.raises(AttributeError): + pickle.dumps(est) def test_parallel_custom_transformer(): @@ -197,11 +168,13 @@ def test_parallel_custom_transformer(): random_state=0, n_jobs=2) est.fit(cancer.data, cancer.target) - assert_raises(AttributeError, pickle.dumps, est) + with pytest.raises(AttributeError): + pickle.dumps(est) # Single threaded will also fail in non-interactive sessions est = SymbolicClassifier(generations=2, transformer=sigmoid, random_state=0) est.fit(cancer.data, cancer.target) - assert_raises(AttributeError, pickle.dumps, est) + with pytest.raises(AttributeError): + pickle.dumps(est) diff --git a/gplearn/tests/test_genetic.py b/gplearn/tests/test_genetic.py index 1364d51..d7e59c0 100644 --- a/gplearn/tests/test_genetic.py +++ b/gplearn/tests/test_genetic.py @@ -7,11 +7,14 @@ gplearn.genetic.SymbolicRegressor and gplearn.genetic.SymbolicTransformer.""" # License: BSD 3 clause import pickle -import pytest import sys from io import StringIO import numpy as np +import pytest +from numpy.testing import assert_almost_equal +from numpy.testing import assert_array_equal +from numpy.testing import assert_array_almost_equal from scipy.stats import pearsonr, spearmanr from sklearn.datasets import load_diabetes, load_breast_cancer from sklearn.metrics import mean_absolute_error @@ -19,10 +22,6 @@ from sklearn.model_selection import GridSearchCV from sklearn.pipeline import make_pipeline from sklearn.preprocessing import StandardScaler from sklearn.tree import DecisionTreeRegressor -from sklearn.utils._testing import assert_almost_equal -from sklearn.utils._testing import assert_array_equal -from sklearn.utils._testing import assert_array_almost_equal -from sklearn.utils._testing import assert_raises from sklearn.utils.validation import check_random_state from gplearn.genetic import SymbolicClassifier, SymbolicRegressor @@ -175,14 +174,16 @@ def test_validate_program(): random_state, program=test_gp) # Now try a couple that shouldn't be - assert_raises(ValueError, _Program, function_set, arities, init_depth, - init_method, n_features, const_range, metric, - p_point_replace, parsimony_coefficient, random_state, - program=test_gp[:-1]) - assert_raises(ValueError, _Program, function_set, arities, init_depth, - init_method, n_features, const_range, metric, - p_point_replace, parsimony_coefficient, random_state, - program=test_gp + [1]) + with pytest.raises(ValueError): + _Program(function_set, arities, init_depth, + init_method, n_features, const_range, metric, + p_point_replace, parsimony_coefficient, random_state, + program=test_gp[:-1]) + with pytest.raises(ValueError): + _Program(function_set, arities, init_depth, + init_method, n_features, const_range, metric, + p_point_replace, parsimony_coefficient, random_state, + program=test_gp + [1]) def test_print_overloading(): @@ -304,12 +305,14 @@ def test_invalid_feature_names(): # Check invalid length feature_names est = Symbolic(feature_names=['foo', 'bar']) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) # Check invalid type feature_name feature_names = [str(n) for n in range(12)] + [0] est = Symbolic(feature_names=feature_names) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) def test_execute(): @@ -435,21 +438,27 @@ def test_input_validation(): for Symbolic in (SymbolicRegressor, SymbolicTransformer): # Check too much proba est = Symbolic(p_point_mutation=.5) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) # Check invalid init_method est = Symbolic(init_method='ni') - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) # Check invalid const_ranges est = Symbolic(const_range=2) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) est = Symbolic(const_range=[2, 2]) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) est = Symbolic(const_range=(2, 2, 2)) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) est = Symbolic(const_range='ni') - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) # And check acceptable, but strange, representations of const_range est = Symbolic(population_size=100, generations=1, const_range=(2, 2)) est.fit(diabetes.data, diabetes.target) @@ -460,30 +469,40 @@ def test_input_validation(): # Check invalid init_depth est = Symbolic(init_depth=2) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) est = Symbolic(init_depth=2) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) est = Symbolic(init_depth=[2, 2]) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) est = Symbolic(init_depth=(2, 2, 2)) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) est = Symbolic(init_depth='ni') - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) est = Symbolic(init_depth=(4, 2)) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) # And check acceptable, but strange, representations of init_depth est = Symbolic(population_size=100, generations=1, init_depth=(2, 2)) est.fit(diabetes.data, diabetes.target) # Check hall_of_fame and n_components for transformer est = SymbolicTransformer(hall_of_fame=2000) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) est = SymbolicTransformer(n_components=2000) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) est = SymbolicTransformer(hall_of_fame=0) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) est = SymbolicTransformer(n_components=0) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) # Check regressor metrics for m in ['mean absolute error', 'mse', 'rmse', 'pearson', 'spearman']: @@ -491,7 +510,8 @@ def test_input_validation(): est.fit(diabetes.data, diabetes.target) # And check a fake one est = SymbolicRegressor(metric='the larch') - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) # Check transformer metrics for m in ['pearson', 'spearman']: est = SymbolicTransformer(population_size=100, generations=1, metric=m) @@ -499,7 +519,8 @@ def test_input_validation(): # And check the regressor metrics as well as a fake one for m in ['mean absolute error', 'mse', 'rmse', 'the larch']: est = SymbolicTransformer(metric=m) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) def test_input_validation_classifier(): @@ -507,21 +528,27 @@ def test_input_validation_classifier(): # Check too much proba est = SymbolicClassifier(p_point_mutation=.5) - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) # Check invalid init_method est = SymbolicClassifier(init_method='ni') - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) # Check invalid const_ranges est = SymbolicClassifier(const_range=2) - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) est = SymbolicClassifier(const_range=[2, 2]) - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) est = SymbolicClassifier(const_range=(2, 2, 2)) - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) est = SymbolicClassifier(const_range='ni') - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) # And check acceptable, but strange, representations of const_range est = SymbolicClassifier(population_size=100, generations=1, const_range=(2, 2)) @@ -535,17 +562,23 @@ def test_input_validation_classifier(): # Check invalid init_depth est = SymbolicClassifier(init_depth=2) - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) est = SymbolicClassifier(init_depth=2) - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) est = SymbolicClassifier(init_depth=[2, 2]) - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) est = SymbolicClassifier(init_depth=(2, 2, 2)) - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) est = SymbolicClassifier(init_depth='ni') - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) est = SymbolicClassifier(init_depth=(4, 2)) - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) # And check acceptable, but strange, representations of init_depth est = SymbolicClassifier(population_size=100, generations=1, init_depth=(2, 2)) @@ -557,7 +590,8 @@ def test_input_validation_classifier(): est.fit(cancer.data, cancer.target) # And check a fake one est = SymbolicClassifier(metric='the larch') - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) # Check classifier transformers for t in ['sigmoid']: @@ -566,10 +600,12 @@ def test_input_validation_classifier(): est.fit(cancer.data, cancer.target) # And check an incompatible one with wrong arity est = SymbolicClassifier(transformer=sub2) - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) # And check a fake one est = SymbolicClassifier(transformer='the larch') - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) def test_none_const_range(): @@ -997,7 +1033,8 @@ def test_transformer_iterable(): assert np.allclose(fitted_iter, expected_iter, atol=1) # Check IndexError - assert_raises(IndexError, est.__getitem__, 10) + with pytest.raises(IndexError): + est[10] def test_print_overloading_estimator(): @@ -1137,12 +1174,15 @@ def test_validate_functions(): # These should fail est = Symbolic(generations=2, random_state=0, function_set=('ni', 'sub', 'mul', div2)) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) est = Symbolic(generations=2, random_state=0, function_set=(7, 'sub', 'mul', div2)) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) est = Symbolic(generations=2, random_state=0, function_set=()) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) # Now for the classifier... These should be fine est = SymbolicClassifier(population_size=100, generations=2, @@ -1157,12 +1197,15 @@ def test_validate_functions(): # These should fail est = SymbolicClassifier(generations=2, random_state=0, function_set=('ni', 'sub', 'mul', div2)) - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) est = SymbolicClassifier(generations=2, random_state=0, function_set=(7, 'sub', 'mul', div2)) - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) est = SymbolicClassifier(generations=2, random_state=0, function_set=()) - assert_raises(ValueError, est.fit, cancer.data, cancer.target) + with pytest.raises(ValueError): + est.fit(cancer.data, cancer.target) def test_indices(): @@ -1181,13 +1224,16 @@ def test_indices(): test_gp = [mul2, div2, 8, 1, sub2, 9, .5] gp = _Program(random_state=random_state, program=test_gp, **params) - assert_raises(ValueError, gp.get_all_indices) - assert_raises(ValueError, gp._indices) + with pytest.raises(ValueError): + gp.get_all_indices() + with pytest.raises(ValueError): + gp._indices() def get_indices_property(): return gp.indices_ - assert_raises(ValueError, get_indices_property) + with pytest.raises(ValueError): + get_indices_property() indices, _ = gp.get_all_indices(10, 7, random_state) @@ -1222,7 +1268,8 @@ def test_warm_start(): # Check fitting fewer generations raises error est.set_params(generations=5, warm_start=True) - assert_raises(ValueError, est.fit, diabetes.data, diabetes.target) + with pytest.raises(ValueError): + est.fit(diabetes.data, diabetes.target) # Check fitting the same number of generations warns est.set_params(generations=10, warm_start=True) diff --git a/gplearn/tests/test_utils.py b/gplearn/tests/test_utils.py index 6420e7a..82b8333 100644 --- a/gplearn/tests/test_utils.py +++ b/gplearn/tests/test_utils.py @@ -5,7 +5,7 @@ # License: BSD 3 clause import numpy as np -from sklearn.utils._testing import assert_raises +import pytest from gplearn.utils import _get_n_jobs, check_random_state, cpu_count @@ -25,7 +25,8 @@ def test_check_random_state(): rng_42 = np.random.RandomState(42) assert(check_random_state(43).randint(100) != rng_42.randint(100)) - assert_raises(ValueError, check_random_state, "some invalid seed") + with pytest.raises(ValueError): + check_random_state("some invalid seed") def test_get_n_jobs(): @@ -39,4 +40,5 @@ def test_get_n_jobs(): jobs = _get_n_jobs(jobs) assert(jobs == expected) - assert_raises(ValueError, _get_n_jobs, 0) + with pytest.raises(ValueError): + _get_n_jobs(0)