Fix pandas-dev#61072: inconsistent fullmatch results with regex alternation

in PyArrow strings
Fixes an issue where regex patterns with alternation (|) produce
different results between str dtype and string[pyarrow] dtype. When
using patterns like "(as)|(as)", PyArrow implementation would
incorrectly match "asdf" while Python's implementation correctly
rejects it. The fix adds special handling to ensure alternation
patterns are properly parenthesized when using PyArrow-backed
strings

Author: Pedro-Santos04

pandas/core/strings/accessor.py

@@ -1487,37 +1487,27 @@ def fullmatch(self, pat, case: bool = True, flags: int = 0, na=lib.no_default):
         1     True
         dtype: bool
         """
-
         is_pyarrow = False
-
         arr = self._data.array
-        
         arr_type = type(arr).__name__
         is_pyarrow = arr_type == "ArrowStringArray"
-        
         if not is_pyarrow:
             is_pyarrow = "Arrow" in arr_type
-            
             if not is_pyarrow and hasattr(arr, "dtype"):
                 dtype_str = str(arr.dtype)
                 is_pyarrow = "pyarrow" in dtype_str.lower() or "arrow" in dtype_str.lower()
-        
-        # Handle pattern modification for PyArrow implementation
         if is_pyarrow and "|" in pat:
             def _is_fully_wrapped(pattern):
                 if not (pattern.startswith('(') and pattern.endswith(')')):
-                    return False
-                    
+                    return False     
                 inner = pattern[1:-1]
                 level = 0
                 escape = False
                 in_char_class = False
-                
                 for char in inner:
                     if escape:
                         escape = False
-                        continue
-                        
+                        continue   
                     if char == '\\':
                         escape = True
                     elif not in_char_class and char == '[':
@@ -1529,19 +1519,12 @@ def _is_fully_wrapped(pattern):
                             level += 1
                         elif char == ')':
                             if level == 0:
-                                # Found a closing parenthesis without matching opening one
                                 return False
                             level -= 1
-                
-                # If we end with zero level, 
-                #        the outer parentheses fully wrap the pattern
                 return level == 0
-                
-            
             if not (pat.startswith('(') and pat.endswith(')') and 
                     _is_fully_wrapped(pat)):
                 pat = f"({pat})"
-        
         result = self._data.array._str_fullmatch(pat, case=case, flags=flags, na=na)
         return self._wrap_result(result, fill_value=na, returns_string=False)
 

pandas/tests/strings/test_pyarrow_format_behavior.py

@@ -1,27 +1,39 @@
-import pandas
-
-test_series = pandas.Series(['asdf', 'as'], dtype='string[pyarrow]')
-regex = r'((as)|(as))'
-regex2 = r'(as)|(as)'
-
-print(test_series.str.fullmatch(regex))
-# False
-# True
-print(test_series.str.fullmatch(regex2))
-# True
-# True
-
-test_series2 = pandas.Series(['asdf', 'as'], dtype=str)
-
-print(test_series2.str.fullmatch(regex))
-# False
-# True
-print(test_series2.str.fullmatch(regex2))
-# False
-# True
-
-ser = pandas.Series(["cat", "duck", "dove"])
-print(ser.str.fullmatch(r"d.+"))
-# False
-# True
-# True
+import pytest
+
+from pandas import (
+    Series,
+)
+
+@pytest.mark.parametrize("dtype", ["string[pyarrow]", str])
+def test_string_array(dtype):
+    test_series = Series(['asdf', 'as'], dtype=dtype)
+    regex = r'((as)|(as))'
+    regex2 = r'(as)|(as)'
+
+    assert list(test_series.str.fullmatch(regex)) == [False, True]
+    assert list(test_series.str.fullmatch(regex2)) == [False, True]
+
+@pytest.mark.parametrize(
+    "data, pattern, expected",
+    [
+        (["cat", "duck", "dove"], r"d.+", [False, True, True]),
+    ],
+)
+def test_string_match(data, pattern, expected):
+    ser = Series(data)
+    assert list(ser.str.fullmatch(pattern)) == expected
+
+@pytest.mark.parametrize("dtype", ["string[pyarrow]", str])
+@pytest.mark.parametrize(
+    "pattern, expected",
+    [
+        (r'(foo)|((as)(df)?)', [True, True, True]),
+        ('foo|as', [False, True, True]),
+    ],
+)
+def test_string_alternation_patterns(dtype, pattern, expected):
+    ser = Series(['asdf', 'foo', 'as'], dtype=dtype)
+    assert list(ser.str.fullmatch(pattern)) == expected
+
+
+