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

Author: Pedro-Santos04

pandas/core/strings/accessor.py

@@ -1429,12 +1429,12 @@ 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,32 +1448,104 @@ 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"])
         >>> ser.str.fullmatch(r"d.+")
-        0   False
-        1    True
-        2    True
+        0    False
+        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
+                    
+                inner = pattern[1:-1]
+                
+                level = 0
+                escape = False
+                in_char_class = False
+                
+                for char in inner:
+                    if escape:
+                        escape = False
+                        continue
+                        
+                    if char == '\\':
+                        escape = True
+                    elif not in_char_class and char == '[':
+                        in_char_class = True
+                    elif in_char_class and char == ']':
+                        in_char_class = False
+                    elif not in_char_class:
+                        if char == '(':
+                            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)
-
+    
     @forbid_nonstring_types(["bytes"])
     def replace(
         self,

pandas/tests/test.py

@@ -0,0 +1,27 @@
+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