Convert float freqstrs to ints at finer resolution

Passing `'0.5min'` as a frequency string should generate 30 second
intervals, rather than five minute intervals. By recursively increasing
resolution until one is found for which the frequency is an integer,
this commit ensures that that's the case for resolutions from days to
microseconds.

Fixes pandas-dev#8419

Author: jisantuc

pandas/tseries/frequencies.py

@@ -63,7 +63,28 @@ class Resolution(object):
         RESO_SEC: 'second',
         RESO_MIN: 'minute',
         RESO_HR: 'hour',
-        RESO_DAY: 'day'}
+        RESO_DAY: 'day'
+    }
+
+    # factor to multiply a value by to convert it to the next finer grained
+    # resolution
+    _reso_mult_map = {
+        RESO_US: None,
+        RESO_MS: 1000,
+        RESO_SEC: 1000,
+        RESO_MIN: 60,
+        RESO_HR: 60,
+        RESO_DAY: 24
+    }
+
+    _reso_str_bump_map = {
+        'D': 'H',
+        'H': 'T',
+        'T': 'S',
+        'S': 'L',
+        'L': 'U',
+        'U': None
+    }
 
     _str_reso_map = dict([(v, k) for k, v in compat.iteritems(_reso_str_map)])
 
@@ -160,6 +181,34 @@ def get_reso_from_freq(cls, freq):
         """
         return cls.get_reso(cls.get_str_from_freq(freq))
 
+    @classmethod
+    def bump_to_int(cls, value, freq):
+        """
+        Increase resolution an integer value is available to create an
+        offset.
+
+        Example
+        -------
+        >>> Resolution.bump_to_int(1.5, 'T')
+        <90 * Seconds>
+
+        >>> Resolution.bump_to_int(1.04, 'H')
+        <3744 * Seconds>
+
+        >>> Resolution.bump_to_int(1, 'D')
+        <Day>
+        """
+
+        if np.isclose(value % 1, 0):
+            return int(value), freq
+        else:
+            start_reso = cls.get_reso_from_freq(freq)
+            if start_reso == 0:
+                raise ValueError(_CANNOT_CONVERT_TO_INT)
+            next_value = cls._reso_mult_map[start_reso] * value
+            next_name = cls._reso_str_bump_map[freq]
+            return cls.bump_to_int(next_value, next_name)
+
 
 def get_to_timestamp_base(base):
     """
@@ -384,6 +433,9 @@ def get_period_alias(offset_str):
 
 
 _INVALID_FREQ_ERROR = "Invalid frequency: {0}"
+_CANNOT_CONVERT_TO_INT = (
+    "Could not convert to integer offset at any resolution"
+)
 
 
 @deprecate_kwarg(old_arg_name='freqstr', new_arg_name='freq')
@@ -472,12 +524,17 @@ def to_offset(freq):
                                          splitted[2::4]):
                 if sep != '' and not sep.isspace():
                     raise ValueError('separator must be spaces')
-                offset = get_offset(name)
+                prefix = _lite_rule_alias.get(name)
                 if stride_sign is None:
                     stride_sign = -1 if stride.startswith('-') else 1
                 if not stride:
                     stride = 1
+                if prefix in Resolution._reso_str_bump_map.keys():
+                    stride, name = Resolution.bump_to_int(
+                        float(stride), prefix
+                    )
                 stride = int(stride)
+                offset = get_offset(name)
                 offset = offset * int(np.fabs(stride) * stride_sign)
                 if delta is None:
                     delta = offset
@@ -493,7 +550,9 @@ def to_offset(freq):
 
 
 # hack to handle WOM-1MON
-opattern = re.compile(r'([\-]?\d*)\s*([A-Za-z]+([\-][\dA-Za-z\-]+)?)')
+opattern = re.compile(
+    r'([\-]?\d*|[\-]?\d*\.\d*)\s*([A-Za-z]+([\-][\dA-Za-z\-]+)?)'
+)
 
 
 def _base_and_stride(freqstr):

pandas/tseries/tests/test_frequencies.py

@@ -39,6 +39,11 @@ def test_to_offset_multiple(self):
         expected = offsets.Hour(3)
         assert (result == expected)
 
+        freqstr = '1.5min'
+        result = frequencies.to_offset(freqstr)
+        expected = offsets.Second(90)
+        assert (result == expected)
+
         freqstr = '15l500u'
         result = frequencies.to_offset(freqstr)
         expected = offsets.Micro(15500)
@@ -108,10 +113,6 @@ def test_to_offset_invalid(self):
         with tm.assertRaisesRegexp(ValueError, 'Invalid frequency: -2D:3H'):
             frequencies.to_offset('-2D:3H')
 
-        # ToDo: Must be fixed in #8419
-        with tm.assertRaisesRegexp(ValueError, 'Invalid frequency: .5S'):
-            frequencies.to_offset('.5S')
-
         # split offsets with spaces are valid
         assert frequencies.to_offset('2D 3H') == offsets.Hour(51)
         assert frequencies.to_offset('2 D3 H') == offsets.Hour(51)
@@ -379,6 +380,17 @@ def test_freq_to_reso(self):
             result = Reso.get_freq(Reso.get_str(Reso.get_reso_from_freq(freq)))
             self.assertEqual(freq, result)
 
+    def test_resolution_bumping(self):
+        Reso = frequencies.Resolution
+
+        self.assertEqual(Reso.bump_to_int(1.5, 'T'), (90, 'S'))
+        self.assertEqual(Reso.bump_to_int(62.4, 'T'), (3744, 'S'))
+        self.assertEqual(Reso.bump_to_int(1.04, 'H'), (3744, 'S'))
+        self.assertEqual(Reso.bump_to_int(1, 'D'), (1, 'D'))
+
+        with self.assertRaises(ValueError):
+            Reso.bump_to_int(0.5, 'U')
+
     def test_get_freq_code(self):
         # freqstr
         self.assertEqual(frequencies.get_freq_code('A'),