Updated version of 62317

Author: eicchen

doc/source/whatsnew/v3.0.0.rst

@@ -200,6 +200,8 @@ Other enhancements
 - :class:`Holiday` has gained the constructor argument and field ``exclude_dates`` to exclude specific datetimes from a custom holiday calendar (:issue:`54382`)
 - :class:`Rolling` and :class:`Expanding` now support ``nunique`` (:issue:`26958`)
 - :class:`Rolling` and :class:`Expanding` now support aggregations ``first`` and ``last`` (:issue:`33155`)
+- :class:`StringDtype` now supports addition to Series/DataFrame with strings (:issue:`61581`)
+
 - :func:`read_parquet` accepts ``to_pandas_kwargs`` which are forwarded to :meth:`pyarrow.Table.to_pandas` which enables passing additional keywords to customize the conversion to pandas, such as ``maps_as_pydicts`` to read the Parquet map data type as python dictionaries (:issue:`56842`)
 - :meth:`.DataFrameGroupBy.transform`, :meth:`.SeriesGroupBy.transform`, :meth:`.DataFrameGroupBy.agg`, :meth:`.SeriesGroupBy.agg`, :meth:`.SeriesGroupBy.apply`, :meth:`.DataFrameGroupBy.apply` now support ``kurt`` (:issue:`40139`)
 - :meth:`DataFrame.apply` supports using third-party execution engines like the Bodo.ai JIT compiler (:issue:`60668`)
@@ -998,6 +1000,7 @@ MultiIndex
 - :func:`MultiIndex.get_level_values` accessing a :class:`DatetimeIndex` does not carry the frequency attribute along (:issue:`58327`, :issue:`57949`)
 - Bug in :class:`DataFrame` arithmetic operations in case of unaligned MultiIndex columns (:issue:`60498`)
 - Bug in :class:`DataFrame` arithmetic operations with :class:`Series` in case of unaligned MultiIndex (:issue:`61009`)
+- Bug in :class:`DataFrame` arithmetic operations with :class:`Series` now works with ``fill_value`` parameter (:issue:`61581`)
 - Bug in :meth:`MultiIndex.from_tuples` causing wrong output with input of type tuples having NaN values (:issue:`60695`, :issue:`60988`)
 - Bug in :meth:`DataFrame.__setitem__` where column alignment logic would reindex the assigned value with an empty index, incorrectly setting all values to ``NaN``.(:issue:`61841`)
 - Bug in :meth:`DataFrame.reindex` and :meth:`Series.reindex` where reindexing :class:`Index` to a :class:`MultiIndex` would incorrectly set all values to ``NaN``.(:issue:`60923`)

pandas/core/arrays/arrow/array.py

@@ -890,7 +890,14 @@ def _op_method_error_message(self, other, op) -> str:
     def _evaluate_op_method(self, other, op, arrow_funcs) -> Self:
         pa_type = self._pa_array.type
         other_original = other
-        other = self._box_pa(other)
+        try:
+            other = self._box_pa(other)
+        except (ValueError, pa.lib.ArrowTypeError) as err:
+            # Categorical and Interval dtype raises errors in self._box_pa
+            # Could be fixed in the future if needed
+            raise TypeError(
+                "Incompatible type when converting to PyArrow dtype for operation."
+            ) from err
 
         if (
             pa.types.is_string(pa_type)
@@ -899,6 +906,11 @@ def _evaluate_op_method(self, other, op, arrow_funcs) -> Self:
         ):
             if op in [operator.add, roperator.radd]:
                 sep = pa.scalar("", type=pa_type)
+                if not (is_scalar(other) or isinstance(other, pa.Scalar)):
+                    if len(other) == 0 or isna(other).any():
+                        other = other.cast(pa_type)
+                elif isna(other):
+                    other = other.cast(pa_type)
                 try:
                     if op is operator.add:
                         result = pc.binary_join_element_wise(self._pa_array, other, sep)

pandas/tests/arithmetic/test_period.py

@@ -1361,7 +1361,6 @@ def test_period_add_timestamp_raises(self, box_with_array):
             arr + ts
         with pytest.raises(TypeError, match=msg):
             ts + arr
-        
         msg = "cannot add PeriodArray and DatetimeArray"
         with pytest.raises(TypeError, match=msg):
             arr + Series([ts])

pandas/tests/arrays/boolean/test_arithmetic.py

@@ -118,7 +118,7 @@ def test_error_invalid_values(data, all_arithmetic_operators):
         ops(pd.Timestamp("20180101"))
 
     # invalid array-likes
-    if op not in ("__mul__", "__rmul__"):
+    if op not in ("__mul__", "__rmul__", "__add__", "__radd__"):
         # TODO(extension) numpy's mul with object array sees booleans as numbers
         msg = "|".join(
             [

pandas/tests/arrays/floating/test_arithmetic.py

@@ -152,8 +152,42 @@ def test_error_invalid_values(data, all_arithmetic_operators):
         ops(pd.Timestamp("20180101"))
 
     # invalid array-likes
-    with pytest.raises(TypeError, match=msg):
-        ops(pd.Series("foo", index=s.index))
+    str_ser = pd.Series("foo", index=s.index)
+    if (
+        all_arithmetic_operators
+        in [
+            "__add__",
+            "__radd__",
+        ]
+        and pd.options.future.infer_string
+    ):
+        res = ops(str_ser)
+        if all_arithmetic_operators == "__radd__":
+            data_expected = []
+            for i in data:
+                if pd.isna(i):
+                    data_expected.append(i)
+                elif i.is_integer():
+                    data_expected.append("foo" + str(int(i)))
+                else:
+                    data_expected.append("foo" + str(i))
+
+            expected = pd.Series(data_expected, index=s.index)
+        else:
+            data_expected = []
+            for i in data:
+                if pd.isna(i):
+                    data_expected.append(i)
+                elif i.is_integer():
+                    data_expected.append(str(int(i)) + "foo")
+                else:
+                    data_expected.append(str(i) + "foo")
+
+            expected = pd.Series(data_expected, index=s.index)
+        tm.assert_series_equal(res, expected)
+    else:
+        with pytest.raises(TypeError, match=msg):
+            ops(str_ser)
 
     msg = "|".join(
         [

pandas/tests/arrays/integer/test_arithmetic.py

@@ -197,6 +197,26 @@ def test_error_invalid_values(data, all_arithmetic_operators):
         #  assert_almost_equal stricter, but the expected with pd.NA seems
         #  more-correct than np.nan here.
         tm.assert_series_equal(res, expected)
+    elif (
+        all_arithmetic_operators
+        in [
+            "__add__",
+            "__radd__",
+        ]
+        and pd.options.future.infer_string
+    ):
+        res = ops(str_ser)
+        if all_arithmetic_operators == "__radd__":
+            expected = pd.Series(
+                [np.nan if pd.isna(x) == 1 else "foo" + str(x) for x in data],
+                index=s.index,
+            )
+        else:
+            expected = pd.Series(
+                [np.nan if pd.isna(x) == 1 else str(x) + "foo" for x in data],
+                index=s.index,
+            )
+        tm.assert_series_equal(res, expected)
     else:
         with tm.external_error_raised(TypeError):
             ops(str_ser)

pandas/tests/arrays/string_/test_string.py

@@ -249,6 +249,19 @@ def test_mul(dtype):
     tm.assert_extension_array_equal(result, expected)
 
 
+def test_add_series(dtype):
+    arr = pd.array(["a", "b", "c", "d"], dtype=dtype)
+    df = pd.Series(["t", "y", "v", "w"], dtype=object)
+
+    result = arr + df
+    expected = pd.Series(["at", "by", "cv", "dw"]).astype(dtype)
+    tm.assert_series_equal(result, expected)
+
+    result = df + arr
+    expected = pd.Series(["ta", "yb", "vc", "wd"]).astype(dtype)
+    tm.assert_series_equal(result, expected)
+
+
 def test_add_strings(dtype):
     arr = pd.array(["a", "b", "c", "d"], dtype=dtype)
     df = pd.DataFrame([["t", "y", "v", "w"]], dtype=object)
@@ -263,20 +276,48 @@ def test_add_strings(dtype):
     tm.assert_frame_equal(result, expected)
 
 
-@pytest.mark.xfail(reason="GH-28527")
 def test_add_frame(dtype):
     arr = pd.array(["a", "b", np.nan, np.nan], dtype=dtype)
     df = pd.DataFrame([["x", np.nan, "y", np.nan]])
-
     assert arr.__add__(df) is NotImplemented
 
     result = arr + df
     expected = pd.DataFrame([["ax", np.nan, np.nan, np.nan]]).astype(dtype)
-    tm.assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected, check_dtype=False)
 
     result = df + arr
     expected = pd.DataFrame([["xa", np.nan, np.nan, np.nan]]).astype(dtype)
-    tm.assert_frame_equal(result, expected)
+    tm.assert_frame_equal(result, expected, check_dtype=False)
+
+
+@pytest.mark.parametrize(
+    "invalid",
+    [
+        10,
+        1.5,
+        pd.Timedelta(hours=31),
+        pd.Timestamp("2021-01-01"),
+        True,
+        pd.Period("2025-09"),
+        pd.Categorical(["test"]),
+        pd.offsets.Minute(3),
+        pd.Interval(1, 2, closed="right"),
+    ],
+)
+def test_add_frame_invalid(dtype, invalid):
+    arr = pd.array(["a", np.nan], dtype=dtype)
+    df = pd.DataFrame([[invalid, invalid]])
+
+    msg = "|".join(
+        [
+            r"can only concatenate str \(not \".+\"\) to str",
+            r"unsupported operand type\(s\) for \+: '.+' and 'str'",
+            r"operation 'add' not supported for dtype 'str|string' with dtype '.+'",
+            "Incompatible type when converting to PyArrow dtype for operation.",
+        ]
+    )
+    with pytest.raises(TypeError, match=msg):
+        arr + df
 
 
 def test_comparison_methods_scalar(comparison_op, dtype):