MAINT Remove assert_no_warnings from tests (scikit-learn#29525)

Author: jeremiedbb

sklearn/compose/tests/test_target.py

@@ -10,7 +10,7 @@
 from sklearn.linear_model import LinearRegression, OrthogonalMatchingPursuit
 from sklearn.pipeline import Pipeline
 from sklearn.preprocessing import FunctionTransformer, StandardScaler
-from sklearn.utils._testing import assert_allclose, assert_no_warnings
+from sklearn.utils._testing import assert_allclose
 
 friedman = datasets.make_friedman1(random_state=0)
 
@@ -66,17 +66,17 @@ def test_transform_target_regressor_invertible():
     )
     with pytest.warns(
         UserWarning,
-        match=(
-            "The provided functions or"
-            " transformer are not strictly inverse of each other."
-        ),
+        match=(r"The provided functions.* are not strictly inverse of each other"),
     ):
         regr.fit(X, y)
     regr = TransformedTargetRegressor(
         regressor=LinearRegression(), func=np.sqrt, inverse_func=np.log
     )
     regr.set_params(check_inverse=False)
-    assert_no_warnings(regr.fit, X, y)
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", UserWarning)
+        regr.fit(X, y)
 
 
 def _check_standard_scaled(y, y_pred):

sklearn/metrics/tests/test_classification.py

@@ -45,7 +45,6 @@
     assert_almost_equal,
     assert_array_almost_equal,
     assert_array_equal,
-    assert_no_warnings,
     ignore_warnings,
 )
 from sklearn.utils.extmath import _nanaverage
@@ -266,24 +265,24 @@ def test_precision_recall_f1_score_binary():
     # individual scoring function that can be used for grid search: in the
     # binary class case the score is the value of the measure for the positive
     # class (e.g. label == 1). This is deprecated for average != 'binary'.
-    for kwargs, my_assert in [
-        ({}, assert_no_warnings),
-        ({"average": "binary"}, assert_no_warnings),
-    ]:
-        ps = my_assert(precision_score, y_true, y_pred, **kwargs)
-        assert_array_almost_equal(ps, 0.85, 2)
+    for kwargs in [{}, {"average": "binary"}]:
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
 
-        rs = my_assert(recall_score, y_true, y_pred, **kwargs)
-        assert_array_almost_equal(rs, 0.68, 2)
+            ps = precision_score(y_true, y_pred, **kwargs)
+            assert_array_almost_equal(ps, 0.85, 2)
 
-        fs = my_assert(f1_score, y_true, y_pred, **kwargs)
-        assert_array_almost_equal(fs, 0.76, 2)
+            rs = recall_score(y_true, y_pred, **kwargs)
+            assert_array_almost_equal(rs, 0.68, 2)
 
-        assert_almost_equal(
-            my_assert(fbeta_score, y_true, y_pred, beta=2, **kwargs),
-            (1 + 2**2) * ps * rs / (2**2 * ps + rs),
-            2,
-        )
+            fs = f1_score(y_true, y_pred, **kwargs)
+            assert_array_almost_equal(fs, 0.76, 2)
+
+            assert_almost_equal(
+                fbeta_score(y_true, y_pred, beta=2, **kwargs),
+                (1 + 2**2) * ps * rs / (2**2 * ps + rs),
+                2,
+            )
 
 
 @ignore_warnings
@@ -1919,22 +1918,23 @@ def test_precision_recall_f1_no_labels(beta, average, zero_division):
     y_true = np.zeros((20, 3))
     y_pred = np.zeros_like(y_true)
 
-    p, r, f, s = assert_no_warnings(
-        precision_recall_fscore_support,
-        y_true,
-        y_pred,
-        average=average,
-        beta=beta,
-        zero_division=zero_division,
-    )
-    fbeta = assert_no_warnings(
-        fbeta_score,
-        y_true,
-        y_pred,
-        beta=beta,
-        average=average,
-        zero_division=zero_division,
-    )
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+
+        p, r, f, s = precision_recall_fscore_support(
+            y_true,
+            y_pred,
+            average=average,
+            beta=beta,
+            zero_division=zero_division,
+        )
+        fbeta = fbeta_score(
+            y_true,
+            y_pred,
+            beta=beta,
+            average=average,
+            zero_division=zero_division,
+        )
     assert s is None
 
     # if zero_division = nan, check that all metrics are nan and exit
@@ -1984,17 +1984,20 @@ def test_precision_recall_f1_no_labels_average_none(zero_division):
     # |y_i| = [0, 0, 0]
     # |y_hat_i| = [0, 0, 0]
 
-    p, r, f, s = assert_no_warnings(
-        precision_recall_fscore_support,
-        y_true,
-        y_pred,
-        average=None,
-        beta=1.0,
-        zero_division=zero_division,
-    )
-    fbeta = assert_no_warnings(
-        fbeta_score, y_true, y_pred, beta=1.0, average=None, zero_division=zero_division
-    )
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+
+        p, r, f, s = precision_recall_fscore_support(
+            y_true,
+            y_pred,
+            average=None,
+            beta=1.0,
+            zero_division=zero_division,
+        )
+        fbeta = fbeta_score(
+            y_true, y_pred, beta=1.0, average=None, zero_division=zero_division
+        )
+
     zero_division = np.float64(zero_division)
     assert_array_almost_equal(p, [zero_division, zero_division, zero_division], 2)
     assert_array_almost_equal(r, [zero_division, zero_division, zero_division], 2)
@@ -2138,59 +2141,57 @@ def test_prf_warnings():
 
 @pytest.mark.parametrize("zero_division", [0, 1, np.nan])
 def test_prf_no_warnings_if_zero_division_set(zero_division):
-    # average of per-label scores
-    f = precision_recall_fscore_support
-    for average in [None, "weighted", "macro"]:
-        assert_no_warnings(
-            f, [0, 1, 2], [1, 1, 2], average=average, zero_division=zero_division
-        )
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
 
-        assert_no_warnings(
-            f, [1, 1, 2], [0, 1, 2], average=average, zero_division=zero_division
-        )
+        # average of per-label scores
+        for average in [None, "weighted", "macro"]:
+            precision_recall_fscore_support(
+                [0, 1, 2], [1, 1, 2], average=average, zero_division=zero_division
+            )
 
-    # average of per-sample scores
-    assert_no_warnings(
-        f,
-        np.array([[1, 0], [1, 0]]),
-        np.array([[1, 0], [0, 0]]),
-        average="samples",
-        zero_division=zero_division,
-    )
+            precision_recall_fscore_support(
+                [1, 1, 2], [0, 1, 2], average=average, zero_division=zero_division
+            )
 
-    assert_no_warnings(
-        f,
-        np.array([[1, 0], [0, 0]]),
-        np.array([[1, 0], [1, 0]]),
-        average="samples",
-        zero_division=zero_division,
-    )
+        # average of per-sample scores
+        precision_recall_fscore_support(
+            np.array([[1, 0], [1, 0]]),
+            np.array([[1, 0], [0, 0]]),
+            average="samples",
+            zero_division=zero_division,
+        )
 
-    # single score: micro-average
-    assert_no_warnings(
-        f,
-        np.array([[1, 1], [1, 1]]),
-        np.array([[0, 0], [0, 0]]),
-        average="micro",
-        zero_division=zero_division,
-    )
+        precision_recall_fscore_support(
+            np.array([[1, 0], [0, 0]]),
+            np.array([[1, 0], [1, 0]]),
+            average="samples",
+            zero_division=zero_division,
+        )
 
-    assert_no_warnings(
-        f,
-        np.array([[0, 0], [0, 0]]),
-        np.array([[1, 1], [1, 1]]),
-        average="micro",
-        zero_division=zero_division,
-    )
+        # single score: micro-average
+        precision_recall_fscore_support(
+            np.array([[1, 1], [1, 1]]),
+            np.array([[0, 0], [0, 0]]),
+            average="micro",
+            zero_division=zero_division,
+        )
 
-    # single positive label
-    assert_no_warnings(
-        f, [1, 1], [-1, -1], average="binary", zero_division=zero_division
-    )
+        precision_recall_fscore_support(
+            np.array([[0, 0], [0, 0]]),
+            np.array([[1, 1], [1, 1]]),
+            average="micro",
+            zero_division=zero_division,
+        )
 
-    assert_no_warnings(
-        f, [-1, -1], [1, 1], average="binary", zero_division=zero_division
-    )
+        # single positive label
+        precision_recall_fscore_support(
+            [1, 1], [-1, -1], average="binary", zero_division=zero_division
+        )
+
+        precision_recall_fscore_support(
+            [-1, -1], [1, 1], average="binary", zero_division=zero_division
+        )
 
     with warnings.catch_warnings(record=True) as record:
         warnings.simplefilter("always")
@@ -2202,13 +2203,16 @@ def test_prf_no_warnings_if_zero_division_set(zero_division):
 
 @pytest.mark.parametrize("zero_division", ["warn", 0, 1, np.nan])
 def test_recall_warnings(zero_division):
-    assert_no_warnings(
-        recall_score,
-        np.array([[1, 1], [1, 1]]),
-        np.array([[0, 0], [0, 0]]),
-        average="micro",
-        zero_division=zero_division,
-    )
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+
+        recall_score(
+            np.array([[1, 1], [1, 1]]),
+            np.array([[0, 0], [0, 0]]),
+            average="micro",
+            zero_division=zero_division,
+        )
+
     with warnings.catch_warnings(record=True) as record:
         warnings.simplefilter("always")
         recall_score(
@@ -2266,13 +2270,15 @@ def test_precision_warnings(zero_division):
                 " this behavior."
             )
 
-    assert_no_warnings(
-        precision_score,
-        np.array([[0, 0], [0, 0]]),
-        np.array([[1, 1], [1, 1]]),
-        average="micro",
-        zero_division=zero_division,
-    )
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+
+        precision_score(
+            np.array([[0, 0], [0, 0]]),
+            np.array([[1, 1], [1, 1]]),
+            average="micro",
+            zero_division=zero_division,
+        )
 
 
 @pytest.mark.parametrize("zero_division", ["warn", 0, 1, np.nan])

sklearn/preprocessing/tests/test_encoders.py

@@ -1,4 +1,5 @@
 import re
+import warnings
 
 import numpy as np
 import pytest
@@ -796,7 +797,9 @@ def test_encoder_dtypes_pandas():
 def test_one_hot_encoder_warning():
     enc = OneHotEncoder()
     X = [["Male", 1], ["Female", 3]]
-    np.testing.assert_no_warnings(enc.fit_transform, X)
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        enc.fit_transform(X)
 
 
 @pytest.mark.parametrize("missing_value", [np.nan, None, float("nan")])

sklearn/tests/test_base.py

@@ -34,7 +34,6 @@
 from sklearn.utils._testing import (
     _convert_container,
     assert_array_equal,
-    assert_no_warnings,
     ignore_warnings,
 )
 
@@ -472,7 +471,10 @@ def test_pickle_version_warning_is_not_raised_with_matching_version():
     tree = DecisionTreeClassifier().fit(iris.data, iris.target)
     tree_pickle = pickle.dumps(tree)
     assert b"_sklearn_version" in tree_pickle
-    tree_restored = assert_no_warnings(pickle.loads, tree_pickle)
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("error")
+        tree_restored = pickle.loads(tree_pickle)
 
     # test that we can predict with the restored decision tree classifier
     score_of_original = tree.score(iris.data, iris.target)
@@ -542,7 +544,11 @@ def test_pickle_version_no_warning_is_issued_with_non_sklearn_estimator():
     try:
         module_backup = TreeNoVersion.__module__
         TreeNoVersion.__module__ = "notsklearn"
-        assert_no_warnings(pickle.loads, tree_pickle_noversion)
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("error")
+
+            pickle.loads(tree_pickle_noversion)
     finally:
         TreeNoVersion.__module__ = module_backup
 

sklearn/utils/_testing.py

@@ -32,7 +32,6 @@
     assert_array_almost_equal,
     assert_array_equal,
     assert_array_less,
-    assert_no_warnings,
 )
 
 import sklearn
@@ -61,7 +60,6 @@
     "assert_approx_equal",
     "assert_allclose",
     "assert_run_python_script_without_output",
-    "assert_no_warnings",
     "SkipTest",
 ]