Revert "DEPR: warn on silent dtype changes during setitem-with-expansion"

This reverts commit 817819d.

Author: jbrockmendel

doc/source/whatsnew/v0.19.0.rst

@@ -762,7 +762,6 @@ A ``Series`` will now correctly promote its dtype for assignment with incompat v
 **New behavior**:
 
 .. ipython:: python
-   :okwarning:
 
    s["a"] = pd.Timestamp("2016-01-01")
    s["b"] = 3.0

doc/source/whatsnew/v3.1.0.rst

@@ -106,7 +106,6 @@ Deprecations
 - Deprecated passing a non-dict (e.g. a list of dicts) to :meth:`DataFrame.from_dict`. Use the :class:`DataFrame` constructor instead (:issue:`58862`)
 - Deprecated passing unnecessary ``*args`` and ``**kwargs`` to :meth:`.GroupBy.cumsum`, :meth:`.GroupBy.cumprod`, :meth:`.GroupBy.cummin`, :meth:`.GroupBy.cummax`, :meth:`.SeriesGroupBy.skew`, :meth:`.DataFrameGroupBy.skew`, :meth:`.SeriesGroupBy.take`, and :meth:`.DataFrameGroupBy.take`. The ``skipna`` parameter for the cum* methods is now an explicit keyword argument (:issue:`50407`)
 - Deprecated setting values with :meth:`DataFrame.at` and :meth:`Series.at` when the key does not exist in the index, which previously expanded the object. Use ``.loc`` instead (:issue:`48323`)
-- Deprecated silent dtype changes during setitem-with-expansion (e.g. ``ser.loc[new_key] = incompatible_value``). In a future version, the existing dtype will be retained instead of being silently changed. To keep the current behavior, cast the object to the desired dtype before the operation. The exception is int/uint to float when the value introduces ``NaN``, which is still allowed per PDEP-6 (:issue:`45070`)
 - Deprecated the ``.name`` property of offset objects (e.g., :class:`~pandas.tseries.offsets.Day`, :class:`~pandas.tseries.offsets.Hour`). Use ``.rule_code`` instead (:issue:`64207`)
 - Deprecated the ``dropna`` keyword in :meth:`DataFrame.to_hdf`, :meth:`HDFStore.put`, :meth:`HDFStore.append`, and :meth:`HDFStore.append_to_multiple`, and the ``io.hdf.dropna_table`` option. Use :meth:`DataFrame.dropna` before writing instead (:issue:`32038`)
 - Deprecated the ``float_precision`` argument in :func:`read_csv`, :func:`read_table`, and :func:`read_fwf`. All float precision modes now use the same converter (:issue:`64395`)

pandas/core/frame.py

@@ -14492,9 +14492,7 @@ def _append_internal(
             for i in range(len(self.columns)):
                 arr = self.iloc[:, i].array
 
-                casted = infer_and_maybe_downcast(
-                    arr, row_df.iloc[:, i]._values, warn_if_cast=False
-                )
+                casted = infer_and_maybe_downcast(arr, row_df.iloc[:, i]._values)
 
                 row_df.isetitem(i, casted)
 

pandas/core/indexing.py

@@ -60,7 +60,6 @@
     construct_1d_array_from_inferred_fill_value,
     infer_fill_value,
     is_valid_na_for_dtype,
-    isna,
     na_value_for_dtype,
 )
 
@@ -962,29 +961,20 @@ def __setitem__(self, key, value) -> None:
         iloc._setitem_with_indexer(indexer, value, self.name)
 
         if self.obj.shape[0] != orig_nrows:
-            # For empty DataFrames, suppress the deprecation warning —
-            # the placeholder dtypes aren't meaningful to preserve.
-            warn = self.obj.ndim == 1 or orig_nrows > 0
-            self._post_expansion_casting(
-                orig_dtype_info, orig_columns, warn_if_cast=warn
-            )
+            self._post_expansion_casting(orig_dtype_info, orig_columns)
 
     def _post_expansion_casting(
         self,
         orig_dtype_info: DtypeObj | npt.NDArray[np.object_],
         orig_columns: Index | None,
-        *,
-        warn_if_cast: bool = True,
     ) -> None:
         # setitem-with-expansion added new rows.  Try to retain
         #  original dtypes
         if self.obj.ndim == 1:
             assert not isinstance(orig_dtype_info, np.ndarray)
             if orig_dtype_info != self.obj.dtype:
                 orig_arr = pd_array([], dtype=orig_dtype_info)
-                new_arr = infer_and_maybe_downcast(
-                    orig_arr, self.obj._values, warn_if_cast=warn_if_cast
-                )
+                new_arr = infer_and_maybe_downcast(orig_arr, self.obj._values)
                 new_ser = self.obj._constructor(
                     new_arr, index=self.obj.index, name=self.obj.name
                 )
@@ -1000,9 +990,7 @@ def _post_expansion_casting(
                 for idx in np.flatnonzero(changed_dtypes):
                     orig_arr = pd_array([], dtype=orig_dtypes[idx])
                     new_arr = infer_and_maybe_downcast(
-                        orig_arr,
-                        self.obj.iloc[:, idx]._values,
-                        warn_if_cast=warn_if_cast,
+                        orig_arr, self.obj.iloc[:, idx]._values
                     )
                     self.obj.isetitem(idx, new_arr)
 
@@ -1014,9 +1002,7 @@ def _post_expansion_casting(
                     if new_dtype != orig_dtype:
                         orig_arr = pd_array([], dtype=orig_dtype)
                         new_arr = infer_and_maybe_downcast(
-                            orig_arr,
-                            self.obj[col]._values,
-                            warn_if_cast=warn_if_cast,
+                            orig_arr, self.obj[col]._values
                         )
                         self.obj[col] = new_arr
             else:
@@ -2872,15 +2858,12 @@ def _setitem_with_indexer_missing(self, indexer, value):
                     # Every NA value is suitable for object, no conversion needed
                     value = na_value_for_dtype(self.obj.dtype, compat=False)
 
-            new_values = infer_and_maybe_downcast(
-                self.obj.array, [value], warn_if_cast=False
-            )
+            new_values = infer_and_maybe_downcast(self.obj.array, [value])
 
             if len(self.obj._values):
                 # GH#22717 handle casting compatibility that np.concatenate
                 #  does incorrectly
                 new_values = concat_compat([self.obj._values, new_values])
-
             self.obj._mgr = self.obj._constructor(
                 new_values, index=new_index, name=self.obj.name
             )._mgr
@@ -3555,12 +3538,7 @@ def check_dict_or_set_indexers(key) -> None:
         )
 
 
-def infer_and_maybe_downcast(
-    orig: ExtensionArray,
-    new_arr,
-    *,
-    warn_if_cast: bool = True,
-) -> ArrayLike:
+def infer_and_maybe_downcast(orig: ExtensionArray, new_arr) -> ArrayLike:
     new_arr = orig._cast_pointwise_result(new_arr)
 
     dtype = orig.dtype
@@ -3572,36 +3550,4 @@ def infer_and_maybe_downcast(
 
     if is_np_dtype(new_arr.dtype, "f") and is_np_dtype(dtype, "iu"):
         new_arr = maybe_downcast_to_dtype(new_arr, dtype)
-    elif (
-        warn_if_cast and is_np_dtype(dtype, "fc") and is_np_dtype(new_arr.dtype, "iufc")
-    ):
-        # _cast_pointwise_result may have inferred a narrower numeric dtype
-        # (e.g. int64 from a float64 array with integer values).
-        # Cast back to the original dtype since float/complex can hold
-        # int/float values without loss.
-        new_arr = new_arr.astype(dtype, copy=False)
-
-    if warn_if_cast and new_arr.dtype != dtype:
-        # PDEP6 exception: int/uint -> float when result contains NaN
-        pdep6_allowed = (
-            is_np_dtype(dtype, "iu")
-            and is_np_dtype(new_arr.dtype, "f")
-            and isna(new_arr).any()
-        )
-        # If the original dtype can hold the new values (e.g. object
-        # can hold anything), retaining it in the future is fine.
-        orig_can_hold = can_hold_element(orig, new_arr)
-        if not pdep6_allowed and not orig_can_hold:
-            warnings.warn(
-                f"Setting an item of incompatible dtype is deprecated "
-                f"and will raise in a future version of pandas. "
-                f"The existing dtype is {dtype} but the new values "
-                f"have dtype {new_arr.dtype}. In a future version, the "
-                f"existing dtype will be retained. Cast the object to "
-                f"{new_arr.dtype} before this operation to retain the "
-                f"current behavior.",
-                Pandas4Warning,
-                stacklevel=find_stack_level(),
-            )
-
     return new_arr

pandas/tests/series/indexing/test_setitem.py

@@ -10,10 +10,7 @@
 
 from pandas.compat import HAS_PYARROW
 from pandas.compat.numpy import np_version_gt2
-from pandas.errors import (
-    IndexingError,
-    Pandas4Warning,
-)
+from pandas.errors import IndexingError
 
 from pandas.core.dtypes.common import is_list_like
 
@@ -521,30 +518,21 @@ def test_append_timedelta_does_not_cast(self, td, using_infer_string, request):
         # GH#22717 inserting a Timedelta should _not_ cast to int64
         expected = Series(["x", td], index=[0, "td"], dtype=object)
 
-        # With infer_string, dtype changes from str -> object; without it,
-        # the Series is already object so no dtype change occurs.
-        warn = Pandas4Warning if using_infer_string else None
-
         ser = Series(["x"])
-        with tm.assert_produces_warning(warn):
-            ser["td"] = td
+        ser["td"] = td
         tm.assert_series_equal(ser, expected)
         assert isinstance(ser["td"], Timedelta)
 
         ser = Series(["x"])
-        with tm.assert_produces_warning(warn):
-            ser.loc["td"] = Timedelta("9 days")
+        ser.loc["td"] = Timedelta("9 days")
         tm.assert_series_equal(ser, expected)
         assert isinstance(ser["td"], Timedelta)
 
     def test_setitem_with_expansion_type_promotion(self):
         # GH#12599
         ser = Series(dtype=object)
         ser["a"] = Timestamp("2016-01-01")
-        # After the first insert ser has datetime64 dtype; inserting a float
-        # is incompatible with that.
-        with tm.assert_produces_warning(Pandas4Warning):
-            ser["b"] = 3.0
+        ser["b"] = 3.0
         ser["c"] = "foo"
         expected = Series([Timestamp("2016-01-01"), 3.0, "foo"], index=["a", "b", "c"])
         tm.assert_series_equal(ser, expected)
@@ -600,6 +588,7 @@ def test_setitem_enlarge_with_na(
     def test_setitem_enlargement_object_none(self, nulls_fixture, using_infer_string):
         # GH#48665
         ser = Series(["a", "b"])
+        ser[3] = nulls_fixture
 
         dtype = (
             "str"
@@ -608,12 +597,6 @@ def test_setitem_enlargement_object_none(self, nulls_fixture, using_infer_string
             else object
         )
 
-        # Warn when the dtype changes (str -> object for Decimal without
-        # pyarrow); no warning when the dtype is preserved.
-        warn = Pandas4Warning if ser.dtype != dtype else None
-        with tm.assert_produces_warning(warn):
-            ser[3] = nulls_fixture
-
         expected = Series(["a", "b", nulls_fixture], index=[0, 1, 3], dtype=dtype)
         tm.assert_series_equal(ser, expected)
         if dtype == "str":