Minor fix

Author: pdnm

pandas/_libs/tslibs/timedeltas.pxd

@@ -2,6 +2,5 @@ from numpy cimport int64_t
 
 # Exposed for tslib, not intended for outside use.
 cpdef parse_timedelta_string(object ts, object specified_unit=*)
-cdef int64_t cast_from_unit(object ts, object unit) except? -1
 cpdef int64_t delta_to_nanoseconds(delta) except? -1
 cpdef convert_to_timedelta64(object ts, object unit=*)

pandas/_libs/tslibs/timedeltas.pyx

@@ -1,4 +1,5 @@
 import collections
+import warnings
 
 import cython
 
@@ -257,67 +258,6 @@ def array_to_timedelta64(object[:] values, unit=None, errors='raise'):
     return iresult.base  # .base to access underlying np.ndarray
 
 
-cdef inline int64_t cast_from_unit(object ts, object unit) except? -1:
-    """ return a casting of the unit represented to nanoseconds
-        round the fractional part of a float to our precision, p """
-    cdef:
-        int64_t m
-        int p
-
-    if unit == 'Y':
-        m = 1000000000L * 31556952
-        p = 9
-    elif unit == 'M':
-        m = 1000000000L * 2629746
-        p = 9
-    elif unit == 'W':
-        m = 1000000000L * DAY_SECONDS * 7
-        p = 9
-    elif unit == 'D' or unit == 'd':
-        m = 1000000000L * DAY_SECONDS
-        p = 9
-    elif unit == 'h':
-        m = 1000000000L * 3600
-        p = 9
-    elif unit == 'm':
-        m = 1000000000L * 60
-        p = 9
-    elif unit == 's':
-        m = 1000000000L
-        p = 9
-    elif unit == 'ms':
-        m = 1000000L
-        p = 6
-    elif unit == 'us':
-        m = 1000L
-        p = 3
-    elif unit == 'ns' or unit is None:
-        m = 1L
-        p = 0
-    else:
-        raise ValueError("cannot cast unit {unit}".format(unit=unit))
-
-    # just give me the unit back
-    if ts is None:
-        return m
-
-    # cast the unit, multiply base/frace separately
-    # to avoid precision issues from float -> int
-    base = <int64_t>ts
-    frac = ts - base
-    if p:
-        frac = round(frac, p)
-    return <int64_t>(base * m) + <int64_t>(frac * m)
-
-
-cdef inline _decode_if_necessary(object ts):
-    # decode ts if necessary
-    if not isinstance(ts, unicode) and not PY3:
-        ts = str(ts).decode('utf-8')
-
-    return ts
-
-
 cpdef inline parse_timedelta_string(object ts, specified_unit=None):
     """
     Parse a regular format timedelta string. Return an int64_t (in ns)

pandas/core/computation/pytables.py

@@ -200,7 +200,7 @@ def stringify(value):
                 v = v.tz_convert("UTC")
             return TermValue(v, v.value, kind)
         elif kind == "timedelta64" or kind == "timedelta":
-            v = Timedelta(v, unit="s").value
+            v = Timedelta(v).value
             return TermValue(int(v), v, kind)
         elif meta == "category":
             metadata = extract_array(self.metadata, extract_numpy=True)

pandas/core/tools/timedeltas.py

@@ -4,8 +4,9 @@
 
 import numpy as np
 
-from pandas._libs import tslibs
+from pandas._libs.tslibs import NaT
 from pandas._libs.tslibs.timedeltas import (
+    Timedelta,
     convert_to_timedelta64,
     parse_timedelta_string,
     parse_timedelta_unit,
@@ -115,19 +116,15 @@ def to_timedelta(arg, unit=None, box=True, errors='raise'):
 def _coerce_scalar_to_timedelta_type(r, unit=None, box=True, errors='raise'):
     """Convert string 'r' to a timedelta object."""
     try:
-        result = parse_timedelta_string(r, unit)
-        result = np.timedelta64(result)
-    except (ValueError, TypeError):
-        try:
-            result = convert_to_timedelta64(r, unit)
-        except ValueError:
-            if errors == 'raise':
-                raise
-            elif errors == 'ignore':
-                return r
-
-            # coerce
-            result = pd.NaT
+        result = Timedelta(r, unit)
+    except ValueError:
+        if errors == 'raise':
+            raise
+        elif errors == 'ignore':
+            return r
+
+        # coerce
+        result = NaT
 
     return result
 

pandas/tests/indexes/timedeltas/test_ops.py

@@ -180,8 +180,8 @@ def test_drop_duplicates(self, freq_sample, keep, expected, index):
 
     def test_infer_freq(self, freq_sample):
         # GH#11018
-        idx = pd.timedelta_range('1ns', freq=freq, periods=10)
-        result = pd.TimedeltaIndex(idx.asi8, freq='infer')
+        idx = pd.timedelta_range("1ns", freq=freq_sample, periods=10)
+        result = pd.TimedeltaIndex(idx.asi8, freq="infer")
         tm.assert_index_equal(idx, result)
         assert result.freq == freq_sample
 

pandas/tests/indexes/timedeltas/test_partial_slicing.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pytest
 
-from pandas import Series, timedelta_range
+from pandas import IndexSlice, Series, timedelta_range
 import pandas._testing as tm
 
 
@@ -44,40 +44,4 @@ def test_partial_slice_high_reso(self):
         tm.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('0ns', 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('0ns', 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]
+        assert result == s.iloc[1001]