Make common impl. with Index.searchsorted part II

Author: topper-123

pandas/core/common.py

@@ -16,6 +16,8 @@
 from pandas.compat import iteritems, PY2, PY36, OrderedDict
 from pandas.core.dtypes.generic import ABCSeries, ABCIndex, ABCIndexClass
 from pandas.core.dtypes.common import (is_integer, is_integer_dtype,
+                                       is_float_dtype, is_object_dtype,
+                                       is_categorical_dtype,
                                        is_numeric_dtype, is_number,
                                        is_scalar, ensure_platform_int)
 from pandas.core.dtypes.inference import _iterable_not_string
@@ -447,10 +449,10 @@ def ensure_within_integer_bounds(value, dtype):
     ValueError : if value is outside the bounds set in iinfo(dtype)
     """
     if PY2:
-        # python 2 allows e.g. "a" < 1, avoid this
+        # python 2 allows "a" < 1, avoid such nonsense
         if not (is_number(value) or is_numeric_dtype(value)):
             msg = "value must be a number, was type {}"
-            raise ValueError(msg.format(value))
+            raise TypeError(msg.format(value))
 
     # check if value is within integer bounds
     iinfo = np.iinfo(dtype)
@@ -481,24 +483,30 @@ def searchsorted_integer(arr, value, side="left", sorter=None):
         # but float 2.2 should *not* be converted to int 2
         value = np.asarray(value, dtype=dtype)
 
-    return arr.searchsorted(value, side=side, sorter=sorter)
+    return np.searchsorted(arr, value, side=side, sorter=sorter)
 
 
 def searchsorted(arr, value, side="left", sorter=None):
     """
-    Do a arr.searchsorted(value) with adjustments for dtypes.
+    Find indices where elements should be inserted to maintain order.
 
-    :func:`numpy.searchsorted` is only fast if value is of same dtype
-    as the searched array. Else numpy recasts arr to a higher dtype, which
-    causes a slowdown. Below we ensure that value has the right dtype
-    for giving fast results for arr.searchsorted, when possible.
+    Find the indices into a sorted array-like `arr` such that, if the
+    corresponding elements in `value` were inserted before the indices,
+    the order of `arr` would be preserved.
 
-    See :meth:`Index.searchsorted` for details on parameters and return value.
+    See :class:`IndexOpsMixin.searchsorted` for more details and examples.
     """
     if sorter is not None:
         sorter = ensure_platform_int(sorter)
 
     if is_integer_dtype(arr):
         return searchsorted_integer(arr, value, side=side, sorter=sorter)
+    elif (is_object_dtype(arr) or is_float_dtype(arr) or
+          is_categorical_dtype(arr)):
+        return arr.searchsorted(value, side=side, sorter=sorter)
     else:
+        # fallback solution. E.g. arr is an array with dtype='datetime64[ns]'
+        # and value is a pd.Timestamp
+        from pandas.core.series import Series
+        value = Series(value)._values
         return arr.searchsorted(value, side=side, sorter=sorter)

pandas/core/series.py

@@ -2087,18 +2087,8 @@ def __rmatmul__(self, other):
     @Appender(base._shared_docs['searchsorted'])
     @deprecate_kwarg(old_arg_name='v', new_arg_name='value')
     def searchsorted(self, value, side='left', sorter=None):
-        simple_types = (is_integer_dtype, is_float_dtype, is_object_dtype,
-                        is_categorical_dtype)
-
-        if any(is_dtype(self) for is_dtype in simple_types):
-            result = com.searchsorted(self._values, value,
-                                      side=side, sorter=sorter)
-        else:
-            # e.g. self is datetimelike and value is a pd.Timestamp
-            if sorter is not None:
-                sorter = ensure_platform_int(sorter)
-            value = Series(value)._values
-            result = self._values.searchsorted(value, side=side, sorter=sorter)
+        result = com.searchsorted(self._values, value,
+                                  side=side, sorter=sorter)
 
         if is_scalar(result):
             # ensure that a 1-dim array is returned