Removal IntervalDtype/StructDtype inheritance (#21114)

Authors:
  - Vyas Ramasubramani (https://github.com/vyasr)

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

URL: #21114

Author: vyasr

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

@@ -2646,9 +2646,9 @@ def column_empty(
     dtype : Dtype
         Type of the column.
     """
-    if (is_struct := isinstance(dtype, StructDtype)) or isinstance(
-        dtype, ListDtype
-    ):
+    if (
+        is_struct := isinstance(dtype, (StructDtype, IntervalDtype))
+    ) or isinstance(dtype, ListDtype):
         if is_struct:
             children = tuple(
                 column_empty(row_count, field_dtype)
@@ -2844,7 +2844,15 @@ def as_column(
                 dtype=dtype,
                 length=length,
             )
-            if (
+            if isinstance(arbitrary.dtype, pd.IntervalDtype):
+                # Wrap StructColumn as IntervalColumn with proper metadata
+                result = result._with_type_metadata(
+                    IntervalDtype(
+                        subtype=arbitrary.dtype.subtype,
+                        closed=arbitrary.dtype.closed,
+                    )
+                )
+            elif (
                 cudf.get_option("mode.pandas_compatible")
                 and isinstance(arbitrary.dtype, pd.CategoricalDtype)
                 and is_pandas_nullable_extension_dtype(
@@ -3266,12 +3274,14 @@ def as_column(
                     length=length,
                 )
             elif (
-                isinstance(element, (pd.Timestamp, pd.Timedelta))
+                isinstance(element, (pd.Timestamp, pd.Timedelta, pd.Interval))
                 or element is pd.NaT
             ):
                 # TODO: Remove this after
                 # https://github.com/apache/arrow/issues/26492
                 # is fixed.
+                # Note: pd.Interval also requires pandas Series conversion
+                # because PyArrow cannot infer interval type from raw list
                 return as_column(
                     pd.Series(arbitrary),
                     dtype=dtype,

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

@@ -7,21 +7,25 @@
 
 import pandas as pd
 import pyarrow as pa
+from pandas.core.arrays.arrow.extension_types import ArrowIntervalType
 from typing_extensions import Self
 
 import pylibcudf as plc
 
 import cudf
 from cudf.core.column.column import ColumnBase, _handle_nulls, as_column
-from cudf.core.column.struct import StructColumn
 from cudf.core.dtypes import IntervalDtype, _dtype_to_metadata
 from cudf.utils.dtypes import is_dtype_obj_interval
+from cudf.utils.scalar import maybe_nested_pa_scalar_to_py
 
 if TYPE_CHECKING:
     from cudf._typing import DtypeObj
+    from cudf.core.buffer import Buffer
 
 
-class IntervalColumn(StructColumn):
+class IntervalColumn(ColumnBase):
+    _VALID_PLC_TYPES = {plc.TypeId.STRUCT}
+
     @classmethod
     def _validate_args(  # type: ignore[override]
         cls, plc_column: plc.Column, dtype: IntervalDtype
@@ -48,6 +52,39 @@ def _validate_args(  # type: ignore[override]
             raise ValueError("dtype must be a IntervalDtype.")
         return plc_column, dtype
 
+    def _with_type_metadata(self, dtype: DtypeObj) -> ColumnBase:
+        """
+        Apply IntervalDtype metadata to this column.
+
+        Creates new children with the subtype metadata applied and
+        reconstructs the plc.Column.
+        """
+        if isinstance(dtype, IntervalDtype):
+            new_children = tuple(
+                ColumnBase.from_pylibcudf(child).astype(dtype.subtype)
+                for child in self.plc_column.children()
+            )
+            new_plc_column = plc.Column(
+                plc.DataType(plc.TypeId.STRUCT),
+                self.plc_column.size(),
+                self.plc_column.data(),
+                self.plc_column.null_mask(),
+                self.plc_column.null_count(),
+                self.plc_column.offset(),
+                [child.plc_column for child in new_children],
+            )
+            return type(self)._from_preprocessed(
+                plc_column=new_plc_column,
+                dtype=dtype,
+            )
+        # For pandas dtypes, store them directly in the column's dtype property
+        elif isinstance(dtype, pd.ArrowDtype) and isinstance(
+            dtype.pyarrow_dtype, ArrowIntervalType
+        ):
+            self._dtype = dtype
+
+        return self
+
     @classmethod
     def from_arrow(cls, array: pa.Array | pa.ChunkedArray) -> Self:
         if not isinstance(array, pa.ExtensionArray):
@@ -76,6 +113,36 @@ def to_arrow(self) -> pa.Array:
             struct_arrow = pa.array([], typ.storage_type)
         return pa.ExtensionArray.from_storage(typ, struct_arrow)
 
+    @classmethod
+    def _deserialize_plc_column(
+        cls,
+        header: dict,
+        dtype: DtypeObj,
+        data: Buffer | None,
+        mask: Buffer | None,
+        children: list[plc.Column],
+    ) -> plc.Column:
+        """Construct plc.Column using STRUCT type for interval columns."""
+        offset = header.get("offset", 0)
+        if mask is None:
+            null_count = 0
+        else:
+            null_count = plc.null_mask.null_count(
+                mask, offset, header["size"] + offset
+            )
+
+        plc_type = plc.DataType(plc.TypeId.STRUCT)
+        return plc.Column(
+            plc_type,
+            header["size"],
+            data,
+            mask,
+            null_count,
+            offset,
+            children,
+            validate=False,
+        )
+
     def copy(self, deep: bool = True) -> Self:
         return super().copy(deep=deep)._with_type_metadata(self.dtype)  # type: ignore[return-value]
 
@@ -134,6 +201,12 @@ def right(self) -> ColumnBase:
             self.plc_column.children()[1]
         )._with_type_metadata(self.dtype.subtype)  # type: ignore[union-attr]
 
+    @property
+    def __cuda_array_interface__(self) -> dict[str, Any]:
+        raise NotImplementedError(
+            "Intervals are not yet supported via `__cuda_array_interface__`"
+        )
+
     def overlaps(other) -> ColumnBase:
         raise NotImplementedError("overlaps is not currently implemented.")
 
@@ -176,6 +249,9 @@ def element_indexing(
         self, index: int
     ) -> pd.Interval | dict[Any, Any] | None:
         result = super().element_indexing(index)
+        if isinstance(result, pa.Scalar):
+            py_element = maybe_nested_pa_scalar_to_py(result)
+            result = self.dtype._recursively_replace_fields(py_element)  # type: ignore[union-attr]
         if isinstance(result, dict) and cudf.get_option(
             "mode.pandas_compatible"
         ):

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

@@ -53,17 +53,14 @@ def _validate_args(  # type: ignore[override]
         cls, plc_column: plc.Column, dtype: StructDtype
     ) -> tuple[plc.Column, StructDtype]:
         plc_column, dtype = super()._validate_args(plc_column, dtype)  # type: ignore[assignment]
-        # IntervalDtype is a subclass of StructDtype, so compare types exactly
         if (
             not cudf.get_option("mode.pandas_compatible")
-            and type(dtype) is not StructDtype
+            and not isinstance(dtype, StructDtype)
         ) or (
             cudf.get_option("mode.pandas_compatible")
             and not is_dtype_obj_struct(dtype)
         ):
-            raise ValueError(
-                f"{type(dtype).__name__} must be a StructDtype exactly."
-            )
+            raise ValueError(f"{type(dtype).__name__} must be a StructDtype.")
         return plc_column, dtype
 
     def _get_sliced_child(self, idx: int) -> ColumnBase:
@@ -148,18 +145,38 @@ def __cuda_array_interface__(self) -> Mapping[str, Any]:
             "Structs are not yet supported via `__cuda_array_interface__`"
         )
 
-    def _with_type_metadata(
-        self: StructColumn, dtype: DtypeObj
-    ) -> StructColumn:
-        from cudf.core.column import IntervalColumn
+    def _with_type_metadata(self: StructColumn, dtype: DtypeObj) -> ColumnBase:
         from cudf.core.dtypes import IntervalDtype
 
         # Check IntervalDtype first because it's a subclass of StructDtype
         if isinstance(dtype, IntervalDtype):
-            # TODO: Rewrite this to avoid needing to round-trip via ColumnBase
+            # Dispatch to IntervalColumn when given IntervalDtype
+            from cudf.core.column.interval import IntervalColumn
+
+            # Determine the current subtype from the first child
+            first_child = ColumnBase.from_pylibcudf(
+                self.plc_column.children()[0]
+            )
+            current_dtype = IntervalDtype(
+                subtype=first_child.dtype, closed=dtype.closed
+            )
+
+            # Convert to IntervalColumn and apply target metadata
+            interval_col = IntervalColumn._from_preprocessed(
+                plc_column=self.plc_column,
+                dtype=current_dtype,
+            )
+            return interval_col._with_type_metadata(dtype)
+        elif isinstance(dtype, StructDtype):
             new_children = tuple(
-                ColumnBase.from_pylibcudf(child).astype(dtype.subtype)
-                for child in self.plc_column.children()
+                ColumnBase.from_pylibcudf(child)._with_type_metadata(
+                    dtype.fields[f]
+                )
+                for child, f in zip(
+                    self.plc_column.children(),
+                    dtype.fields.keys(),
+                    strict=True,
+                )
             )
             new_plc_column = plc.Column(
                 plc.DataType(plc.TypeId.STRUCT),
@@ -170,12 +187,10 @@ def _with_type_metadata(
                 self.plc_column.offset(),
                 [child.plc_column for child in new_children],
             )
-            return IntervalColumn._from_preprocessed(
+            return StructColumn._from_preprocessed(
                 plc_column=new_plc_column,
                 dtype=dtype,
             )
-        elif isinstance(dtype, StructDtype):
-            self._dtype = dtype
         # For pandas dtypes, store them directly in the column's dtype property
         elif isinstance(dtype, pd.ArrowDtype) and isinstance(
             dtype.pyarrow_dtype, pa.StructType