more tests

Author: TomAugspurger

pandas/core/arrays/datetimes.py

@@ -33,6 +33,20 @@
 from pandas.tseries.offsets import Day, Tick
 
 _midnight = time(0, 0)
+_i8_message = (
+    "Passing integer-dtype data and a timezone to DatetimeIndex.\n"
+    "Integer values will be interpreted differently in a future version \n"
+    "of pandas. Previously, these were viewed as datetime64[ns] values, \n"
+    "representing the wall time *in the specified timezone*. \n"
+    "In the future, these will be viewed as datetime64[ns] values \n"
+    "representing the wall time *in UTC*. This is similar to a \n"
+    "nanosecond-precision UNIX epoch.\n\n"
+    "To accept the future behavior, use\n\n"
+    "\tpd.to_datetime(integer_data, utc=True).tz_convert(tz) "
+    "\n\n"
+    "To keep the previous behavior, use \n\n"
+    "\tpd.to_datetime(integer_data).tz_localize(tz)"
+)
 
 
 def tz_to_dtype(tz):
@@ -1707,6 +1721,9 @@ 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)
+            # When a sequence of timestamp objects is passed, we always
+            # want to treat the (now i8-valued) data as UTC timestamps,
+            # not wall times.
             int_as_wall_time = False
 
     # `data` may have originally been a Categorical[datetime64[ns, tz]],
@@ -1738,8 +1755,8 @@ def sequence_to_dt64ns(data, dtype=None, copy=False,
         if data.dtype != _INT64_DTYPE:
             data = data.astype(np.int64, copy=False)
         if int_as_wall_time and tz is not None:
-            warnings.warn("test", FutureWarning)
             tz = timezones.maybe_get_tz(tz)
+            warnings.warn(_i8_message, FutureWarning, stacklevel=4)
             data = conversion.tz_localize_to_utc(data.view('i8'), tz,
                                                  ambiguous=ambiguous)
             data = data.view(_NS_DTYPE)

pandas/tests/dtypes/test_common.py

@@ -209,8 +209,8 @@ def test_is_datetime64tz_dtype():
     assert not com.is_datetime64tz_dtype(object)
     assert not com.is_datetime64tz_dtype([1, 2, 3])
     assert not com.is_datetime64tz_dtype(pd.DatetimeIndex([1, 2, 3]))
-    assert com.is_datetime64tz_dtype(pd.DatetimeIndex(
-        [1, 2, 3], tz="US/Eastern"))
+    assert com.is_datetime64tz_dtype(pd.DatetimeIndex(['2000'],
+                                                      tz="US/Eastern"))
 
 
 def test_is_timedelta64_dtype():
@@ -286,7 +286,7 @@ def test_is_datetimelike():
     assert com.is_datetimelike(pd.PeriodIndex([], freq="A"))
     assert com.is_datetimelike(np.array([], dtype=np.datetime64))
     assert com.is_datetimelike(pd.Series([], dtype="timedelta64[ns]"))
-    assert com.is_datetimelike(pd.DatetimeIndex([1, 2, 3], tz="US/Eastern"))
+    assert com.is_datetimelike(pd.DatetimeIndex(["2000"], tz="US/Eastern"))
 
     dtype = DatetimeTZDtype("ns", tz="US/Eastern")
     s = pd.Series([], dtype=dtype)
@@ -480,7 +480,7 @@ def test_needs_i8_conversion():
     assert com.needs_i8_conversion(np.datetime64)
     assert com.needs_i8_conversion(pd.Series([], dtype="timedelta64[ns]"))
     assert com.needs_i8_conversion(pd.DatetimeIndex(
-        [1, 2, 3], tz="US/Eastern"))
+        ["2000"], tz="US/Eastern"))
 
 
 def test_is_numeric_dtype():
@@ -541,7 +541,7 @@ def test_is_extension_type(check_scipy):
     assert com.is_extension_type(pd.Series(cat))
     assert com.is_extension_type(pd.SparseArray([1, 2, 3]))
     assert com.is_extension_type(pd.SparseSeries([1, 2, 3]))
-    assert com.is_extension_type(pd.DatetimeIndex([1, 2, 3], tz="US/Eastern"))
+    assert com.is_extension_type(pd.DatetimeIndex(['2000'], tz="US/Eastern"))
 
     dtype = DatetimeTZDtype("ns", tz="US/Eastern")
     s = pd.Series([], dtype=dtype)
@@ -635,8 +635,8 @@ def test__get_dtype_fails(input_param):
     (pd.DatetimeIndex([1, 2]), np.datetime64),
     (pd.DatetimeIndex([1, 2]).dtype, np.datetime64),
     ('<M8[ns]', np.datetime64),
-    (pd.DatetimeIndex([1, 2], tz='Europe/London'), pd.Timestamp),
-    (pd.DatetimeIndex([1, 2], tz='Europe/London').dtype,
+    (pd.DatetimeIndex(['2000'], tz='Europe/London'), pd.Timestamp),
+    (pd.DatetimeIndex(['2000'], tz='Europe/London').dtype,
      pd.Timestamp),
     ('datetime64[ns, Europe/London]', pd.Timestamp),
     (pd.SparseSeries([1, 2], dtype='int32'), np.int32),

pandas/tests/indexes/datetimes/test_astype.py

@@ -246,12 +246,12 @@ def test_integer_index_astype_datetime(self, tz, dtype):
         else:
             ex_warn = None
 
-        with tm.assert_produces_warning(ex_warn, check_stacklevel=False):
+        with tm.assert_produces_warning(ex_warn):
             # 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):
+        with tm.assert_produces_warning(ex_warn):
             expected = pd.DatetimeIndex(val, tz=tz)
         tm.assert_index_equal(result, expected)
 

pandas/tests/indexes/datetimes/test_construction.py

@@ -380,6 +380,13 @@ def test_range_kwargs_deprecated(self):
         with tm.assert_produces_warning(FutureWarning):
             DatetimeIndex(start='1/1/2000', end='1/10/2000', freq='D')
 
+    def test_integer_values_and_tz_deprecated(self):
+        values = np.array([946684800000000000])
+        with tm.assert_produces_warning(FutureWarning):
+            result = DatetimeIndex(values, tz='US/Central')
+        expected = pd.DatetimeIndex(['2000-01-01T00:00:00'], tz="US/Central")
+        tm.assert_index_equal(result, expected)
+
     def test_constructor_coverage(self):
         rng = date_range('1/1/2000', periods=10.5)
         exp = date_range('1/1/2000', periods=10)