update exception messages

Author: jbrockmendel

asv_bench/benchmarks/groupby.py

@@ -760,6 +760,8 @@ def setup(self, dtype, method):
         )
 
     def time_str_func(self, dtype, method):
+        if dtype == "string[python]" and method == "sum":
+            raise NotImplementedError
         self.df.groupby("a")[self.df.columns[1:]].agg(method)
 
 

pandas/core/arrays/arrow/array.py

@@ -2256,7 +2256,9 @@ def _groupby_op(
                 "var",
                 "skew",
             ]:
-                raise TypeError(f"{self.dtype} dtype does not support {how} operations")
+                raise TypeError(
+                    f"dtype '{self.dtype}' does not support operation '{how}'"
+                )
             return super()._groupby_op(
                 how=how,
                 has_dropped_na=has_dropped_na,

pandas/core/arrays/base.py

@@ -2423,7 +2423,7 @@ def _groupby_op(
                 "skew",
             ]:
                 raise TypeError(
-                    f"{self.dtype} dtype does not support {op.how} operations"
+                    f"dtype '{self.dtype}' does not support operation '{how}'"
                 )
             if op.how not in ["any", "all"]:
                 # Fail early to avoid conversion to object

pandas/core/groupby/groupby.py

@@ -4292,7 +4292,7 @@ def pre_processor(vals: ArrayLike) -> tuple[np.ndarray, DtypeObj | None]:
                 )
             elif isinstance(vals.dtype, StringDtype):
                 raise TypeError(
-                    f"{vals.dtype} dtype does not support quantile operations"
+                    f"dtype '{vals.dtype}' does not support operation 'quantile'"
                 )
 
             inference: DtypeObj | None = None

pandas/tests/frame/test_stack_unstack.py

@@ -2126,7 +2126,7 @@ def test_stack_multiple_bug(self, future_stack, using_infer_string):
         unst = multi.unstack("ID")
         msg = re.escape("agg function failed [how->mean,dtype->")
         if using_infer_string:
-            msg = "str dtype does not support mean operations"
+            msg = "dtype 'str' does not support operation 'mean'"
         with pytest.raises(TypeError, match=msg):
             unst.resample("W-THU").mean()
         down = unst.resample("W-THU").mean(numeric_only=True)

pandas/tests/generic/test_frame.py

@@ -61,6 +61,7 @@ def test_metadata_propagation_indiv_groupby(self):
                 "D": np.random.default_rng(2).standard_normal(8),
             }
         )
+        df = df.astype({"A": object, "B": object})
         result = df.groupby("A").sum()
         tm.assert_metadata_equivalent(df, result)
 

pandas/tests/groupby/aggregate/test_aggregate.py

@@ -1020,7 +1020,7 @@ def test_groupby_as_index_agg(df):
 
     result2 = grouped.agg({"C": "mean", "D": "sum"})
     expected2 = grouped.mean(numeric_only=True)
-    expected2["D"] = grouped.sum()["D"]
+    expected2["D"] = grouped.sum(numeric_only=True)["D"]
     tm.assert_frame_equal(result2, expected2)
 
     grouped = df.groupby("A", as_index=True)

pandas/tests/groupby/methods/test_quantile.py

@@ -241,19 +241,20 @@ def test_groupby_quantile_nullable_array(values, q):
     tm.assert_series_equal(result, expected)
 
 
-@pytest.mark.xfail(using_string_dtype(), reason="TODO(infer_string)", strict=False)
+# @pytest.mark.xfail(using_string_dtype(), reason="TODO(infer_string)", strict=False)
 @pytest.mark.parametrize("q", [0.5, [0.0, 0.5, 1.0]])
 @pytest.mark.parametrize("numeric_only", [True, False])
-def test_groupby_quantile_raises_on_invalid_dtype(q, numeric_only):
+def test_groupby_quantile_raises_on_invalid_dtype(q, numeric_only, using_infer_string):
     df = DataFrame({"a": [1], "b": [2.0], "c": ["x"]})
     if numeric_only:
         result = df.groupby("a").quantile(q, numeric_only=numeric_only)
         expected = df.groupby("a")[["b"]].quantile(q)
         tm.assert_frame_equal(result, expected)
     else:
-        with pytest.raises(
-            TypeError, match="'quantile' cannot be performed against 'object' dtypes!"
-        ):
+        msg = "'quantile' cannot be performed against 'object' dtypes!"
+        if using_infer_string:
+            msg = "dtype 'str' does not support operation 'quantile'"
+        with pytest.raises(TypeError, match=msg):
             df.groupby("a").quantile(q, numeric_only=numeric_only)
 
 

pandas/tests/groupby/test_groupby.py

@@ -480,7 +480,7 @@ def test_frame_multi_key_function_list_partial_failure(using_infer_string):
     funcs = ["mean", "std"]
     msg = re.escape("agg function failed [how->mean,dtype->")
     if using_infer_string:
-        msg = "str dtype does not support mean operations"
+        msg = "dtype 'str' does not support operation 'mean'"
     with pytest.raises(TypeError, match=msg):
         grouped.agg(funcs)
 
@@ -578,6 +578,7 @@ def test_ops_not_as_index(reduction_func):
 
 
 def test_as_index_series_return_frame(df):
+    df = df.astype({"A": object, "B": object})
     grouped = df.groupby("A", as_index=False)
     grouped2 = df.groupby(["A", "B"], as_index=False)
 
@@ -671,7 +672,7 @@ def test_raises_on_nuisance(df, using_infer_string):
     grouped = df.groupby("A")
     msg = re.escape("agg function failed [how->mean,dtype->")
     if using_infer_string:
-        msg = "str dtype does not support mean operations"
+        msg = "dtype 'str' does not support operation 'mean'"
     with pytest.raises(TypeError, match=msg):
         grouped.agg("mean")
     with pytest.raises(TypeError, match=msg):
@@ -717,7 +718,7 @@ def test_omit_nuisance_agg(df, agg_function, numeric_only, using_infer_string):
         # Added numeric_only as part of GH#46560; these do not drop nuisance
         # columns when numeric_only is False
         if using_infer_string:
-            msg = f"str dtype does not support {agg_function} operations"
+            msg = f"dtype 'str' does not support operation '{agg_function}'"
             klass = TypeError
         elif agg_function in ("std", "sem"):
             klass = ValueError
@@ -740,18 +741,24 @@ def test_omit_nuisance_agg(df, agg_function, numeric_only, using_infer_string):
         tm.assert_frame_equal(result, expected)
 
 
-def test_raise_on_nuisance_python_single(df):
+def test_raise_on_nuisance_python_single(df, using_infer_string):
     # GH 38815
     grouped = df.groupby("A")
-    with pytest.raises(ValueError, match="could not convert"):
+
+    err = ValueError
+    msg = "could not convert"
+    if using_infer_string:
+        err = TypeError
+        msg = "dtype 'str' does not support operation 'skew'"
+    with pytest.raises(err, match=msg):
         grouped.skew()
 
 
 def test_raise_on_nuisance_python_multiple(three_group, using_infer_string):
     grouped = three_group.groupby(["A", "B"])
     msg = re.escape("agg function failed [how->mean,dtype->")
     if using_infer_string:
-        msg = "str dtype does not support mean operations"
+        msg = "dtype 'str' does not support operation 'mean'"
     with pytest.raises(TypeError, match=msg):
         grouped.agg("mean")
     with pytest.raises(TypeError, match=msg):
@@ -798,7 +805,7 @@ def test_wrap_aggregated_output_multindex(
     keys = [np.array([0, 0, 1]), np.array([0, 0, 1])]
     msg = re.escape("agg function failed [how->mean,dtype->")
     if using_infer_string:
-        msg = "str dtype does not support mean operations"
+        msg = "dtype 'str' does not support operation 'mean'"
     with pytest.raises(TypeError, match=msg):
         df.groupby(keys).agg("mean")
     agged = df.drop(columns=("baz", "two")).groupby(keys).agg("mean")
@@ -976,10 +983,20 @@ def test_groupby_with_hier_columns():
     tm.assert_index_equal(result.columns, df.columns[:-1])
 
 
-def test_grouping_ndarray(df):
+def test_grouping_ndarray(df, using_infer_string):
     grouped = df.groupby(df["A"].values)
+    grouped2 = df.groupby(df["A"].rename(None))
+
+    if using_infer_string:
+        msg = "dtype 'str' does not support operation 'sum'"
+        with pytest.raises(TypeError, match=msg):
+            grouped.sum()
+        with pytest.raises(TypeError, match=msg):
+            grouped2.sum()
+        return
+
     result = grouped.sum()
-    expected = df.groupby(df["A"].rename(None)).sum()
+    expected = grouped2.sum()
     tm.assert_frame_equal(result, expected)
 
 
@@ -1478,13 +1495,23 @@ def f(group):
     assert names == expected_names
 
 
-def test_no_dummy_key_names(df):
+def test_no_dummy_key_names(df, using_infer_string):
     # see gh-1291
-    result = df.groupby(df["A"].values).sum()
+    gb = df.groupby(df["A"].values)
+    gb2 = df.groupby([df["A"].values, df["B"].values])
+    if using_infer_string:
+        msg = "dtype 'str' does not support operation 'sum'"
+        with pytest.raises(TypeError, match=msg):
+            gb.sum()
+        with pytest.raises(TypeError, match=msg):
+            gb2.sum()
+        return
+
+    result = gb.sum()
     assert result.index.name is None
 
-    result = df.groupby([df["A"].values, df["B"].values]).sum()
-    assert result.index.names == (None, None)
+    result2 = gb2.sum()
+    assert result2.index.names == (None, None)
 
 
 def test_groupby_sort_multiindex_series():
@@ -1820,7 +1847,7 @@ def get_categorical_invalid_expected():
             elif is_per:
                 msg = "Period type does not support"
             elif is_str:
-                msg = "str dtype does not support"
+                msg = f"dtype 'str' does not support operation '{op}'"
             else:
                 msg = "category type does not support"
             if op == "skew":
@@ -2750,7 +2777,7 @@ def test_obj_with_exclusions_duplicate_columns():
 def test_groupby_numeric_only_std_no_result(numeric_only):
     # GH 51080
     dicts_non_numeric = [{"a": "foo", "b": "bar"}, {"a": "car", "b": "dar"}]
-    df = DataFrame(dicts_non_numeric)
+    df = DataFrame(dicts_non_numeric, dtype=object)
     dfgb = df.groupby("a", as_index=False, sort=False)
 
     if numeric_only:
@@ -2809,10 +2836,14 @@ def test_grouping_with_categorical_interval_columns():
 def test_groupby_sum_on_nan_should_return_nan(bug_var):
     # GH 24196
     df = DataFrame({"A": [bug_var, bug_var, bug_var, np.nan]})
+    if isinstance(bug_var, str):
+        df = df.astype(object)
     dfgb = df.groupby(lambda x: x)
     result = dfgb.sum(min_count=1)
 
-    expected_df = DataFrame([bug_var, bug_var, bug_var, None], columns=["A"])
+    expected_df = DataFrame(
+        [bug_var, bug_var, bug_var, None], columns=["A"], dtype=df["A"].dtype
+    )
     tm.assert_frame_equal(result, expected_df)
 
 

pandas/tests/groupby/test_numeric_only.py

@@ -28,7 +28,7 @@ def df(self):
                 "group": [1, 1, 2],
                 "int": [1, 2, 3],
                 "float": [4.0, 5.0, 6.0],
-                "string": list("abc"),
+                "string": Series(["a", "b", "c"], dtype=object),
                 "category_string": Series(list("abc")).astype("category"),
                 "category_int": [7, 8, 9],
                 "datetime": date_range("20130101", periods=3),
@@ -180,7 +180,7 @@ def _check(self, df, method, expected_columns, expected_columns_numeric):
                     "category type does not support sum operations",
                     re.escape(f"agg function failed [how->{method},dtype->object]"),
                     re.escape(f"agg function failed [how->{method},dtype->string]"),
-                    f"str dtype does not support {method} operations",
+                    f"dtype 'str' does not support operation '{method}'",
                 ]
             )
             with pytest.raises(exception, match=msg):
@@ -198,7 +198,7 @@ def _check(self, df, method, expected_columns, expected_columns_numeric):
                     f"Cannot perform {method} with non-ordered Categorical",
                     re.escape(f"agg function failed [how->{method},dtype->object]"),
                     re.escape(f"agg function failed [how->{method},dtype->string]"),
-                    f"str dtype does not support {method} operations",
+                    f"dtype 'str' does not support operation '{method}'",
                 ]
             )
             with pytest.raises(exception, match=msg):

pandas/tests/groupby/test_raises.py

@@ -194,7 +194,7 @@ def test_groupby_raises_string(
             "skew",
             "quantile",
         ]:
-            msg = f"str dtype does not support {groupby_func} operations"
+            msg = f"dtype 'str' does not support operation '{groupby_func}'"
             if groupby_func == "sum":
                 # The object-dtype allows this, StringArray variants do not.
                 klass = TypeError
@@ -213,14 +213,13 @@ def test_groupby_raises_string(
             #  there.
             import pyarrow as pa
 
+            # TODO(infer_string): avoid bubbling up pyarrow exceptions
             klass = pa.lib.ArrowNotImplementedError
             msg = "Function 'subtract_checked' has no kernel matching input types"
         elif groupby_func in ["cummin", "cummax"]:
             msg = msg.replace("object", "str")
         elif groupby_func == "corrwith":
-            msg = (
-                "'.*NumpySemantics' with dtype str does " "not support operation 'mean'"
-            )
+            msg = "'.*NumpySemantics' with dtype str does not support operation 'mean'"
 
     if groupby_func == "fillna":
         kind = "Series" if groupby_series else "DataFrame"
@@ -275,7 +274,10 @@ def test_groupby_raises_string_np(
     if using_infer_string:
         klass = TypeError
         if df["d"].dtype.storage == "python":
-            msg = "Cannot perform reduction 'mean' with string dtype"
+            msg = (
+                f"Cannot perform reduction '{groupby_func_np.__name__}' "
+                "with string dtype"
+            )
         else:
             msg = (
                 "'ArrowStringArrayNumpySemantics' with dtype str does not "

pandas/tests/resample/test_resample_api.py

@@ -198,7 +198,7 @@ def tests_raises_on_nuisance(test_frame, using_infer_string):
     expected = r[["A", "B", "C"]].mean()
     msg = re.escape("agg function failed [how->mean,dtype->")
     if using_infer_string:
-        msg = "str dtype does not support mean operations"
+        msg = "dtype 'str' does not support operation 'mean'"
     with pytest.raises(TypeError, match=msg):
         r.mean()
     result = r.mean(numeric_only=True)
@@ -903,18 +903,18 @@ def test_frame_downsample_method(
             klass = TypeError
             msg = re.escape(f"agg function failed [how->{method},dtype->")
             if using_infer_string:
-                msg = f"str dtype does not support {method} operations"
+                msg = f"dtype 'str' does not support operation '{method}'"
         elif method in ["sum", "std", "sem"] and using_infer_string:
             klass = TypeError
-            msg = f"str dtype does not support {method} operations"
+            msg = f"dtype 'str' does not support operation '{method}'"
         else:
             klass = ValueError
             msg = expected_data
         with pytest.raises(klass, match=msg):
             _ = func(**kwargs)
     elif method == "sum" and using_infer_string and numeric_only is not True:
         klass = TypeError
-        msg = "str dtype does not support sum operations"
+        msg = f"dtype 'str' does not support operation '{method}'"
         with pytest.raises(klass, match=msg):
             _ = func(**kwargs)
     else:
@@ -965,11 +965,11 @@ def test_series_downsample_method(
     elif method == "prod":
         msg = re.escape("agg function failed [how->prod,dtype->")
         if using_infer_string:
-            msg = "str dtype does not support prod operations"
+            msg = "dtype 'str' does not support operation 'prod'"
         with pytest.raises(TypeError, match=msg):
             func(**kwargs)
     elif method == "sum" and using_infer_string and numeric_only is not True:
-        msg = "str dtype does not support sum operations"
+        msg = "dtype 'str' does not support operation 'sum'"
         with pytest.raises(TypeError, match=msg):
             func(**kwargs)
 

pandas/tests/reshape/merge/test_join.py

@@ -632,7 +632,7 @@ def test_mixed_type_join_with_suffix(self, using_infer_string):
         grouped = df.groupby("id")
         msg = re.escape("agg function failed [how->mean,dtype->")
         if using_infer_string:
-            msg = "str dtype does not support mean operations"
+            msg = "dtype 'str' does not support operation 'mean'"
         with pytest.raises(TypeError, match=msg):
             grouped.mean()
         mn = grouped.mean(numeric_only=True)

pandas/tests/reshape/test_pivot.py

@@ -135,10 +135,11 @@ def test_pivot_table_categorical_observed_equal(self, observed):
 
         tm.assert_frame_equal(result, expected)
 
-    def test_pivot_table_nocols(self, using_infer_string):
+    def test_pivot_table_nocols(self):
         df = DataFrame(
             {"rows": ["a", "b", "c"], "cols": ["x", "y", "z"], "values": [1, 2, 3]}
         )
+        df = df.astype({"rows": object, "cols": object})
         rs = df.pivot_table(columns="cols", aggfunc="sum")
         xp = df.pivot_table(index="cols", aggfunc="sum").T
         tm.assert_frame_equal(rs, xp)
@@ -942,7 +943,7 @@ def test_no_col(self, data, using_infer_string):
         data.columns = [k * 2 for k in data.columns]
         msg = re.escape("agg function failed [how->mean,dtype->")
         if using_infer_string:
-            msg = "str dtype does not support mean operations"
+            msg = "dtype 'str' does not support operation 'mean'"
         with pytest.raises(TypeError, match=msg):
             data.pivot_table(index=["AA", "BB"], margins=True, aggfunc="mean")
         table = data.drop(columns="CC").pivot_table(
@@ -1017,7 +1018,7 @@ def test_margin_with_only_columns_defined(
         if aggfunc != "sum":
             msg = re.escape("agg function failed [how->mean,dtype->")
             if using_infer_string:
-                msg = "str dtype does not support mean operations"
+                msg = "dtype 'str' does not support operation 'mean'"
             with pytest.raises(TypeError, match=msg):
                 df.pivot_table(columns=columns, margins=True, aggfunc=aggfunc)
         if "B" not in columns: