Amend tests to suppress warnings from deprecation

Author: Chris Bertinato

pandas/tests/indexes/datetimes/test_tools.py

@@ -4,6 +4,7 @@
 from datetime import datetime, time
 from distutils.version import LooseVersion
 import locale
+from warnings import catch_warnings, simplefilter
 
 import dateutil
 from dateutil.parser import parse
@@ -221,12 +222,15 @@ def test_to_datetime_format_weeks(self, cache):
     def test_to_datetime_parse_tzname_or_tzoffset(self, box, const,
                                                   fmt, dates, expected_dates):
         # GH 13486
-        result = pd.to_datetime(dates, format=fmt, box=box)
-        expected = const(expected_dates)
-        tm.assert_equal(result, expected)
+        with catch_warnings():
+            simplefilter("ignore", FutureWarning)
 
-        with pytest.raises(ValueError):
-            pd.to_datetime(dates, format=fmt, box=box, utc=True)
+            result = pd.to_datetime(dates, format=fmt, box=box)
+            expected = const(expected_dates)
+            tm.assert_equal(result, expected)
+
+            with pytest.raises(ValueError):
+                pd.to_datetime(dates, format=fmt, box=box, utc=True)
 
     @pytest.mark.parametrize('offset', [
         '+0', '-1foo', 'UTCbar', ':10', '+01:000:01', ''])
@@ -256,8 +260,11 @@ def test_to_datetime_dtarr(self, tz):
         result = to_datetime(arr)
         assert result is arr
 
-        result = to_datetime(arr, box=True)
-        assert result is arr
+        with catch_warnings():
+            simplefilter("ignore", FutureWarning)
+
+            result = to_datetime(arr, box=True)
+            assert result is arr
 
     def test_to_datetime_pydatetime(self):
         actual = pd.to_datetime(datetime(2008, 1, 15))
@@ -357,43 +364,46 @@ def test_to_datetime_dt64s(self, cache):
     def test_to_datetime_array_of_dt64s(self, cache):
         dts = [np.datetime64('2000-01-01'), np.datetime64('2000-01-02'), ]
 
-        # Assuming all datetimes are in bounds, to_datetime() returns
-        # an array that is equal to Timestamp() parsing
-        tm.assert_numpy_array_equal(
-            pd.to_datetime(dts, box=False, cache=cache),
-            np.array([Timestamp(x).asm8 for x in dts])
-        )
-
-        # A list of datetimes where the last one is out of bounds
-        dts_with_oob = dts + [np.datetime64('9999-01-01')]
+        with catch_warnings():
+            simplefilter("ignore", FutureWarning)
 
-        pytest.raises(ValueError, pd.to_datetime, dts_with_oob,
-                      errors='raise')
+            # Assuming all datetimes are in bounds, to_datetime() returns
+            # an array that is equal to Timestamp() parsing
+            tm.assert_numpy_array_equal(
+                pd.to_datetime(dts, box=False, cache=cache),
+                np.array([Timestamp(x).asm8 for x in dts])
+            )
 
-        tm.assert_numpy_array_equal(
-            pd.to_datetime(dts_with_oob, box=False, errors='coerce',
-                           cache=cache),
-            np.array(
-                [
-                    Timestamp(dts_with_oob[0]).asm8,
-                    Timestamp(dts_with_oob[1]).asm8,
-                    tslib.iNaT,
-                ],
-                dtype='M8'
+            # A list of datetimes where the last one is out of bounds
+            dts_with_oob = dts + [np.datetime64('9999-01-01')]
+
+            pytest.raises(ValueError, pd.to_datetime, dts_with_oob,
+                          errors='raise')
+
+            tm.assert_numpy_array_equal(
+                pd.to_datetime(dts_with_oob, box=False, errors='coerce',
+                               cache=cache),
+                np.array(
+                    [
+                        Timestamp(dts_with_oob[0]).asm8,
+                        Timestamp(dts_with_oob[1]).asm8,
+                        tslib.iNaT,
+                    ],
+                    dtype='M8'
+                )
             )
-        )
-
-        # With errors='ignore', out of bounds datetime64s
-        # are converted to their .item(), which depending on the version of
-        # numpy is either a python datetime.datetime or datetime.date
-        tm.assert_numpy_array_equal(
-            pd.to_datetime(dts_with_oob, box=False, errors='ignore',
-                           cache=cache),
-            np.array(
-                [dt.item() for dt in dts_with_oob],
-                dtype='O'
+
+            # With errors='ignore', out of bounds datetime64s
+            # are converted to their .item(), which depending on the version of
+            # numpy is either a python datetime.datetime or datetime.date
+            tm.assert_numpy_array_equal(
+                pd.to_datetime(dts_with_oob, box=False, errors='ignore',
+                               cache=cache),
+                np.array(
+                    [dt.item() for dt in dts_with_oob],
+                    dtype='O'
+                )
             )
-        )
 
     @pytest.mark.parametrize('cache', [True, False])
     def test_to_datetime_tz(self, cache):
@@ -563,10 +573,14 @@ def test_to_datetime_cache(self, utc, format, box, constructor):
         date = '20130101 00:00:00'
         test_dates = [date] * 10**5
         data = constructor(test_dates)
-        result = pd.to_datetime(data, utc=utc, format=format, box=box,
-                                cache=True)
-        expected = pd.to_datetime(data, utc=utc, format=format, box=box,
-                                  cache=False)
+
+        with catch_warnings():
+            simplefilter("ignore", FutureWarning)
+
+            result = pd.to_datetime(data, utc=utc, format=format, box=box,
+                                    cache=True)
+            expected = pd.to_datetime(data, utc=utc, format=format, box=box,
+                                      cache=False)
         if box:
             tm.assert_index_equal(result, expected)
         else:
@@ -619,7 +633,11 @@ def test_iso_8601_strings_with_same_offset(self):
     def test_iso_8601_strings_same_offset_no_box(self):
         # GH 22446
         data = ['2018-01-04 09:01:00+09:00', '2018-01-04 09:02:00+09:00']
-        result = pd.to_datetime(data, box=False)
+
+        with catch_warnings():
+            simplefilter("ignore", FutureWarning)
+            result = pd.to_datetime(data, box=False)
+
         expected = np.array([
             datetime(2018, 1, 4, 9, 1, tzinfo=pytz.FixedOffset(540)),
             datetime(2018, 1, 4, 9, 2, tzinfo=pytz.FixedOffset(540))
@@ -813,7 +831,7 @@ def test_unit_rounding(self, cache):
     def test_unit_ignore_keeps_name(self, cache):
         # GH 21697
         expected = pd.Index([15e9] * 2, name='name')
-        result = pd.to_datetime(expected, errors='ignore', box=True, unit='s',
+        result = pd.to_datetime(expected, errors='ignore', unit='s',
                                 cache=cache)
         tm.assert_index_equal(result, expected)
 
@@ -974,7 +992,11 @@ def test_dataframe_box_false(self):
         df = pd.DataFrame({'year': [2015, 2016],
                            'month': [2, 3],
                            'day': [4, 5]})
-        result = pd.to_datetime(df, box=False)
+
+        with catch_warnings():
+            simplefilter("ignore", FutureWarning)
+            result = pd.to_datetime(df, box=False)
+
         expected = np.array(['2015-02-04', '2016-03-05'],
                             dtype='datetime64[ns]')
         tm.assert_numpy_array_equal(result, expected)
@@ -991,8 +1013,7 @@ def test_dataframe_utc_true(self):
 
     def test_to_datetime_errors_ignore_utc_true(self):
         # GH 23758
-        result = pd.to_datetime([1], unit='s', box=True, utc=True,
-                                errors='ignore')
+        result = pd.to_datetime([1], unit='s', utc=True, errors='ignore')
         expected = DatetimeIndex(['1970-01-01 00:00:01'], tz='UTC')
         tm.assert_index_equal(result, expected)
 
@@ -1118,11 +1139,15 @@ def test_to_datetime_types(self, cache):
     def test_to_datetime_unprocessable_input(self, cache, box, klass):
         # GH 4928
         # GH 21864
-        result = to_datetime([1, '1'], errors='ignore', cache=cache, box=box)
-        expected = klass(np.array([1, '1'], dtype='O'))
-        tm.assert_equal(result, expected)
-        pytest.raises(TypeError, to_datetime, [1, '1'], errors='raise',
-                      cache=cache, box=box)
+        with catch_warnings():
+            simplefilter("ignore", FutureWarning)
+            result = to_datetime([1, '1'], errors='ignore', cache=cache,
+                                 box=box)
+
+            expected = klass(np.array([1, '1'], dtype='O'))
+            tm.assert_equal(result, expected)
+            pytest.raises(TypeError, to_datetime, [1, '1'], errors='raise',
+                          cache=cache, box=box)
 
     def test_to_datetime_other_datetime64_units(self):
         # 5/25/2012

pandas/tests/indexes/timedeltas/test_tools.py

@@ -1,4 +1,5 @@
 from datetime import time, timedelta
+from warnings import catch_warnings, simplefilter
 
 import numpy as np
 import pytest
@@ -18,15 +19,18 @@ def conv(v):
 
         d1 = np.timedelta64(1, 'D')
 
-        assert (to_timedelta('1 days 06:05:01.00003', box=False) ==
-                conv(d1 + np.timedelta64(6 * 3600 + 5 * 60 + 1, 's') +
-                     np.timedelta64(30, 'us')))
-        assert (to_timedelta('15.5us', box=False) ==
-                conv(np.timedelta64(15500, 'ns')))
+        with catch_warnings():
+            simplefilter("ignore", FutureWarning)
 
-        # empty string
-        result = to_timedelta('', box=False)
-        assert result.astype('int64') == iNaT
+            assert (to_timedelta('1 days 06:05:01.00003', box=False) ==
+                    conv(d1 + np.timedelta64(6 * 3600 + 5 * 60 + 1, 's') +
+                         np.timedelta64(30, 'us')))
+            assert (to_timedelta('15.5us', box=False) ==
+                    conv(np.timedelta64(15500, 'ns')))
+
+            # empty string
+            result = to_timedelta('', box=False)
+            assert result.astype('int64') == iNaT
 
         result = to_timedelta(['', ''])
         assert isna(result).all()
@@ -36,10 +40,13 @@ def conv(v):
         expected = pd.Index(np.array([np.timedelta64(1, 's')]))
         tm.assert_index_equal(result, expected)
 
-        # ints
-        result = np.timedelta64(0, 'ns')
-        expected = to_timedelta(0, box=False)
-        assert result == expected
+        with catch_warnings():
+            simplefilter("ignore", FutureWarning)
+
+            # ints
+            result = np.timedelta64(0, 'ns')
+            expected = to_timedelta(0, box=False)
+            assert result == expected
 
         # Series
         expected = Series([timedelta(days=1), timedelta(days=1, seconds=1)])
@@ -52,16 +59,19 @@ def conv(v):
         expected = to_timedelta([0, 10], unit='s')
         tm.assert_index_equal(result, expected)
 
-        # single element conversion
-        v = timedelta(seconds=1)
-        result = to_timedelta(v, box=False)
-        expected = np.timedelta64(timedelta(seconds=1))
-        assert result == expected
+        with catch_warnings():
+            simplefilter("ignore", FutureWarning)
 
-        v = np.timedelta64(timedelta(seconds=1))
-        result = to_timedelta(v, box=False)
-        expected = np.timedelta64(timedelta(seconds=1))
-        assert result == expected
+            # single element conversion
+            v = timedelta(seconds=1)
+            result = to_timedelta(v, box=False)
+            expected = np.timedelta64(timedelta(seconds=1))
+            assert result == expected
+
+            v = np.timedelta64(timedelta(seconds=1))
+            result = to_timedelta(v, box=False)
+            expected = np.timedelta64(timedelta(seconds=1))
+            assert result == expected
 
         # arrays of various dtypes
         arr = np.array([1] * 5, dtype='int64')
@@ -89,22 +99,25 @@ def conv(v):
         expected = TimedeltaIndex([np.timedelta64(1, 'D')] * 5)
         tm.assert_index_equal(result, expected)
 
-        # Test with lists as input when box=false
-        expected = np.array(np.arange(3) * 1000000000, dtype='timedelta64[ns]')
-        result = to_timedelta(range(3), unit='s', box=False)
-        tm.assert_numpy_array_equal(expected, result)
+        with catch_warnings():
+            simplefilter("ignore", FutureWarning)
+
+            # Test with lists as input when box=false
+            expected = np.array(np.arange(3) * 1000000000, dtype='timedelta64[ns]')
+            result = to_timedelta(range(3), unit='s', box=False)
+            tm.assert_numpy_array_equal(expected, result)
 
-        result = to_timedelta(np.arange(3), unit='s', box=False)
-        tm.assert_numpy_array_equal(expected, result)
+            result = to_timedelta(np.arange(3), unit='s', box=False)
+            tm.assert_numpy_array_equal(expected, result)
 
-        result = to_timedelta([0, 1, 2], unit='s', box=False)
-        tm.assert_numpy_array_equal(expected, result)
+            result = to_timedelta([0, 1, 2], unit='s', box=False)
+            tm.assert_numpy_array_equal(expected, result)
 
-        # Tests with fractional seconds as input:
-        expected = np.array(
-            [0, 500000000, 800000000, 1200000000], dtype='timedelta64[ns]')
-        result = to_timedelta([0., 0.5, 0.8, 1.2], unit='s', box=False)
-        tm.assert_numpy_array_equal(expected, result)
+            # Tests with fractional seconds as input:
+            expected = np.array(
+                [0, 500000000, 800000000, 1200000000], dtype='timedelta64[ns]')
+            result = to_timedelta([0., 0.5, 0.8, 1.2], unit='s', box=False)
+            tm.assert_numpy_array_equal(expected, result)
 
     def test_to_timedelta_invalid(self):
 

pandas/tests/scalar/timedelta/test_timedelta.py

@@ -1,5 +1,6 @@
 """ test the scalar Timedelta """
 from datetime import timedelta
+from warnings import catch_warnings, simplefilter
 
 import numpy as np
 import pytest
@@ -289,8 +290,11 @@ def test_iso_conversion(self):
         assert to_timedelta('P0DT0H0M1S') == expected
 
     def test_nat_converters(self):
-        assert to_timedelta('nat', box=False).astype('int64') == iNaT
-        assert to_timedelta('nan', box=False).astype('int64') == iNaT
+        with catch_warnings():
+            simplefilter("ignore", FutureWarning)
+
+            assert to_timedelta('nat', box=False).astype('int64') == iNaT
+            assert to_timedelta('nan', box=False).astype('int64') == iNaT
 
     @pytest.mark.parametrize('units, np_unit',
                              [(['Y', 'y'], 'Y'),