COMPAT: remove some deprecation warnings in 3.6

partion on pandas-dev#14679

Author: jreback

pandas/io/tests/json/test_pandas.py

@@ -971,7 +971,7 @@ def test_to_jsonl(self):
     def test_latin_encoding(self):
         if compat.PY2:
             self.assertRaisesRegexp(
-                TypeError, '\[unicode\] is not implemented as a table column')
+                TypeError, r'\[unicode\] is not implemented as a table column')
             return
 
         # GH 13774

pandas/io/tests/parser/common.py

@@ -836,7 +836,7 @@ def test_integer_overflow_bug(self):
         result = self.read_csv(StringIO(data), header=None, sep=' ')
         self.assertTrue(result[0].dtype == np.float64)
 
-        result = self.read_csv(StringIO(data), header=None, sep='\s+')
+        result = self.read_csv(StringIO(data), header=None, sep=r'\s+')
         self.assertTrue(result[0].dtype == np.float64)
 
     def test_catch_too_many_names(self):
@@ -852,7 +852,7 @@ def test_catch_too_many_names(self):
     def test_ignore_leading_whitespace(self):
         # see gh-3374, gh-6607
         data = ' a b c\n 1 2 3\n 4 5 6\n 7 8 9'
-        result = self.read_table(StringIO(data), sep='\s+')
+        result = self.read_table(StringIO(data), sep=r'\s+')
         expected = DataFrame({'a': [1, 4, 7], 'b': [2, 5, 8], 'c': [3, 6, 9]})
         tm.assert_frame_equal(result, expected)
 
@@ -1052,7 +1052,7 @@ def test_uneven_lines_with_usecols(self):
 
         # make sure that an error is still thrown
         # when the 'usecols' parameter is not provided
-        msg = "Expected \d+ fields in line \d+, saw \d+"
+        msg = r"Expected \d+ fields in line \d+, saw \d+"
         with tm.assertRaisesRegexp(ValueError, msg):
             df = self.read_csv(StringIO(csv))
 
@@ -1122,7 +1122,7 @@ def test_raise_on_sep_with_delim_whitespace(self):
         # see gh-6607
         data = 'a b c\n1 2 3'
         with tm.assertRaisesRegexp(ValueError, 'you can only specify one'):
-            self.read_table(StringIO(data), sep='\s', delim_whitespace=True)
+            self.read_table(StringIO(data), sep=r'\s', delim_whitespace=True)
 
     def test_single_char_leading_whitespace(self):
         # see gh-9710
@@ -1157,7 +1157,7 @@ def test_empty_lines(self):
                              [-70., .4, 1.]])
         df = self.read_csv(StringIO(data))
         tm.assert_numpy_array_equal(df.values, expected)
-        df = self.read_csv(StringIO(data.replace(',', '  ')), sep='\s+')
+        df = self.read_csv(StringIO(data.replace(',', '  ')), sep=r'\s+')
         tm.assert_numpy_array_equal(df.values, expected)
         expected = np.array([[1., 2., 4.],
                              [np.nan, np.nan, np.nan],
@@ -1189,14 +1189,14 @@ def test_regex_separator(self):
 b   1   2   3   4
 c   1   2   3   4
 """
-        df = self.read_table(StringIO(data), sep='\s+')
+        df = self.read_table(StringIO(data), sep=r'\s+')
         expected = self.read_csv(StringIO(re.sub('[ ]+', ',', data)),
                                  index_col=0)
         self.assertIsNone(expected.index.name)
         tm.assert_frame_equal(df, expected)
 
         data = '    a b c\n1 2 3 \n4 5  6\n 7 8 9'
-        result = self.read_table(StringIO(data), sep='\s+')
+        result = self.read_table(StringIO(data), sep=r'\s+')
         expected = DataFrame([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
                              columns=['a', 'b', 'c'])
         tm.assert_frame_equal(result, expected)
@@ -1580,7 +1580,7 @@ def test_temporary_file(self):
         new_file.flush()
         new_file.seek(0)
 
-        result = self.read_csv(new_file, sep='\s+', header=None)
+        result = self.read_csv(new_file, sep=r'\s+', header=None)
         new_file.close()
         expected = DataFrame([[0, 0]])
         tm.assert_frame_equal(result, expected)

pandas/io/tests/test_pytables.py

@@ -987,7 +987,7 @@ def test_latin_encoding(self):
 
         if compat.PY2:
             self.assertRaisesRegexp(
-                TypeError, '\[unicode\] is not implemented as a table column')
+                TypeError, r'\[unicode\] is not implemented as a table column')
             return
 
         values = [[b'E\xc9, 17', b'', b'a', b'b', b'c'],

pandas/tests/formats/test_format.py

@@ -89,7 +89,7 @@ def has_vertically_truncated_repr(df):
     r = repr(df)
     only_dot_row = False
     for row in r.splitlines():
-        if re.match('^[\.\ ]+$', row):
+        if re.match(r'^[\.\ ]+$', row):
             only_dot_row = True
     return only_dot_row
 
@@ -834,7 +834,7 @@ def check_with_width(df, col_space):
             # check that col_space affects HTML generation
             # and be very brittle about it.
             html = df.to_html(col_space=col_space)
-            hdrs = [x for x in html.split("\n") if re.search("<th[>\s]", x)]
+            hdrs = [x for x in html.split(r"\n") if re.search(r"<th[>\s]", x)]
             self.assertTrue(len(hdrs) > 0)
             for h in hdrs:
                 self.assertTrue("min-width" in h)
@@ -1940,7 +1940,7 @@ def test_to_string(self):
                                   float_format='%.5f'.__mod__)
         lines = result.split('\n')
         header = lines[0].strip().split()
-        joined = '\n'.join([re.sub('\s+', ' ', x).strip() for x in lines[1:]])
+        joined = '\n'.join([re.sub(r'\s+', ' ', x).strip() for x in lines[1:]])
         recons = read_table(StringIO(joined), names=header,
                             header=None, sep=' ')
         tm.assert_series_equal(recons['B'], biggie['B'])
@@ -3782,7 +3782,7 @@ def chck_ncols(self, s):
             res = repr(s)
         lines = res.split('\n')
         lines = [line for line in repr(s).split('\n')
-                 if not re.match('[^\.]*\.+', line)][:-1]
+                 if not re.match(r'[^\.]*\.+', line)][:-1]
         ncolsizes = len(set(len(line.strip()) for line in lines))
         self.assertEqual(ncolsizes, 1)
 
@@ -3823,7 +3823,7 @@ def test_max_rows_eq_one(self):
 
     def test_truncate_ndots(self):
         def getndots(s):
-            return len(re.match('[^\.]*(\.*)', s).groups()[0])
+            return len(re.match(r'[^\.]*(\.*)', s).groups()[0])
 
         s = Series([0, 2, 3, 6])
         with option_context("display.max_rows", 2):

pandas/tests/frame/test_constructors.py

@@ -304,7 +304,7 @@ def test_constructor_error_msgs(self):
                        'B': ['a', 'b', 'c']})
 
         # wrong size ndarray, GH 3105
-        msg = "Shape of passed values is \(3, 4\), indices imply \(3, 3\)"
+        msg = r"Shape of passed values is \(3, 4\), indices imply \(3, 3\)"
         with tm.assertRaisesRegexp(ValueError, msg):
             DataFrame(np.arange(12).reshape((4, 3)),
                       columns=['foo', 'bar', 'baz'],
@@ -316,11 +316,11 @@ def test_constructor_error_msgs(self):
 
         # wrong size axis labels
         with tm.assertRaisesRegexp(ValueError, "Shape of passed values is "
-                                   "\(3, 2\), indices imply \(3, 1\)"):
+                                   r"\(3, 2\), indices imply \(3, 1\)"):
             DataFrame(np.random.rand(2, 3), columns=['A', 'B', 'C'], index=[1])
 
         with tm.assertRaisesRegexp(ValueError, "Shape of passed values is "
-                                   "\(3, 2\), indices imply \(2, 2\)"):
+                                   r"\(3, 2\), indices imply \(2, 2\)"):
             DataFrame(np.random.rand(2, 3), columns=['A', 'B'], index=[1, 2])
 
         with tm.assertRaisesRegexp(ValueError, 'If using all scalar values, '

pandas/tests/frame/test_query_eval.py

@@ -1124,8 +1124,8 @@ def test_invalid_type_for_operator_raises(self):
         ops = '+', '-', '*', '/'
         for op in ops:
             with tm.assertRaisesRegexp(TypeError,
-                                       "unsupported operand type\(s\) for "
-                                       ".+: '.+' and '.+'"):
+                                       r"unsupported operand type\(s\) for "
+                                       r".+: '.+' and '.+'"):
                 df.eval('a {0} b'.format(op), engine=self.engine,
                         parser=self.parser)
 

pandas/tests/frame/test_replace.py

@@ -550,7 +550,7 @@ def test_regex_replace_numeric_to_object_conversion(self):
         self.assertEqual(res.a.dtype, np.object_)
 
     def test_replace_regex_metachar(self):
-        metachars = '[]', '()', '\d', '\w', '\s'
+        metachars = '[]', '()', r'\d', r'\w', r'\s'
 
         for metachar in metachars:
             df = DataFrame({'a': [metachar, 'else']})
@@ -889,7 +889,7 @@ def test_replace_doesnt_replace_without_regex(self):
         2    2     0     0     0
         3    3     0    bt     0"""
         df = pd.read_csv(StringIO(raw), sep=r'\s+')
-        res = df.replace({'\D': 1})
+        res = df.replace({r'\D': 1})
         assert_frame_equal(df, res)
 
     def test_replace_bool_with_string(self):

pandas/tests/indexes/common.py

@@ -431,7 +431,7 @@ def test_take_invalid_kwargs(self):
         idx = self.create_index()
         indices = [1, 2]
 
-        msg = "take\(\) got an unexpected keyword argument 'foo'"
+        msg = r"take\(\) got an unexpected keyword argument 'foo'"
         tm.assertRaisesRegexp(TypeError, msg, idx.take,
                               indices, foo=2)
 

pandas/tests/indexes/test_category.py

@@ -890,7 +890,7 @@ def test_take_invalid_kwargs(self):
         idx = pd.CategoricalIndex([1, 2, 3], name='foo')
         indices = [1, 0, -1]
 
-        msg = "take\(\) got an unexpected keyword argument 'foo'"
+        msg = r"take\(\) got an unexpected keyword argument 'foo'"
         tm.assertRaisesRegexp(TypeError, msg, idx.take,
                               indices, foo=2)
 

pandas/tests/indexes/test_multi.py

@@ -1870,7 +1870,7 @@ def take_invalid_kwargs(self):
         idx = pd.MultiIndex.from_product(vals, names=['str', 'dt'])
         indices = [1, 2]
 
-        msg = "take\(\) got an unexpected keyword argument 'foo'"
+        msg = r"take\(\) got an unexpected keyword argument 'foo'"
         tm.assertRaisesRegexp(TypeError, msg, idx.take,
                               indices, foo=2)
 

pandas/tests/indexing/test_indexing.py

@@ -1338,7 +1338,7 @@ def test_at_to_fail(self):
         df.columns = ['x', 'x', 'z']
 
         # Check that we get the correct value in the KeyError
-        self.assertRaisesRegexp(KeyError, "\['y'\] not in index",
+        self.assertRaisesRegexp(KeyError, r"\['y'\] not in index",
                                 lambda: df[['x', 'y', 'z']])
 
     def test_loc_getitem_label_slice(self):
@@ -2232,7 +2232,7 @@ def f():
         with tm.assertRaisesRegexp(
                 KeyError,
                 'MultiIndex Slicing requires the index to be fully '
-                'lexsorted tuple len \(2\), lexsort depth \(0\)'):
+                r'lexsorted tuple len \(2\), lexsort depth \(0\)'):
             df.loc[(slice(None), df.loc[:, ('a', 'bar')] > 5), :]
 
     def test_multiindex_slicers_non_unique(self):
@@ -3646,7 +3646,7 @@ def test_mi_access(self):
 5  f    B   6  A2   6
 """
 
-        df = pd.read_csv(StringIO(data), sep='\s+', index_col=0)
+        df = pd.read_csv(StringIO(data), sep=r'\s+', index_col=0)
         df2 = df.set_index(['main', 'sub']).T.sort_index(1)
         index = Index(['h1', 'h3', 'h5'])
         columns = MultiIndex.from_tuples([('A', 'A1')], names=['main', 'sub'])

pandas/tests/series/test_analytics.py

@@ -1618,7 +1618,7 @@ def test_reshape_bad_kwarg(self):
             tm.assertRaisesRegexp(TypeError, msg, a.reshape, (2, 2), foo=2)
 
         with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
-            msg = "reshape\(\) got an unexpected keyword argument 'foo'"
+            msg = r"reshape\(\) got an unexpected keyword argument 'foo'"
             tm.assertRaisesRegexp(TypeError, msg, a.reshape, a.shape, foo=2)
 
     def test_numpy_reshape(self):

pandas/tests/test_generic.py

@@ -1740,8 +1740,8 @@ def test_numpy_squeeze(self):
                               np.squeeze, s, axis=0)
 
     def test_transpose(self):
-        msg = ("transpose\(\) got multiple values for "
-               "keyword argument 'axes'")
+        msg = (r"transpose\(\) got multiple values for "
+               r"keyword argument 'axes'")
         for s in [tm.makeFloatSeries(), tm.makeStringSeries(),
                   tm.makeObjectSeries()]:
             # calls implementation in pandas/core/base.py
@@ -1831,7 +1831,7 @@ def test_take_invalid_kwargs(self):
             p4d = tm.makePanel4D()
 
         for obj in (s, df, p, p4d):
-            msg = "take\(\) got an unexpected keyword argument 'foo'"
+            msg = r"take\(\) got an unexpected keyword argument 'foo'"
             tm.assertRaisesRegexp(TypeError, msg, obj.take,
                                   indices, foo=2)
 

pandas/tests/test_internals.py

@@ -82,7 +82,7 @@ def create_block(typestr, placement, item_shape=None, num_offset=0):
         values = (mat * 1e9).astype('M8[ns]')
     elif typestr.startswith('M8[ns'):
         # datetime with tz
-        m = re.search('M8\[ns,\s*(\w+\/?\w*)\]', typestr)
+        m = re.search(r'M8\[ns,\s*(\w+\/?\w*)\]', typestr)
         assert m is not None, "incompatible typestr -> {0}".format(typestr)
         tz = m.groups()[0]
         assert num_items == 1, "must have only 1 num items for a tz-aware"

pandas/tests/test_multilevel.py

@@ -554,7 +554,7 @@ def test_xs_level_multiple(self):
 a   q   20      4     0.4473  1.4152  0.2834  1.00661  0.1744
 x   q   30      3    -0.6662 -0.5243 -0.3580  0.89145  2.5838"""
 
-        df = read_table(StringIO(text), sep='\s+', engine='python')
+        df = read_table(StringIO(text), sep=r'\s+', engine='python')
 
         result = df.xs(('a', 4), level=['one', 'four'])
         expected = df.xs('a').xs(4, level='four')
@@ -588,7 +588,7 @@ def test_xs_level0(self):
 a   q   20      4     0.4473  1.4152  0.2834  1.00661  0.1744
 x   q   30      3    -0.6662 -0.5243 -0.3580  0.89145  2.5838"""
 
-        df = read_table(StringIO(text), sep='\s+', engine='python')
+        df = read_table(StringIO(text), sep=r'\s+', engine='python')
 
         result = df.xs('a', level=0)
         expected = df.xs('a')

pandas/tests/test_panel.py

@@ -496,8 +496,8 @@ def test_setitem(self):
         # bad shape
         p = Panel(np.random.randn(4, 3, 2))
         with tm.assertRaisesRegexp(ValueError,
-                                   "shape of value must be \(3, 2\), "
-                                   "shape of given object was \(4, 2\)"):
+                                   r"shape of value must be \(3, 2\), "
+                                   r"shape of given object was \(4, 2\)"):
             p[0] = np.random.randn(4, 2)
 
     def test_setitem_ndarray(self):
@@ -1128,24 +1128,24 @@ def testit():
             Panel(np.random.randn(3, 4, 5), lrange(4), lrange(5), lrange(5))
 
         assertRaisesRegexp(ValueError,
-                           "Shape of passed values is \(3, 4, 5\), "
-                           "indices imply \(4, 5, 5\)",
+                           r"Shape of passed values is \(3, 4, 5\), "
+                           r"indices imply \(4, 5, 5\)",
                            testit)
 
         def testit():
             Panel(np.random.randn(3, 4, 5), lrange(5), lrange(4), lrange(5))
 
         assertRaisesRegexp(ValueError,
-                           "Shape of passed values is \(3, 4, 5\), "
-                           "indices imply \(5, 4, 5\)",
+                           r"Shape of passed values is \(3, 4, 5\), "
+                           r"indices imply \(5, 4, 5\)",
                            testit)
 
         def testit():
             Panel(np.random.randn(3, 4, 5), lrange(5), lrange(5), lrange(4))
 
         assertRaisesRegexp(ValueError,
-                           "Shape of passed values is \(3, 4, 5\), "
-                           "indices imply \(5, 5, 4\)",
+                           r"Shape of passed values is \(3, 4, 5\), "
+                           r"indices imply \(5, 5, 4\)",
                            testit)
 
     def test_conform(self):