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

@@ -1429,12 +1429,10 @@ def match(self, pat: str, case: bool = True, flags: int = 0, na=lib.no_default):
     def fullmatch(self, pat, case: bool = True, flags: int = 0, na=lib.no_default):
         """
         Determine if each string entirely matches a regular expression.
-        
         Checks if each string in the Series or Index fully matches the
         specified regular expression pattern. This function is useful when the
         requirement is for an entire string to conform to a pattern, such as
         validating formats like phone numbers or email addresses.
-        
         Parameters
         ----------
         pat : str
@@ -1448,28 +1446,24 @@ def fullmatch(self, pat, case: bool = True, flags: int = 0, na=lib.no_default):
             array. For object-dtype, ``numpy.nan`` is used. For the nullable
             ``StringDtype``, ``pandas.NA`` is used. For the ``"str"`` dtype,
             ``False`` is used.
-        
         Returns
         -------
         Series/Index/array of boolean values
             The function returns a Series, Index, or array of boolean values,
             where True indicates that the entire string matches the regular
             expression pattern and False indicates that it does not.
-        
         See Also
         --------
         match : Similar, but also returns `True` when only a *prefix* of the string
             matches the regular expression.
         extract : Extract matched groups.
-        
         Notes
         -----
         This method enforces consistent behavior between Python's string dtype
         and PyArrow-backed string arrays when using regular expressions
         containing alternation (|). For regex patterns with alternation operators,
         the method ensures proper grouping by wrapping the pattern in parentheses
         when using PyArrow-backed string arrays.
-        
         Examples
         --------
         >>> ser = pd.Series(["cat", "duck", "dove"])
@@ -1478,46 +1472,34 @@ def fullmatch(self, pat, case: bool = True, flags: int = 0, na=lib.no_default):
         1     True
         2     True
         dtype: bool
-        
         Ensure consistent behavior with alternation patterns:
-        
         >>> ser = pd.Series(['asdf', 'as'], dtype='string[pyarrow]')
         >>> ser.str.fullmatch(r"(as)|(as)")
         0    False
         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 +1511,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,31 @@
-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