Updates

Author: TomAugspurger

pandas/core/arrays/datetimes.py

@@ -1707,6 +1707,7 @@ def sequence_to_dt64ns(data, dtype=None, copy=False,
             data, inferred_tz = objects_to_datetime64ns(
                 data, dayfirst=dayfirst, yearfirst=yearfirst)
             tz = maybe_infer_tz(tz, inferred_tz)
+            int_as_wall_time = False
 
     # `data` may have originally been a Categorical[datetime64[ns, tz]],
     # so we need to handle these types.

pandas/tests/indexes/datetimes/test_astype.py

@@ -240,8 +240,19 @@ def _check_rng(rng):
     def test_integer_index_astype_datetime(self, tz, dtype):
         # GH 20997, 20964
         val = [pd.Timestamp('2018-01-01', tz=tz).value]
-        result = pd.Index(val).astype(dtype)
-        expected = pd.DatetimeIndex(['2018-01-01'], tz=tz)
+
+        if tz:
+            ex_warn = FutureWarning
+        else:
+            ex_warn = None
+
+        with tm.assert_produces_warning(ex_warn, check_stacklevel=False):
+            # XXX: This likely shouldn't warn.
+            # This raised on 0.24.x, so we can probably do the right thing
+            # now.
+            result = pd.Index(val).astype(dtype)
+        with tm.assert_produces_warning(ex_warn, check_stacklevel=False):
+            expected = pd.DatetimeIndex(val, tz=tz)
         tm.assert_index_equal(result, expected)
 
 

pandas/tests/indexes/datetimes/test_construction.py

@@ -118,12 +118,15 @@ def test_construction_with_alt_tz_localize(self, kwargs, tz_aware_fixture):
         tz = tz_aware_fixture
         i = pd.date_range('20130101', periods=5, freq='H', tz=tz)
         kwargs = {key: attrgetter(val)(i) for key, val in kwargs.items()}
-        result = DatetimeIndex(i.tz_localize(None).asi8, **kwargs)
-        expected = i.tz_localize(None).tz_localize('UTC').tz_convert(tz)
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            result = DatetimeIndex(i.tz_localize(None).asi8, **kwargs)
+        expected = DatetimeIndex(i, **kwargs)
+        # expected = i.tz_localize(None).tz_localize('UTC').tz_convert(tz)
         tm.assert_index_equal(result, expected)
 
         # localize into the provided tz
-        i2 = DatetimeIndex(i.tz_localize(None).asi8, tz='UTC')
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            i2 = DatetimeIndex(i.tz_localize(None).asi8, tz='UTC')
         expected = i.tz_localize(None).tz_localize('UTC')
         tm.assert_index_equal(i2, expected)
 
@@ -559,15 +562,20 @@ def test_constructor_timestamp_near_dst(self):
     @pytest.mark.parametrize('box', [
         np.array, partial(np.array, dtype=object), list])
     @pytest.mark.parametrize('tz, dtype', [
-        ['US/Pacific', 'datetime64[ns, US/Pacific]'],
-        [None, 'datetime64[ns]']])
+        pytest.param('US/Pacific', 'datetime64[ns, US/Pacific]',
+                     marks=[pytest.mark.xfail(),
+                            pytest.mark.filterwarnings("ignore")]),
+        [None, 'datetime64[ns]'],
+    ])
     def test_constructor_with_int_tz(self, klass, box, tz, dtype):
         # GH 20997, 20964
         ts = Timestamp('2018-01-01', tz=tz)
         result = klass(box([ts.value]), dtype=dtype)
         expected = klass([ts])
         assert result == expected
 
+    @pytest.mark.xfail(reason="TBD", strict=False)  # non-strict for tz-naive
+    @pytest.mark.filterwarnings("ignore::FutureWarning")
     def test_construction_int_rountrip(self, tz_naive_fixture):
         # GH 12619
         tz = tz_naive_fixture

pandas/tests/indexes/multi/test_integrity.py

@@ -50,7 +50,8 @@ def test_values_multiindex_datetimeindex():
     # Test to ensure we hit the boxing / nobox part of MI.values
     ints = np.arange(10 ** 18, 10 ** 18 + 5)
     naive = pd.DatetimeIndex(ints)
-    aware = pd.DatetimeIndex(ints, tz='US/Central')
+    with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+        aware = pd.DatetimeIndex(ints, tz='US/Central')
 
     idx = pd.MultiIndex.from_arrays([naive, aware])
     result = idx.values

pandas/tests/indexes/test_base.py

@@ -398,27 +398,34 @@ def test_constructor_dtypes_to_timedelta(self, cast_index, vals):
     @pytest.mark.parametrize("klass", [pd.Index, pd.DatetimeIndex])
     def test_constructor_dtypes_datetime(self, tz_naive_fixture, attr, utc,
                                          klass):
+        # TODO: update comment
         # Test constructing with a datetimetz dtype
         # .values produces numpy datetimes, so these are considered naive
         # .asi8 produces integers, so these are considered epoch timestamps
         index = pd.date_range('2011-01-01', periods=5)
         arg = getattr(index, attr)
-        if utc:
-            index = index.tz_localize('UTC').tz_convert(tz_naive_fixture)
-        else:
-            index = index.tz_localize(tz_naive_fixture)
+        index = index.tz_localize(tz_naive_fixture)
         dtype = index.dtype
 
-        result = klass(arg, tz=tz_naive_fixture)
+        if tz_naive_fixture and attr == "asi8":
+            ex_warn = FutureWarning
+        else:
+            ex_warn = None
+
+        with tm.assert_produces_warning(ex_warn, check_stacklevel=False):
+            result = klass(arg, tz=tz_naive_fixture)
         tm.assert_index_equal(result, index)
 
-        result = klass(arg, dtype=dtype)
+        with tm.assert_produces_warning(ex_warn, check_stacklevel=False):
+            result = klass(arg, dtype=dtype)
         tm.assert_index_equal(result, index)
 
-        result = klass(list(arg), tz=tz_naive_fixture)
+        with tm.assert_produces_warning(ex_warn, check_stacklevel=False):
+            result = klass(list(arg), tz=tz_naive_fixture)
         tm.assert_index_equal(result, index)
 
-        result = klass(list(arg), dtype=dtype)
+        with tm.assert_produces_warning(ex_warn, check_stacklevel=False):
+            result = klass(list(arg), dtype=dtype)
         tm.assert_index_equal(result, index)
 
     @pytest.mark.parametrize("attr", ['values', 'asi8'])