MAINT: Remove tm.assertIsNot from testing (#16024)

Author: gfyoung

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]},