[REVIEW] Fix find_common_dtype and values to handle complex dtypes

python/cudf/cudf/core/frame.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2022, NVIDIA CORPORATION.
+# Copyright (c) 2020-2023, NVIDIA CORPORATION.
 
 from __future__ import annotations
 
@@ -484,9 +484,21 @@ def get_column_values_na(col):
             )
 
         if dtype is None:
-            dtype = find_common_type(
-                [col.dtype for col in self._data.values()]
-            )
+            dtypes = [col.dtype for col in self._data.values()]
+            for dtype in dtypes:
+                if isinstance(
+                    dtype,
+                    (
+                        cudf.ListDtype,
+                        cudf.core.dtypes.DecimalDtype,
+                        cudf.StructDtype,
+                    ),
+                ):
+                    raise NotImplementedError(
+                        f"{dtype} are not yet supported via "
+                        "`__cuda_array_interface__`"
+                    )
+            dtype = find_common_type(dtypes)
 
         matrix = make_empty_matrix(
             shape=(len(self), ncol), dtype=dtype, order="F"

python/cudf/cudf/tests/test_concat.py

@@ -1869,3 +1869,17 @@ def test_concat_invalid_axis(axis):
     s = gd.Series([1, 2, 3])
     with pytest.raises(ValueError):
         gd.concat([s], axis=axis)
+
+
+@pytest.mark.parametrize(
+    "s1,s2,expected",
+    [
+        ([1, 2], [[1, 2], [3, 4]], ["1", "2", "[1, 2]", "[3, 4]"]),
+    ],
+)
+def test_concat_mixed_list_types(s1, s2, expected):
+    s1, s2 = gd.Series(s1), gd.Series(s2)
+    expected = pd.Series(expected)
+    actual = gd.concat([s1, s2], ignore_index=True)
+
+    assert_eq(expected, actual, check_dtype=False)

python/cudf/cudf/tests/test_dataframe.py

@@ -10013,3 +10013,17 @@ def test_dataframe_transpose_complex_types(data):
     actual = gdf.T
 
     assert_eq(expected, actual)
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        {"col": [{"a": 1.1}, {"a": 2.1}, {"a": 10.0}, {"a": 11.2323}, None]},
+        {"a": [[{"b": 567}], None] * 10},
+        {"a": [decimal.Decimal(10), decimal.Decimal(20), None]},
+    ],
+)
+def test_dataframe_values_complex_types(data):
+    gdf = cudf.DataFrame(data)
+    with pytest.raises(NotImplementedError):
+        gdf.values

python/cudf/cudf/utils/dtypes.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2022, NVIDIA CORPORATION.
+# Copyright (c) 2020-2023, NVIDIA CORPORATION.
 
 import datetime
 from collections import namedtuple
@@ -572,6 +572,24 @@ def find_common_type(dtypes):
             )
         else:
             return cudf.dtype("O")
+    if any(cudf.api.types.is_list_dtype(dtype) for dtype in dtypes):
+        if len(dtypes) == 1:
+            return dtypes.get(0)
+        else:
+            # TODO: As list dtypes allow casting
+            # to identical types, improve this logic of returning a
+            # common dtype, for example:
+            # ListDtype(int64) & ListDtype(int32) common
+            # dtype could be ListDtype(int64).
+            return cudf.dtype("O")
+    if any(cudf.api.types.is_struct_dtype(dtype) for dtype in dtypes):
+        if len(dtypes) == 1:
+            return dtypes.get(0)
+        else:
+            raise NotImplementedError(
+                "Finding a common type for `StructDtype` is currently "
+                "not supported"
+            )
 
     # Corner case 1:
     # Resort to np.result_type to handle "M" and "m" types separately