MAINT: Remove tm.assertIsNot from testing

pandas/tests/core/sparse/test_frame.py

@@ -422,24 +422,24 @@ def test_iloc(self):
 
     def test_set_value(self):
 
-        # ok as the index gets conver to object
+        # ok, as the index gets converted to object
         frame = self.frame.copy()
         res = frame.set_value('foobar', 'B', 1.5)
-        self.assertEqual(res.index.dtype, 'object')
+        assert res.index.dtype == 'object'
 
         res = self.frame
         res.index = res.index.astype(object)
 
         res = self.frame.set_value('foobar', 'B', 1.5)
-        self.assertIsNot(res, self.frame)
-        self.assertEqual(res.index[-1], 'foobar')
-        self.assertEqual(res.get_value('foobar', 'B'), 1.5)
+        assert res is not self.frame
+        assert res.index[-1] == 'foobar'
+        assert res.get_value('foobar', 'B') == 1.5
 
         res2 = res.set_value('foobar', 'qux', 1.5)
-        self.assertIsNot(res2, res)
-        self.assert_index_equal(res2.columns,
-                                pd.Index(list(self.frame.columns) + ['qux']))
-        self.assertEqual(res2.get_value('foobar', 'qux'), 1.5)
+        assert res2 is not res
+        tm.assert_index_equal(res2.columns,
+                              pd.Index(list(self.frame.columns) + ['qux']))
+        assert res2.get_value('foobar', 'qux') == 1.5
 
     def test_fancy_index_misc(self):
         # axis = 0

pandas/tests/core/sparse/test_indexing.py

@@ -1,6 +1,6 @@
 # pylint: disable-msg=E1101,W0612
 
-import pytest  # noqa
+import pytest
 import numpy as np
 import pandas as pd
 import pandas.util.testing as tm
@@ -578,15 +578,15 @@ def test_reindex(self):
         exp = orig.reindex(['A'], level=0).to_sparse()
         tm.assert_sp_series_equal(res, exp)
 
-        with tm.assertRaises(TypeError):
+        with pytest.raises(TypeError):
             # Incomplete keys are not accepted for reindexing:
             sparse.reindex(['A', 'C'])
 
         # "copy" argument:
         res = sparse.reindex(sparse.index, copy=True)
         exp = orig.reindex(orig.index, copy=True).to_sparse()
         tm.assert_sp_series_equal(res, exp)
-        self.assertIsNot(sparse, res)
+        assert sparse is not res
 
 
 class TestSparseDataFrameIndexing(tm.TestCase):

pandas/tests/core/sparse/test_series.py

@@ -314,9 +314,9 @@ def test_constructor_empty(self):
 
     def test_copy_astype(self):
         cop = self.bseries.astype(np.float64)
-        self.assertIsNot(cop, self.bseries)
-        self.assertIs(cop.sp_index, self.bseries.sp_index)
-        self.assertEqual(cop.dtype, np.float64)
+        assert cop is not self.bseries
+        assert cop.sp_index is self.bseries.sp_index
+        assert cop.dtype == np.float64
 
         cop2 = self.iseries.copy()
 
@@ -325,8 +325,8 @@ def test_copy_astype(self):
 
         # test that data is copied
         cop[:5] = 97
-        self.assertEqual(cop.sp_values[0], 97)
-        self.assertNotEqual(self.bseries.sp_values[0], 97)
+        assert cop.sp_values[0] == 97
+        assert self.bseries.sp_values[0] != 97
 
         # correct fill value
         zbcop = self.zbseries.copy()
@@ -338,7 +338,7 @@ def test_copy_astype(self):
         # no deep copy
         view = self.bseries.copy(deep=False)
         view.sp_values[:5] = 5
-        self.assertTrue((self.bseries.sp_values[:5] == 5).all())
+        assert (self.bseries.sp_values[:5] == 5).all()
 
     def test_shape(self):
         # GH 10452
@@ -639,7 +639,7 @@ def _compare_with_series(sps, new_index):
         # special cases
         same_index = self.bseries.reindex(self.bseries.index)
         tm.assert_sp_series_equal(self.bseries, same_index)
-        self.assertIsNot(same_index, self.bseries)
+        assert same_index is not self.bseries
 
         # corner cases
         sp = SparseSeries([], index=[])
@@ -650,7 +650,7 @@ def _compare_with_series(sps, new_index):
         # with copy=False
         reindexed = self.bseries.reindex(self.bseries.index, copy=True)
         reindexed.sp_values[:] = 1.
-        self.assertTrue((self.bseries.sp_values != 1.).all())
+        assert (self.bseries.sp_values != 1.).all()
 
         reindexed = self.bseries.reindex(self.bseries.index, copy=False)
         reindexed.sp_values[:] = 1.
@@ -824,7 +824,7 @@ def test_shift(self):
         series = SparseSeries([nan, 1., 2., 3., nan, nan], index=np.arange(6))
 
         shifted = series.shift(0)
-        self.assertIsNot(shifted, series)
+        assert shifted is not series
         tm.assert_sp_series_equal(shifted, series)
 
         f = lambda s: s.shift(1)

pandas/tests/frame/test_axis_select_reindex.py

@@ -2,6 +2,8 @@
 
 from __future__ import print_function
 
+import pytest
+
 from datetime import datetime
 
 from numpy import random
@@ -409,33 +411,35 @@ def test_reindex_dups(self):
 
     def test_align(self):
         af, bf = self.frame.align(self.frame)
-        self.assertIsNot(af._data, self.frame._data)
+        assert af._data is not self.frame._data
 
         af, bf = self.frame.align(self.frame, copy=False)
-        self.assertIs(af._data, self.frame._data)
+        assert af._data is self.frame._data
 
         # axis = 0
         other = self.frame.iloc[:-5, :3]
         af, bf = self.frame.align(other, axis=0, fill_value=-1)
-        self.assert_index_equal(bf.columns, other.columns)
+
+        tm.assert_index_equal(bf.columns, other.columns)
+
         # test fill value
         join_idx = self.frame.index.join(other.index)
         diff_a = self.frame.index.difference(join_idx)
         diff_b = other.index.difference(join_idx)
         diff_a_vals = af.reindex(diff_a).values
         diff_b_vals = bf.reindex(diff_b).values
-        self.assertTrue((diff_a_vals == -1).all())
+        assert (diff_a_vals == -1).all()
 
         af, bf = self.frame.align(other, join='right', axis=0)
-        self.assert_index_equal(bf.columns, other.columns)
-        self.assert_index_equal(bf.index, other.index)
-        self.assert_index_equal(af.index, other.index)
+        tm.assert_index_equal(bf.columns, other.columns)
+        tm.assert_index_equal(bf.index, other.index)
+        tm.assert_index_equal(af.index, other.index)
 
         # axis = 1
         other = self.frame.iloc[:-5, :3].copy()
         af, bf = self.frame.align(other, axis=1)
-        self.assert_index_equal(bf.columns, self.frame.columns)
-        self.assert_index_equal(bf.index, other.index)
+        tm.assert_index_equal(bf.columns, self.frame.columns)
+        tm.assert_index_equal(bf.index, other.index)
 
         # test fill value
         join_idx = self.frame.index.join(other.index)
@@ -446,42 +450,42 @@ def test_align(self):
         # TODO(wesm): unused?
         diff_b_vals = bf.reindex(diff_b).values  # noqa
 
-        self.assertTrue((diff_a_vals == -1).all())
+        assert (diff_a_vals == -1).all()
 
         af, bf = self.frame.align(other, join='inner', axis=1)
-        self.assert_index_equal(bf.columns, other.columns)
+        tm.assert_index_equal(bf.columns, other.columns)
 
         af, bf = self.frame.align(other, join='inner', axis=1, method='pad')
-        self.assert_index_equal(bf.columns, other.columns)
+        tm.assert_index_equal(bf.columns, other.columns)
 
         # test other non-float types
         af, bf = self.intframe.align(other, join='inner', axis=1, method='pad')
-        self.assert_index_equal(bf.columns, other.columns)
+        tm.assert_index_equal(bf.columns, other.columns)
 
         af, bf = self.mixed_frame.align(self.mixed_frame,
                                         join='inner', axis=1, method='pad')
-        self.assert_index_equal(bf.columns, self.mixed_frame.columns)
+        tm.assert_index_equal(bf.columns, self.mixed_frame.columns)
 
         af, bf = self.frame.align(other.iloc[:, 0], join='inner', axis=1,
                                   method=None, fill_value=None)
-        self.assert_index_equal(bf.index, Index([]))
+        tm.assert_index_equal(bf.index, Index([]))
 
         af, bf = self.frame.align(other.iloc[:, 0], join='inner', axis=1,
                                   method=None, fill_value=0)
-        self.assert_index_equal(bf.index, Index([]))
+        tm.assert_index_equal(bf.index, Index([]))
 
         # mixed floats/ints
         af, bf = self.mixed_float.align(other.iloc[:, 0], join='inner', axis=1,
                                         method=None, fill_value=0)
-        self.assert_index_equal(bf.index, Index([]))
+        tm.assert_index_equal(bf.index, Index([]))
 
         af, bf = self.mixed_int.align(other.iloc[:, 0], join='inner', axis=1,
                                       method=None, fill_value=0)
-        self.assert_index_equal(bf.index, Index([]))
+        tm.assert_index_equal(bf.index, Index([]))
 
-        # try to align dataframe to series along bad axis
-        self.assertRaises(ValueError, self.frame.align, af.iloc[0, :3],
-                          join='inner', axis=2)
+        # Try to align DataFrame to Series along bad axis
+        with pytest.raises(ValueError):
+            self.frame.align(af.iloc[0, :3], join='inner', axis=2)
 
         # align dataframe to series with broadcast or not
         idx = self.frame.index
@@ -490,7 +494,7 @@ def test_align(self):
         left, right = self.frame.align(s, axis=0)
         tm.assert_index_equal(left.index, self.frame.index)
         tm.assert_index_equal(right.index, self.frame.index)
-        self.assertTrue(isinstance(right, Series))
+        assert isinstance(right, Series)
 
         left, right = self.frame.align(s, broadcast_axis=1)
         tm.assert_index_equal(left.index, self.frame.index)
@@ -499,17 +503,17 @@ def test_align(self):
             expected[c] = s
         expected = DataFrame(expected, index=self.frame.index,
                              columns=self.frame.columns)
-        assert_frame_equal(right, expected)
+        tm.assert_frame_equal(right, expected)
 
-        # GH 9558
+        # see gh-9558
         df = DataFrame({'a': [1, 2, 3], 'b': [4, 5, 6]})
         result = df[df['a'] == 2]
         expected = DataFrame([[2, 5]], index=[1], columns=['a', 'b'])
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
         result = df.where(df['a'] == 2, 0)
         expected = DataFrame({'a': [0, 2, 0], 'b': [0, 5, 0]})
-        assert_frame_equal(result, expected)
+        tm.assert_frame_equal(result, expected)
 
     def _check_align(self, a, b, axis, fill_axis, how, method, limit=None):
         aa, ab = a.align(b, axis=axis, join=how, method=method, limit=limit,

pandas/tests/frame/test_block_internals.py

@@ -41,17 +41,18 @@ def test_cast_internals(self):
     def test_consolidate(self):
         self.frame['E'] = 7.
         consolidated = self.frame._consolidate()
-        self.assertEqual(len(consolidated._data.blocks), 1)
+        assert len(consolidated._data.blocks) == 1
 
         # Ensure copy, do I want this?
         recons = consolidated._consolidate()
-        self.assertIsNot(recons, consolidated)
-        assert_frame_equal(recons, consolidated)
+        assert recons is not consolidated
+        tm.assert_frame_equal(recons, consolidated)
 
         self.frame['F'] = 8.
-        self.assertEqual(len(self.frame._data.blocks), 3)
+        assert len(self.frame._data.blocks) == 3
+
         self.frame._consolidate(inplace=True)
-        self.assertEqual(len(self.frame._data.blocks), 1)
+        assert len(self.frame._data.blocks) == 1
 
     def test_consolidate_deprecation(self):
         self.frame['E'] = 7
@@ -343,11 +344,11 @@ def test_no_copy_blocks(self):
     def test_copy(self):
         cop = self.frame.copy()
         cop['E'] = cop['A']
-        self.assertNotIn('E', self.frame)
+        assert 'E' not in self.frame
 
         # copy objects
         copy = self.mixed_frame.copy()
-        self.assertIsNot(copy._data, self.mixed_frame._data)
+        assert copy._data is not self.mixed_frame._data
 
     def test_pickle(self):
         unpickled = tm.round_trip_pickle(self.mixed_frame)

pandas/tests/frame/test_indexing.py

@@ -672,19 +672,19 @@ def test_setitem_ambig(self):
         self.assertEqual(dm[2].dtype, np.object_)
 
     def test_setitem_clear_caches(self):
-        # GH #304
+        # see gh-304
         df = DataFrame({'x': [1.1, 2.1, 3.1, 4.1], 'y': [5.1, 6.1, 7.1, 8.1]},
                        index=[0, 1, 2, 3])
         df.insert(2, 'z', np.nan)
 
         # cache it
         foo = df['z']
-
         df.loc[df.index[2:], 'z'] = 42
 
         expected = Series([np.nan, np.nan, 42, 42], index=df.index, name='z')
-        self.assertIsNot(df['z'], foo)
-        assert_series_equal(df['z'], expected)
+
+        assert df['z'] is not foo
+        tm.assert_series_equal(df['z'], expected)
 
     def test_setitem_None(self):
         # GH #766

pandas/tests/frame/test_missing.py

@@ -403,18 +403,18 @@ def test_fillna_inplace(self):
         df[3][-4:] = np.nan
 
         expected = df.fillna(value=0)
-        self.assertIsNot(expected, df)
+        assert expected is not df
 
         df.fillna(value=0, inplace=True)
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
         df[1][:4] = np.nan
         df[3][-4:] = np.nan
         expected = df.fillna(method='ffill')
-        self.assertIsNot(expected, df)
+        assert expected is not df
 
         df.fillna(method='ffill', inplace=True)
-        assert_frame_equal(df, expected)
+        tm.assert_frame_equal(df, expected)
 
     def test_fillna_dict_series(self):
         df = DataFrame({'a': [nan, 1, 2, nan, nan],

pandas/tests/frame/test_timeseries.py

@@ -14,8 +14,7 @@
 import pandas as pd
 import pandas.tseries.offsets as offsets
 
-from pandas.util.testing import (assert_almost_equal,
-                                 assert_series_equal,
+from pandas.util.testing import (assert_series_equal,
                                  assert_frame_equal,
                                  assertRaisesRegexp)
 
@@ -355,7 +354,7 @@ def test_asfreq(self):
         offset_monthly = self.tsframe.asfreq(offsets.BMonthEnd())
         rule_monthly = self.tsframe.asfreq('BM')
 
-        assert_almost_equal(offset_monthly['A'], rule_monthly['A'])
+        tm.assert_almost_equal(offset_monthly['A'], rule_monthly['A'])
 
         filled = rule_monthly.asfreq('B', method='pad')  # noqa
         # TODO: actually check that this worked.
@@ -366,7 +365,7 @@ def test_asfreq(self):
         # test does not blow up on length-0 DataFrame
         zero_length = self.tsframe.reindex([])
         result = zero_length.asfreq('BM')
-        self.assertIsNot(result, zero_length)
+        assert result is not zero_length
 
     def test_asfreq_datetimeindex(self):
         df = DataFrame({'A': [1, 2, 3]},