Update boolean dtype representation and improve regex handling in StringMethods

Author: Pedro-Santos04

pandas/core/strings/accessor.py

@@ -1477,14 +1477,14 @@ def fullmatch(self, pat, case: bool = True, flags: int = 0, na=lib.no_default):
         0    False
         1     True
         2     True
-        dtype: bool
+        dtype: boolean
 
         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
+        dtype: boolean
         """
         is_pyarrow = False
         arr = self._data.array
@@ -1494,35 +1494,40 @@ def fullmatch(self, pat, case: bool = True, flags: int = 0, na=lib.no_default):
             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()
+                is_pyarrow = (
+                    "pyarrow" in dtype_str.lower() or "arrow" in dtype_str.lower()
+                )
         if is_pyarrow and "|" in pat:
+
             def _is_fully_wrapped(pattern):
-                if not (pattern.startswith('(') and pattern.endswith(')')):
-                    return False     
+                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 == '\\':
+                        continue
+                    if char == "\\":
                         escape = True
-                    elif not in_char_class and char == '[':
+                    elif not in_char_class and char == "[":
                         in_char_class = True
-                    elif in_char_class and char == ']':
+                    elif in_char_class and char == "]":
                         in_char_class = False
                     elif not in_char_class:
-                        if char == '(':
+                        if char == "(":
                             level += 1
-                        elif char == ')':
+                        elif char == ")":
                             if level == 0:
                                 return False
                             level -= 1
                 return level == 0
-            if not (pat.startswith('(') and pat.endswith(')') and 
-                    _is_fully_wrapped(pat)):
+
+            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,14 +1,17 @@
 import pytest
-from pandas import (
-    Series,
-)
+
+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)'
+    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",
     [
@@ -18,14 +21,16 @@ def test_string_array(dtype):
 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]),
+        (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
+    ser = Series(["asdf", "foo", "as"], dtype=dtype)
+    assert list(ser.str.fullmatch(pattern)) == expected