Start working through circular import errors

python/cudf/cudf/core/_base_index.py

@@ -2032,10 +2032,13 @@ def dropna(self, how="any"):
         data_columns = [col.nans_to_nulls() for col in self._columns]
 
         return self._from_columns_like_self(
-            drop_nulls(
-                data_columns,
-                how=how,
-            ),
+            [
+                ColumnBase.from_pylibcudf(col)
+                for col in drop_nulls(
+                    data_columns,
+                    how=how,
+                )
+            ],
             self._column_names,
         )
 
@@ -2103,7 +2106,12 @@ def _apply_boolean_mask(self, boolean_mask):
             raise ValueError("boolean_mask is not boolean type.")
 
         return self._from_columns_like_self(
-            apply_boolean_mask(list(self._columns), boolean_mask),
+            [
+                ColumnBase.from_pylibcudf(col)
+                for col in apply_boolean_mask(
+                    list(self._columns), boolean_mask
+                )
+            ],
             column_names=self._column_names,
         )
 

python/cudf/cudf/core/_internals/copying.py

@@ -6,12 +6,14 @@
 import pylibcudf as plc
 
 from cudf.core.buffer import acquire_spill_lock
-from cudf.core.column import ColumnBase
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
 
     from cudf import Scalar
+
+    # ruff does not identify that there's a relative import in use
+    from cudf.core.column import ColumnBase  # noqa: TC004
     from cudf.core.column.numerical import NumericalColumn
 
 
@@ -20,15 +22,15 @@ def gather(
     columns: Iterable[ColumnBase],
     gather_map: NumericalColumn,
     nullify: bool = False,
-) -> list[ColumnBase]:
+) -> list[plc.Column]:
     plc_tbl = plc.copying.gather(
         plc.Table([col.to_pylibcudf(mode="read") for col in columns]),
         gather_map.to_pylibcudf(mode="read"),
         plc.copying.OutOfBoundsPolicy.NULLIFY
         if nullify
         else plc.copying.OutOfBoundsPolicy.DONT_CHECK,
     )
-    return [ColumnBase.from_pylibcudf(col) for col in plc_tbl.columns()]
+    return plc_tbl.columns()
 
 
 @acquire_spill_lock()
@@ -69,13 +71,13 @@ def scatter(
         plc.Table([col.to_pylibcudf(mode="read") for col in target_columns]),
     )
 
-    return [ColumnBase.from_pylibcudf(col) for col in plc_tbl.columns()]
+    return plc_tbl.columns()
 
 
 @acquire_spill_lock()
 def columns_split(
     input_columns: Iterable[ColumnBase], splits: list[int]
-) -> list[list[ColumnBase]]:
+) -> list[list[plc.Column]]:
     return [
         [ColumnBase.from_pylibcudf(col) for col in plc_tbl.columns()]
         for plc_tbl in plc.copying.split(

python/cudf/cudf/core/_internals/sorting.py

@@ -7,11 +7,12 @@
 import pylibcudf as plc
 
 from cudf.core.buffer import acquire_spill_lock
-from cudf.core.column import ColumnBase
 
 if TYPE_CHECKING:
     from collections.abc import Iterable
 
+    from cudf.core.column import ColumnBase
+
 
 @acquire_spill_lock()
 def is_sorted(
@@ -118,7 +119,7 @@ def order_by(
     na_position: Literal["first", "last"],
     *,
     stable: bool,
-):
+) -> plc.Column:
     """
     Get index to sort the table in ascending/descending order.
 
@@ -144,14 +145,12 @@ def order_by(
     func = (
         plc.sorting.stable_sorted_order if stable else plc.sorting.sorted_order
     )
-    return ColumnBase.from_pylibcudf(
-        func(
-            plc.Table(
-                [col.to_pylibcudf(mode="read") for col in columns_from_table],
-            ),
-            order[0],
-            order[1],
-        )
+    return func(
+        plc.Table(
+            [col.to_pylibcudf(mode="read") for col in columns_from_table],
+        ),
+        order[0],
+        order[1],
     )
 
 
@@ -163,7 +162,7 @@ def sort_by_key(
     na_position: list[Literal["first", "last"]],
     *,
     stable: bool,
-) -> list[ColumnBase]:
+) -> list[plc.Column]:
     """
     Sort a table by given keys
 
@@ -192,12 +191,9 @@ def sort_by_key(
     func = (
         plc.sorting.stable_sort_by_key if stable else plc.sorting.sort_by_key
     )
-    return [
-        ColumnBase.from_pylibcudf(col)
-        for col in func(
-            plc.Table([col.to_pylibcudf(mode="read") for col in values]),
-            plc.Table([col.to_pylibcudf(mode="read") for col in keys]),
-            order[0],
-            order[1],
-        ).columns()
-    ]
+    return func(
+        plc.Table([col.to_pylibcudf(mode="read") for col in values]),
+        plc.Table([col.to_pylibcudf(mode="read") for col in keys]),
+        order[0],
+        order[1],
+    ).columns()

python/cudf/cudf/core/_internals/stream_compaction.py

@@ -1,12 +1,14 @@
 # Copyright (c) 2020-2025, NVIDIA CORPORATION.
 from __future__ import annotations
 
-from typing import Literal
+from typing import TYPE_CHECKING, Literal
 
 import pylibcudf as plc
 
 from cudf.core.buffer import acquire_spill_lock
-from cudf.core.column import ColumnBase
+
+if TYPE_CHECKING:
+    from cudf.core.column import ColumnBase
 
 
 @acquire_spill_lock()
@@ -15,7 +17,7 @@ def drop_nulls(
     how: Literal["any", "all"] = "any",
     keys: list[int] | None = None,
     thresh: int | None = None,
-) -> list[ColumnBase]:
+) -> list[plc.Column]:
     """
     Drops null rows from cols depending on key columns.
 
@@ -50,13 +52,13 @@ def drop_nulls(
         keys,
         keep_threshold,
     )
-    return [ColumnBase.from_pylibcudf(col) for col in plc_table.columns()]
+    return plc_table.columns()
 
 
 @acquire_spill_lock()
 def apply_boolean_mask(
     columns: list[ColumnBase], boolean_mask: ColumnBase
-) -> list[ColumnBase]:
+) -> list[plc.Column]:
     """
     Drops the rows which correspond to False in boolean_mask.
 
@@ -73,7 +75,7 @@ def apply_boolean_mask(
         plc.Table([col.to_pylibcudf(mode="read") for col in columns]),
         boolean_mask.to_pylibcudf(mode="read"),
     )
-    return [ColumnBase.from_pylibcudf(col) for col in plc_table.columns()]
+    return plc_table.columns()
 
 
 @acquire_spill_lock()
@@ -82,7 +84,7 @@ def drop_duplicates(
     keys: list[int] | None = None,
     keep: Literal["first", "last", False] = "first",
     nulls_are_equal: bool = True,
-) -> list[ColumnBase]:
+) -> list[plc.Column]:
     """
     Drops rows in source_table as per duplicate rows in keys.
 
@@ -115,4 +117,4 @@ def drop_duplicates(
         else plc.types.NullEquality.UNEQUAL,
         plc.types.NanEquality.ALL_EQUAL,
     )
-    return [ColumnBase.from_pylibcudf(col) for col in plc_table.columns()]
+    return plc_table.columns()

python/cudf/cudf/core/column/column.py

@@ -719,7 +719,9 @@ def any(self, skipna: bool = True) -> bool:
 
     def dropna(self) -> Self:
         if self.has_nulls():
-            return drop_nulls([self])[0]._with_type_metadata(self.dtype)  # type: ignore[return-value]
+            return ColumnBase.from_pylibcudf(
+                drop_nulls([self])[0]
+            )._with_type_metadata(self.dtype)  # type: ignore[return-value]
         else:
             return self.copy()
 
@@ -1300,9 +1302,9 @@ def indices_of(
         else:
             value = as_column(value, dtype=self.dtype, length=1)
         mask = value.contains(self)
-        return apply_boolean_mask(  # type: ignore[return-value]
-            [as_column(range(0, len(self)), dtype=SIZE_TYPE_DTYPE)], mask
-        )[0]
+        return as_column(
+            range(len(self)), dtype=SIZE_TYPE_DTYPE
+        ).apply_boolean_mask(mask)  # type: ignore[return-value]
 
     def _find_first_and_last(self, value: ScalarLike) -> tuple[int, int]:
         indices = self.indices_of(value)
@@ -1682,9 +1684,9 @@ def apply_boolean_mask(self, mask) -> ColumnBase:
         if mask.dtype.kind != "b":
             raise ValueError("boolean_mask is not boolean type.")
 
-        return apply_boolean_mask([self], mask)[0]._with_type_metadata(
-            self.dtype
-        )
+        return ColumnBase.from_pylibcudf(
+            apply_boolean_mask([self], mask)[0]
+        )._with_type_metadata(self.dtype)
 
     def argsort(
         self,
@@ -1705,8 +1707,8 @@ def argsort(
                 as_column(range(len(self) - 1, -1, -1)),
             )
         else:
-            return sorting.order_by(
-                [self], [ascending], na_position, stable=True
+            return ColumnBase.from_pylibcudf(  # type: ignore[return-value]
+                sorting.order_by([self], [ascending], na_position, stable=True)
             )
 
     def __arrow_array__(self, type=None):
@@ -1772,9 +1774,11 @@ def unique(self) -> Self:
         if self.is_unique:
             return self.copy()
         else:
-            return drop_duplicates([self], keep="first")[  # type: ignore[return-value]
-                0
-            ]._with_type_metadata(self.dtype)
+            return ColumnBase.from_pylibcudf(
+                drop_duplicates([self], keep="first")[  # type: ignore[return-value]
+                    0
+                ]
+            )._with_type_metadata(self.dtype)
 
     def serialize(self) -> tuple[dict, list]:
         # data model:
@@ -2010,10 +2014,10 @@ def _return_sentinel_column():
         del right_rows
         # reorder `codes` so that its values correspond to the
         # values of `self`:
-        (codes,) = sorting.sort_by_key(
+        plc_codes = sorting.sort_by_key(
             [codes], [left_gather_map], [True], ["last"], stable=True
-        )
-        return codes.fillna(na_sentinel.value)
+        )[0]
+        return ColumnBase.from_pylibcudf(plc_codes).fillna(na_sentinel.value)
 
     @acquire_spill_lock()
     def copy_if_else(

python/cudf/cudf/core/column/numerical_base.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2018-2024, NVIDIA CORPORATION.
+# Copyright (c) 2018-2025, NVIDIA CORPORATION.
 """Define an interface for columns that can perform numerical operations."""
 
 from __future__ import annotations
@@ -10,7 +10,6 @@
 import pylibcudf as plc
 
 import cudf
-from cudf.core._internals import sorting
 from cudf.core.buffer import Buffer, acquire_spill_lock
 from cudf.core.column.column import ColumnBase
 from cudf.core.missing import NA
@@ -145,8 +144,8 @@ def quantile(
         else:
             no_nans = self.nans_to_nulls()
             # get sorted indices and exclude nulls
-            indices = sorting.order_by(
-                [no_nans], [True], "first", stable=True
+            indices = no_nans.argsort(
+                ascending=True, na_position="first"
             ).slice(no_nans.null_count, len(no_nans))
             with acquire_spill_lock():
                 plc_column = plc.quantiles.quantile(