wip

Author: MarcoGorelli

pandas/tests/frame/indexing/test_indexing.py

@@ -9,7 +9,6 @@
 import numpy as np
 import pytest
 
-from pandas._libs import iNaT
 from pandas.errors import InvalidIndexError
 
 from pandas.core.dtypes.common import is_integer
@@ -25,7 +24,6 @@
     Timestamp,
     date_range,
     isna,
-    notna,
     to_datetime,
 )
 import pandas._testing as tm
@@ -832,15 +830,6 @@ def test_setitem_single_column_mixed_datetime(self):
         )
         tm.assert_series_equal(result, expected)
 
-        # GH#16674 iNaT is treated as an integer when given by the user
-        with tm.assert_produces_warning(
-            FutureWarning, match="Setting an item of incompatible dtype"
-        ):
-            df.loc["b", "timestamp"] = iNaT
-        assert not isna(df.loc["b", "timestamp"])
-        assert df["timestamp"].dtype == np.object_
-        assert df.loc["b", "timestamp"] == iNaT
-
         # allow this syntax (as of GH#3216)
         df.loc["c", "timestamp"] = np.nan
         assert isna(df.loc["c", "timestamp"])
@@ -849,38 +838,6 @@ def test_setitem_single_column_mixed_datetime(self):
         df.loc["d", :] = np.nan
         assert not isna(df.loc["c", :]).all()
 
-    def test_setitem_mixed_datetime(self):
-        # GH 9336
-        expected = DataFrame(
-            {
-                "a": [0, 0, 0, 0, 13, 14],
-                "b": [
-                    datetime(2012, 1, 1),
-                    1,
-                    "x",
-                    "y",
-                    datetime(2013, 1, 1),
-                    datetime(2014, 1, 1),
-                ],
-            }
-        )
-        df = DataFrame(0, columns=list("ab"), index=range(6))
-        df["b"] = pd.NaT
-        df.loc[0, "b"] = datetime(2012, 1, 1)
-        with tm.assert_produces_warning(
-            FutureWarning, match="Setting an item of incompatible dtype"
-        ):
-            df.loc[1, "b"] = 1
-        df.loc[[2, 3], "b"] = "x", "y"
-        A = np.array(
-            [
-                [13, np.datetime64("2013-01-01T00:00:00")],
-                [14, np.datetime64("2014-01-01T00:00:00")],
-            ]
-        )
-        df.loc[[4, 5], ["a", "b"]] = A
-        tm.assert_frame_equal(df, expected)
-
     def test_setitem_frame_float(self, float_frame):
         piece = float_frame.loc[float_frame.index[:2], ["A", "B"]]
         float_frame.loc[float_frame.index[-2] :, ["A", "B"]] = piece.values
@@ -932,17 +889,6 @@ def test_setitem_frame_mixed_ndarray(self, float_string_frame):
         f.loc[key] = piece.values
         tm.assert_almost_equal(f.loc[f.index[-2:], ["A", "B"]].values, piece.values)
 
-    def test_setitem_frame_upcast(self):
-        # needs upcasting
-        df = DataFrame([[1, 2, "foo"], [3, 4, "bar"]], columns=["A", "B", "C"])
-        df2 = df.copy()
-        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
-            df2.loc[:, ["A", "B"]] = df.loc[:, ["A", "B"]] + 0.5
-        expected = df.reindex(columns=["A", "B"])
-        expected += 0.5
-        expected["C"] = df["C"]
-        tm.assert_frame_equal(df2, expected)
-
     def test_setitem_frame_align(self, float_frame):
         piece = float_frame.loc[float_frame.index[:2], ["A", "B"]]
         piece.index = float_frame.index[-2:]
@@ -1353,26 +1299,6 @@ def test_loc_expand_empty_frame_keep_midx_names(self):
         )
         tm.assert_frame_equal(df, expected)
 
-    @pytest.mark.parametrize(
-        "val, idxr",
-        [
-            ("x", "a"),
-            ("x", ["a"]),
-            (1, "a"),
-            (1, ["a"]),
-        ],
-    )
-    def test_loc_setitem_rhs_frame(self, idxr, val):
-        # GH#47578
-        df = DataFrame({"a": [1, 2]})
-
-        with tm.assert_produces_warning(
-            FutureWarning, match="Setting an item of incompatible dtype"
-        ):
-            df.loc[:, idxr] = DataFrame({"a": [val, 11]}, index=[1, 2])
-        expected = DataFrame({"a": [np.nan, val]})
-        tm.assert_frame_equal(df, expected)
-
     def test_iloc_setitem_enlarge_no_warning(self):
         # GH#47381
         df = DataFrame(columns=["a", "b"])
@@ -1576,22 +1502,6 @@ def test_setitem(self):
         tm.assert_series_equal(df["D"], Series(idx, name="D"))
         del df["D"]
 
-        # With NaN: because uint64 has no NaN element,
-        # the column should be cast to object.
-        df2 = df.copy()
-        with tm.assert_produces_warning(FutureWarning, match="incompatible dtype"):
-            df2.iloc[1, 1] = pd.NaT
-            df2.iloc[1, 2] = pd.NaT
-        result = df2["B"]
-        tm.assert_series_equal(notna(result), Series([True, False, True], name="B"))
-        tm.assert_series_equal(
-            df2.dtypes,
-            Series(
-                [np.dtype("uint64"), np.dtype("O"), np.dtype("O")],
-                index=["A", "B", "C"],
-            ),
-        )
-
 
 def test_object_casting_indexing_wraps_datetimelike():
     # GH#31649, check the indexing methods all the way down the stack
@@ -1927,21 +1837,30 @@ class TestSetitemValidation:
     # This is adapted from pandas/tests/arrays/masked/test_indexing.py
     # but checks for warnings instead of errors.
     def _check_setitem_invalid(self, df, invalid, indexer, warn):
-        msg = "Setting an item of incompatible dtype is deprecated"
-        msg = re.escape(msg)
-
         orig_df = df.copy()
 
         # iloc
-        with tm.assert_produces_warning(warn, match=msg):
+        with pytest.raises(TypeError, match="Invalid value"):
             df.iloc[indexer, 0] = invalid
             df = orig_df.copy()
 
         # loc
-        with tm.assert_produces_warning(warn, match=msg):
+        with pytest.raises(TypeError, match="Invalid value"):
             df.loc[indexer, "a"] = invalid
             df = orig_df.copy()
 
+    def _check_setitem_valid(self, df, invalid, indexer):
+        # Just execute, verify no error is raised
+        orig_df = df.copy()
+
+        # iloc
+        df.iloc[indexer, 0] = invalid
+        df = orig_df.copy()
+
+        # loc
+        df.loc[indexer, "a"] = invalid
+        df = orig_df.copy()
+
     _invalid_scalars = [
         1 + 2j,
         "True",
@@ -1959,20 +1878,19 @@ def _check_setitem_invalid(self, df, invalid, indexer, warn):
     @pytest.mark.parametrize("indexer", _indexers)
     def test_setitem_validation_scalar_bool(self, invalid, indexer):
         df = DataFrame({"a": [True, False, False]}, dtype="bool")
-        self._check_setitem_invalid(df, invalid, indexer, FutureWarning)
+        self._check_setitem_invalid(df, invalid, indexer)
 
     @pytest.mark.parametrize("invalid", _invalid_scalars + [True, 1.5, np.float64(1.5)])
     @pytest.mark.parametrize("indexer", _indexers)
     def test_setitem_validation_scalar_int(self, invalid, any_int_numpy_dtype, indexer):
         df = DataFrame({"a": [1, 2, 3]}, dtype=any_int_numpy_dtype)
         if isna(invalid) and invalid is not pd.NaT and not np.isnat(invalid):
-            warn = None
+            self._check_setitem_valid(df, invalid, indexer)
         else:
-            warn = FutureWarning
-        self._check_setitem_invalid(df, invalid, indexer, warn)
+            self._check_setitem_invalid(df, invalid, indexer)
 
     @pytest.mark.parametrize("invalid", _invalid_scalars + [True])
     @pytest.mark.parametrize("indexer", _indexers)
     def test_setitem_validation_scalar_float(self, invalid, float_numpy_dtype, indexer):
         df = DataFrame({"a": [1, 2, None]}, dtype=float_numpy_dtype)
-        self._check_setitem_invalid(df, invalid, indexer, FutureWarning)
+        self._check_setitem_invalid(df, invalid, indexer)