CLN: Specialize assert_(np.array_equal(...))

Work on pandas-dev#6175. This is the third (and final) "half" of the work started in pandas-dev#6368.

Author: bwignall

pandas/io/tests/test_cparser.py

@@ -82,8 +82,8 @@ def test_skipinitialspace(self):
                             header=None)
         result = reader.read()
 
-        self.assert_(np.array_equal(result[0], ['a', 'a', 'a', 'a']))
-        self.assert_(np.array_equal(result[1], ['b', 'b', 'b', 'b']))
+        self.assert_numpy_array_equal(result[0], ['a', 'a', 'a', 'a'])
+        self.assert_numpy_array_equal(result[1], ['b', 'b', 'b', 'b'])
 
     def test_parse_booleans(self):
         data = 'True\nFalse\nTrue\nTrue'
@@ -100,8 +100,8 @@ def test_delimit_whitespace(self):
                             header=None)
         result = reader.read()
 
-        self.assert_(np.array_equal(result[0], ['a', 'a', 'a']))
-        self.assert_(np.array_equal(result[1], ['b', 'b', 'b']))
+        self.assert_numpy_array_equal(result[0], ['a', 'a', 'a'])
+        self.assert_numpy_array_equal(result[1], ['b', 'b', 'b'])
 
     def test_embedded_newline(self):
         data = 'a\n"hello\nthere"\nthis'
@@ -110,7 +110,7 @@ def test_embedded_newline(self):
         result = reader.read()
 
         expected = ['a', 'hello\nthere', 'this']
-        self.assert_(np.array_equal(result[0], expected))
+        self.assert_numpy_array_equal(result[0], expected)
 
     def test_euro_decimal(self):
         data = '12345,67\n345,678'

pandas/io/tests/test_parsers.py

@@ -810,9 +810,9 @@ def test_unnamed_columns(self):
                     [11, 12, 13, 14, 15]]
         df = self.read_table(StringIO(data), sep=',')
         tm.assert_almost_equal(df.values, expected)
-        self.assert_(np.array_equal(df.columns,
-                                    ['A', 'B', 'C', 'Unnamed: 3',
-                                     'Unnamed: 4']))
+        self.assert_numpy_array_equal(df.columns,
+                                      ['A', 'B', 'C', 'Unnamed: 3',
+                                       'Unnamed: 4'])
 
     def test_string_nas(self):
         data = """A,B,C
@@ -963,11 +963,11 @@ def test_no_header(self):
         tm.assert_almost_equal(df.values, expected)
         tm.assert_almost_equal(df.values, df2.values)
 
-        self.assert_(np.array_equal(df_pref.columns,
-                                    ['X0', 'X1', 'X2', 'X3', 'X4']))
-        self.assert_(np.array_equal(df.columns, lrange(5)))
+        self.assert_numpy_array_equal(df_pref.columns,
+                                      ['X0', 'X1', 'X2', 'X3', 'X4'])
+        self.assert_numpy_array_equal(df.columns, lrange(5))
 
-        self.assert_(np.array_equal(df2.columns, names))
+        self.assert_numpy_array_equal(df2.columns, names)
 
     def test_no_header_prefix(self):
         data = """1,2,3,4,5
@@ -982,8 +982,8 @@ def test_no_header_prefix(self):
                     [11, 12, 13, 14, 15]]
         tm.assert_almost_equal(df_pref.values, expected)
 
-        self.assert_(np.array_equal(df_pref.columns,
-                                    ['Field0', 'Field1', 'Field2', 'Field3', 'Field4']))
+        self.assert_numpy_array_equal(df_pref.columns,
+                                      ['Field0', 'Field1', 'Field2', 'Field3', 'Field4'])
 
     def test_header_with_index_col(self):
         data = """foo,1,2,3
@@ -1004,7 +1004,7 @@ def test_read_csv_dataframe(self):
         df = self.read_csv(self.csv1, index_col=0, parse_dates=True)
         df2 = self.read_table(self.csv1, sep=',', index_col=0,
                               parse_dates=True)
-        self.assert_(np.array_equal(df.columns, ['A', 'B', 'C', 'D']))
+        self.assert_numpy_array_equal(df.columns, ['A', 'B', 'C', 'D'])
         self.assertEqual(df.index.name, 'index')
         self.assert_(isinstance(df.index[0], (datetime, np.datetime64,
                                               Timestamp)))
@@ -1015,7 +1015,7 @@ def test_read_csv_no_index_name(self):
         df = self.read_csv(self.csv2, index_col=0, parse_dates=True)
         df2 = self.read_table(self.csv2, sep=',', index_col=0,
                               parse_dates=True)
-        self.assert_(np.array_equal(df.columns, ['A', 'B', 'C', 'D', 'E']))
+        self.assert_numpy_array_equal(df.columns, ['A', 'B', 'C', 'D', 'E'])
         self.assert_(isinstance(df.index[0], (datetime, np.datetime64,
                                               Timestamp)))
         self.assertEqual(df.ix[:, ['A', 'B', 'C', 'D']].values.dtype, np.float64)

pandas/sparse/tests/test_sparse.py

@@ -1099,8 +1099,8 @@ def test_set_value(self):
 
         res2 = res.set_value('foobar', 'qux', 1.5)
         self.assert_(res2 is not res)
-        self.assert_(np.array_equal(res2.columns,
-                                    list(self.frame.columns) + ['qux']))
+        self.assert_numpy_array_equal(res2.columns,
+                                      list(self.frame.columns) + ['qux'])
         self.assertEqual(res2.get_value('foobar', 'qux'), 1.5)
 
     def test_fancy_index_misc(self):
@@ -1126,7 +1126,7 @@ def test_getitem_overload(self):
         subindex = self.frame.index[indexer]
         subframe = self.frame[indexer]
 
-        self.assert_(np.array_equal(subindex, subframe.index))
+        self.assert_numpy_array_equal(subindex, subframe.index)
         self.assertRaises(Exception, self.frame.__getitem__, indexer[:-1])
 
     def test_setitem(self):
@@ -1413,8 +1413,8 @@ def _check(frame):
 
             from_sparse_lp = spf.stack_sparse_frame(frame)
 
-            self.assert_(np.array_equal(from_dense_lp.values,
-                                        from_sparse_lp.values))
+            self.assert_numpy_array_equal(from_dense_lp.values,
+                                          from_sparse_lp.values)
 
         _check(self.frame)
         _check(self.iframe)
@@ -1624,7 +1624,7 @@ def _compare_with_dense(panel):
             slp = panel.to_frame()
             dlp = panel.to_dense().to_frame()
 
-            self.assert_(np.array_equal(slp.values, dlp.values))
+            self.assert_numpy_array_equal(slp.values, dlp.values)
             self.assert_(slp.index.equals(dlp.index))
 
         _compare_with_dense(self.panel)

pandas/stats/tests/test_ols.py

@@ -881,7 +881,7 @@ def testFilterWithDictRHS(self):
         self.tsAssertEqual(exp_rhs2, rhs['x2'])
 
     def tsAssertEqual(self, ts1, ts2):
-        self.assert_(np.array_equal(ts1, ts2))
+        self.assert_numpy_array_equal(ts1, ts2)
 
 
 if __name__ == '__main__':

pandas/tools/tests/test_merge.py

@@ -90,8 +90,8 @@ def test_cython_left_outer_join(self):
         exp_rs = exp_rs.take(exp_ri)
         exp_rs[exp_ri == -1] = -1
 
-        self.assert_(np.array_equal(ls, exp_ls))
-        self.assert_(np.array_equal(rs, exp_rs))
+        self.assert_numpy_array_equal(ls, exp_ls)
+        self.assert_numpy_array_equal(rs, exp_rs)
 
     def test_cython_right_outer_join(self):
         left = a_([0, 1, 2, 1, 2, 0, 0, 1, 2, 3, 3], dtype=np.int64)
@@ -116,8 +116,8 @@ def test_cython_right_outer_join(self):
         exp_rs = exp_rs.take(exp_ri)
         exp_rs[exp_ri == -1] = -1
 
-        self.assert_(np.array_equal(ls, exp_ls))
-        self.assert_(np.array_equal(rs, exp_rs))
+        self.assert_numpy_array_equal(ls, exp_ls)
+        self.assert_numpy_array_equal(rs, exp_rs)
 
     def test_cython_inner_join(self):
         left = a_([0, 1, 2, 1, 2, 0, 0, 1, 2, 3, 3], dtype=np.int64)
@@ -140,8 +140,8 @@ def test_cython_inner_join(self):
         exp_rs = exp_rs.take(exp_ri)
         exp_rs[exp_ri == -1] = -1
 
-        self.assert_(np.array_equal(ls, exp_ls))
-        self.assert_(np.array_equal(rs, exp_rs))
+        self.assert_numpy_array_equal(ls, exp_ls)
+        self.assert_numpy_array_equal(rs, exp_rs)
 
     def test_left_outer_join(self):
         joined_key2 = merge(self.df, self.df2, on='key2')
@@ -199,8 +199,8 @@ def test_join_on(self):
         source = self.source
 
         merged = target.join(source, on='C')
-        self.assert_(np.array_equal(merged['MergedA'], target['A']))
-        self.assert_(np.array_equal(merged['MergedD'], target['D']))
+        self.assert_numpy_array_equal(merged['MergedA'], target['A'])
+        self.assert_numpy_array_equal(merged['MergedD'], target['D'])
 
         # join with duplicates (fix regression from DataFrame/Matrix merge)
         df = DataFrame({'key': ['a', 'a', 'b', 'b', 'c']})
@@ -285,8 +285,8 @@ def test_join_on_inner(self):
 
         expected = df.join(df2, on='key')
         expected = expected[expected['value'].notnull()]
-        self.assert_(np.array_equal(joined['key'], expected['key']))
-        self.assert_(np.array_equal(joined['value'], expected['value']))
+        self.assert_numpy_array_equal(joined['key'], expected['key'])
+        self.assert_numpy_array_equal(joined['value'], expected['value'])
         self.assert_(joined.index.equals(expected.index))
 
     def test_join_on_singlekey_list(self):
@@ -612,7 +612,7 @@ def test_join_sort(self):
 
         # smoke test
         joined = left.join(right, on='key', sort=False)
-        self.assert_(np.array_equal(joined.index, lrange(4)))
+        self.assert_numpy_array_equal(joined.index, lrange(4))
 
     def test_intelligently_handle_join_key(self):
         # #733, be a bit more 1337 about not returning unconsolidated DataFrame
@@ -651,15 +651,15 @@ def test_handle_join_key_pass_array(self):
         rkey = np.array([1, 1, 2, 3, 4, 5])
 
         merged = merge(left, right, left_on=lkey, right_on=rkey, how='outer')
-        self.assert_(np.array_equal(merged['key_0'],
-                                    np.array([1, 1, 1, 1, 2, 2, 3, 4, 5])))
+        self.assert_numpy_array_equal(merged['key_0'],
+                                      np.array([1, 1, 1, 1, 2, 2, 3, 4, 5]))
 
         left = DataFrame({'value': lrange(3)})
         right = DataFrame({'rvalue': lrange(6)})
 
         key = np.array([0, 1, 1, 2, 2, 3])
         merged = merge(left, right, left_index=True, right_on=key, how='outer')
-        self.assert_(np.array_equal(merged['key_0'], key))
+        self.assert_numpy_array_equal(merged['key_0'], key)
 
     def test_mixed_type_join_with_suffix(self):
         # GH #916
@@ -1414,7 +1414,7 @@ def test_concat_keys_specific_levels(self):
                         levels=[level],
                         names=['group_key'])
 
-        self.assert_(np.array_equal(result.columns.levels[0], level))
+        self.assert_numpy_array_equal(result.columns.levels[0], level)
         self.assertEqual(result.columns.names[0], 'group_key')
 
     def test_concat_dataframe_keys_bug(self):
@@ -1518,7 +1518,7 @@ def test_concat_keys_and_levels(self):
                               ('baz', 'one'), ('baz', 'two')],
                         names=['first', 'second'])
         self.assertEqual(result.index.names, ('first', 'second') + (None,))
-        self.assert_(np.array_equal(result.index.levels[0], ['baz', 'foo']))
+        self.assert_numpy_array_equal(result.index.levels[0], ['baz', 'foo'])
 
     def test_concat_keys_levels_no_overlap(self):
         # GH #1406

pandas/tools/tests/test_tile.py

@@ -76,12 +76,12 @@ def test_labels(self):
         result, bins = cut(arr, 4, retbins=True)
         ex_levels = ['(-0.001, 0.25]', '(0.25, 0.5]', '(0.5, 0.75]',
                      '(0.75, 1]']
-        self.assert_(np.array_equal(result.levels, ex_levels))
+        self.assert_numpy_array_equal(result.levels, ex_levels)
 
         result, bins = cut(arr, 4, retbins=True, right=False)
         ex_levels = ['[0, 0.25)', '[0.25, 0.5)', '[0.5, 0.75)',
                      '[0.75, 1.001)']
-        self.assert_(np.array_equal(result.levels, ex_levels))
+        self.assert_numpy_array_equal(result.levels, ex_levels)
 
     def test_cut_pass_series_name_to_factor(self):
         s = Series(np.random.randn(100), name='foo')
@@ -95,7 +95,7 @@ def test_label_precision(self):
         result = cut(arr, 4, precision=2)
         ex_levels = ['(-0.00072, 0.18]', '(0.18, 0.36]', '(0.36, 0.54]',
                      '(0.54, 0.72]']
-        self.assert_(np.array_equal(result.levels, ex_levels))
+        self.assert_numpy_array_equal(result.levels, ex_levels)
 
     def test_na_handling(self):
         arr = np.arange(0, 0.75, 0.01)
@@ -137,7 +137,7 @@ def test_qcut(self):
         assert_almost_equal(bins, ex_bins)
 
         ex_levels = cut(arr, ex_bins, include_lowest=True)
-        self.assert_(np.array_equal(labels, ex_levels))
+        self.assert_numpy_array_equal(labels, ex_levels)
 
     def test_qcut_bounds(self):
         arr = np.random.randn(1000)
@@ -162,7 +162,7 @@ def test_cut_out_of_bounds(self):
 
         mask = result.labels == -1
         ex_mask = (arr < -1) | (arr > 1)
-        self.assert_(np.array_equal(mask, ex_mask))
+        self.assert_numpy_array_equal(mask, ex_mask)
 
     def test_cut_pass_labels(self):
         arr = [50, 5, 10, 15, 20, 30, 70]

pandas/tseries/tests/test_daterange.py

@@ -42,13 +42,13 @@ class TestGenRangeGeneration(tm.TestCase):
     def test_generate(self):
         rng1 = list(generate_range(START, END, offset=datetools.bday))
         rng2 = list(generate_range(START, END, time_rule='B'))
-        self.assert_(np.array_equal(rng1, rng2))
+        self.assert_numpy_array_equal(rng1, rng2)
 
     def test_generate_cday(self):
         _skip_if_no_cday()
         rng1 = list(generate_range(START, END, offset=datetools.cday))
         rng2 = list(generate_range(START, END, time_rule='C'))
-        self.assert_(np.array_equal(rng1, rng2))
+        self.assert_numpy_array_equal(rng1, rng2)
 
     def test_1(self):
         eq_gen_range(dict(start=datetime(2009, 3, 25), periods=2),
@@ -139,7 +139,7 @@ def test_repr(self):
 
     def test_getitem(self):
         smaller = self.rng[:5]
-        self.assert_(np.array_equal(smaller, self.rng.view(np.ndarray)[:5]))
+        self.assert_numpy_array_equal(smaller, self.rng.view(np.ndarray)[:5])
         self.assertEquals(smaller.offset, self.rng.offset)
 
         sliced = self.rng[::5]
@@ -156,7 +156,7 @@ def test_getitem(self):
     def test_getitem_matplotlib_hackaround(self):
         values = self.rng[:, None]
         expected = self.rng.values[:, None]
-        self.assert_(np.array_equal(values, expected))
+        self.assert_numpy_array_equal(values, expected)
 
     def test_shift(self):
         shifted = self.rng.shift(5)
@@ -204,7 +204,7 @@ def test_union(self):
         tm.assert_isinstance(the_union, DatetimeIndex)
 
         # order does not matter
-        self.assert_(np.array_equal(right.union(left), the_union))
+        self.assert_numpy_array_equal(right.union(left), the_union)
 
         # overlapping, but different offset
         rng = date_range(START, END, freq=datetools.bmonthEnd)
@@ -352,7 +352,7 @@ def test_range_bug(self):
 
         start = datetime(2011, 1, 1)
         exp_values = [start + i * offset for i in range(5)]
-        self.assert_(np.array_equal(result, DatetimeIndex(exp_values)))
+        self.assert_numpy_array_equal(result, DatetimeIndex(exp_values))
 
     def test_range_tz(self):
         # GH 2906
@@ -459,7 +459,7 @@ def test_repr(self):
 
     def test_getitem(self):
         smaller = self.rng[:5]
-        self.assert_(np.array_equal(smaller, self.rng.view(np.ndarray)[:5]))
+        self.assert_numpy_array_equal(smaller, self.rng.view(np.ndarray)[:5])
         self.assertEquals(smaller.offset, self.rng.offset)
 
         sliced = self.rng[::5]
@@ -476,7 +476,7 @@ def test_getitem(self):
     def test_getitem_matplotlib_hackaround(self):
         values = self.rng[:, None]
         expected = self.rng.values[:, None]
-        self.assert_(np.array_equal(values, expected))
+        self.assert_numpy_array_equal(values, expected)
 
     def test_shift(self):
         shifted = self.rng.shift(5)
@@ -524,7 +524,7 @@ def test_union(self):
         tm.assert_isinstance(the_union, DatetimeIndex)
 
         # order does not matter
-        self.assert_(np.array_equal(right.union(left), the_union))
+        self.assert_numpy_array_equal(right.union(left), the_union)
 
         # overlapping, but different offset
         rng = date_range(START, END, freq=datetools.bmonthEnd)

pandas/tseries/tests/test_period.py

@@ -1088,7 +1088,7 @@ def test_astype(self):
         idx = period_range('1990', '2009', freq='A')
 
         result = idx.astype('i8')
-        self.assert_(np.array_equal(result, idx.values))
+        self.assert_numpy_array_equal(result, idx.values)
 
     def test_constructor_use_start_freq(self):
         # GH #1118
@@ -1140,8 +1140,8 @@ def test_constructor_arrays_negative_year(self):
 
         pindex = PeriodIndex(year=years, quarter=quarters)
 
-        self.assert_(np.array_equal(pindex.year, years))
-        self.assert_(np.array_equal(pindex.quarter, quarters))
+        self.assert_numpy_array_equal(pindex.year, years)
+        self.assert_numpy_array_equal(pindex.quarter, quarters)
 
     def test_constructor_invalid_quarters(self):
         self.assertRaises(ValueError, PeriodIndex, year=lrange(2000, 2004),
@@ -1210,7 +1210,7 @@ def test_comp_period(self):
 
         result = idx < idx[10]
         exp = idx.values < idx.values[10]
-        self.assert_(np.array_equal(result, exp))
+        self.assert_numpy_array_equal(result, exp)
 
     def test_getitem_ndim2(self):
         idx = period_range('2007-01', periods=3, freq='M')
@@ -2215,7 +2215,7 @@ def test_nanosecondly(self):
     def _check_freq(self, freq, base_date):
         rng = PeriodIndex(start=base_date, periods=10, freq=freq)
         exp = np.arange(10, dtype=np.int64)
-        self.assert_(np.array_equal(rng.values, exp))
+        self.assert_numpy_array_equal(rng.values, exp)
 
     def test_negone_ordinals(self):
         freqs = ['A', 'M', 'Q', 'D', 'H', 'T', 'S']