[REVIEW] Create agg() function for dataframes

python/cudf/cudf/core/dataframe.py

@@ -3722,6 +3722,49 @@ def sort_values(
             keep_index=not ignore_index,
         )
 
+    def agg(self, aggs):
+        dtypes = [self[col].dtype for col in self._column_names]
+        common_dtype = np.find_common_type(dtypes, [])
+        df_normalized = self.astype(common_dtype)
+
+        if isinstance(aggs, list):
+            result = cudf.DataFrame()
+            for agg in aggs:
+                result[agg] = getattr(df_normalized, agg)()
+
+        elif isinstance(aggs, str):
+            result = cudf.DataFrame()
+            result[aggs] = getattr(df_normalized, aggs)()
+            result = result.T.loc[aggs]
+            result.name = None
+            return result
+
+        elif isinstance(aggs, dict):
+            cols = aggs.keys()
+            idxs = set()
+            for agg_l in aggs.values():
+                for agg in agg_l:
+                    idxs.add(agg)
+            idxs = sorted(list(idxs))
+            result = cudf.DataFrame(index=idxs, columns=cols)
+            for key in aggs.keys():
+                col = df_normalized[key]
+                ans = cudf.Series(
+                    [None] * len(idxs), index=idxs, dtype=col.dtype
+                )
+                for agg in aggs.get(key):
+                    ans[agg] = getattr(col, agg)()
+                result[key] = ans
+            return result
+        elif callable(aggs):
+            raise NotImplementedError(
+                "callable parameter is not implemented yet"
+            )
+
+        else:
+            raise ValueError("argument must be a string or list")
+        return result.T.sort_index(axis=1, ascending=True)
+
     def nlargest(self, n, columns, keep="first"):
         """Get the rows of the DataFrame sorted by the n largest value of *columns*
 

python/cudf/cudf/tests/test_dataframe.py

@@ -7684,3 +7684,38 @@ def test_dataframe_error_equality(df1, df2, op):
     gdf2 = gd.from_pandas(df2)
 
     assert_exceptions_equal(op, op, ([df1, df2],), ([gdf1, gdf2],))
+
+
+@pytest.mark.parametrize(
+    "data",
+    [
+        {"a": [1, 2, 3], "b": [3.0, 4.0, 5.0], "c": [True, True, False]},
+        {"a": [1.0, 2.0, 3.0], "b": [3.0, 4.0, 5.0], "c": [True, True, False]},
+        {"a": [1, 2, 3], "b": [3, 4, 5], "c": [True, True, False]},
+        {"a": [1, 2, 3], "b": [True, True, False], "c": [False, True, False]},
+        {
+            "a": [1.0, 2.0, 3.0],
+            "b": [True, True, False],
+            "c": [False, True, False],
+        },
+        {"a": [1, 2, 3], "b": [3, 4, 5], "c": [2.0, 3.0, 4.0]},
+        {"a": [1, 2, 3], "b": [2.0, 3.0, 4.0], "c": [5.0, 6.0, 4.0]},
+    ],
+)
+@pytest.mark.parametrize(
+    "aggs",
+    [
+        ["min", "sum", "max"],
+        "sum",
+        "min",
+        {"a": ["sum", "min"], "b": ["min"], "c": ["max"]},
+    ],
+)
+def test_agg_for_dataframes(data, aggs):
+    pdf = pd.DataFrame(data)
+    gdf = gd.DataFrame(data)
+
+    expect = pdf.agg(aggs)
+    got = gdf.agg(aggs)
+
+    assert_eq(expect, got, check_dtype=False)