CLN/TST: use assertIsInstance (#75)

pandas_ml/misc/test/test_patsy.py

@@ -18,7 +18,7 @@ def test_patsy_matrices(self):
         mdf = pdml.ModelFrame(df, target=s)
 
         result = mdf.transform('A ~ B + C')
-        self.assertTrue(isinstance(result, pdml.ModelFrame))
+        self.assertIsInstance(result, pdml.ModelFrame)
         self.assertEqual(result.shape, (3, 4))
         self.assert_index_equal(result.index, pd.Index(['a', 'b', 'c']))
         self.assert_index_equal(result.columns, pd.Index(['A', 'Intercept', 'B', 'C']))
@@ -45,7 +45,7 @@ def test_patsy_matrix(self):
         mdf = pdml.ModelFrame(df, target=s)
 
         result = mdf.transform('B + C')
-        self.assertTrue(isinstance(result, pdml.ModelFrame))
+        self.assertIsInstance(result, pdml.ModelFrame)
         self.assertEqual(result.shape, (3, 3))
         self.assert_index_equal(result.index, pd.Index(['a', 'b', 'c']))
         self.assert_index_equal(result.columns, pd.Index(['Intercept', 'B', 'C']))

pandas_ml/skaccessors/test/test_cluster.py

@@ -47,7 +47,7 @@ def test_k_means(self):
         self.assertEqual(len(result), 3)
         self.assert_numpy_array_almost_equal(result[0], expected[0])
 
-        self.assertTrue(isinstance(result[1], pdml.ModelSeries))
+        self.assertIsInstance(result[1], pdml.ModelSeries)
         self.assert_index_equal(result[1].index, df.index)
         self.assert_numpy_array_equal(result[1].values, expected[1])
 
@@ -86,7 +86,7 @@ def test_affinity_propagation(self):
         self.assertEqual(len(result), 2)
         self.assert_numpy_array_almost_equal(result[0], expected[0])
 
-        self.assertTrue(isinstance(result[1], pdml.ModelSeries))
+        self.assertIsInstance(result[1], pdml.ModelSeries)
         self.assert_index_equal(result[1].index, df.index)
         self.assert_numpy_array_equal(result[1].values, expected[1])
 
@@ -117,7 +117,7 @@ def test_dbscan(self):
 
         self.assertEqual(len(result), 2)
         self.assert_numpy_array_almost_equal(result[0], expected[0])
-        self.assertTrue(isinstance(result[1], pdml.ModelSeries))
+        self.assertIsInstance(result[1], pdml.ModelSeries)
         self.assert_index_equal(result[1].index, df.index)
         self.assert_numpy_array_equal(result[1].values, expected[1])
 
@@ -130,7 +130,7 @@ def test_mean_shift(self):
 
         self.assertEqual(len(result), 2)
         self.assert_numpy_array_almost_equal(result[0], expected[0])
-        self.assertTrue(isinstance(result[1], pdml.ModelSeries))
+        self.assertIsInstance(result[1], pdml.ModelSeries)
         self.assert_index_equal(result[1].index, df.index)
         self.assert_numpy_array_equal(result[1].values, expected[1])
 
@@ -143,7 +143,7 @@ def test_spectral_clustering(self):
         result = df.cluster.spectral_clustering(random_state=self.random_state)
         expected = cluster.spectral_clustering(m, random_state=self.random_state)
 
-        self.assertTrue(isinstance(result, pdml.ModelSeries))
+        self.assertIsInstance(result, pdml.ModelSeries)
         self.assert_index_equal(result.index, df.index)
         self.assert_numpy_array_equal(result.values, expected)
 
@@ -162,7 +162,7 @@ def test_KMeans(self):
             result = df.predict(mod1)
             expected = mod2.predict(iris.data)
 
-            self.assertTrue(isinstance(result, pdml.ModelSeries))
+            self.assertIsInstance(result, pdml.ModelSeries)
             self.assert_numpy_array_almost_equal(result.values, expected)
 
     def test_KMeans_scores(self):
@@ -216,7 +216,7 @@ def test_Classifications(self):
             result = df.predict(mod1)
             expected = mod2.predict(iris.data)
 
-            self.assertTrue(isinstance(result, pdml.ModelSeries))
+            self.assertIsInstance(result, pdml.ModelSeries)
             self.assert_numpy_array_almost_equal(result.values, expected)
 
     def test_fit_predict(self):
@@ -231,7 +231,7 @@ def test_fit_predict(self):
             result = df.fit_predict(mod1)
             expected = mod2.fit_predict(iris.data)
 
-            self.assertTrue(isinstance(result, pdml.ModelSeries))
+            self.assertIsInstance(result, pdml.ModelSeries)
             self.assert_numpy_array_almost_equal(result.values, expected)
 
             result = df.score(mod1)

pandas_ml/skaccessors/test/test_covariance.py

@@ -29,7 +29,7 @@ def test_empirical_covariance(self):
 
         result = df.covariance.empirical_covariance()
         expected = covariance.empirical_covariance(iris.data)
-        self.assertTrue(isinstance(result, pdml.ModelFrame))
+        self.assertIsInstance(result, pdml.ModelFrame)
         self.assert_index_equal(result.index, df.data.columns)
         self.assert_index_equal(result.columns, df.data.columns)
         self.assert_numpy_array_almost_equal(result.values, expected)
@@ -43,7 +43,7 @@ def test_ledoit_wolf(self):
 
         self.assertEqual(len(result), 2)
 
-        self.assertTrue(isinstance(result[0], pdml.ModelFrame))
+        self.assertIsInstance(result[0], pdml.ModelFrame)
         self.assert_index_equal(result[0].index, df.data.columns)
         self.assert_index_equal(result[0].columns, df.data.columns)
         self.assert_numpy_array_almost_equal(result[0].values, expected[0])
@@ -59,7 +59,7 @@ def test_oas(self):
 
         self.assertEqual(len(result), 2)
 
-        self.assertTrue(isinstance(result[0], pdml.ModelFrame))
+        self.assertIsInstance(result[0], pdml.ModelFrame)
         self.assert_index_equal(result[0].index, df.data.columns)
         self.assert_index_equal(result[0].columns, df.data.columns)
         self.assert_numpy_array_almost_equal(result[0].values, expected[0])

pandas_ml/skaccessors/test/test_cross_decomposition.py

@@ -29,13 +29,15 @@ def test_CCA(self):
         mod2.fit(X, Y)
 
         # 2nd cols are different on travis-CI
-        self.assert_numpy_array_almost_equal(mod1.x_weights_[:, 0], mod2.x_weights_[:, 0])
-        self.assert_numpy_array_almost_equal(mod1.y_weights_[:, 0], mod2.y_weights_[:, 0])
+        self.assert_numpy_array_almost_equal(mod1.x_weights_[:, 0],
+                                             mod2.x_weights_[:, 0])
+        self.assert_numpy_array_almost_equal(mod1.y_weights_[:, 0],
+                                             mod2.y_weights_[:, 0])
 
         result = df.transform(mod1)
         expected = mod2.transform(X, Y)
 
-        self.assertTrue(isinstance(result, pdml.ModelFrame))
+        self.assertIsInstance(result, pdml.ModelFrame)
         self.assert_numpy_array_almost_equal(result.data.values.reshape(4),
                                              expected[0].reshape(4))
         self.assert_numpy_array_almost_equal(result.target.values.reshape(4),
@@ -82,21 +84,27 @@ def test_CCA_PLSCannonical(self):
             mod2.fit(X_train, Y_train)
 
             # 2nd cols are different on travis-CI
-            self.assert_numpy_array_almost_equal(mod1.x_weights_[:, 0], mod2.x_weights_[:, 0])
-            self.assert_numpy_array_almost_equal(mod1.y_weights_[:, 0], mod2.y_weights_[:, 0])
+            self.assert_numpy_array_almost_equal(mod1.x_weights_[:, 0],
+                                                 mod2.x_weights_[:, 0])
+            self.assert_numpy_array_almost_equal(mod1.y_weights_[:, 0],
+                                                 mod2.y_weights_[:, 0])
 
             result_tr = train.transform(mod1)
             result_test = test.transform(mod1)
 
             expected_tr = mod2.transform(X_train, Y_train)
             expected_test = mod2.transform(X_test, Y_test)
 
-            self.assertTrue(isinstance(result_tr, pdml.ModelFrame))
-            self.assertTrue(isinstance(result_test, pdml.ModelFrame))
-            self.assert_numpy_array_almost_equal(result_tr.data.values[:, 0], expected_tr[0][:, 0])
-            self.assert_numpy_array_almost_equal(result_tr.target.values[:, 0], expected_tr[1][:, 0])
-            self.assert_numpy_array_almost_equal(result_test.data.values[:, 0], expected_test[0][:, 0])
-            self.assert_numpy_array_almost_equal(result_test.target.values[:, 0], expected_test[1][:, 0])
+            self.assertIsInstance(result_tr, pdml.ModelFrame)
+            self.assertIsInstance(result_test, pdml.ModelFrame)
+            self.assert_numpy_array_almost_equal(result_tr.data.values[:, 0],
+                                                 expected_tr[0][:, 0])
+            self.assert_numpy_array_almost_equal(result_tr.target.values[:, 0],
+                                                 expected_tr[1][:, 0])
+            self.assert_numpy_array_almost_equal(result_test.data.values[:, 0],
+                                                 expected_test[0][:, 0])
+            self.assert_numpy_array_almost_equal(result_test.target.values[:, 0],
+                                                 expected_test[1][:, 0])
 
     def test_PLSRegression(self):
 
@@ -117,7 +125,7 @@ def test_PLSRegression(self):
         pls2.fit(X, Y)
         expected = pls2.predict(X)
 
-        self.assertTrue(isinstance(result, pdml.ModelFrame))
+        self.assertIsInstance(result, pdml.ModelFrame)
         self.assert_numpy_array_almost_equal(result.values, expected)
 
 if __name__ == '__main__':

pandas_ml/skaccessors/test/test_cross_validation.py

@@ -35,8 +35,8 @@ def test_iterate(self):
         df = pdml.ModelFrame(datasets.load_iris())
         kf = df.cross_validation.KFold(4, n_folds=2, random_state=self.random_state)
         for train_df, test_df in df.cross_validation.iterate(kf):
-            self.assertTrue(isinstance(train_df, pdml.ModelFrame))
-            self.assertTrue(isinstance(test_df, pdml.ModelFrame))
+            self.assertIsInstance(train_df, pdml.ModelFrame)
+            self.assertIsInstance(test_df, pdml.ModelFrame)
             self.assert_index_equal(df.columns, train_df.columns)
             self.assert_index_equal(df.columns, test_df.columns)
 
@@ -59,18 +59,23 @@ def test_iterate_keep_index(self):
 
         folded = [f for f in df.cross_validation.iterate(kf, reset_index=True)]
         self.assertEqual(len(folded), 3)
-        self.assert_frame_equal(folded[0][0], df.iloc[3:, :].reset_index(drop=True))
-        self.assert_frame_equal(folded[0][1], df.iloc[:3, :].reset_index(drop=True))
+        self.assert_frame_equal(folded[0][0],
+                                df.iloc[3:, :].reset_index(drop=True))
+        self.assert_frame_equal(folded[0][1],
+                                df.iloc[:3, :].reset_index(drop=True))
         self.assert_frame_equal(folded[1][0],
                                 df.iloc[[0, 1, 2, 6, 7], :].reset_index(drop=True))
-        self.assert_frame_equal(folded[1][1], df.iloc[3:6, :].reset_index(drop=True))
-        self.assert_frame_equal(folded[2][0], df.iloc[:6, :].reset_index(drop=True))
-        self.assert_frame_equal(folded[2][1], df.iloc[6:, :].reset_index(drop=True))
+        self.assert_frame_equal(folded[1][1],
+                                df.iloc[3:6, :].reset_index(drop=True))
+        self.assert_frame_equal(folded[2][0],
+                                df.iloc[:6, :].reset_index(drop=True))
+        self.assert_frame_equal(folded[2][1],
+                                df.iloc[6:, :].reset_index(drop=True))
 
     def test_train_test_split(self):
 
         df = pdml.ModelFrame(datasets.load_digits())
-        self.assertTrue(isinstance(df, pdml.ModelFrame))
+        self.assertIsInstance(df, pdml.ModelFrame)
 
         train_df, test_df = df.cross_validation.train_test_split()
         self.assert_index_equal(df.columns, train_df.columns)
@@ -95,7 +100,7 @@ def test_train_test_split(self):
     def test_train_test_split_abbr(self):
 
         df = pdml.ModelFrame(datasets.load_digits())
-        self.assertTrue(isinstance(df, pdml.ModelFrame))
+        self.assertIsInstance(df, pdml.ModelFrame)
 
         train_df, test_df = df.crv.train_test_split()
         self.assert_index_equal(df.columns, train_df.columns)
@@ -174,7 +179,7 @@ def test_check_cv(self):
 
         df = pdml.ModelFrame(iris)
         result = df.cross_validation.check_cv(cv=5)
-        self.assertTrue(isinstance(result, cv.KFold))
+        self.assertIsInstance(result, cv.KFold)
 
     def test_StratifiedShuffleSplit(self):
         iris = datasets.load_iris()
@@ -189,8 +194,8 @@ def test_StratifiedShuffleSplit(self):
         with tm.assert_produces_warning(UserWarning):
             # StratifiedShuffleSplit is not a subclass of PartitionIterator
             for train_df, test_df in df.cross_validation.iterate(sf1):
-                self.assertTrue(isinstance(train_df, pdml.ModelFrame))
-                self.assertTrue(isinstance(test_df, pdml.ModelFrame))
+                self.assertIsInstance(train_df, pdml.ModelFrame)
+                self.assertIsInstance(test_df, pdml.ModelFrame)
                 self.assert_index_equal(df.columns, train_df.columns)
                 self.assert_index_equal(df.columns, test_df.columns)
 

pandas_ml/skaccessors/test/test_decomposition.py

@@ -46,14 +46,14 @@ def test_fastica(self):
                                          random_state=self.random_state)
 
         self.assertEqual(len(result), 3)
-        self.assertTrue(isinstance(result[0], pdml.ModelFrame))
+        self.assertIsInstance(result[0], pdml.ModelFrame)
         self.assert_index_equal(result[0].index, df.data.columns)
         self.assert_numpy_array_almost_equal(result[0].values, expected[0])
 
-        self.assertTrue(isinstance(result[1], pdml.ModelFrame))
+        self.assertIsInstance(result[1], pdml.ModelFrame)
         self.assert_numpy_array_almost_equal(result[1].values, expected[1])
 
-        self.assertTrue(isinstance(result[2], pdml.ModelFrame))
+        self.assertIsInstance(result[2], pdml.ModelFrame)
         self.assert_index_equal(result[2].index, df.index)
         self.assert_numpy_array_almost_equal(result[2].values, expected[2])
 
@@ -63,14 +63,14 @@ def test_fastica(self):
                                          random_state=self.random_state)
 
         self.assertEqual(len(result), 4)
-        self.assertTrue(isinstance(result[0], pdml.ModelFrame))
+        self.assertIsInstance(result[0], pdml.ModelFrame)
         self.assert_index_equal(result[0].index, df.data.columns)
         self.assert_numpy_array_almost_equal(result[0].values, expected[0])
 
-        self.assertTrue(isinstance(result[1], pdml.ModelFrame))
+        self.assertIsInstance(result[1], pdml.ModelFrame)
         self.assert_numpy_array_almost_equal(result[1].values, expected[1])
 
-        self.assertTrue(isinstance(result[2], pdml.ModelFrame))
+        self.assertIsInstance(result[2], pdml.ModelFrame)
         self.assert_index_equal(result[2].index, df.index)
         self.assert_numpy_array_almost_equal(result[2].values, expected[2])
 
@@ -84,11 +84,11 @@ def test_dict_learning(self):
         expected = decomposition.dict_learning(iris.data, 2, 1,
                                                random_state=self.random_state)
         self.assertEqual(len(result), 3)
-        self.assertTrue(isinstance(result[0], pdml.ModelFrame))
+        self.assertIsInstance(result[0], pdml.ModelFrame)
         self.assert_index_equal(result[0].index, df.data.index)
         self.assert_numpy_array_almost_equal(result[0].values, expected[0])
 
-        self.assertTrue(isinstance(result[1], pdml.ModelFrame))
+        self.assertIsInstance(result[1], pdml.ModelFrame)
         self.assert_index_equal(result[1].columns, df.data.columns)
         self.assert_numpy_array_almost_equal(result[1].values, expected[1])
 
@@ -103,11 +103,11 @@ def test_dict_learning_online(self):
                                                       random_state=self.random_state)
 
         self.assertEqual(len(result), 2)
-        self.assertTrue(isinstance(result[0], pdml.ModelFrame))
+        self.assertIsInstance(result[0], pdml.ModelFrame)
         self.assert_index_equal(result[0].index, df.data.index)
         self.assert_numpy_array_almost_equal(result[0].values, expected[0])
 
-        self.assertTrue(isinstance(result[1], pdml.ModelFrame))
+        self.assertIsInstance(result[1], pdml.ModelFrame)
         self.assert_index_equal(result[1].columns, df.data.columns)
         self.assert_numpy_array_almost_equal(result[1].values, expected[1])
 
@@ -116,7 +116,7 @@ def test_dict_learning_online(self):
         expected = decomposition.dict_learning_online(iris.data,
                                                       return_code=False,
                                                       random_state=self.random_state)
-        self.assertTrue(isinstance(result, pdml.ModelFrame))
+        self.assertIsInstance(result, pdml.ModelFrame)
         self.assert_index_equal(result.columns, df.data.columns)
         self.assert_numpy_array_almost_equal(result.values, expected)
 
@@ -129,7 +129,7 @@ def test_sparse_encode(self):
 
         result = df.decomposition.sparse_encode(dictionary)
         expected = decomposition.sparse_encode(iris.data, dictionary)
-        self.assertTrue(isinstance(result, pdml.ModelFrame))
+        self.assertIsInstance(result, pdml.ModelFrame)
         self.assert_index_equal(result.index, df.data.index)
         self.assert_numpy_array_almost_equal(result.values, expected)
 
@@ -146,7 +146,7 @@ def test_Decompositions_PCA(self):
         result = df.transform(mod1)
         expected = mod2.transform(iris.data)
 
-        self.assertTrue(isinstance(result, pdml.ModelFrame))
+        self.assertIsInstance(result, pdml.ModelFrame)
         self.assert_series_equal(df.target, result.target)
         self.assert_numpy_array_almost_equal(result.data.values,
                                              expected)
@@ -161,7 +161,7 @@ def test_fit_transform_PCA(self):
         result = df.fit_transform(mod1)
         expected = mod2.fit_transform(iris.data, iris.target)
 
-        self.assertTrue(isinstance(result, pdml.ModelFrame))
+        self.assertIsInstance(result, pdml.ModelFrame)
         self.assert_series_equal(df.target, result.target)
         self.assert_numpy_array_almost_equal(result.data.values,
                                              expected)
@@ -179,7 +179,7 @@ def test_Decompositions_KernelPCA(self):
         result = df.transform(mod1)
         expected = mod2.transform(iris.data)
 
-        self.assertTrue(isinstance(result, pdml.ModelFrame))
+        self.assertIsInstance(result, pdml.ModelFrame)
         self.assert_series_equal(df.target, result.target)
         self.assert_numpy_array_almost_equal(result.data.values[:, :40],
                                              expected[:, :40])
@@ -194,7 +194,7 @@ def test_fit_transform_KernelPCA(self):
         result = df.fit_transform(mod1)
         expected = mod2.fit_transform(iris.data, iris.target)
 
-        self.assertTrue(isinstance(result, pdml.ModelFrame))
+        self.assertIsInstance(result, pdml.ModelFrame)
         self.assert_series_equal(df.target, result.target)
         self.assert_numpy_array_almost_equal(result.data.values[:, :40],
                                              expected[:, :40])
@@ -214,14 +214,14 @@ def test_inverse_transform(self):
             result = df.transform(mod1)
             expected = mod2.transform(iris.data)
 
-            self.assertTrue(isinstance(result, pdml.ModelFrame))
+            self.assertIsInstance(result, pdml.ModelFrame)
             self.assert_series_equal(df.target, result.target)
             self.assert_numpy_array_almost_equal(result.data.values, expected)
 
             result = df.inverse_transform(mod1)
             expected = mod2.inverse_transform(iris.data)
 
-            self.assertTrue(isinstance(result, pdml.ModelFrame))
+            self.assertIsInstance(result, pdml.ModelFrame)
             self.assert_series_equal(df.target, result.target)
             self.assert_numpy_array_almost_equal(result.data.values, expected)
             self.assert_index_equal(result.columns, df.columns)

pandas_ml/skaccessors/test/test_discriminant_analysis.py

@@ -52,7 +52,7 @@ def test_LDA(self):
 
             result = df.predict(mod1)
             expected = mod2.predict(diabetes.data)
-            self.assertTrue(isinstance(result, pdml.ModelSeries))
+            self.assertIsInstance(result, pdml.ModelSeries)
             self.assert_numpy_array_almost_equal(result.values, expected)