Fix indentation errors in tests (#153)

moves the asserts for error message outside of the assertRaises context

the tests for the error messages were ignored because they were within the assertRaises context

Author: victorprincipe

skcosmo/preprocessing/_data.py

@@ -504,7 +504,7 @@ def fit(self, Knm, Kmm, y=None, sample_weight=None):
 
         if Knm.shape[1] != Kmm.shape[0]:
             raise ValueError(
-                "The reference kernel is not commensurate shape with the"
+                "The reference kernel is not commensurate shape with the "
                 "active kernel."
             )
 

skcosmo/sample_selection/_voronoi_fps.py

@@ -183,13 +183,13 @@ def _init_greedy_search(self, X, y, n_to_select):
             if isinstance(self.full_fraction, numbers.Real):
                 if not 0 < self.full_fraction <= 1:
                     raise ValueError(
-                        "Switching point should be real and more than 0 and less than 1",
-                        f"received {self.full_fraction}",
+                        "Switching point should be real and more than 0 and less than 1. "
+                        f"Received {self.full_fraction}"
                     )
             else:
                 raise ValueError(
-                    "Switching point should be real and more than 0 and less than 1",
-                    f"received {self.full_fraction}",
+                    "Switching point should be real and more than 0 and less than 1. "
+                    f"Received {self.full_fraction}"
                 )
 
         super()._init_greedy_search(X, y, n_to_select)

tests/test_feature_pcov_fps.py

@@ -31,11 +31,10 @@ def test_no_mixing_1(self):
 
         with self.assertRaises(ValueError) as cm:
             _ = PCovFPS(n_to_select=1, mixing=1.0)
-            self.assertEquals(
-                str(cm.message),
-                "Mixing = 1.0 corresponds to traditional FPS."
-                "Please use the FPS class.",
-            )
+        self.assertEqual(
+            str(cm.exception),
+            "Mixing = 1.0 corresponds to traditional FPS." "Please use the FPS class.",
+        )
 
 
 if __name__ == "__main__":

tests/test_feature_simple_fps.py

@@ -45,9 +45,7 @@ def test_initialize(self):
         with self.assertRaises(ValueError) as cm:
             selector = FPS(n_to_select=1, initialize="bad")
             selector.fit(self.X)
-            self.assertEquals(
-                str(cm.message), "Invalid value of the initialize parameter"
-            )
+        self.assertEqual(str(cm.exception), "Invalid value of the initialize parameter")
 
     def test_get_distances(self):
         """

tests/test_greedy_selector.py

@@ -44,19 +44,19 @@ def test_score_threshold(self):
     def test_score_threshold_and_full(self):
         with self.assertRaises(ValueError) as cm:
             _ = GreedyTester(score_threshold=20, full=True, n_to_select=12).fit(self.X)
-            self.assertEqual(
-                str(cm.message),
-                "You cannot specify both `score_threshold` and `full=True`.",
-            )
+        self.assertEqual(
+            str(cm.exception),
+            "You cannot specify both `score_threshold` and `full=True`.",
+        )
 
     def test_bad_warm_start(self):
         selector = GreedyTester()
         with self.assertRaises(ValueError) as cm:
             selector.fit(self.X, warm_start=True)
-            self.assertTrue(
-                str(cm.message),
-                "Cannot fit with warm_start=True without having been previously initialized",
-            )
+        self.assertTrue(
+            str(cm.exception),
+            "Cannot fit with warm_start=True without having been previously initialized",
+        )
 
     def test_bad_y(self):
         self.X, self.Y = get_dataset(return_X_y=True)
@@ -66,11 +66,12 @@ def test_bad_y(self):
 
     def test_bad_transform(self):
         selector = GreedyTester(n_to_select=2)
+        selector.fit(self.X)
         with self.assertRaises(ValueError) as cm:
             _ = selector.transform(self.X[:, :3])
-            self.assertEqual(
-                str(cm.message), "X has a different shape than during fitting."
-            )
+        self.assertEqual(
+            str(cm.exception), "X has a different shape than during fitting."
+        )
 
     def test_no_nfeatures(self):
         selector = GreedyTester()
@@ -88,17 +89,16 @@ def test_bad_nfeatures(self):
                 selector = GreedyTester(n_to_select=nf)
                 with self.assertRaises(ValueError) as cm:
                     selector.fit(self.X)
-                    self.assertEqual(
-                        str(cm.message),
-                        (
-                            "n_to_select must be either None, an "
-                            "integer in [1, n_features - 1] "
-                            "representing the absolute "
-                            "number of features, or a float in (0, 1] "
-                            "representing a percentage of features to "
-                            f"select. Got {nf}"
-                        ),
-                    )
+                self.assertEqual(
+                    str(cm.exception),
+                    (
+                        "n_to_select must be either None, an integer in "
+                        "[1, n_features] representing the absolute number "
+                        "of features, or a float in (0, 1] representing a "
+                        f"percentage of features to select. Got {nf} "
+                        f"features and an input with {self.X.shape[1]} feature."
+                    ),
+                )
 
     def test_not_fitted(self):
         with self.assertRaises(NotFittedError):
@@ -120,18 +120,18 @@ def test_size_input(self):
         selector_sample.fit(X)
         with self.assertRaises(ValueError) as cm:
             selector_feature.fit(X)
-            self.assertEqual(
-                str(cm.message),
-                "Found array with 1 feature(s) (shape=(5, 1)) while a minimum of 2 is required.",
-            )
+        self.assertEqual(
+            str(cm.exception),
+            "Found array with 1 feature(s) (shape=(5, 1)) while a minimum of 2 is required.",
+        )
         X = X.reshape(1, -1)
         selector_feature.fit(X)
         with self.assertRaises(ValueError) as cm:
             selector_sample.fit(X)
-            self.assertEqual(
-                str(cm.message),
-                "Found array with 1 sample(s) (shape=(1, 5)) while a minimum of 2 is required.",
-            )
+        self.assertEqual(
+            str(cm.exception),
+            "Found array with 1 sample(s) (shape=(1, 5)) while a minimum of 2 is required.",
+        )
 
 
 if __name__ == "__main__":

tests/test_kernel_pcovr.py

@@ -232,13 +232,13 @@ def test_regressor_modifications(self):
         # kernel parameters now inconsistent
         with self.assertRaises(ValueError) as cm:
             kpcovr.fit(self.X, self.Y)
-            self.assertTrue(
-                str(cm.message),
-                "Kernel parameter mismatch: the regressor has kernel parameters "
-                "{kernel: linear, gamma: 0.2, degree: 3, coef0: 1, kernel_params: None}"
-                " and KernelPCovR was initialized with kernel parameters "
-                "{kernel: linear, gamma: 0.1, degree: 3, coef0: 1, kernel_params: None}",
-            )
+        self.assertTrue(
+            str(cm.exception),
+            "Kernel parameter mismatch: the regressor has kernel parameters "
+            "{kernel: linear, gamma: 0.2, degree: 3, coef0: 1, kernel_params: None}"
+            " and KernelPCovR was initialized with kernel parameters "
+            "{kernel: linear, gamma: 0.1, degree: 3, coef0: 1, kernel_params: None}",
+        )
 
     def test_incompatible_regressor(self):
         regressor = Ridge(alpha=1e-8)
@@ -247,10 +247,10 @@ def test_incompatible_regressor(self):
 
         with self.assertRaises(ValueError) as cm:
             kpcovr.fit(self.X, self.Y)
-            self.assertTrue(
-                str(cm.message),
-                "Regressor must be an instance of `KernelRidge`",
-            )
+        self.assertTrue(
+            str(cm.exception),
+            "Regressor must be an instance of `KernelRidge`",
+        )
 
     def test_none_regressor(self):
         kpcovr = KernelPCovR(mixing=0.5, regressor=None)
@@ -269,24 +269,24 @@ def test_incompatible_coef_shape(self):
         # Dimension mismatch
         with self.assertRaises(ValueError) as cm:
             kpcovr.fit(self.X, self.Y[:, 0])
-            self.assertTrue(
-                str(cm.message),
-                "The regressor coefficients have a dimension incompatible "
-                "with the supplied target space. "
-                "The coefficients have dimension %d and the targets "
-                "have dimension %d" % (regressor.dual_coef_.ndim, self.Y[:, 0].ndim),
-            )
+        self.assertTrue(
+            str(cm.exception),
+            "The regressor coefficients have a dimension incompatible "
+            "with the supplied target space. "
+            "The coefficients have dimension %d and the targets "
+            "have dimension %d" % (regressor.dual_coef_.ndim, self.Y[:, 0].ndim),
+        )
 
         # Shape mismatch (number of targets)
         with self.assertRaises(ValueError) as cm:
             kpcovr.fit(self.X, self.Y)
-            self.assertTrue(
-                str(cm.message),
-                "The regressor coefficients have a shape incompatible "
-                "with the supplied target space. "
-                "The coefficients have shape %r and the targets "
-                "have shape %r" % (regressor.dual_coef_.shape, self.Y.shape),
-            )
+        self.assertTrue(
+            str(cm.exception),
+            "The regressor coefficients have a shape incompatible "
+            "with the supplied target space. "
+            "The coefficients have shape %r and the targets "
+            "have shape %r" % (regressor.dual_coef_.shape, self.Y.shape),
+        )
 
     def test_precomputed_regression(self):
         regressor = KernelRidge(alpha=1e-8, kernel="rbf", gamma=0.1)
@@ -422,7 +422,7 @@ def test_bad_solver(self):
             kpcovr = self.model(svd_solver="bad")
             kpcovr.fit(self.X, self.Y)
 
-            self.assertTrue(str(cm.message), "Unrecognized svd_solver='bad'" "")
+        self.assertTrue(str(cm.exception), "Unrecognized svd_solver='bad'" "")
 
     def test_good_n_components(self):
         """
@@ -454,60 +454,60 @@ def test_bad_n_components(self):
                 kpcovr = self.model(n_components=-1, svd_solver="auto")
                 kpcovr.fit(self.X, self.Y)
 
-                self.assertTrue(
-                    str(cm.message),
-                    "self.n_components=%r must be between 0 and "
-                    "min(n_samples, n_features)=%r with "
-                    "svd_solver='%s'"
-                    % (
-                        kpcovr.n_components,
-                        self.X.shape[0],
-                        kpcovr.svd_solver,
-                    ),
-                )
+            self.assertTrue(
+                str(cm.exception),
+                "self.n_components=%r must be between 0 and "
+                "min(n_samples, n_features)=%r with "
+                "svd_solver='%s'"
+                % (
+                    kpcovr.n_components,
+                    self.X.shape[0],
+                    kpcovr.svd_solver,
+                ),
+            )
         with self.subTest(type="0_ncomponents"):
             with self.assertRaises(ValueError) as cm:
                 kpcovr = self.model(n_components=0, svd_solver="randomized")
                 kpcovr.fit(self.X, self.Y)
 
-                self.assertTrue(
-                    str(cm.message),
-                    "self.n_components=%r must be between 1 and "
-                    "min(n_samples, n_features)=%r with "
-                    "svd_solver='%s'"
-                    % (
-                        kpcovr.n_components,
-                        self.X.shape[0],
-                        kpcovr.svd_solver,
-                    ),
-                )
+            self.assertTrue(
+                str(cm.exception),
+                "self.n_components=%r must be between 1 and "
+                "min(n_samples, n_features)=%r with "
+                "svd_solver='%s'"
+                % (
+                    kpcovr.n_components,
+                    self.X.shape[0],
+                    kpcovr.svd_solver,
+                ),
+            )
         with self.subTest(type="arpack_X_ncomponents"):
             with self.assertRaises(ValueError) as cm:
                 kpcovr = self.model(n_components=self.X.shape[0], svd_solver="arpack")
                 kpcovr.fit(self.X, self.Y)
-                self.assertTrue(
-                    str(cm.message),
-                    "self.n_components=%r must be strictly less than "
-                    "min(n_samples, n_features)=%r with "
-                    "svd_solver='%s'"
-                    % (
-                        kpcovr.n_components,
-                        self.X.shape[0],
-                        kpcovr.svd_solver,
-                    ),
-                )
+            self.assertTrue(
+                str(cm.exception),
+                "self.n_components=%r must be strictly less than "
+                "min(n_samples, n_features)=%r with "
+                "svd_solver='%s'"
+                % (
+                    kpcovr.n_components,
+                    self.X.shape[0],
+                    kpcovr.svd_solver,
+                ),
+            )
 
         for svd_solver in ["auto", "full"]:
             with self.subTest(type="pi_ncomponents"):
                 with self.assertRaises(ValueError) as cm:
                     kpcovr = self.model(n_components=np.pi, svd_solver=svd_solver)
                     kpcovr.fit(self.X, self.Y)
-                    self.assertTrue(
-                        str(cm.message),
-                        "self.n_components=%r must be of type int "
-                        "when greater than or equal to 1, was of type=%r"
-                        % (kpcovr.n_components, type(kpcovr.n_components)),
-                    )
+                self.assertTrue(
+                    str(cm.exception),
+                    "self.n_components=%r must be of type int "
+                    "when greater than or equal to 1, was of type=%r"
+                    % (kpcovr.n_components, type(kpcovr.n_components)),
+                )
 
 
 if __name__ == "__main__":

tests/test_orthogonalizers.py

@@ -130,11 +130,11 @@ def test_multicolumn(self):
                     -3, 3, size=(self.n_samples + 4, self.n_features)
                 ),
             )
-            self.assertEqual(
-                str(cm.message),
-                "You can only orthogonalize a matrix using a vector with the same number of rows."
-                f"Matrix X has {self.n_samples} rows, whereas the orthogonalizing matrix has {self.n_samples+4} rows.",
-            )
+        self.assertEqual(
+            str(cm.exception),
+            "You can only orthogonalize a matrix using a vector with the same number of rows."
+            f"Matrix X has {self.n_samples} rows, whereas the orthogonalizing matrix has {self.n_samples+4} rows.",
+        )
 
     def test_warning(self):
         # checks that a warning is raised when trying to orthogonalize by