BUG/REF: TimedeltaIndex.__new__

pandas/core/arrays/datetimes.py

@@ -221,9 +221,7 @@ def __new__(cls, values, freq=None, tz=None, dtype=None):
 
         result = cls._simple_new(values, freq=freq, tz=tz)
         if freq_infer:
-            inferred = result.inferred_freq
-            if inferred:
-                result.freq = to_offset(inferred)
+            result.freq = to_offset(result.inferred_freq)
 
         # NB: Among other things not yet ported from the DatetimeIndex
         # constructor, this does not call _deepcopy_if_needed

pandas/core/arrays/timedeltas.py

@@ -137,9 +137,7 @@ def __new__(cls, values, freq=None):
 
         result = cls._simple_new(values, freq=freq)
         if freq_infer:
-            inferred = result.inferred_freq
-            if inferred:
-                result.freq = to_offset(inferred)
+            result.freq = to_offset(result.inferred_freq)
 
         return result
 

pandas/core/indexes/datetimes.py

@@ -239,6 +239,21 @@ def __new__(cls, data=None,
                 dayfirst=False, yearfirst=False, dtype=None,
                 copy=False, name=None, verify_integrity=True):
 
+        if data is None:
+            # TODO: Remove this block and associated kwargs; GH#20535
+            result = cls._generate_range(start, end, periods,
+                                         freq=freq, tz=tz, normalize=normalize,
+                                         closed=closed, ambiguous=ambiguous)
+            result.name = name
+            return result
+
+        if is_scalar(data):
+            raise ValueError("{cls}() must be called with a "
+                             "collection of some kind, {data} was passed"
+                             .format(cls=cls.__name__, data=repr(data)))
+
+        # - Cases checked above all return/raise before reaching here - #
+
         # This allows to later ensure that the 'copy' parameter is honored:
         if isinstance(data, Index):
             ref_to_data = data._data
@@ -253,20 +268,8 @@ def __new__(cls, data=None,
         # if dtype has an embedded tz, capture it
         tz = dtl.validate_tz_from_dtype(dtype, tz)
 
-        if data is None:
-            # TODO: Remove this block and associated kwargs; GH#20535
-            result = cls._generate_range(start, end, periods,
-                                         freq=freq, tz=tz, normalize=normalize,
-                                         closed=closed, ambiguous=ambiguous)
-            result.name = name
-            return result
-
         if not isinstance(data, (np.ndarray, Index, ABCSeries,
                                  DatetimeArrayMixin)):
-            if is_scalar(data):
-                raise ValueError('DatetimeIndex() must be called with a '
-                                 'collection of some kind, %s was passed'
-                                 % repr(data))
             # other iterable of some kind
             if not isinstance(data, (list, tuple)):
                 data = list(data)
@@ -328,9 +331,7 @@ def __new__(cls, data=None,
                 cls._validate_frequency(subarr, freq, ambiguous=ambiguous)
 
         if freq_infer:
-            inferred = subarr.inferred_freq
-            if inferred:
-                subarr.freq = to_offset(inferred)
+            subarr.freq = to_offset(subarr.inferred_freq)
 
         return subarr._deepcopy_if_needed(ref_to_data, copy)
 

pandas/core/indexes/timedeltas.py

@@ -8,11 +8,16 @@
     is_float,
     is_list_like,
     is_scalar,
+    is_integer_dtype,
+    is_float_dtype,
+    is_object_dtype,
+    is_string_dtype,
     is_timedelta64_dtype,
     is_timedelta64_ns_dtype,
     pandas_dtype,
     ensure_int64)
 from pandas.core.dtypes.missing import isna
+from pandas.core.dtypes.generic import ABCSeries
 
 from pandas.core.arrays.timedeltas import (
     TimedeltaArrayMixin, _is_convertible_to_td, _to_m8)
@@ -35,7 +40,7 @@
 from pandas.core.tools.timedeltas import (
     to_timedelta, _coerce_scalar_to_timedelta_type)
 from pandas._libs import (lib, index as libindex,
-                          join as libjoin, Timedelta, NaT)
+                          join as libjoin, Timedelta, NaT, iNaT)
 from pandas._libs.tslibs.timedeltas import array_to_timedelta64
 
 
@@ -139,12 +144,6 @@ def __new__(cls, data=None, unit=None, freq=None, start=None, end=None,
                 periods=None, closed=None, dtype=None, copy=False,
                 name=None, verify_integrity=True):
 
-        if isinstance(data, TimedeltaIndex) and freq is None and name is None:
-            if copy:
-                return data.copy()
-            else:
-                return data._shallow_copy()
-
         freq, freq_infer = dtl.maybe_infer_freq(freq)
 
         if data is None:
@@ -154,32 +153,73 @@ def __new__(cls, data=None, unit=None, freq=None, start=None, end=None,
             result.name = name
             return result
 
-        if unit is not None:
-            data = to_timedelta(data, unit=unit, box=False)
-
         if is_scalar(data):
-            raise ValueError('TimedeltaIndex() must be called with a '
+            raise ValueError('{cls}() must be called with a '
                              'collection of some kind, {data} was passed'
-                             .format(data=repr(data)))
+                             .format(cls=cls.__name__, data=repr(data)))
 
-        # convert if not already
-        if getattr(data, 'dtype', None) != _TD_DTYPE:
+        if isinstance(data, TimedeltaIndex) and freq is None and name is None:
+            if copy:
+                return data.copy()
+            else:
+                return data._shallow_copy()
+
+        # - Cases checked above all return/raise before reaching here - #
+
+        if unit is not None:
             data = to_timedelta(data, unit=unit, box=False)
-        elif copy:
-            data = np.array(data, copy=True)
-
-        data = np.array(data, copy=False)
-        if data.dtype == np.object_:
-            data = array_to_timedelta64(data)
-        if data.dtype != _TD_DTYPE:
-            if is_timedelta64_dtype(data):
+
+        # Unwrap whatever we have into a np.ndarray
+        if not hasattr(data, 'dtype'):
+            # e.g. list, tuple
+            if np.ndim(data) == 0:
+                # i.e.g generator
+                data = list(data)
+            data = np.array(data, copy=False)
+        elif isinstance(data, ABCSeries):
+            data = data._values
+        elif isinstance(data, (cls, TimedeltaArrayMixin)):
+            data = data._data
+
+        # Convert whatever we have into timedelta64[ns] dtype
+        if is_object_dtype(data) or is_string_dtype(data):
+            # no need to make a copy, need to convert if string-dtyped
+            data = np.array(data, dtype=np.object_, copy=False)
+            data = array_to_timedelta64(data).view(_TD_DTYPE)
+            copy = False
+        elif is_integer_dtype(data):
+            # treat as nanoseconds
+            # if something other than int64, convert
+            data = ensure_int64(data)
+            if copy:
+                # TODO: can we avoid branching here? `astype(data, copy=False)`
+                #  appears to be making a copy
+                data = data.astype(_TD_DTYPE)
+                copy = False
+            else:
+                data = data.view(_TD_DTYPE)
+        elif is_float_dtype(data):
+            # We allow it if and only if it can be converted lossessly
+            mask = np.isnan(data)
+            casted = data.astype(np.int64)
+            if not (casted[~mask] == data[~mask]).all():
+                raise TypeError("floating-dtype data cannot be losslessly "
+                                "converted to {cls}".format(cls=cls.__name__))
+            data = casted.view(_TD_DTYPE)
+            data[mask] = iNaT
+            copy = False
+        elif is_timedelta64_dtype(data):
+            if data.dtype != _TD_DTYPE:
                 # non-nano unit
                 # TODO: watch out for overflows
                 data = data.astype(_TD_DTYPE)
-            else:
-                data = ensure_int64(data).view(_TD_DTYPE)
+                copy = False
+        else:
+            raise TypeError("dtype {dtype} is invalid for constructing {cls}"
+                            .format(dtype=data.dtype, cls=cls.__name__))
 
-        assert data.dtype == 'm8[ns]', data.dtype
+        data = np.array(data, copy=copy)
+        assert data.dtype == 'm8[ns]', data
 
         subarr = cls._simple_new(data, name=name, freq=freq)
         # check that we are matching freqs
@@ -188,9 +228,7 @@ def __new__(cls, data=None, unit=None, freq=None, start=None, end=None,
                 cls._validate_frequency(subarr, freq)
 
         if freq_infer:
-            inferred = subarr.inferred_freq
-            if inferred:
-                subarr.freq = to_offset(inferred)
+            subarr.freq = to_offset(subarr.inferred_freq)
 
         return subarr
 

pandas/tests/arithmetic/test_timedelta64.py

@@ -1054,11 +1054,11 @@ def test_tdi_mul_float_series(self, box_df_fail):
         idx = tm.box_expected(idx, box)
 
         rng5f = np.arange(5, dtype='float64')
-        expected = TimedeltaIndex(rng5f * (rng5f + 0.1))
+        expected = TimedeltaIndex(rng5f * (rng5f + 1.0))
         box2 = pd.Series if box is pd.Index else box
         expected = tm.box_expected(expected, box2)
 
-        result = idx * Series(rng5f + 0.1)
+        result = idx * Series(rng5f + 1.0)
         tm.assert_equal(result, expected)
 
     # TODO: Put Series/DataFrame in others?

pandas/tests/indexes/timedeltas/test_construction.py

@@ -10,6 +10,30 @@
 
 class TestTimedeltaIndex(object):
 
+    def test_dt64_data_invalid(self):
+        # GH#23539
+        dti = pd.date_range('2016-01-01', periods=3)
+        with pytest.raises(TypeError):
+            TimedeltaIndex(dti)
+
+        with pytest.raises(TypeError):
+            TimedeltaIndex(np.asarray(dti))
+
+    def test_float64_lossy_invalid(self):
+        # GH#23539 passing floats that would be truncated is unsupported
+        with pytest.raises(TypeError):
+            TimedeltaIndex([2.3, 9.0])
+
+        # but non-lossy floats are OK
+        tdi = TimedeltaIndex([2.0, 9.0])
+        expected = TimedeltaIndex([2, 9])
+        tm.assert_index_equal(tdi, expected)
+
+        # NaNs get converted to NaT
+        tdi = TimedeltaIndex([2.0, np.nan])
+        expected = TimedeltaIndex([pd.Timedelta(nanoseconds=2), pd.NaT])
+        tm.assert_index_equal(tdi, expected)
+
     def test_construction_base_constructor(self):
         arr = [pd.Timedelta('1 days'), pd.NaT, pd.Timedelta('3 days')]
         tm.assert_index_equal(pd.Index(arr), pd.TimedeltaIndex(arr))

pandas/tests/indexes/timedeltas/test_ops.py

@@ -54,8 +54,7 @@ def test_minmax(self):
             assert pd.isna(getattr(obj, op)())
 
     def test_numpy_minmax(self):
-        dr = pd.date_range(start='2016-01-15', end='2016-01-20')
-        td = TimedeltaIndex(np.asarray(dr))
+        td = timedelta_range('16815 days', '16820 days', freq='D')
 
         assert np.min(td) == Timedelta('16815 days')
         assert np.max(td) == Timedelta('16820 days')

pandas/tests/scalar/timedelta/test_arithmetic.py

@@ -506,6 +506,9 @@ def test_td_rfloordiv_numeric_series(self):
             # TODO: GH-19761. Change to TypeError.
             ser // td
 
+    # ----------------------------------------------------------------
+    # Timedelta.__mod__, __rmod__
+
     def test_mod_timedeltalike(self):
         # GH#19365
         td = Timedelta(hours=37)
@@ -545,9 +548,6 @@ def test_mod_offset(self):
         assert isinstance(result, Timedelta)
         assert result == Timedelta(hours=2)
 
-    # ----------------------------------------------------------------
-    # Timedelta.__mod__, __rmod__
-
     def test_mod_numeric(self):
         # GH#19365
         td = Timedelta(hours=37)