Remove pyarrow from cudf_polars tests (#19219)

With #19193 and this PR, we'll not import `pyarrow` explicitly in `cudf_polars` xref #18534

Authors:
  - Matthew Roeschke (https://github.com/mroeschke)

Approvers:
  - Matthew Murray (https://github.com/Matt711)

URL: #19219

Author: mroeschke

python/cudf_polars/tests/containers/test_column.py

@@ -3,7 +3,6 @@
 
 from __future__ import annotations
 
-import pyarrow
 import pytest
 
 import polars as pl
@@ -71,21 +70,23 @@ def test_shallow_copy():
 @pytest.mark.parametrize("typeid", [pl.Int8(), pl.Float32()])
 def test_mask_nans(typeid):
     dtype = DataType(typeid)
-    values = pyarrow.array([0, 0, 0], type=plc.interop.to_arrow(dtype.plc))
-    column = Column(plc.Column.from_arrow(values), dtype=dtype)
+    column = Column(
+        plc.Column.from_iterable_of_py([0, 0, 0], dtype=dtype.plc), dtype=dtype
+    )
     masked = column.mask_nans()
     assert column.null_count == masked.null_count
 
 
 def test_mask_nans_float():
     dtype = DataType(pl.Float32())
-    values = pyarrow.array([0, 0, float("nan")], type=plc.interop.to_arrow(dtype.plc))
-    column = Column(plc.Column.from_arrow(values), dtype=dtype)
+    column = Column(
+        plc.Column.from_iterable_of_py([0, 0, float("nan")], dtype=dtype.plc),
+        dtype=dtype,
+    )
     masked = column.mask_nans()
-    expect = pyarrow.array([0, 0, None], type=plc.interop.to_arrow(dtype.plc))
-    got = pyarrow.array(plc.interop.to_arrow(masked.obj))
-
-    assert expect == got
+    assert masked.nan_count == 0
+    assert masked.slice((0, 2)).null_count == 0
+    assert masked.slice((2, 1)).null_count == 1
 
 
 def test_slice_none_returns_self():

python/cudf_polars/tests/containers/test_dataframe.py

@@ -3,7 +3,6 @@
 
 from __future__ import annotations
 
-import pyarrow as pa
 import pytest
 
 import polars as pl
@@ -175,20 +174,18 @@ def test_empty_name_roundtrips_no_overlap():
 
 
 @pytest.mark.parametrize(
-    "arrow_tbl",
+    "polars_tbl",
     [
-        pa.table([]),
-        pa.table({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]}),
-        pa.table({"a": [1, 2, 3]}),
-        pa.table({"a": [1], "b": [2], "c": [3]}),
-        pa.table({"a": ["a", "bb", "ccc"]}),
-        pa.table({"a": [1, 2, None], "b": [None, 3, 4]}),
+        pl.DataFrame(),
+        pl.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]}),
+        pl.DataFrame({"a": [1, 2, 3]}),
+        pl.DataFrame({"a": [1], "b": [2], "c": [3]}),
+        pl.DataFrame({"a": ["a", "bb", "ccc"]}),
+        pl.DataFrame({"a": [1, 2, None], "b": [None, 3, 4]}),
     ],
 )
-def test_serialization_roundtrip(arrow_tbl):
-    plc_tbl = plc.Table.from_arrow(arrow_tbl)
-    dtypes = [DataType(pl_type) for pl_type in pl.from_arrow(arrow_tbl).dtypes]
-    df = DataFrame.from_table(plc_tbl, names=arrow_tbl.column_names, dtypes=dtypes)
+def test_serialization_roundtrip(polars_tbl):
+    df = DataFrame.from_polars(polars_tbl)
 
     header, frames = df.serialize()
     res = DataFrame.deserialize(header, frames)

python/cudf_polars/tests/experimental/test_dask_serialize.py

@@ -3,19 +3,16 @@
 
 from __future__ import annotations
 
-import numpy as np
-import pyarrow as pa
 import pytest
 from distributed.protocol import deserialize, serialize
 
 import polars as pl
 from polars.testing.asserts import assert_frame_equal
 
-import pylibcudf as plc
 import rmm
 from rmm.pylibrmm.stream import DEFAULT_STREAM
 
-from cudf_polars.containers import DataFrame, DataType
+from cudf_polars.containers import DataFrame
 from cudf_polars.experimental.dask_registers import register
 
 # Must register serializers before running tests
@@ -33,15 +30,15 @@ def convert_to_rmm(frame):
 
 
 @pytest.mark.parametrize(
-    "arrow_tbl",
+    "polars_tbl",
     [
-        pa.table([]),
-        pa.table({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]}),
-        pa.table({"a": [1, 2, 3]}),
-        pa.table({"a": [1], "b": [2], "c": [3]}),
-        pa.table({"a": ["a", "bb", "ccc"]}),
-        pa.table({"a": [1, 2, None], "b": [None, 3, 4]}),
-        pa.table({"a": pa.array(np.arange(1e7))}),
+        pl.DataFrame(),
+        pl.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]}),
+        pl.DataFrame({"a": [1, 2, 3]}),
+        pl.DataFrame({"a": [1], "b": [2], "c": [3]}),
+        pl.DataFrame({"a": ["a", "bb", "ccc"]}),
+        pl.DataFrame({"a": [1, 2, None], "b": [None, 3, 4]}),
+        pl.DataFrame({"a": range(int(1e7))}),
     ],
 )
 @pytest.mark.parametrize("protocol", ["cuda", "cuda_rmm", "dask"])
@@ -57,10 +54,8 @@ def convert_to_rmm(frame):
         },
     ],
 )
-def test_dask_serialization_roundtrip(arrow_tbl, protocol, context):
-    plc_tbl = plc.Table.from_arrow(arrow_tbl)
-    dtypes = [DataType(pl_type) for pl_type in pl.from_arrow(arrow_tbl).dtypes]
-    df = DataFrame.from_table(plc_tbl, names=arrow_tbl.column_names, dtypes=dtypes)
+def test_dask_serialization_roundtrip(polars_tbl, protocol, context):
+    df = DataFrame.from_polars(polars_tbl)
 
     cuda_rmm = protocol == "cuda_rmm"
     protocol = "cuda" if protocol == "cuda_rmm" else protocol
@@ -91,10 +86,7 @@ def test_dask_serialization_roundtrip(arrow_tbl, protocol, context):
 
 
 def test_dask_serialization_error():
-    arrow_tbl = pa.table({"a": [1, 2, 3]})
-    plc_tbl = plc.Table.from_arrow(arrow_tbl)
-    dtypes = [DataType(pl_type) for pl_type in pl.from_arrow(arrow_tbl).dtypes]
-    df = DataFrame.from_table(plc_tbl, names=arrow_tbl.column_names, dtypes=dtypes)
+    df = DataFrame.from_polars(pl.DataFrame({"a": [1, 2, 3]}))
 
     header, frames = serialize(
         df,

python/cudf_polars/tests/experimental/test_dask_sizeof.py

@@ -3,34 +3,29 @@
 
 from __future__ import annotations
 
-import pyarrow as pa
 import pytest
 from dask.sizeof import sizeof
 
 import polars as pl
 
-import pylibcudf as plc
-
-from cudf_polars.containers import DataFrame, DataType
+from cudf_polars.containers import DataFrame
 from cudf_polars.experimental.dask_registers import register
 
 # Must register sizeof dispatch before running tests
 register()
 
 
 @pytest.mark.parametrize(
-    "arrow_tbl, size",
+    "polars_tbl, size",
     [
-        (pa.table([]), 0),
-        (pa.table({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]}), 9 * 8),
-        (pa.table({"a": [1, 2, 3]}), 3 * 8),
-        (pa.table({"a": ["a"], "b": ["bc"]}), 2 * 8 + 3),
-        (pa.table({"a": [1, 2, None]}), 88),
+        (pl.DataFrame(), 0),
+        (pl.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]}), 9 * 8),
+        (pl.DataFrame({"a": [1, 2, 3]}), 3 * 8),
+        (pl.DataFrame({"a": ["a"], "b": ["bc"]}), 2 * 8 + 3),
+        (pl.DataFrame({"a": [1, 2, None]}), 88),
     ],
 )
-def test_dask_sizeof(arrow_tbl, size):
-    plc_tbl = plc.Table.from_arrow(arrow_tbl)
-    dtypes = [DataType(pl_type) for pl_type in pl.from_arrow(arrow_tbl).dtypes]
-    df = DataFrame.from_table(plc_tbl, names=arrow_tbl.column_names, dtypes=dtypes)
+def test_dask_sizeof(polars_tbl, size):
+    df = DataFrame.from_polars(polars_tbl)
     assert sizeof(df) == size
     assert sum(sizeof(c) for c in df.columns) == size