API:move use of maybe_convert_numeric_to_64bit to to also be used in IntervalIndex._engine

Author: topper-123

pandas/core/indexes/interval.py

@@ -31,6 +31,7 @@
     DtypeObj,
     IntervalClosedType,
     npt,
+    NumpyIndexT,
 )
 from pandas.errors import InvalidIndexError
 from pandas.util._decorators import (
@@ -47,6 +48,7 @@
 )
 from pandas.core.dtypes.common import (
     ensure_platform_int,
+    is_array_like,
     is_datetime64tz_dtype,
     is_datetime_or_timedelta_dtype,
     is_dtype_equal,
@@ -146,6 +148,24 @@ def _new_IntervalIndex(cls, d):
     return cls.from_arrays(**d)
 
 
+def maybe_convert_numeric_to_64bit(arr: NumpyIndexT) -> NumpyIndexT:
+    # IntervalTree only supports 64 bit numpy array
+
+    if not is_array_like(arr):
+        return arr
+    dtype = arr.dtype
+    if not np.issubclass_(dtype.type, np.number):
+        return arr
+    elif is_signed_integer_dtype(dtype) and dtype != np.int64:
+        return arr.astype(np.int64)
+    elif is_unsigned_integer_dtype(dtype) and dtype != np.uint64:
+        return arr.astype(np.uint64)
+    elif is_float_dtype(dtype) and dtype != np.float64:
+        return arr.astype(np.float64)
+    else:
+        return arr
+
+
 @Appender(
     _interval_shared_docs["class"]
     % {
@@ -343,7 +363,9 @@ def from_tuples(
     @cache_readonly
     def _engine(self) -> IntervalTree:  # type: ignore[override]
         left = self._maybe_convert_i8(self.left)
+        left = maybe_convert_numeric_to_64bit(left)
         right = self._maybe_convert_i8(self.right)
+        right = maybe_convert_numeric_to_64bit(right)
         return IntervalTree(left, right, closed=self.closed)
 
     def __contains__(self, key: Any) -> bool:
@@ -520,13 +542,12 @@ def _maybe_convert_i8(self, key):
             The original key if no conversion occurred, int if converted scalar,
             Int64Index if converted list-like.
         """
-        original = key
         if is_list_like(key):
             key = ensure_index(key)
-            key = self._maybe_convert_numeric_to_64bit(key)
+            key = maybe_convert_numeric_to_64bit(key)
 
         if not self._needs_i8_conversion(key):
-            return original
+            return key
 
         scalar = is_scalar(key)
         if is_interval_dtype(key) or isinstance(key, Interval):
@@ -569,20 +590,6 @@ def _maybe_convert_i8(self, key):
 
         return key_i8
 
-    def _maybe_convert_numeric_to_64bit(self, idx: Index) -> Index:
-        # IntervalTree only supports 64 bit numpy array
-        dtype = idx.dtype
-        if np.issubclass_(dtype.type, np.number):
-            return idx
-        elif is_signed_integer_dtype(dtype) and dtype != np.int64:
-            return idx.astype(np.int64)
-        elif is_unsigned_integer_dtype(dtype) and dtype != np.uint64:
-            return idx.astype(np.uint64)
-        elif is_float_dtype(dtype) and dtype != np.float64:
-            return idx.astype(np.float64)
-        else:
-            return idx
-
     def _searchsorted_monotonic(self, label, side: Literal["left", "right"] = "left"):
         if not self.is_non_overlapping_monotonic:
             raise KeyError(

pandas/tests/indexes/interval/test_interval.py

@@ -18,7 +18,10 @@
     timedelta_range,
 )
 import pandas._testing as tm
-from pandas.core.api import Float64Index
+from pandas.core.api import (
+    Float64Index,
+    NumericIndex,
+)
 import pandas.core.common as com
 
 
@@ -435,9 +438,12 @@ def test_maybe_convert_i8_numeric(self, breaks, make_key):
         index = IntervalIndex.from_breaks(breaks)
         key = make_key(breaks)
 
-        # no conversion occurs for numeric
         result = index._maybe_convert_i8(key)
-        assert result is key
+        if not isinstance(result, NumericIndex):
+            assert result is key
+        else:
+            expected = NumericIndex(key)
+            tm.assert_index_equal(result, expected)
 
     @pytest.mark.parametrize(
         "breaks1, breaks2",