remove Int/Uint/Float64Index from pandas/tests/indexes/ranges

Author: topper-123

pandas/core/indexes/range.py

@@ -48,7 +48,6 @@
 import pandas.core.indexes.base as ibase
 from pandas.core.indexes.base import maybe_extract_name
 from pandas.core.indexes.numeric import (
-    Float64Index,
     Int64Index,
     NumericIndex,
 )
@@ -386,7 +385,7 @@ def _shallow_copy(self, values, name: Hashable = no_default):
         name = self.name if name is no_default else name
 
         if values.dtype.kind == "f":
-            return Float64Index(values, name=name)
+            return NumericIndex(values, name=name, dtype=np.float64)
         # GH 46675 & 43885: If values is equally spaced, return a
         # more memory-compact RangeIndex instead of Int64Index
         unique_diffs = unique_deltas(values)
@@ -395,7 +394,7 @@ def _shallow_copy(self, values, name: Hashable = no_default):
             new_range = range(values[0], values[-1] + diff, diff)
             return type(self)._simple_new(new_range, name=name)
         else:
-            return Int64Index._simple_new(values, name=name)
+            return NumericIndex._simple_new(values, name=name)
 
     def _view(self: RangeIndex) -> RangeIndex:
         result = type(self)._simple_new(self._range, name=self._name)
@@ -848,7 +847,7 @@ def _concat(self, indexes: list[Index], name: Hashable) -> Index:
                 # First non-empty index had only one element
                 if rng.start == start:
                     values = np.concatenate([x._values for x in rng_indexes])
-                    result = Int64Index(values)
+                    result = self._constructor(values)
                     return result.rename(name)
 
                 step = rng.start - start
@@ -857,7 +856,9 @@ def _concat(self, indexes: list[Index], name: Hashable) -> Index:
                 next_ is not None and rng.start != next_
             )
             if non_consecutive:
-                result = Int64Index(np.concatenate([x._values for x in rng_indexes]))
+                result = self._constructor(
+                    np.concatenate([x._values for x in rng_indexes])
+                )
                 return result.rename(name)
 
             if step is not None:
@@ -905,7 +906,6 @@ def __getitem__(self, key):
                 "and integer or boolean "
                 "arrays are valid indices"
             )
-        # fall back to Int64Index
         return super().__getitem__(key)
 
     def _getitem_slice(self: RangeIndex, slobj: slice) -> RangeIndex:
@@ -1010,15 +1010,14 @@ def _arith_method(self, other, op):
             res_name = ops.get_op_result_name(self, other)
             result = type(self)(rstart, rstop, rstep, name=res_name)
 
-            # for compat with numpy / Int64Index
+            # for compat with numpy / Index with int64 dtype
             # even if we can represent as a RangeIndex, return
-            # as a Float64Index if we have float-like descriptors
+            # as a float64 Index if we have float-like descriptors
             if not all(is_integer(x) for x in [rstart, rstop, rstep]):
                 result = result.astype("float64")
 
             return result
 
         except (ValueError, TypeError, ZeroDivisionError):
-            # Defer to Int64Index implementation
             # test_arithmetic_explicit_conversions
             return super()._arith_method(other, op)

pandas/tests/indexes/ranges/test_join.py

@@ -5,20 +5,19 @@
     RangeIndex,
 )
 import pandas._testing as tm
-from pandas.core.indexes.api import Int64Index
 
 
 class TestJoin:
     def test_join_outer(self):
-        # join with Int64Index
+        # join with Index[int64]
         index = RangeIndex(start=0, stop=20, step=2)
-        other = Int64Index(np.arange(25, 14, -1))
+        other = Index(np.arange(25, 14, -1, dtype=np.int64))
 
         res, lidx, ridx = index.join(other, how="outer", return_indexers=True)
         noidx_res = index.join(other, how="outer")
         tm.assert_index_equal(res, noidx_res)
 
-        eres = Int64Index(
+        eres = Index(
             [0, 2, 4, 6, 8, 10, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]
         )
         elidx = np.array(
@@ -30,9 +29,9 @@ def test_join_outer(self):
             dtype=np.intp,
         )
 
-        assert isinstance(res, Int64Index)
+        assert isinstance(res, Index) and res.dtype == np.int64
         assert not isinstance(res, RangeIndex)
-        tm.assert_index_equal(res, eres)
+        tm.assert_index_equal(res, eres, exact=True)
         tm.assert_numpy_array_equal(lidx, elidx)
         tm.assert_numpy_array_equal(ridx, eridx)
 
@@ -43,7 +42,7 @@ def test_join_outer(self):
         noidx_res = index.join(other, how="outer")
         tm.assert_index_equal(res, noidx_res)
 
-        assert isinstance(res, Int64Index)
+        assert isinstance(res, Index) and res.dtype == np.int64
         assert not isinstance(res, RangeIndex)
         tm.assert_index_equal(res, eres)
         tm.assert_numpy_array_equal(lidx, elidx)
@@ -52,7 +51,7 @@ def test_join_outer(self):
     def test_join_inner(self):
         # Join with non-RangeIndex
         index = RangeIndex(start=0, stop=20, step=2)
-        other = Int64Index(np.arange(25, 14, -1))
+        other = Index(np.arange(25, 14, -1, dtype=np.int64))
 
         res, lidx, ridx = index.join(other, how="inner", return_indexers=True)
 
@@ -62,7 +61,7 @@ def test_join_inner(self):
         lidx = lidx.take(ind)
         ridx = ridx.take(ind)
 
-        eres = Int64Index([16, 18])
+        eres = Index([16, 18])
         elidx = np.array([8, 9], dtype=np.intp)
         eridx = np.array([9, 7], dtype=np.intp)
 
@@ -82,9 +81,9 @@ def test_join_inner(self):
         tm.assert_numpy_array_equal(ridx, eridx)
 
     def test_join_left(self):
-        # Join with Int64Index
+        # Join with Index[int64]
         index = RangeIndex(start=0, stop=20, step=2)
-        other = Int64Index(np.arange(25, 14, -1))
+        other = Index(np.arange(25, 14, -1, dtype=np.int64))
 
         res, lidx, ridx = index.join(other, how="left", return_indexers=True)
         eres = index
@@ -96,7 +95,7 @@ def test_join_left(self):
         tm.assert_numpy_array_equal(ridx, eridx)
 
         # Join withRangeIndex
-        other = Int64Index(np.arange(25, 14, -1))
+        other = Index(np.arange(25, 14, -1, dtype=np.int64))
 
         res, lidx, ridx = index.join(other, how="left", return_indexers=True)
 
@@ -106,15 +105,15 @@ def test_join_left(self):
         tm.assert_numpy_array_equal(ridx, eridx)
 
     def test_join_right(self):
-        # Join with Int64Index
+        # Join with Index[int64]
         index = RangeIndex(start=0, stop=20, step=2)
-        other = Int64Index(np.arange(25, 14, -1))
+        other = Index(np.arange(25, 14, -1, dtype=np.int64))
 
         res, lidx, ridx = index.join(other, how="right", return_indexers=True)
         eres = other
         elidx = np.array([-1, -1, -1, -1, -1, -1, -1, 9, -1, 8, -1], dtype=np.intp)
 
-        assert isinstance(other, Int64Index)
+        assert isinstance(other, Index) and other.dtype == np.int64
         tm.assert_index_equal(res, eres)
         tm.assert_numpy_array_equal(lidx, elidx)
         assert ridx is None
@@ -164,7 +163,7 @@ def test_join_non_unique(self):
 
         res, lidx, ridx = index.join(other, return_indexers=True)
 
-        eres = Int64Index([0, 2, 4, 4, 6, 8, 10, 12, 14, 16, 18])
+        eres = Index([0, 2, 4, 4, 6, 8, 10, 12, 14, 16, 18])
         elidx = np.array([0, 1, 2, 2, 3, 4, 5, 6, 7, 8, 9], dtype=np.intp)
         eridx = np.array([-1, -1, 0, 1, -1, -1, -1, -1, -1, -1, -1], dtype=np.intp)
 

pandas/tests/indexes/ranges/test_range.py

@@ -4,20 +4,15 @@
 from pandas.core.dtypes.common import ensure_platform_int
 
 import pandas as pd
-import pandas._testing as tm
-from pandas.core.indexes.api import (
-    Float64Index,
+from pandas import (
     Index,
-    Int64Index,
     RangeIndex,
 )
+import pandas._testing as tm
 from pandas.tests.indexes.common import NumericBase
 
 # aliases to make some tests easier to read
 RI = RangeIndex
-I64 = Int64Index
-F64 = Float64Index
-OI = Index
 
 
 class TestRangeIndex(NumericBase):
@@ -111,7 +106,7 @@ def test_insert(self):
         tm.assert_index_equal(idx[0:4], result.insert(0, idx[0]), exact="equiv")
 
         # GH 18295 (test missing)
-        expected = Float64Index([0, np.nan, 1, 2, 3, 4])
+        expected = Index([0, np.nan, 1, 2, 3, 4], dtype=np.float64)
         for na in [np.nan, None, pd.NA]:
             result = RangeIndex(5).insert(1, na)
             tm.assert_index_equal(result, expected)
@@ -379,7 +374,7 @@ def test_nbytes(self):
 
         # memory savings vs int index
         idx = RangeIndex(0, 1000)
-        assert idx.nbytes < Int64Index(idx._values).nbytes / 10
+        assert idx.nbytes < Index(idx._values).nbytes / 10
 
         # constant memory usage
         i2 = RangeIndex(0, 10)
@@ -530,16 +525,16 @@ def test_len_specialised(self, step):
             ([RI(-4, -8), RI(-8, -12)], RI(0, 0)),
             ([RI(-4, -8), RI(3, -4)], RI(0, 0)),
             ([RI(-4, -8), RI(3, 5)], RI(3, 5)),
-            ([RI(-4, -2), RI(3, 5)], I64([-4, -3, 3, 4])),
+            ([RI(-4, -2), RI(3, 5)], Index([-4, -3, 3, 4])),
             ([RI(-2), RI(3, 5)], RI(3, 5)),
-            ([RI(2), RI(2)], I64([0, 1, 0, 1])),
+            ([RI(2), RI(2)], Index([0, 1, 0, 1])),
             ([RI(2), RI(2, 5), RI(5, 8, 4)], RI(0, 6)),
-            ([RI(2), RI(3, 5), RI(5, 8, 4)], I64([0, 1, 3, 4, 5])),
+            ([RI(2), RI(3, 5), RI(5, 8, 4)], Index([0, 1, 3, 4, 5])),
             ([RI(-2, 2), RI(2, 5), RI(5, 8, 4)], RI(-2, 6)),
-            ([RI(3), OI([-1, 3, 15])], OI([0, 1, 2, -1, 3, 15])),
-            ([RI(3), OI([-1, 3.1, 15.0])], OI([0, 1, 2, -1, 3.1, 15.0])),
-            ([RI(3), OI(["a", None, 14])], OI([0, 1, 2, "a", None, 14])),
-            ([RI(3, 1), OI(["a", None, 14])], OI(["a", None, 14])),
+            ([RI(3), Index([-1, 3, 15])], Index([0, 1, 2, -1, 3, 15])),
+            ([RI(3), Index([-1, 3.1, 15.0])], Index([0, 1, 2, -1, 3.1, 15.0])),
+            ([RI(3), Index(["a", None, 14])], Index([0, 1, 2, "a", None, 14])),
+            ([RI(3, 1), Index(["a", None, 14])], Index(["a", None, 14])),
         ]
     )
     def appends(self, request):