BUG: Avoid rounding when specifying unit and integer

Add tests

Add whatsnew

flake8

Add aditional formatting

remove tabs

address review

Author: mroeschke

doc/source/whatsnew/v0.23.0.txt

@@ -817,7 +817,8 @@ Timedelta
 - Bug in :func:`Timedelta.total_seconds()` causing precision errors i.e. ``Timedelta('30S').total_seconds()==30.000000000000004`` (:issue:`19458`)
 - Bug in :func: `Timedelta.__rmod__` where operating with a ``numpy.timedelta64`` returned a ``timedelta64`` object instead of a ``Timedelta`` (:issue:`19820`)
 - Multiplication of :class:`TimedeltaIndex` by ``TimedeltaIndex`` will now raise ``TypeError`` instead of raising ``ValueError`` in cases of length mis-match (:issue`19333`)
--
+- Bug in :class:`Timedelta`: where a numerical value with a unit would round values (:issue: `12690`)
+
 
 Timezones
 ^^^^^^^^^

pandas/_libs/tslibs/timedeltas.pyx

@@ -200,22 +200,22 @@ cpdef inline int64_t cast_from_unit(object ts, object unit) except? -1:
 
     if unit == 'D' or unit == 'd':
         m = 1000000000L * 86400
-        p = 6
+        p = 9
     elif unit == 'h':
         m = 1000000000L * 3600
-        p = 6
+        p = 9
     elif unit == 'm':
         m = 1000000000L * 60
-        p = 6
+        p = 9
     elif unit == 's':
         m = 1000000000L
-        p = 6
+        p = 9
     elif unit == 'ms':
         m = 1000000L
-        p = 3
+        p = 6
     elif unit == 'us':
         m = 1000L
-        p = 0
+        p = 3
     elif unit == 'ns' or unit is None:
         m = 1L
         p = 0
@@ -229,10 +229,10 @@ cpdef inline int64_t cast_from_unit(object ts, object unit) except? -1:
     # cast the unit, multiply base/frace separately
     # to avoid precision issues from float -> int
     base = <int64_t> ts
-    frac = ts -base
+    frac = ts - base
     if p:
         frac = round(frac, p)
-    return <int64_t> (base *m) + <int64_t> (frac *m)
+    return <int64_t> (base * m) + <int64_t> (frac * m)
 
 
 cdef inline _decode_if_necessary(object ts):

pandas/tests/scalar/timedelta/test_timedelta.py

@@ -94,6 +94,174 @@ def test_compare_timedelta_ndarray(self):
 
 class TestTimedeltas(object):
 
+    def setup_method(self, method):
+        pass
+
+    def test_construction(self):
+
+        expected = np.timedelta64(10, 'D').astype('m8[ns]').view('i8')
+        assert Timedelta(10, unit='d').value == expected
+        assert Timedelta(10.0, unit='d').value == expected
+        assert Timedelta('10 days').value == expected
+        assert Timedelta(days=10).value == expected
+        assert Timedelta(days=10.0).value == expected
+
+        expected += np.timedelta64(10, 's').astype('m8[ns]').view('i8')
+        assert Timedelta('10 days 00:00:10').value == expected
+        assert Timedelta(days=10, seconds=10).value == expected
+        assert Timedelta(days=10, milliseconds=10 * 1000).value == expected
+        assert (Timedelta(days=10, microseconds=10 * 1000 * 1000)
+                .value == expected)
+
+        # gh-8757: test construction with np dtypes
+        timedelta_kwargs = {'days': 'D',
+                            'seconds': 's',
+                            'microseconds': 'us',
+                            'milliseconds': 'ms',
+                            'minutes': 'm',
+                            'hours': 'h',
+                            'weeks': 'W'}
+        npdtypes = [np.int64, np.int32, np.int16, np.float64, np.float32,
+                    np.float16]
+        for npdtype in npdtypes:
+            for pykwarg, npkwarg in timedelta_kwargs.items():
+                expected = np.timedelta64(1, npkwarg).astype(
+                    'm8[ns]').view('i8')
+                assert Timedelta(**{pykwarg: npdtype(1)}).value == expected
+
+        # rounding cases
+        assert Timedelta(82739999850000).value == 82739999850000
+        assert ('0 days 22:58:59.999850' in str(Timedelta(82739999850000)))
+        assert Timedelta(123072001000000).value == 123072001000000
+        assert ('1 days 10:11:12.001' in str(Timedelta(123072001000000)))
+
+        # string conversion with/without leading zero
+        # GH 9570
+        assert Timedelta('0:00:00') == timedelta(hours=0)
+        assert Timedelta('00:00:00') == timedelta(hours=0)
+        assert Timedelta('-1:00:00') == -timedelta(hours=1)
+        assert Timedelta('-01:00:00') == -timedelta(hours=1)
+
+        # more strings & abbrevs
+        # GH 8190
+        assert Timedelta('1 h') == timedelta(hours=1)
+        assert Timedelta('1 hour') == timedelta(hours=1)
+        assert Timedelta('1 hr') == timedelta(hours=1)
+        assert Timedelta('1 hours') == timedelta(hours=1)
+        assert Timedelta('-1 hours') == -timedelta(hours=1)
+        assert Timedelta('1 m') == timedelta(minutes=1)
+        assert Timedelta('1.5 m') == timedelta(seconds=90)
+        assert Timedelta('1 minute') == timedelta(minutes=1)
+        assert Timedelta('1 minutes') == timedelta(minutes=1)
+        assert Timedelta('1 s') == timedelta(seconds=1)
+        assert Timedelta('1 second') == timedelta(seconds=1)
+        assert Timedelta('1 seconds') == timedelta(seconds=1)
+        assert Timedelta('1 ms') == timedelta(milliseconds=1)
+        assert Timedelta('1 milli') == timedelta(milliseconds=1)
+        assert Timedelta('1 millisecond') == timedelta(milliseconds=1)
+        assert Timedelta('1 us') == timedelta(microseconds=1)
+        assert Timedelta('1 micros') == timedelta(microseconds=1)
+        assert Timedelta('1 microsecond') == timedelta(microseconds=1)
+        assert Timedelta('1.5 microsecond') == Timedelta('00:00:00.000001500')
+        assert Timedelta('1 ns') == Timedelta('00:00:00.000000001')
+        assert Timedelta('1 nano') == Timedelta('00:00:00.000000001')
+        assert Timedelta('1 nanosecond') == Timedelta('00:00:00.000000001')
+
+        # combos
+        assert Timedelta('10 days 1 hour') == timedelta(days=10, hours=1)
+        assert Timedelta('10 days 1 h') == timedelta(days=10, hours=1)
+        assert Timedelta('10 days 1 h 1m 1s') == timedelta(
+            days=10, hours=1, minutes=1, seconds=1)
+        assert Timedelta('-10 days 1 h 1m 1s') == -timedelta(
+            days=10, hours=1, minutes=1, seconds=1)
+        assert Timedelta('-10 days 1 h 1m 1s') == -timedelta(
+            days=10, hours=1, minutes=1, seconds=1)
+        assert Timedelta('-10 days 1 h 1m 1s 3us') == -timedelta(
+            days=10, hours=1, minutes=1, seconds=1, microseconds=3)
+        assert Timedelta('-10 days 1 h 1.5m 1s 3us'), -timedelta(
+            days=10, hours=1, minutes=1, seconds=31, microseconds=3)
+
+        # Currently invalid as it has a - on the hh:mm:dd part
+        # (only allowed on the days)
+        pytest.raises(ValueError,
+                      lambda: Timedelta('-10 days -1 h 1.5m 1s 3us'))
+
+        # only leading neg signs are allowed
+        pytest.raises(ValueError,
+                      lambda: Timedelta('10 days -1 h 1.5m 1s 3us'))
+
+        # no units specified
+        pytest.raises(ValueError, lambda: Timedelta('3.1415'))
+
+        # invalid construction
+        tm.assert_raises_regex(ValueError, "cannot construct a Timedelta",
+                               lambda: Timedelta())
+        tm.assert_raises_regex(ValueError,
+                               "unit abbreviation w/o a number",
+                               lambda: Timedelta('foo'))
+        tm.assert_raises_regex(ValueError,
+                               "cannot construct a Timedelta from the "
+                               "passed arguments, allowed keywords are ",
+                               lambda: Timedelta(day=10))
+
+        # round-trip both for string and value
+        for v in ['1s', '-1s', '1us', '-1us', '1 day', '-1 day',
+                  '-23:59:59.999999', '-1 days +23:59:59.999999', '-1ns',
+                  '1ns', '-23:59:59.999999999']:
+
+            td = Timedelta(v)
+            assert Timedelta(td.value) == td
+
+            # str does not normally display nanos
+            if not td.nanoseconds:
+                assert Timedelta(str(td)) == td
+            assert Timedelta(td._repr_base(format='all')) == td
+
+        # floats
+        expected = np.timedelta64(
+            10, 's').astype('m8[ns]').view('i8') + np.timedelta64(
+                500, 'ms').astype('m8[ns]').view('i8')
+        assert Timedelta(10.5, unit='s').value == expected
+
+        # offset
+        assert (to_timedelta(pd.offsets.Hour(2)) ==
+                Timedelta('0 days, 02:00:00'))
+        assert (Timedelta(pd.offsets.Hour(2)) ==
+                Timedelta('0 days, 02:00:00'))
+        assert (Timedelta(pd.offsets.Second(2)) ==
+                Timedelta('0 days, 00:00:02'))
+
+        # gh-11995: unicode
+        expected = Timedelta('1H')
+        result = pd.Timedelta(u'1H')
+        assert result == expected
+        assert (to_timedelta(pd.offsets.Hour(2)) ==
+                Timedelta(u'0 days, 02:00:00'))
+
+        pytest.raises(ValueError, lambda: Timedelta(u'foo bar'))
+
+    @pytest.mark.parametrize("unit, value, expected", [
+        ('us', 9.999, 9999), ('ms', 9.999999, 9999999),
+        ('s', 9.999999999, 9999999999)])
+    def test_rounding_on_int_unit_construction(self, unit, value, expected):
+        # GH 12690
+        result = Timedelta(value, unit=unit)
+        assert result.value == expected
+        result = Timedelta(str(value) + unit)
+        assert result.value == expected
+
+    def test_overflow_on_construction(self):
+        # xref https://github.com/statsmodels/statsmodels/issues/3374
+        value = pd.Timedelta('1day').value * 20169940
+        pytest.raises(OverflowError, pd.Timedelta, value)
+
+        # xref gh-17637
+        with pytest.raises(OverflowError):
+            pd.Timedelta(7 * 19999, unit='D')
+
+        with pytest.raises(OverflowError):
+            pd.Timedelta(timedelta(days=13 * 19999))
+
     def test_total_seconds_scalar(self):
         # see gh-10939
         rng = Timedelta('1 days, 10:11:12.100123456')