Merge branch 'pandas-dev:main' into ordered_cat_corr

Author: pandeconscious

doc/source/whatsnew/v3.0.0.rst

@@ -1112,6 +1112,7 @@ Conversion
 - Bug in :meth:`DataFrame.astype` not casting ``values`` for Arrow-based dictionary dtype correctly (:issue:`58479`)
 - Bug in :meth:`DataFrame.update` bool dtype being converted to object (:issue:`55509`)
 - Bug in :meth:`Series.astype` might modify read-only array inplace when casting to a string dtype (:issue:`57212`)
+- Bug in :meth:`Series.convert_dtypes` and :meth:`DataFrame.convert_dtypes` raising ``TypeError`` when called on data with complex dtype (:issue:`60129`)
 - Bug in :meth:`Series.convert_dtypes` and :meth:`DataFrame.convert_dtypes` removing timezone information for objects with :class:`ArrowDtype` (:issue:`60237`)
 - Bug in :meth:`Series.reindex` not maintaining ``float32`` type when a ``reindex`` introduces a missing value (:issue:`45857`)
 - Bug in :meth:`to_datetime` and :meth:`to_timedelta` with input ``None`` returning ``None`` instead of ``NaT``, inconsistent with other conversion methods (:issue:`23055`)
@@ -1128,6 +1129,7 @@ Interval
 - :meth:`Index.is_monotonic_decreasing`, :meth:`Index.is_monotonic_increasing`, and :meth:`Index.is_unique` could incorrectly be ``False`` for an ``Index`` created from a slice of another ``Index``. (:issue:`57911`)
 - Bug in :class:`Index`, :class:`Series`, :class:`DataFrame` constructors when given a sequence of :class:`Interval` subclass objects casting them to :class:`Interval` (:issue:`46945`)
 - Bug in :func:`interval_range` where start and end numeric types were always cast to 64 bit (:issue:`57268`)
+- Bug in :func:`pandas.interval_range` incorrectly inferring ``int64`` dtype when ``np.float32`` and ``int`` are used for ``start`` and ``freq`` (:issue:`58964`)
 - Bug in :meth:`IntervalIndex.get_indexer` and :meth:`IntervalIndex.drop` when one of the sides of the index is non-unique (:issue:`52245`)
 - Construction of :class:`IntervalArray` and :class:`IntervalIndex` from arrays with mismatched signed/unsigned integer dtypes (e.g., ``int64`` and ``uint64``) now raises a :exc:`TypeError` instead of proceeding silently. (:issue:`55715`)
 

pandas/core/dtypes/cast.py

@@ -934,6 +934,9 @@ def convert_dtypes(
     if (
         convert_string or convert_integer or convert_boolean or convert_floating
     ) and isinstance(input_array, np.ndarray):
+        if input_array.dtype.kind == "c":
+            return input_array.dtype
+
         if input_array.dtype == object:
             inferred_dtype = lib.infer_dtype(input_array)
         else:
@@ -954,7 +957,7 @@ def convert_dtypes(
                 inferred_dtype = NUMPY_INT_TO_DTYPE.get(
                     input_array.dtype, target_int_dtype
                 )
-            elif input_array.dtype.kind in "fcb":
+            elif input_array.dtype.kind in "fb":
                 # TODO: de-dup with maybe_cast_to_integer_array?
                 arr = input_array[notna(input_array)]
                 if len(arr) < len(input_array) and not is_nan_na():
@@ -972,7 +975,7 @@ def convert_dtypes(
                 inferred_dtype = target_int_dtype
 
         if convert_floating:
-            if input_array.dtype.kind in "fcb":
+            if input_array.dtype.kind in "fb":
                 # i.e. numeric but not integer
                 from pandas.core.arrays.floating import NUMPY_FLOAT_TO_DTYPE
 
@@ -1028,11 +1031,11 @@ def convert_dtypes(
 
         if (
             (convert_integer and inferred_dtype.kind in "iu")
-            or (convert_floating and inferred_dtype.kind in "fc")
+            or (convert_floating and inferred_dtype.kind in "f")
             or (convert_boolean and inferred_dtype.kind == "b")
             or (convert_string and isinstance(inferred_dtype, StringDtype))
             or (
-                inferred_dtype.kind not in "iufcb"
+                inferred_dtype.kind not in "iufb"
                 and not isinstance(inferred_dtype, StringDtype)
                 and not isinstance(inferred_dtype, CategoricalDtype)
             )

pandas/core/indexes/interval.py

@@ -1420,17 +1420,17 @@ def interval_range(
         dtype: np.dtype = np.dtype("int64")
         if com.all_not_none(start, end, freq):
             if (
-                isinstance(start, (float, np.float16))
-                or isinstance(end, (float, np.float16))
-                or isinstance(freq, (float, np.float16))
-            ):
-                dtype = np.dtype("float64")
-            elif (
                 isinstance(start, (np.integer, np.floating))
                 and isinstance(end, (np.integer, np.floating))
                 and start.dtype == end.dtype
             ):
                 dtype = start.dtype
+            elif (
+                isinstance(start, (float, np.floating))
+                or isinstance(end, (float, np.floating))
+                or isinstance(freq, (float, np.floating))
+            ):
+                dtype = np.dtype("float64")
             # 0.1 ensures we capture end
             breaks = np.arange(start, end + (freq * 0.1), freq)
             breaks = maybe_downcast_numeric(breaks, dtype)

pandas/tests/frame/methods/test_convert_dtypes.py

@@ -228,3 +228,15 @@ def test_convert_dtype_pyarrow_timezone_preserve(self):
         result = df.convert_dtypes(dtype_backend="pyarrow")
         expected = df.copy()
         tm.assert_frame_equal(result, expected)
+
+    def test_convert_dtypes_complex(self):
+        # GH 60129
+        df = pd.DataFrame({"a": [1.0 + 5.0j, 1.5 - 3.0j], "b": [1, 2]})
+        expected = pd.DataFrame(
+            {
+                "a": pd.array([1.0 + 5.0j, 1.5 - 3.0j], dtype="complex128"),
+                "b": pd.array([1, 2], dtype="Int64"),
+            }
+        )
+        result = df.convert_dtypes()
+        tm.assert_frame_equal(result, expected)

pandas/tests/frame/methods/test_rename_axis.py

@@ -28,6 +28,18 @@ def test_rename_axis_inplace(self, float_frame):
         assert no_return is None
         tm.assert_frame_equal(result, expected)
 
+    def test_rename_axis_with_allows_duplicate_labels_false(self):
+        # GH#44958
+        df = DataFrame([[1, 2], [3, 4]], columns=["a", "b"]).set_flags(
+            allows_duplicate_labels=False
+        )
+
+        result = df.rename_axis("idx", axis=0)
+        expected = DataFrame(
+            [[1, 2], [3, 4]], index=Index([0, 1], name="idx"), columns=["a", "b"]
+        )
+        tm.assert_frame_equal(result, expected, check_flags=False)
+
     def test_rename_axis_raises(self):
         # GH#17833
         df = DataFrame({"A": [1, 2], "B": [1, 2]})

pandas/tests/frame/methods/test_set_axis.py

@@ -112,6 +112,16 @@ def obj(self):
         )
         return df
 
+    def test_set_axis_with_allows_duplicate_labels_false(self):
+        # GH#44958
+        df = DataFrame([[1, 2], [3, 4]], columns=["a", "b"]).set_flags(
+            allows_duplicate_labels=False
+        )
+
+        result = df.set_axis(labels=["x", "y"], axis=0)
+        expected = DataFrame([[1, 2], [3, 4]], index=["x", "y"], columns=["a", "b"])
+        tm.assert_frame_equal(result, expected, check_flags=False)
+
 
 class TestSeriesSetAxis(SharedSetAxisTests):
     @pytest.fixture

pandas/tests/indexes/interval/test_interval_range.py

@@ -380,3 +380,11 @@ def test_float_freq(self):
         result = interval_range(0, 1, freq=0.6)
         expected = IntervalIndex.from_breaks([0, 0.6])
         tm.assert_index_equal(result, expected)
+
+    def test_interval_range_float32_start_int_freq(self):
+        # GH 58964
+        result = interval_range(start=np.float32(0), end=2, freq=1)
+        expected = IntervalIndex.from_tuples(
+            [(0.0, 1.0), (1.0, 2.0)], dtype="interval[float64, right]"
+        )
+        tm.assert_index_equal(result, expected)

pandas/tests/io/parser/test_na_values.py

@@ -499,13 +499,8 @@ def test_na_values_scalar(all_parsers, na_values, row_data):
     data = "1,2\n2,1"
 
     if parser.engine == "pyarrow" and isinstance(na_values, dict):
-        if isinstance(na_values, dict):
-            err = ValueError
-            msg = "The pyarrow engine doesn't support passing a dict for na_values"
-        else:
-            err = TypeError
-            msg = "The 'pyarrow' engine requires all na_values to be strings"
-        with pytest.raises(err, match=msg):
+        msg = "The pyarrow engine doesn't support passing a dict for na_values"
+        with pytest.raises(ValueError, match=msg):
             parser.read_csv(StringIO(data), names=names, na_values=na_values)
         return
     elif parser.engine == "pyarrow":

pandas/tests/series/methods/test_convert_dtypes.py

@@ -332,3 +332,9 @@ def test_convert_dtype_pyarrow_timezone_preserve(self):
         result = ser.convert_dtypes(dtype_backend="pyarrow")
         expected = ser.copy()
         tm.assert_series_equal(result, expected)
+
+    def test_convert_dtypes_complex(self):
+        # GH 60129
+        ser = pd.Series([1.5 + 3.0j, 1.5 - 3.0j])
+        result = ser.convert_dtypes()
+        tm.assert_series_equal(result, ser)