remove deprecated test code xref pandas-dev#10726

fix some stacklevels on warnings

Author: jreback

pandas/core/index.py

@@ -842,14 +842,14 @@ def to_int():
             elif is_float(key):
                 key = to_int()
                 warnings.warn("scalar indexers for index type {0} should be integers and not floating point".format(
-                    type(self).__name__),FutureWarning)
+                    type(self).__name__),FutureWarning, stacklevel=8)
                 return key
             return self._invalid_indexer('label', key)
 
         if is_float(key):
             if not self.is_floating():
                 warnings.warn("scalar indexers for index type {0} should be integers and not floating point".format(
-                    type(self).__name__),FutureWarning)
+                    type(self).__name__),FutureWarning, stacklevel=8)
             return to_int()
 
         return key
@@ -1488,7 +1488,9 @@ def union(self, other):
                     self.values[0] < other_diff[0]
                 except TypeError as e:
                     warnings.warn("%s, sort order is undefined for "
-                                  "incomparable objects" % e, RuntimeWarning)
+                                  "incomparable objects" % e,
+                                  RuntimeWarning,
+                                  stacklevel=3)
                 else:
                     types = frozenset((self.inferred_type,
                                        other.inferred_type))
@@ -1502,7 +1504,9 @@ def union(self, other):
                     result = np.sort(result)
                 except TypeError as e:
                     warnings.warn("%s, sort order is undefined for "
-                                  "incomparable objects" % e, RuntimeWarning)
+                                  "incomparable objects" % e,
+                                  RuntimeWarning,
+                                  stacklevel=3)
 
         # for subclasses
         return self._wrap_union_result(other, result)
@@ -5268,7 +5272,7 @@ def _maybe_str_to_time_stamp(key, lev):
             return slice(start, stop)
 
         warnings.warn('indexing past lexsort depth may impact performance.',
-                PerformanceWarning)
+                      PerformanceWarning, stacklevel=10)
 
         loc = np.arange(start, stop, dtype='int64')
 

pandas/tests/test_index.py

@@ -971,7 +971,8 @@ def test_add(self):
         with tm.assert_produces_warning():
             self.strIndex.tolist() + self.strIndex
 
-        firstCat = self.strIndex.union(self.dateIndex)
+        with tm.assert_produces_warning(RuntimeWarning):
+            firstCat = self.strIndex.union(self.dateIndex)
         secondCat = self.strIndex.union(self.strIndex)
 
         if self.dateIndex.dtype == np.object_:
@@ -1635,9 +1636,11 @@ def test_outer_join_sort(self):
 
         with tm.assert_produces_warning(RuntimeWarning):
             joined = left_idx.join(right_idx, how='outer')
+
         # right_idx in this case because DatetimeIndex has join precedence over
         # Int64Index
-        expected = right_idx.astype(object).union(left_idx.astype(object))
+        with tm.assert_produces_warning(RuntimeWarning):
+            expected = right_idx.astype(object).union(left_idx.astype(object))
         tm.assert_index_equal(joined, expected)
 
     def test_nan_first_take_datetime(self):

pandas/tests/test_indexing.py

@@ -1761,7 +1761,8 @@ def test_ix_general(self):
         key = 4.0, 2012
 
         # emits a PerformanceWarning, ok
-        tm.assert_frame_equal(df.ix[key], df.iloc[2:])
+        with self.assert_produces_warning(PerformanceWarning):
+            tm.assert_frame_equal(df.ix[key], df.iloc[2:])
 
         # this is ok
         df.sortlevel(inplace=True)

pandas/tools/plotting.py

@@ -1194,7 +1194,7 @@ def _get_xticks(self, convert_period=False):
 
         if self.use_index:
             if convert_period and isinstance(index, PeriodIndex):
-                self.data = self.data.reindex(index=index.order())
+                self.data = self.data.reindex(index=index.sort_values())
                 x = self.data.index.to_timestamp()._mpl_repr()
             elif index.is_numeric():
                 """

pandas/tools/tests/test_merge.py

@@ -992,8 +992,8 @@ def test_merge_on_multikey(self):
         assert_frame_equal(joined, expected.ix[:, joined.columns])
 
         left = self.data.join(self.to_join, on=['key1', 'key2'], sort=True)
-        right = expected.ix[:, joined.columns].sort(['key1', 'key2'],
-                                                    kind='mergesort')
+        right = expected.ix[:, joined.columns].sort_values(['key1', 'key2'],
+                                                           kind='mergesort')
         assert_frame_equal(left, right)
 
     def test_left_join_multi_index(self):
@@ -1019,7 +1019,7 @@ def run_asserts(left, right):
 
                 if sort:
                     tm.assert_frame_equal(res,
-                                          res.sort(icols, kind='mergesort'))
+                                          res.sort_values(icols, kind='mergesort'))
 
                 out = merge(left, right.reset_index(), on=icols,
                             sort=sort, how='left')
@@ -1099,7 +1099,7 @@ def test_left_join_index_preserve_order(self):
         expected.loc[(expected.k1 == 1) & (expected.k2 == 'foo'),'v2'] = 7
 
         tm.assert_frame_equal(result, expected)
-        tm.assert_frame_equal(result.sort(['k1', 'k2'], kind='mergesort'),
+        tm.assert_frame_equal(result.sort_values(['k1', 'k2'], kind='mergesort'),
                               left.join(right, on=['k1', 'k2'], sort=True))
 
         # test join with multi dtypes blocks
@@ -1119,7 +1119,7 @@ def test_left_join_index_preserve_order(self):
         expected.loc[(expected.k1 == 1) & (expected.k2 == 'foo'),'v2'] = 7
 
         tm.assert_frame_equal(result, expected)
-        tm.assert_frame_equal(result.sort(['k1', 'k2'], kind='mergesort'),
+        tm.assert_frame_equal(result.sort_values(['k1', 'k2'], kind='mergesort'),
                               left.join(right, on=['k1', 'k2'], sort=True))
 
         # do a right join for an extra test
@@ -1186,7 +1186,7 @@ def test_left_join_index_multi_match_multiindex(self):
                            how='left', sort=True)
 
         tm.assert_frame_equal(result,
-                expected.sort(['cola', 'colb', 'colc'], kind='mergesort'))
+                expected.sort_values(['cola', 'colb', 'colc'], kind='mergesort'))
 
         # GH7331 - maintain left frame order in left merge
         right.reset_index(inplace=True)
@@ -1233,7 +1233,7 @@ def test_left_join_index_multi_match(self):
         tm.assert_frame_equal(result, expected)
 
         result = left.join(right, on='tag', how='left', sort=True)
-        tm.assert_frame_equal(result, expected.sort('tag', kind='mergesort'))
+        tm.assert_frame_equal(result, expected.sort_values('tag', kind='mergesort'))
 
         # GH7331 - maintain left frame order in left merge
         result = merge(left, right.reset_index(), how='left', on='tag')
@@ -1264,7 +1264,7 @@ def _test(dtype1,dtype2):
             tm.assert_frame_equal(result, expected)
 
             result = left.join(right, on=['k1', 'k2'], sort=True)
-            expected.sort(['k1', 'k2'], kind='mergesort', inplace=True)
+            expected.sort_values(['k1', 'k2'], kind='mergesort', inplace=True)
             tm.assert_frame_equal(result, expected)
 
         for d1 in [np.int64,np.int32,np.int16,np.int8,np.uint8]:
@@ -1347,7 +1347,7 @@ def test_int64_overflow_issues(self):
         assert_series_equal(out['left'], result, check_names=False)
         self.assertTrue(result.name is None)
 
-        out.sort(out.columns.tolist(), inplace=True)
+        out.sort_values(out.columns.tolist(), inplace=True)
         out.index = np.arange(len(out))
         for how in ['left', 'right', 'outer', 'inner']:
             assert_frame_equal(out, merge(left, right, how=how, sort=True))
@@ -1411,14 +1411,14 @@ def test_int64_overflow_issues(self):
                     vals.append(k + tuple([np.nan, rv]))
 
         def align(df):
-            df = df.sort(df.columns.tolist())
+            df = df.sort_values(df.columns.tolist())
             df.index = np.arange(len(df))
             return df
 
         def verify_order(df):
             kcols = list('ABCDEFG')
             assert_frame_equal(df[kcols].copy(),
-                               df[kcols].sort(kcols, kind='mergesort'))
+                               df[kcols].sort_values(kcols, kind='mergesort'))
 
         out = DataFrame(vals, columns=list('ABCDEFG') + ['left', 'right'])
         out = align(out)

pandas/tseries/tests/test_base.py

@@ -305,22 +305,22 @@ def test_order(self):
                              freq='H', tz='Asia/Tokyo', name='tzidx')
 
         for idx in [idx1, idx2]:
-            ordered = idx.order()
+            ordered = idx.sort_values()
             self.assert_index_equal(ordered, idx)
             self.assertEqual(ordered.freq, idx.freq)
 
-            ordered = idx.order(ascending=False)
+            ordered = idx.sort_values(ascending=False)
             expected = idx[::-1]
             self.assert_index_equal(ordered, expected)
             self.assertEqual(ordered.freq, expected.freq)
             self.assertEqual(ordered.freq.n, -1)
 
-            ordered, indexer = idx.order(return_indexer=True)
+            ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, idx)
             self.assert_numpy_array_equal(indexer, np.array([0, 1, 2]))
             self.assertEqual(ordered.freq, idx.freq)
 
-            ordered, indexer = idx.order(return_indexer=True, ascending=False)
+            ordered, indexer = idx.sort_values(return_indexer=True, ascending=False)
             expected = idx[::-1]
             self.assert_index_equal(ordered, expected)
             self.assert_numpy_array_equal(indexer, np.array([2, 1, 0]))
@@ -346,20 +346,20 @@ def test_order(self):
                               '2011-01-05'], name='idx3')
 
         for idx, expected in [(idx1, exp1), (idx1, exp1), (idx1, exp1)]:
-            ordered = idx.order()
+            ordered = idx.sort_values()
             self.assert_index_equal(ordered, expected)
             self.assertIsNone(ordered.freq)
 
-            ordered = idx.order(ascending=False)
+            ordered = idx.sort_values(ascending=False)
             self.assert_index_equal(ordered, expected[::-1])
             self.assertIsNone(ordered.freq)
 
-            ordered, indexer = idx.order(return_indexer=True)
+            ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, expected)
             self.assert_numpy_array_equal(indexer, np.array([0, 4, 3, 1, 2]))
             self.assertIsNone(ordered.freq)
 
-            ordered, indexer = idx.order(return_indexer=True, ascending=False)
+            ordered, indexer = idx.sort_values(return_indexer=True, ascending=False)
             self.assert_index_equal(ordered, expected[::-1])
             self.assert_numpy_array_equal(indexer, np.array([2, 1, 3, 4, 0]))
             self.assertIsNone(ordered.freq)
@@ -900,22 +900,22 @@ def test_order(self):
         idx2 = TimedeltaIndex(['1 hour', '2 hour', '3 hour'], freq='H', name='idx')
 
         for idx in [idx1, idx2]:
-            ordered = idx.order()
+            ordered = idx.sort_values()
             self.assert_index_equal(ordered, idx)
             self.assertEqual(ordered.freq, idx.freq)
 
-            ordered = idx.order(ascending=False)
+            ordered = idx.sort_values(ascending=False)
             expected = idx[::-1]
             self.assert_index_equal(ordered, expected)
             self.assertEqual(ordered.freq, expected.freq)
             self.assertEqual(ordered.freq.n, -1)
 
-            ordered, indexer = idx.order(return_indexer=True)
+            ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, idx)
             self.assert_numpy_array_equal(indexer, np.array([0, 1, 2]))
             self.assertEqual(ordered.freq, idx.freq)
 
-            ordered, indexer = idx.order(return_indexer=True, ascending=False)
+            ordered, indexer = idx.sort_values(return_indexer=True, ascending=False)
             self.assert_index_equal(ordered, idx[::-1])
             self.assertEqual(ordered.freq, expected.freq)
             self.assertEqual(ordered.freq.n, -1)
@@ -936,20 +936,20 @@ def test_order(self):
                                '5 minute'], name='idx3')
 
         for idx, expected in [(idx1, exp1), (idx1, exp1), (idx1, exp1)]:
-            ordered = idx.order()
+            ordered = idx.sort_values()
             self.assert_index_equal(ordered, expected)
             self.assertIsNone(ordered.freq)
 
-            ordered = idx.order(ascending=False)
+            ordered = idx.sort_values(ascending=False)
             self.assert_index_equal(ordered, expected[::-1])
             self.assertIsNone(ordered.freq)
 
-            ordered, indexer = idx.order(return_indexer=True)
+            ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, expected)
             self.assert_numpy_array_equal(indexer, np.array([0, 4, 3, 1, 2]))
             self.assertIsNone(ordered.freq)
 
-            ordered, indexer = idx.order(return_indexer=True, ascending=False)
+            ordered, indexer = idx.sort_values(return_indexer=True, ascending=False)
             self.assert_index_equal(ordered, expected[::-1])
             self.assert_numpy_array_equal(indexer, np.array([2, 1, 3, 4, 0]))
             self.assertIsNone(ordered.freq)
@@ -1480,20 +1480,20 @@ def _check_freq(index, expected_index):
         # for compatibility check
         iidx = Index([2011, 2012, 2013], name='idx')
         for idx in [pidx, iidx]:
-            ordered = idx.order()
+            ordered = idx.sort_values()
             self.assert_index_equal(ordered, idx)
             _check_freq(ordered, idx)
 
-            ordered = idx.order(ascending=False)
+            ordered = idx.sort_values(ascending=False)
             self.assert_index_equal(ordered, idx[::-1])
             _check_freq(ordered, idx[::-1])
 
-            ordered, indexer = idx.order(return_indexer=True)
+            ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, idx)
             self.assert_numpy_array_equal(indexer, np.array([0, 1, 2]))
             _check_freq(ordered, idx)
 
-            ordered, indexer = idx.order(return_indexer=True, ascending=False)
+            ordered, indexer = idx.sort_values(return_indexer=True, ascending=False)
             self.assert_index_equal(ordered, idx[::-1])
             self.assert_numpy_array_equal(indexer, np.array([2, 1, 0]))
             _check_freq(ordered, idx[::-1])
@@ -1504,32 +1504,32 @@ def _check_freq(index, expected_index):
         iidx = Index([2011, 2013, 2015, 2012, 2011], name='idx')
         iexpected = Index([2011, 2011, 2012, 2013, 2015], name='idx')
         for idx, expected in [(pidx, pexpected), (iidx, iexpected)]:
-            ordered = idx.order()
+            ordered = idx.sort_values()
             self.assert_index_equal(ordered, expected)
             _check_freq(ordered, idx)
 
-            ordered = idx.order(ascending=False)
+            ordered = idx.sort_values(ascending=False)
             self.assert_index_equal(ordered, expected[::-1])
             _check_freq(ordered, idx)
 
-            ordered, indexer = idx.order(return_indexer=True)
+            ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, expected)
             self.assert_numpy_array_equal(indexer, np.array([0, 4, 3, 1, 2]))
             _check_freq(ordered, idx)
 
-            ordered, indexer = idx.order(return_indexer=True, ascending=False)
+            ordered, indexer = idx.sort_values(return_indexer=True, ascending=False)
             self.assert_index_equal(ordered, expected[::-1])
             self.assert_numpy_array_equal(indexer, np.array([2, 1, 3, 4, 0]))
             _check_freq(ordered, idx)
 
         pidx = PeriodIndex(['2011', '2013', 'NaT', '2011'], name='pidx', freq='D')
 
-        result = pidx.order()
+        result = pidx.sort_values()
         expected = PeriodIndex(['NaT', '2011', '2011', '2013'], name='pidx', freq='D')
         self.assert_index_equal(result, expected)
         self.assertEqual(result.freq, 'D')
 
-        result = pidx.order(ascending=False)
+        result = pidx.sort_values(ascending=False)
         expected = PeriodIndex(['2013', '2011', '2011', 'NaT'], name='pidx', freq='D')
         self.assert_index_equal(result, expected)
         self.assertEqual(result.freq, 'D')
@@ -1539,21 +1539,21 @@ def test_order(self):
                            freq='D', name='idx')
 
         for idx in [idx1]:
-            ordered = idx.order()
+            ordered = idx.sort_values()
             self.assert_index_equal(ordered, idx)
             self.assertEqual(ordered.freq, idx.freq)
 
-            ordered = idx.order(ascending=False)
+            ordered = idx.sort_values(ascending=False)
             expected = idx[::-1]
             self.assert_index_equal(ordered, expected)
             self.assertEqual(ordered.freq, 'D')
 
-            ordered, indexer = idx.order(return_indexer=True)
+            ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, idx)
             self.assert_numpy_array_equal(indexer, np.array([0, 1, 2]))
             self.assertEqual(ordered.freq, 'D')
 
-            ordered, indexer = idx.order(return_indexer=True, ascending=False)
+            ordered, indexer = idx.sort_values(return_indexer=True, ascending=False)
             expected = idx[::-1]
             self.assert_index_equal(ordered, expected)
             self.assert_numpy_array_equal(indexer, np.array([2, 1, 0]))
@@ -1577,20 +1577,20 @@ def test_order(self):
                             '2011-01-05'], freq='D', name='idx3')
 
         for idx, expected in [(idx1, exp1), (idx1, exp1), (idx1, exp1)]:
-            ordered = idx.order()
+            ordered = idx.sort_values()
             self.assert_index_equal(ordered, expected)
             self.assertEqual(ordered.freq, 'D')
 
-            ordered = idx.order(ascending=False)
+            ordered = idx.sort_values(ascending=False)
             self.assert_index_equal(ordered, expected[::-1])
             self.assertEqual(ordered.freq, 'D')
 
-            ordered, indexer = idx.order(return_indexer=True)
+            ordered, indexer = idx.sort_values(return_indexer=True)
             self.assert_index_equal(ordered, expected)
             self.assert_numpy_array_equal(indexer, np.array([0, 4, 3, 1, 2]))
             self.assertEqual(ordered.freq, 'D')
 
-            ordered, indexer = idx.order(return_indexer=True, ascending=False)
+            ordered, indexer = idx.sort_values(return_indexer=True, ascending=False)
             self.assert_index_equal(ordered, expected[::-1])
             self.assert_numpy_array_equal(indexer, np.array([2, 1, 3, 4, 0]))
             self.assertEqual(ordered.freq, 'D')