Fix some str accessor methods

Author: jbrockmendel

pandas/_libs/lib.pyx

@@ -2786,17 +2786,21 @@ def maybe_convert_objects(ndarray[object] objects,
         seen.object_ = True
 
     elif seen.str_:
-        if convert_to_nullable_dtype and is_string_array(objects, skipna=True):
-            from pandas.core.arrays.string_ import StringDtype
+        if is_string_array(objects, skipna=True):
+            if convert_to_nullable_dtype:
+                from pandas.core.arrays.string_ import StringDtype
 
-            dtype = StringDtype()
-            return dtype.construct_array_type()._from_sequence(objects, dtype=dtype)
+                if using_string_dtype():
+                    dtype = StringDtype(na_value=np.nan)
+                else:
+                    dtype = StringDtype()
+                return dtype.construct_array_type()._from_sequence(objects, dtype=dtype)
 
-        elif using_string_dtype() and is_string_array(objects, skipna=True):
-            from pandas.core.arrays.string_ import StringDtype
+            elif using_string_dtype():
+                from pandas.core.arrays.string_ import StringDtype
 
-            dtype = StringDtype(na_value=np.nan)
-            return dtype.construct_array_type()._from_sequence(objects, dtype=dtype)
+                dtype = StringDtype(na_value=np.nan)
+                return dtype.construct_array_type()._from_sequence(objects, dtype=dtype)
 
         seen.object_ = True
     elif seen.interval_:

pandas/core/arrays/datetimelike.py

@@ -973,7 +973,13 @@ def _cmp_method(self, other, op):
         try:
             other = self._validate_comparison_value(other)
         except InvalidComparison:
-            return invalid_comparison(self, other, op)
+            res = invalid_comparison(self, other, op)
+            if get_option("mode.pdep16_data_types"):
+                res = pd_array(res)
+                o_mask = isna(other)
+                mask = self._isnan | o_mask
+                res[mask] = res.dtype.na_value
+            return res
 
         dtype = getattr(other, "dtype", None)
         if is_object_dtype(dtype):
@@ -982,12 +988,18 @@ def _cmp_method(self, other, op):
             result = ops.comp_method_OBJECT_ARRAY(
                 op, np.asarray(self.astype(object)), other
             )
+            if get_option("mode.pdep16_data_types"):
+                result = pd_array(result)
+                result[self.isna()] = result.dtype.na_value
             return result
         if other is NaT:
             if op is operator.ne:
                 result = np.ones(self.shape, dtype=bool)
             else:
                 result = np.zeros(self.shape, dtype=bool)
+            if get_option("mode.pdep16_data_types"):
+                result = pd_array(result)
+                result[self.isna()] = result.dtype.na_value
             return result
 
         if not isinstance(self.dtype, PeriodDtype):
@@ -1018,6 +1030,10 @@ def _cmp_method(self, other, op):
             nat_result = op is operator.ne
             np.putmask(result, mask, nat_result)
 
+        if get_option("mode.pdep16_data_types"):
+            result = pd_array(result)
+            if mask.any():
+                result[mask] = result.dtype.na_value
         return result
 
     # pow is invalid for all three subclasses; TimedeltaArray will override

pandas/core/arrays/string_.py

@@ -444,6 +444,9 @@ def _str_map(
             elif dtype == np.dtype("bool"):
                 # GH#55736
                 na_value = bool(na_value)
+
+            dtype = pandas_dtype(dtype)
+            pass_dtype = dtype.numpy_dtype
             result = lib.map_infer_mask(
                 arr,
                 f,
@@ -453,7 +456,7 @@ def _str_map(
                 # error: Argument 1 to "dtype" has incompatible type
                 # "Union[ExtensionDtype, str, dtype[Any], Type[object]]"; expected
                 # "Type[object]"
-                dtype=np.dtype(cast(type, dtype)),
+                dtype=np.dtype(cast(type, pass_dtype)),
             )
 
             if not na_value_is_na:

pandas/core/arrays/timedeltas.py

@@ -9,6 +9,8 @@
 
 import numpy as np
 
+from pandas._config import get_option
+
 from pandas._libs import (
     lib,
     tslibs,
@@ -59,6 +61,7 @@
 from pandas.core.arrays import datetimelike as dtl
 from pandas.core.arrays._ranges import generate_regular_range
 import pandas.core.common as com
+from pandas.core.construction import array as pd_array
 from pandas.core.ops.common import unpack_zerodim_and_defer
 
 if TYPE_CHECKING:
@@ -528,10 +531,13 @@ def _scalar_divlike_op(self, other, op):
                 # specifically timedelta64-NaT
                 res = np.empty(self.shape, dtype=np.float64)
                 res.fill(np.nan)
-                return res
 
-            # otherwise, dispatch to Timedelta implementation
-            return op(self._ndarray, other)
+            else:
+                # otherwise, dispatch to Timedelta implementation
+                res = op(self._ndarray, other)
+            if get_option("mode.pdep16_data_types"):
+                res = pd_array(res)
+            return res
 
         else:
             # caller is responsible for checking lib.is_scalar(other)
@@ -585,6 +591,8 @@ def _vector_divlike_op(self, other, op) -> np.ndarray | Self:
                 result = result.astype(np.float64)
                 np.putmask(result, mask, np.nan)
 
+        if get_option("mode.pdep16_data_types"):
+            result = pd_array(result)
         return result
 
     @unpack_zerodim_and_defer("__truediv__")

pandas/core/indexes/base.py

@@ -7137,7 +7137,7 @@ def _cmp_method(self, other, op):
         """
         Wrapper used to dispatch comparison operations.
         """
-        if self.is_(other):
+        if False:  # self.is_(other):
             # fastpath
             if op in {operator.eq, operator.le, operator.ge}:
                 arr = np.ones(len(self), dtype=bool)

pandas/core/strings/object_array.py

@@ -74,6 +74,10 @@ def _str_map(
             na_value = self.dtype.na_value  # type: ignore[attr-defined]
 
         if not len(self):
+            if dtype == "Int64":
+                from pandas.core.construction import array as pd_array
+
+                return pd_array([], dtype=dtype)
             return np.array([], dtype=dtype)
 
         arr = np.asarray(self, dtype=object)
@@ -110,12 +114,17 @@ def g(x):
             np.putmask(result, mask, na_value)
             if convert and result.dtype == object:
                 result = lib.maybe_convert_objects(result)
+
+        if dtype == "Int64":
+            from pandas.core.construction import array as pd_array
+
+            return pd_array(result, dtype=dtype)
         return result
 
     def _str_count(self, pat, flags: int = 0):
         regex = re.compile(pat, flags=flags)
         f = lambda x: len(regex.findall(x))
-        return self._str_map(f, dtype="int64")
+        return self._str_map(f, dtype="Int64")
 
     def _str_pad(
         self,
@@ -298,7 +307,7 @@ def _str_find_(self, sub, start, end, side):
             f = lambda x: getattr(x, method)(sub, start)
         else:
             f = lambda x: getattr(x, method)(sub, start, end)
-        return self._str_map(f, dtype="int64")
+        return self._str_map(f, dtype="Int64")
 
     def _str_findall(self, pat, flags: int = 0):
         regex = re.compile(pat, flags=flags)
@@ -319,14 +328,14 @@ def _str_index(self, sub, start: int = 0, end=None):
             f = lambda x: x.index(sub, start, end)
         else:
             f = lambda x: x.index(sub, start, end)
-        return self._str_map(f, dtype="int64")
+        return self._str_map(f, dtype="Int64")
 
     def _str_rindex(self, sub, start: int = 0, end=None):
         if end:
             f = lambda x: x.rindex(sub, start, end)
         else:
             f = lambda x: x.rindex(sub, start, end)
-        return self._str_map(f, dtype="int64")
+        return self._str_map(f, dtype="Int64")
 
     def _str_join(self, sep: str):
         return self._str_map(sep.join)
@@ -339,7 +348,7 @@ def _str_rpartition(self, sep: str, expand):
         return self._str_map(lambda x: x.rpartition(sep), dtype="object")
 
     def _str_len(self):
-        return self._str_map(len, dtype="int64")
+        return self._str_map(len, dtype="Int64")
 
     def _str_slice(self, start=None, stop=None, step=None):
         obj = slice(start, stop, step)