MAINT: Remove assertIsNotNone from testing (#16027)

Follow-up to gh-16024. Also removes some vestigial assertIsNot calls missed in #16024. Partially addresses #15990.

Author: gfyoung

pandas/tests/core/computation/test_eval.py

@@ -1308,16 +1308,17 @@ def test_column_in(self):
  assert_series_equal(result, expected)
 
  def assignment_not_inplace(self):
- # GH 9297
+ # see gh-9297
  df = DataFrame(np.random.randn(5, 2), columns=list('ab'))
 
  actual = df.eval('c = a + b', inplace=False)
- self.assertIsNotNone(actual)
+ assert actual is not None
+
  expected = df.copy()
  expected['c'] = expected['a'] + expected['b']
- assert_frame_equal(df, expected)
+ tm.assert_frame_equal(df, expected)
 
- # default for inplace will change
+ # Default for inplace will change
  with tm.assert_produces_warnings(FutureWarning):
  df.eval('c = a + b')
 

pandas/tests/frame/test_indexing.py

@@ -10,6 +10,8 @@
 
 from numpy import nan
 from numpy.random import randn
+
+import pytest
 import numpy as np
 
 import pandas.core.common as com
@@ -25,7 +27,6 @@
  is_integer,
  is_scalar)
 from pandas.util.testing import (assert_almost_equal,
- assert_numpy_array_equal,
  assert_series_equal,
  assert_frame_equal,
  assertRaisesRegexp,
@@ -40,30 +41,33 @@
 class TestDataFrameIndexing(tm.TestCase, TestData):
 
  def test_getitem(self):
- # slicing
+ # Slicing
  sl = self.frame[:20]
- self.assertEqual(20, len(sl.index))
-
- # column access
+ assert len(sl.index) == 20
 
+ # Column access
  for _, series in compat.iteritems(sl):
- self.assertEqual(20, len(series.index))
- self.assertTrue(tm.equalContents(series.index, sl.index))
+ assert len(series.index) == 20
+ assert tm.equalContents(series.index, sl.index)
 
  for key, _ in compat.iteritems(self.frame._series):
- self.assertIsNotNone(self.frame[key])
+ assert self.frame[key] is not None
 
- self.assertNotIn('random', self.frame)
+ assert 'random' not in self.frame
  with assertRaisesRegexp(KeyError, 'random'):
  self.frame['random']
 
  df = self.frame.copy()
  df['$10'] = randn(len(df))
+
  ad = randn(len(df))
  df['@awesome_domain'] = ad
- self.assertRaises(KeyError, df.__getitem__, 'df["$10"]')
+
+ with pytest.raises(KeyError):
+ df.__getitem__('df["$10"]')
+
  res = df['@awesome_domain']
- assert_numpy_array_equal(ad, res.values)
+ tm.assert_numpy_array_equal(ad, res.values)
 
  def test_getitem_dupe_cols(self):
  df = DataFrame([[1, 2, 3], [4, 5, 6]], columns=['a', 'a', 'b'])
@@ -648,28 +652,25 @@ def test_setitem_corner2(self):
  self.assertEqual(df.loc[1, 'cruft'], 0)
 
  def test_setitem_ambig(self):
- # difficulties with mixed-type data
+ # Difficulties with mixed-type data
  from decimal import Decimal
 
- # created as float type
+ # Created as float type
  dm = DataFrame(index=lrange(3), columns=lrange(3))
 
  coercable_series = Series([Decimal(1) for _ in range(3)],
  index=lrange(3))
  uncoercable_series = Series(['foo', 'bzr', 'baz'], index=lrange(3))
 
  dm[0] = np.ones(3)
- self.assertEqual(len(dm.columns), 3)
- # self.assertIsNone(dm.objects)
+ assert len(dm.columns) == 3
 
  dm[1] = coercable_series
- self.assertEqual(len(dm.columns), 3)
- # self.assertIsNone(dm.objects)
+ assert len(dm.columns) == 3
 
  dm[2] = uncoercable_series
- self.assertEqual(len(dm.columns), 3)
- # self.assertIsNotNone(dm.objects)
- self.assertEqual(dm[2].dtype, np.object_)
+ assert len(dm.columns) == 3
+ assert dm[2].dtype == np.object_
 
  def test_setitem_clear_caches(self):
  # see gh-304

pandas/tests/indexes/datetimes/test_construction.py

@@ -53,15 +53,14 @@ def test_construction_with_alt(self):
  i.tz_localize(None).asi8, dtype=i.dtype, tz='US/Pacific'))
 
  def test_construction_index_with_mixed_timezones(self):
- # GH 11488
- # no tz results in DatetimeIndex
+ # gh-11488: no tz results in DatetimeIndex
  result = Index([Timestamp('2011-01-01'),
  Timestamp('2011-01-02')], name='idx')
  exp = DatetimeIndex([Timestamp('2011-01-01'),
  Timestamp('2011-01-02')], name='idx')
- self.assert_index_equal(result, exp, exact=True)
- self.assertTrue(isinstance(result, DatetimeIndex))
- self.assertIsNone(result.tz)
+ tm.assert_index_equal(result, exp, exact=True)
+ assert isinstance(result, DatetimeIndex)
+ assert result.tz is None
 
  # same tz results in DatetimeIndex
  result = Index([Timestamp('2011-01-01 10:00', tz='Asia/Tokyo'),
@@ -70,10 +69,10 @@ def test_construction_index_with_mixed_timezones(self):
  exp = DatetimeIndex(
  [Timestamp('2011-01-01 10:00'), Timestamp('2011-01-02 10:00')
  ], tz='Asia/Tokyo', name='idx')
- self.assert_index_equal(result, exp, exact=True)
- self.assertTrue(isinstance(result, DatetimeIndex))
- self.assertIsNotNone(result.tz)
- self.assertEqual(result.tz, exp.tz)
+ tm.assert_index_equal(result, exp, exact=True)
+ assert isinstance(result, DatetimeIndex)
+ assert result.tz is not None
+ assert result.tz == exp.tz
 
  # same tz results in DatetimeIndex (DST)
  result = Index([Timestamp('2011-01-01 10:00', tz='US/Eastern'),
@@ -82,69 +81,69 @@ def test_construction_index_with_mixed_timezones(self):
  exp = DatetimeIndex([Timestamp('2011-01-01 10:00'),
  Timestamp('2011-08-01 10:00')],
  tz='US/Eastern', name='idx')
- self.assert_index_equal(result, exp, exact=True)
- self.assertTrue(isinstance(result, DatetimeIndex))
- self.assertIsNotNone(result.tz)
- self.assertEqual(result.tz, exp.tz)
+ tm.assert_index_equal(result, exp, exact=True)
+ assert isinstance(result, DatetimeIndex)
+ assert result.tz is not None
+ assert result.tz == exp.tz
 
- # different tz results in Index(dtype=object)
+ # Different tz results in Index(dtype=object)
  result = Index([Timestamp('2011-01-01 10:00'),
  Timestamp('2011-01-02 10:00', tz='US/Eastern')],
  name='idx')
  exp = Index([Timestamp('2011-01-01 10:00'),
  Timestamp('2011-01-02 10:00', tz='US/Eastern')],
  dtype='object', name='idx')
- self.assert_index_equal(result, exp, exact=True)
- self.assertFalse(isinstance(result, DatetimeIndex))
+ tm.assert_index_equal(result, exp, exact=True)
+ assert not isinstance(result, DatetimeIndex)
 
  result = Index([Timestamp('2011-01-01 10:00', tz='Asia/Tokyo'),
  Timestamp('2011-01-02 10:00', tz='US/Eastern')],
  name='idx')
  exp = Index([Timestamp('2011-01-01 10:00', tz='Asia/Tokyo'),
  Timestamp('2011-01-02 10:00', tz='US/Eastern')],
  dtype='object', name='idx')
- self.assert_index_equal(result, exp, exact=True)
- self.assertFalse(isinstance(result, DatetimeIndex))
+ tm.assert_index_equal(result, exp, exact=True)
+ assert not isinstance(result, DatetimeIndex)
 
  # length = 1
  result = Index([Timestamp('2011-01-01')], name='idx')
  exp = DatetimeIndex([Timestamp('2011-01-01')], name='idx')
- self.assert_index_equal(result, exp, exact=True)
- self.assertTrue(isinstance(result, DatetimeIndex))
- self.assertIsNone(result.tz)
+ tm.assert_index_equal(result, exp, exact=True)
+ assert isinstance(result, DatetimeIndex)
+ assert result.tz is None
 
  # length = 1 with tz
  result = Index(
  [Timestamp('2011-01-01 10:00', tz='Asia/Tokyo')], name='idx')
  exp = DatetimeIndex([Timestamp('2011-01-01 10:00')], tz='Asia/Tokyo',
  name='idx')
- self.assert_index_equal(result, exp, exact=True)
- self.assertTrue(isinstance(result, DatetimeIndex))
- self.assertIsNotNone(result.tz)
- self.assertEqual(result.tz, exp.tz)
+ tm.assert_index_equal(result, exp, exact=True)
+ assert isinstance(result, DatetimeIndex)
+ assert result.tz is not None
+ assert result.tz == exp.tz
 
  def test_construction_index_with_mixed_timezones_with_NaT(self):
- # GH 11488
+ # see gh-11488
  result = Index([pd.NaT, Timestamp('2011-01-01'),
  pd.NaT, Timestamp('2011-01-02')], name='idx')
  exp = DatetimeIndex([pd.NaT, Timestamp('2011-01-01'),
  pd.NaT, Timestamp('2011-01-02')], name='idx')
- self.assert_index_equal(result, exp, exact=True)
- self.assertTrue(isinstance(result, DatetimeIndex))
- self.assertIsNone(result.tz)
+ tm.assert_index_equal(result, exp, exact=True)
+ assert isinstance(result, DatetimeIndex)
+ assert result.tz is None
 
- # same tz results in DatetimeIndex
+ # Same tz results in DatetimeIndex
  result = Index([pd.NaT, Timestamp('2011-01-01 10:00', tz='Asia/Tokyo'),
  pd.NaT, Timestamp('2011-01-02 10:00',
  tz='Asia/Tokyo')],
  name='idx')
  exp = DatetimeIndex([pd.NaT, Timestamp('2011-01-01 10:00'),
  pd.NaT, Timestamp('2011-01-02 10:00')],
  tz='Asia/Tokyo', name='idx')
- self.assert_index_equal(result, exp, exact=True)
- self.assertTrue(isinstance(result, DatetimeIndex))
- self.assertIsNotNone(result.tz)
- self.assertEqual(result.tz, exp.tz)
+ tm.assert_index_equal(result, exp, exact=True)
+ assert isinstance(result, DatetimeIndex)
+ assert result.tz is not None
+ assert result.tz == exp.tz
 
  # same tz results in DatetimeIndex (DST)
  result = Index([Timestamp('2011-01-01 10:00', tz='US/Eastern'),
@@ -154,10 +153,10 @@ def test_construction_index_with_mixed_timezones_with_NaT(self):
  exp = DatetimeIndex([Timestamp('2011-01-01 10:00'), pd.NaT,
  Timestamp('2011-08-01 10:00')],
  tz='US/Eastern', name='idx')
- self.assert_index_equal(result, exp, exact=True)
- self.assertTrue(isinstance(result, DatetimeIndex))
- self.assertIsNotNone(result.tz)
- self.assertEqual(result.tz, exp.tz)
+ tm.assert_index_equal(result, exp, exact=True)
+ assert isinstance(result, DatetimeIndex)
+ assert result.tz is not None
+ assert result.tz == exp.tz
 
  # different tz results in Index(dtype=object)
  result = Index([pd.NaT, Timestamp('2011-01-01 10:00'),
@@ -167,32 +166,33 @@ def test_construction_index_with_mixed_timezones_with_NaT(self):
  exp = Index([pd.NaT, Timestamp('2011-01-01 10:00'),
  pd.NaT, Timestamp('2011-01-02 10:00', tz='US/Eastern')],
  dtype='object', name='idx')
- self.assert_index_equal(result, exp, exact=True)
- self.assertFalse(isinstance(result, DatetimeIndex))
+ tm.assert_index_equal(result, exp, exact=True)
+ assert not isinstance(result, DatetimeIndex)
 
  result = Index([pd.NaT, Timestamp('2011-01-01 10:00', tz='Asia/Tokyo'),
  pd.NaT, Timestamp('2011-01-02 10:00',
  tz='US/Eastern')], name='idx')
  exp = Index([pd.NaT, Timestamp('2011-01-01 10:00', tz='Asia/Tokyo'),
  pd.NaT, Timestamp('2011-01-02 10:00', tz='US/Eastern')],
  dtype='object', name='idx')
- self.assert_index_equal(result, exp, exact=True)
- self.assertFalse(isinstance(result, DatetimeIndex))
+ tm.assert_index_equal(result, exp, exact=True)
+ assert not isinstance(result, DatetimeIndex)
 
  # all NaT
  result = Index([pd.NaT, pd.NaT], name='idx')
  exp = DatetimeIndex([pd.NaT, pd.NaT], name='idx')
- self.assert_index_equal(result, exp, exact=True)
- self.assertTrue(isinstance(result, DatetimeIndex))
- self.assertIsNone(result.tz)
+ tm.assert_index_equal(result, exp, exact=True)
+ assert isinstance(result, DatetimeIndex)
+ assert result.tz is None
 
  # all NaT with tz
  result = Index([pd.NaT, pd.NaT], tz='Asia/Tokyo', name='idx')
  exp = DatetimeIndex([pd.NaT, pd.NaT], tz='Asia/Tokyo', name='idx')
- self.assert_index_equal(result, exp, exact=True)
- self.assertTrue(isinstance(result, DatetimeIndex))
- self.assertIsNotNone(result.tz)
- self.assertEqual(result.tz, exp.tz)
+
+ tm.assert_index_equal(result, exp, exact=True)
+ assert isinstance(result, DatetimeIndex)
+ assert result.tz is not None
+ assert result.tz == exp.tz
 
  def test_construction_dti_with_mixed_timezones(self):
  # GH 11488 (not changed, added explicit tests)

pandas/tests/indexes/datetimes/test_ops.py

@@ -1122,7 +1122,7 @@ def test_comparison(self):
 
  def test_pickle_unpickle(self):
  unpickled = tm.round_trip_pickle(self.rng)
- self.assertIsNotNone(unpickled.offset)
+ assert unpickled.offset is not None
 
  def test_copy(self):
  cp = self.rng.copy()
@@ -1273,7 +1273,7 @@ def test_shift(self):
 
  def test_pickle_unpickle(self):
  unpickled = tm.round_trip_pickle(self.rng)
- self.assertIsNotNone(unpickled.offset)
+ assert unpickled.offset is not None
 
  def test_summary(self):
  self.rng.summary()

pandas/tests/indexes/test_multi.py

@@ -393,39 +393,46 @@ def test_inplace_mutation_resets_values(self):
  levels = [['a', 'b', 'c'], [4]]
  levels2 = [[1, 2, 3], ['a']]
  labels = [[0, 1, 0, 2, 2, 0], [0, 0, 0, 0, 0, 0]]
+
  mi1 = MultiIndex(levels=levels, labels=labels)
  mi2 = MultiIndex(levels=levels2, labels=labels)
  vals = mi1.values.copy()
  vals2 = mi2.values.copy()
- self.assertIsNotNone(mi1._tuples)
 
- # make sure level setting works
+ assert mi1._tuples is not None
+
+ # Make sure level setting works
  new_vals = mi1.set_levels(levels2).values
- assert_almost_equal(vals2, new_vals)
- # non-inplace doesn't kill _tuples [implementation detail]
- assert_almost_equal(mi1._tuples, vals)
- # and values is still same too
- assert_almost_equal(mi1.values, vals)
+ tm.assert_almost_equal(vals2, new_vals)
+
+ # Non-inplace doesn't kill _tuples [implementation detail]
+ tm.assert_almost_equal(mi1._tuples, vals)
+
+ # ...and values is still same too
+ tm.assert_almost_equal(mi1.values, vals)
 
- # inplace should kill _tuples
+ # Inplace should kill _tuples
  mi1.set_levels(levels2, inplace=True)
- assert_almost_equal(mi1.values, vals2)
+ tm.assert_almost_equal(mi1.values, vals2)
 
- # make sure label setting works too
+ # Make sure label setting works too
  labels2 = [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
  exp_values = np.empty((6, ), dtype=object)
  exp_values[:] = [(long(1), 'a')] * 6
- # must be 1d array of tuples
- self.assertEqual(exp_values.shape, (6, ))
+
+ # Must be 1d array of tuples
+ assert exp_values.shape == (6, )
  new_values = mi2.set_labels(labels2).values
- # not inplace shouldn't change
- assert_almost_equal(mi2._tuples, vals2)
- # should have correct values
- assert_almost_equal(exp_values, new_values)
 
- # and again setting inplace should kill _tuples, etc
+ # Not inplace shouldn't change
+ tm.assert_almost_equal(mi2._tuples, vals2)
+
+ # Should have correct values
+ tm.assert_almost_equal(exp_values, new_values)
+
+ # ...and again setting inplace should kill _tuples, etc
  mi2.set_labels(labels2, inplace=True)
- assert_almost_equal(mi2.values, new_values)
+ tm.assert_almost_equal(mi2.values, new_values)
 
  def test_copy_in_constructor(self):
  levels = np.array(["a", "b", "c"])