clean up convert_tolerance to use np.asarray

Author: Brian Tu

pandas/core/indexes/base.py

@@ -2601,8 +2601,7 @@ def get_indexer(self, target, method=None, limit=None, tolerance=None):
         target = _ensure_index(target)
         if tolerance is not None:
             tolerance = self._convert_tolerance(tolerance)
-            if isinstance(tolerance, np.ndarray) and \
-               target.size != len(tolerance) and len(tolerance) > 1:
+            if target.size != tolerance.size and tolerance.size > 1:
                 raise ValueError('list-like tolerance size must match '
                                  'target index size')
 
@@ -2639,7 +2638,7 @@ def get_indexer(self, target, method=None, limit=None, tolerance=None):
 
     def _convert_tolerance(self, tolerance):
         # override this method on subclasses
-        return _list_to_ndarray(tolerance)
+        return np.asarray(tolerance)
 
     def _get_fill_indexer(self, target, method, limit=None, tolerance=None):
         if self.is_monotonic_increasing and target.is_monotonic_increasing:
@@ -4029,17 +4028,6 @@ def invalid_op(self, other=None):
 Index._add_comparison_methods()
 
 
-def _list_to_ndarray(a):
-    """Convert list-like to np.ndarray, otherwise leave as-is.
-    Used for converting tolerance to ndarray in _convert_tolerance.
-    """
-    if isinstance(a, ABCSeries):
-        return a.values
-    elif isinstance(a, (list, tuple)):
-        return np.array(a)
-    return a
-
-
 def _ensure_index_from_sequences(sequences, names=None):
     """Construct an index from sequences of data.
 

pandas/core/indexes/datetimelike.py

@@ -7,6 +7,7 @@
 
 from pandas import compat
 from pandas.compat.numpy import function as nv
+from pandas.core.tools.timedeltas import to_timedelta
 
 import numpy as np
 from pandas.core.dtypes.common import (
@@ -27,8 +28,7 @@
                           Timedelta, Timestamp, iNaT, NaT)
 from pandas._libs.period import Period
 
-from pandas.core.indexes.base import (Index, _index_shared_docs,
-                                      _list_to_ndarray)
+from pandas.core.indexes.base import Index, _index_shared_docs
 from pandas.util._decorators import Appender, cache_readonly
 import pandas.core.dtypes.concat as _concat
 import pandas.tseries.frequencies as frequencies
@@ -433,36 +433,9 @@ def asobject(self):
         return Index(self._box_values(self.asi8), name=self.name, dtype=object)
 
     def _convert_tolerance(self, tolerance):
-        tolerance = _list_to_ndarray(tolerance)
-        if isinstance(tolerance, np.ndarray):
-            if np.issubdtype(tolerance.dtype, np.timedelta64):
-                return tolerance
-            else:
-                try:
-                    tolerance = np.array([np.timedelta64(x)
-                                          for x in tolerance])
-                    # in case user mixes something like seconds and Month
-                    if not np.issubdtype(tolerance.dtype, np.timedelta64):
-                        raise TypeError('All values in tolerance array must '
-                                        'be convertible to [ns]')
-                except ValueError:
-                    raise TypeError(('tolerance argument for %s must contain '
-                                     'objects convertible to np.timedelta64 '
-                                     'if it is list type') %
-                                    (type(self).__name__,))
-                else:
-                    warnings.warn('Converting tolerance array to '
-                                  'np.timedelta64 objects, consider doing '
-                                  'preconverting for speed')
-                return tolerance
-        else:
-            try:
-                return Timedelta(tolerance).to_timedelta64()
-            except ValueError:
-                raise ValueError(('tolerance argument for %s must be '
-                                  'convertible to Timedelta if it is a '
-                                  'scalar: %r') %
-                                 (type(self).__name__, tolerance))
+        if not is_list_like(tolerance):
+            tolerance = [tolerance]
+        return np.asarray(to_timedelta(tolerance))
 
     def _maybe_mask_results(self, result, fill_value=None, convert=None):
         """

pandas/core/indexes/numeric.py

@@ -15,7 +15,7 @@
 from pandas import compat
 from pandas.core import algorithms
 from pandas.core.indexes.base import (
-    Index, InvalidIndexError, _index_shared_docs, _list_to_ndarray)
+    Index, InvalidIndexError, _index_shared_docs)
 from pandas.util._decorators import Appender, cache_readonly
 import pandas.core.indexes.base as ibase
 
@@ -72,21 +72,17 @@ def _convert_for_op(self, value):
         return value
 
     def _convert_tolerance(self, tolerance):
-        tolerance = _list_to_ndarray(tolerance)
-        if isinstance(tolerance, np.ndarray):
-            if np.issubdtype(tolerance.dtype, np.number):
-                return tolerance
-            else:
+        tolerance = np.asarray(tolerance)
+        if not np.issubdtype(tolerance.dtype, np.number):
+            if tolerance.ndim > 0:
                 raise ValueError(('tolerance argument for %s must contain '
-                                  'numeric elements if it is list type') %
-                                 (type(self).__name__,))
-        else:
-            try:
-                return float(tolerance)
-            except ValueError:
+                                    'numeric elements if it is list type') %
+                                    (type(self).__name__,))
+            else:
                 raise ValueError(('tolerance argument for %s must be numeric '
-                                  'if it is a scalar: %r') %
-                                 (type(self).__name__, tolerance))
+                                    'if it is a scalar: %r') %
+                                    (type(self).__name__, tolerance))
+        return tolerance
 
     @classmethod
     def _assert_safe_casting(cls, data, subarr):

pandas/core/indexes/period.py

@@ -639,10 +639,7 @@ def _maybe_convert_timedelta(self, other):
             if isinstance(offset, offsets.Tick):
                 nanos = tslib._delta_to_nanoseconds(other)
                 offset_nanos = tslib._delta_to_nanoseconds(offset)
-                if isinstance(other, np.ndarray):
-                    check = np.all(nanos % offset_nanos == 0)
-                else:
-                    check = nanos % offset_nanos == 0
+                check = np.all(nanos % offset_nanos == 0)
                 if check:
                     return nanos // offset_nanos
         elif isinstance(other, offsets.DateOffset):
@@ -780,8 +777,7 @@ def get_indexer(self, target, method=None, limit=None, tolerance=None):
 
         if tolerance is not None:
             tolerance = self._convert_tolerance(tolerance)
-            if isinstance(tolerance, np.ndarray) and \
-               target.size != tolerance.size and tolerance.size > 1:
+            if target.size != tolerance.size and tolerance.size > 1:
                 raise ValueError('list-like tolerance size must match '
                                  'target index size')
         return Index.get_indexer(self._int64index, target, method,
@@ -911,10 +907,6 @@ def _get_string_slice(self, key):
 
     def _convert_tolerance(self, tolerance):
         tolerance = DatetimeIndexOpsMixin._convert_tolerance(self, tolerance)
-        if isinstance(tolerance, np.ndarray) \
-                and not np.issubdtype(tolerance.dtype, np.timedelta64):
-            raise TypeError('All values in tolerance array must be '
-                            'convertible to [ns]')
         return self._maybe_convert_timedelta(tolerance)
 
     def insert(self, loc, item):

pandas/tests/indexes/datetimes/test_datetime.py

@@ -41,7 +41,8 @@ def test_get_loc(self):
                            tolerance=np.timedelta64(1, 'D')) == 1
         assert idx.get_loc('2000-01-01T12', method='nearest',
                            tolerance=timedelta(1)) == 1
-        with tm.assert_raises_regex(ValueError, 'must be convertible'):
+        with tm.assert_raises_regex(ValueError,
+                'unit abbreviation w/o a number'):
             idx.get_loc('2000-01-01T12', method='nearest', tolerance='foo')
         with pytest.raises(KeyError):
             idx.get_loc('2000-01-01T03', method='nearest', tolerance='2 hours')
@@ -102,28 +103,15 @@ def test_get_indexer(self):
         tol_raw = [pd.Timedelta('1 hour'),
                    pd.Timedelta('1 hour'),
                    pd.Timedelta('1 hour').to_timedelta64(), ]
-        with pytest.warns(UserWarning) as speedwarning:
-            tm.assert_numpy_array_equal(
-                idx.get_indexer(target, 'nearest',
-                                tolerance=tol_raw),
-                np.array([0, -1, 1], dtype=np.intp))
-        assert len(speedwarning) == 1
-        assert speedwarning[0].message.args[0]\
-            .endswith('preconverting for speed')
         tm.assert_numpy_array_equal(
             idx.get_indexer(target, 'nearest',
                             tolerance=[np.timedelta64(x) for x in tol_raw]),
             np.array([0, -1, 1], dtype=np.intp))
-        with pytest.raises(
-                TypeError,
-                match='must contain objects convertible to np.timedelta64'):
-            idx.get_indexer(target, 'nearest', tolerance=[1, 2, 3])
         tol_bad = [pd.Timedelta('2 hour').to_timedelta64(),
                    pd.Timedelta('1 hour').to_timedelta64(),
-                   np.timedelta64(1, 'M'), ]
+                   'foo', ]
         with pytest.raises(
-               TypeError, match='All values.* convertible to \\[ns\\]'),\
-             pytest.warns(UserWarning):
+                ValueError, match='abbreviation w/o a number'):
             idx.get_indexer(target, 'nearest', tolerance=tol_bad)
         with pytest.raises(ValueError):
             idx.get_indexer(idx[[0]], method='nearest', tolerance='foo')

pandas/tests/indexes/period/test_period.py

@@ -9,6 +9,7 @@
 from pandas import (PeriodIndex, period_range, notna, DatetimeIndex, NaT,
                     Index, Period, Int64Index, Series, DataFrame, date_range,
                     offsets, compat)
+from pandas.core.indexes.period import IncompatibleFrequency
 
 from ..datetimelike import DatetimeLike
 
@@ -81,7 +82,8 @@ def test_get_loc(self):
                            tolerance=np.timedelta64(1, 'D')) == 1
         assert idx.get_loc('2000-01-02T12', method='nearest',
                            tolerance=timedelta(1)) == 1
-        with tm.assert_raises_regex(ValueError, 'must be convertible'):
+        with tm.assert_raises_regex(ValueError,
+                'unit abbreviation w/o a number'):
             idx.get_loc('2000-01-10', method='nearest', tolerance='foo')
 
         msg = 'Input has different freq from PeriodIndex\\(freq=D\\)'
@@ -165,14 +167,6 @@ def test_get_indexer(self):
         tol_raw = [pd.Timedelta('1 hour'),
                    pd.Timedelta('1 hour'),
                    np.timedelta64(1, 'D'), ]
-        with pytest.warns(UserWarning) as speedwarning:
-            tm.assert_numpy_array_equal(
-                idx.get_indexer(target, 'nearest',
-                                tolerance=tol_raw),
-                np.array([0, -1, 1], dtype=np.intp))
-        assert len(speedwarning) == 1
-        assert speedwarning[0].message.args[0]\
-            .endswith('preconverting for speed')
         tm.assert_numpy_array_equal(
             idx.get_indexer(target, 'nearest',
                             tolerance=[np.timedelta64(x) for x in tol_raw]),
@@ -181,14 +175,9 @@ def test_get_indexer(self):
                    pd.Timedelta('1 hour').to_timedelta64(),
                    np.timedelta64(1, 'M'), ]
         with pytest.raises(
-               TypeError,
-               match='All values.* convertible to \\[ns\\]'),\
-             pytest.warns(UserWarning):
+               IncompatibleFrequency,
+               match='Input has different freq from'):
             idx.get_indexer(target, 'nearest', tolerance=tol_bad)
-        with pytest.raises(
-                TypeError,
-                match='must contain objects convertible to np.timedelta64'):
-            idx.get_indexer(target, 'nearest', tolerance=[1, 2, 3])
 
     def test_repeat(self):
         # GH10183

pandas/tests/indexes/timedeltas/test_timedelta.py

@@ -60,12 +60,13 @@ def test_get_loc(self):
         assert idx.get_loc(idx[1], 'pad',
                            tolerance=timedelta(0)) == 1
 
-        with tm.assert_raises_regex(ValueError, 'must be convertible'):
+        with tm.assert_raises_regex(ValueError,
+                'unit abbreviation w/o a number'):
             idx.get_loc(idx[1], method='nearest', tolerance='foo')
 
         with pytest.raises(
                 ValueError,
-                match='tolerance size must match target index size'):
+                match='tolerance size must match'):
             idx.get_loc(idx[1], method='nearest',
                         tolerance=[Timedelta(0).to_timedelta64(),
                                    Timedelta(0).to_timedelta64()])
@@ -104,13 +105,6 @@ def test_get_indexer(self):
                               tolerance=pd.Timedelta('1 hour'))
         tm.assert_numpy_array_equal(res, np.array([0, -1, 1], dtype=np.intp))
 
-        with pytest.warns(UserWarning):
-            res = idx.get_indexer(target, 'nearest',
-                                  tolerance=[pd.Timedelta('2 hour'),
-                                             pd.Timedelta('5 hours'),
-                                             pd.Timedelta('1 hour')])
-        tm.assert_numpy_array_equal(res, np.array([0, -1, 1], dtype=np.intp))
-
     def test_numeric_compat(self):
 
         idx = self._holder(np.arange(5, dtype='int64'))