Disallow constructing frames from a ColumnAccessor

python/cudf/cudf/core/dataframe.py

@@ -207,20 +207,7 @@ def __init__(self, data=None, index=None, columns=None, dtype=None):
         if isinstance(columns, (Series, cudf.Index)):
             columns = columns.to_pandas()
 
-        if isinstance(data, ColumnAccessor):
-            if index is None:
-                index = as_index(range(data.nrows))
-            else:
-                index = as_index(index)
-            self._index = index
-
-            if columns is not None:
-                self._data = data
-                self._reindex(columns=columns, deep=True, inplace=True)
-            else:
-                self._data = data
-
-        elif isinstance(data, (DataFrame, pd.DataFrame)):
+        if isinstance(data, (DataFrame, pd.DataFrame)):
             if isinstance(data, pd.DataFrame):
                 data = self.from_pandas(data)
 
@@ -250,7 +237,6 @@ def __init__(self, data=None, index=None, columns=None, dtype=None):
             else:
                 self._index = as_index(index)
             if columns is not None:
-
                 self._data = ColumnAccessor(
                     OrderedDict.fromkeys(
                         columns,
@@ -502,6 +488,17 @@ def _from_table(cls, table, index=None):
         out._index = index
         return out
 
+    @classmethod
+    def _from_data(cls, data, index=None, columns=None):
+        out = cls.__new__(cls)
+        out._data = data
+        if index is None:
+            index = cudf.Index(range(data.nrows))
+        out._index = index
+        if columns is not None:
+            out.columns = columns
+        return out
+
     @staticmethod
     def _align_input_series_indices(data, index):
         data = data.copy()
@@ -1332,12 +1329,14 @@ def _get_columns_by_label(self, labels, downcast=False):
             elif isinstance(labels, tuple):
                 nlevels = len(labels)
             if self._data.multiindex is False or nlevels == self._data.nlevels:
-                return self._constructor_sliced(
-                    new_data, name=labels, index=self.index
+                out = self._constructor_sliced()._from_data(
+                    new_data, index=self.index, name=labels
                 )
-        return self._constructor(
-            new_data, columns=new_data.to_pandas_index(), index=self.index
+                return out
+        out = self._constructor()._from_data(
+            new_data, index=self.index, columns=new_data.to_pandas_index()
         )
+        return out
 
     # unary, binary, rbinary, orderedcompare, unorderedcompare
     def _apply_op(self, fn, other=None, fill_value=None):
@@ -3036,21 +3035,6 @@ def take(self, positions, keep_index=True):
         out.columns = self.columns
         return out
 
-    @annotate("DATAFRAME_COPY", color="cyan", domain="cudf_python")
-    def copy(self, deep=True):
-        """
-        Returns a copy of this dataframe
-
-        Parameters
-        ----------
-        deep: bool
-           Make a full copy of Series columns and Index at the GPU level, or
-           create a new allocation with references.
-        """
-        out = DataFrame(data=self._data.copy(deep=deep))
-        out.index = self.index.copy(deep=deep)
-        return out
-
     def __copy__(self):
         return self.copy(deep=True)
 

python/cudf/cudf/core/frame.py

@@ -6,7 +6,7 @@
 import operator
 import warnings
 from collections import OrderedDict, abc as abc
-from typing import TYPE_CHECKING, Any, Dict, Tuple, overload
+from typing import TYPE_CHECKING, Any, Dict, Tuple, TypeVar, overload
 
 import cupy
 import numpy as np
@@ -27,6 +27,9 @@
     min_scalar_type,
 )
 
+
+T = TypeVar("T", bound="Frame")
+
 if TYPE_CHECKING:
     from cudf.core.column_accessor import ColumnAccessor
 
@@ -214,8 +217,89 @@ def empty(self):
     def __len__(self):
         return self._num_rows
 
-    def copy(self, deep=True):
-        return Frame(self._data.copy(deep=deep))
+    def copy(self: T, deep: bool = True) -> T:
+        """
+        Make a copy of this object's indices and data.
+
+        When ``deep=True`` (default), a new object will be created with a
+        copy of the calling object's data and indices. Modifications to
+        the data or indices of the copy will not be reflected in the
+        original object (see notes below).
+        When ``deep=False``, a new object will be created without copying
+        the calling object's data or index (only references to the data
+        and index are copied). Any changes to the data of the original
+        will be reflected in the shallow copy (and vice versa).
+
+        Parameters
+        ----------
+        deep : bool, default True
+            Make a deep copy, including a copy of the data and the indices.
+            With ``deep=False`` neither the indices nor the data are copied.
+
+        Returns
+        -------
+        copy : Series or DataFrame
+            Object type matches caller.
+        Examples
+        --------
+        >>> s = cudf.Series([1, 2], index=["a", "b"])
+        >>> s
+        a    1
+        b    2
+        dtype: int64
+        >>> s_copy = s.copy()
+        >>> s_copy
+        a    1
+        b    2
+        dtype: int64
+
+        **Shallow copy versus default (deep) copy:**
+
+        >>> s = cudf.Series([1, 2], index=["a", "b"])
+        >>> deep = s.copy()
+        >>> shallow = s.copy(deep=False)
+
+        Shallow copy shares data and index with original.
+
+        >>> s is shallow
+        False
+        >>> s._column is shallow._column and s.index is shallow.index
+        True
+
+        Deep copy has own copy of data and index.
+
+        >>> s is deep
+        False
+        >>> s.values is deep.values or s.index is deep.index
+        False
+
+        Updates to the data shared by shallow copy and original is reflected
+        in both; deep copy remains unchanged.
+
+        >>> s['a'] = 3
+        >>> shallow['b'] = 4
+        >>> s
+        a    3
+        b    4
+        dtype: int64
+        >>> shallow
+        a    3
+        b    4
+        dtype: int64
+        >>> deep
+        a    1
+        b    2
+        dtype: int64
+        """
+        new_frame = self.__class__.__new__(type(self))
+        new_frame._data = self._data.copy(deep=deep)
+
+        if self._index is not None:
+            new_frame._index = self._index.copy(deep=deep)
+        else:
+            new_frame._index = None
+
+        return new_frame
 
     @classmethod
     @annotate("CONCAT", color="orange", domain="cudf_python")

python/cudf/cudf/core/multiindex.py

@@ -289,7 +289,8 @@ def shape(self):
 
     @property
     def _source_data(self):
-        return cudf.DataFrame(self._data)
+        out = cudf.DataFrame._from_data(data=self._data)
+        return out
 
     @_source_data.setter
     def _source_data(self, value):
@@ -452,7 +453,7 @@ def __repr__(self):
             )
             preprocess = self.take(indices)
         else:
-            preprocess = self
+            preprocess = self.copy(deep=False)
 
         cols_nulls = [
             preprocess._source_data._data[col].has_nulls

python/cudf/cudf/core/reshape.py

@@ -831,10 +831,10 @@ def as_tuple(x):
                 )
             )._data
         )
-
-    return cudf.DataFrame(
+    out = cudf.DataFrame._from_data(
         result, index=cudf.Index(index_labels, name=index.name)
     )
+    return out
 
 
 def pivot(data, index=None, columns=None, values=None):

python/cudf/cudf/core/series.py

@@ -1,11 +1,12 @@
 # Copyright (c) 2018-2021, NVIDIA CORPORATION.
+from __future__ import annotations
 
 import pickle
 import warnings
 from collections import abc as abc
 from numbers import Number
 from shutil import get_terminal_size
-from typing import Any, Set
+from typing import Any, Optional, Set
 from uuid import uuid4
 
 import cupy
@@ -216,6 +217,23 @@ def _from_table(cls, table, index=None):
                 index = Index._from_table(table._index)
         return cls(data=data, index=index, name=name)
 
+    @classmethod
+    def _from_data(
+        cls,
+        data: ColumnAccessor,
+        index: Optional[Index] = None,
+        name: Any = None,
+    ) -> Series:
+        """
+        Construct the Series from a ColumnAccessor
+        """
+        out = cls.__new__(cls)
+        out._data = data
+        out._index = index if index is not None else RangeIndex(data.nrows)
+        if name is not None:
+            out.name = name
+        return out
+
     @property
     def _column(self):
         return self._data[self.name]
@@ -472,88 +490,6 @@ def to_arrow(self):
         """
         return self._column.to_arrow()
 
-    def copy(self, deep=True):
-        """
-        Make a copy of this object's indices and data.
-
-        When ``deep=True`` (default), a new object will be created with a
-        copy of the calling object's data and indices. Modifications to
-        the data or indices of the copy will not be reflected in the
-        original object (see notes below).
-        When ``deep=False``, a new object will be created without copying
-        the calling object's data or index (only references to the data
-        and index are copied). Any changes to the data of the original
-        will be reflected in the shallow copy (and vice versa).
-
-        Parameters
-        ----------
-        deep : bool, default True
-            Make a deep copy, including a copy of the data and the indices.
-            With ``deep=False`` neither the indices nor the data are copied.
-
-        Returns
-        -------
-        copy : Series or DataFrame
-            Object type matches caller.
-
-
-        Examples
-        --------
-        >>> s = cudf.Series([1, 2], index=["a", "b"])
-        >>> s
-        a    1
-        b    2
-        dtype: int64
-        >>> s_copy = s.copy()
-        >>> s_copy
-        a    1
-        b    2
-        dtype: int64
-
-        **Shallow copy versus default (deep) copy:**
-
-        >>> s = cudf.Series([1, 2], index=["a", "b"])
-        >>> deep = s.copy()
-        >>> shallow = s.copy(deep=False)
-
-        Shallow copy shares data and index with original.
-
-        >>> s is shallow
-        False
-        >>> s._column is shallow._column and s.index is shallow.index
-        True
-
-        Deep copy has own copy of data and index.
-
-        >>> s is deep
-        False
-        >>> s.values is deep.values or s.index is deep.index
-        False
-
-        Updates to the data shared by shallow copy and original is reflected
-        in both; deep copy remains unchanged.
-
-        >>> s['a'] = 3
-        >>> shallow['b'] = 4
-        >>> s
-        a    3
-        b    4
-        dtype: int64
-        >>> shallow
-        a    3
-        b    4
-        dtype: int64
-        >>> deep
-        a    1
-        b    2
-        dtype: int64
-        """
-        result = self._copy_construct()
-        if deep:
-            result._column = self._column.copy(deep=deep)
-            result.index = self.index.copy(deep=deep)
-        return result
-
     def __copy__(self, deep=True):
         return self.copy(deep)
 

python/cudf/cudf/tests/test_cuda_array_interface.py

@@ -208,3 +208,11 @@ def test_cuda_array_interface_pytorch():
 
     with pytest.raises(TypeError):
         cat_series.__cuda_array_interface__
+
+
+def test_cai_after_indexing():
+    df = cudf.DataFrame({"a": [1, 2, 3]})
+    cai1 = df["a"].__cuda_array_interface__
+    df[["a"]]
+    cai2 = df["a"].__cuda_array_interface__
+    assert cai1 == cai2

python/cudf/cudf/tests/test_dataframe.py

@@ -8057,15 +8057,6 @@ def assert_local_eq(actual, df, expected, host_columns):
 
     assert_local_eq(actual, df, expected, host_columns)
 
-    expected = pd.DataFrame(df, columns=host_columns)
-    actual = gd.DataFrame(gdf._data, columns=columns, index=index)
-    if index is not None:
-        if df.shape == (0, 0):
-            expected = pd.DataFrame(columns=host_columns, index=index)
-        else:
-            expected.index = index
-    assert_local_eq(actual, df, expected, host_columns)
-
 
 @pytest.mark.parametrize(
     "data",