Add standard data ingestion pipelines to pylibcudf for ndarrays

python/pylibcudf/pylibcudf/column.pyi

@@ -35,8 +35,10 @@ class Column:
     def from_scalar(scalar: Scalar, size: int) -> Column: ...
     @staticmethod
     def all_null_like(like: Column, size: int) -> Column: ...
-    @staticmethod
-    def from_cuda_array_interface_obj(obj: Any) -> Column: ...
+    @classmethod
+    def from_cuda_array_interface_obj(cls, obj: Any) -> Column: ...
+    @classmethod
+    def from_any(cls, obj: Any) -> Column: ...
 
 class ListColumnView:
     def __init__(self, column: Column): ...

python/pylibcudf/pylibcudf/column.pyx

@@ -15,7 +15,22 @@ from .scalar cimport Scalar
 from .types cimport DataType, size_of, type_id
 from .utils cimport int_to_bitmask_ptr, int_to_void_ptr
 
-import functools
+from functools import cache, singledispatchmethod
+
+
+try:
+    import numpy as np
+    np_error = None
+except ImportError as err:
+    np = None
+    np_error = err
+
+try:
+    import cupy as cp
+    cp_error = None
+except ImportError as err:
+    cp = None
+    cp_error = err
 
 __all__ = ["Column", "ListColumnView", "is_c_contiguous"]
 
@@ -275,8 +290,8 @@ cdef class Column:
             c_result = make_column_from_scalar(dereference(slr.get()), size)
         return Column.from_libcudf(move(c_result))
 
-    @staticmethod
-    def from_cuda_array_interface_obj(object obj):
+    @classmethod
+    def from_cuda_array_interface_obj(cls, object obj):
         """Create a Column from an object with a CUDA array interface.
 
         Parameters
@@ -310,8 +325,10 @@ cdef class Column:
         ):
             raise ValueError("Data must be C-contiguous")
 
+        if len(iface['shape']) > 1:
+            raise ValueError("Data must be 1-dimensional")
         size = iface['shape'][0]
-        return Column(
+        return cls(
             data_type,
             size,
             data,
@@ -321,6 +338,106 @@ cdef class Column:
             []
         )
 
+    @singledispatchmethod
+    @classmethod
+    def from_ndarray(cls, obj):
+        """
+        Create a Column from any object which supports the NumPy array interface.
+
+        Parameters
+        ----------
+        obj : Any
+            The input array to be converted into a `pylibcudf.Column`.
+
+        Returns
+        -------
+        Column
+
+        Raises
+        ------
+        TypeError
+            If the input type is neither `numpy.ndarray` nor `cupy.ndarray`.
+        ImportError
+            If NumPy or CuPy is required but not installed.
+
+        Notes
+        -----
+        - If `obj` is a 2D CuPy array, the resulting column is a list column.
+        - NumPy conversion logic is not yet implemented.
+        - Multi-dimensional arrays (ndim > 2) are not supported.
+        """
+        if np_error is not None:
+            raise np_error
+        if cp_error is not None:
+            raise cp_error
+        raise TypeError(f"Cannot convert a {type(obj)} to a pylibcudf Column")
+
+    if np is not None:
+        @classmethod
+        def from_numpy_array(cls, object obj):
+            # TODO: Should expand to support __array_interface__
+            raise NotImplementedError(
+                "Converting to a pylibcudf Column from "
+                "a numpy object is not yet implemented."
+            )
+
+        @from_ndarray.register(np.ndarray)
+        @classmethod
+        def _(cls, obj):
+            return cls.from_numpy_array(obj)
+
+    if cp is not None:
+        @classmethod
+        def _from_2d_cupy_array(cls, object arr):
+            """Convert a 2D CuPy array to a Column."""
+            flat_data = arr.ravel()
+
+            num_rows, num_cols = arr.shape
+            offsets = cp.arange(0, (num_rows + 1) * num_cols, num_cols, dtype=cp.int32)
+
+            data_view = gpumemoryview(flat_data)
+            offsets_view = gpumemoryview(offsets)
+            typestr = arr.__cuda_array_interface__['typestr'][1:]
+
+            data_col = cls(
+                data_type=_datatype_from_dtype_desc(typestr),
+                size=flat_data.size,
+                data=data_view,
+                mask=None,
+                null_count=0,
+                offset=0,
+                children=[],
+            )
+            offsets_col = cls(
+                data_type=DataType(type_id.INT32),
+                size=num_rows + 1,
+                data=offsets_view,
+                mask=None,
+                null_count=0,
+                offset=0,
+                children=[],
+            )
+            return cls(
+                data_type=DataType(type_id.LIST),
+                size=num_rows,
+                data=None,
+                mask=None,
+                null_count=0,
+                offset=0,
+                children=[offsets_col, data_col],
+            )
+
+        @from_ndarray.register(cp.ndarray)
+        @classmethod
+        def _(cls, obj):
+            ndim = len(obj.shape)
+            if ndim == 1:
+                return cls.from_cuda_array_interface_obj(obj)
+            elif ndim == 2:
+                return cls._from_2d_cupy_array(obj)
+            else:
+                raise ValueError("Must pass a 1D or 2D CuPy array only")
+
     cpdef DataType type(self):
         """The type of data in the column."""
         return self._data_type
@@ -407,7 +524,7 @@ cdef class ListColumnView:
         return lists_column_view(self._column.view())
 
 
-@functools.cache
+@cache
 def _datatype_from_dtype_desc(desc):
     mapping = {
         'u1': type_id.UINT8,