Merge branch 'master' into feature/generalized_window_operations

Author: Matt Roeschke

doc/source/whatsnew/v1.0.0.rst

@@ -184,6 +184,7 @@ Indexing
 - Bug in :meth:`DataFrame.explode` would duplicate frame in the presence of duplicates in the index (:issue:`28010`)
 - Bug in reindexing a :meth:`PeriodIndex` with another type of index that contained a `Period` (:issue:`28323`) (:issue:`28337`)
 - Fix assignment of column via `.loc` with numpy non-ns datetime type (:issue:`27395`)
+- Bug in :meth:`Float64Index.astype` where ``np.inf`` was not handled properly when casting to an integer dtype (:issue:`28475`)
 
 Missing
 ^^^^^^^
@@ -240,7 +241,7 @@ Sparse
 ExtensionArray
 ^^^^^^^^^^^^^^
 
--
+- Bug in :class:`arrays.PandasArray` when setting a scalar string (:issue:`28118`, :issue:`28150`).
 -
 
 

pandas/_libs/testing.pyx

@@ -143,11 +143,9 @@ cpdef assert_almost_equal(a, b,
                 from pandas.util.testing import assert_attr_equal
                 assert_attr_equal('dtype', a, b, obj=obj)
 
-            try:
-                if array_equivalent(a, b, strict_nan=True):
-                    return True
-            except:
-                pass
+            if array_equivalent(a, b, strict_nan=True):
+                return True
+
         else:
             na, nb = len(a), len(b)
 

pandas/core/arrays/numpy_.py

@@ -235,15 +235,8 @@ def __setitem__(self, key, value):
         if not lib.is_scalar(value):
             value = np.asarray(value)
 
-        values = self._ndarray
-        t = np.result_type(value, values)
-        if t != self._ndarray.dtype:
-            values = values.astype(t, casting="safe")
-            values[key] = value
-            self._dtype = PandasDtype(t)
-            self._ndarray = values
-        else:
-            self._ndarray[key] = value
+        value = np.asarray(value, dtype=self._ndarray.dtype)
+        self._ndarray[key] = value
 
     def __len__(self) -> int:
         return len(self._ndarray)

pandas/core/dtypes/missing.py

@@ -445,7 +445,7 @@ def array_equivalent(left, right, strict_nan=False):
                 if not isinstance(right_value, float) or not np.isnan(right_value):
                     return False
             else:
-                if left_value != right_value:
+                if np.any(left_value != right_value):
                     return False
         return True
 

pandas/core/indexes/base.py

@@ -452,7 +452,7 @@ def __new__(
         elif hasattr(data, "__array__"):
             return Index(np.asarray(data), dtype=dtype, copy=copy, name=name, **kwargs)
         elif data is None or is_scalar(data):
-            cls._scalar_data_error(data)
+            raise cls._scalar_data_error(data)
         else:
             if tupleize_cols and is_list_like(data):
                 # GH21470: convert iterable to list before determining if empty
@@ -4020,7 +4020,9 @@ def _try_convert_to_int_index(cls, data, copy, name, dtype):
 
     @classmethod
     def _scalar_data_error(cls, data):
-        raise TypeError(
+        # We return the TypeError so that we can raise it from the constructor
+        #  in order to keep mypy happy
+        return TypeError(
             "{0}(...) must be called with a collection of some "
             "kind, {1} was passed".format(cls.__name__, repr(data))
         )
@@ -4048,7 +4050,7 @@ def _coerce_to_ndarray(cls, data):
 
         if not isinstance(data, (np.ndarray, Index)):
             if data is None or is_scalar(data):
-                cls._scalar_data_error(data)
+                raise cls._scalar_data_error(data)
 
             # other iterable of some kind
             if not isinstance(data, (ABCSeries, list, tuple)):

pandas/core/indexes/category.py

@@ -194,7 +194,7 @@ def __new__(
             # if data is None, then categories must be provided
             if is_scalar(data):
                 if data is not None or categories is None:
-                    cls._scalar_data_error(data)
+                    raise cls._scalar_data_error(data)
                 data = []
 
         data = cls._create_categorical(data, dtype=dtype)

pandas/core/indexes/numeric.py

@@ -5,6 +5,7 @@
 from pandas._libs import index as libindex
 from pandas.util._decorators import Appender, cache_readonly
 
+from pandas.core.dtypes.cast import astype_nansafe
 from pandas.core.dtypes.common import (
     is_bool,
     is_bool_dtype,
@@ -367,12 +368,11 @@ def astype(self, dtype, copy=True):
                 "values are required for conversion"
             ).format(dtype=dtype)
             raise TypeError(msg)
-        elif (
-            is_integer_dtype(dtype) and not is_extension_array_dtype(dtype)
-        ) and self.hasnans:
+        elif is_integer_dtype(dtype) and not is_extension_array_dtype(dtype):
             # TODO(jreback); this can change once we have an EA Index type
             # GH 13149
-            raise ValueError("Cannot convert NA to integer")
+            arr = astype_nansafe(self.values, dtype=dtype)
+            return Int64Index(arr)
         return super().astype(dtype, copy=copy)
 
     @Appender(_index_shared_docs["_convert_scalar_indexer"])

pandas/tests/arithmetic/test_datetime64.py

@@ -78,17 +78,6 @@ def assert_invalid_comparison(left, right, box):
         right >= left
 
 
-def assert_all(obj):
-    """
-    Test helper to call call obj.all() the appropriate number of times on
-    a Series or DataFrame.
-    """
-    if isinstance(obj, pd.DataFrame):
-        assert obj.all().all()
-    else:
-        assert obj.all()
-
-
 # ------------------------------------------------------------------
 # Comparisons
 
@@ -578,17 +567,17 @@ def test_comparison_tzawareness_compat(self, op, box_df_fail):
             op(dz, np.array(list(dr), dtype=object))
 
         # The aware==aware and naive==naive comparisons should *not* raise
-        assert_all(dr == dr)
-        assert_all(dr == list(dr))
-        assert_all(list(dr) == dr)
-        assert_all(np.array(list(dr), dtype=object) == dr)
-        assert_all(dr == np.array(list(dr), dtype=object))
-
-        assert_all(dz == dz)
-        assert_all(dz == list(dz))
-        assert_all(list(dz) == dz)
-        assert_all(np.array(list(dz), dtype=object) == dz)
-        assert_all(dz == np.array(list(dz), dtype=object))
+        assert np.all(dr == dr)
+        assert np.all(dr == list(dr))
+        assert np.all(list(dr) == dr)
+        assert np.all(np.array(list(dr), dtype=object) == dr)
+        assert np.all(dr == np.array(list(dr), dtype=object))
+
+        assert np.all(dz == dz)
+        assert np.all(dz == list(dz))
+        assert np.all(list(dz) == dz)
+        assert np.all(np.array(list(dz), dtype=object) == dz)
+        assert np.all(dz == np.array(list(dz), dtype=object))
 
     @pytest.mark.parametrize(
         "op",
@@ -606,12 +595,12 @@ def test_comparison_tzawareness_compat_scalars(self, op, box_with_array):
         ts = pd.Timestamp("2000-03-14 01:59")
         ts_tz = pd.Timestamp("2000-03-14 01:59", tz="Europe/Amsterdam")
 
-        assert_all(dr > ts)
+        assert np.all(dr > ts)
         msg = "Cannot compare tz-naive and tz-aware"
         with pytest.raises(TypeError, match=msg):
             op(dr, ts_tz)
 
-        assert_all(dz > ts_tz)
+        assert np.all(dz > ts_tz)
         with pytest.raises(TypeError, match=msg):
             op(dz, ts)
 

pandas/tests/arrays/test_numpy.py

@@ -211,3 +211,18 @@ def test_basic_binop():
     result = x + x
     expected = PandasArray(np.array([2, 4, 6]))
     tm.assert_extension_array_equal(result, expected)
+
+
+@pytest.mark.parametrize("dtype", [None, object])
+def test_setitem_object_typecode(dtype):
+    arr = PandasArray(np.array(["a", "b", "c"], dtype=dtype))
+    arr[0] = "t"
+    expected = PandasArray(np.array(["t", "b", "c"], dtype=dtype))
+    tm.assert_extension_array_equal(arr, expected)
+
+
+def test_setitem_no_coercion():
+    # https://github.com/pandas-dev/pandas/issues/28150
+    arr = PandasArray(np.array([1, 2, 3]))
+    with pytest.raises(ValueError, match="int"):
+        arr[0] = "a"

pandas/tests/dtypes/test_missing.py

@@ -360,6 +360,20 @@ def test_array_equivalent_str():
         )
 
 
+def test_array_equivalent_nested():
+    # reached in groupby aggregations, make sure we use np.any when checking
+    #  if the comparison is truthy
+    left = np.array([np.array([50, 70, 90]), np.array([20, 30, 40])], dtype=object)
+    right = np.array([np.array([50, 70, 90]), np.array([20, 30, 40])], dtype=object)
+
+    assert array_equivalent(left, right, strict_nan=True)
+    assert not array_equivalent(left, right[::-1], strict_nan=True)
+
+    left = np.array([np.array([50, 50, 50]), np.array([40, 40, 40])], dtype=object)
+    right = np.array([50, 40])
+    assert not array_equivalent(left, right, strict_nan=True)
+
+
 @pytest.mark.parametrize(
     "dtype, na_value",
     [