DEPR/TST: correct stacklevels (GH9584)

Only check stacklevel for FutureWarnings/DeprecationWarnings for now

Author: jorisvandenbossche

pandas/computation/align.py

@@ -101,7 +101,8 @@ def _align_core(terms):
                                   'than an order of magnitude on term {1!r}, '
                                   'by more than {2:.4g}; performance may '
                                   'suffer'.format(axis, terms[i].name, ordm),
-                                  category=pd.io.common.PerformanceWarning)
+                                  category=pd.io.common.PerformanceWarning,
+                                  stacklevel=6)
 
                 if transpose:
                     f = partial(ti.reindex, index=reindexer, copy=False)

pandas/computation/pytables.py

@@ -535,7 +535,7 @@ def parse_back_compat(self, w, op=None, value=None):
                 w, op, value = w
             warnings.warn("passing a tuple into Expr is deprecated, "
                           "pass the where as a single string",
-                          DeprecationWarning)
+                          DeprecationWarning, stacklevel=10)
 
         if op is not None:
             if not isinstance(w, string_types):

pandas/core/categorical.py

@@ -414,7 +414,7 @@ def _get_labels(self):
 
         Deprecated, use .codes!
         """
-        warn("'labels' is deprecated. Use 'codes' instead", FutureWarning, stacklevel=3)
+        warn("'labels' is deprecated. Use 'codes' instead", FutureWarning, stacklevel=2)
         return self.codes
 
     labels = property(fget=_get_labels, fset=_set_codes)
@@ -456,7 +456,7 @@ def _validate_categories(cls, categories, fastpath=False):
                 # NaNs in cats deprecated in 0.17, remove in 0.18 or 0.19 GH 10748
                 msg = ('\nSetting NaNs in `categories` is deprecated and '
                        'will be removed in a future version of pandas.')
-                warn(msg, FutureWarning, stacklevel=5)
+                warn(msg, FutureWarning, stacklevel=3)
 
             # categories must be unique
 
@@ -491,12 +491,12 @@ def _get_categories(self):
 
     def _set_levels(self, levels):
         """ set new levels (deprecated, use "categories") """
-        warn("Assigning to 'levels' is deprecated, use 'categories'", FutureWarning, stacklevel=3)
+        warn("Assigning to 'levels' is deprecated, use 'categories'", FutureWarning, stacklevel=2)
         self.categories = levels
 
     def _get_levels(self):
         """ Gets the levels (deprecated, use "categories") """
-        warn("Accessing 'levels' is deprecated, use 'categories'", FutureWarning, stacklevel=3)
+        warn("Accessing 'levels' is deprecated, use 'categories'", FutureWarning, stacklevel=2)
         return self.categories
 
     # TODO: Remove after deprecation period in 2017/ after 0.18
@@ -507,7 +507,7 @@ def _get_levels(self):
     def _set_ordered(self, value):
         """ Sets the ordered attribute to the boolean value """
         warn("Setting 'ordered' directly is deprecated, use 'set_ordered'", FutureWarning,
-             stacklevel=3)
+             stacklevel=2)
         self.set_ordered(value, inplace=True)
 
     def set_ordered(self, value, inplace=False):
@@ -1200,7 +1200,7 @@ def order(self, inplace=False, ascending=True, na_position='last'):
         Category.sort
         """
         warn("order is deprecated, use sort_values(...)",
-             FutureWarning, stacklevel=3)
+             FutureWarning, stacklevel=2)
         return self.sort_values(inplace=inplace, ascending=ascending, na_position=na_position)
 
     def sort(self, inplace=True, ascending=True, na_position='last'):

pandas/core/frame.py

@@ -2919,7 +2919,7 @@ def dropna(self, axis=0, how='any', thresh=None, subset=None,
             return result
 
     @deprecate_kwarg('take_last', 'keep', mapping={True: 'last', False: 'first'})
-    @deprecate_kwarg(old_arg_name='cols', new_arg_name='subset')
+    @deprecate_kwarg(old_arg_name='cols', new_arg_name='subset', stacklevel=3)
     def drop_duplicates(self, subset=None, keep='first', inplace=False):
         """
         Return DataFrame with duplicate rows removed, optionally only
@@ -2953,7 +2953,7 @@ def drop_duplicates(self, subset=None, keep='first', inplace=False):
             return self[-duplicated]
 
     @deprecate_kwarg('take_last', 'keep', mapping={True: 'last', False: 'first'})
-    @deprecate_kwarg(old_arg_name='cols', new_arg_name='subset')
+    @deprecate_kwarg(old_arg_name='cols', new_arg_name='subset', stacklevel=3)
     def duplicated(self, subset=None, keep='first'):
         """
         Return boolean Series denoting duplicate rows, optionally only

pandas/core/generic.py

@@ -706,7 +706,7 @@ def iterkv(self, *args, **kwargs):
         "iteritems alias used to get around 2to3. Deprecated"
         warnings.warn("iterkv is deprecated and will be removed in a future "
                       "release, use ``iteritems`` instead.",
-                      FutureWarning)
+                      FutureWarning, stacklevel=2)
         return self.iteritems(*args, **kwargs)
 
     def __len__(self):

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, stacklevel=2)
+                    type(self).__name__), FutureWarning, stacklevel=5)
                 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, stacklevel=2)
+                    type(self).__name__), FutureWarning, stacklevel=3)
             return to_int()
 
         return key
@@ -887,7 +887,7 @@ def f(c):
                 # warn if it's a convertible float
                 if v == int(v):
                     warnings.warn("slice indexers when using iloc should be integers "
-                                  "and not floating point",FutureWarning, stacklevel=2)
+                                  "and not floating point", FutureWarning, stacklevel=7)
                     return int(v)
 
                 self._invalid_indexer('slice {0} value'.format(c), v)

pandas/core/strings.py

@@ -204,7 +204,7 @@ def str_contains(arr, pat, case=True, flags=0, na=np.nan, regex=True):
 
         if regex.groups > 0:
             warnings.warn("This pattern has match groups. To actually get the"
-                          " groups, use str.extract.", UserWarning)
+                          " groups, use str.extract.", UserWarning, stacklevel=3)
 
         f = lambda x: bool(regex.search(x))
     else:
@@ -377,11 +377,12 @@ def str_match(arr, pat, case=True, flags=0, na=np.nan, as_indexer=False):
         # Do this first, to make sure it happens even if the re.compile
         # raises below.
         warnings.warn("In future versions of pandas, match will change to"
-                      " always return a bool indexer.", UserWarning)
+                      " always return a bool indexer.", FutureWarning,
+                      stacklevel=3)
 
     if as_indexer and regex.groups > 0:
         warnings.warn("This pattern has match groups. To actually get the"
-                      " groups, use str.extract.", UserWarning)
+                      " groups, use str.extract.", UserWarning, stacklevel=3)
 
     # If not as_indexer and regex.groups == 0, this returns empty lists
     # and is basically useless, so we will not warn.

pandas/io/parsers.py

@@ -647,7 +647,7 @@ def _clean_options(self, options, engine):
             warnings.warn(("Falling back to the 'python' engine because"
                            " {0}; you can avoid this warning by specifying"
                            " engine='python'.").format(fallback_reason),
-                          ParserWarning)
+                          ParserWarning, stacklevel=5)
 
         index_col = options['index_col']
         names = options['names']

pandas/io/pytables.py

@@ -1596,7 +1596,7 @@ def update_info(self, info):
                 # frequency/name just warn
                 if key in ['freq', 'index_name']:
                     ws = attribute_conflict_doc % (key, existing_value, value)
-                    warnings.warn(ws, AttributeConflictWarning)
+                    warnings.warn(ws, AttributeConflictWarning, stacklevel=6)
 
                     # reset
                     idx[key] = None
@@ -2581,7 +2581,7 @@ def write_array(self, key, value, items=None):
                 except:
                     pass
                 ws = performance_doc % (inferred_type, key, items)
-                warnings.warn(ws, PerformanceWarning)
+                warnings.warn(ws, PerformanceWarning, stacklevel=7)
 
             vlarr = self._handle.create_vlarray(self.group, key,
                                                _tables().ObjectAtom())
@@ -3716,7 +3716,7 @@ def read(self, where=None, columns=None, **kwargs):
                 objs.append(obj)
 
         else:
-            warnings.warn(duplicate_doc, DuplicateWarning)
+            warnings.warn(duplicate_doc, DuplicateWarning, stacklevel=5)
 
             # reconstruct
             long_index = MultiIndex.from_arrays(

pandas/io/sql.py

@@ -328,7 +328,7 @@ def read_sql_table(table_name, con, schema=None, index_col=None,
     read_sql
 
     """
-    
+
     con = _engine_builder(con)
     if not _is_sqlalchemy_connectable(con):
         raise NotImplementedError("read_sql_table only supported for "
@@ -364,7 +364,7 @@ def read_sql_query(sql, con, index_col=None, coerce_float=True, params=None,
     ----------
     sql : string
         SQL query to be executed
-    con : SQLAlchemy connectable(engine/connection) or database string URI 
+    con : SQLAlchemy connectable(engine/connection) or database string URI
         or sqlite3 DBAPI2 connection
         Using SQLAlchemy makes it possible to use any DB supported by that
         library.
@@ -618,7 +618,7 @@ def pandasSQL_builder(con, flavor=None, schema=None, meta=None,
         return SQLDatabase(con, schema=schema, meta=meta)
     else:
         if flavor == 'mysql':
-            warnings.warn(_MYSQL_WARNING, FutureWarning, stacklevel=2)
+            warnings.warn(_MYSQL_WARNING, FutureWarning, stacklevel=3)
         return SQLiteDatabase(con, flavor, is_cursor=is_cursor)
 
 
@@ -957,7 +957,7 @@ def _sqlalchemy_type(self, col):
         if col_type == 'timedelta64':
             warnings.warn("the 'timedelta' type is not supported, and will be "
                           "written as integer values (ns frequency) to the "
-                          "database.", UserWarning)
+                          "database.", UserWarning, stacklevel=8)
             return BigInteger
         elif col_type == 'floating':
             if col.dtype == 'float32':
@@ -1409,7 +1409,7 @@ def _create_table_setup(self):
         pat = re.compile('\s+')
         column_names = [col_name for col_name, _, _ in column_names_and_types]
         if any(map(pat.search, column_names)):
-            warnings.warn(_SAFE_NAMES_WARNING)
+            warnings.warn(_SAFE_NAMES_WARNING, stacklevel=6)
 
         flv = self.pd_sql.flavor
         escape = _SQL_GET_IDENTIFIER[flv]
@@ -1450,7 +1450,7 @@ def _sql_type_name(self, col):
         if col_type == 'timedelta64':
             warnings.warn("the 'timedelta' type is not supported, and will be "
                           "written as integer values (ns frequency) to the "
-                          "database.", UserWarning)
+                          "database.", UserWarning, stacklevel=8)
             col_type = "integer"
 
         elif col_type == "datetime64":

pandas/io/tests/test_pytables.py

@@ -122,7 +122,7 @@ def _maybe_remove(store, key):
         pass
 
 
-def compat_assert_produces_warning(w,f):
+def compat_assert_produces_warning(w, f):
     """ don't produce a warning under PY3 """
     if compat.PY3:
         f()
@@ -2516,7 +2516,8 @@ def test_terms(self):
                 [ "minor_axis=['A','B']", dict(field='major_axis', op='>', value='20121114') ]
                 ]
             for t in terms:
-                with tm.assert_produces_warning(expected_warning=DeprecationWarning):
+                with tm.assert_produces_warning(expected_warning=DeprecationWarning,
+                                                check_stacklevel=False):
                     Term(t)
 
             # valid terms
@@ -2609,7 +2610,8 @@ def test_backwards_compat_without_term_object(self):
                        major_axis=date_range('1/1/2000', periods=5),
                        minor_axis=['A', 'B', 'C', 'D'])
             store.append('wp',wp)
-            with tm.assert_produces_warning(expected_warning=DeprecationWarning):
+            with tm.assert_produces_warning(expected_warning=DeprecationWarning,
+                                            check_stacklevel=not compat.PY3):
                 result = store.select('wp', [('major_axis>20000102'),
                                              ('minor_axis', '=', ['A','B']) ])
             expected = wp.loc[:,wp.major_axis>Timestamp('20000102'),['A','B']]
@@ -2628,20 +2630,24 @@ def test_backwards_compat_without_term_object(self):
             store.append('wp',wp)
 
             # stringified datetimes
-            with tm.assert_produces_warning(expected_warning=DeprecationWarning):
+            with tm.assert_produces_warning(expected_warning=DeprecationWarning,
+                                            check_stacklevel=not compat.PY3):
                 result = store.select('wp', [('major_axis','>',datetime.datetime(2000,1,2))])
             expected = wp.loc[:,wp.major_axis>Timestamp('20000102')]
             assert_panel_equal(result, expected)
-            with tm.assert_produces_warning(expected_warning=DeprecationWarning):
+            with tm.assert_produces_warning(expected_warning=DeprecationWarning,
+                                            check_stacklevel=not compat.PY3):
                 result = store.select('wp', [('major_axis','>',datetime.datetime(2000,1,2,0,0))])
             expected = wp.loc[:,wp.major_axis>Timestamp('20000102')]
             assert_panel_equal(result, expected)
-            with tm.assert_produces_warning(expected_warning=DeprecationWarning):
+            with tm.assert_produces_warning(expected_warning=DeprecationWarning,
+                                            check_stacklevel=not compat.PY3):
                 result = store.select('wp', [('major_axis','=',[datetime.datetime(2000,1,2,0,0),
                                                                 datetime.datetime(2000,1,3,0,0)])])
             expected = wp.loc[:,[Timestamp('20000102'),Timestamp('20000103')]]
             assert_panel_equal(result, expected)
-            with tm.assert_produces_warning(expected_warning=DeprecationWarning):
+            with tm.assert_produces_warning(expected_warning=DeprecationWarning,
+                                            check_stacklevel=not compat.PY3):
                 result = store.select('wp', [('minor_axis','=',['A','B'])])
             expected = wp.loc[:,:,['A','B']]
             assert_panel_equal(result, expected)
@@ -4528,7 +4534,7 @@ def f():
             s = Series(np.random.randn(len(unicode_values)), unicode_values)
             self._check_roundtrip(s, tm.assert_series_equal)
 
-        compat_assert_produces_warning(PerformanceWarning,f)
+        compat_assert_produces_warning(PerformanceWarning, f)
 
     def test_store_datetime_mixed(self):
 

pandas/parser.pyx

@@ -1838,7 +1838,7 @@ def _concatenate_chunks(list chunks):
         warning_message = " ".join(["Columns (%s) have mixed types." % warning_names,
             "Specify dtype option on import or set low_memory=False."
           ])
-        warnings.warn(warning_message, DtypeWarning)
+        warnings.warn(warning_message, DtypeWarning, stacklevel=8)
     return result
 
 #----------------------------------------------------------------------

pandas/tests/test_categorical.py

@@ -1590,7 +1590,7 @@ def test_nan_handling(self):
 
         # Changing categories should also make the replaced category np.nan
         s3 = Series(Categorical(["a","b","c","a"]))
-        with tm.assert_produces_warning(FutureWarning):
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
             s3.cat.categories = ["a","b",np.nan]
         self.assert_numpy_array_equal(s3.cat.categories,
                                       np.array(["a","b",np.nan], dtype=np.object_))

pandas/tests/test_expressions.py

@@ -382,32 +382,32 @@ def test_bool_ops_warn_on_arithmetic(self):
             fe = getattr(operator, sub_funcs[subs[op]])
 
             with tm.use_numexpr(True, min_elements=5):
-                with tm.assert_produces_warning():
+                with tm.assert_produces_warning(check_stacklevel=False):
                     r = f(df, df)
                     e = fe(df, df)
                     tm.assert_frame_equal(r, e)
 
-                with tm.assert_produces_warning():
+                with tm.assert_produces_warning(check_stacklevel=False):
                     r = f(df.a, df.b)
                     e = fe(df.a, df.b)
                     tm.assert_series_equal(r, e)
 
-                with tm.assert_produces_warning():
+                with tm.assert_produces_warning(check_stacklevel=False):
                     r = f(df.a, True)
                     e = fe(df.a, True)
                     tm.assert_series_equal(r, e)
 
-                with tm.assert_produces_warning():
+                with tm.assert_produces_warning(check_stacklevel=False):
                     r = f(False, df.a)
                     e = fe(False, df.a)
                     tm.assert_series_equal(r, e)
 
-                with tm.assert_produces_warning():
+                with tm.assert_produces_warning(check_stacklevel=False):
                     r = f(False, df)
                     e = fe(False, df)
                     tm.assert_frame_equal(r, e)
 
-                with tm.assert_produces_warning():
+                with tm.assert_produces_warning(check_stacklevel=False):
                     r = f(df, True)
                     e = fe(df, True)
                     tm.assert_frame_equal(r, e)

pandas/tests/test_format.py

@@ -2734,7 +2734,7 @@ def test_round_dataframe(self):
         non_int_round_dict = {'col1': 1, 'col2': 0.5}
         if sys.version < LooseVersion('2.7'):
             # np.round([1.123, 2.123], 0.5) is only a warning in Python 2.6
-            with self.assert_produces_warning(DeprecationWarning):
+            with self.assert_produces_warning(DeprecationWarning, check_stacklevel=False):
                 df.round(non_int_round_dict)
         else:
             with self.assertRaises(TypeError):

pandas/tests/test_frame.py

@@ -1440,7 +1440,8 @@ def test_getitem_setitem_float_labels(self):
         df = DataFrame(np.random.randn(5, 5), index=index)
 
         # positional slicing only via iloc!
-        with tm.assert_produces_warning(FutureWarning):
+        # stacklevel=False -> needed stacklevel depends on index type
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
             result = df.iloc[1.0:5]
 
         expected = df.reindex([2.5, 3.5, 4.5, 5.0])

pandas/tests/test_graphics_others.py

@@ -677,7 +677,7 @@ def test_grouped_box_return_type(self):
                                     expected_keys=['height', 'weight', 'category'])
 
         # now for groupby
-        with tm.assert_produces_warning(FutureWarning):
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
             result = df.groupby('gender').boxplot()
         self._check_box_return_type(result, 'dict', expected_keys=['Male', 'Female'])