maxframe 0.1.0b5__cp39-cp39-macosx_11_0_arm64.whl

maxframe/dataframe/reduction/tests/test_reduction.py

@@ -0,0 +1,486 @@
+# Copyright 1999-2024 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
+import operator
+from functools import reduce
+from typing import NamedTuple
+
+import numpy as np
+import pandas as pd
+import pytest
+
+from .... import dataframe as md
+from ....tensor import Tensor
+from ...core import DataFrame, IndexValue, OutputType, Series
+from ...datasource.dataframe import from_pandas as from_pandas_df
+from ...datasource.series import from_pandas as from_pandas_series
+from .. import (
+    CustomReduction,
+    DataFrameAll,
+    DataFrameAny,
+    DataFrameCount,
+    DataFrameCummax,
+    DataFrameCummin,
+    DataFrameCumprod,
+    DataFrameCumsum,
+    DataFrameKurtosis,
+    DataFrameMax,
+    DataFrameMean,
+    DataFrameMin,
+    DataFrameNunique,
+    DataFrameProd,
+    DataFrameSem,
+    DataFrameSkew,
+    DataFrameSum,
+    DataFrameVar,
+)
+from ..aggregation import where_function
+from ..core import ReductionCompiler
+
+pytestmark = pytest.mark.pd_compat
+
+
+class FunctionOptions(NamedTuple):
+    has_skipna: bool = True
+    has_numeric_only: bool = True
+    has_bool_only: bool = False
+
+
+reduction_functions = [
+    ("sum", DataFrameSum, FunctionOptions()),
+    ("prod", DataFrameProd, FunctionOptions()),
+    ("min", DataFrameMin, FunctionOptions()),
+    ("max", DataFrameMax, FunctionOptions()),
+    ("count", DataFrameCount, FunctionOptions(has_skipna=False)),
+    ("mean", DataFrameMean, FunctionOptions()),
+    ("var", DataFrameVar, FunctionOptions()),
+    ("skew", DataFrameSkew, FunctionOptions()),
+    ("kurt", DataFrameKurtosis, FunctionOptions()),
+    ("sem", DataFrameSem, FunctionOptions()),
+    ("all", DataFrameAll, FunctionOptions(has_numeric_only=False, has_bool_only=True)),
+    ("any", DataFrameAny, FunctionOptions(has_numeric_only=False, has_bool_only=True)),
+]
+
+
+@pytest.mark.parametrize("func_name,op,func_opts", reduction_functions)
+def test_series_reduction(func_name, op, func_opts: FunctionOptions):
+    data = pd.Series(range(20), index=[str(i) for i in range(20)])
+    series = getattr(from_pandas_series(data, chunk_size=3), func_name)()
+
+    assert isinstance(series, Tensor)
+    assert isinstance(series.op, op)
+    assert series.shape == ()
+
+    data = pd.Series(np.random.rand(25), name="a")
+    if func_opts.has_skipna:
+        kwargs = dict(axis="index", skipna=False)
+    else:
+        kwargs = dict()
+    series = getattr(from_pandas_series(data, chunk_size=7), func_name)(**kwargs)
+
+    assert isinstance(series, Tensor)
+    assert series.shape == ()
+
+
+@pytest.mark.parametrize("func_name,op,func_opts", reduction_functions)
+def test_dataframe_reduction(func_name, op, func_opts: FunctionOptions):
+    data = pd.DataFrame(
+        {"a": list(range(20)), "b": list(range(20, 0, -1))},
+        index=[str(i) for i in range(20)],
+    )
+    reduction_df = getattr(from_pandas_df(data, chunk_size=3), func_name)()
+
+    assert isinstance(reduction_df, Series)
+    assert isinstance(reduction_df.op, op)
+    assert isinstance(reduction_df.index_value._index_value, IndexValue.Index)
+    assert reduction_df.shape == (2,)
+
+    data = pd.DataFrame(np.random.rand(20, 10))
+    reduction_df = getattr(from_pandas_df(data, chunk_size=3), func_name)()
+
+    assert isinstance(reduction_df, Series)
+    assert isinstance(
+        reduction_df.index_value._index_value,
+        (IndexValue.RangeIndex, IndexValue.Int64Index),
+    )
+    assert reduction_df.shape == (10,)
+
+    data = pd.DataFrame(np.random.rand(20, 20), index=[str(i) for i in range(20)])
+    reduction_df = getattr(from_pandas_df(data, chunk_size=4), func_name)(
+        axis="columns"
+    )
+
+    assert reduction_df.shape == (20,)
+
+    with pytest.raises(NotImplementedError):
+        getattr(from_pandas_df(data, chunk_size=3), func_name)(level=0, axis=1)
+
+
+cum_reduction_functions = [
+    ("cummin", DataFrameCummin, FunctionOptions()),
+    ("cummax", DataFrameCummax, FunctionOptions()),
+    ("cumprod", DataFrameCumprod, FunctionOptions()),
+    ("cumsum", DataFrameCumsum, FunctionOptions()),
+]
+
+
+@pytest.mark.parametrize("func_name,op,func_opts", cum_reduction_functions)
+def test_cum_series_reduction(func_name, op, func_opts: FunctionOptions):
+    data = pd.Series({"a": list(range(20))}, index=[str(i) for i in range(20)])
+    series = getattr(from_pandas_series(data, chunk_size=3), func_name)()
+
+    assert isinstance(series, Series)
+    assert series.shape == (20,)
+
+    data = pd.Series(np.random.rand(25), name="a")
+    if func_opts.has_skipna:
+        kwargs = dict(axis="index", skipna=False)
+    else:
+        kwargs = dict()
+    series = getattr(from_pandas_series(data, chunk_size=7), func_name)(**kwargs)
+
+    assert isinstance(series, Series)
+    assert series.shape == (25,)
+
+
+@pytest.mark.parametrize("func_name,op,func_opts", cum_reduction_functions)
+def test_cum_dataframe_reduction(func_name, op, func_opts: FunctionOptions):
+    data = pd.DataFrame(
+        {"a": list(range(20)), "b": list(range(20, 0, -1))},
+        index=[str(i) for i in range(20)],
+    )
+    reduction_df = getattr(from_pandas_df(data, chunk_size=3), func_name)()
+
+    assert isinstance(reduction_df, DataFrame)
+    assert isinstance(reduction_df.index_value._index_value, IndexValue.Index)
+    assert reduction_df.shape == (20, 2)
+
+    data = pd.DataFrame(np.random.rand(20, 10))
+    reduction_df = getattr(from_pandas_df(data, chunk_size=3), func_name)()
+
+    assert isinstance(reduction_df, DataFrame)
+    assert isinstance(reduction_df.index_value._index_value, IndexValue.RangeIndex)
+    assert reduction_df.shape == (20, 10)
+
+
+def test_nunique():
+    data = pd.DataFrame(
+        np.random.randint(0, 6, size=(20, 10)),
+        columns=["c" + str(i) for i in range(10)],
+    )
+    df = from_pandas_df(data, chunk_size=3)
+    result = df.nunique()
+
+    assert result.shape == (10,)
+    assert result.op.output_types[0] == OutputType.series
+    assert isinstance(result.op, DataFrameNunique)
+
+    data2 = data.copy()
+    df2 = from_pandas_df(data2, chunk_size=3)
+    result2 = df2.nunique(axis=1)
+
+    assert result2.shape == (20,)
+    assert result2.op.output_types[0] == OutputType.series
+    assert isinstance(result2.op, DataFrameNunique)
+
+
+def test_dataframe_aggregate():
+    data = pd.DataFrame(np.random.rand(20, 19))
+    agg_funcs = [
+        "sum",
+        "min",
+        "max",
+        "mean",
+        "var",
+        "std",
+        "all",
+        "any",
+        "skew",
+        "kurt",
+        "sem",
+    ]
+
+    df = from_pandas_df(data)
+    result = df.agg(agg_funcs)
+    assert result.shape == (len(agg_funcs), data.shape[1])
+    assert list(result.columns_value.to_pandas()) == list(range(19))
+    assert list(result.index_value.to_pandas()) == agg_funcs
+    assert result.op.output_types[0] == OutputType.dataframe
+    assert result.op.func == agg_funcs
+
+    df = from_pandas_df(data, chunk_size=(3, 4))
+
+    result = df.agg("sum")
+    assert result.shape == (data.shape[1],)
+    assert list(result.index_value.to_pandas()) == list(range(data.shape[1]))
+    assert result.op.output_types[0] == OutputType.series
+    assert result.op.func == ["sum"]
+
+    result = df.agg("sum", axis=1)
+    assert result.shape == (data.shape[0],)
+    assert list(result.index_value.to_pandas()) == list(range(data.shape[0]))
+    assert result.op.output_types[0] == OutputType.series
+
+    result = df.agg("var", axis=1)
+    assert result.shape == (data.shape[0],)
+    assert list(result.index_value.to_pandas()) == list(range(data.shape[0]))
+    assert result.op.output_types[0] == OutputType.series
+    assert result.op.func == ["var"]
+
+    result = df.agg(agg_funcs)
+    assert result.shape == (len(agg_funcs), data.shape[1])
+    assert list(result.columns_value.to_pandas()) == list(range(data.shape[1]))
+    assert list(result.index_value.to_pandas()) == agg_funcs
+    assert result.op.output_types[0] == OutputType.dataframe
+    assert result.op.func == agg_funcs
+
+    result = df.agg(agg_funcs, axis=1)
+    assert result.shape == (data.shape[0], len(agg_funcs))
+    assert list(result.columns_value.to_pandas()) == agg_funcs
+    assert list(result.index_value.to_pandas()) == list(range(data.shape[0]))
+    assert result.op.output_types[0] == OutputType.dataframe
+    assert result.op.func == agg_funcs
+
+    dict_fun = {0: "sum", 2: ["var", "max"], 9: ["mean", "var", "std"]}
+    all_cols = set(
+        reduce(
+            operator.add, [[v] if isinstance(v, str) else v for v in dict_fun.values()]
+        )
+    )
+    result = df.agg(dict_fun)
+    assert result.shape == (len(all_cols), len(dict_fun))
+    assert set(result.columns_value.to_pandas()) == set(dict_fun.keys())
+    assert set(result.index_value.to_pandas()) == all_cols
+    assert result.op.output_types[0] == OutputType.dataframe
+    assert result.op.func[0] == [dict_fun[0]]
+    assert result.op.func[2] == dict_fun[2]
+
+    with pytest.raises(TypeError):
+        df.agg(sum_0="sum", mean_0="mean")
+    with pytest.raises(NotImplementedError):
+        df.agg({0: ["sum", "min", "var"], 9: ["mean", "var", "std"]}, axis=1)
+
+
+def test_series_aggregate():
+    data = pd.Series(np.random.rand(20), index=[str(i) for i in range(20)], name="a")
+    agg_funcs = [
+        "sum",
+        "min",
+        "max",
+        "mean",
+        "var",
+        "std",
+        "all",
+        "any",
+        "skew",
+        "kurt",
+        "sem",
+    ]
+
+    series = from_pandas_series(data)
+
+    result = series.agg(agg_funcs)
+    assert result.shape == (len(agg_funcs),)
+    assert list(result.index_value.to_pandas()) == agg_funcs
+    assert result.op.output_types[0] == OutputType.series
+    assert result.op.func == agg_funcs
+
+    series = from_pandas_series(data, chunk_size=3)
+
+    result = series.agg("sum")
+    assert result.shape == ()
+    assert result.op.output_types[0] == OutputType.scalar
+
+    result = series.agg(agg_funcs)
+    assert result.shape == (len(agg_funcs),)
+    assert list(result.index_value.to_pandas()) == agg_funcs
+    assert result.op.output_types[0] == OutputType.series
+    assert result.op.func == agg_funcs
+
+    with pytest.raises(TypeError):
+        series.agg(sum_0=(0, "sum"), mean_0=(0, "mean"))
+
+
+def test_compile_function():
+    compiler = ReductionCompiler()
+    ms = md.Series([1, 2, 3])
+    # no MaxFrame objects inside closures
+    with pytest.raises(ValueError):
+        compiler.add_function(functools.partial(lambda x: (x + ms).sum()), ndim=2)
+    # function should return a MaxFrame object
+    with pytest.raises(ValueError):
+        compiler.add_function(lambda x: x is not None, ndim=2)
+    # function should perform some sort of reduction in dimensionality
+    with pytest.raises(ValueError):
+        compiler.add_function(lambda x: x, ndim=2)
+    # function should only contain acceptable operators
+    with pytest.raises(ValueError):
+        compiler.add_function(lambda x: x.sort_values().max(), ndim=1)
+    with pytest.raises(ValueError):
+        compiler.add_function(lambda x: x.max().shift(1), ndim=2)
+
+    # test agg for all data
+    for ndim in [1, 2]:
+        compiler = ReductionCompiler()
+        compiler.add_function(lambda x: (x**2).count() + 1, ndim=ndim)
+        result = compiler.compile()
+        # check pre_funcs
+        assert len(result.pre_funcs) == 1
+        assert b"pow" in result.pre_funcs[0].func_idl
+        # check agg_funcs
+        assert len(result.agg_funcs) == 1
+        assert result.agg_funcs[0].map_func_name == "count"
+        assert result.agg_funcs[0].agg_func_name == "sum"
+        # check post_funcs
+        assert len(result.post_funcs) == 1
+        assert result.post_funcs[0].func_name == "<lambda>"
+        assert b"add" in result.post_funcs[0].func_idl
+
+        compiler.add_function(
+            lambda x: -x.prod() ** 2 + (1 + (x**2).count()), ndim=ndim
+        )
+        result = compiler.compile()
+        # check pre_funcs
+        assert len(result.pre_funcs) == 2
+        assert (
+            b"pow" in result.pre_funcs[0].func_idl
+            or b"pow" in result.pre_funcs[1].func_idl
+        )
+        assert (
+            b"pow" not in result.pre_funcs[0].func_idl
+            or b"pow" not in result.pre_funcs[1].func_idl
+        )
+        # check agg_funcs
+        assert len(result.agg_funcs) == 2
+        assert set(result.agg_funcs[i].map_func_name for i in range(2)) == {
+            "count",
+            "prod",
+        }
+        assert set(result.agg_funcs[i].agg_func_name for i in range(2)) == {
+            "sum",
+            "prod",
+        }
+        # check post_funcs
+        assert len(result.post_funcs) == 2
+        assert result.post_funcs[0].func_name == "<lambda_0>"
+        assert b"add" in result.post_funcs[0].func_idl
+        assert b"add" in result.post_funcs[1].func_idl
+
+        compiler = ReductionCompiler()
+        compiler.add_function(
+            lambda x: where_function(x.all(), x.count(), 0), ndim=ndim
+        )
+        result = compiler.compile()
+        # check pre_funcs
+        assert len(result.pre_funcs) == 1
+        assert result.pre_funcs[0].input_key == result.pre_funcs[0].output_key
+        # check agg_funcs
+        assert len(result.agg_funcs) == 2
+        assert set(result.agg_funcs[i].map_func_name for i in range(2)) == {
+            "all",
+            "count",
+        }
+        assert set(result.agg_funcs[i].agg_func_name for i in range(2)) == {
+            "sum",
+            "all",
+        }
+        # check post_funcs
+        assert len(result.post_funcs) == 1
+        assert b"where" in result.post_funcs[0].func_idl
+
+        # check boolean expressions
+        compiler = ReductionCompiler()
+        compiler.add_function(lambda x: (x == "1").sum(), ndim=ndim)
+        result = compiler.compile()
+        # check pre_funcs
+        assert len(result.pre_funcs) == 1
+        assert b"eq" in result.pre_funcs[0].func_idl
+        # check agg_funcs
+        assert len(result.agg_funcs) == 1
+        assert result.agg_funcs[0].map_func_name == "sum"
+        assert result.agg_funcs[0].agg_func_name == "sum"
+
+    # test agg for specific columns
+    compiler = ReductionCompiler()
+    compiler.add_function(lambda x: 1 + x.sum(), ndim=2, cols=["a", "b"])
+    compiler.add_function(lambda x: -1 + x.sum(), ndim=2, cols=["b", "c"])
+    result = compiler.compile()
+    # check pre_funcs
+    assert len(result.pre_funcs) == 1
+    assert set(result.pre_funcs[0].columns) == set("abc")
+    # check agg_funcs
+    assert len(result.agg_funcs) == 1
+    assert result.agg_funcs[0].map_func_name == "sum"
+    assert result.agg_funcs[0].agg_func_name == "sum"
+    # check post_funcs
+    assert len(result.post_funcs) == 2
+    assert set("".join(sorted(result.post_funcs[i].columns)) for i in range(2)) == {
+        "ab",
+        "bc",
+    }
+
+    # test agg for multiple columns
+    compiler = ReductionCompiler()
+    compiler.add_function(lambda x: x.sum(), ndim=2, cols=["a"])
+    compiler.add_function(lambda x: x.sum(), ndim=2, cols=["b"])
+    compiler.add_function(lambda x: x.min(), ndim=2, cols=["c"])
+    result = compiler.compile()
+    # check pre_funcs
+    assert len(result.pre_funcs) == 1
+    assert set(result.pre_funcs[0].columns) == set("abc")
+    # check agg_funcs
+    assert len(result.agg_funcs) == 2
+    assert result.agg_funcs[0].map_func_name == "sum"
+    assert result.agg_funcs[0].agg_func_name == "sum"
+    # check post_funcs
+    assert len(result.post_funcs) == 2
+    assert set(result.post_funcs[0].columns) == set("ab")
+
+
+def test_custom_aggregation():
+    class MockReduction1(CustomReduction):
+        def agg(self, v1):
+            return v1.sum()
+
+    class MockReduction2(CustomReduction):
+        def pre(self, value):
+            return value + 1, value**2
+
+        def agg(self, v1, v2):
+            return v1.sum(), v2.prod()
+
+        def post(self, v1, v2):
+            return v1 + v2
+
+    for ndim in [1, 2]:
+        compiler = ReductionCompiler()
+        compiler.add_function(MockReduction1(), ndim=ndim)
+        result = compiler.compile()
+        # check agg_funcs
+        assert len(result.agg_funcs) == 1
+        assert result.agg_funcs[0].map_func_name == "custom_reduction"
+        assert result.agg_funcs[0].agg_func_name == "custom_reduction"
+        assert isinstance(result.agg_funcs[0].custom_reduction, MockReduction1)
+        assert result.agg_funcs[0].output_limit == 1
+
+        compiler = ReductionCompiler()
+        compiler.add_function(MockReduction2(), ndim=ndim)
+        result = compiler.compile()
+        # check agg_funcs
+        assert len(result.agg_funcs) == 1
+        assert result.agg_funcs[0].map_func_name == "custom_reduction"
+        assert result.agg_funcs[0].agg_func_name == "custom_reduction"
+        assert isinstance(result.agg_funcs[0].custom_reduction, MockReduction2)
+        assert result.agg_funcs[0].output_limit == 2

maxframe/dataframe/reduction/unique.py

@@ -0,0 +1,90 @@
+# Copyright 1999-2024 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 numpy as np
+import pandas as pd
+
+from ... import opcodes
+from ...core import ENTITY_TYPE, OutputType
+from ...tensor.core import TensorOrder
+from ...utils import lazy_import
+from ..initializer import Series as asseries
+from .core import CustomReduction, DataFrameReductionMixin, DataFrameReductionOperator
+
+cudf = lazy_import("cudf")
+
+
+class UniqueReduction(CustomReduction):
+    def agg(self, data):  # noqa: W0221  # pylint: disable=arguments-differ
+        xdf = cudf if self.is_gpu() else pd
+        # convert to series data
+        return xdf.Series(data.unique())
+
+    def post(self, data):  # noqa: W0221  # pylint: disable=arguments-differ
+        return data.unique()
+
+
+class DataFrameUnique(DataFrameReductionOperator, DataFrameReductionMixin):
+    _op_type_ = opcodes.UNIQUE
+    _func_name = "unique"
+
+    @classmethod
+    def get_reduction_callable(cls, op):
+        return UniqueReduction(name=cls._func_name, is_gpu=op.is_gpu())
+
+    def __call__(self, a):
+        if not isinstance(a, ENTITY_TYPE):
+            a = asseries(a)
+        self.output_types = [OutputType.tensor]
+        return self.new_tileables(
+            [a], shape=(np.nan,), dtype=a.dtype, order=TensorOrder.C_ORDER
+        )[0]
+
+
+def unique(values, method="tree"):
+    """
+    Uniques are returned in order of appearance. This does NOT sort.
+
+    Parameters
+    ----------
+    values : 1d array-like
+    method : 'shuffle' or 'tree', 'tree' method provide a better performance, 'shuffle'
+    is recommended if the number of unique values is very large.
+    See Also
+    --------
+    Index.unique
+    Series.unique
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> import pandas as pd
+    >>> md.unique(md.Series([2, 1, 3, 3])).execute()
+    array([2, 1, 3])
+
+    >>> md.unique(md.Series([2] + [1] * 5)).execute()
+    array([2, 1])
+
+    >>> md.unique(md.Series([pd.Timestamp('20160101'),
+    ...                     pd.Timestamp('20160101')])).execute()
+    array(['2016-01-01T00:00:00.000000000'], dtype='datetime64[ns]')
+
+    >>> md.unique(md.Series([pd.Timestamp('20160101', tz='US/Eastern'),
+    ...                      pd.Timestamp('20160101', tz='US/Eastern')])).execute()
+    array([Timestamp('2016-01-01 00:00:00-0500', tz='US/Eastern')],
+          dtype=object)
+    """
+    op = DataFrameUnique(method=method)
+    return op(values)

maxframe/dataframe/reduction/var.py

@@ -0,0 +1,72 @@
+# Copyright 1999-2024 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.
+
+from ... import opcodes
+from ...core import OutputType
+from ...serialization.serializables import Int32Field
+from .core import DataFrameReductionMixin, DataFrameReductionOperator
+
+
+class DataFrameVar(DataFrameReductionOperator, DataFrameReductionMixin):
+    _op_type_ = opcodes.VAR
+    _func_name = "var"
+
+    ddof = Int32Field("ddof", default=None)
+
+    @classmethod
+    def get_reduction_callable(cls, op: "DataFrameVar"):
+        skipna, ddof = op.skipna, op.ddof
+
+        def var(x):
+            cnt = x.count()
+            if ddof == 0:
+                return (x**2).mean(skipna=skipna) - (x.mean(skipna=skipna)) ** 2
+            return ((x**2).sum(skipna=skipna) - x.sum(skipna=skipna) ** 2 / cnt) / (
+                cnt - ddof
+            )
+
+        return var
+
+
+def var_series(series, axis=None, skipna=True, level=None, ddof=1, method=None):
+    op = DataFrameVar(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        ddof=ddof,
+        output_types=[OutputType.scalar],
+        method=method,
+    )
+    return op(series)
+
+
+def var_dataframe(
+    df,
+    axis=None,
+    skipna=True,
+    level=None,
+    ddof=1,
+    numeric_only=None,
+    method=None,
+):
+    op = DataFrameVar(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        ddof=ddof,
+        numeric_only=numeric_only,
+        output_types=[OutputType.series],
+        method=method,
+    )
+    return op(df)

maxframe/dataframe/sort/__init__.py

@@ -0,0 +1,34 @@
+# Copyright 1999-2024 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.
+
+from .sort_index import DataFrameSortIndex
+from .sort_values import DataFrameSortValues
+
+
+def _install():
+    from ..core import DATAFRAME_TYPE, SERIES_TYPE
+    from .sort_index import sort_index
+    from .sort_values import dataframe_sort_values, series_sort_values
+
+    for cls in DATAFRAME_TYPE:
+        setattr(cls, "sort_values", dataframe_sort_values)
+        setattr(cls, "sort_index", sort_index)
+
+    for cls in SERIES_TYPE:
+        setattr(cls, "sort_values", series_sort_values)
+        setattr(cls, "sort_index", sort_index)
+
+
+_install()
+del _install