Merge branch 'main' into ref-gpr_index

Author: jbrockmendel

ci/code_checks.sh

@@ -597,10 +597,7 @@ if [[ -z "$CHECK" || "$CHECK" == "docstrings" ]]; then
         pandas.api.types.is_datetime64_dtype \
         pandas.api.types.is_datetime64_ns_dtype \
         pandas.api.types.is_datetime64tz_dtype \
-        pandas.api.types.is_dict_like \
-        pandas.api.types.is_file_like \
         pandas.api.types.is_float_dtype \
-        pandas.api.types.is_hashable \
         pandas.api.types.is_int64_dtype \
         pandas.api.types.is_integer_dtype \
         pandas.api.types.is_interval_dtype \

doc/source/whatsnew/v2.0.0.rst

@@ -65,15 +65,14 @@ Below is a possibly non-exhaustive list of changes:
 
 1. Instantiating using a numpy numeric array now follows the dtype of the numpy array.
    Previously, all indexes created from numpy numeric arrays were forced to 64-bit. Now,
-   the index dtype follows the dtype of the numpy array. For example, it would for all
-   signed integer arrays previously return an index with ``int64`` dtype, but will now
-   reuse the dtype of the supplied numpy array. So ``Index(np.array([1, 2, 3]))`` will be ``int32`` on 32-bit systems.
+   for example, ``Index(np.array([1, 2, 3]))`` will be ``int32`` on 32-bit systems, where
+   it previously would have been ``int64``` even on 32-bit systems.
    Instantiating :class:`Index` using a list of numbers will still return 64bit dtypes,
    e.g. ``Index([1, 2, 3])`` will have a ``int64`` dtype, which is the same as previously.
-2. The various numeric datetime attributes of :class:`DateTimeIndex` (:attr:`~Date_TimeIndex.day`,
-   :attr:`~DateTimeIndex.month`, :attr:`~DateTimeIndex.year` etc.) were previously in of
+2. The various numeric datetime attributes of :class:`DatetimeIndex` (:attr:`~DatetimeIndex.day`,
+   :attr:`~DatetimeIndex.month`, :attr:`~DatetimeIndex.year` etc.) were previously in of
    dtype ``int64``, while they were ``int32`` for :class:`DatetimeArray`. They are now
-   ``int32`` on ``DateTimeIndex`` also:
+   ``int32`` on ``DatetimeIndex`` also:
 
    .. ipython:: python
 
@@ -92,7 +91,7 @@ Below is a possibly non-exhaustive list of changes:
            ([3.0, 1.0, 2.0], ([1, 0, 0], [0, 2, 3])), shape=(3, 4)
        )
        ser = pd.Series.sparse.from_coo(A)
-       ser.index.dtype
+       ser.index.dtypes
 
 4. :class:`Index` cannot be instantiated using a float16 dtype. Previously instantiating
    an :class:`Index` using dtype ``float16`` resulted in a :class:`Float64Index` with a
@@ -1325,6 +1324,7 @@ ExtensionArray
 - Bug in :meth:`api.types.is_numeric_dtype` where a custom :class:`ExtensionDtype` would not return ``True`` if ``_is_numeric`` returned ``True`` (:issue:`50563`)
 - Bug in :meth:`api.types.is_integer_dtype`, :meth:`api.types.is_unsigned_integer_dtype`, :meth:`api.types.is_signed_integer_dtype`, :meth:`api.types.is_float_dtype` where a custom :class:`ExtensionDtype` would not return ``True`` if ``kind`` returned the corresponding NumPy type (:issue:`50667`)
 - Bug in :class:`Series` constructor unnecessarily overflowing for nullable unsigned integer dtypes (:issue:`38798`, :issue:`25880`)
+- Bug in setting non-string value into ``StringArray`` raising ``ValueError`` instead of ``TypeError`` (:issue:`49632`)
 
 Styler
 ^^^^^^

pandas/core/array_algos/replace.py

@@ -19,8 +19,6 @@
 )
 
 from pandas.core.dtypes.common import (
-    is_datetimelike_v_numeric,
-    is_numeric_v_string_like,
     is_re,
     is_re_compilable,
     is_scalar,
@@ -44,7 +42,7 @@ def should_use_regex(regex: bool, to_replace: Any) -> bool:
 
 def compare_or_regex_search(
     a: ArrayLike, b: Scalar | Pattern, regex: bool, mask: npt.NDArray[np.bool_]
-) -> ArrayLike | bool:
+) -> ArrayLike:
     """
     Compare two array-like inputs of the same shape or two scalar values
 
@@ -95,15 +93,6 @@ def _check_comparison_types(
     if isinstance(a, np.ndarray):
         a = a[mask]
 
-    if is_numeric_v_string_like(a, b):
-        # GH#29553 avoid deprecation warnings from numpy
-        return np.zeros(a.shape, dtype=bool)
-
-    elif is_datetimelike_v_numeric(a, b):
-        # GH#29553 avoid deprecation warnings from numpy
-        _check_comparison_types(False, a, b)
-        return False
-
     result = op(a)
 
     if isinstance(result, np.ndarray) and mask is not None:

pandas/core/arrays/numpy_.py

@@ -16,7 +16,12 @@
 )
 from pandas.compat.numpy import function as nv
 
+from pandas.core.dtypes.astype import astype_array
 from pandas.core.dtypes.cast import construct_1d_object_array_from_listlike
+from pandas.core.dtypes.common import (
+    is_dtype_equal,
+    pandas_dtype,
+)
 from pandas.core.dtypes.dtypes import PandasDtype
 from pandas.core.dtypes.missing import isna
 
@@ -185,6 +190,17 @@ def __array_ufunc__(self, ufunc: np.ufunc, method: str, *inputs, **kwargs):
     # ------------------------------------------------------------------------
     # Pandas ExtensionArray Interface
 
+    def astype(self, dtype, copy: bool = True):
+        dtype = pandas_dtype(dtype)
+
+        if is_dtype_equal(dtype, self.dtype):
+            if copy:
+                return self.copy()
+            return self
+
+        result = astype_array(self._ndarray, dtype=dtype, copy=copy)
+        return result
+
     def isna(self) -> np.ndarray:
         return isna(self._ndarray)
 

pandas/core/arrays/string_.py

@@ -414,14 +414,14 @@ def __setitem__(self, key, value):
             if isna(value):
                 value = libmissing.NA
             elif not isinstance(value, str):
-                raise ValueError(
+                raise TypeError(
                     f"Cannot set non-string value '{value}' into a StringArray."
                 )
         else:
             if not is_array_like(value):
                 value = np.asarray(value, dtype=object)
             if len(value) and not lib.is_string_array(value, skipna=True):
-                raise ValueError("Must provide strings.")
+                raise TypeError("Must provide strings.")
 
             value[isna(value)] = libmissing.NA
 
@@ -454,7 +454,8 @@ def astype(self, dtype, copy: bool = True):
             values = arr.astype(dtype.numpy_dtype)
             return FloatingArray(values, mask, copy=False)
         elif isinstance(dtype, ExtensionDtype):
-            return super().astype(dtype, copy=copy)
+            # Skip the PandasArray.astype method
+            return ExtensionArray.astype(self, dtype, copy)
         elif np.issubdtype(dtype, np.floating):
             arr = self._ndarray.copy()
             mask = self.isna()

pandas/core/arrays/string_arrow.py

@@ -163,13 +163,13 @@ def _maybe_convert_setitem_value(self, value):
             if isna(value):
                 value = None
             elif not isinstance(value, str):
-                raise ValueError("Scalar must be NA or str")
+                raise TypeError("Scalar must be NA or str")
         else:
             value = np.array(value, dtype=object, copy=True)
             value[isna(value)] = None
             for v in value:
                 if not (v is None or isinstance(v, str)):
-                    raise ValueError("Scalar must be NA or str")
+                    raise TypeError("Scalar must be NA or str")
         return super()._maybe_convert_setitem_value(value)
 
     def isin(self, values) -> npt.NDArray[np.bool_]:

pandas/core/dtypes/common.py

@@ -1067,64 +1067,6 @@ def is_numeric_v_string_like(a: ArrayLike, b) -> bool:
     )
 
 
-# This exists to silence numpy deprecation warnings, see GH#29553
-def is_datetimelike_v_numeric(a, b) -> bool:
-    """
-    Check if we are comparing a datetime-like object to a numeric object.
-    By "numeric," we mean an object that is either of an int or float dtype.
-
-    Parameters
-    ----------
-    a : array-like, scalar
-        The first object to check.
-    b : array-like, scalar
-        The second object to check.
-
-    Returns
-    -------
-    boolean
-        Whether we return a comparing a datetime-like to a numeric object.
-
-    Examples
-    --------
-    >>> from datetime import datetime
-    >>> dt = np.datetime64(datetime(2017, 1, 1))
-    >>>
-    >>> is_datetimelike_v_numeric(1, 1)
-    False
-    >>> is_datetimelike_v_numeric(dt, dt)
-    False
-    >>> is_datetimelike_v_numeric(1, dt)
-    True
-    >>> is_datetimelike_v_numeric(dt, 1)  # symmetric check
-    True
-    >>> is_datetimelike_v_numeric(np.array([dt]), 1)
-    True
-    >>> is_datetimelike_v_numeric(np.array([1]), dt)
-    True
-    >>> is_datetimelike_v_numeric(np.array([dt]), np.array([1]))
-    True
-    >>> is_datetimelike_v_numeric(np.array([1]), np.array([2]))
-    False
-    >>> is_datetimelike_v_numeric(np.array([dt]), np.array([dt]))
-    False
-    """
-    if not hasattr(a, "dtype"):
-        a = np.asarray(a)
-    if not hasattr(b, "dtype"):
-        b = np.asarray(b)
-
-    def is_numeric(x):
-        """
-        Check if an object has a numeric dtype (i.e. integer or float).
-        """
-        return is_integer_dtype(x) or is_float_dtype(x)
-
-    return (needs_i8_conversion(a) and is_numeric(b)) or (
-        needs_i8_conversion(b) and is_numeric(a)
-    )
-
-
 def needs_i8_conversion(arr_or_dtype) -> bool:
     """
     Check whether the array or dtype should be converted to int64.
@@ -1790,7 +1732,6 @@ def is_all_strings(value: ArrayLike) -> bool:
     "is_datetime64_dtype",
     "is_datetime64_ns_dtype",
     "is_datetime64tz_dtype",
-    "is_datetimelike_v_numeric",
     "is_datetime_or_timedelta_dtype",
     "is_decimal",
     "is_dict_like",
@@ -1809,7 +1750,6 @@ def is_all_strings(value: ArrayLike) -> bool:
     "is_number",
     "is_numeric_dtype",
     "is_any_numeric_dtype",
-    "is_numeric_v_string_like",
     "is_object_dtype",
     "is_period_dtype",
     "is_re",

pandas/core/dtypes/inference.py

@@ -119,6 +119,7 @@ def is_file_like(obj) -> bool:
     Examples
     --------
     >>> import io
+    >>> from pandas.api.types import is_file_like
     >>> buffer = io.StringIO("data")
     >>> is_file_like(buffer)
     True
@@ -275,6 +276,7 @@ def is_dict_like(obj) -> bool:
 
     Examples
     --------
+    >>> from pandas.api.types import is_dict_like
     >>> is_dict_like({1: 2})
     True
     >>> is_dict_like([1, 2, 3])
@@ -336,6 +338,7 @@ def is_hashable(obj) -> bool:
     Examples
     --------
     >>> import collections
+    >>> from pandas.api.types import is_hashable
     >>> a = ([],)
     >>> isinstance(a, collections.abc.Hashable)
     True

pandas/core/dtypes/missing.py

@@ -28,7 +28,6 @@
     is_bool_dtype,
     is_categorical_dtype,
     is_complex_dtype,
-    is_datetimelike_v_numeric,
     is_dtype_equal,
     is_extension_array_dtype,
     is_float_dtype,
@@ -505,8 +504,6 @@ def array_equivalent(
         # fastpath when we require that the dtypes match (Block.equals)
         if left.dtype.kind in ["f", "c"]:
             return _array_equivalent_float(left, right)
-        elif is_datetimelike_v_numeric(left.dtype, right.dtype):
-            return False
         elif needs_i8_conversion(left.dtype):
             return _array_equivalent_datetimelike(left, right)
         elif is_string_or_object_np_dtype(left.dtype):
@@ -529,10 +526,6 @@ def array_equivalent(
             return True
         return ((left == right) | (isna(left) & isna(right))).all()
 
-    elif is_datetimelike_v_numeric(left, right):
-        # GH#29553 avoid numpy deprecation warning
-        return False
-
     elif needs_i8_conversion(left.dtype) or needs_i8_conversion(right.dtype):
         # datetime64, timedelta64, Period
         if not is_dtype_equal(left.dtype, right.dtype):