rebase after #41472

pandas/__init__.py

@@ -76,6 +76,7 @@
     RangeIndex,
     Float64Index,
     MultiIndex,
+    NumericIndex,
     IntervalIndex,
     TimedeltaIndex,
     DatetimeIndex,

pandas/core/index.py

@@ -1,7 +1,6 @@
 import warnings
 
 from pandas.core.indexes.api import (  # noqa:F401
-    BaseNumericIndex,
     CategoricalIndex,
     DatetimeIndex,
     Float64Index,
@@ -10,6 +9,7 @@
     IntervalIndex,
     MultiIndex,
     NaT,
+    NumericIndex,
     PeriodIndex,
     RangeIndex,
     TimedeltaIndex,

pandas/core/indexes/api.py

@@ -20,7 +20,6 @@
 from pandas.core.indexes.interval import IntervalIndex
 from pandas.core.indexes.multi import MultiIndex
 from pandas.core.indexes.numeric import (
-    BaseNumericIndex,
     Float64Index,
     Int64Index,
     NumericIndex,
@@ -46,7 +45,6 @@
     "Index",
     "MultiIndex",
     "NumericIndex",
-    "BaseNumericIndex",
     "Float64Index",
     "Int64Index",
     "CategoricalIndex",

pandas/core/indexes/base.py

@@ -2441,16 +2441,17 @@ def _is_numeric_index(cls) -> bool:
 
         Used to check if an operation should return NumericIndex or plain Index.
         """
-        from pandas.core.indexes.numeric import (
+        from pandas import (
             Float64Index,
             Int64Index,
             NumericIndex,
+            RangeIndex,
             UInt64Index,
         )
 
         if not issubclass(cls, NumericIndex):
             return False
-        elif issubclass(cls, (Int64Index, UInt64Index, Float64Index)):
+        elif issubclass(cls, (RangeIndex, Int64Index, UInt64Index, Float64Index)):
             return False
         else:
             return True

pandas/core/indexes/numeric.py

@@ -212,13 +212,52 @@ def _ensure_dtype(
         else:
             return dtype
 
+    def __contains__(self, key) -> bool:
+        """
+        Check if key is a float and has a decimal. If it has, return False.
+        """
+        if not is_integer_dtype(self.dtype):
+            return super().__contains__(key)
+
+        hash(key)
+        try:
+            if is_float(key) and int(key) != key:
+                # otherwise the `key in self._engine` check casts e.g. 1.1 -> 1
+                return False
+            return key in self._engine
+        except (OverflowError, TypeError, ValueError):
+            return False
+
+    @doc(Index.astype)
+    def astype(self, dtype, copy=True):
+        if is_float_dtype(self.dtype):
+            dtype = pandas_dtype(dtype)
+            if needs_i8_conversion(dtype):
+                raise TypeError(
+                    f"Cannot convert Float64Index to dtype {dtype}; integer "
+                    "values are required for conversion"
+                )
+            elif is_integer_dtype(dtype) and not is_extension_array_dtype(dtype):
+                # TODO(jreback); this can change once we have an EA Index type
+                # GH 13149
+                arr = astype_nansafe(self._values, dtype=dtype)
+                if isinstance(self, Float64Index):
+                    return Int64Index(arr, name=self.name)
+                else:
+                    return NumericIndex(arr, name=self.name, dtype=dtype)
+
+        return super().astype(dtype, copy=copy)
+
     # ----------------------------------------------------------------
     # Indexing Methods
 
     @cache_readonly
     @doc(Index._should_fallback_to_positional)
     def _should_fallback_to_positional(self) -> bool:
-        return False
+        if self.inferred_type == "floating":
+            return False
+
+        return super()._should_fallback_to_positional()
 
     @doc(Index._convert_slice_indexer)
     def _convert_slice_indexer(self, key: slice, kind: str):
@@ -239,6 +278,21 @@ def _maybe_cast_slice_bound(self, label, side: str, kind=lib.no_default):
         # we will try to coerce to integers
         return self._maybe_cast_indexer(label)
 
+    @doc(Index._convert_arr_indexer)
+    def _convert_arr_indexer(self, keyarr) -> np.ndarray:
+        if is_unsigned_integer_dtype(self.dtype):
+            # Cast the indexer to uint64 if possible so that the values returned
+            # from indexing are also uint64.
+            dtype = None
+            if is_integer_dtype(keyarr) or (
+                lib.infer_dtype(keyarr, skipna=False) == "integer"
+            ):
+                dtype = np.dtype(np.uint64)
+
+            return com.asarray_tuplesafe(keyarr, dtype=dtype)
+
+        return super()._convert_arr_indexer(keyarr)
+
     # ----------------------------------------------------------------
 
     @doc(Index._shallow_copy)
@@ -270,13 +324,13 @@ def _is_comparable_dtype(self, dtype: DtypeObj) -> bool:
         return is_numeric_dtype(dtype)
 
     @classmethod
-    def _assert_safe_casting(cls, data, subarr):
+    def _assert_safe_casting(cls, data, subarr) -> None:
         """
-        Subclasses need to override this only if the process of casting data
-        from some accepted dtype to the internal dtype(s) bears the risk of
-        truncation (e.g. float to int).
+        Ensure incoming data can be represented with matching signed-ness.
         """
-        pass
+        if is_integer_dtype(subarr.dtype):
+            if not np.array_equal(data, subarr):
+                raise TypeError("Unsafe NumPy casting, you must explicitly cast")
 
     @property
     def _is_all_dates(self) -> bool:

pandas/core/indexes/range.py

@@ -45,9 +45,9 @@
 import pandas.core.indexes.base as ibase
 from pandas.core.indexes.base import maybe_extract_name
 from pandas.core.indexes.numeric import (
-    BaseNumericIndex,
     Float64Index,
     Int64Index,
+    NumericIndex,
 )
 from pandas.core.ops.common import unpack_zerodim_and_defer
 
@@ -57,7 +57,7 @@
 _empty_range = range(0)
 
 
-class RangeIndex(BaseNumericIndex):
+class RangeIndex(NumericIndex):
     """
     Immutable Index implementing a monotonic integer range.
 

pandas/tests/indexes/test_numpy_compat.py

@@ -10,7 +10,7 @@
 )
 import pandas._testing as tm
 from pandas.core.indexes.datetimelike import DatetimeIndexOpsMixin
-from pandas.core.indexes.numeric import BaseNumericIndex
+from pandas.core.indexes.numeric import NumericIndex
 
 
 @pytest.mark.parametrize(
@@ -49,7 +49,7 @@ def test_numpy_ufuncs_basic(index, func):
         with tm.external_error_raised((TypeError, AttributeError)):
             with np.errstate(all="ignore"):
                 func(index)
-    elif isinstance(index, BaseNumericIndex):
+    elif isinstance(index, NumericIndex):
         # coerces to float (e.g. np.sin)
         with np.errstate(all="ignore"):
             result = func(index)
@@ -94,7 +94,7 @@ def test_numpy_ufuncs_other(index, func, request):
         with tm.external_error_raised(TypeError):
             func(index)
 
-    elif isinstance(index, BaseNumericIndex):
+    elif isinstance(index, NumericIndex):
         # Results in bool array
         result = func(index)
         assert isinstance(result, np.ndarray)

pandas/tests/indexes/test_setops.py

@@ -31,22 +31,7 @@
 
 COMPATIBLE_INCONSISTENT_PAIRS = [
     (np.float64, np.int64),
-    (np.float64, np.int32),
-    (np.float64, np.int16),
-    (np.float64, np.int8),
     (np.float64, np.uint64),
-    (np.float64, np.uint32),
-    (np.float64, np.uint16),
-    (np.float64, np.uint8),
-    (np.float32, np.int64),
-    (np.float32, np.int32),
-    (np.float32, np.int16),
-    (np.float32, np.int8),
-    (np.float32, np.uint64),
-    (np.float32, np.uint32),
-    (np.float32, np.uint16),
-    (np.float32, np.uint8),
-    (np.float32, np.float64),
 ]