MAINT: Remove assertIsInstance from testing

pandas/tests/dtypes/test_generic.py

@@ -20,23 +20,22 @@ class TestABCClasses(tm.TestCase):
     sparse_array = pd.SparseArray(np.random.randn(10))
 
     def test_abc_types(self):
-        self.assertIsInstance(pd.Index(['a', 'b', 'c']), gt.ABCIndex)
-        self.assertIsInstance(pd.Int64Index([1, 2, 3]), gt.ABCInt64Index)
-        self.assertIsInstance(pd.UInt64Index([1, 2, 3]), gt.ABCUInt64Index)
-        self.assertIsInstance(pd.Float64Index([1, 2, 3]), gt.ABCFloat64Index)
-        self.assertIsInstance(self.multi_index, gt.ABCMultiIndex)
-        self.assertIsInstance(self.datetime_index, gt.ABCDatetimeIndex)
-        self.assertIsInstance(self.timedelta_index, gt.ABCTimedeltaIndex)
-        self.assertIsInstance(self.period_index, gt.ABCPeriodIndex)
-        self.assertIsInstance(self.categorical_df.index,
-                              gt.ABCCategoricalIndex)
-        self.assertIsInstance(pd.Index(['a', 'b', 'c']), gt.ABCIndexClass)
-        self.assertIsInstance(pd.Int64Index([1, 2, 3]), gt.ABCIndexClass)
-        self.assertIsInstance(pd.Series([1, 2, 3]), gt.ABCSeries)
-        self.assertIsInstance(self.df, gt.ABCDataFrame)
+        assert isinstance(pd.Index(['a', 'b', 'c']), gt.ABCIndex)
+        assert isinstance(pd.Int64Index([1, 2, 3]), gt.ABCInt64Index)
+        assert isinstance(pd.UInt64Index([1, 2, 3]), gt.ABCUInt64Index)
+        assert isinstance(pd.Float64Index([1, 2, 3]), gt.ABCFloat64Index)
+        assert isinstance(self.multi_index, gt.ABCMultiIndex)
+        assert isinstance(self.datetime_index, gt.ABCDatetimeIndex)
+        assert isinstance(self.timedelta_index, gt.ABCTimedeltaIndex)
+        assert isinstance(self.period_index, gt.ABCPeriodIndex)
+        assert isinstance(self.categorical_df.index, gt.ABCCategoricalIndex)
+        assert isinstance(pd.Index(['a', 'b', 'c']), gt.ABCIndexClass)
+        assert isinstance(pd.Int64Index([1, 2, 3]), gt.ABCIndexClass)
+        assert isinstance(pd.Series([1, 2, 3]), gt.ABCSeries)
+        assert isinstance(self.df, gt.ABCDataFrame)
         with catch_warnings(record=True):
-            self.assertIsInstance(self.df.to_panel(), gt.ABCPanel)
-        self.assertIsInstance(self.sparse_series, gt.ABCSparseSeries)
-        self.assertIsInstance(self.sparse_array, gt.ABCSparseArray)
-        self.assertIsInstance(self.categorical, gt.ABCCategorical)
-        self.assertIsInstance(pd.Period('2012', freq='A-DEC'), gt.ABCPeriod)
+            assert isinstance(self.df.to_panel(), gt.ABCPanel)
+        assert isinstance(self.sparse_series, gt.ABCSparseSeries)
+        assert isinstance(self.sparse_array, gt.ABCSparseArray)
+        assert isinstance(self.categorical, gt.ABCCategorical)
+        assert isinstance(pd.Period('2012', freq='A-DEC'), gt.ABCPeriod)

pandas/tests/dtypes/test_missing.py

@@ -76,7 +76,7 @@ def test_isnull(self):
         for s in [tm.makeFloatSeries(), tm.makeStringSeries(),
                   tm.makeObjectSeries(), tm.makeTimeSeries(),
                   tm.makePeriodSeries()]:
-            self.assertIsInstance(isnull(s), Series)
+            assert isinstance(isnull(s), Series)
 
         # frame
         for df in [tm.makeTimeDataFrame(), tm.makePeriodFrame(),

pandas/tests/frame/test_alter_axes.py

@@ -198,7 +198,7 @@ def test_set_index_cast_datetimeindex(self):
                         'B': np.random.randn(1000)})
 
         idf = df.set_index('A')
-        tm.assertIsInstance(idf.index, pd.DatetimeIndex)
+        assert isinstance(idf.index, pd.DatetimeIndex)
 
         # don't cast a DatetimeIndex WITH a tz, leave as object
         # GH 6032
@@ -740,7 +740,7 @@ def test_reset_index_range(self):
         df = pd.DataFrame([[0, 0], [1, 1]], columns=['A', 'B'],
                           index=RangeIndex(stop=2))
         result = df.reset_index()
-        tm.assertIsInstance(result.index, RangeIndex)
+        assert isinstance(result.index, RangeIndex)
         expected = pd.DataFrame([[0, 0, 0], [1, 1, 1]],
                                 columns=['index', 'A', 'B'],
                                 index=RangeIndex(stop=2))
@@ -809,7 +809,7 @@ def test_setitem(self):
 
         df = DataFrame({'A': range(10)})
         s = pd.cut(df.A, 5)
-        self.assertIsInstance(s.cat.categories, IntervalIndex)
+        assert isinstance(s.cat.categories, IntervalIndex)
 
         # B & D end up as Categoricals
         # the remainer are converted to in-line objects

pandas/tests/frame/test_analytics.py

@@ -399,10 +399,10 @@ def test_count(self):
         # corner case
         frame = DataFrame()
         ct1 = frame.count(1)
-        tm.assertIsInstance(ct1, Series)
+        assert isinstance(ct1, Series)
 
         ct2 = frame.count(0)
-        tm.assertIsInstance(ct2, Series)
+        assert isinstance(ct2, Series)
 
         # GH #423
         df = DataFrame(index=lrange(10))
@@ -711,11 +711,11 @@ def _check_stat_op(self, name, alternative, frame=None, has_skipna=True,
             df = DataFrame({'b': date_range('1/1/2001', periods=2)})
             _f = getattr(df, name)
             result = _f()
-            self.assertIsInstance(result, Series)
+            assert isinstance(result, Series)
 
             df['a'] = lrange(len(df))
             result = getattr(df, name)()
-            self.assertIsInstance(result, Series)
+            assert isinstance(result, Series)
             self.assertTrue(len(result))
 
         if has_skipna:
@@ -913,8 +913,8 @@ def test_operators_timedelta64(self):
     def test_sum_corner(self):
         axis0 = self.empty.sum(0)
         axis1 = self.empty.sum(1)
-        tm.assertIsInstance(axis0, Series)
-        tm.assertIsInstance(axis1, Series)
+        assert isinstance(axis0, Series)
+        assert isinstance(axis1, Series)
         self.assertEqual(len(axis0), 0)
         self.assertEqual(len(axis1), 0)
 

pandas/tests/frame/test_api.py

@@ -118,7 +118,7 @@ def test_new_empty_index(self):
     def test_array_interface(self):
         with np.errstate(all='ignore'):
             result = np.sqrt(self.frame)
-        tm.assertIsInstance(result, type(self.frame))
+        assert isinstance(result, type(self.frame))
         self.assertIs(result.index, self.frame.index)
         self.assertIs(result.columns, self.frame.columns)
 
@@ -174,7 +174,7 @@ def test_itertuples(self):
                         'ints': lrange(5)}, columns=['floats', 'ints'])
 
         for tup in df.itertuples(index=False):
-            tm.assertIsInstance(tup[1], np.integer)
+            assert isinstance(tup[1], np.integer)
 
         df = DataFrame(data={"a": [1, 2, 3], "b": [4, 5, 6]})
         dfaa = df[['a', 'a']]
@@ -204,7 +204,7 @@ def test_itertuples(self):
         # will raise SyntaxError if trying to create namedtuple
         tup3 = next(df3.itertuples())
         self.assertFalse(hasattr(tup3, '_fields'))
-        self.assertIsInstance(tup3, tuple)
+        assert isinstance(tup3, tuple)
 
     def test_len(self):
         self.assertEqual(len(self.frame), len(self.frame.index))

pandas/tests/frame/test_apply.py

@@ -187,10 +187,10 @@ def _checkit(axis=0, raw=False):
                 res = df.apply(f, axis=axis, raw=raw)
                 if is_reduction:
                     agg_axis = df._get_agg_axis(axis)
-                    tm.assertIsInstance(res, Series)
+                    assert isinstance(res, Series)
                     self.assertIs(res.index, agg_axis)
                 else:
-                    tm.assertIsInstance(res, DataFrame)
+                    assert isinstance(res, DataFrame)
 
             _checkit()
             _checkit(axis=1)
@@ -204,7 +204,7 @@ def _checkit(axis=0, raw=False):
             _check(no_index, lambda x: x.mean())
 
         result = no_cols.apply(lambda x: x.mean(), broadcast=True)
-        tm.assertIsInstance(result, DataFrame)
+        assert isinstance(result, DataFrame)
 
     def test_apply_with_args_kwds(self):
         def add_some(x, howmuch=0):
@@ -357,7 +357,7 @@ def test_apply_multi_index(self):
         s.index = MultiIndex.from_arrays([['a', 'a', 'b'], ['c', 'd', 'd']])
         s.columns = ['col1', 'col2']
         res = s.apply(lambda x: Series({'min': min(x), 'max': max(x)}), 1)
-        tm.assertIsInstance(res.index, MultiIndex)
+        assert isinstance(res.index, MultiIndex)
 
     def test_apply_dict(self):
 
@@ -385,7 +385,7 @@ def test_applymap(self):
 
         # GH #465, function returning tuples
         result = self.frame.applymap(lambda x: (x, x))
-        tm.assertIsInstance(result['A'][0], tuple)
+        assert isinstance(result['A'][0], tuple)
 
         # GH 2909, object conversion to float in constructor?
         df = DataFrame(data=[1, 'a'])

pandas/tests/frame/test_constructors.py

@@ -101,7 +101,7 @@ def test_constructor_list_frames(self):
         self.assertEqual(result.shape, (1, 0))
 
         result = DataFrame([DataFrame(dict(A=lrange(5)))])
-        tm.assertIsInstance(result.iloc[0, 0], DataFrame)
+        assert isinstance(result.iloc[0, 0], DataFrame)
 
     def test_constructor_mixed_dtypes(self):
 
@@ -397,10 +397,10 @@ def test_constructor_dict_cast(self):
     def test_constructor_dict_dont_upcast(self):
         d = {'Col1': {'Row1': 'A String', 'Row2': np.nan}}
         df = DataFrame(d)
-        tm.assertIsInstance(df['Col1']['Row2'], float)
+        assert isinstance(df['Col1']['Row2'], float)
 
         dm = DataFrame([[1, 2], ['a', 'b']], index=[1, 2], columns=[1, 2])
-        tm.assertIsInstance(dm[1][1], int)
+        assert isinstance(dm[1][1], int)
 
     def test_constructor_dict_of_tuples(self):
         # GH #1491
@@ -1169,7 +1169,7 @@ def test_constructor_from_items(self):
                                       columns=self.mixed_frame.columns,
                                       orient='index')
         tm.assert_frame_equal(recons, self.mixed_frame)
-        tm.assertIsInstance(recons['foo'][0], tuple)
+        assert isinstance(recons['foo'][0], tuple)
 
         rs = DataFrame.from_items([('A', [1, 2, 3]), ('B', [4, 5, 6])],
                                   orient='index',

pandas/tests/frame/test_convert_to.py

@@ -45,7 +45,7 @@ def test_to_dict(self):
         expected_records = [{'A': 1.0, 'B': '1'},
                             {'A': 2.0, 'B': '2'},
                             {'A': np.nan, 'B': '3'}]
-        tm.assertIsInstance(recons_data, list)
+        assert isinstance(recons_data, list)
         self.assertEqual(len(recons_data), 3)
         for l, r in zip(recons_data, expected_records):
             tm.assert_dict_equal(l, r)

pandas/tests/frame/test_indexing.py

@@ -1830,14 +1830,14 @@ def test_iloc_duplicates(self):
         result = df.iloc[0]
         with catch_warnings(record=True):
             result2 = df.ix[0]
-        tm.assertIsInstance(result, Series)
+        assert isinstance(result, Series)
         assert_almost_equal(result.values, df.values[0])
         assert_series_equal(result, result2)
 
         with catch_warnings(record=True):
             result = df.T.iloc[:, 0]
             result2 = df.T.ix[:, 0]
-        tm.assertIsInstance(result, Series)
+        assert isinstance(result, Series)
         assert_almost_equal(result.values, df.values[0])
         assert_series_equal(result, result2)
 

pandas/tests/frame/test_period.py

@@ -41,7 +41,7 @@ def test_frame_setitem(self):
         self.assertEqual(rng.name, 'index')
 
         rs = df.reset_index().set_index('index')
-        tm.assertIsInstance(rs.index, PeriodIndex)
+        assert isinstance(rs.index, PeriodIndex)
         tm.assert_index_equal(rs.index, rng)
 
     def test_frame_to_time_stamp(self):

pandas/tests/frame/test_subclass.py

@@ -99,32 +99,32 @@ def test_indexing_sliced(self):
         res = df.loc[:, 'X']
         exp = tm.SubclassedSeries([1, 2, 3], index=list('abc'), name='X')
         tm.assert_series_equal(res, exp)
-        tm.assertIsInstance(res, tm.SubclassedSeries)
+        assert isinstance(res, tm.SubclassedSeries)
 
         res = df.iloc[:, 1]
         exp = tm.SubclassedSeries([4, 5, 6], index=list('abc'), name='Y')
         tm.assert_series_equal(res, exp)
-        tm.assertIsInstance(res, tm.SubclassedSeries)
+        assert isinstance(res, tm.SubclassedSeries)
 
         res = df.loc[:, 'Z']
         exp = tm.SubclassedSeries([7, 8, 9], index=list('abc'), name='Z')
         tm.assert_series_equal(res, exp)
-        tm.assertIsInstance(res, tm.SubclassedSeries)
+        assert isinstance(res, tm.SubclassedSeries)
 
         res = df.loc['a', :]
         exp = tm.SubclassedSeries([1, 4, 7], index=list('XYZ'), name='a')
         tm.assert_series_equal(res, exp)
-        tm.assertIsInstance(res, tm.SubclassedSeries)
+        assert isinstance(res, tm.SubclassedSeries)
 
         res = df.iloc[1, :]
         exp = tm.SubclassedSeries([2, 5, 8], index=list('XYZ'), name='b')
         tm.assert_series_equal(res, exp)
-        tm.assertIsInstance(res, tm.SubclassedSeries)
+        assert isinstance(res, tm.SubclassedSeries)
 
         res = df.loc['c', :]
         exp = tm.SubclassedSeries([3, 6, 9], index=list('XYZ'), name='c')
         tm.assert_series_equal(res, exp)
-        tm.assertIsInstance(res, tm.SubclassedSeries)
+        assert isinstance(res, tm.SubclassedSeries)
 
     def test_to_panel_expanddim(self):
         # GH 9762
@@ -173,15 +173,15 @@ def test_subclass_align(self):
         exp2 = tm.SubclassedDataFrame({'c': [1, 2, np.nan, 4, np.nan],
                                        'd': [1, 2, np.nan, 4, np.nan]},
                                       index=list('ABCDE'))
-        tm.assertIsInstance(res1, tm.SubclassedDataFrame)
+        assert isinstance(res1, tm.SubclassedDataFrame)
         tm.assert_frame_equal(res1, exp1)
-        tm.assertIsInstance(res2, tm.SubclassedDataFrame)
+        assert isinstance(res2, tm.SubclassedDataFrame)
         tm.assert_frame_equal(res2, exp2)
 
         res1, res2 = df1.a.align(df2.c)
-        tm.assertIsInstance(res1, tm.SubclassedSeries)
+        assert isinstance(res1, tm.SubclassedSeries)
         tm.assert_series_equal(res1, exp1.a)
-        tm.assertIsInstance(res2, tm.SubclassedSeries)
+        assert isinstance(res2, tm.SubclassedSeries)
         tm.assert_series_equal(res2, exp2.c)
 
     def test_subclass_align_combinations(self):
@@ -199,23 +199,23 @@ def test_subclass_align_combinations(self):
         exp2 = pd.Series([1, 2, np.nan, 4, np.nan],
                          index=list('ABCDE'), name='x')
 
-        tm.assertIsInstance(res1, tm.SubclassedDataFrame)
+        assert isinstance(res1, tm.SubclassedDataFrame)
         tm.assert_frame_equal(res1, exp1)
-        tm.assertIsInstance(res2, tm.SubclassedSeries)
+        assert isinstance(res2, tm.SubclassedSeries)
         tm.assert_series_equal(res2, exp2)
 
         # series + frame
         res1, res2 = s.align(df)
-        tm.assertIsInstance(res1, tm.SubclassedSeries)
+        assert isinstance(res1, tm.SubclassedSeries)
         tm.assert_series_equal(res1, exp2)
-        tm.assertIsInstance(res2, tm.SubclassedDataFrame)
+        assert isinstance(res2, tm.SubclassedDataFrame)
         tm.assert_frame_equal(res2, exp1)
 
     def test_subclass_iterrows(self):
         # GH 13977
         df = tm.SubclassedDataFrame({'a': [1]})
         for i, row in df.iterrows():
-            tm.assertIsInstance(row, tm.SubclassedSeries)
+            assert isinstance(row, tm.SubclassedSeries)
             tm.assert_series_equal(row, df.loc[i])
 
     def test_subclass_sparse_slice(self):

pandas/tests/frame/test_timeseries.py

@@ -372,10 +372,10 @@ def test_asfreq_datetimeindex(self):
                        index=[datetime(2011, 11, 1), datetime(2011, 11, 2),
                               datetime(2011, 11, 3)])
         df = df.asfreq('B')
-        tm.assertIsInstance(df.index, DatetimeIndex)
+        assert isinstance(df.index, DatetimeIndex)
 
         ts = df['A'].asfreq('B')
-        tm.assertIsInstance(ts.index, DatetimeIndex)
+        assert isinstance(ts.index, DatetimeIndex)
 
     def test_asfreq_fillvalue(self):
         # test for fill value during upsampling, related to issue 3715

pandas/tests/frame/test_to_csv.py

@@ -883,7 +883,7 @@ def test_to_csv_path_is_none(self):
         # Make sure we return string for consistency with
         # Series.to_csv()
         csv_str = self.frame.to_csv(path_or_buf=None)
-        self.assertIsInstance(csv_str, str)
+        assert isinstance(csv_str, str)
         recons = pd.read_csv(StringIO(csv_str), index_col=0)
         assert_frame_equal(self.frame, recons)
 

pandas/tests/groupby/test_aggregate.py

@@ -117,7 +117,7 @@ def test_agg_period_index(self):
         prng = period_range('2012-1-1', freq='M', periods=3)
         df = DataFrame(np.random.randn(3, 2), index=prng)
         rs = df.groupby(level=0).sum()
-        tm.assertIsInstance(rs.index, PeriodIndex)
+        assert isinstance(rs.index, PeriodIndex)
 
         # GH 3579
         index = period_range(start='1999-01', periods=5, freq='M')
@@ -464,7 +464,7 @@ def aggfun(ser):
             return ser.size
 
         result = DataFrame().groupby(self.df.A).agg(aggfun)
-        tm.assertIsInstance(result, DataFrame)
+        assert isinstance(result, DataFrame)
         self.assertEqual(len(result), 0)
 
     def test_agg_item_by_item_raise_typeerror(self):