MAINT: Remove assertIs from testing

pandas/tests/dtypes/test_common.py

@@ -26,7 +26,7 @@ def test_datetimetz_dtype(self):
         for dtype in ['datetime64[ns, US/Eastern]',
                       'datetime64[ns, Asia/Tokyo]',
                       'datetime64[ns, UTC]']:
-            self.assertIs(pandas_dtype(dtype), DatetimeTZDtype(dtype))
+            assert pandas_dtype(dtype) is DatetimeTZDtype(dtype)
             self.assertEqual(pandas_dtype(dtype), DatetimeTZDtype(dtype))
             self.assertEqual(pandas_dtype(dtype), dtype)
 
@@ -36,7 +36,7 @@ def test_categorical_dtype(self):
     def test_period_dtype(self):
         for dtype in ['period[D]', 'period[3M]', 'period[U]',
                       'Period[D]', 'Period[3M]', 'Period[U]']:
-            self.assertIs(pandas_dtype(dtype), PeriodDtype(dtype))
+            assert pandas_dtype(dtype) is PeriodDtype(dtype)
             self.assertEqual(pandas_dtype(dtype), PeriodDtype(dtype))
             self.assertEqual(pandas_dtype(dtype), dtype)
 

pandas/tests/dtypes/test_dtypes.py

@@ -249,20 +249,14 @@ def test_subclass(self):
         self.assertTrue(issubclass(type(a), type(b)))
 
     def test_identity(self):
-        self.assertEqual(PeriodDtype('period[D]'),
-                         PeriodDtype('period[D]'))
-        self.assertIs(PeriodDtype('period[D]'),
-                      PeriodDtype('period[D]'))
+        assert PeriodDtype('period[D]') == PeriodDtype('period[D]')
+        assert PeriodDtype('period[D]') is PeriodDtype('period[D]')
 
-        self.assertEqual(PeriodDtype('period[3D]'),
-                         PeriodDtype('period[3D]'))
-        self.assertIs(PeriodDtype('period[3D]'),
-                      PeriodDtype('period[3D]'))
+        assert PeriodDtype('period[3D]') == PeriodDtype('period[3D]')
+        assert PeriodDtype('period[3D]') is PeriodDtype('period[3D]')
 
-        self.assertEqual(PeriodDtype('period[1S1U]'),
-                         PeriodDtype('period[1000001U]'))
-        self.assertIs(PeriodDtype('period[1S1U]'),
-                      PeriodDtype('period[1000001U]'))
+        assert PeriodDtype('period[1S1U]') == PeriodDtype('period[1000001U]')
+        assert PeriodDtype('period[1S1U]') is PeriodDtype('period[1000001U]')
 
     def test_coerce_to_dtype(self):
         self.assertEqual(_coerce_to_dtype('period[D]'),
@@ -371,12 +365,12 @@ def test_construction(self):
     def test_construction_generic(self):
         # generic
         i = IntervalDtype('interval')
-        self.assertIs(i.subtype, None)
+        assert i.subtype is None
         self.assertTrue(is_interval_dtype(i))
         self.assertTrue(str(i) == 'interval')
 
         i = IntervalDtype()
-        self.assertIs(i.subtype, None)
+        assert i.subtype is None
         self.assertTrue(is_interval_dtype(i))
         self.assertTrue(str(i) == 'interval')
 

pandas/tests/frame/test_alter_axes.py

@@ -35,7 +35,7 @@ def test_set_index(self):
         # cache it
         _ = self.mixed_frame['foo']  # noqa
         self.mixed_frame.index = idx
-        self.assertIs(self.mixed_frame['foo'].index, idx)
+        assert self.mixed_frame['foo'].index is idx
         with assertRaisesRegexp(ValueError, 'Length mismatch'):
             self.mixed_frame.index = idx[::2]
 

pandas/tests/frame/test_api.py

@@ -88,8 +88,8 @@ def test_get_axis(self):
         self.assertEqual(f._get_axis_name('rows'), 'index')
         self.assertEqual(f._get_axis_name('columns'), 'columns')
 
-        self.assertIs(f._get_axis(0), f.index)
-        self.assertIs(f._get_axis(1), f.columns)
+        assert f._get_axis(0) is f.index
+        assert f._get_axis(1) is f.columns
 
         assertRaisesRegexp(ValueError, 'No axis named', f._get_axis_number, 2)
         assertRaisesRegexp(ValueError, 'No axis.*foo', f._get_axis_name, 'foo')
@@ -99,7 +99,7 @@ def test_get_axis(self):
 
     def test_keys(self):
         getkeys = self.frame.keys
-        self.assertIs(getkeys(), self.frame.columns)
+        assert getkeys() is self.frame.columns
 
     def test_column_contains_typeerror(self):
         try:
@@ -122,17 +122,17 @@ def test_array_interface(self):
         with np.errstate(all='ignore'):
             result = np.sqrt(self.frame)
         assert isinstance(result, type(self.frame))
-        self.assertIs(result.index, self.frame.index)
-        self.assertIs(result.columns, self.frame.columns)
+        assert result.index is self.frame.index
+        assert result.columns is self.frame.columns
 
         assert_frame_equal(result, self.frame.apply(np.sqrt))
 
     def test_get_agg_axis(self):
         cols = self.frame._get_agg_axis(0)
-        self.assertIs(cols, self.frame.columns)
+        assert cols is self.frame.columns
 
         idx = self.frame._get_agg_axis(1)
-        self.assertIs(idx, self.frame.index)
+        assert idx is self.frame.index
 
         pytest.raises(ValueError, self.frame._get_agg_axis, 2)
 

pandas/tests/frame/test_apply.py

@@ -25,29 +25,30 @@ def test_apply(self):
         with np.errstate(all='ignore'):
             # ufunc
             applied = self.frame.apply(np.sqrt)
-            assert_series_equal(np.sqrt(self.frame['A']), applied['A'])
+            tm.assert_series_equal(np.sqrt(self.frame['A']), applied['A'])
 
             # aggregator
             applied = self.frame.apply(np.mean)
-            self.assertEqual(applied['A'], np.mean(self.frame['A']))
+            assert applied['A'] == np.mean(self.frame['A'])
 
             d = self.frame.index[0]
             applied = self.frame.apply(np.mean, axis=1)
-            self.assertEqual(applied[d], np.mean(self.frame.xs(d)))
-            self.assertIs(applied.index, self.frame.index)  # want this
+            assert applied[d] == np.mean(self.frame.xs(d))
+            assert applied.index is self.frame.index  # want this
 
         # invalid axis
         df = DataFrame(
             [[1, 2, 3], [4, 5, 6], [7, 8, 9]], index=['a', 'a', 'c'])
         pytest.raises(ValueError, df.apply, lambda x: x, 2)
 
-        # GH9573
+        # see gh-9573
         df = DataFrame({'c0': ['A', 'A', 'B', 'B'],
                         'c1': ['C', 'C', 'D', 'D']})
         df = df.apply(lambda ts: ts.astype('category'))
-        self.assertEqual(df.shape, (4, 2))
-        self.assertTrue(isinstance(df['c0'].dtype, CategoricalDtype))
-        self.assertTrue(isinstance(df['c1'].dtype, CategoricalDtype))
+
+        assert df.shape == (4, 2)
+        assert isinstance(df['c0'].dtype, CategoricalDtype)
+        assert isinstance(df['c1'].dtype, CategoricalDtype)
 
     def test_apply_mixed_datetimelike(self):
         # mixed datetimelike
@@ -190,7 +191,7 @@ def _checkit(axis=0, raw=False):
                 if is_reduction:
                     agg_axis = df._get_agg_axis(axis)
                     assert isinstance(res, Series)
-                    self.assertIs(res.index, agg_axis)
+                    assert res.index is agg_axis
                 else:
                     assert isinstance(res, DataFrame)
 

pandas/tests/frame/test_axis_select_reindex.py

@@ -204,7 +204,7 @@ def test_reindex(self):
 
         # Same index, copies values but not index if copy=False
         newFrame = self.frame.reindex(self.frame.index, copy=False)
-        self.assertIs(newFrame.index, self.frame.index)
+        assert newFrame.index is self.frame.index
 
         # length zero
         newFrame = self.frame.reindex([])

pandas/tests/frame/test_indexing.py

@@ -1171,29 +1171,29 @@ def test_getitem_fancy_1d(self):
 
         # return self if no slicing...for now
         with catch_warnings(record=True):
-            self.assertIs(f.ix[:, :], f)
+            assert f.ix[:, :] is f
 
         # low dimensional slice
         with catch_warnings(record=True):
             xs1 = f.ix[2, ['C', 'B', 'A']]
         xs2 = f.xs(f.index[2]).reindex(['C', 'B', 'A'])
-        assert_series_equal(xs1, xs2)
+        tm.assert_series_equal(xs1, xs2)
 
         with catch_warnings(record=True):
             ts1 = f.ix[5:10, 2]
         ts2 = f[f.columns[2]][5:10]
-        assert_series_equal(ts1, ts2)
+        tm.assert_series_equal(ts1, ts2)
 
         # positional xs
         with catch_warnings(record=True):
             xs1 = f.ix[0]
         xs2 = f.xs(f.index[0])
-        assert_series_equal(xs1, xs2)
+        tm.assert_series_equal(xs1, xs2)
 
         with catch_warnings(record=True):
             xs1 = f.ix[f.index[5]]
         xs2 = f.xs(f.index[5])
-        assert_series_equal(xs1, xs2)
+        tm.assert_series_equal(xs1, xs2)
 
         # single column
         with catch_warnings(record=True):
@@ -1204,18 +1204,18 @@ def test_getitem_fancy_1d(self):
             exp = f.copy()
             exp.values[5] = 4
             f.ix[5][:] = 4
-        assert_frame_equal(exp, f)
+        tm.assert_frame_equal(exp, f)
 
         with catch_warnings(record=True):
             exp.values[:, 1] = 6
             f.ix[:, 1][:] = 6
-        assert_frame_equal(exp, f)
+        tm.assert_frame_equal(exp, f)
 
         # slice of mixed-frame
         with catch_warnings(record=True):
             xs = self.mixed_frame.ix[5]
         exp = self.mixed_frame.xs(self.mixed_frame.index[5])
-        assert_series_equal(xs, exp)
+        tm.assert_series_equal(xs, exp)
 
     def test_setitem_fancy_1d(self):
 
@@ -1676,7 +1676,7 @@ def test_set_value(self):
     def test_set_value_resize(self):
 
         res = self.frame.set_value('foobar', 'B', 0)
-        self.assertIs(res, self.frame)
+        assert res is self.frame
         self.assertEqual(res.index[-1], 'foobar')
         self.assertEqual(res.get_value('foobar', 'B'), 0)
 

pandas/tests/frame/test_operators.py

@@ -907,7 +907,7 @@ def test_combineFunc(self):
         _check_mixed_float(result, dtype=dict(C=None))
 
         result = self.empty * 2
-        self.assertIs(result.index, self.empty.index)
+        assert result.index is self.empty.index
         self.assertEqual(len(result.columns), 0)
 
     def test_comparisons(self):
@@ -1117,16 +1117,16 @@ def test_inplace_ops_identity(self):
         s += 1
         assert_series_equal(s, s2)
         assert_series_equal(s_orig + 1, s)
-        self.assertIs(s, s2)
-        self.assertIs(s._data, s2._data)
+        assert s is s2
+        assert s._data is s2._data
 
         df = df_orig.copy()
         df2 = df
         df += 1
         assert_frame_equal(df, df2)
         assert_frame_equal(df_orig + 1, df)
-        self.assertIs(df, df2)
-        self.assertIs(df._data, df2._data)
+        assert df is df2
+        assert df._data is df2._data
 
         # dtype change
         s = s_orig.copy()
@@ -1140,8 +1140,8 @@ def test_inplace_ops_identity(self):
         df += 1.5
         assert_frame_equal(df, df2)
         assert_frame_equal(df_orig + 1.5, df)
-        self.assertIs(df, df2)
-        self.assertIs(df._data, df2._data)
+        assert df is df2
+        assert df._data is df2._data
 
         # mixed dtype
         arr = np.random.randint(0, 10, size=5)
@@ -1152,15 +1152,15 @@ def test_inplace_ops_identity(self):
         expected = DataFrame({'A': arr.copy() + 1, 'B': 'foo'})
         assert_frame_equal(df, expected)
         assert_frame_equal(df2, expected)
-        self.assertIs(df._data, df2._data)
+        assert df._data is df2._data
 
         df = df_orig.copy()
         df2 = df
         df['A'] += 1.5
         expected = DataFrame({'A': arr.copy() + 1.5, 'B': 'foo'})
         assert_frame_equal(df, expected)
         assert_frame_equal(df2, expected)
-        self.assertIs(df._data, df2._data)
+        assert df._data is df2._data
 
     def test_alignment_non_pandas(self):
         index = ['A', 'B', 'C']

pandas/tests/groupby/test_groupby.py

@@ -759,17 +759,18 @@ def test_len(self):
     def test_groups(self):
         grouped = self.df.groupby(['A'])
         groups = grouped.groups
-        self.assertIs(groups, grouped.groups)  # caching works
+        assert groups is grouped.groups  # caching works
 
         for k, v in compat.iteritems(grouped.groups):
-            self.assertTrue((self.df.loc[v]['A'] == k).all())
+            assert (self.df.loc[v]['A'] == k).all()
 
         grouped = self.df.groupby(['A', 'B'])
         groups = grouped.groups
-        self.assertIs(groups, grouped.groups)  # caching works
+        assert groups is grouped.groups  # caching works
+
         for k, v in compat.iteritems(grouped.groups):
-            self.assertTrue((self.df.loc[v]['A'] == k[0]).all())
-            self.assertTrue((self.df.loc[v]['B'] == k[1]).all())
+            assert (self.df.loc[v]['A'] == k[0]).all()
+            assert (self.df.loc[v]['B'] == k[1]).all()
 
     def test_basic_regression(self):
         # regression

pandas/tests/indexes/datetimes/test_datetime.py

@@ -156,7 +156,7 @@ def test_time_overflow_for_32bit_machines(self):
         self.assertEqual(len(idx2), periods)
 
     def test_nat(self):
-        self.assertIs(DatetimeIndex([np.nan])[0], pd.NaT)
+        assert DatetimeIndex([np.nan])[0] is pd.NaT
 
     def test_ufunc_coercions(self):
         idx = date_range('2011-01-01', periods=3, freq='2D', name='x')
@@ -617,7 +617,7 @@ def test_join_self(self):
         kinds = 'outer', 'inner', 'left', 'right'
         for kind in kinds:
             joined = index.join(index, how=kind)
-            self.assertIs(index, joined)
+            assert index is joined
 
     def assert_index_parameters(self, index):
         assert index.freq == '40960N'

pandas/tests/indexes/datetimes/test_ops.py

@@ -879,8 +879,8 @@ def test_shift(self):
             tm.assert_index_equal(idx.shift(-3, freq='H'), exp)
 
     def test_nat(self):
-        self.assertIs(pd.DatetimeIndex._na_value, pd.NaT)
-        self.assertIs(pd.DatetimeIndex([])._na_value, pd.NaT)
+        assert pd.DatetimeIndex._na_value is pd.NaT
+        assert pd.DatetimeIndex([])._na_value is pd.NaT
 
         for tz in [None, 'US/Eastern', 'UTC']:
             idx = pd.DatetimeIndex(['2011-01-01', '2011-01-02'], tz=tz)

pandas/tests/indexes/datetimes/test_setops.py

@@ -185,7 +185,7 @@ def test_datetimeindex_union_join_empty(self):
 
         result = dti.union(empty)
         assert isinstance(result, DatetimeIndex)
-        self.assertIs(result, result)
+        assert result is result
 
         result = dti.join(empty)
         assert isinstance(result, DatetimeIndex)

pandas/tests/indexes/datetimes/test_tools.py

@@ -179,14 +179,14 @@ def test_to_datetime_dt64s(self):
         ]
 
         for dt in in_bound_dts:
-            self.assertEqual(pd.to_datetime(dt), Timestamp(dt))
+            assert pd.to_datetime(dt) == Timestamp(dt)
 
         oob_dts = [np.datetime64('1000-01-01'), np.datetime64('5000-01-02'), ]
 
         for dt in oob_dts:
             pytest.raises(ValueError, pd.to_datetime, dt, errors='raise')
             pytest.raises(ValueError, Timestamp, dt)
-            self.assertIs(pd.to_datetime(dt, errors='coerce'), NaT)
+            assert pd.to_datetime(dt, errors='coerce') is NaT
 
     def test_to_datetime_array_of_dt64s(self):
         dts = [np.datetime64('2000-01-01'), np.datetime64('2000-01-02'), ]
@@ -681,7 +681,7 @@ def test_to_datetime_types(self):
 
         # empty string
         result = to_datetime('')
-        self.assertIs(result, NaT)
+        assert result is NaT
 
         result = to_datetime(['', ''])
         self.assertTrue(isnull(result).all())

pandas/tests/indexes/period/test_indexing.py

@@ -121,15 +121,15 @@ def test_getitem_datetime(self):
     def test_getitem_nat(self):
         idx = pd.PeriodIndex(['2011-01', 'NaT', '2011-02'], freq='M')
         self.assertEqual(idx[0], pd.Period('2011-01', freq='M'))
-        self.assertIs(idx[1], tslib.NaT)
+        assert idx[1] is tslib.NaT
 
         s = pd.Series([0, 1, 2], index=idx)
         self.assertEqual(s[pd.NaT], 1)
 
         s = pd.Series(idx, index=idx)
         self.assertEqual(s[pd.Period('2011-01', freq='M')],
                          pd.Period('2011-01', freq='M'))
-        self.assertIs(s[pd.NaT], tslib.NaT)
+        assert s[pd.NaT] is tslib.NaT
 
     def test_getitem_list_periods(self):
         # GH 7710