REF/DEPR: DatetimeIndex constructor

doc/source/whatsnew/v0.24.0.rst

@@ -985,6 +985,7 @@ Deprecations
   `use_threads` to reflect the changes in pyarrow 0.11.0. (:issue:`23053`)
 - :func:`pandas.read_excel` has deprecated accepting ``usecols`` as an integer. Please pass in a list of ints from 0 to ``usecols`` inclusive instead (:issue:`23527`)
 - Constructing a :class:`TimedeltaIndex` from data with ``datetime64``-dtyped data is deprecated, will raise ``TypeError`` in a future version (:issue:`23539`)
+- Constructing a :class:`DatetimeIndex` from data with ``timedelta64``-dtyped data is deprecated, will raise ``TypeError`` in a future version (:issue:`23675`)
 
 .. _whatsnew_0240.deprecations.datetimelike_int_ops:
 

pandas/_libs/tslibs/conversion.pyx

@@ -858,8 +858,8 @@ def tz_localize_to_utc(ndarray[int64_t] vals, object tz, object ambiguous=None,
         - bool if True, treat all vals as DST. If False, treat them as non-DST
         - 'NaT' will return NaT where there are ambiguous times
 
-    nonexistent : str
-        If arraylike, must have the same length as vals
+    nonexistent : {None, "NaT", "shift", "raise"}
+        How to handle non-existent times when converting wall times to UTC
 
         .. versionadded:: 0.24.0
 

pandas/core/arrays/datetimes.py

@@ -186,7 +186,7 @@ class DatetimeArrayMixin(dtl.DatetimeLikeArrayMixin):
     _freq = None
 
     @classmethod
-    def _simple_new(cls, values, freq=None, tz=None, **kwargs):
+    def _simple_new(cls, values, freq=None, tz=None):
         """
         we require the we have a dtype compat for the values
         if we are passed a non-dtype compat, then coerce using the constructor

pandas/core/indexes/datetimes.py

@@ -16,10 +16,11 @@
 from pandas.util._decorators import Appender, Substitution, cache_readonly
 
 from pandas.core.dtypes.common import (
-    _INT64_DTYPE, _NS_DTYPE, ensure_int64, is_datetime64_dtype,
-    is_datetime64_ns_dtype, is_datetimetz, is_dtype_equal, is_float,
-    is_integer, is_integer_dtype, is_list_like, is_period_dtype, is_scalar,
-    is_string_like, pandas_dtype)
+    _INT64_DTYPE, _NS_DTYPE, ensure_int64, is_datetime64_ns_dtype,
+    is_datetime64tz_dtype, is_dtype_equal, is_extension_type, is_float,
+    is_float_dtype, is_integer, is_list_like, is_object_dtype, is_period_dtype,
+    is_scalar, is_string_dtype, is_string_like, is_timedelta64_dtype,
+    pandas_dtype)
 import pandas.core.dtypes.concat as _concat
 from pandas.core.dtypes.generic import ABCSeries
 from pandas.core.dtypes.missing import isna
@@ -252,19 +253,54 @@ def __new__(cls, data=None,
         # if dtype has an embedded tz, capture it
         tz = dtl.validate_tz_from_dtype(dtype, tz)
 
-        if not isinstance(data, (np.ndarray, Index, ABCSeries, DatetimeArray)):
-            # other iterable of some kind
-            if not isinstance(data, (list, tuple)):
+        if not hasattr(data, "dtype"):
+            # e.g. list, tuple
+            if np.ndim(data) == 0:
+                # i.e. generator
                 data = list(data)
-            data = np.asarray(data, dtype='O')
+            data = np.asarray(data)
+            copy = False
         elif isinstance(data, ABCSeries):
             data = data._values
 
-        # data must be Index or np.ndarray here
-        if not (is_datetime64_dtype(data) or is_datetimetz(data) or
-                is_integer_dtype(data) or lib.infer_dtype(data) == 'integer'):
-            data = tools.to_datetime(data, dayfirst=dayfirst,
-                                     yearfirst=yearfirst)
+        # By this point we are assured to have either a numpy array or Index
+
+        if is_float_dtype(data):
+            # Note: we must cast to datetime64[ns] here in order to treat these
+            #  as wall-times instead of UTC timestamps.
+            data = data.astype(_NS_DTYPE)
+            copy = False
+            # TODO: Why do we treat this differently from integer dtypes?
+
+        elif is_timedelta64_dtype(data):
+            warnings.warn("Passing timedelta64-dtype data to {cls} is "
+                          "deprecated, will raise a TypeError in a future "
+                          "version".format(cls=cls.__name__),
+                          FutureWarning, stacklevel=2)
+            data = data.view(_NS_DTYPE)
+
+        elif is_period_dtype(data):
+            # Note: without explicitly raising here, PeriondIndex
+            #  test_setops.test_join_does_not_recur fails
+            raise TypeError("Passing PeriodDtype data to {cls} is invalid.  "
+                            "Use `data.to_timestamp()` instead"
+                            .format(cls=cls.__name__))
+
+        elif is_extension_type(data) and not is_datetime64tz_dtype(data):
+            # Includes categorical
+            # TODO: We have no tests for these
+            data = np.array(data, dtype=np.object_)
+            copy = False
+
+        if is_object_dtype(data) or is_string_dtype(data):
+            # TODO: We do not have tests specific to string-dtypes,
+            #  also complex or categorical or other extension
+            copy = False
+            if lib.infer_dtype(data) == 'integer':
+                data = data.astype(np.int64)
+            else:
+                data = tools.to_datetime(data, dayfirst=dayfirst,
+                                         yearfirst=yearfirst)
 
         if isinstance(data, DatetimeArray):
             if tz is None:
@@ -281,6 +317,7 @@ def __new__(cls, data=None,
             subarr = data._data
 
             if freq is None:
+                # TODO: Should this be the stronger condition of `freq_infer`?
                 freq = data.freq
                 verify_integrity = False
         elif issubclass(data.dtype.type, np.datetime64):
@@ -319,17 +356,15 @@ def __new__(cls, data=None,
         return subarr._deepcopy_if_needed(ref_to_data, copy)
 
     @classmethod
-    def _simple_new(cls, values, name=None, freq=None, tz=None,
-                    dtype=None, **kwargs):
+    def _simple_new(cls, values, name=None, freq=None, tz=None, dtype=None):
         """
         we require the we have a dtype compat for the values
         if we are passed a non-dtype compat, then coerce using the constructor
         """
         # DatetimeArray._simple_new will accept either i8 or M8[ns] dtypes
         assert isinstance(values, np.ndarray), type(values)
 
-        result = super(DatetimeIndex, cls)._simple_new(values, freq, tz,
-                                                       **kwargs)
+        result = super(DatetimeIndex, cls)._simple_new(values, freq, tz)
         result.name = name
         result._reset_identity()
         return result

pandas/tests/indexes/datetimes/test_construction.py

@@ -18,6 +18,19 @@
 
 class TestDatetimeIndex(object):
 
+    def test_dti_with_timedelta64_data_deprecation(self):
+        # GH#23675
+        data = np.array([0], dtype='m8[ns]')
+        with tm.assert_produces_warning(FutureWarning):
+            result = DatetimeIndex(data)
+
+        assert result[0] == Timestamp('1970-01-01')
+
+        with tm.assert_produces_warning(FutureWarning):
+            result = DatetimeIndex(pd.TimedeltaIndex(data))
+
+        assert result[0] == Timestamp('1970-01-01')
+
     def test_construction_caching(self):
 
         df = pd.DataFrame({'dt': pd.date_range('20130101', periods=3),

pandas/tests/scalar/timedelta/test_timedelta.py

@@ -548,7 +548,7 @@ def test_overflow(self):
 
         # mean
         result = (s - s.min()).mean()
-        expected = pd.Timedelta((pd.DatetimeIndex((s - s.min())).asi8 / len(s)
+        expected = pd.Timedelta((pd.TimedeltaIndex((s - s.min())).asi8 / len(s)
                                  ).sum())
 
         # the computation is converted to float so