Various internal MultiIndex improvements

python/cudf/cudf/core/_base_index.py

@@ -44,6 +44,11 @@ def _values(self) -> ColumnBase:
     def copy(self, deep: bool = True) -> BaseIndex:
         raise NotImplementedError
 
+    @property
+    def size(self):
+        # The size of an index is always its length irrespective of dimension.
+        return len(self)
+
     @property
     def values(self):
         return self._values.values
@@ -162,6 +167,38 @@ def _clean_nulls_from_index(self):
         else:
             return self
 
+    @property
+    def is_monotonic(self):
+        """Return boolean if values in the object are monotonic_increasing.
+
+        This property is an alias for :attr:`is_monotonic_increasing`.
+
+        Returns
+        -------
+        bool
+        """
+        return self.is_monotonic_increasing
+
+    @property
+    def is_monotonic_increasing(self):
+        """Return boolean if values in the object are monotonically increasing.
+
+        Returns
+        -------
+        bool
+        """
+        raise NotImplementedError
+
+    @property
+    def is_monotonic_decreasing(self):
+        """Return boolean if values in the object are monotonically decreasing.
+
+        Returns
+        -------
+        bool
+        """
+        raise NotImplementedError
+
     @property
     def nlevels(self):
         """

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

@@ -352,7 +352,9 @@ def cat(self, others=None, sep=None, na_rep=None):
 
         if len(data) == 1 and data.null_count == 1:
             data = [""]
-        out = self._return_or_inplace(data)
+        # We only want to keep the index if we are adding something to each
+        # row, not if we are joining all the rows into a single string.
+        out = self._return_or_inplace(data, retain_index=others is not None)
         if len(out) == 1 and others is None:
             if isinstance(out, cudf.Series):
                 out = out.iloc[0]

python/cudf/cudf/core/dataframe.py

@@ -594,12 +594,6 @@ def dtypes(self):
             data=[x.dtype for x in self._data.columns], index=self._data.names,
         )
 
-    @property
-    def shape(self):
-        """Returns a tuple representing the dimensionality of the DataFrame.
-        """
-        return self._num_rows, self._num_columns
-
     @property
     def ndim(self):
         """Dimension of the data. DataFrame ndim is always 2.
@@ -938,12 +932,6 @@ def memory_usage(self, index=True, deep=False):
             sizes.append(self.index.memory_usage(deep=deep))
         return Series(sizes, index=ind)
 
-    def __len__(self):
-        """
-        Returns the number of rows
-        """
-        return len(self.index)
-
     def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
         import cudf
 

python/cudf/cudf/core/frame.py

@@ -166,6 +166,11 @@ def size(self):
         """
         return self._num_columns * self._num_rows
 
+    @property
+    def shape(self):
+        """Returns a tuple representing the dimensionality of the DataFrame."""
+        return self._num_rows, self._num_columns
+
     @property
     def _is_homogeneous(self):
         # make sure that the dataframe has columns
@@ -4458,6 +4463,12 @@ def to_string(self):
     def __str__(self):
         return self.to_string()
 
+    def __deepcopy__(self, memo):
+        return self.copy(deep=True)
+
+    def __copy__(self):
+        return self.copy(deep=False)
+
     def head(self, n=5):
         """
         Return the first `n` rows.
@@ -4726,9 +4737,6 @@ def __iter__(self):
         """
         cudf.utils.utils.raise_iteration_error(obj=self)
 
-    def __len__(self):
-        return len(self._column)
-
     def __bool__(self):
         raise TypeError(
             f"The truth value of a {type(self)} is ambiguous. Use "
@@ -4916,7 +4924,7 @@ def is_unique(self):
 
     @property
     def is_monotonic(self):
-        """Return boolean if values in the object are monotonic_increasing.
+        """Return boolean if values in the object are monotonically increasing.
 
         This property is an alias for :attr:`is_monotonic_increasing`.
 
@@ -4928,7 +4936,7 @@ def is_monotonic(self):
 
     @property
     def is_monotonic_increasing(self):
-        """Return boolean if values in the object are monotonic_increasing.
+        """Return boolean if values in the object are monotonically increasing.
 
         Returns
         -------
@@ -4938,7 +4946,7 @@ def is_monotonic_increasing(self):
 
     @property
     def is_monotonic_decreasing(self):
-        """Return boolean if values in the object are monotonic_decreasing.
+        """Return boolean if values in the object are monotonically decreasing.
 
         Returns
         -------

python/cudf/cudf/core/index.py

@@ -349,17 +349,6 @@ def dtype(self):
         """
         return cudf.dtype(np.int64)
 
-    @property
-    def is_contiguous(self):
-        """
-        Returns if the index is contiguous.
-        """
-        return self._step == 1
-
-    @property
-    def size(self):
-        return len(self)
-
     def find_label_range(self, first=None, last=None):
         """Find subrange in the ``RangeIndex``, marked by their positions, that
         starts greater or equal to ``first`` and ends less or equal to ``last``
@@ -417,18 +406,10 @@ def is_unique(self):
 
     @property
     def is_monotonic_increasing(self):
-        """
-        Return if the index is monotonic increasing
-        (only equal or increasing) values.
-        """
         return self._step > 0 or len(self) <= 1
 
     @property
     def is_monotonic_decreasing(self):
-        """
-        Return if the index is monotonic decreasing
-        (only equal or decreasing) values.
-        """
         return self._step < 0 or len(self) <= 1
 
     def get_slice_bound(self, label, side, kind=None):