gh reference

Author: Rohan Jain

doc/source/whatsnew/v2.2.0.rst

@@ -803,6 +803,7 @@ Strings
 - Bug in :meth:`DataFrame.reindex` not matching :class:`Index` with ``string[pyarrow_numpy]`` dtype (:issue:`56106`)
 - Bug in :meth:`Index.str.cat` always casting result to object dtype (:issue:`56157`)
 - Bug in :meth:`Series.__mul__` for :class:`ArrowDtype` with ``pyarrow.string`` dtype and ``string[pyarrow]`` for the pyarrow backend (:issue:`51970`)
+- Bug in :meth:`Series.str.find` when ``start < 0`` and ``end < 0`` for :class:`ArrowDtype` with ``pyarrow.string`` (:issue:`56791`)
 - Bug in :meth:`Series.str.find` when ``start < 0`` for :class:`ArrowDtype` with ``pyarrow.string`` (:issue:`56411`)
 - Bug in :meth:`Series.str.replace` when ``n < 0`` for :class:`ArrowDtype` with ``pyarrow.string`` (:issue:`56404`)
 - Bug in :meth:`Series.str.startswith` and :meth:`Series.str.endswith` with arguments of type ``tuple[str, ...]`` for :class:`ArrowDtype` with ``pyarrow.string`` dtype (:issue:`56579`)

pandas/core/arrays/arrow/array.py

@@ -2331,23 +2331,20 @@ def _str_find(self, sub: str, start: int = 0, end: int | None = None) -> Self:
         if (start == 0 or start is None) and end is None:
             result = pc.find_substring(self._pa_array, sub)
         else:
-            result = pc.find_substring(self._pa_array, sub)
-            length = pc.utf8_length(self._pa_array)
             if start is None:
-                start = pa.scalar(0, result.type)
+                start_offset = 0
+                start = 0
             elif start < 0:
-                start = pc.add(start, length)
-            if end is None:
-                end = length
-            elif end < 0:
-                end = pc.add(end, length)
-            found = pc.not_equal(pa.scalar(-1, type=result.type), result)
-            found_in_bounds = pc.and_(
-                pc.greater_equal(result, start), pc.less(result, end)
-            )
-            result = pc.if_else(
-                pc.and_(found, found_in_bounds), result, pa.scalar(-1, type=result.type)
-            )
+                start_offset = pc.add(start, pc.utf8_length(self._pa_array))
+                start_offset = pc.if_else(pc.less(start_offset, 0), 0, start_offset)
+            else:
+                start_offset = start
+            slices = pc.utf8_slice_codeunits(self._pa_array, start, stop=end)
+            result = pc.find_substring(slices, sub)
+            not_found = pc.equal(result, pa.scalar(-1, type=result.type))
+
+            offset_result = pc.add(result, start_offset)
+            result = pc.if_else(not_found, result, offset_result)
         return type(self)(result)
 
     def _str_join(self, sep: str) -> Self:

pandas/tests/extension/test_arrow.py

@@ -1919,29 +1919,34 @@ def test_str_fullmatch(pat, case, na, exp):
 
 
 @pytest.mark.parametrize(
-    "sub, start, end, exp",
-    [["ab", 0, None, [0, None]], ["bc", 1, 3, [1, None]], ["ab", 1, None, [-1, None]]],
+    "sub, start, end, exp, exp_type",
+    [
+        ["ab", 0, None, [0, None], pa.int32()],
+        ["bc", 1, 3, [1, None], pa.int64()],
+        ["ab", 1, None, [-1, None], pa.int64()],
+        ["ab", -3, -3, [-1, None], pa.int64()],
+    ],
 )
-def test_str_find(sub, start, end, exp):
+def test_str_find(sub, start, end, exp, exp_type):
     ser = pd.Series(["abc", None], dtype=ArrowDtype(pa.string()))
     result = ser.str.find(sub, start=start, end=end)
-    expected = pd.Series(exp, dtype=ArrowDtype(pa.int32()))
+    expected = pd.Series(exp, dtype=ArrowDtype(exp_type))
     tm.assert_series_equal(result, expected)
 
 
 def test_str_find_negative_start():
     # GH 56411
     ser = pd.Series(["abc", None], dtype=ArrowDtype(pa.string()))
     result = ser.str.find(sub="b", start=-1000, end=3)
-    expected = pd.Series([1, None], dtype=ArrowDtype(pa.int32()))
+    expected = pd.Series([1, None], dtype=ArrowDtype(pa.int64()))
     tm.assert_series_equal(result, expected)
 
 
 def test_str_find_negative_start_negative_end():
-    # GH 56411
+    # GH 56791
     ser = pd.Series(["abcdefg", None], dtype=ArrowDtype(pa.string()))
     result = ser.str.find(sub="d", start=-6, end=-3)
-    expected = pd.Series([3, None], dtype=ArrowDtype(pa.int32()))
+    expected = pd.Series([3, None], dtype=ArrowDtype(pa.int64()))
     tm.assert_series_equal(result, expected)