maxframe 2.0.0b1__cp37-cp37m-win_amd64.whl → 2.2.0__cp37-cp37m-win_amd64.whl

maxframe/dataframe/extensions/tests/test_map_reduce.py

@@ -0,0 +1,135 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import functools
+from collections import defaultdict
+
+import pandas as pd
+import pytest
+
+from .... import dataframe as md
+from ...groupby.apply_chunk import GroupByApplyChunk
+from .. import DataFrameApplyChunk
+
+
+@pytest.fixture
+def df1():
+    return md.DataFrame(
+        {
+            "name": ["name key", "name", "key", "name", "key name"],
+            "id": [4, 2, 4, 3, 3],
+            "fid": [5.3, 3.5, 4.2, 2.2, 4.1],
+        }
+    )
+
+
+def test_map_reduce_with_map_only(df1):
+    func = functools.partial(lambda x: x)
+
+    with pytest.raises(ValueError):
+        df1.mf.map_reduce(func, reducer_dtypes={"col": "string"})
+
+    mapped = df1.mf.map_reduce(func)
+    assert isinstance(mapped.op, DataFrameApplyChunk)
+    assert mapped.op.func is func
+
+    map_combined = df1.mf.map_reduce(
+        func, combiner=func, mapper_dtypes=df1.dtypes, mapper_index=df1.index
+    )
+    assert isinstance(map_combined.op, DataFrameApplyChunk)
+    assert map_combined.op.func.__name__ == "CombinedMapper"
+
+
+def test_mapper_with_combiner(df1):
+    class BaseFunc:
+        def __init__(self):
+            self._word_to_count = defaultdict(lambda: 0)
+
+        def _collect_df(self):
+            word_to_count = self._word_to_count.copy()
+            self._word_to_count.clear()
+            return pd.DataFrame(
+                [list(tp) for tp in word_to_count.items()],
+                columns=["word", "count"],
+            )
+
+        def close(self):
+            print(f"Close {type(self)}")
+
+    class MapperCls(BaseFunc):
+        def __call__(self, batch, end=False):
+            for words in batch["name"]:
+                for w in words.split():
+                    self._word_to_count[w] += 1
+            if end:
+                return self._collect_df()
+
+    class CombinerCls(BaseFunc):
+        def __call__(self, batch, end=False):
+            for _, row in batch.iterrows():
+                self._word_to_count[row["word"]] = row["count"]
+            if end:
+                return self._collect_df()
+
+    map_combined = df1.mf.map_reduce(
+        MapperCls,
+        combiner=CombinerCls,
+        group_cols="word",
+        mapper_dtypes={"word": "str", "count": "int"},
+        mapper_index=df1.index,
+    )
+
+    raw = df1.op.data
+    combiner = map_combined.op.func()
+    ret1 = combiner(raw.iloc[:3], end=True)
+    ret2 = combiner(raw.iloc[3:], end=True)
+    close_ret = combiner.close()
+    expected1 = pd.DataFrame([["key", 2], ["name", 2]], columns=["word", "count"])
+    expected2 = pd.DataFrame([["key", 1], ["name", 2]], columns=["word", "count"])
+    assert close_ret is None
+    pd.testing.assert_frame_equal(ret1.reset_index(drop=True), expected1)
+    pd.testing.assert_frame_equal(ret2.reset_index(drop=True), expected2)
+
+
+def test_map_reduce_with_reduce_only(df1):
+    func = functools.partial(lambda x: x)
+
+    with pytest.raises(ValueError):
+        df1.mf.map_reduce(reducer=func, mapper_dtypes={"col": "string"})
+
+    reduced = df1.mf.map_reduce(reducer=func, group_cols="name")
+    assert isinstance(reduced.op, GroupByApplyChunk)
+    assert reduced.op.func is func
+    assert reduced.op.groupby_params["by"] == ["name"]
+
+
+def test_map_reduce_with_both_funcs(df1):
+    map_func = functools.partial(lambda x: x)
+
+    class ReducerCls:
+        def __call__(self, batch):
+            return batch
+
+    reduced = df1.mf.map_reduce(
+        mapper=map_func,
+        reducer=ReducerCls,
+        group_cols="name",
+        reducer_dtypes=df1.dtypes,
+        reducer_index=df1.index,
+    )
+    assert isinstance(reduced.op, GroupByApplyChunk)
+    assert reduced.op.func is ReducerCls
+    assert reduced.op.groupby_params["by"] == ["name"]
+    assert isinstance(reduced.inputs[0].op, DataFrameApplyChunk)
+    assert reduced.inputs[0].op.func is map_func

maxframe/dataframe/groupby/__init__.py

@@ -15,6 +15,8 @@
 # noinspection PyUnresolvedReferences
 from ..core import DataFrameGroupBy, GroupBy, SeriesGroupBy
 from .core import NamedAgg
+from .expanding import ExpandingGroupby
+from .rolling import RollingGroupby
 
 
 def _install():
@@ -24,12 +26,15 @@ def _install():
     from .apply import groupby_apply
     from .apply_chunk import df_groupby_apply_chunk
     from .core import groupby
-    from .cum import cumcount, cummax, cummin, cumprod, cumsum
+    from .expanding import cumcount, cummax, cummin, cumprod, cumsum, expanding
     from .extensions import DataFrameGroupByMaxFrameAccessor
     from .fill import bfill, ffill, fillna
     from .getitem import df_groupby_getitem
     from .head import head
+    from .rank import rank
+    from .rolling import rolling
     from .sample import groupby_sample
+    from .shift import shift
     from .transform import groupby_transform
 
     for cls in DATAFRAME_TYPE:
@@ -69,6 +74,12 @@ def _install():
         setattr(cls, "cumprod", cumprod)
         setattr(cls, "cumsum", cumsum)
 
+        setattr(cls, "expanding", expanding)
+        setattr(cls, "rolling", rolling)
+
+        setattr(cls, "shift", shift)
+        setattr(cls, "rank", rank)
+
         setattr(cls, "head", head)
 
         setattr(cls, "sample", groupby_sample)

maxframe/dataframe/groupby/aggregation.py

@@ -20,16 +20,21 @@ import numpy as np
 import pandas as pd
 
 from ... import opcodes
+from ...config import options
 from ...core import ENTITY_TYPE, EntityData, OutputType
+from ...serialization import PickleContainer
 from ...serialization.serializables import (
     AnyField,
+    BoolField,
     DictField,
+    Int8Field,
     Int32Field,
     Int64Field,
     ListField,
     StringField,
 )
-from ...utils import lazy_import, pd_release_version
+from ...udf import BuiltinFunction
+from ...utils import find_objects, lazy_import, pd_release_version
 from ..core import GROUPBY_TYPE
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
 from ..reduction.aggregation import (
@@ -46,19 +51,7 @@ logger = logging.getLogger(__name__)
 CV_THRESHOLD = 0.2
 MEAN_RATIO_THRESHOLD = 2 / 3
 _support_get_group_without_as_index = pd_release_version[:2] > (1, 0)
-
-
-class SizeRecorder:
-    def __init__(self):
-        self._raw_records = []
-        self._agg_records = []
-
-    def record(self, raw_record: int, agg_record: int):
-        self._raw_records.append(raw_record)
-        self._agg_records.append(agg_record)
-
-    def get(self):
-        return self._raw_records, self._agg_records
+_support_multi_index_as_index = pd_release_version[:2] > (2, 0)
 
 
 _agg_functions = {
@@ -86,24 +79,28 @@ _series_col_name = "col_name"
 
 def _patch_groupby_kurt():
     try:
-        from pandas.core.groupby import DataFrameGroupBy, SeriesGroupBy
-
-        if not hasattr(DataFrameGroupBy, "kurt"):  # pragma: no branch
-
-            def _kurt_by_frame(a, *args, **kwargs):
-                data = a.to_frame().kurt(*args, **kwargs).iloc[0]
-                if is_cudf(data):  # pragma: no cover
-                    data = data.copy()
-                return data
-
-            def _group_kurt(x, *args, **kwargs):
-                if kwargs.get("numeric_only") is not None:
-                    return x.agg(functools.partial(_kurt_by_frame, *args, **kwargs))
-                else:
-                    return x.agg(functools.partial(pd.Series.kurt, *args, **kwargs))
-
-            DataFrameGroupBy.kurt = DataFrameGroupBy.kurtosis = _group_kurt
-            SeriesGroupBy.kurt = SeriesGroupBy.kurtosis = _group_kurt
+        try:
+            from pandas.api.typing import DataFrameGroupBy, SeriesGroupBy
+        except ImportError:
+            from pandas.core.groupby import DataFrameGroupBy, SeriesGroupBy
+
+        if hasattr(DataFrameGroupBy, "kurt"):  # pragma: no branch
+            return
+
+        def _kurt_by_frame(a, *args, **kwargs):
+            data = a.to_frame().kurt(*args, **kwargs).iloc[0]
+            if is_cudf(data):  # pragma: no cover
+                data = data.copy()
+            return data
+
+        def _group_kurt(x, *args, **kwargs):
+            if kwargs.get("numeric_only") is not None:
+                return x.agg(functools.partial(_kurt_by_frame, *args, **kwargs))
+            else:
+                return x.agg(functools.partial(pd.Series.kurt, *args, **kwargs))
+
+        DataFrameGroupBy.kurt = DataFrameGroupBy.kurtosis = _group_kurt
+        SeriesGroupBy.kurt = SeriesGroupBy.kurtosis = _group_kurt
     except (AttributeError, ImportError):  # pragma: no cover
         pass
 
@@ -137,23 +134,43 @@ def build_mock_agg_result(
 class DataFrameGroupByAgg(DataFrameOperator, DataFrameOperatorMixin):
     _op_type_ = opcodes.GROUPBY_AGG
 
-    raw_func = AnyField("raw_func")
-    raw_func_kw = DictField("raw_func_kw")
-    func = AnyField("func")
+    raw_func = AnyField("raw_func", default=None)
+    raw_func_kw = DictField("raw_func_kw", default=None)
+    func = AnyField("func", default=None)
     func_rename = ListField("func_rename", default=None)
 
-    raw_groupby_params = DictField("raw_groupby_params")
-    groupby_params = DictField("groupby_params")
+    raw_groupby_params = DictField("raw_groupby_params", default=None)
+    groupby_params = DictField("groupby_params", default=None)
 
-    method = StringField("method")
+    method = StringField("method", default=None)
 
     # for chunk
-    chunk_store_limit = Int64Field("chunk_store_limit")
-    pre_funcs = ListField("pre_funcs")
-    agg_funcs = ListField("agg_funcs")
-    post_funcs = ListField("post_funcs")
-    index_levels = Int32Field("index_levels")
-    size_recorder_name = StringField("size_recorder_name")
+    chunk_store_limit = Int64Field("chunk_store_limit", default=None)
+    pre_funcs = ListField("pre_funcs", default=None)
+    agg_funcs = ListField("agg_funcs", default=None)
+    post_funcs = ListField("post_funcs", default=None)
+    index_levels = Int32Field("index_levels", default=None)
+    size_recorder_name = StringField("size_recorder_name", default=None)
+    combine_size = Int32Field("combine_size", default=None)
+
+    use_inf_as_na = BoolField("use_inf_as_na", default=None)
+    input_ndim = Int8Field("input_ndim", default=1)
+    append_level = BoolField("append_level", default=False)
+
+    def has_custom_code(self) -> bool:
+        callable_bys = find_objects(
+            self.groupby_params.get("by"), types=PickleContainer, checker=callable
+        )
+        if callable_bys and any(
+            not isinstance(fun, BuiltinFunction) for fun in callable_bys
+        ):
+            return True
+
+        return any(
+            fun.custom_reduction
+            and not isinstance(fun.custom_reduction, BuiltinFunction)
+            for fun in self.agg_funcs or ()
+        )
 
     @classmethod
     def _set_inputs(cls, op: "DataFrameGroupByAgg", inputs: List[EntityData]):
@@ -193,7 +210,9 @@ class DataFrameGroupByAgg(DataFrameOperator, DataFrameOperatorMixin):
 
     def _fix_as_index(self, result_index: pd.Index):
         # make sure if as_index=False takes effect
-        if isinstance(result_index, pd.MultiIndex):
+        if not _support_multi_index_as_index and isinstance(
+            result_index, pd.MultiIndex
+        ):
             # if MultiIndex, as_index=False definitely takes no effect
             self.groupby_params["as_index"] = True
         elif result_index.name is not None:
@@ -217,12 +236,17 @@ class DataFrameGroupByAgg(DataFrameOperator, DataFrameOperatorMixin):
                 agg_df.index, groupby.key, groupby.index_value.key
             )
 
+        self.input_ndim = 2
+
         # make sure if as_index=False takes effect
         self._fix_as_index(agg_df.index)
 
         # determine num of indices to group in intermediate steps
         self.index_levels = self._get_index_levels(groupby, agg_df.index)
 
+        # if True, name of agg funcs will be appended as the last level
+        self.append_level = agg_df.dtypes.index.nlevels > input_df.dtypes.index.nlevels
+
         inputs = self._get_inputs([input_df])
         return self.new_dataframe(
             inputs,
@@ -247,6 +271,8 @@ class DataFrameGroupByAgg(DataFrameOperator, DataFrameOperatorMixin):
 
         inputs = self._get_inputs([in_series])
 
+        self.input_ndim = 1
+
         # determine num of indices to group in intermediate steps
         self.index_levels = self._get_index_levels(groupby, agg_result.index)
 
@@ -376,6 +402,10 @@ def agg(groupby, func=None, method="auto", *args, **kwargs):
             f"Method {method} is not available, please specify 'tree' or 'shuffle"
         )
 
+    combine_size = (
+        kwargs.pop("combine_size", None) or options.dpe.reduction.combine_size
+    )
+
     if not is_funcs_aggregate(func, ndim=groupby.ndim):
         # pass index to transform, otherwise it will lose name info for index
         agg_result = build_mock_agg_result(
@@ -400,5 +430,8 @@ def agg(groupby, func=None, method="auto", *args, **kwargs):
         method=method,
         raw_groupby_params=groupby.op.groupby_params,
         groupby_params=groupby.op.groupby_params,
+        combine_size=combine_size,
+        chunk_store_limit=options.chunk_store_limit,
+        use_inf_as_na=pd.get_option("mode.use_inf_as_na"),
     )
     return agg_op(groupby)

maxframe/dataframe/groupby/apply.py

@@ -60,7 +60,7 @@ class GroupByApply(
     maybe_agg = BoolField("maybe_agg", default=None)
 
     logic_key = StringField("logic_key", default=None)
-    func_key = AnyField("func_key", default=None)
+    func_ref = AnyField("func_ref", default=None)
     need_clean_up_func = BoolField("need_clean_up_func", default=False)
 
     def __init__(self, output_types=None, **kw):

maxframe/dataframe/groupby/apply_chunk.py

@@ -22,8 +22,10 @@ from ...core import OutputType
 from ...lib.version import parse as parse_version
 from ...serialization.serializables import (
     DictField,
+    FieldTypes,
     FunctionField,
     Int32Field,
+    ListField,
     TupleField,
 )
 from ...udf import BuiltinFunction, MarkedFunction
@@ -31,6 +33,7 @@ from ...utils import copy_if_possible
 from ..core import (
     DATAFRAME_GROUPBY_TYPE,
     GROUPBY_TYPE,
+    INDEX_TYPE,
     DataFrameGroupBy,
     IndexValue,
     SeriesGroupBy,
@@ -61,6 +64,8 @@ class GroupByApplyChunk(DataFrameOperatorMixin, DataFrameOperator):
     kwargs = DictField("kwargs", default=None)
 
     groupby_params = DictField("groupby_params", default=None)
+    order_cols = ListField("order_cols", default=None)
+    ascending = ListField("ascending", FieldTypes.bool, default_factory=lambda: [True])
 
     def __init__(self, output_type=None, **kw):
         if output_type:
@@ -240,14 +245,14 @@ class GroupByApplyChunk(DataFrameOperatorMixin, DataFrameOperator):
         if self.output_types:
             inferred_meta.output_type = self.output_types[0]
         inferred_meta.dtypes = dtypes if dtypes is not None else inferred_meta.dtypes
+        if isinstance(index, INDEX_TYPE):
+            index = index.index_value
         if index is not None:
             inferred_meta.index_value = (
                 parse_index(index)
                 if index is not input_groupby.index_value
                 else input_groupby.index_value
             )
-        else:
-            inferred_meta.index_value = inferred_meta.index_value
         inferred_meta.elementwise = elementwise or inferred_meta.elementwise
         return inferred_meta
 
@@ -272,6 +277,8 @@ def df_groupby_apply_chunk(
     output_type=None,
     index=None,
     skip_infer=False,
+    order_cols=None,
+    ascending=True,
     args=(),
     **kwargs,
 ):
@@ -373,6 +380,13 @@ def df_groupby_apply_chunk(
     if skip_infer and output_type is None:
         output_type = OutputType.df_or_series
 
+    if order_cols and not isinstance(order_cols, list):
+        order_cols = [order_cols]
+    if not isinstance(ascending, list):
+        ascending = [ascending]
+    elif len(order_cols) != len(ascending):
+        raise ValueError("order_cols and ascending must have same length")
+
     # bind args and kwargs
     op = GroupByApplyChunk(
         func=func,
@@ -380,6 +394,8 @@ def df_groupby_apply_chunk(
         output_type=output_type,
         args=args,
         kwargs=kwargs,
+        order_cols=order_cols,
+        ascending=ascending,
         groupby_params=dataframe_groupby.op.groupby_params,
     )
 

maxframe/dataframe/groupby/core.py

@@ -13,19 +13,27 @@
 # limitations under the License.
 
 from collections import namedtuple
-from typing import List
+from typing import Any, Dict, List
 
 import pandas as pd
 
 from ... import opcodes
 from ...core import ENTITY_TYPE, Entity, EntityData, OutputType
 from ...core.operator import MapReduceOperator
-from ...serialization.serializables import AnyField, BoolField, Int32Field
-from ...utils import lazy_import, no_default
-from ..core import SERIES_TYPE
+from ...serialization import PickleContainer
+from ...serialization.serializables import AnyField, BoolField, DictField, Int32Field
+from ...udf import BuiltinFunction
+from ...utils import find_objects, lazy_import, no_default
+from ..core import GROUPBY_TYPE, SERIES_TYPE
 from ..initializer import Series as asseries
-from ..operators import DataFrameOperatorMixin
-from ..utils import build_df, build_series, parse_index
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import (
+    build_df,
+    build_series,
+    call_groupby_with_params,
+    make_column_list,
+    parse_index,
+)
 
 cudf = lazy_import("cudf")
 
@@ -35,7 +43,7 @@ NamedAgg = namedtuple("NamedAgg", ["column", "aggfunc"])
 
 class DataFrameGroupByOp(MapReduceOperator, DataFrameOperatorMixin):
     _op_type_ = opcodes.GROUPBY
-    _legacy_name = "DataFrameGroupByOperator"
+    _legacy_name = "DataFrameGroupByOperator"  # since v2.0.0
 
     by = AnyField(
         "by",
@@ -61,6 +69,12 @@ class DataFrameGroupByOp(MapReduceOperator, DataFrameOperatorMixin):
                 output_types = [OutputType.series_groupby]
             self.output_types = output_types
 
+    def has_custom_code(self) -> bool:
+        callable_bys = find_objects(self.by, types=PickleContainer, checker=callable)
+        if not callable_bys:
+            return False
+        return any(not isinstance(fun, BuiltinFunction) for fun in callable_bys)
+
     @property
     def is_dataframe_obj(self):
         return self.output_types[0] in (
@@ -93,8 +107,8 @@ class DataFrameGroupByOp(MapReduceOperator, DataFrameOperatorMixin):
                 ensure_string=True,
             )
 
-        new_kw = self.groupby_params
-        new_kw.update(kwargs)
+        new_kw = self.groupby_params.copy()
+        new_kw.update({k: v for k, v in kwargs.items()})
         if isinstance(new_kw["by"], list):
             new_by = []
             for v in new_kw["by"]:
@@ -110,7 +124,7 @@ class DataFrameGroupByOp(MapReduceOperator, DataFrameOperatorMixin):
                 else:
                     new_by.append(v)
             new_kw["by"] = new_by
-        return mock_obj.groupby(**new_kw)
+        return call_groupby_with_params(mock_obj, new_kw)
 
     @classmethod
     def _set_inputs(cls, op: "DataFrameGroupByOp", inputs: List[EntityData]):
@@ -118,8 +132,8 @@ class DataFrameGroupByOp(MapReduceOperator, DataFrameOperatorMixin):
         inputs_iter = iter(op._inputs[1:])
         if len(inputs) > 1:
             by = []
-            for k in op.by:
-                if isinstance(k, SERIES_TYPE):
+            for k in op.by or ():
+                if isinstance(k, ENTITY_TYPE):
                     by.append(next(inputs_iter))
                 else:
                     by.append(k)
@@ -240,3 +254,73 @@ def groupby(df, by=None, level=None, as_index=True, sort=True, group_keys=True):
         output_types=output_types,
     )
     return op(df)
+
+
+class BaseGroupByWindowOp(DataFrameOperatorMixin, DataFrameOperator):
+    _op_module_ = "dataframe.groupby"
+
+    groupby_params = DictField("groupby_params", default=None)
+    window_params = DictField("window_params", default=None)
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+
+    def _calc_mock_result_df(self, mock_groupby):
+        raise NotImplementedError
+
+    def get_sort_cols_to_asc(self) -> Dict[Any, bool]:
+        order_cols = self.window_params.get("order_cols") or []
+        asc_list = self.window_params.get("ascending") or [True]
+        if len(asc_list) < len(order_cols):
+            asc_list = [asc_list[0]] * len(order_cols)
+        return dict(zip(order_cols, asc_list))
+
+    def _calc_out_dtypes(self, in_groupby):
+        in_obj = in_groupby
+        groupby_params = in_groupby.op.groupby_params
+        while isinstance(in_obj, GROUPBY_TYPE):
+            in_obj = in_obj.inputs[0]
+
+        if in_groupby.ndim == 1:
+            selection = None
+        else:
+            by_cols = (
+                make_column_list(groupby_params.get("by"), in_groupby.dtypes) or []
+            )
+            selection = groupby_params.get("selection")
+            if not selection:
+                selection = [c for c in in_obj.dtypes.index if c not in by_cols]
+
+        mock_groupby = in_groupby.op.build_mock_groupby(
+            group_keys=False, selection=selection
+        )
+
+        result_df = self._calc_mock_result_df(mock_groupby)
+
+        if isinstance(result_df, pd.DataFrame):
+            self.output_types = [OutputType.dataframe]
+            return result_df.dtypes
+        else:
+            self.output_types = [OutputType.series]
+            return result_df.name, result_df.dtype
+
+    def __call__(self, groupby):
+        in_df = groupby
+        while in_df.op.output_types[0] not in (OutputType.dataframe, OutputType.series):
+            in_df = in_df.inputs[0]
+
+        out_dtypes = self._calc_out_dtypes(groupby)
+
+        kw = in_df.params.copy()
+        if self.output_types[0] == OutputType.dataframe:
+            kw.update(
+                dict(
+                    columns_value=parse_index(out_dtypes.index, store_data=True),
+                    dtypes=out_dtypes,
+                    shape=(groupby.shape[0], len(out_dtypes)),
+                )
+            )
+        else:
+            name, dtype = out_dtypes
+            kw.update(dtype=dtype, name=name, shape=(groupby.shape[0],))
+        return self.new_tileable([in_df], **kw)

maxframe/dataframe/groupby/cum.py

@@ -25,6 +25,10 @@ cudf = lazy_import("cudf")
 
 
 class GroupByCumReductionOperator(DataFrameOperatorMixin, DataFrameOperator):
+    """
+    NOTE: this operator has been deprecated and merged with GroupByExpandingAgg.
+    """
+
     _op_module_ = "dataframe.groupby"
 
     axis = AnyField("axis", default=None)
@@ -96,28 +100,3 @@ class GroupByCumprod(GroupByCumReductionOperator):
 class GroupByCumcount(GroupByCumReductionOperator):
     _op_type_ = opcodes.CUMCOUNT
     _func_name = "cumcount"
-
-
-def cumcount(groupby, ascending: bool = True):
-    op = GroupByCumcount(ascending=ascending)
-    return op(groupby)
-
-
-def cummin(groupby, axis=0):
-    op = GroupByCummin(axis=axis)
-    return op(groupby)
-
-
-def cummax(groupby, axis=0):
-    op = GroupByCummax(axis=axis)
-    return op(groupby)
-
-
-def cumprod(groupby, axis=0):
-    op = GroupByCumprod(axis=axis)
-    return op(groupby)
-
-
-def cumsum(groupby, axis=0):
-    op = GroupByCumsum(axis=axis)
-    return op(groupby)