Fix wrapped array dtype on proxy ndarray scalar cast

python/cudf/cudf/pandas/proxy_base.py

@@ -29,7 +29,26 @@ def __new__(cls, arr):
     def __array_finalize__(self, obj):
         if obj is None:
             return
-        self._fsproxy_wrapped = getattr(obj, "_fsproxy_wrapped", obj)
+        wrapped = getattr(obj, "_fsproxy_wrapped", obj)
+        target_dtype = super().dtype
+        if (
+            hasattr(wrapped, "astype")
+            and getattr(wrapped, "dtype", None) != target_dtype
+        ):
+            try:
+                wrapped = wrapped.astype(target_dtype)
+            except (ValueError, TypeError):
+                if callable(getattr(obj, "_fsproxy_fast_to_slow", None)):
+                    wrapped = obj._fsproxy_fast_to_slow()
+                elif hasattr(wrapped, "get"):
+                    wrapped = wrapped.get()
+                else:
+                    wrapped = np.asarray(wrapped)
+                wrapped = wrapped.astype(target_dtype)
+        self._fsproxy_wrapped = wrapped
         original_slow = getattr(obj, "_fsproxy_original_slow", None)
-        if original_slow is not None:
+        if (
+            original_slow is not None
+            and getattr(original_slow, "dtype", None) == target_dtype
+        ):
             self._fsproxy_original_slow = original_slow

python/cudf/cudf_pandas_tests/test_cudf_pandas.py

@@ -2250,3 +2250,34 @@ def test_numpy_random_permutation_string(storage, na_value, box):
             data, dtype=xpd.StringDtype(storage=storage, na_value=na_value)
         ),
     )
+
+
+@pytest.mark.parametrize("scalar_type", [np.int64, np.int32, np.float32])
+def test_numpy_scalar_cast_proxy_array(scalar_type):
+    # https://github.com/NVIDIA/cudf/issues/24899
+    # NumPy scalar types (e.g. np.int64(proxy)) create a new ndarray
+    # subclass with the target dtype; the wrapped array must reflect that dtype.
+    df = xpd.DataFrame({"c0": [1.0, 2.0]})
+    left = scalar_type(df["c0"].values)
+    expected_dtype = np.dtype(scalar_type)
+    assert left.dtype == expected_dtype
+    assert_eq(left, df["c0"].values.astype(expected_dtype))
+
+    # Downstream ufuncs expecting matching integer types should succeed
+    right = df["c0"].values.astype("int64")
+    int_left = np.int64(df["c0"].values)
+    result = np.lcm(int_left, right)
+    assert_eq(result, np.array([1, 2], dtype="int64"))
+
+
+def test_numpy_vectorize_proxy_array():
+    df = xpd.DataFrame({"c0": [1, 2]})
+    result = np.vectorize(lambda x: x + 1)(df["c0"].values)
+    assert_eq(result, np.array([2, 3]))
+
+
+def test_numpy_longdouble_scalar_cast_proxy_array():
+    df = xpd.DataFrame({"c0": [1.5, 2.5]})
+    result = np.longdouble(df["c0"].values)
+    expected = df["c0"].values.astype(np.longdouble)
+    assert_eq(result, expected)

python/cudf/cudf_pandas_tests/test_fast_slow_proxy.py

@@ -1086,3 +1086,63 @@ def fake(self):
     monkeypatch.undo()
     assert Pxy.__dict__["existing"] is custom
     assert Slow.__dict__["existing"] is original_slow
+
+
+def test_proxy_ndarray_base_scalar_cast():
+    from cudf.pandas.proxy_base import ProxyNDarrayBase
+
+    class DummyArray:
+        def __init__(self, data, dtype=None):
+            self.data = np.array(data, dtype=dtype)
+            self.dtype = self.data.dtype
+
+        def astype(self, dtype):
+            return DummyArray(self.data.astype(dtype), dtype=dtype)
+
+    proxy = np.asarray([1.0, 2.0], dtype=np.float64).view(ProxyNDarrayBase)
+    proxy._fsproxy_wrapped = DummyArray([1.0, 2.0], dtype=np.float64)
+
+    cast = np.int64(proxy)
+    assert super(ProxyNDarrayBase, cast).dtype == np.dtype("int64")
+    assert cast._fsproxy_wrapped.dtype == np.dtype("int64")
+    assert isinstance(cast._fsproxy_wrapped, DummyArray)
+
+    # original_slow with differing dtype is not retained
+    proxy._fsproxy_original_slow = np.array([1.0, 2.0], dtype=np.float64)
+    cast = np.int64(proxy)
+    assert not hasattr(cast, "_fsproxy_original_slow")
+
+
+def test_proxy_ndarray_base_unsupported_dtype_fallback():
+    from cudf.pandas.proxy_base import ProxyNDarrayBase
+
+    class DummyCuPyArray:
+        def __init__(self, data, dtype=None):
+            self.data = np.array(data, dtype=dtype)
+            self.dtype = self.data.dtype
+
+        def astype(self, dtype):
+            dtype = np.dtype(dtype)
+            if dtype == np.dtype("O"):
+                raise ValueError("Unsupported dtype object")
+            return DummyCuPyArray(self.data.astype(dtype), dtype=dtype)
+
+        def get(self):
+            return np.array(self.data)
+
+    proxy = np.asarray([1.0, 2.0], dtype=np.float64).view(ProxyNDarrayBase)
+    proxy._fsproxy_wrapped = DummyCuPyArray([1.0, 2.0], dtype=np.float64)
+
+    # np.vectorize creates an object-dtype intermediate array invoking __array_finalize__
+    @np.vectorize
+    def add_one(x):
+        return x + 1
+
+    result = add_one(proxy)
+    assert_eq(result, np.array([2.0, 3.0], dtype=np.float64))
+
+    # Direct cast to an unsupported dtype falls back to CPU numpy.ndarray
+    cast_obj = proxy.astype(object)
+    assert super(ProxyNDarrayBase, cast_obj).dtype == np.dtype("O")
+    assert isinstance(cast_obj._fsproxy_wrapped, np.ndarray)
+    assert cast_obj._fsproxy_wrapped.dtype == np.dtype("O")