BUG: Special-case setting nan into integer series

pandas/_libs/lib.pyi

@@ -195,6 +195,7 @@ def array_equivalent_object(
     right: npt.NDArray[np.object_],
 ) -> bool: ...
 def has_infs(arr: np.ndarray) -> bool: ...  # const floating[:]
+def has_only_ints_or_nan(arr: np.ndarray) -> bool: ...  # const floating[:]
 def get_reverse_indexer(
     indexer: np.ndarray,  # const intp_t[:]
     length: int,

pandas/_libs/lib.pyx

@@ -530,6 +530,22 @@ def has_infs(floating[:] arr) -> bool:
     return ret
 
 
+@cython.boundscheck(False)
+@cython.wraparound(False)
+def has_only_ints_or_nan(floating[:] arr) -> bool:
+    cdef:
+        floating val
+        intp_t i
+
+    for i in range(len(arr)):
+        val = arr[i]
+        if (val != val) or (val == <int64_t>val):
+            continue
+        else:
+            return False
+    return True
+
+
 def maybe_indices_to_slice(ndarray[intp_t, ndim=1] indices, int max_len):
     cdef:
         Py_ssize_t i, n = len(indices)

pandas/core/internals/blocks.py

@@ -60,7 +60,10 @@
 from pandas.core.dtypes.common import (
     ensure_platform_int,
     is_1d_only_ea_dtype,
+    is_float_dtype,
+    is_integer_dtype,
     is_list_like,
+    is_scalar,
     is_string_dtype,
 )
 from pandas.core.dtypes.dtypes import (
@@ -454,6 +457,32 @@ def coerce_to_target_dtype(self, other, warn_on_upcast: bool = False) -> Block:
         and will receive the same block
         """
         new_dtype = find_result_type(self.values.dtype, other)
+
+        # In a future version of pandas, the default will be that
+        # setting `nan` into an integer series won't raise.
+        if is_scalar(other) and is_integer_dtype(self.values.dtype):
+            try:
+                is_nan = bool(np.isnan(other))
+            except TypeError:
+                # ufunc 'isnan' not supported for the input types
+                # boolean value of NA is ambiguous
+                is_nan = False
+            try:
+                is_nat = np.isnat(other)
+            except TypeError:
+                # ufunc 'isnat' is only defined for np.datetime64 and np.timedelta64
+                is_nat = False
+            if is_nan and not is_nat:
+                warn_on_upcast = False
+        elif (
+            isinstance(other, np.ndarray)
+            and other.ndim == 1
+            and is_integer_dtype(self.values.dtype)
+            and is_float_dtype(other.dtype)
+            and lib.has_only_ints_or_nan(other)
+        ):
+            warn_on_upcast = False
+
         if warn_on_upcast:
             warnings.warn(
                 f"Setting an item of incompatible dtype is deprecated "

pandas/tests/frame/indexing/test_indexing.py

@@ -337,18 +337,12 @@ def test_setitem(self, float_frame, using_copy_on_write):
     def test_setitem2(self):
         # dtype changing GH4204
         df = DataFrame([[0, 0]])
-        with tm.assert_produces_warning(
-            FutureWarning, match="Setting an item of incompatible dtype"
-        ):
-            df.iloc[0] = np.nan
+        df.iloc[0] = np.nan
         expected = DataFrame([[np.nan, np.nan]])
         tm.assert_frame_equal(df, expected)
 
         df = DataFrame([[0, 0]])
-        with tm.assert_produces_warning(
-            FutureWarning, match="Setting an item of incompatible dtype"
-        ):
-            df.loc[0] = np.nan
+        df.loc[0] = np.nan
         tm.assert_frame_equal(df, expected)
 
     def test_setitem_boolean(self, float_frame):

pandas/tests/indexing/test_indexing.py

@@ -830,8 +830,7 @@ def test_coercion_with_loc(self, expected):
         start_data, expected_result, warn = expected
 
         start_dataframe = DataFrame({"foo": start_data})
-        with tm.assert_produces_warning(warn, match="incompatible dtype"):
-            start_dataframe.loc[0, ["foo"]] = None
+        start_dataframe.loc[0, ["foo"]] = None
 
         expected_dataframe = DataFrame({"foo": expected_result})
         tm.assert_frame_equal(start_dataframe, expected_dataframe)
@@ -841,8 +840,7 @@ def test_coercion_with_setitem_and_dataframe(self, expected):
         start_data, expected_result, warn = expected
 
         start_dataframe = DataFrame({"foo": start_data})
-        with tm.assert_produces_warning(warn, match="incompatible dtype"):
-            start_dataframe[start_dataframe["foo"] == start_dataframe["foo"][0]] = None
+        start_dataframe[start_dataframe["foo"] == start_dataframe["foo"][0]] = None
 
         expected_dataframe = DataFrame({"foo": expected_result})
         tm.assert_frame_equal(start_dataframe, expected_dataframe)
@@ -852,10 +850,7 @@ def test_none_coercion_loc_and_dataframe(self, expected):
         start_data, expected_result, warn = expected
 
         start_dataframe = DataFrame({"foo": start_data})
-        with tm.assert_produces_warning(warn, match="incompatible dtype"):
-            start_dataframe.loc[
-                start_dataframe["foo"] == start_dataframe["foo"][0]
-            ] = None
+        start_dataframe.loc[start_dataframe["foo"] == start_dataframe["foo"][0]] = None
 
         expected_dataframe = DataFrame({"foo": expected_result})
         tm.assert_frame_equal(start_dataframe, expected_dataframe)
@@ -869,10 +864,7 @@ def test_none_coercion_mixed_dtypes(self):
                 "d": ["a", "b", "c"],
             }
         )
-        with tm.assert_produces_warning(
-            FutureWarning, match="item of incompatible dtype"
-        ):
-            start_dataframe.iloc[0] = None
+        start_dataframe.iloc[0] = None
 
         exp = DataFrame(
             {

pandas/tests/series/indexing/test_setitem.py

@@ -191,14 +191,11 @@ def test_setitem_series_object_dtype(self, indexer, ser_index):
         expected = Series([Series([42], index=[ser_index]), 0], dtype="object")
         tm.assert_series_equal(ser, expected)
 
-    @pytest.mark.parametrize(
-        "index, exp_value, warn", [(0, 42, None), (1, np.nan, FutureWarning)]
-    )
-    def test_setitem_series(self, index, exp_value, warn):
+    @pytest.mark.parametrize("index, exp_value", [(0, 42), (1, np.nan)])
+    def test_setitem_series(self, index, exp_value):
         # GH#38303
         ser = Series([0, 0])
-        with tm.assert_produces_warning(warn, match="item of incompatible dtype"):
-            ser.loc[0] = Series([42], index=[index])
+        ser.loc[0] = Series([42], index=[index])
         expected = Series([exp_value, 0])
         tm.assert_series_equal(ser, expected)
 
@@ -575,15 +572,15 @@ def test_setitem_keep_precision(self, any_numeric_ea_dtype):
         [
             (NA, NA, "Int64", "Int64", 1, None),
             (NA, NA, "Int64", "Int64", 2, None),
-            (NA, np.nan, "int64", "float64", 1, FutureWarning),
+            (NA, np.nan, "int64", "float64", 1, None),
             (NA, np.nan, "int64", "float64", 2, None),
             (NaT, NaT, "int64", "object", 1, FutureWarning),
             (NaT, NaT, "int64", "object", 2, None),
             (np.nan, NA, "Int64", "Int64", 1, None),
             (np.nan, NA, "Int64", "Int64", 2, None),
             (np.nan, NA, "Float64", "Float64", 1, None),
             (np.nan, NA, "Float64", "Float64", 2, None),
-            (np.nan, np.nan, "int64", "float64", 1, FutureWarning),
+            (np.nan, np.nan, "int64", "float64", 1, None),
             (np.nan, np.nan, "int64", "float64", 2, None),
         ],
     )
@@ -884,7 +881,7 @@ def test_index_putmask(self, obj, key, expected, warn, val):
             Series([2, 3, 4, 5, 6, 7, 8, 9, 10]),
             Series([np.nan, 3, np.nan, 5, np.nan, 7, np.nan, 9, np.nan]),
             slice(None, None, 2),
-            FutureWarning,
+            None,
             id="int_series_slice_key_step",
         ),
         pytest.param(
@@ -899,15 +896,15 @@ def test_index_putmask(self, obj, key, expected, warn, val):
             Series(np.arange(10)),
             Series([np.nan, np.nan, np.nan, np.nan, np.nan, 5, 6, 7, 8, 9]),
             slice(None, 5),
-            FutureWarning,
+            None,
             id="int_series_slice_key",
         ),
         pytest.param(
             # changes dtype GH#4463
             Series([1, 2, 3]),
             Series([np.nan, 2, 3]),
             0,
-            FutureWarning,
+            None,
             id="int_series_int_key",
         ),
         pytest.param(
@@ -1134,7 +1131,7 @@ def warn(self):
     "obj,expected,warn",
     [
         # For numeric series, we should coerce to NaN.
-        (Series([1, 2, 3]), Series([np.nan, 2, 3]), FutureWarning),
+        (Series([1, 2, 3]), Series([np.nan, 2, 3]), None),
         (Series([1.0, 2.0, 3.0]), Series([np.nan, 2.0, 3.0]), None),
         # For datetime series, we should coerce to NaT.
         (
@@ -1584,13 +1581,11 @@ def test_20643_comment():
     expected = Series([np.nan, 1, 2], index=["a", "b", "c"])
 
     ser = orig.copy()
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
-        ser.iat[0] = None
+    ser.iat[0] = None
     tm.assert_series_equal(ser, expected)
 
     ser = orig.copy()
-    with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
-        ser.iloc[0] = None
+    ser.iloc[0] = None
     tm.assert_series_equal(ser, expected)
 
 

pandas/tests/series/methods/test_convert_dtypes.py

@@ -206,17 +206,7 @@ def test_convert_dtypes(
         # Test that it is a copy
         copy = series.copy(deep=True)
 
-        if result.notna().sum() > 0 and result.dtype in [
-            "int8",
-            "uint8",
-            "int16",
-            "uint16",
-            "int32",
-            "uint32",
-            "int64",
-            "uint64",
-            "interval[int64, right]",
-        ]:
+        if result.notna().sum() > 0 and result.dtype in ["interval[int64, right]"]:
             with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
                 result[result.notna()] = np.nan
         else: