ENH: Index.infer_objects (#50034)

* ENH: Index.infer_objects

* GH ref

* mypy fixup

* raise NotImplementedError for MultiIndex

Author: jbrockmendel

doc/source/whatsnew/v2.0.0.rst

@@ -83,6 +83,7 @@ Other enhancements
 - :func:`timedelta_range` now supports a ``unit`` keyword ("s", "ms", "us", or "ns") to specify the desired resolution of the output index (:issue:`49824`)
 - :meth:`DataFrame.to_json` now supports a ``mode`` keyword with supported inputs 'w' and 'a'. Defaulting to 'w', 'a' can be used when lines=True and orient='records' to append record oriented json lines to an existing json file. (:issue:`35849`)
 - Added ``name`` parameter to :meth:`IntervalIndex.from_breaks`, :meth:`IntervalIndex.from_arrays` and :meth:`IntervalIndex.from_tuples` (:issue:`48911`)
+- Added :meth:`Index.infer_objects` analogous to :meth:`Series.infer_objects` (:issue:`50034`)
 - :meth:`DataFrame.plot.hist` now recognizes ``xlabel`` and ``ylabel`` arguments (:issue:`49793`)
 -
 

pandas/core/indexes/base.py

@@ -6521,6 +6521,36 @@ def drop(
             indexer = indexer[~mask]
         return self.delete(indexer)
 
+    def infer_objects(self, copy: bool = True) -> Index:
+        """
+        If we have an object dtype, try to infer a non-object dtype.
+
+        Parameters
+        ----------
+        copy : bool, default True
+            Whether to make a copy in cases where no inference occurs.
+        """
+        if self._is_multi:
+            raise NotImplementedError(
+                "infer_objects is not implemented for MultiIndex. "
+                "Use index.to_frame().infer_objects() instead."
+            )
+        if self.dtype != object:
+            return self.copy() if copy else self
+
+        values = self._values
+        values = cast("npt.NDArray[np.object_]", values)
+        res_values = lib.maybe_convert_objects(
+            values,
+            convert_datetime=True,
+            convert_timedelta=True,
+            convert_period=True,
+            convert_interval=True,
+        )
+        if copy and res_values is values:
+            return self.copy()
+        return Index(res_values, name=self.name)
+
     # --------------------------------------------------------------------
     # Generated Arithmetic, Comparison, and Unary Methods
 

pandas/tests/indexes/multi/test_analytics.py

@@ -12,6 +12,11 @@
 from pandas.core.api import UInt64Index
 
 
+def test_infer_objects(idx):
+    with pytest.raises(NotImplementedError, match="to_frame"):
+        idx.infer_objects()
+
+
 def test_shift(idx):
 
     # GH8083 test the base class for shift

pandas/tests/series/methods/test_infer_objects.py

@@ -1,23 +1,24 @@
 import numpy as np
 
-from pandas import Series
 import pandas._testing as tm
 
 
 class TestInferObjects:
-    def test_infer_objects_series(self):
+    def test_infer_objects_series(self, index_or_series):
         # GH#11221
-        actual = Series(np.array([1, 2, 3], dtype="O")).infer_objects()
-        expected = Series([1, 2, 3])
-        tm.assert_series_equal(actual, expected)
+        actual = index_or_series(np.array([1, 2, 3], dtype="O")).infer_objects()
+        expected = index_or_series([1, 2, 3])
+        tm.assert_equal(actual, expected)
 
-        actual = Series(np.array([1, 2, 3, None], dtype="O")).infer_objects()
-        expected = Series([1.0, 2.0, 3.0, np.nan])
-        tm.assert_series_equal(actual, expected)
+        actual = index_or_series(np.array([1, 2, 3, None], dtype="O")).infer_objects()
+        expected = index_or_series([1.0, 2.0, 3.0, np.nan])
+        tm.assert_equal(actual, expected)
 
         # only soft conversions, unconvertable pass thru unchanged
-        actual = Series(np.array([1, 2, 3, None, "a"], dtype="O")).infer_objects()
-        expected = Series([1, 2, 3, None, "a"])
+
+        obj = index_or_series(np.array([1, 2, 3, None, "a"], dtype="O"))
+        actual = obj.infer_objects()
+        expected = index_or_series([1, 2, 3, None, "a"], dtype=object)
 
         assert actual.dtype == "object"
-        tm.assert_series_equal(actual, expected)
+        tm.assert_equal(actual, expected)