fix merge conflict

Author: davidwendt

conda/environments/all_cuda-129_arch-aarch64.yaml

@@ -59,6 +59,7 @@ dependencies:
 - numpy>=1.23,<3.0a0
 - numpydoc
 - nvcomp==4.2.0.11
+- nvidia-ml-py
 - nvtx>=0.2.1
 - openpyxl
 - packaging

conda/environments/all_cuda-129_arch-x86_64.yaml

@@ -60,6 +60,7 @@ dependencies:
 - numpy>=1.23,<3.0a0
 - numpydoc
 - nvcomp==4.2.0.11
+- nvidia-ml-py
 - nvtx>=0.2.1
 - openpyxl
 - packaging

dependencies.yaml

@@ -718,6 +718,7 @@ dependencies:
     common:
       - output_types: [conda, requirements, pyproject]
         packages:
+          - nvidia-ml-py
           - polars>=1.28,<1.32
     specific:
       - output_types: [requirements, pyproject]
@@ -729,8 +730,12 @@ dependencies:
     common:
       - output_types: [conda, requirements, pyproject]
         packages:
+<<<<<<< HEAD
           - rapids-dask-dependency==25.10.*,>=0.0.0a0
           - nvidia-ml-py
+=======
+          - rapids-dask-dependency==25.8.*,>=0.0.0a0
+>>>>>>> branch-25.08
   run_dask_cudf:
     common:
       - output_types: [conda, requirements, pyproject]

python/cudf/cudf/tests/test_api_types.py

@@ -1109,4 +1109,3 @@ def test_pandas_agreement_scalar(obj):
 
 
 # TODO: Add test of interval.
-# TODO: Add test of Scalar.

python/cudf/cudf/tests/test_array_function.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2018-2024, NVIDIA CORPORATION.
+# Copyright (c) 2018-2025, NVIDIA CORPORATION.
 
 import numpy as np
 import pandas as pd
@@ -8,35 +8,11 @@
 from cudf.testing import assert_eq
 
 
-# To determine if NEP18 is available in the current version of NumPy we simply
-# attempt to concatenate an object with `__array_function__` defined and see if
-# NumPy invokes the protocol or not. Taken from dask array
-# https://github.com/dask/dask/blob/master/dask/array/utils.py#L352-L363
-# TODO: Unclear if this is still necessary. NEP 18 was introduced as the
-# default in 1.17 (https://github.com/numpy/numpy/releases/tag/v1.17.0) almost
-# 3 years ago, and it was originally introduced one version before in 1.16
-# (although not enabled by default then). Can we safely assume that testers
-# will have a sufficiently new version of numpy to run these tests?
-class _Test:
-    def __array_function__(self, *args, **kwargs):
-        return True
+@pytest.fixture
+def rng():
+    return np.random.default_rng(seed=0)
 
 
-try:
-    np.concatenate([_Test()])
-except ValueError:
-    missing_arrfunc_cond = True
-else:
-    missing_arrfunc_cond = False
-
-del _Test
-
-missing_arrfunc_reason = "NEP-18 support is not available in NumPy"
-
-rng = np.random.default_rng(seed=0)
-
-
-@pytest.mark.skipif(missing_arrfunc_cond, reason=missing_arrfunc_reason)
 @pytest.mark.parametrize(
     "func",
     [
@@ -48,7 +24,7 @@ def __array_function__(self, *args, **kwargs):
         lambda x: np.linalg.norm(x),
     ],
 )
-def test_array_func_cudf_series(func):
+def test_array_func_cudf_series(func, rng):
     np_ar = rng.random(100)
     cudf_ser = cudf.Series(np_ar)
     expect = func(np_ar)
@@ -59,7 +35,6 @@ def test_array_func_cudf_series(func):
         assert_eq(expect, got.to_numpy())
 
 
-@pytest.mark.skipif(missing_arrfunc_cond, reason=missing_arrfunc_reason)
 @pytest.mark.parametrize(
     "func",
     [
@@ -73,15 +48,14 @@ def test_array_func_cudf_series(func):
         lambda x: np.prod(x, axis=1),
     ],
 )
-def test_array_func_cudf_dataframe(func):
+def test_array_func_cudf_dataframe(func, rng):
     pd_df = pd.DataFrame(rng.uniform(size=(100, 10)))
     cudf_df = cudf.from_pandas(pd_df)
     expect = func(pd_df)
     got = func(cudf_df)
     assert_eq(expect, got)
 
 
-@pytest.mark.skipif(missing_arrfunc_cond, reason=missing_arrfunc_reason)
 @pytest.mark.parametrize(
     "func",
     [
@@ -90,21 +64,20 @@ def test_array_func_cudf_dataframe(func):
         lambda x: np.linalg.det(x),
     ],
 )
-def test_array_func_missing_cudf_dataframe(func):
+def test_array_func_missing_cudf_dataframe(func, rng):
     pd_df = pd.DataFrame(rng.uniform(size=(100, 10)))
     cudf_df = cudf.from_pandas(pd_df)
     with pytest.raises(TypeError):
         func(cudf_df)
 
 
-@pytest.mark.skipif(missing_arrfunc_cond, reason=missing_arrfunc_reason)
 @pytest.mark.parametrize(
     "func",
     [
         lambda x: np.unique(x),
     ],
 )
-def test_array_func_cudf_index(func):
+def test_array_func_cudf_index(func, rng):
     np_ar = rng.random(100)
     cudf_index = cudf.Index(cudf.Series(np_ar))
     expect = func(np_ar)
@@ -115,7 +88,6 @@ def test_array_func_cudf_index(func):
         assert_eq(expect, got.to_numpy())
 
 
-@pytest.mark.skipif(missing_arrfunc_cond, reason=missing_arrfunc_reason)
 @pytest.mark.parametrize(
     "func",
     [
@@ -124,14 +96,13 @@ def test_array_func_cudf_index(func):
         lambda x: np.linalg.det(x),
     ],
 )
-def test_array_func_missing_cudf_index(func):
+def test_array_func_missing_cudf_index(func, rng):
     np_ar = rng.random(100)
     cudf_index = cudf.Index(cudf.Series(np_ar))
     with pytest.raises(TypeError):
         func(cudf_index)
 
 
-@pytest.mark.skipif(missing_arrfunc_cond, reason=missing_arrfunc_reason)
 @pytest.mark.parametrize(
     "func",
     [
@@ -150,7 +121,6 @@ def test_array_func_missing_cudf_multi_index(func):
         func(cudf_multi_index)
 
 
-@pytest.mark.skipif(missing_arrfunc_cond, reason=missing_arrfunc_reason)
 def test_list_input_array_func():
     ar = np.array([1, 2, 3])
 

python/cudf/cudf/tests/test_array_ufunc.py

@@ -19,11 +19,16 @@
 from cudf.testing import assert_eq
 from cudf.testing._utils import expect_warning_if, set_random_null_mask_inplace
 
-_UFUNCS = [
-    obj
-    for obj in (getattr(np, name) for name in dir(np))
-    if isinstance(obj, np.ufunc)
-]
+
+@pytest.fixture(
+    params=[
+        obj
+        for obj in (getattr(np, name) for name in dir(np))
+        if isinstance(obj, np.ufunc)
+    ]
+)
+def ufunc(request):
+    return request.param
 
 
 @contextmanager
@@ -72,7 +77,6 @@ def _hide_ufunc_warnings(ufunc):
         yield
 
 
-@pytest.mark.parametrize("ufunc", _UFUNCS)
 def test_ufunc_index(request, ufunc):
     # Note: This test assumes that all ufuncs are unary or binary.
     fname = ufunc.__name__
@@ -157,7 +161,6 @@ def test_binary_ufunc_index_array(ufunc, reflect):
     PANDAS_VERSION < PANDAS_CURRENT_SUPPORTED_VERSION,
     reason="warning not present in older pandas versions",
 )
-@pytest.mark.parametrize("ufunc", _UFUNCS)
 @pytest.mark.parametrize("has_nulls", [True, False])
 @pytest.mark.parametrize("indexed", [True, False])
 def test_ufunc_series(request, ufunc, has_nulls, indexed):
@@ -367,7 +370,6 @@ def test_ufunc_cudf_series_error_with_out_kwarg(func):
     PANDAS_VERSION < PANDAS_CURRENT_SUPPORTED_VERSION,
     reason="warning not present in older pandas versions",
 )
-@pytest.mark.parametrize("ufunc", (uf for uf in _UFUNCS if uf != np.matmul))
 @pytest.mark.parametrize("has_nulls", [True, False])
 @pytest.mark.parametrize("indexed", [True, False])
 def test_ufunc_dataframe(request, ufunc, has_nulls, indexed):
@@ -407,6 +409,12 @@ def test_ufunc_dataframe(request, ufunc, has_nulls, indexed):
             reason="https://github.com/cupy/cupy/issues/9018",
         )
     )
+    request.applymarker(
+        pytest.mark.xfail(
+            condition=fname == "matmul",
+            reason=f"{fname} is not supported in cuDF",
+        )
+    )
 
     N = 100
     # Avoid zeros in either array to skip division by 0 errors. Also limit the

python/cudf/cudf/tests/test_avro_reader_fastavro_integration.py

@@ -36,23 +36,36 @@ def cudf_from_avro_util(schema: dict, records: list) -> cudf.DataFrame:
     return cudf.read_avro(buffer)
 
 
-avro_type_params = [
-    ("boolean", "bool"),
-    ("int", "int32"),
-    ("long", "int64"),
-    ("float", "float32"),
-    ("double", "float64"),
-    ("bytes", "str"),
-    ("string", "str"),
-]
-
-
-@pytest.mark.parametrize("avro_type, expected_dtype", avro_type_params)
+@pytest.fixture(
+    params=[
+        ("boolean", "bool"),
+        ("int", "int32"),
+        ("long", "int64"),
+        ("float", "float32"),
+        ("double", "float64"),
+        ("bytes", "str"),
+        ("string", "str"),
+    ]
+)
+def avro_type_params(request):
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def nullable(request):
+    return request.param
+
+
+@pytest.fixture(params=[True, False])
+def prepend_null(request):
+    return request.param
+
+
 @pytest.mark.parametrize("namespace", [None, "root_ns"])
-@pytest.mark.parametrize("nullable", [True, False])
 def test_can_detect_dtype_from_avro_type(
-    avro_type, expected_dtype, namespace, nullable
+    avro_type_params, namespace, nullable
 ):
+    avro_type, expected_dtype = avro_type_params
     avro_type = avro_type if not nullable else ["null", avro_type]
 
     schema = fastavro.parse_schema(
@@ -73,12 +86,11 @@ def test_can_detect_dtype_from_avro_type(
     assert_eq(expected, actual)
 
 
-@pytest.mark.parametrize("avro_type, expected_dtype", avro_type_params)
 @pytest.mark.parametrize("namespace", [None, "root_ns"])
-@pytest.mark.parametrize("nullable", [True, False])
 def test_can_detect_dtype_from_avro_type_nested(
-    avro_type, expected_dtype, namespace, nullable
+    avro_type_params, namespace, nullable
 ):
+    avro_type, expected_dtype = avro_type_params
     avro_type = avro_type if not nullable else ["null", avro_type]
 
     schema_leaf = {
@@ -146,8 +158,8 @@ def test_can_parse_single_value(avro_type, cudf_type, avro_val, cudf_val):
     assert_eq(expected, actual)
 
 
-@pytest.mark.parametrize("avro_type, cudf_type", avro_type_params)
-def test_can_parse_single_null(avro_type, cudf_type):
+def test_can_parse_single_null(avro_type_params):
+    avro_type, expected_dtype = avro_type_params
     schema_root = {
         "name": "root",
         "type": "record",
@@ -159,14 +171,14 @@ def test_can_parse_single_null(avro_type, cudf_type):
     actual = cudf_from_avro_util(schema_root, records)
 
     expected = cudf.DataFrame(
-        {"prop": cudf.Series(data=[None], dtype=cudf_type)}
+        {"prop": cudf.Series(data=[None], dtype=expected_dtype)}
     )
 
     assert_eq(expected, actual)
 
 
-@pytest.mark.parametrize("avro_type, cudf_type", avro_type_params)
-def test_can_parse_no_data(avro_type, cudf_type):
+def test_can_parse_no_data(avro_type_params):
+    avro_type, expected_dtype = avro_type_params
     schema_root = {
         "name": "root",
         "type": "record",
@@ -177,16 +189,18 @@ def test_can_parse_no_data(avro_type, cudf_type):
 
     actual = cudf_from_avro_util(schema_root, records)
 
-    expected = cudf.DataFrame({"prop": cudf.Series(data=[], dtype=cudf_type)})
+    expected = cudf.DataFrame(
+        {"prop": cudf.Series(data=[], dtype=expected_dtype)}
+    )
 
     assert_eq(expected, actual)
 
 
 @pytest.mark.xfail(
     reason="cudf avro reader is unable to parse zero-field metadata."
 )
-@pytest.mark.parametrize("avro_type, cudf_type", avro_type_params)
-def test_can_parse_no_fields(avro_type, cudf_type):
+def test_can_parse_no_fields(avro_type_params):
+    avro_type, expected_dtype = avro_type_params
     schema_root = {
         "name": "root",
         "type": "record",
@@ -251,26 +265,15 @@ def test_avro_decompression(set_decomp_env_vars, rows, codec):
     assert_eq(expected_df, got_df)
 
 
-avro_logical_type_params = [
-    # (avro logical type, avro primitive type, cudf expected dtype)
-    ("date", "int", "datetime64[s]"),
-]
-
-
-@pytest.mark.parametrize(
-    "logical_type, primitive_type, expected_dtype", avro_logical_type_params
-)
 @pytest.mark.parametrize("namespace", [None, "root_ns"])
-@pytest.mark.parametrize("nullable", [True, False])
-@pytest.mark.parametrize("prepend_null", [True, False])
 def test_can_detect_dtypes_from_avro_logical_type(
-    logical_type,
-    primitive_type,
-    expected_dtype,
     namespace,
     nullable,
     prepend_null,
 ):
+    logical_type = "date"
+    primitive_type = "int"
+    expected_dtype = "datetime64[s]"
     avro_type = [{"logicalType": logical_type, "type": primitive_type}]
     if nullable:
         if prepend_null:
@@ -303,8 +306,6 @@ def get_days_from_epoch(date: datetime.date | None) -> int | None:
 
 
 @pytest.mark.parametrize("namespace", [None, "root_ns"])
-@pytest.mark.parametrize("nullable", [True, False])
-@pytest.mark.parametrize("prepend_null", [True, False])
 @pytest.mark.skipif(
     PANDAS_VERSION < PANDAS_CURRENT_SUPPORTED_VERSION,
     reason="Fails in older versions of pandas (datetime(9999, ...) too large)",