BUG: IntervalIndex.get_loc/get_indexer wrong return value / error

pandas/core/indexes/interval.py

@@ -766,8 +766,11 @@ def get_loc(self, key, method=None):
                 key = Interval(left, right, key.closed)
             else:
                 key = self._maybe_cast_slice_bound(key, 'left', None)
-
-            start, stop = self._find_non_overlapping_monotonic_bounds(key)
+            try:
+                start, stop = self._find_non_overlapping_monotonic_bounds(key)
+            except TypeError:
+                # get_loc should raise KeyError
+                raise KeyError('key is hashable but of incorrect type')
 
             if start is None or stop is None:
                 return slice(start, stop)
@@ -785,7 +788,10 @@ def get_loc(self, key, method=None):
                 left, right = _get_interval_closed_bounds(key)
                 return self._engine.get_loc_interval(left, right)
             else:
-                return self._engine.get_loc(key)
+                try:
+                    return self._engine.get_loc(key)
+                except TypeError:
+                    raise KeyError('No engine for key {!r}'.format(key))
 
     def get_value(self, series, key):
         if com.is_bool_indexer(key):
@@ -819,7 +825,12 @@ def get_indexer(self, target, method=None, limit=None, tolerance=None):
             return np.arange(len(self), dtype='intp')
 
         if self.is_non_overlapping_monotonic:
-            start, stop = self._find_non_overlapping_monotonic_bounds(target)
+            try:
+                start, stop = (
+                    self._find_non_overlapping_monotonic_bounds(target)
+                )
+            except TypeError:
+                return np.repeat(np.int(-1), len(target))
 
             start_plus_one = start + 1
             if not ((start_plus_one < stop).any()):
@@ -834,7 +845,13 @@ def get_indexer(self, target, method=None, limit=None, tolerance=None):
 
         # non IntervalIndex
         else:
-            indexer = np.concatenate([self.get_loc(i) for i in target])
+            vals = []
+            for i in target:
+                try:
+                    vals.append(self.get_loc(i))
+                except KeyError:
+                    vals.append(np.array([-1]))
+                indexer = np.concatenate(vals)
 
         return ensure_platform_int(indexer)
 

pandas/tests/indexes/interval/test_interval.py

@@ -435,6 +435,14 @@ def test_get_loc_value(self):
         idx = IntervalIndex.from_arrays([0, 2], [1, 3])
         pytest.raises(KeyError, idx.get_loc, 1.5)
 
+        # GH25087, test get_loc returns key error for interval indexes
+        msg = 'key is hashable but of incorrect type'
+        with pytest.raises(KeyError, match=msg):
+            idx.get_loc('a')
+        idx = pd.interval_range(0, 1.0)
+        with pytest.raises(KeyError, match=msg):
+            idx.get_loc('a')
+
     # To be removed, replaced by test_interval_new.py (see #16316, #16386)
     def slice_locs_cases(self, breaks):
         # TODO: same tests for more index types
@@ -616,6 +624,14 @@ def test_get_indexer_length_one(self, item, closed):
         expected = np.array([0] * len(item), dtype='intp')
         tm.assert_numpy_array_equal(result, expected)
 
+    @pytest.mark.parametrize('index', [
+        pd.interval_range(0, 1),
+        pd.IntervalIndex.from_tuples([(1, 3), (2, 4), (0, 2)])
+    ])
+    def test_get_indexer_errors(self, index):
+        expected = np.array([-1], dtype='intp')
+        assert tm.assert_numpy_array_equal(index.get_indexer(['gg']), expected)
+
     # Make consistent with test_interval_new.py (see #16316, #16386)
     @pytest.mark.parametrize('arrays', [
         (date_range('20180101', periods=4), date_range('20180103', periods=4)),

pandas/tests/indexing/test_categorical.py

@@ -78,6 +78,12 @@ def test_getitem_scalar(self):
         result = s[cats[0]]
         assert result == expected
 
+    def test_contains_interval_range(self):
+        """Check we can use contains """
+        intervals = pd.interval_range(0.0, 1.0)
+        cats = pd.Categorical(intervals)
+        assert 'gg' not in cats
+
     def test_slicing_directly(self):
         cat = Categorical(["a", "b", "c", "d", "a", "b", "c"])
         sliced = cat[3]