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):