ISO 8601 Duration Refactoring

Author: WillAyd

doc/source/timedeltas.rst

@@ -67,6 +67,7 @@ You can construct a ``Timedelta`` scalar through various arguments:
    pd.Timedelta('P0DT0H0M0.000000123S')
 
 .. versionadded:: 0.23.0
+
    Added constructor for `ISO 8601 Duration`_ strings
 
 :ref:`DateOffsets<timeseries.offsets>` (``Day, Hour, Minute, Second, Milli, Micro, Nano``) can also be used in construction.

pandas/_libs/tslibs/timedeltas.pyx

@@ -236,25 +236,6 @@ cpdef inline int64_t cast_from_unit(object ts, object unit) except? -1:
     return <int64_t> (base *m) + <int64_t> (frac *m)
 
 
-cpdef match_iso_format(object ts):
-    """
-    Match a provided string against an ISO 8601 pattern, providing a group for
-    each ``Timedelta`` component.
-    """
-    pater = re.compile(r"""P
-                       (?P<days>-?[0-9]*)DT
-                       (?P<hours>[0-9]{1,2})H
-                       (?P<minutes>[0-9]{1,2})M
-                       (?P<seconds>[0-9]{0,2})
-                       (\.
-                       (?P<milliseconds>[0-9]{0,3})
-                       (?P<microseconds>[0-9]{0,3})
-                       (?P<nanoseconds>[0-9]{0,3})
-                       )?S""", re.VERBOSE)
-
-    return re.match(pater, ts)
-
-
 cdef inline parse_timedelta_string(object ts):
     """
     Parse a regular format timedelta string. Return an int64_t (in ns)
@@ -526,31 +507,55 @@ def _binary_op_method_timedeltalike(op, name):
 # ----------------------------------------------------------------------
 # Timedelta Construction
 
-def _value_from_iso_match(match):
+iso_pater = re.compile(r"""P
+                        (?P<days>-?[0-9]*)DT
+                        (?P<hours>[0-9]{1,2})H
+                        (?P<minutes>[0-9]{1,2})M
+                        (?P<seconds>[0-9]{0,2})
+                        (\.
+                        (?P<milliseconds>[0-9]{1,3})
+                        (?P<microseconds>[0-9]{0,3})
+                        (?P<nanoseconds>[0-9]{0,3})
+                        )?S""", re.VERBOSE)
+
+
+cdef int64_t parse_iso_format_string(object iso_fmt) except? -1:
     """
     Extracts and cleanses the appropriate values from a match object with
     groups for each component of an ISO 8601 duration
 
     Parameters
     ----------
-    match:
-        Regular expression with groups for each component of an ISO 8601
-        duration
+    iso_fmt:
+        ISO 8601 Duration formatted string
 
     Returns
     -------
-    int
+    ns: int64_t
         Precision in nanoseconds of matched ISO 8601 duration
+
+    Raises
+    ------
+    ValueError
+        If ``iso_fmt`` cannot be parsed
     """
-    match_dict = {k: v for k, v in match.groupdict().items() if v}
-    for comp in ['milliseconds', 'microseconds', 'nanoseconds']:
-        if comp in match_dict:
-            match_dict[comp] ='{:0<3}'.format(match_dict[comp])
 
-    match_dict = {k: int(v) for k, v in match_dict.items()}
-    nano = match_dict.pop('nanoseconds', 0)
+    cdef int64_t ns = 0
+
+    match = re.match(iso_pater, iso_fmt)
+    if match:
+        match_dict = match.groupdict(default='0')
+        for comp in ['milliseconds', 'microseconds', 'nanoseconds']:
+            match_dict[comp] = '{:0<3}'.format(match_dict[comp])
+
+        for k, v in match_dict.items():
+            ns += timedelta_from_spec(v, '0', k)
+
+    else:
+        raise ValueError("Invalid ISO 8601 Duration format - "
+                         "{}".format(iso_fmt))
 
-    return nano + convert_to_timedelta64(timedelta(**match_dict), 'ns')
+    return ns
 
 
 cdef _to_py_int_float(v):
@@ -872,11 +877,11 @@ class Timedelta(_Timedelta):
         if isinstance(value, Timedelta):
             value = value.value
         elif is_string_object(value):
-            if len(value) > 0 and value[0] == 'P':  # hackish
-                match = match_iso_format(value)
-                value = _value_from_iso_match(match)
+            if len(value) > 0 and value[0] == 'P':
+                value = parse_iso_format_string(value)
             else:
-                value = np.timedelta64(parse_timedelta_string(value))
+                value = parse_timedelta_string(value)
+            value = np.timedelta64(value)
         elif PyDelta_Check(value):
             value = convert_to_timedelta64(value, 'ns')
         elif is_timedelta64_object(value):

pandas/tests/scalar/test_timedelta.py

@@ -865,6 +865,17 @@ def test_isoformat(self):
         ('P0DT0H0M0.000000123S', Timedelta(nanoseconds=123)),
         ('P0DT0H0M0.00001S', Timedelta(microseconds=10)),
         ('P0DT0H0M0.001S', Timedelta(milliseconds=1)),
-        ('P0DT0H1M0S', Timedelta(minutes=1))])
+        ('P0DT0H1M0S', Timedelta(minutes=1)),
+        ('P1DT25H61M61S', Timedelta(days=1, hours=25, minutes=61, seconds=61))
+    ])
     def test_iso_constructor(self, fmt, exp):
         assert Timedelta(fmt) == exp
+
+    @pytest.mark.parametrize('fmt', [
+        'PPPPPPPPPPPP', 'PDTHMS', 'P0DT999H999M999S',
+        'P1DT0H0M0.0000000000000S', 'P1DT0H0M00000000000S',
+        'P1DT0H0M0.S'])
+    def test_iso_constructor_raises(self, fmt):
+        with tm.assert_raises_regex(ValueError, 'Invalid ISO 8601 Duration '
+                                    'format - {}'.format(fmt)):
+            Timedelta(fmt)