Merge remote-tracking branch 'upstream/main' into test_numpy_complex2

pandas/tests/arithmetic/test_numeric.py

@@ -1116,11 +1116,10 @@ def test_ufunc_compat(self, holder, dtype):
         tm.assert_equal(result, expected)
 
     # TODO: add more dtypes
-    @pytest.mark.parametrize("holder", [Index, Series])
     @pytest.mark.parametrize("dtype", [np.int64, np.uint64, np.float64, np.complex128])
-    def test_ufunc_coercions(self, holder, dtype):
-        idx = holder([1, 2, 3, 4, 5], dtype=dtype, name="x")
-        box = Series if holder is Series else Index
+    def test_ufunc_coercions(self, index_or_series, dtype):
+        idx = index_or_series([1, 2, 3, 4, 5], dtype=dtype, name="x")
+        box = index_or_series
 
         result = np.sqrt(idx)
         if result.dtype.kind == "c":

pandas/tests/extension/base/io.py

@@ -17,6 +17,26 @@ def test_EA_types(self, engine, data, request):
                     reason=f"engine '{engine}' cannot parse the dtype {data.dtype.name}"
                 )
             )
+        if isinstance(data.dtype, pd.CategoricalDtype):
+            # in parsers.pyx _convert_with_dtype there is special-casing for
+            #  Categorical that pre-empts _from_sequence_of_strings
+            pass
+        elif isinstance(data.dtype, pd.core.dtypes.dtypes.NumpyEADtype):
+            # These get unwrapped internally so are treated as numpy dtypes
+            #  in the parsers.pyx code
+            pass
+        elif (
+            type(data)._from_sequence_of_strings.__func__
+            is ExtensionArray._from_sequence_of_strings.__func__
+        ):
+            # i.e. the EA hasn't overridden _from_sequence_of_strings
+            mark = pytest.mark.xfail(
+                reason="_from_sequence_of_strings not implemented",
+                raises=NotImplementedError,
+            )
+            request.node.add_marker(mark)
+
+>>>>>>> upstream/main
         df = pd.DataFrame({"with_dtype": pd.Series(data, dtype=str(data.dtype))})
         csv_output = df.to_csv(index=False, na_rep=np.nan)
         result = pd.read_csv(

pandas/tests/extension/decimal/test_decimal.py

@@ -257,7 +257,6 @@ def test_fillna_copy_series(self, data_missing, using_copy_on_write):
         with tm.assert_produces_warning(warn, match=msg, check_stacklevel=False):
             super().test_fillna_copy_series(data_missing)
 
-    @pytest.mark.parametrize("dropna", [True, False])
     def test_value_counts(self, all_data, dropna):
         all_data = all_data[:10]
         if dropna:

pandas/tests/extension/test_datetime.py

@@ -117,12 +117,6 @@ def test_map(self, data, na_action):
         result = data.map(lambda x: x, na_action=na_action)
         tm.assert_extension_array_equal(result, data)
 
-    @pytest.mark.parametrize("engine", ["c", "python"])
-    def test_EA_types(self, engine, data, request):
-        expected_msg = r".*must implement _from_sequence_of_strings.*"
-        with pytest.raises(NotImplementedError, match=expected_msg):
-            super().test_EA_types(engine, data, request)
-
     def check_reduce(self, ser: pd.Series, op_name: str, skipna: bool):
         if op_name in ["median", "mean", "std"]:
             alt = ser.astype("int64")

pandas/tests/extension/test_interval.py

@@ -90,12 +90,6 @@ def _supports_reduction(self, ser: pd.Series, op_name: str) -> bool:
     def test_fillna_length_mismatch(self, data_missing):
         super().test_fillna_length_mismatch(data_missing)
 
-    @pytest.mark.parametrize("engine", ["c", "python"])
-    def test_EA_types(self, engine, data, request):
-        expected_msg = r".*must implement _from_sequence_of_strings.*"
-        with pytest.raises(NotImplementedError, match=expected_msg):
-            super().test_EA_types(engine, data, request)
-
 
 # TODO: either belongs in tests.arrays.interval or move into base tests.
 def test_fillna_non_scalar_raises(data_missing):

pandas/tests/extension/test_numpy.py

@@ -286,36 +286,54 @@ def _get_expected_exception(
                     return TypeError
         return super()._get_expected_exception(op_name, obj, other)
 
-    @skip_nested
+    def test_divmod(self, data):
+        divmod_exc = None
+        if data.dtype.kind == "O":
+            divmod_exc = TypeError
+        self.divmod_exc = divmod_exc
+        super().test_divmod(data)
+
+    def test_divmod_series_array(self, data):
+        ser = pd.Series(data)
+        exc = None
+        if data.dtype.kind == "O":
+            exc = TypeError
+            self.divmod_exc = exc
+        self._check_divmod_op(ser, divmod, data)
+
     def test_arith_series_with_scalar(self, data, all_arithmetic_operators, request):
-        super().test_arith_series_with_scalar(
-            data, all_arithmetic_operators, request=request
-        )
+        opname = all_arithmetic_operators
+        series_scalar_exc = None
+        if data.dtype.numpy_dtype == object:
+            if opname in ["__mul__", "__rmul__"]:
+                mark = pytest.mark.xfail(
+                    reason="the Series.combine step raises but not the Series method."
+                )
+                request.node.add_marker(mark)
+            series_scalar_exc = TypeError
+        self.series_scalar_exc = series_scalar_exc
+        super().test_arith_series_with_scalar(data, all_arithmetic_operators)
 
     def test_arith_series_with_array(self, data, all_arithmetic_operators):
         opname = all_arithmetic_operators
         series_array_exc = None
         if data.dtype.numpy_dtype == object and opname not in ["__add__", "__radd__"]:
-            mark = pytest.mark.xfail(reason="Fails for object dtype")
-            # TODO: check that we shouldn't use applymarker here instead
-            request.node.add_marker(mark)
-        # TODO: check that the request=request parameter is needed
-        super().test_arith_series_with_array(
-            data, all_arithmetic_operators, request=request
-        )
+            series_array_exc = TypeError
+        self.series_array_exc = series_array_exc
+        super().test_arith_series_with_array(data, all_arithmetic_operators)
 
-    @skip_nested
     def test_arith_frame_with_scalar(self, data, all_arithmetic_operators, request):
-        super().test_arith_frame_with_scalar(
-            data, all_arithmetic_operators, request=request
-        )
-
-    @skip_nested
-    def test_divmod(self, data, request):
-        super().test_divmod(data, request=request)
-
-    def test_divmod_series_array(self, data, data_for_twos, request):
-        super().test_divmod_series_array(data, data_for_twos, request=request)
+        opname = all_arithmetic_operators
+        frame_scalar_exc = None
+        if data.dtype.numpy_dtype == object:
+            if opname in ["__mul__", "__rmul__"]:
+                mark = pytest.mark.xfail(
+                    reason="the Series.combine step raises but not the Series method."
+                )
+                request.node.add_marker(mark)
+            frame_scalar_exc = TypeError
+        self.frame_scalar_exc = frame_scalar_exc
+        super().test_arith_frame_with_scalar(data, all_arithmetic_operators)
 
     def _supports_reduction(self, ser: pd.Series, op_name: str) -> bool:
         if ser.dtype.kind == "O":
@@ -363,12 +381,6 @@ def test_fillna_no_op_returns_copy(self, data, request):
             )
         super().test_fillna_no_op_returns_copy(data)
 
-
-class TestReshaping(BaseNumPyTests, base.BaseReshapingTests):
-    pass
-
-
-class TestSetitem(BaseNumPyTests, base.BaseSetitemTests):
     @skip_nested
     def test_setitem_invalid(self, data, invalid_scalar):
         # object dtype can hold anything, so doesn't raise

pandas/tests/extension/test_sparse.py

@@ -495,13 +495,9 @@ def test_sparse_array(self, data_for_compare: SparseArray, comparison_op, reques
     def test_array_repr(self, data, size):
         super().test_array_repr(data, size)
 
-
-class TestParsing(BaseSparseTests, base.BaseParsingTests):
-    @pytest.mark.parametrize("engine", ["c", "python"])
-    def test_EA_types(self, engine, data, request):
-        expected_msg = r".*must implement _from_sequence_of_strings.*"
-        with pytest.raises(NotImplementedError, match=expected_msg):
-            super().test_EA_types(engine, data, request)
+    @pytest.mark.xfail(reason="result does not match expected")
+    def test_groupby_extension_agg(self, as_index, data_for_grouping):
+        super().test_groupby_extension_agg(as_index, data_for_grouping)
 
 
 def test_array_type_with_arg(dtype):