demo + utils venv

utils/venv/lib/python3.6/site-packages/pandas/tests/indexes/timedeltas/test_arithmetic.py

@@ -0,0 +1,265 @@
+# -*- coding: utf-8 -*-
+
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+from pandas.errors import NullFrequencyError
+
+import pandas as pd
+from pandas import Timedelta, TimedeltaIndex, timedelta_range
+import pandas.util.testing as tm
+
+
+@pytest.fixture(params=[pd.offsets.Hour(2), timedelta(hours=2),
+                        np.timedelta64(2, 'h'), Timedelta(hours=2)],
+                ids=str)
+def delta(request):
+    # Several ways of representing two hours
+    return request.param
+
+
+@pytest.fixture(params=['B', 'D'])
+def freq(request):
+    return request.param
+
+
+class TestTimedeltaIndexArithmetic(object):
+    # Addition and Subtraction Operations
+
+    # -------------------------------------------------------------
+    # TimedeltaIndex.shift is used by __add__/__sub__
+
+    def test_tdi_shift_empty(self):
+        # GH#9903
+        idx = pd.TimedeltaIndex([], name='xxx')
+        tm.assert_index_equal(idx.shift(0, freq='H'), idx)
+        tm.assert_index_equal(idx.shift(3, freq='H'), idx)
+
+    def test_tdi_shift_hours(self):
+        # GH#9903
+        idx = pd.TimedeltaIndex(['5 hours', '6 hours', '9 hours'], name='xxx')
+        tm.assert_index_equal(idx.shift(0, freq='H'), idx)
+        exp = pd.TimedeltaIndex(['8 hours', '9 hours', '12 hours'], name='xxx')
+        tm.assert_index_equal(idx.shift(3, freq='H'), exp)
+        exp = pd.TimedeltaIndex(['2 hours', '3 hours', '6 hours'], name='xxx')
+        tm.assert_index_equal(idx.shift(-3, freq='H'), exp)
+
+    def test_tdi_shift_minutes(self):
+        # GH#9903
+        idx = pd.TimedeltaIndex(['5 hours', '6 hours', '9 hours'], name='xxx')
+        tm.assert_index_equal(idx.shift(0, freq='T'), idx)
+        exp = pd.TimedeltaIndex(['05:03:00', '06:03:00', '9:03:00'],
+                                name='xxx')
+        tm.assert_index_equal(idx.shift(3, freq='T'), exp)
+        exp = pd.TimedeltaIndex(['04:57:00', '05:57:00', '8:57:00'],
+                                name='xxx')
+        tm.assert_index_equal(idx.shift(-3, freq='T'), exp)
+
+    def test_tdi_shift_int(self):
+        # GH#8083
+        trange = pd.to_timedelta(range(5), unit='d') + pd.offsets.Hour(1)
+        result = trange.shift(1)
+        expected = TimedeltaIndex(['1 days 01:00:00', '2 days 01:00:00',
+                                   '3 days 01:00:00',
+                                   '4 days 01:00:00', '5 days 01:00:00'],
+                                  freq='D')
+        tm.assert_index_equal(result, expected)
+
+    def test_tdi_shift_nonstandard_freq(self):
+        # GH#8083
+        trange = pd.to_timedelta(range(5), unit='d') + pd.offsets.Hour(1)
+        result = trange.shift(3, freq='2D 1s')
+        expected = TimedeltaIndex(['6 days 01:00:03', '7 days 01:00:03',
+                                   '8 days 01:00:03', '9 days 01:00:03',
+                                   '10 days 01:00:03'], freq='D')
+        tm.assert_index_equal(result, expected)
+
+    def test_shift_no_freq(self):
+        # GH#19147
+        tdi = TimedeltaIndex(['1 days 01:00:00', '2 days 01:00:00'], freq=None)
+        with pytest.raises(NullFrequencyError):
+            tdi.shift(2)
+
+    # -------------------------------------------------------------
+    # Binary operations TimedeltaIndex and integer
+
+    def test_tdi_add_int(self, one):
+        # Variants of `one` for #19012
+        rng = timedelta_range('1 days 09:00:00', freq='H', periods=10)
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            # GH#22535
+            result = rng + one
+        expected = timedelta_range('1 days 10:00:00', freq='H', periods=10)
+        tm.assert_index_equal(result, expected)
+
+    def test_tdi_iadd_int(self, one):
+        rng = timedelta_range('1 days 09:00:00', freq='H', periods=10)
+        expected = timedelta_range('1 days 10:00:00', freq='H', periods=10)
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            # GH#22535
+            rng += one
+        tm.assert_index_equal(rng, expected)
+
+    def test_tdi_sub_int(self, one):
+        rng = timedelta_range('1 days 09:00:00', freq='H', periods=10)
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            # GH#22535
+            result = rng - one
+        expected = timedelta_range('1 days 08:00:00', freq='H', periods=10)
+        tm.assert_index_equal(result, expected)
+
+    def test_tdi_isub_int(self, one):
+        rng = timedelta_range('1 days 09:00:00', freq='H', periods=10)
+        expected = timedelta_range('1 days 08:00:00', freq='H', periods=10)
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            # GH#22535
+            rng -= one
+        tm.assert_index_equal(rng, expected)
+
+    # -------------------------------------------------------------
+    # __add__/__sub__ with integer arrays
+
+    @pytest.mark.parametrize('box', [np.array, pd.Index])
+    def test_tdi_add_integer_array(self, box):
+        # GH#19959
+        rng = timedelta_range('1 days 09:00:00', freq='H', periods=3)
+        other = box([4, 3, 2])
+        expected = TimedeltaIndex(['1 day 13:00:00'] * 3)
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            # GH#22535
+            result = rng + other
+            tm.assert_index_equal(result, expected)
+
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            # GH#22535
+            result = other + rng
+            tm.assert_index_equal(result, expected)
+
+    @pytest.mark.parametrize('box', [np.array, pd.Index])
+    def test_tdi_sub_integer_array(self, box):
+        # GH#19959
+        rng = timedelta_range('9H', freq='H', periods=3)
+        other = box([4, 3, 2])
+        expected = TimedeltaIndex(['5H', '7H', '9H'])
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            # GH#22535
+            result = rng - other
+            tm.assert_index_equal(result, expected)
+
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            # GH#22535
+            result = other - rng
+            tm.assert_index_equal(result, -expected)
+
+    @pytest.mark.parametrize('box', [np.array, pd.Index])
+    def test_tdi_addsub_integer_array_no_freq(self, box):
+        # GH#19959
+        tdi = TimedeltaIndex(['1 Day', 'NaT', '3 Hours'])
+        other = box([14, -1, 16])
+        with pytest.raises(NullFrequencyError):
+            tdi + other
+        with pytest.raises(NullFrequencyError):
+            other + tdi
+        with pytest.raises(NullFrequencyError):
+            tdi - other
+        with pytest.raises(NullFrequencyError):
+            other - tdi
+
+    # -------------------------------------------------------------
+    # Binary operations TimedeltaIndex and timedelta-like
+    # Note: add and sub are tested in tests.test_arithmetic, in-place
+    #  tests are kept here because their behavior is Index-specific
+
+    def test_tdi_iadd_timedeltalike(self, delta):
+        # only test adding/sub offsets as + is now numeric
+        rng = timedelta_range('1 days', '10 days')
+        expected = timedelta_range('1 days 02:00:00', '10 days 02:00:00',
+                                   freq='D')
+        rng += delta
+        tm.assert_index_equal(rng, expected)
+
+    def test_tdi_isub_timedeltalike(self, delta):
+        # only test adding/sub offsets as - is now numeric
+        rng = timedelta_range('1 days', '10 days')
+        expected = timedelta_range('0 days 22:00:00', '9 days 22:00:00')
+        rng -= delta
+        tm.assert_index_equal(rng, expected)
+
+    # -------------------------------------------------------------
+
+    # TODO: after #24365 this probably belongs in scalar tests
+    def test_ops_ndarray(self):
+        td = Timedelta('1 day')
+
+        # timedelta, timedelta
+        other = pd.to_timedelta(['1 day']).values
+        expected = pd.to_timedelta(['2 days']).values
+        tm.assert_numpy_array_equal(td + other, expected)
+        tm.assert_numpy_array_equal(other + td, expected)
+        pytest.raises(TypeError, lambda: td + np.array([1]))
+        pytest.raises(TypeError, lambda: np.array([1]) + td)
+
+        expected = pd.to_timedelta(['0 days']).values
+        tm.assert_numpy_array_equal(td - other, expected)
+        tm.assert_numpy_array_equal(-other + td, expected)
+        pytest.raises(TypeError, lambda: td - np.array([1]))
+        pytest.raises(TypeError, lambda: np.array([1]) - td)
+
+        expected = pd.to_timedelta(['2 days']).values
+        tm.assert_numpy_array_equal(td * np.array([2]), expected)
+        tm.assert_numpy_array_equal(np.array([2]) * td, expected)
+        pytest.raises(TypeError, lambda: td * other)
+        pytest.raises(TypeError, lambda: other * td)
+
+        tm.assert_numpy_array_equal(td / other,
+                                    np.array([1], dtype=np.float64))
+        tm.assert_numpy_array_equal(other / td,
+                                    np.array([1], dtype=np.float64))
+
+        # timedelta, datetime
+        other = pd.to_datetime(['2000-01-01']).values
+        expected = pd.to_datetime(['2000-01-02']).values
+        tm.assert_numpy_array_equal(td + other, expected)
+        tm.assert_numpy_array_equal(other + td, expected)
+
+        expected = pd.to_datetime(['1999-12-31']).values
+        tm.assert_numpy_array_equal(-td + other, expected)
+        tm.assert_numpy_array_equal(other - td, expected)
+
+    def test_tdi_ops_attributes(self):
+        rng = timedelta_range('2 days', periods=5, freq='2D', name='x')
+
+        result = rng + 1 * rng.freq
+        exp = timedelta_range('4 days', periods=5, freq='2D', name='x')
+        tm.assert_index_equal(result, exp)
+        assert result.freq == '2D'
+
+        result = rng - 2 * rng.freq
+        exp = timedelta_range('-2 days', periods=5, freq='2D', name='x')
+        tm.assert_index_equal(result, exp)
+        assert result.freq == '2D'
+
+        result = rng * 2
+        exp = timedelta_range('4 days', periods=5, freq='4D', name='x')
+        tm.assert_index_equal(result, exp)
+        assert result.freq == '4D'
+
+        result = rng / 2
+        exp = timedelta_range('1 days', periods=5, freq='D', name='x')
+        tm.assert_index_equal(result, exp)
+        assert result.freq == 'D'
+
+        result = -rng
+        exp = timedelta_range('-2 days', periods=5, freq='-2D', name='x')
+        tm.assert_index_equal(result, exp)
+        assert result.freq == '-2D'
+
+        rng = pd.timedelta_range('-2 days', periods=5, freq='D', name='x')
+
+        result = abs(rng)
+        exp = TimedeltaIndex(['2 days', '1 days', '0 days', '1 days',
+                              '2 days'], name='x')
+        tm.assert_index_equal(result, exp)
+        assert result.freq is None

utils/venv/lib/python3.6/site-packages/pandas/tests/indexes/timedeltas/test_astype.py

@@ -0,0 +1,110 @@
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    Float64Index, Index, Int64Index, NaT, Timedelta, TimedeltaIndex,
+    timedelta_range)
+import pandas.util.testing as tm
+
+
+class TestTimedeltaIndex(object):
+    def test_astype_object(self):
+        idx = timedelta_range(start='1 days', periods=4, freq='D', name='idx')
+        expected_list = [Timedelta('1 days'), Timedelta('2 days'),
+                         Timedelta('3 days'), Timedelta('4 days')]
+        result = idx.astype(object)
+        expected = Index(expected_list, dtype=object, name='idx')
+        tm.assert_index_equal(result, expected)
+        assert idx.tolist() == expected_list
+
+    def test_astype_object_with_nat(self):
+        idx = TimedeltaIndex([timedelta(days=1), timedelta(days=2), NaT,
+                              timedelta(days=4)], name='idx')
+        expected_list = [Timedelta('1 days'), Timedelta('2 days'), NaT,
+                         Timedelta('4 days')]
+        result = idx.astype(object)
+        expected = Index(expected_list, dtype=object, name='idx')
+        tm.assert_index_equal(result, expected)
+        assert idx.tolist() == expected_list
+
+    def test_astype(self):
+        # GH 13149, GH 13209
+        idx = TimedeltaIndex([1e14, 'NaT', NaT, np.NaN])
+
+        result = idx.astype(object)
+        expected = Index([Timedelta('1 days 03:46:40')] + [NaT] * 3,
+                         dtype=object)
+        tm.assert_index_equal(result, expected)
+
+        result = idx.astype(int)
+        expected = Int64Index([100000000000000] + [-9223372036854775808] * 3,
+                              dtype=np.int64)
+        tm.assert_index_equal(result, expected)
+
+        result = idx.astype(str)
+        expected = Index(str(x) for x in idx)
+        tm.assert_index_equal(result, expected)
+
+        rng = timedelta_range('1 days', periods=10)
+        result = rng.astype('i8')
+        tm.assert_index_equal(result, Index(rng.asi8))
+        tm.assert_numpy_array_equal(rng.asi8, result.values)
+
+    def test_astype_uint(self):
+        arr = timedelta_range('1H', periods=2)
+        expected = pd.UInt64Index(
+            np.array([3600000000000, 90000000000000], dtype="uint64")
+        )
+
+        tm.assert_index_equal(arr.astype("uint64"), expected)
+        tm.assert_index_equal(arr.astype("uint32"), expected)
+
+    def test_astype_timedelta64(self):
+        # GH 13149, GH 13209
+        idx = TimedeltaIndex([1e14, 'NaT', NaT, np.NaN])
+
+        result = idx.astype('timedelta64')
+        expected = Float64Index([1e+14] + [np.NaN] * 3, dtype='float64')
+        tm.assert_index_equal(result, expected)
+
+        result = idx.astype('timedelta64[ns]')
+        tm.assert_index_equal(result, idx)
+        assert result is not idx
+
+        result = idx.astype('timedelta64[ns]', copy=False)
+        tm.assert_index_equal(result, idx)
+        assert result is idx
+
+    @pytest.mark.parametrize('dtype', [
+        float, 'datetime64', 'datetime64[ns]'])
+    def test_astype_raises(self, dtype):
+        # GH 13149, GH 13209
+        idx = TimedeltaIndex([1e14, 'NaT', NaT, np.NaN])
+        msg = 'Cannot cast TimedeltaArray to dtype'
+        with pytest.raises(TypeError, match=msg):
+            idx.astype(dtype)
+
+    def test_astype_category(self):
+        obj = pd.timedelta_range("1H", periods=2, freq='H')
+
+        result = obj.astype('category')
+        expected = pd.CategoricalIndex([pd.Timedelta('1H'),
+                                        pd.Timedelta('2H')])
+        tm.assert_index_equal(result, expected)
+
+        result = obj._data.astype('category')
+        expected = expected.values
+        tm.assert_categorical_equal(result, expected)
+
+    def test_astype_array_fallback(self):
+        obj = pd.timedelta_range("1H", periods=2)
+        result = obj.astype(bool)
+        expected = pd.Index(np.array([True, True]))
+        tm.assert_index_equal(result, expected)
+
+        result = obj._data.astype(bool)
+        expected = np.array([True, True])
+        tm.assert_numpy_array_equal(result, expected)

utils/venv/lib/python3.6/site-packages/pandas/tests/indexes/timedeltas/test_construction.py

@@ -0,0 +1,199 @@
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Timedelta, TimedeltaIndex, timedelta_range, to_timedelta
+from pandas.core.arrays import TimedeltaArray
+import pandas.util.testing as tm
+
+
+class TestTimedeltaIndex(object):
+
+    def test_verify_integrity_deprecated(self):
+        # GH#23919
+        with tm.assert_produces_warning(FutureWarning):
+            TimedeltaIndex(['1 Day'], verify_integrity=False)
+
+    def test_range_kwargs_deprecated(self):
+        # GH#23919
+        with tm.assert_produces_warning(FutureWarning):
+            TimedeltaIndex(start='1 Day', end='3 Days', freq='D')
+
+    def test_int64_nocopy(self):
+        # GH#23539 check that a copy isn't made when we pass int64 data
+        #  and copy=False
+        arr = np.arange(10, dtype=np.int64)
+        tdi = TimedeltaIndex(arr, copy=False)
+        assert tdi._data._data.base is arr
+
+    def test_infer_from_tdi(self):
+        # GH#23539
+        # fast-path for inferring a frequency if the passed data already
+        #  has one
+        tdi = pd.timedelta_range('1 second', periods=10**7, freq='1s')
+
+        result = pd.TimedeltaIndex(tdi, freq='infer')
+        assert result.freq == tdi.freq
+
+        # check that inferred_freq was not called by checking that the
+        #  value has not been cached
+        assert "inferred_freq" not in getattr(result, "_cache", {})
+
+    def test_infer_from_tdi_mismatch(self):
+        # GH#23539
+        # fast-path for invalidating a frequency if the passed data already
+        #  has one and it does not match the `freq` input
+        tdi = pd.timedelta_range('1 second', periods=100, freq='1s')
+
+        msg = ("Inferred frequency .* from passed values does "
+               "not conform to passed frequency")
+        with pytest.raises(ValueError, match=msg):
+            TimedeltaIndex(tdi, freq='D')
+
+        with pytest.raises(ValueError, match=msg):
+            # GH#23789
+            TimedeltaArray(tdi, freq='D')
+
+    def test_dt64_data_invalid(self):
+        # GH#23539
+        # passing tz-aware DatetimeIndex raises, naive or ndarray[datetime64]
+        #  does not yet, but will in the future
+        dti = pd.date_range('2016-01-01', periods=3)
+
+        msg = "cannot be converted to timedelta64"
+        with pytest.raises(TypeError, match=msg):
+            TimedeltaIndex(dti.tz_localize('Europe/Brussels'))
+
+        with tm.assert_produces_warning(FutureWarning):
+            TimedeltaIndex(dti)
+
+        with tm.assert_produces_warning(FutureWarning):
+            TimedeltaIndex(np.asarray(dti))
+
+    def test_float64_ns_rounded(self):
+        # GH#23539 without specifying a unit, floats are regarded as nanos,
+        #  and fractional portions are truncated
+        tdi = TimedeltaIndex([2.3, 9.7])
+        expected = TimedeltaIndex([2, 9])
+        tm.assert_index_equal(tdi, expected)
+
+        # integral floats are non-lossy
+        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_float64_unit_conversion(self):
+        # GH#23539
+        tdi = TimedeltaIndex([1.5, 2.25], unit='D')
+        expected = TimedeltaIndex([Timedelta(days=1.5), Timedelta(days=2.25)])
+        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))
+        tm.assert_index_equal(pd.Index(np.array(arr)),
+                              pd.TimedeltaIndex(np.array(arr)))
+
+        arr = [np.nan, pd.NaT, pd.Timedelta('1 days')]
+        tm.assert_index_equal(pd.Index(arr), pd.TimedeltaIndex(arr))
+        tm.assert_index_equal(pd.Index(np.array(arr)),
+                              pd.TimedeltaIndex(np.array(arr)))
+
+    def test_constructor(self):
+        expected = TimedeltaIndex(['1 days', '1 days 00:00:05', '2 days',
+                                   '2 days 00:00:02', '0 days 00:00:03'])
+        result = TimedeltaIndex(['1 days', '1 days, 00:00:05', np.timedelta64(
+            2, 'D'), timedelta(days=2, seconds=2), pd.offsets.Second(3)])
+        tm.assert_index_equal(result, expected)
+
+        # unicode
+        result = TimedeltaIndex([u'1 days', '1 days, 00:00:05', np.timedelta64(
+            2, 'D'), timedelta(days=2, seconds=2), pd.offsets.Second(3)])
+
+        expected = TimedeltaIndex(['0 days 00:00:00', '0 days 00:00:01',
+                                   '0 days 00:00:02'])
+        tm.assert_index_equal(TimedeltaIndex(range(3), unit='s'), expected)
+        expected = TimedeltaIndex(['0 days 00:00:00', '0 days 00:00:05',
+                                   '0 days 00:00:09'])
+        tm.assert_index_equal(TimedeltaIndex([0, 5, 9], unit='s'), expected)
+        expected = TimedeltaIndex(
+            ['0 days 00:00:00.400', '0 days 00:00:00.450',
+             '0 days 00:00:01.200'])
+        tm.assert_index_equal(TimedeltaIndex([400, 450, 1200], unit='ms'),
+                              expected)
+
+    def test_constructor_iso(self):
+        # GH #21877
+        expected = timedelta_range('1s', periods=9, freq='s')
+        durations = ['P0DT0H0M{}S'.format(i) for i in range(1, 10)]
+        result = to_timedelta(durations)
+        tm.assert_index_equal(result, expected)
+
+    def test_constructor_coverage(self):
+        rng = timedelta_range('1 days', periods=10.5)
+        exp = timedelta_range('1 days', periods=10)
+        tm.assert_index_equal(rng, exp)
+
+        msg = 'periods must be a number, got foo'
+        with pytest.raises(TypeError, match=msg):
+            timedelta_range(start='1 days', periods='foo', freq='D')
+
+        with pytest.raises(ValueError):
+            with tm.assert_produces_warning(FutureWarning):
+                TimedeltaIndex(start='1 days', end='10 days')
+
+        with pytest.raises(TypeError):
+            TimedeltaIndex('1 days')
+
+        # generator expression
+        gen = (timedelta(i) for i in range(10))
+        result = TimedeltaIndex(gen)
+        expected = TimedeltaIndex([timedelta(i) for i in range(10)])
+        tm.assert_index_equal(result, expected)
+
+        # NumPy string array
+        strings = np.array(['1 days', '2 days', '3 days'])
+        result = TimedeltaIndex(strings)
+        expected = to_timedelta([1, 2, 3], unit='d')
+        tm.assert_index_equal(result, expected)
+
+        from_ints = TimedeltaIndex(expected.asi8)
+        tm.assert_index_equal(from_ints, expected)
+
+        # non-conforming freq
+        pytest.raises(ValueError, TimedeltaIndex,
+                      ['1 days', '2 days', '4 days'], freq='D')
+
+        pytest.raises(ValueError, timedelta_range, periods=10, freq='D')
+
+    def test_constructor_name(self):
+        idx = timedelta_range(start='1 days', periods=1, freq='D', name='TEST')
+        assert idx.name == 'TEST'
+
+        # GH10025
+        idx2 = TimedeltaIndex(idx, name='something else')
+        assert idx2.name == 'something else'
+
+    def test_constructor_no_precision_warns(self):
+        # GH-24753, GH-24739
+        expected = pd.TimedeltaIndex(['2000'], dtype='timedelta64[ns]')
+
+        # we set the stacklevel for DatetimeIndex
+        with tm.assert_produces_warning(FutureWarning):
+            result = pd.TimedeltaIndex(['2000'], dtype='timedelta64')
+        tm.assert_index_equal(result, expected)
+
+        with tm.assert_produces_warning(FutureWarning, check_stacklevel=False):
+            result = pd.Index(['2000'], dtype='timedelta64')
+        tm.assert_index_equal(result, expected)
+
+    def test_constructor_wrong_precision_raises(self):
+        with pytest.raises(ValueError):
+            pd.TimedeltaIndex(['2000'], dtype='timedelta64[us]')

utils/venv/lib/python3.6/site-packages/pandas/tests/indexes/timedeltas/test_formats.py

@@ -0,0 +1,96 @@
+# -*- coding: utf-8 -*-
+
+import pytest
+
+import pandas as pd
+from pandas import TimedeltaIndex
+
+
+class TestTimedeltaIndexRendering(object):
+    @pytest.mark.parametrize('method', ['__repr__', '__unicode__', '__str__'])
+    def test_representation(self, method):
+        idx1 = TimedeltaIndex([], freq='D')
+        idx2 = TimedeltaIndex(['1 days'], freq='D')
+        idx3 = TimedeltaIndex(['1 days', '2 days'], freq='D')
+        idx4 = TimedeltaIndex(['1 days', '2 days', '3 days'], freq='D')
+        idx5 = TimedeltaIndex(['1 days 00:00:01', '2 days', '3 days'])
+
+        exp1 = """TimedeltaIndex([], dtype='timedelta64[ns]', freq='D')"""
+
+        exp2 = ("TimedeltaIndex(['1 days'], dtype='timedelta64[ns]', "
+                "freq='D')")
+
+        exp3 = ("TimedeltaIndex(['1 days', '2 days'], "
+                "dtype='timedelta64[ns]', freq='D')")
+
+        exp4 = ("TimedeltaIndex(['1 days', '2 days', '3 days'], "
+                "dtype='timedelta64[ns]', freq='D')")
+
+        exp5 = ("TimedeltaIndex(['1 days 00:00:01', '2 days 00:00:00', "
+                "'3 days 00:00:00'], dtype='timedelta64[ns]', freq=None)")
+
+        with pd.option_context('display.width', 300):
+            for idx, expected in zip([idx1, idx2, idx3, idx4, idx5],
+                                     [exp1, exp2, exp3, exp4, exp5]):
+                result = getattr(idx, method)()
+                assert result == expected
+
+    def test_representation_to_series(self):
+        idx1 = TimedeltaIndex([], freq='D')
+        idx2 = TimedeltaIndex(['1 days'], freq='D')
+        idx3 = TimedeltaIndex(['1 days', '2 days'], freq='D')
+        idx4 = TimedeltaIndex(['1 days', '2 days', '3 days'], freq='D')
+        idx5 = TimedeltaIndex(['1 days 00:00:01', '2 days', '3 days'])
+
+        exp1 = """Series([], dtype: timedelta64[ns])"""
+
+        exp2 = ("0   1 days\n"
+                "dtype: timedelta64[ns]")
+
+        exp3 = ("0   1 days\n"
+                "1   2 days\n"
+                "dtype: timedelta64[ns]")
+
+        exp4 = ("0   1 days\n"
+                "1   2 days\n"
+                "2   3 days\n"
+                "dtype: timedelta64[ns]")
+
+        exp5 = ("0   1 days 00:00:01\n"
+                "1   2 days 00:00:00\n"
+                "2   3 days 00:00:00\n"
+                "dtype: timedelta64[ns]")
+
+        with pd.option_context('display.width', 300):
+            for idx, expected in zip([idx1, idx2, idx3, idx4, idx5],
+                                     [exp1, exp2, exp3, exp4, exp5]):
+                result = repr(pd.Series(idx))
+                assert result == expected
+
+    def test_summary(self):
+        # GH#9116
+        idx1 = TimedeltaIndex([], freq='D')
+        idx2 = TimedeltaIndex(['1 days'], freq='D')
+        idx3 = TimedeltaIndex(['1 days', '2 days'], freq='D')
+        idx4 = TimedeltaIndex(['1 days', '2 days', '3 days'], freq='D')
+        idx5 = TimedeltaIndex(['1 days 00:00:01', '2 days', '3 days'])
+
+        exp1 = ("TimedeltaIndex: 0 entries\n"
+                "Freq: D")
+
+        exp2 = ("TimedeltaIndex: 1 entries, 1 days to 1 days\n"
+                "Freq: D")
+
+        exp3 = ("TimedeltaIndex: 2 entries, 1 days to 2 days\n"
+                "Freq: D")
+
+        exp4 = ("TimedeltaIndex: 3 entries, 1 days to 3 days\n"
+                "Freq: D")
+
+        exp5 = ("TimedeltaIndex: 3 entries, 1 days 00:00:01 to 3 days "
+                "00:00:00")
+
+        for idx, expected in zip([idx1, idx2, idx3, idx4, idx5],
+                                 [exp1, exp2, exp3, exp4, exp5]):
+            result = idx._summary()
+            assert result == expected

utils/venv/lib/python3.6/site-packages/pandas/tests/indexes/timedeltas/test_indexing.py

@@ -0,0 +1,338 @@
+from datetime import datetime, timedelta
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Index, Timedelta, TimedeltaIndex, compat, timedelta_range
+import pandas.util.testing as tm
+
+
+class TestGetItem(object):
+    def test_ellipsis(self):
+        # GH#21282
+        idx = timedelta_range('1 day', '31 day', freq='D', name='idx')
+
+        result = idx[...]
+        assert result.equals(idx)
+        assert result is not idx
+
+    def test_getitem(self):
+        idx1 = timedelta_range('1 day', '31 day', freq='D', name='idx')
+
+        for idx in [idx1]:
+            result = idx[0]
+            assert result == Timedelta('1 day')
+
+            result = idx[0:5]
+            expected = timedelta_range('1 day', '5 day', freq='D',
+                                       name='idx')
+            tm.assert_index_equal(result, expected)
+            assert result.freq == expected.freq
+
+            result = idx[0:10:2]
+            expected = timedelta_range('1 day', '9 day', freq='2D',
+                                       name='idx')
+            tm.assert_index_equal(result, expected)
+            assert result.freq == expected.freq
+
+            result = idx[-20:-5:3]
+            expected = timedelta_range('12 day', '24 day', freq='3D',
+                                       name='idx')
+            tm.assert_index_equal(result, expected)
+            assert result.freq == expected.freq
+
+            result = idx[4::-1]
+            expected = TimedeltaIndex(['5 day', '4 day', '3 day',
+                                       '2 day', '1 day'],
+                                      freq='-1D', name='idx')
+            tm.assert_index_equal(result, expected)
+            assert result.freq == expected.freq
+
+    @pytest.mark.parametrize('key', [pd.Timestamp('1970-01-01'),
+                                     pd.Timestamp('1970-01-02'),
+                                     datetime(1970, 1, 1)])
+    def test_timestamp_invalid_key(self, key):
+        # GH#20464
+        tdi = pd.timedelta_range(0, periods=10)
+        with pytest.raises(TypeError):
+            tdi.get_loc(key)
+
+
+class TestWhere(object):
+    # placeholder for symmetry with DatetimeIndex and PeriodIndex tests
+    pass
+
+
+class TestTake(object):
+    def test_take(self):
+        # GH 10295
+        idx1 = timedelta_range('1 day', '31 day', freq='D', name='idx')
+
+        for idx in [idx1]:
+            result = idx.take([0])
+            assert result == Timedelta('1 day')
+
+            result = idx.take([-1])
+            assert result == Timedelta('31 day')
+
+            result = idx.take([0, 1, 2])
+            expected = timedelta_range('1 day', '3 day', freq='D',
+                                       name='idx')
+            tm.assert_index_equal(result, expected)
+            assert result.freq == expected.freq
+
+            result = idx.take([0, 2, 4])
+            expected = timedelta_range('1 day', '5 day', freq='2D',
+                                       name='idx')
+            tm.assert_index_equal(result, expected)
+            assert result.freq == expected.freq
+
+            result = idx.take([7, 4, 1])
+            expected = timedelta_range('8 day', '2 day', freq='-3D',
+                                       name='idx')
+            tm.assert_index_equal(result, expected)
+            assert result.freq == expected.freq
+
+            result = idx.take([3, 2, 5])
+            expected = TimedeltaIndex(['4 day', '3 day', '6 day'], name='idx')
+            tm.assert_index_equal(result, expected)
+            assert result.freq is None
+
+            result = idx.take([-3, 2, 5])
+            expected = TimedeltaIndex(['29 day', '3 day', '6 day'], name='idx')
+            tm.assert_index_equal(result, expected)
+            assert result.freq is None
+
+    def test_take_invalid_kwargs(self):
+        idx = timedelta_range('1 day', '31 day', freq='D', name='idx')
+        indices = [1, 6, 5, 9, 10, 13, 15, 3]
+
+        msg = r"take\(\) got an unexpected keyword argument 'foo'"
+        with pytest.raises(TypeError, match=msg):
+            idx.take(indices, foo=2)
+
+        msg = "the 'out' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            idx.take(indices, out=indices)
+
+        msg = "the 'mode' parameter is not supported"
+        with pytest.raises(ValueError, match=msg):
+            idx.take(indices, mode='clip')
+
+    # TODO: This method came from test_timedelta; de-dup with version above
+    def test_take2(self):
+        tds = ['1day 02:00:00', '1 day 04:00:00', '1 day 10:00:00']
+        idx = timedelta_range(start='1d', end='2d', freq='H', name='idx')
+        expected = TimedeltaIndex(tds, freq=None, name='idx')
+
+        taken1 = idx.take([2, 4, 10])
+        taken2 = idx[[2, 4, 10]]
+
+        for taken in [taken1, taken2]:
+            tm.assert_index_equal(taken, expected)
+            assert isinstance(taken, TimedeltaIndex)
+            assert taken.freq is None
+            assert taken.name == expected.name
+
+    def test_take_fill_value(self):
+        # GH 12631
+        idx = TimedeltaIndex(['1 days', '2 days', '3 days'],
+                             name='xxx')
+        result = idx.take(np.array([1, 0, -1]))
+        expected = TimedeltaIndex(['2 days', '1 days', '3 days'],
+                                  name='xxx')
+        tm.assert_index_equal(result, expected)
+
+        # fill_value
+        result = idx.take(np.array([1, 0, -1]), fill_value=True)
+        expected = TimedeltaIndex(['2 days', '1 days', 'NaT'],
+                                  name='xxx')
+        tm.assert_index_equal(result, expected)
+
+        # allow_fill=False
+        result = idx.take(np.array([1, 0, -1]), allow_fill=False,
+                          fill_value=True)
+        expected = TimedeltaIndex(['2 days', '1 days', '3 days'],
+                                  name='xxx')
+        tm.assert_index_equal(result, expected)
+
+        msg = ('When allow_fill=True and fill_value is not None, '
+               'all indices must be >= -1')
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -2]), fill_value=True)
+        with pytest.raises(ValueError, match=msg):
+            idx.take(np.array([1, 0, -5]), fill_value=True)
+
+        with pytest.raises(IndexError):
+            idx.take(np.array([1, -5]))
+
+
+class TestTimedeltaIndex(object):
+
+    def test_insert(self):
+
+        idx = TimedeltaIndex(['4day', '1day', '2day'], name='idx')
+
+        result = idx.insert(2, timedelta(days=5))
+        exp = TimedeltaIndex(['4day', '1day', '5day', '2day'], name='idx')
+        tm.assert_index_equal(result, exp)
+
+        # insertion of non-datetime should coerce to object index
+        result = idx.insert(1, 'inserted')
+        expected = Index([Timedelta('4day'), 'inserted', Timedelta('1day'),
+                          Timedelta('2day')], name='idx')
+        assert not isinstance(result, TimedeltaIndex)
+        tm.assert_index_equal(result, expected)
+        assert result.name == expected.name
+
+        idx = timedelta_range('1day 00:00:01', periods=3, freq='s', name='idx')
+
+        # preserve freq
+        expected_0 = TimedeltaIndex(['1day', '1day 00:00:01', '1day 00:00:02',
+                                     '1day 00:00:03'],
+                                    name='idx', freq='s')
+        expected_3 = TimedeltaIndex(['1day 00:00:01', '1day 00:00:02',
+                                     '1day 00:00:03', '1day 00:00:04'],
+                                    name='idx', freq='s')
+
+        # reset freq to None
+        expected_1_nofreq = TimedeltaIndex(['1day 00:00:01', '1day 00:00:01',
+                                            '1day 00:00:02', '1day 00:00:03'],
+                                           name='idx', freq=None)
+        expected_3_nofreq = TimedeltaIndex(['1day 00:00:01', '1day 00:00:02',
+                                            '1day 00:00:03', '1day 00:00:05'],
+                                           name='idx', freq=None)
+
+        cases = [(0, Timedelta('1day'), expected_0),
+                 (-3, Timedelta('1day'), expected_0),
+                 (3, Timedelta('1day 00:00:04'), expected_3),
+                 (1, Timedelta('1day 00:00:01'), expected_1_nofreq),
+                 (3, Timedelta('1day 00:00:05'), expected_3_nofreq)]
+
+        for n, d, expected in cases:
+            result = idx.insert(n, d)
+            tm.assert_index_equal(result, expected)
+            assert result.name == expected.name
+            assert result.freq == expected.freq
+
+        # GH 18295 (test missing)
+        expected = TimedeltaIndex(['1day', pd.NaT, '2day', '3day'])
+        for na in (np.nan, pd.NaT, None):
+            result = timedelta_range('1day', '3day').insert(1, na)
+            tm.assert_index_equal(result, expected)
+
+    def test_delete(self):
+        idx = timedelta_range(start='1 Days', periods=5, freq='D', name='idx')
+
+        # prserve freq
+        expected_0 = timedelta_range(start='2 Days', periods=4, freq='D',
+                                     name='idx')
+        expected_4 = timedelta_range(start='1 Days', periods=4, freq='D',
+                                     name='idx')
+
+        # reset freq to None
+        expected_1 = TimedeltaIndex(
+            ['1 day', '3 day', '4 day', '5 day'], freq=None, name='idx')
+
+        cases = {0: expected_0,
+                 -5: expected_0,
+                 -1: expected_4,
+                 4: expected_4,
+                 1: expected_1}
+        for n, expected in compat.iteritems(cases):
+            result = idx.delete(n)
+            tm.assert_index_equal(result, expected)
+            assert result.name == expected.name
+            assert result.freq == expected.freq
+
+        with pytest.raises((IndexError, ValueError)):
+            # either depending on numpy version
+            idx.delete(5)
+
+    def test_delete_slice(self):
+        idx = timedelta_range(start='1 days', periods=10, freq='D', name='idx')
+
+        # prserve freq
+        expected_0_2 = timedelta_range(start='4 days', periods=7, freq='D',
+                                       name='idx')
+        expected_7_9 = timedelta_range(start='1 days', periods=7, freq='D',
+                                       name='idx')
+
+        # reset freq to None
+        expected_3_5 = TimedeltaIndex(['1 d', '2 d', '3 d',
+                                       '7 d', '8 d', '9 d', '10d'],
+                                      freq=None, name='idx')
+
+        cases = {(0, 1, 2): expected_0_2,
+                 (7, 8, 9): expected_7_9,
+                 (3, 4, 5): expected_3_5}
+        for n, expected in compat.iteritems(cases):
+            result = idx.delete(n)
+            tm.assert_index_equal(result, expected)
+            assert result.name == expected.name
+            assert result.freq == expected.freq
+
+            result = idx.delete(slice(n[0], n[-1] + 1))
+            tm.assert_index_equal(result, expected)
+            assert result.name == expected.name
+            assert result.freq == expected.freq
+
+    def test_get_loc(self):
+        idx = pd.to_timedelta(['0 days', '1 days', '2 days'])
+
+        for method in [None, 'pad', 'backfill', 'nearest']:
+            assert idx.get_loc(idx[1], method) == 1
+            assert idx.get_loc(idx[1].to_pytimedelta(), method) == 1
+            assert idx.get_loc(str(idx[1]), method) == 1
+
+        assert idx.get_loc(idx[1], 'pad',
+                           tolerance=Timedelta(0)) == 1
+        assert idx.get_loc(idx[1], 'pad',
+                           tolerance=np.timedelta64(0, 's')) == 1
+        assert idx.get_loc(idx[1], 'pad',
+                           tolerance=timedelta(0)) == 1
+
+        with pytest.raises(ValueError, match='unit abbreviation w/o a number'):
+            idx.get_loc(idx[1], method='nearest', tolerance='foo')
+
+        with pytest.raises(
+                ValueError,
+                match='tolerance size must match'):
+            idx.get_loc(idx[1], method='nearest',
+                        tolerance=[Timedelta(0).to_timedelta64(),
+                                   Timedelta(0).to_timedelta64()])
+
+        for method, loc in [('pad', 1), ('backfill', 2), ('nearest', 1)]:
+            assert idx.get_loc('1 day 1 hour', method) == loc
+
+        # GH 16909
+        assert idx.get_loc(idx[1].to_timedelta64()) == 1
+
+        # GH 16896
+        assert idx.get_loc('0 days') == 0
+
+    def test_get_loc_nat(self):
+        tidx = TimedeltaIndex(['1 days 01:00:00', 'NaT', '2 days 01:00:00'])
+
+        assert tidx.get_loc(pd.NaT) == 1
+        assert tidx.get_loc(None) == 1
+        assert tidx.get_loc(float('nan')) == 1
+        assert tidx.get_loc(np.nan) == 1
+
+    def test_get_indexer(self):
+        idx = pd.to_timedelta(['0 days', '1 days', '2 days'])
+        tm.assert_numpy_array_equal(idx.get_indexer(idx),
+                                    np.array([0, 1, 2], dtype=np.intp))
+
+        target = pd.to_timedelta(['-1 hour', '12 hours', '1 day 1 hour'])
+        tm.assert_numpy_array_equal(idx.get_indexer(target, 'pad'),
+                                    np.array([-1, 0, 1], dtype=np.intp))
+        tm.assert_numpy_array_equal(idx.get_indexer(target, 'backfill'),
+                                    np.array([0, 1, 2], dtype=np.intp))
+        tm.assert_numpy_array_equal(idx.get_indexer(target, 'nearest'),
+                                    np.array([0, 1, 1], dtype=np.intp))
+
+        res = idx.get_indexer(target, 'nearest',
+                              tolerance=Timedelta('1 hour'))
+        tm.assert_numpy_array_equal(res, np.array([0, -1, 1], dtype=np.intp))

utils/venv/lib/python3.6/site-packages/pandas/tests/indexes/timedeltas/test_ops.py

@@ -0,0 +1,281 @@
+
+import numpy as np
+import pytest
+
+from pandas.core.dtypes.generic import ABCDateOffset
+
+import pandas as pd
+from pandas import Series, TimedeltaIndex, timedelta_range
+from pandas.tests.test_base import Ops
+import pandas.util.testing as tm
+
+from pandas.tseries.offsets import Day, Hour
+
+
+class TestTimedeltaIndexOps(Ops):
+    def setup_method(self, method):
+        super(TestTimedeltaIndexOps, self).setup_method(method)
+        mask = lambda x: isinstance(x, TimedeltaIndex)
+        self.is_valid_objs = [o for o in self.objs if mask(o)]
+        self.not_valid_objs = []
+
+    def test_ops_properties(self):
+        f = lambda x: isinstance(x, TimedeltaIndex)
+        self.check_ops_properties(TimedeltaIndex._field_ops, f)
+        self.check_ops_properties(TimedeltaIndex._object_ops, f)
+
+    def test_value_counts_unique(self):
+        # GH 7735
+
+        idx = timedelta_range('1 days 09:00:00', freq='H', periods=10)
+        # create repeated values, 'n'th element is repeated by n+1 times
+        idx = TimedeltaIndex(np.repeat(idx.values, range(1, len(idx) + 1)))
+
+        exp_idx = timedelta_range('1 days 18:00:00', freq='-1H', periods=10)
+        expected = Series(range(10, 0, -1), index=exp_idx, dtype='int64')
+
+        for obj in [idx, Series(idx)]:
+            tm.assert_series_equal(obj.value_counts(), expected)
+
+        expected = timedelta_range('1 days 09:00:00', freq='H', periods=10)
+        tm.assert_index_equal(idx.unique(), expected)
+
+        idx = TimedeltaIndex(['1 days 09:00:00', '1 days 09:00:00',
+                              '1 days 09:00:00', '1 days 08:00:00',
+                              '1 days 08:00:00', pd.NaT])
+
+        exp_idx = TimedeltaIndex(['1 days 09:00:00', '1 days 08:00:00'])
+        expected = Series([3, 2], index=exp_idx)
+
+        for obj in [idx, Series(idx)]:
+            tm.assert_series_equal(obj.value_counts(), expected)
+
+        exp_idx = TimedeltaIndex(['1 days 09:00:00', '1 days 08:00:00',
+                                  pd.NaT])
+        expected = Series([3, 2, 1], index=exp_idx)
+
+        for obj in [idx, Series(idx)]:
+            tm.assert_series_equal(obj.value_counts(dropna=False), expected)
+
+        tm.assert_index_equal(idx.unique(), exp_idx)
+
+    def test_nonunique_contains(self):
+        # GH 9512
+        for idx in map(TimedeltaIndex, ([0, 1, 0], [0, 0, -1], [0, -1, -1],
+                                        ['00:01:00', '00:01:00', '00:02:00'],
+                                        ['00:01:00', '00:01:00', '00:00:01'])):
+            assert idx[0] in idx
+
+    def test_unknown_attribute(self):
+        # see gh-9680
+        tdi = pd.timedelta_range(start=0, periods=10, freq='1s')
+        ts = pd.Series(np.random.normal(size=10), index=tdi)
+        assert 'foo' not in ts.__dict__.keys()
+        pytest.raises(AttributeError, lambda: ts.foo)
+
+    def test_order(self):
+        # GH 10295
+        idx1 = TimedeltaIndex(['1 day', '2 day', '3 day'], freq='D',
+                              name='idx')
+        idx2 = TimedeltaIndex(
+            ['1 hour', '2 hour', '3 hour'], freq='H', name='idx')
+
+        for idx in [idx1, idx2]:
+            ordered = idx.sort_values()
+            tm.assert_index_equal(ordered, idx)
+            assert ordered.freq == idx.freq
+
+            ordered = idx.sort_values(ascending=False)
+            expected = idx[::-1]
+            tm.assert_index_equal(ordered, expected)
+            assert ordered.freq == expected.freq
+            assert ordered.freq.n == -1
+
+            ordered, indexer = idx.sort_values(return_indexer=True)
+            tm.assert_index_equal(ordered, idx)
+            tm.assert_numpy_array_equal(indexer, np.array([0, 1, 2]),
+                                        check_dtype=False)
+            assert ordered.freq == idx.freq
+
+            ordered, indexer = idx.sort_values(return_indexer=True,
+                                               ascending=False)
+            tm.assert_index_equal(ordered, idx[::-1])
+            assert ordered.freq == expected.freq
+            assert ordered.freq.n == -1
+
+        idx1 = TimedeltaIndex(['1 hour', '3 hour', '5 hour',
+                               '2 hour ', '1 hour'], name='idx1')
+        exp1 = TimedeltaIndex(['1 hour', '1 hour', '2 hour',
+                               '3 hour', '5 hour'], name='idx1')
+
+        idx2 = TimedeltaIndex(['1 day', '3 day', '5 day',
+                               '2 day', '1 day'], name='idx2')
+
+        # TODO(wesm): unused?
+        # exp2 = TimedeltaIndex(['1 day', '1 day', '2 day',
+        #                        '3 day', '5 day'], name='idx2')
+
+        # idx3 = TimedeltaIndex([pd.NaT, '3 minute', '5 minute',
+        #                        '2 minute', pd.NaT], name='idx3')
+        # exp3 = TimedeltaIndex([pd.NaT, pd.NaT, '2 minute', '3 minute',
+        #                        '5 minute'], name='idx3')
+
+        for idx, expected in [(idx1, exp1), (idx1, exp1), (idx1, exp1)]:
+            ordered = idx.sort_values()
+            tm.assert_index_equal(ordered, expected)
+            assert ordered.freq is None
+
+            ordered = idx.sort_values(ascending=False)
+            tm.assert_index_equal(ordered, expected[::-1])
+            assert ordered.freq is None
+
+            ordered, indexer = idx.sort_values(return_indexer=True)
+            tm.assert_index_equal(ordered, expected)
+
+            exp = np.array([0, 4, 3, 1, 2])
+            tm.assert_numpy_array_equal(indexer, exp, check_dtype=False)
+            assert ordered.freq is None
+
+            ordered, indexer = idx.sort_values(return_indexer=True,
+                                               ascending=False)
+            tm.assert_index_equal(ordered, expected[::-1])
+
+            exp = np.array([2, 1, 3, 4, 0])
+            tm.assert_numpy_array_equal(indexer, exp, check_dtype=False)
+            assert ordered.freq is None
+
+    def test_drop_duplicates_metadata(self):
+        # GH 10115
+        idx = pd.timedelta_range('1 day', '31 day', freq='D', name='idx')
+        result = idx.drop_duplicates()
+        tm.assert_index_equal(idx, result)
+        assert idx.freq == result.freq
+
+        idx_dup = idx.append(idx)
+        assert idx_dup.freq is None  # freq is reset
+        result = idx_dup.drop_duplicates()
+        tm.assert_index_equal(idx, result)
+        assert result.freq is None
+
+    def test_drop_duplicates(self):
+        # to check Index/Series compat
+        base = pd.timedelta_range('1 day', '31 day', freq='D', name='idx')
+        idx = base.append(base[:5])
+
+        res = idx.drop_duplicates()
+        tm.assert_index_equal(res, base)
+        res = Series(idx).drop_duplicates()
+        tm.assert_series_equal(res, Series(base))
+
+        res = idx.drop_duplicates(keep='last')
+        exp = base[5:].append(base[:5])
+        tm.assert_index_equal(res, exp)
+        res = Series(idx).drop_duplicates(keep='last')
+        tm.assert_series_equal(res, Series(exp, index=np.arange(5, 36)))
+
+        res = idx.drop_duplicates(keep=False)
+        tm.assert_index_equal(res, base[5:])
+        res = Series(idx).drop_duplicates(keep=False)
+        tm.assert_series_equal(res, Series(base[5:], index=np.arange(5, 31)))
+
+    @pytest.mark.parametrize('freq', ['D', '3D', '-3D',
+                                      'H', '2H', '-2H',
+                                      'T', '2T', 'S', '-3S'])
+    def test_infer_freq(self, freq):
+        # GH#11018
+        idx = pd.timedelta_range('1', freq=freq, periods=10)
+        result = pd.TimedeltaIndex(idx.asi8, freq='infer')
+        tm.assert_index_equal(idx, result)
+        assert result.freq == freq
+
+    def test_shift(self):
+        pass  # handled in test_arithmetic.py
+
+    def test_repeat(self):
+        index = pd.timedelta_range('1 days', periods=2, freq='D')
+        exp = pd.TimedeltaIndex(['1 days', '1 days', '2 days', '2 days'])
+        for res in [index.repeat(2), np.repeat(index, 2)]:
+            tm.assert_index_equal(res, exp)
+            assert res.freq is None
+
+        index = TimedeltaIndex(['1 days', 'NaT', '3 days'])
+        exp = TimedeltaIndex(['1 days', '1 days', '1 days',
+                              'NaT', 'NaT', 'NaT',
+                              '3 days', '3 days', '3 days'])
+        for res in [index.repeat(3), np.repeat(index, 3)]:
+            tm.assert_index_equal(res, exp)
+            assert res.freq is None
+
+    def test_nat(self):
+        assert pd.TimedeltaIndex._na_value is pd.NaT
+        assert pd.TimedeltaIndex([])._na_value is pd.NaT
+
+        idx = pd.TimedeltaIndex(['1 days', '2 days'])
+        assert idx._can_hold_na
+
+        tm.assert_numpy_array_equal(idx._isnan, np.array([False, False]))
+        assert idx.hasnans is False
+        tm.assert_numpy_array_equal(idx._nan_idxs,
+                                    np.array([], dtype=np.intp))
+
+        idx = pd.TimedeltaIndex(['1 days', 'NaT'])
+        assert idx._can_hold_na
+
+        tm.assert_numpy_array_equal(idx._isnan, np.array([False, True]))
+        assert idx.hasnans is True
+        tm.assert_numpy_array_equal(idx._nan_idxs,
+                                    np.array([1], dtype=np.intp))
+
+    def test_equals(self):
+        # GH 13107
+        idx = pd.TimedeltaIndex(['1 days', '2 days', 'NaT'])
+        assert idx.equals(idx)
+        assert idx.equals(idx.copy())
+        assert idx.equals(idx.astype(object))
+        assert idx.astype(object).equals(idx)
+        assert idx.astype(object).equals(idx.astype(object))
+        assert not idx.equals(list(idx))
+        assert not idx.equals(pd.Series(idx))
+
+        idx2 = pd.TimedeltaIndex(['2 days', '1 days', 'NaT'])
+        assert not idx.equals(idx2)
+        assert not idx.equals(idx2.copy())
+        assert not idx.equals(idx2.astype(object))
+        assert not idx.astype(object).equals(idx2)
+        assert not idx.astype(object).equals(idx2.astype(object))
+        assert not idx.equals(list(idx2))
+        assert not idx.equals(pd.Series(idx2))
+
+    @pytest.mark.parametrize('values', [['0 days', '2 days', '4 days'], []])
+    @pytest.mark.parametrize('freq', ['2D', Day(2), '48H', Hour(48)])
+    def test_freq_setter(self, values, freq):
+        # GH 20678
+        idx = TimedeltaIndex(values)
+
+        # can set to an offset, converting from string if necessary
+        idx.freq = freq
+        assert idx.freq == freq
+        assert isinstance(idx.freq, ABCDateOffset)
+
+        # can reset to None
+        idx.freq = None
+        assert idx.freq is None
+
+    def test_freq_setter_errors(self):
+        # GH 20678
+        idx = TimedeltaIndex(['0 days', '2 days', '4 days'])
+
+        # setting with an incompatible freq
+        msg = ('Inferred frequency 2D from passed values does not conform to '
+               'passed frequency 5D')
+        with pytest.raises(ValueError, match=msg):
+            idx.freq = '5D'
+
+        # setting with a non-fixed frequency
+        msg = r'<2 \* BusinessDays> is a non-fixed frequency'
+        with pytest.raises(ValueError, match=msg):
+            idx.freq = '2B'
+
+        # setting with non-freq string
+        with pytest.raises(ValueError, match='Invalid frequency'):
+            idx.freq = 'foo'

utils/venv/lib/python3.6/site-packages/pandas/tests/indexes/timedeltas/test_partial_slicing.py

@@ -0,0 +1,85 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Series, Timedelta, timedelta_range
+from pandas.util.testing import assert_series_equal
+
+
+class TestSlicing(object):
+    def test_slice_keeps_name(self):
+        # GH4226
+        dr = pd.timedelta_range('1d', '5d', freq='H', name='timebucket')
+        assert dr[1:].name == dr.name
+
+    def test_partial_slice(self):
+        rng = timedelta_range('1 day 10:11:12', freq='h', periods=500)
+        s = Series(np.arange(len(rng)), index=rng)
+
+        result = s['5 day':'6 day']
+        expected = s.iloc[86:134]
+        assert_series_equal(result, expected)
+
+        result = s['5 day':]
+        expected = s.iloc[86:]
+        assert_series_equal(result, expected)
+
+        result = s[:'6 day']
+        expected = s.iloc[:134]
+        assert_series_equal(result, expected)
+
+        result = s['6 days, 23:11:12']
+        assert result == s.iloc[133]
+
+        pytest.raises(KeyError, s.__getitem__, '50 days')
+
+    def test_partial_slice_high_reso(self):
+
+        # higher reso
+        rng = timedelta_range('1 day 10:11:12', freq='us', periods=2000)
+        s = Series(np.arange(len(rng)), index=rng)
+
+        result = s['1 day 10:11:12':]
+        expected = s.iloc[0:]
+        assert_series_equal(result, expected)
+
+        result = s['1 day 10:11:12.001':]
+        expected = s.iloc[1000:]
+        assert_series_equal(result, expected)
+
+        result = s['1 days, 10:11:12.001001']
+        assert result == s.iloc[1001]
+
+    def test_slice_with_negative_step(self):
+        ts = Series(np.arange(20), timedelta_range('0', periods=20, freq='H'))
+        SLC = pd.IndexSlice
+
+        def assert_slices_equivalent(l_slc, i_slc):
+            assert_series_equal(ts[l_slc], ts.iloc[i_slc])
+            assert_series_equal(ts.loc[l_slc], ts.iloc[i_slc])
+            assert_series_equal(ts.loc[l_slc], ts.iloc[i_slc])
+
+        assert_slices_equivalent(SLC[Timedelta(hours=7)::-1], SLC[7::-1])
+        assert_slices_equivalent(SLC['7 hours'::-1], SLC[7::-1])
+
+        assert_slices_equivalent(SLC[:Timedelta(hours=7):-1], SLC[:6:-1])
+        assert_slices_equivalent(SLC[:'7 hours':-1], SLC[:6:-1])
+
+        assert_slices_equivalent(SLC['15 hours':'7 hours':-1], SLC[15:6:-1])
+        assert_slices_equivalent(SLC[Timedelta(hours=15):Timedelta(hours=7):-
+                                     1], SLC[15:6:-1])
+        assert_slices_equivalent(SLC['15 hours':Timedelta(hours=7):-1],
+                                 SLC[15:6:-1])
+        assert_slices_equivalent(SLC[Timedelta(hours=15):'7 hours':-1],
+                                 SLC[15:6:-1])
+
+        assert_slices_equivalent(SLC['7 hours':'15 hours':-1], SLC[:0])
+
+    def test_slice_with_zero_step_raises(self):
+        ts = Series(np.arange(20), timedelta_range('0', periods=20, freq='H'))
+        with pytest.raises(ValueError, match='slice step cannot be zero'):
+            ts[::0]
+        with pytest.raises(ValueError, match='slice step cannot be zero'):
+            ts.loc[::0]
+        with pytest.raises(ValueError, match='slice step cannot be zero'):
+            ts.loc[::0]

utils/venv/lib/python3.6/site-packages/pandas/tests/indexes/timedeltas/test_scalar_compat.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+"""
+Tests for TimedeltaIndex methods behaving like their Timedelta counterparts
+"""
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import Index, Series, Timedelta, TimedeltaIndex, timedelta_range
+import pandas.util.testing as tm
+
+
+class TestVectorizedTimedelta(object):
+    def test_tdi_total_seconds(self):
+        # GH#10939
+        # test index
+        rng = timedelta_range('1 days, 10:11:12.100123456', periods=2,
+                              freq='s')
+        expt = [1 * 86400 + 10 * 3600 + 11 * 60 + 12 + 100123456. / 1e9,
+                1 * 86400 + 10 * 3600 + 11 * 60 + 13 + 100123456. / 1e9]
+        tm.assert_almost_equal(rng.total_seconds(), Index(expt))
+
+        # test Series
+        ser = Series(rng)
+        s_expt = Series(expt, index=[0, 1])
+        tm.assert_series_equal(ser.dt.total_seconds(), s_expt)
+
+        # with nat
+        ser[1] = np.nan
+        s_expt = Series([1 * 86400 + 10 * 3600 + 11 * 60 +
+                         12 + 100123456. / 1e9, np.nan], index=[0, 1])
+        tm.assert_series_equal(ser.dt.total_seconds(), s_expt)
+
+        # with both nat
+        ser = Series([np.nan, np.nan], dtype='timedelta64[ns]')
+        tm.assert_series_equal(ser.dt.total_seconds(),
+                               Series([np.nan, np.nan], index=[0, 1]))
+
+    def test_tdi_round(self):
+        td = pd.timedelta_range(start='16801 days', periods=5, freq='30Min')
+        elt = td[1]
+
+        expected_rng = TimedeltaIndex([Timedelta('16801 days 00:00:00'),
+                                       Timedelta('16801 days 00:00:00'),
+                                       Timedelta('16801 days 01:00:00'),
+                                       Timedelta('16801 days 02:00:00'),
+                                       Timedelta('16801 days 02:00:00')])
+        expected_elt = expected_rng[1]
+
+        tm.assert_index_equal(td.round(freq='H'), expected_rng)
+        assert elt.round(freq='H') == expected_elt
+
+        msg = pd._libs.tslibs.frequencies.INVALID_FREQ_ERR_MSG
+        with pytest.raises(ValueError, match=msg):
+            td.round(freq='foo')
+        with pytest.raises(ValueError, match=msg):
+            elt.round(freq='foo')
+
+        msg = "<MonthEnd> is a non-fixed frequency"
+        with pytest.raises(ValueError, match=msg):
+            td.round(freq='M')
+        with pytest.raises(ValueError, match=msg):
+            elt.round(freq='M')

utils/venv/lib/python3.6/site-packages/pandas/tests/indexes/timedeltas/test_setops.py

@@ -0,0 +1,75 @@
+import numpy as np
+
+import pandas as pd
+from pandas import Int64Index, TimedeltaIndex, timedelta_range
+import pandas.util.testing as tm
+
+
+class TestTimedeltaIndex(object):
+
+    def test_union(self):
+
+        i1 = timedelta_range('1day', periods=5)
+        i2 = timedelta_range('3day', periods=5)
+        result = i1.union(i2)
+        expected = timedelta_range('1day', periods=7)
+        tm.assert_index_equal(result, expected)
+
+        i1 = Int64Index(np.arange(0, 20, 2))
+        i2 = timedelta_range(start='1 day', periods=10, freq='D')
+        i1.union(i2)  # Works
+        i2.union(i1)  # Fails with "AttributeError: can't set attribute"
+
+    def test_union_coverage(self):
+
+        idx = TimedeltaIndex(['3d', '1d', '2d'])
+        ordered = TimedeltaIndex(idx.sort_values(), freq='infer')
+        result = ordered.union(idx)
+        tm.assert_index_equal(result, ordered)
+
+        result = ordered[:0].union(ordered)
+        tm.assert_index_equal(result, ordered)
+        assert result.freq == ordered.freq
+
+    def test_union_bug_1730(self):
+
+        rng_a = timedelta_range('1 day', periods=4, freq='3H')
+        rng_b = timedelta_range('1 day', periods=4, freq='4H')
+
+        result = rng_a.union(rng_b)
+        exp = TimedeltaIndex(sorted(set(list(rng_a)) | set(list(rng_b))))
+        tm.assert_index_equal(result, exp)
+
+    def test_union_bug_1745(self):
+
+        left = TimedeltaIndex(['1 day 15:19:49.695000'])
+        right = TimedeltaIndex(['2 day 13:04:21.322000',
+                                '1 day 15:27:24.873000',
+                                '1 day 15:31:05.350000'])
+
+        result = left.union(right)
+        exp = TimedeltaIndex(sorted(set(list(left)) | set(list(right))))
+        tm.assert_index_equal(result, exp)
+
+    def test_union_bug_4564(self):
+
+        left = timedelta_range("1 day", "30d")
+        right = left + pd.offsets.Minute(15)
+
+        result = left.union(right)
+        exp = TimedeltaIndex(sorted(set(list(left)) | set(list(right))))
+        tm.assert_index_equal(result, exp)
+
+    def test_intersection_bug_1708(self):
+        index_1 = timedelta_range('1 day', periods=4, freq='h')
+        index_2 = index_1 + pd.offsets.Hour(5)
+
+        result = index_1 & index_2
+        assert len(result) == 0
+
+        index_1 = timedelta_range('1 day', periods=4, freq='h')
+        index_2 = index_1 + pd.offsets.Hour(1)
+
+        result = index_1 & index_2
+        expected = timedelta_range('1 day 01:00:00', periods=3, freq='h')
+        tm.assert_index_equal(result, expected)

utils/venv/lib/python3.6/site-packages/pandas/tests/indexes/timedeltas/test_timedelta.py

@@ -0,0 +1,335 @@
+from datetime import timedelta
+
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import (
+    DataFrame, Index, Int64Index, Series, Timedelta, TimedeltaIndex,
+    date_range, timedelta_range)
+import pandas.util.testing as tm
+from pandas.util.testing import (
+    assert_almost_equal, assert_index_equal, assert_series_equal)
+
+from ..datetimelike import DatetimeLike
+
+randn = np.random.randn
+
+
+class TestTimedeltaIndex(DatetimeLike):
+    _holder = TimedeltaIndex
+
+    def setup_method(self, method):
+        self.indices = dict(index=tm.makeTimedeltaIndex(10))
+        self.setup_indices()
+
+    def create_index(self):
+        return pd.to_timedelta(range(5), unit='d') + pd.offsets.Hour(1)
+
+    def test_numeric_compat(self):
+        # Dummy method to override super's version; this test is now done
+        # in test_arithmetic.py
+        pass
+
+    def test_shift(self):
+        pass  # this is handled in test_arithmetic.py
+
+    def test_pickle_compat_construction(self):
+        pass
+
+    def test_fillna_timedelta(self):
+        # GH 11343
+        idx = pd.TimedeltaIndex(['1 day', pd.NaT, '3 day'])
+
+        exp = pd.TimedeltaIndex(['1 day', '2 day', '3 day'])
+        tm.assert_index_equal(idx.fillna(pd.Timedelta('2 day')), exp)
+
+        exp = pd.TimedeltaIndex(['1 day', '3 hour', '3 day'])
+        idx.fillna(pd.Timedelta('3 hour'))
+
+        exp = pd.Index(
+            [pd.Timedelta('1 day'), 'x', pd.Timedelta('3 day')], dtype=object)
+        tm.assert_index_equal(idx.fillna('x'), exp)
+
+    @pytest.mark.parametrize("sort", [True, False])
+    def test_difference_freq(self, sort):
+        # GH14323: Difference of TimedeltaIndex should not preserve frequency
+
+        index = timedelta_range("0 days", "5 days", freq="D")
+
+        other = timedelta_range("1 days", "4 days", freq="D")
+        expected = TimedeltaIndex(["0 days", "5 days"], freq=None)
+        idx_diff = index.difference(other, sort)
+        tm.assert_index_equal(idx_diff, expected)
+        tm.assert_attr_equal('freq', idx_diff, expected)
+
+        other = timedelta_range("2 days", "5 days", freq="D")
+        idx_diff = index.difference(other, sort)
+        expected = TimedeltaIndex(["0 days", "1 days"], freq=None)
+        tm.assert_index_equal(idx_diff, expected)
+        tm.assert_attr_equal('freq', idx_diff, expected)
+
+    @pytest.mark.parametrize("sort", [True, False])
+    def test_difference_sort(self, sort):
+
+        index = pd.TimedeltaIndex(["5 days", "3 days", "2 days", "4 days",
+                                   "1 days", "0 days"])
+
+        other = timedelta_range("1 days", "4 days", freq="D")
+        idx_diff = index.difference(other, sort)
+
+        expected = TimedeltaIndex(["5 days", "0 days"], freq=None)
+
+        if sort:
+            expected = expected.sort_values()
+
+        tm.assert_index_equal(idx_diff, expected)
+        tm.assert_attr_equal('freq', idx_diff, expected)
+
+        other = timedelta_range("2 days", "5 days", freq="D")
+        idx_diff = index.difference(other, sort)
+        expected = TimedeltaIndex(["1 days", "0 days"], freq=None)
+
+        if sort:
+            expected = expected.sort_values()
+
+        tm.assert_index_equal(idx_diff, expected)
+        tm.assert_attr_equal('freq', idx_diff, expected)
+
+    def test_isin(self):
+
+        index = tm.makeTimedeltaIndex(4)
+        result = index.isin(index)
+        assert result.all()
+
+        result = index.isin(list(index))
+        assert result.all()
+
+        assert_almost_equal(index.isin([index[2], 5]),
+                            np.array([False, False, True, False]))
+
+    def test_factorize(self):
+        idx1 = TimedeltaIndex(['1 day', '1 day', '2 day', '2 day', '3 day',
+                               '3 day'])
+
+        exp_arr = np.array([0, 0, 1, 1, 2, 2], dtype=np.intp)
+        exp_idx = TimedeltaIndex(['1 day', '2 day', '3 day'])
+
+        arr, idx = idx1.factorize()
+        tm.assert_numpy_array_equal(arr, exp_arr)
+        tm.assert_index_equal(idx, exp_idx)
+
+        arr, idx = idx1.factorize(sort=True)
+        tm.assert_numpy_array_equal(arr, exp_arr)
+        tm.assert_index_equal(idx, exp_idx)
+
+        # freq must be preserved
+        idx3 = timedelta_range('1 day', periods=4, freq='s')
+        exp_arr = np.array([0, 1, 2, 3], dtype=np.intp)
+        arr, idx = idx3.factorize()
+        tm.assert_numpy_array_equal(arr, exp_arr)
+        tm.assert_index_equal(idx, idx3)
+
+    def test_join_self(self, join_type):
+        index = timedelta_range('1 day', periods=10)
+        joined = index.join(index, how=join_type)
+        tm.assert_index_equal(index, joined)
+
+    def test_does_not_convert_mixed_integer(self):
+        df = tm.makeCustomDataframe(10, 10,
+                                    data_gen_f=lambda *args, **kwargs: randn(),
+                                    r_idx_type='i', c_idx_type='td')
+        str(df)
+
+        cols = df.columns.join(df.index, how='outer')
+        joined = cols.join(df.columns)
+        assert cols.dtype == np.dtype('O')
+        assert cols.dtype == joined.dtype
+        tm.assert_index_equal(cols, joined)
+
+    def test_sort_values(self):
+
+        idx = TimedeltaIndex(['4d', '1d', '2d'])
+
+        ordered = idx.sort_values()
+        assert ordered.is_monotonic
+
+        ordered = idx.sort_values(ascending=False)
+        assert ordered[::-1].is_monotonic
+
+        ordered, dexer = idx.sort_values(return_indexer=True)
+        assert ordered.is_monotonic
+
+        tm.assert_numpy_array_equal(dexer, np.array([1, 2, 0]),
+                                    check_dtype=False)
+
+        ordered, dexer = idx.sort_values(return_indexer=True, ascending=False)
+        assert ordered[::-1].is_monotonic
+
+        tm.assert_numpy_array_equal(dexer, np.array([0, 2, 1]),
+                                    check_dtype=False)
+
+    def test_get_duplicates(self):
+        idx = TimedeltaIndex(['1 day', '2 day', '2 day', '3 day', '3day',
+                              '4day'])
+
+        with tm.assert_produces_warning(FutureWarning):
+            # Deprecated - see GH20239
+            result = idx.get_duplicates()
+
+        ex = TimedeltaIndex(['2 day', '3day'])
+        tm.assert_index_equal(result, ex)
+
+    def test_argmin_argmax(self):
+        idx = TimedeltaIndex(['1 day 00:00:05', '1 day 00:00:01',
+                              '1 day 00:00:02'])
+        assert idx.argmin() == 1
+        assert idx.argmax() == 0
+
+    def test_misc_coverage(self):
+
+        rng = timedelta_range('1 day', periods=5)
+        result = rng.groupby(rng.days)
+        assert isinstance(list(result.values())[0][0], Timedelta)
+
+        idx = TimedeltaIndex(['3d', '1d', '2d'])
+        assert not idx.equals(list(idx))
+
+        non_td = Index(list('abc'))
+        assert not idx.equals(list(non_td))
+
+    def test_map(self):
+        # test_map_dictlike generally tests
+
+        rng = timedelta_range('1 day', periods=10)
+
+        f = lambda x: x.days
+        result = rng.map(f)
+        exp = Int64Index([f(x) for x in rng])
+        tm.assert_index_equal(result, exp)
+
+    def test_pass_TimedeltaIndex_to_index(self):
+
+        rng = timedelta_range('1 days', '10 days')
+        idx = Index(rng, dtype=object)
+
+        expected = Index(rng.to_pytimedelta(), dtype=object)
+
+        tm.assert_numpy_array_equal(idx.values, expected.values)
+
+    def test_pickle(self):
+
+        rng = timedelta_range('1 days', periods=10)
+        rng_p = tm.round_trip_pickle(rng)
+        tm.assert_index_equal(rng, rng_p)
+
+    def test_hash_error(self):
+        index = timedelta_range('1 days', periods=10)
+        with pytest.raises(TypeError, match=("unhashable type: %r" %
+                                             type(index).__name__)):
+            hash(index)
+
+    def test_append_join_nondatetimeindex(self):
+        rng = timedelta_range('1 days', periods=10)
+        idx = Index(['a', 'b', 'c', 'd'])
+
+        result = rng.append(idx)
+        assert isinstance(result[0], Timedelta)
+
+        # it works
+        rng.join(idx, how='outer')
+
+    def test_append_numpy_bug_1681(self):
+
+        td = timedelta_range('1 days', '10 days', freq='2D')
+        a = DataFrame()
+        c = DataFrame({'A': 'foo', 'B': td}, index=td)
+        str(c)
+
+        result = a.append(c)
+        assert (result['B'] == td).all()
+
+    def test_fields(self):
+        rng = timedelta_range('1 days, 10:11:12.100123456', periods=2,
+                              freq='s')
+        tm.assert_index_equal(rng.days, Index([1, 1], dtype='int64'))
+        tm.assert_index_equal(
+            rng.seconds,
+            Index([10 * 3600 + 11 * 60 + 12, 10 * 3600 + 11 * 60 + 13],
+                  dtype='int64'))
+        tm.assert_index_equal(
+            rng.microseconds,
+            Index([100 * 1000 + 123, 100 * 1000 + 123], dtype='int64'))
+        tm.assert_index_equal(rng.nanoseconds,
+                              Index([456, 456], dtype='int64'))
+
+        pytest.raises(AttributeError, lambda: rng.hours)
+        pytest.raises(AttributeError, lambda: rng.minutes)
+        pytest.raises(AttributeError, lambda: rng.milliseconds)
+
+        # with nat
+        s = Series(rng)
+        s[1] = np.nan
+
+        tm.assert_series_equal(s.dt.days, Series([1, np.nan], index=[0, 1]))
+        tm.assert_series_equal(s.dt.seconds, Series(
+            [10 * 3600 + 11 * 60 + 12, np.nan], index=[0, 1]))
+
+        # preserve name (GH15589)
+        rng.name = 'name'
+        assert rng.days.name == 'name'
+
+    def test_freq_conversion(self):
+
+        # doc example
+
+        # series
+        td = Series(date_range('20130101', periods=4)) - \
+            Series(date_range('20121201', periods=4))
+        td[2] += timedelta(minutes=5, seconds=3)
+        td[3] = np.nan
+
+        result = td / np.timedelta64(1, 'D')
+        expected = Series([31, 31, (31 * 86400 + 5 * 60 + 3) / 86400.0, np.nan
+                           ])
+        assert_series_equal(result, expected)
+
+        result = td.astype('timedelta64[D]')
+        expected = Series([31, 31, 31, np.nan])
+        assert_series_equal(result, expected)
+
+        result = td / np.timedelta64(1, 's')
+        expected = Series([31 * 86400, 31 * 86400, 31 * 86400 + 5 * 60 + 3,
+                           np.nan])
+        assert_series_equal(result, expected)
+
+        result = td.astype('timedelta64[s]')
+        assert_series_equal(result, expected)
+
+        # tdi
+        td = TimedeltaIndex(td)
+
+        result = td / np.timedelta64(1, 'D')
+        expected = Index([31, 31, (31 * 86400 + 5 * 60 + 3) / 86400.0, np.nan])
+        assert_index_equal(result, expected)
+
+        result = td.astype('timedelta64[D]')
+        expected = Index([31, 31, 31, np.nan])
+        assert_index_equal(result, expected)
+
+        result = td / np.timedelta64(1, 's')
+        expected = Index([31 * 86400, 31 * 86400, 31 * 86400 + 5 * 60 + 3,
+                          np.nan])
+        assert_index_equal(result, expected)
+
+        result = td.astype('timedelta64[s]')
+        assert_index_equal(result, expected)
+
+
+class TestTimeSeries(object):
+
+    def test_series_box_timedelta(self):
+        rng = timedelta_range('1 day 1 s', periods=5, freq='h')
+        s = Series(rng)
+        assert isinstance(s[1], Timedelta)
+        assert isinstance(s.iat[2], Timedelta)

utils/venv/lib/python3.6/site-packages/pandas/tests/indexes/timedeltas/test_timedelta_range.py

@@ -0,0 +1,79 @@
+import numpy as np
+import pytest
+
+import pandas as pd
+from pandas import timedelta_range, to_timedelta
+import pandas.util.testing as tm
+
+from pandas.tseries.offsets import Day, Second
+
+
+class TestTimedeltas(object):
+
+    def test_timedelta_range(self):
+
+        expected = to_timedelta(np.arange(5), unit='D')
+        result = timedelta_range('0 days', periods=5, freq='D')
+        tm.assert_index_equal(result, expected)
+
+        expected = to_timedelta(np.arange(11), unit='D')
+        result = timedelta_range('0 days', '10 days', freq='D')
+        tm.assert_index_equal(result, expected)
+
+        expected = to_timedelta(np.arange(5), unit='D') + Second(2) + Day()
+        result = timedelta_range('1 days, 00:00:02', '5 days, 00:00:02',
+                                 freq='D')
+        tm.assert_index_equal(result, expected)
+
+        expected = to_timedelta([1, 3, 5, 7, 9], unit='D') + Second(2)
+        result = timedelta_range('1 days, 00:00:02', periods=5, freq='2D')
+        tm.assert_index_equal(result, expected)
+
+        expected = to_timedelta(np.arange(50), unit='T') * 30
+        result = timedelta_range('0 days', freq='30T', periods=50)
+        tm.assert_index_equal(result, expected)
+
+        # GH 11776
+        arr = np.arange(10).reshape(2, 5)
+        df = pd.DataFrame(np.arange(10).reshape(2, 5))
+        for arg in (arr, df):
+            with pytest.raises(TypeError, match="1-d array"):
+                to_timedelta(arg)
+            for errors in ['ignore', 'raise', 'coerce']:
+                with pytest.raises(TypeError, match="1-d array"):
+                    to_timedelta(arg, errors=errors)
+
+        # issue10583
+        df = pd.DataFrame(np.random.normal(size=(10, 4)))
+        df.index = pd.timedelta_range(start='0s', periods=10, freq='s')
+        expected = df.loc[pd.Timedelta('0s'):, :]
+        result = df.loc['0s':, :]
+        tm.assert_frame_equal(expected, result)
+
+    @pytest.mark.parametrize('periods, freq', [
+        (3, '2D'), (5, 'D'), (6, '19H12T'), (7, '16H'), (9, '12H')])
+    def test_linspace_behavior(self, periods, freq):
+        # GH 20976
+        result = timedelta_range(start='0 days', end='4 days', periods=periods)
+        expected = timedelta_range(start='0 days', end='4 days', freq=freq)
+        tm.assert_index_equal(result, expected)
+
+    def test_errors(self):
+        # not enough params
+        msg = ('Of the four parameters: start, end, periods, and freq, '
+               'exactly three must be specified')
+        with pytest.raises(ValueError, match=msg):
+            timedelta_range(start='0 days')
+
+        with pytest.raises(ValueError, match=msg):
+            timedelta_range(end='5 days')
+
+        with pytest.raises(ValueError, match=msg):
+            timedelta_range(periods=2)
+
+        with pytest.raises(ValueError, match=msg):
+            timedelta_range()
+
+        # too many params
+        with pytest.raises(ValueError, match=msg):
+            timedelta_range(start='0 days', end='5 days', periods=10, freq='H')

utils/venv/lib/python3.6/site-packages/pandas/tests/indexes/timedeltas/test_tools.py

@@ -0,0 +1,175 @@
+from datetime import time, timedelta
+
+import numpy as np
+import pytest
+
+from pandas._libs.tslib import iNaT
+
+import pandas as pd
+from pandas import Series, TimedeltaIndex, isna, to_timedelta
+import pandas.util.testing as tm
+from pandas.util.testing import assert_series_equal
+
+
+class TestTimedeltas(object):
+
+    def test_to_timedelta(self):
+        def conv(v):
+            return v.astype('m8[ns]')
+
+        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')))
+
+        # empty string
+        result = to_timedelta('', box=False)
+        assert result.astype('int64') == iNaT
+
+        result = to_timedelta(['', ''])
+        assert isna(result).all()
+
+        # pass thru
+        result = to_timedelta(np.array([np.timedelta64(1, 's')]))
+        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
+
+        # Series
+        expected = Series([timedelta(days=1), timedelta(days=1, seconds=1)])
+        result = to_timedelta(Series(['1d', '1days 00:00:01']))
+        tm.assert_series_equal(result, expected)
+
+        # with units
+        result = TimedeltaIndex([np.timedelta64(0, 'ns'), np.timedelta64(
+            10, 's').astype('m8[ns]')])
+        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
+
+        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')
+        result = to_timedelta(arr, unit='s')
+        expected = TimedeltaIndex([np.timedelta64(1, 's')] * 5)
+        tm.assert_index_equal(result, expected)
+
+        arr = np.array([1] * 5, dtype='int64')
+        result = to_timedelta(arr, unit='m')
+        expected = TimedeltaIndex([np.timedelta64(1, 'm')] * 5)
+        tm.assert_index_equal(result, expected)
+
+        arr = np.array([1] * 5, dtype='int64')
+        result = to_timedelta(arr, unit='h')
+        expected = TimedeltaIndex([np.timedelta64(1, 'h')] * 5)
+        tm.assert_index_equal(result, expected)
+
+        arr = np.array([1] * 5, dtype='timedelta64[s]')
+        result = to_timedelta(arr)
+        expected = TimedeltaIndex([np.timedelta64(1, 's')] * 5)
+        tm.assert_index_equal(result, expected)
+
+        arr = np.array([1] * 5, dtype='timedelta64[D]')
+        result = to_timedelta(arr)
+        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)
+
+        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)
+
+        # 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):
+
+        # bad value for errors parameter
+        msg = "errors must be one of"
+        with pytest.raises(ValueError, match=msg):
+            to_timedelta(['foo'], errors='never')
+
+        # these will error
+        pytest.raises(ValueError, lambda: to_timedelta([1, 2], unit='foo'))
+        pytest.raises(ValueError, lambda: to_timedelta(1, unit='foo'))
+
+        # time not supported ATM
+        pytest.raises(ValueError, lambda: to_timedelta(time(second=1)))
+        assert to_timedelta(time(second=1), errors='coerce') is pd.NaT
+
+        pytest.raises(ValueError, lambda: to_timedelta(['foo', 'bar']))
+        tm.assert_index_equal(TimedeltaIndex([pd.NaT, pd.NaT]),
+                              to_timedelta(['foo', 'bar'], errors='coerce'))
+
+        tm.assert_index_equal(TimedeltaIndex(['1 day', pd.NaT, '1 min']),
+                              to_timedelta(['1 day', 'bar', '1 min'],
+                                           errors='coerce'))
+
+        # gh-13613: these should not error because errors='ignore'
+        invalid_data = 'apple'
+        assert invalid_data == to_timedelta(invalid_data, errors='ignore')
+
+        invalid_data = ['apple', '1 days']
+        tm.assert_numpy_array_equal(
+            np.array(invalid_data, dtype=object),
+            to_timedelta(invalid_data, errors='ignore'))
+
+        invalid_data = pd.Index(['apple', '1 days'])
+        tm.assert_index_equal(invalid_data, to_timedelta(
+            invalid_data, errors='ignore'))
+
+        invalid_data = Series(['apple', '1 days'])
+        tm.assert_series_equal(invalid_data, to_timedelta(
+            invalid_data, errors='ignore'))
+
+    def test_to_timedelta_via_apply(self):
+        # GH 5458
+        expected = Series([np.timedelta64(1, 's')])
+        result = Series(['00:00:01']).apply(to_timedelta)
+        tm.assert_series_equal(result, expected)
+
+        result = Series([to_timedelta('00:00:01')])
+        tm.assert_series_equal(result, expected)
+
+    def test_to_timedelta_on_missing_values(self):
+        # GH5438
+        timedelta_NaT = np.timedelta64('NaT')
+
+        actual = pd.to_timedelta(Series(['00:00:01', np.nan]))
+        expected = Series([np.timedelta64(1000000000, 'ns'),
+                           timedelta_NaT], dtype='<m8[ns]')
+        assert_series_equal(actual, expected)
+
+        actual = pd.to_timedelta(Series(['00:00:01', pd.NaT]))
+        assert_series_equal(actual, expected)
+
+        actual = pd.to_timedelta(np.nan)
+        assert actual.value == timedelta_NaT.astype('int64')
+
+        actual = pd.to_timedelta(pd.NaT)
+        assert actual.value == timedelta_NaT.astype('int64')