CLN: Change assert_(a is [not] None) to specialized forms

pandas/io/tests/test_parsers.py

@@ -1480,7 +1480,7 @@ def test_no_unnamed_index(self):
 2 2 2 e f
 """
         df = self.read_table(StringIO(data), sep=' ')
-        self.assert_(df.index.name is None)
+        self.assertIsNone(df.index.name)
 
     def test_converters(self):
         data = """A,B,C,D
@@ -2177,7 +2177,7 @@ def test_regex_separator(self):
         df = self.read_table(StringIO(data), sep='\s+')
         expected = self.read_csv(StringIO(re.sub('[ ]+', ',', data)),
                                  index_col=0)
-        self.assert_(expected.index.name is None)
+        self.assertIsNone(expected.index.name)
         tm.assert_frame_equal(df, expected)
 
     def test_1000_fwf(self):

pandas/io/tests/test_pytables.py

@@ -777,12 +777,12 @@ def test_append_series(self):
             store.append('ss', ss)
             result = store['ss']
             tm.assert_series_equal(result, ss)
-            self.assert_(result.name is None)
+            self.assertIsNone(result.name)
 
             store.append('ts', ts)
             result = store['ts']
             tm.assert_series_equal(result, ts)
-            self.assert_(result.name is None)
+            self.assertIsNone(result.name)
 
             ns.name = 'foo'
             store.append('ns', ns)
@@ -3213,7 +3213,7 @@ def test_retain_index_attributes(self):
                                                 index=date_range('2002-1-1',periods=3,freq='D'))))
                 store.append('data',df2)
 
-            self.assert_(store.get_storer('data').info['index']['freq'] is None)
+            self.assertIsNone(store.get_storer('data').info['index']['freq'])
 
             # this is ok
             _maybe_remove(store,'df2')
@@ -3248,7 +3248,7 @@ def test_retain_index_attributes2(self):
                 df2 = DataFrame(dict(A = Series(lrange(3), index=idx2)))
                 df2.to_hdf(path,'data',append=True)
 
-            self.assert_(read_hdf(path,'data').index.name is None)
+            self.assertIsNone(read_hdf(path,'data').index.name)
 
     def test_panel_select(self):
 

pandas/sparse/tests/test_sparse.py

@@ -360,7 +360,7 @@ def _check_getitem(sp, dense):
 
     def test_get_get_value(self):
         assert_almost_equal(self.bseries.get(10), self.bseries[10])
-        self.assert_(self.bseries.get(len(self.bseries) + 1) is None)
+        self.assertIsNone(self.bseries.get(len(self.bseries) + 1))
 
         dt = self.btseries.index[10]
         result = self.btseries.get(dt)

pandas/tests/test_format.py

@@ -979,7 +979,7 @@ def test_to_string(self):
 
         buf = StringIO()
         retval = biggie.to_string(buf=buf)
-        self.assert_(retval is None)
+        self.assertIsNone(retval)
         self.assertEqual(buf.getvalue(), s)
 
         tm.assert_isinstance(s, compat.string_types)
@@ -1208,7 +1208,7 @@ def test_to_html(self):
 
         buf = StringIO()
         retval = biggie.to_html(buf=buf)
-        self.assert_(retval is None)
+        self.assertIsNone(retval)
         self.assertEqual(buf.getvalue(), s)
 
         tm.assert_isinstance(s, compat.string_types)
@@ -1574,7 +1574,7 @@ def get_ipython():
                    {'parent_appname': 'ipython-qtconsole'}}}
 
         repstr = self.frame._repr_html_()
-        self.assert_(repstr is not None)
+        self.assertIsNotNone(repstr)
 
         fmt.set_option('display.max_rows', 5, 'display.max_columns', 2)
         repstr = self.frame._repr_html_()
@@ -1807,7 +1807,7 @@ def test_to_string(self):
         s = self.ts.to_string()
 
         retval = self.ts.to_string(buf=buf)
-        self.assert_(retval is None)
+        self.assertIsNone(retval)
         self.assertEqual(buf.getvalue().strip(), s)
 
         # pass float_format

pandas/tests/test_frame.py

@@ -117,7 +117,7 @@ def test_getitem(self):
             self.assert_(tm.equalContents(series.index, sl.index))
 
         for key, _ in compat.iteritems(self.frame._series):
-            self.assert_(self.frame[key] is not None)
+            self.assertIsNotNone(self.frame[key])
 
         self.assertNotIn('random', self.frame)
         with assertRaisesRegexp(KeyError, 'no item named random'):
@@ -144,14 +144,14 @@ def test_get(self):
         b = self.frame.get('B')
         assert_series_equal(b, self.frame['B'])
 
-        self.assert_(self.frame.get('foo') is None)
+        self.assertIsNone(self.frame.get('foo'))
         assert_series_equal(self.frame.get('foo', self.frame['B']),
                             self.frame['B'])
         # None
         # GH 5652
         for df in [DataFrame(), DataFrame(columns=list('AB')), DataFrame(columns=list('AB'),index=range(3)) ]:
             result = df.get(None)
-            self.assert_(result is None)
+            self.assertIsNone(result)
 
     def test_getitem_iterator(self):
         idx = iter(['A', 'B', 'C'])
@@ -614,15 +614,15 @@ def test_setitem_ambig(self):
 
         dm[0] = np.ones(3)
         self.assertEqual(len(dm.columns), 3)
-        # self.assert_(dm.objects is None)
+        # self.assertIsNone(dm.objects)
 
         dm[1] = coercable_series
         self.assertEqual(len(dm.columns), 3)
-        # self.assert_(dm.objects is None)
+        # self.assertIsNone(dm.objects)
 
         dm[2] = uncoercable_series
         self.assertEqual(len(dm.columns), 3)
-        # self.assert_(dm.objects is not None)
+        # self.assertIsNotNone(dm.objects)
         self.assertEqual(dm[2].dtype, np.object_)
 
     def test_setitem_clear_caches(self):
@@ -1761,7 +1761,7 @@ def test_copy_index_name_checking(self):
             ind.name = None
             cp = self.frame.copy()
             getattr(cp, attr).name = 'foo'
-            self.assert_(getattr(self.frame, attr).name is None)
+            self.assertIsNone(getattr(self.frame, attr).name)
 
     def test_getitem_pop_assign_name(self):
         s = self.frame['A']
@@ -2174,7 +2174,7 @@ def test_constructor_dtype_nocast_view(self):
     def test_constructor_dtype_list_data(self):
         df = DataFrame([[1, '2'],
                         [None, 'a']], dtype=object)
-        self.assert_(df.ix[1, 0] is None)
+        self.assertIsNone(df.ix[1, 0])
         self.assertEqual(df.ix[0, 1], '2')
 
     def test_constructor_list_frames(self):
@@ -3606,7 +3606,7 @@ def test_new_empty_index(self):
         df1 = DataFrame(randn(0, 3))
         df2 = DataFrame(randn(0, 3))
         df1.index.name = 'foo'
-        self.assert_(df2.index.name is None)
+        self.assertIsNone(df2.index.name)
 
     def test_astype(self):
         casted = self.frame.astype(int)

pandas/tests/test_generic.py

@@ -227,7 +227,7 @@ def check_metadata(self, x, y=None):
         for m in x._metadata:
             v = getattr(x,m,None)
             if y is None:
-                self.assert_(v is None)
+                self.assertIsNone(v)
             else:
                 self.assertEqual(v, getattr(y,m,None))
 

pandas/tests/test_graphics.py

@@ -524,7 +524,7 @@ def test_subplots(self):
         axes = df.plot(subplots=True, sharex=True, legend=True)
 
         for ax in axes:
-            self.assert_(ax.get_legend() is not None)
+            self.assertIsNotNone(ax.get_legend())
 
         axes = df.plot(subplots=True, sharex=True)
         for ax in axes[:-2]:
@@ -649,7 +649,7 @@ def test_kde(self):
         _check_plot_works(df.plot, kind='kde')
         _check_plot_works(df.plot, kind='kde', subplots=True)
         ax = df.plot(kind='kde')
-        self.assert_(ax.get_legend() is not None)
+        self.assertIsNotNone(ax.get_legend())
         axes = df.plot(kind='kde', logy=True, subplots=True)
         for ax in axes:
             self.assertEqual(ax.get_yscale(), 'log')

pandas/tests/test_groupby.py

@@ -2397,7 +2397,7 @@ def test_no_nonsense_name(self):
         s.name = None
 
         result = s.groupby(self.frame['A']).agg(np.sum)
-        self.assert_(result.name is None)
+        self.assertIsNone(result.name)
 
     def test_wrap_agg_out(self):
         grouped = self.three_group.groupby(['A', 'B'])
@@ -2575,7 +2575,7 @@ def test_no_dummy_key_names(self):
         # GH #1291
 
         result = self.df.groupby(self.df['A'].values).sum()
-        self.assert_(result.index.name is None)
+        self.assertIsNone(result.index.name)
 
         result = self.df.groupby([self.df['A'].values,
                                   self.df['B'].values]).sum()

pandas/tests/test_index.py

@@ -71,7 +71,7 @@ def test_set_name_methods(self):
             self.assertEqual(ind.name, original_name)
             res = ind.rename(new_name, inplace=True)
             # should return None
-            self.assert_(res is None)
+            self.assertIsNone(res)
             self.assertEqual(ind.name, new_name)
             self.assertEqual(ind.names, [new_name])
             with assertRaisesRegexp(TypeError, "list-like"):
@@ -385,7 +385,7 @@ def test_union(self):
 
         second.name = 'B'
         union = first.union(second)
-        self.assert_(union.name is None)
+        self.assertIsNone(union.name)
 
     def test_add(self):
         firstCat = self.strIndex + self.dateIndex
@@ -424,7 +424,7 @@ def test_append_empty_preserve_name(self):
         right = Index([1, 2, 3], name='bar')
 
         result = left.append(right)
-        self.assert_(result.name is None)
+        self.assertIsNone(result.name)
 
     def test_add_string(self):
         # from bug report
@@ -478,12 +478,12 @@ def test_symmetric_diff(self):
         result = idx1.sym_diff(idx2)
         expected = Index([1, 5])
         self.assert_(tm.equalContents(result, expected))
-        self.assert_(result.name is None)
+        self.assertIsNone(result.name)
 
         # __xor__ syntax
         expected = idx1 ^ idx2
         self.assert_(tm.equalContents(result, expected))
-        self.assert_(result.name is None)
+        self.assertIsNone(result.name)
 
         # multiIndex
         idx1 = MultiIndex.from_tuples(self.tuples)
@@ -597,7 +597,7 @@ def test_format_none(self):
 
         idx = Index(values)
         idx.format()
-        self.assert_(idx[3] is None)
+        self.assertIsNone(idx[3])
 
     def test_take(self):
         indexer = [4, 3, 0, 2]
@@ -1056,7 +1056,7 @@ def test_join_left(self):
 
         tm.assert_isinstance(res, Int64Index)
         self.assert_(res.equals(eres))
-        self.assert_(lidx is None)
+        self.assertIsNone(lidx)
         self.assert_numpy_array_equal(ridx, eridx)
 
         # monotonic
@@ -1066,7 +1066,7 @@ def test_join_left(self):
                          dtype=np.int64)
         tm.assert_isinstance(res, Int64Index)
         self.assert_(res.equals(eres))
-        self.assert_(lidx is None)
+        self.assertIsNone(lidx)
         self.assert_numpy_array_equal(ridx, eridx)
 
         # non-unique
@@ -1096,7 +1096,7 @@ def test_join_right(self):
         tm.assert_isinstance(other, Int64Index)
         self.assert_(res.equals(eres))
         self.assert_numpy_array_equal(lidx, elidx)
-        self.assert_(ridx is None)
+        self.assertIsNone(ridx)
 
         # monotonic
         res, lidx, ridx = self.index.join(other_mono, how='right',
@@ -1107,7 +1107,7 @@ def test_join_right(self):
         tm.assert_isinstance(other, Int64Index)
         self.assert_(res.equals(eres))
         self.assert_numpy_array_equal(lidx, elidx)
-        self.assert_(ridx is None)
+        self.assertIsNone(ridx)
 
         # non-unique
         """
@@ -1303,7 +1303,7 @@ def test_set_names_and_rename(self):
             ind.set_names(new_names + new_names)
         new_names2 = [name + "SUFFIX2" for name in new_names]
         res = ind.set_names(new_names2, inplace=True)
-        self.assert_(res is None)
+        self.assertIsNone(res)
         self.assertEqual(ind.names, new_names2)
 
     def test_set_levels_and_set_labels(self):
@@ -1333,7 +1333,7 @@ def assert_matching(actual, expected):
         # level changing [w/ mutation]
         ind2 = self.index.copy()
         inplace_return = ind2.set_levels(new_levels, inplace=True)
-        self.assert_(inplace_return is None)
+        self.assertIsNone(inplace_return)
         assert_matching(ind2.levels, new_levels)
 
         # label changing [w/o mutation]
@@ -1344,7 +1344,7 @@ def assert_matching(actual, expected):
         # label changing [w/ mutation]
         ind2 = self.index.copy()
         inplace_return = ind2.set_labels(new_labels, inplace=True)
-        self.assert_(inplace_return is None)
+        self.assertIsNone(inplace_return)
         assert_matching(ind2.labels, new_labels)
 
     def test_set_levels_labels_names_bad_input(self):
@@ -1450,10 +1450,10 @@ def test_set_value_keeps_names(self):
             columns=['one', 'two', 'three', 'four'],
             index=idx)
         df = df.sortlevel()
-        self.assert_(df.is_copy is None)
+        self.assertIsNone(df.is_copy)
         self.assertEqual(df.index.names, ('Name', 'Number'))
         df = df.set_value(('grethe', '4'), 'one', 99.34)
-        self.assert_(df.is_copy is None)
+        self.assertIsNone(df.is_copy)
         self.assertEqual(df.index.names, ('Name', 'Number'))
 
     def test_names(self):
@@ -1508,7 +1508,7 @@ def test_constructor_single_level(self):
 
         single_level = MultiIndex(levels=[['foo', 'bar', 'baz', 'qux']],
                                   labels=[[0, 1, 2, 3]])
-        self.assert_(single_level.name is None)
+        self.assertIsNone(single_level.name)
 
     def test_constructor_no_levels(self):
         assertRaisesRegexp(ValueError, "non-zero number of levels/labels",
@@ -1850,7 +1850,7 @@ def test_get_loc_level(self):
         loc, new_index = index.get_loc_level((0, 1, 0))
         expected = 1
         self.assertEqual(loc, expected)
-        self.assert_(new_index is None)
+        self.assertIsNone(new_index)
 
         self.assertRaises(KeyError, index.get_loc_level, (2, 2))
 
@@ -2499,7 +2499,7 @@ def test_reindex(self):
 
         result, indexer = self.index.reindex(list(self.index))
         tm.assert_isinstance(result, MultiIndex)
-        self.assert_(indexer is None)
+        self.assertIsNone(indexer)
         self.check_level_names(result, self.index.names)
 
     def test_reindex_level(self):