maxframe 2.0.0b2__cp37-cp37m-win32.whl → 2.3.0rc1__cp37-cp37m-win32.whl

maxframe/dataframe/reduction/nunique.py

@@ -20,35 +20,43 @@ except ImportError:  # pragma: no cover
 from ... import opcodes
 from ...config import options
 from ...core import OutputType
-from ...serialization.serializables import BoolField
+from ...serialization.serializables import BoolField, StringField
 from ...utils import lazy_import
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from ..utils import validate_dtype_backend
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
 
 cudf = lazy_import("cudf")
 
 
-class DataFrameNunique(DataFrameReductionOperator, DataFrameReductionMixin):
+class DataFrameNunique(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.NUNIQUE
     _func_name = "nunique"
 
     dropna = BoolField("dropna", default=None)
-    use_arrow_dtype = BoolField("use_arrow_dtype", default=None)
+    dtype_backend = StringField(
+        "dtype_backend", on_deserialize=validate_dtype_backend, default=None
+    )
+
+    def __init__(self, dtype_backend=None, **kw):
+        dtype_backend = validate_dtype_backend(dtype_backend)
+        super().__init__(dtype_backend=dtype_backend, **kw)
 
     @property
     def is_atomic(self):
         return True
 
+    def get_reduction_args(self, axis=None):
+        args = dict(dropna=self.dropna)
+        if self.inputs and self.inputs[0].ndim > 1:
+            args["axis"] = axis
+        return {k: v for k, v in args.items() if v is not None}
+
     @classmethod
     def get_reduction_callable(cls, op):
         func_name = getattr(op, "_func_name")
         kw = dict(dropna=op.dropna)
         kw = {k: v for k, v in kw.items() if v is not None}
-
-        def fun(value):
-            return value.nunique(**kw)
-
-        fun.__name__ = func_name
-        return fun
+        return ReductionCallable(func_name=func_name, kwargs=kw)
 
 
 def nunique_dataframe(df, axis=0, dropna=True):
@@ -136,6 +144,6 @@ def nunique_series(series, dropna=True):
     op = DataFrameNunique(
         dropna=dropna,
         output_types=[OutputType.scalar],
-        use_arrow_dtype=options.dataframe.use_arrow_dtype,
+        dtype_backend=options.dataframe.dtype_backend,
     )
     return op(series)

maxframe/dataframe/reduction/prod.py

@@ -16,11 +16,23 @@ import numpy as np
 
 from ... import opcodes
 from ...core import OutputType
-from .aggregation import where_function
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
 
 
-class DataFrameProd(DataFrameReductionOperator, DataFrameReductionMixin):
+class ProdReductionCallable(ReductionCallable):
+    def __call__(self, value):
+        from .aggregation import where_function
+
+        skipna, min_count = self.kwargs["skipna"], self.kwargs["min_count"]
+        if min_count == 0:
+            return value.prod(skipna=skipna)
+        else:
+            return where_function(
+                value.count() >= min_count, value.prod(skipna=skipna), np.nan
+            )
+
+
+class DataFrameProd(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.PROD
     _func_name = "prod"
 
@@ -31,16 +43,9 @@ class DataFrameProd(DataFrameReductionOperator, DataFrameReductionMixin):
     @classmethod
     def get_reduction_callable(cls, op):
         skipna, min_count = op.skipna, op.min_count
-
-        def prod(value):
-            if min_count == 0:
-                return value.prod(skipna=skipna)
-            else:
-                return where_function(
-                    value.count() >= min_count, value.prod(skipna=skipna), np.nan
-                )
-
-        return prod
+        return ProdReductionCallable(
+            func_name="prod", kwargs=dict(skipna=skipna, min_count=min_count)
+        )
 
 
 def prod_series(df, axis=None, skipna=True, level=None, min_count=0, method=None):

maxframe/dataframe/reduction/reduction_size.py

@@ -14,10 +14,10 @@
 
 from ... import opcodes
 from ...core import OutputType
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin
 
 
-class DataFrameSize(DataFrameReductionOperator, DataFrameReductionMixin):
+class DataFrameSize(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.REDUCTION_SIZE
     _func_name = "size"
 

maxframe/dataframe/reduction/sem.py

@@ -15,10 +15,18 @@
 from ... import opcodes
 from ...core import OutputType
 from ...serialization.serializables import Int32Field
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
 
 
-class DataFrameSem(DataFrameReductionOperator, DataFrameReductionMixin):
+class SemReductionCallable(ReductionCallable):
+    def __call__(self, value):
+        skipna, ddof = self.kwargs["skipna"], self.kwargs["ddof"]
+        var = value.var(skipna=skipna, ddof=ddof)
+        cnt = value.count()
+        return (var / cnt) ** 0.5
+
+
+class DataFrameSem(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.SEM
     _func_name = "sem"
 
@@ -27,13 +35,9 @@ class DataFrameSem(DataFrameReductionOperator, DataFrameReductionMixin):
     @classmethod
     def get_reduction_callable(cls, op: "DataFrameSem"):
         skipna, ddof = op.skipna, op.ddof
-
-        def sem(x):
-            var = x.var(skipna=skipna, ddof=ddof)
-            cnt = x.count()
-            return (var / cnt) ** 0.5
-
-        return sem
+        return SemReductionCallable(
+            func_name="sem", kwargs={"skipna": skipna, "ddof": ddof}
+        )
 
 
 def sem_series(series, axis=None, skipna=True, level=None, ddof=1, method=None):

maxframe/dataframe/reduction/skew.py

@@ -17,10 +17,36 @@ import numpy as np
 from ... import opcodes
 from ...core import ENTITY_TYPE, OutputType
 from ...serialization.serializables import BoolField
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
 
 
-class DataFrameSkew(DataFrameReductionOperator, DataFrameReductionMixin):
+class SkewReductionCallable(ReductionCallable):
+    def __call__(self, value):
+        from .aggregation import where_function
+
+        skipna, bias = self.kwargs["skipna"], self.kwargs["bias"]
+        cnt = value.count()
+        mean = value.mean(skipna=skipna)
+        divided = (
+            (value**3).mean(skipna=skipna)
+            - 3 * (value**2).mean(skipna=skipna) * mean
+            + 2 * mean**3
+        )
+        var = value.var(skipna=skipna, ddof=0)
+        if isinstance(var, ENTITY_TYPE) or var > 0:
+            val = where_function(var > 0, divided / var**1.5, np.nan)
+        else:
+            val = np.nan
+        if not bias:
+            val = where_function(
+                (var > 0) & (cnt > 2),
+                val * ((cnt * (cnt - 1)) ** 0.5 / (cnt - 2)),
+                np.nan,
+            )
+        return val
+
+
+class DataFrameSkew(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.SKEW
     _func_name = "skew"
 
@@ -28,32 +54,10 @@ class DataFrameSkew(DataFrameReductionOperator, DataFrameReductionMixin):
 
     @classmethod
     def get_reduction_callable(cls, op: "DataFrameSkew"):
-        from .aggregation import where_function
-
         skipna, bias = op.skipna, op.bias
-
-        def skew(x):
-            cnt = x.count()
-            mean = x.mean(skipna=skipna)
-            divided = (
-                (x**3).mean(skipna=skipna)
-                - 3 * (x**2).mean(skipna=skipna) * mean
-                + 2 * mean**3
-            )
-            var = x.var(skipna=skipna, ddof=0)
-            if isinstance(var, ENTITY_TYPE) or var > 0:
-                val = where_function(var > 0, divided / var**1.5, np.nan)
-            else:
-                val = np.nan
-            if not bias:
-                val = where_function(
-                    (var > 0) & (cnt > 2),
-                    val * ((cnt * (cnt - 1)) ** 0.5 / (cnt - 2)),
-                    np.nan,
-                )
-            return val
-
-        return skew
+        return SkewReductionCallable(
+            func_name="skew", kwargs=dict(skipna=skipna, bias=bias)
+        )
 
 
 def skew_series(df, axis=None, skipna=True, level=None, bias=False, method=None):

maxframe/dataframe/reduction/str_concat.py

@@ -15,10 +15,15 @@
 from ... import opcodes
 from ...core import OutputType
 from ...serialization.serializables import StringField
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
 
 
-class DataFrameStrConcat(DataFrameReductionOperator, DataFrameReductionMixin):
+class StrLenReductionCallable(ReductionCallable):
+    def __call__(self, value):
+        return build_str_concat_object(value, **self.kwargs)
+
+
+class DataFrameStrConcat(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.STR_CONCAT
     _func_name = "str_concat"
 
@@ -35,11 +40,9 @@ class DataFrameStrConcat(DataFrameReductionOperator, DataFrameReductionMixin):
     @classmethod
     def get_reduction_callable(cls, op: "DataFrameStrConcat"):
         sep, na_rep = op.sep, op.na_rep
-
-        def str_concat(obj):
-            return build_str_concat_object(obj, sep=sep, na_rep=na_rep)
-
-        return str_concat
+        return StrLenReductionCallable(
+            func_name="str_concat", kwargs=dict(sep=sep, na_rep=na_rep)
+        )
 
 
 def build_str_concat_object(df, sep=None, na_rep=None):

maxframe/dataframe/reduction/sum.py

@@ -16,10 +16,23 @@ import numpy as np
 
 from ... import opcodes
 from ...core import OutputType
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
 
 
-class DataFrameSum(DataFrameReductionOperator, DataFrameReductionMixin):
+class SumReductionCallable(ReductionCallable):
+    def __call__(self, value):
+        from .aggregation import where_function
+
+        skipna, min_count = self.kwargs["skipna"], self.kwargs["min_count"]
+        if min_count == 0:
+            return value.sum(skipna=skipna)
+        else:
+            return where_function(
+                value.count() >= min_count, value.sum(skipna=skipna), np.nan
+            )
+
+
+class DataFrameSum(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.SUM
     _func_name = "sum"
 
@@ -29,19 +42,10 @@ class DataFrameSum(DataFrameReductionOperator, DataFrameReductionMixin):
 
     @classmethod
     def get_reduction_callable(cls, op):
-        from .aggregation import where_function
-
         skipna, min_count = op.skipna, op.min_count
-
-        def sum_(value):
-            if min_count == 0:
-                return value.sum(skipna=skipna)
-            else:
-                return where_function(
-                    value.count() >= min_count, value.sum(skipna=skipna), np.nan
-                )
-
-        return sum_
+        return SumReductionCallable(
+            func_name="sum", kwargs=dict(skipna=skipna, min_count=min_count)
+        )
 
 
 def sum_series(df, axis=None, skipna=True, level=None, min_count=0, method=None):

maxframe/dataframe/reduction/tests/test_reduction.py

@@ -26,6 +26,7 @@ from .... import dataframe as md
 from ....lib.dtypes_extension import ArrowDtype
 from ....tensor import Tensor
 from ....tests.utils import assert_mf_index_dtype
+from ....udf import ODPSFunction
 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
@@ -527,3 +528,14 @@ def test_custom_aggregation():
         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
+
+
+def test_aggregation_with_odps_function():
+    odps_func = ODPSFunction("test_odps_udaf", dtype=np.float64)
+    for ndim in [1, 2]:
+        compiler = ReductionCompiler()
+        compiler.add_function(odps_func, ndim=ndim)
+        result = compiler.compile()
+        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, ODPSFunction)

maxframe/dataframe/reduction/unique.py

@@ -28,12 +28,19 @@ from ...tensor.core import TensorOrder
 from ...utils import lazy_import
 from ..core import DATAFRAME_TYPE
 from ..initializer import Series as asseries
-from .core import CustomReduction, DataFrameReductionMixin, DataFrameReductionOperator
+from .core import (
+    CustomReduction,
+    DataFrameReduction,
+    DataFrameReductionMixin,
+    ReductionCallable,
+)
 
 cudf = lazy_import("cudf")
 
 
 class UniqueReduction(CustomReduction):
+    _func_name = "unique"
+
     def agg(self, data):  # noqa: W0221  # pylint: disable=arguments-differ
         xdf = cudf if self.is_gpu() else pd
         # convert to series data
@@ -43,7 +50,12 @@ class UniqueReduction(CustomReduction):
         return data.unique()
 
 
-class DataFrameUnique(DataFrameReductionOperator, DataFrameReductionMixin):
+class UniqueReductionCallable(ReductionCallable):
+    def __call__(self, value):
+        return UniqueReduction(name="unique", is_gpu=self.kwargs["is_gpu"])(value)
+
+
+class DataFrameUnique(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.UNIQUE
     _func_name = "unique"
 
@@ -53,9 +65,14 @@ class DataFrameUnique(DataFrameReductionOperator, DataFrameReductionMixin):
     def is_atomic(self):
         return True
 
+    def get_reduction_args(self, axis=None):
+        return {}
+
     @classmethod
     def get_reduction_callable(cls, op):
-        return UniqueReduction(name=cls._func_name, is_gpu=op.is_gpu())
+        return UniqueReductionCallable(
+            func_name=cls._func_name, kwargs=dict(is_gpu=op.is_gpu())
+        )
 
     def __call__(self, a):
         if not isinstance(a, ENTITY_TYPE):

maxframe/dataframe/reduction/var.py

@@ -15,10 +15,21 @@
 from ... import opcodes
 from ...core import OutputType
 from ...serialization.serializables import Int32Field
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
 
 
-class DataFrameVar(DataFrameReductionOperator, DataFrameReductionMixin):
+class VarReductionCallable(ReductionCallable):
+    def __call__(self, value):
+        skipna, ddof = self.kwargs["skipna"], self.kwargs["ddof"]
+        cnt = value.count()
+        if ddof == 0:
+            return (value**2).mean(skipna=skipna) - (value.mean(skipna=skipna)) ** 2
+        return (
+            (value**2).sum(skipna=skipna) - value.sum(skipna=skipna) ** 2 / cnt
+        ) / (cnt - ddof)
+
+
+class DataFrameVar(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.VAR
     _func_name = "var"
 
@@ -27,16 +38,9 @@ class DataFrameVar(DataFrameReductionOperator, DataFrameReductionMixin):
     @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
+        return VarReductionCallable(
+            func_name="var", kwargs={"skipna": skipna, "ddof": ddof}
+        )
 
 
 def var_series(series, axis=None, skipna=True, level=None, ddof=1, method=None):

maxframe/dataframe/reshape/__init__.py

@@ -0,0 +1,38 @@
+# 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.
+
+from .melt import melt
+from .pivot import pivot
+from .pivot_table import pivot_table
+from .stack import stack
+from .unstack import unstack
+
+
+def _install():
+    from ..core import DATAFRAME_TYPE, SERIES_TYPE
+
+    for t in DATAFRAME_TYPE:
+        setattr(t, "melt", melt)
+        setattr(t, "pivot", pivot)
+        setattr(t, "pivot_table", pivot_table)
+        setattr(t, "stack", stack)
+        setattr(t, "unstack", unstack)
+
+    for t in SERIES_TYPE:
+        setattr(t, "unstack", unstack)
+
+
+_install()
+del _install

maxframe/dataframe/{misc → reshape}/pivot.py

@@ -35,6 +35,7 @@ class DataFramePivot(DataFrameOperator, DataFrameOperatorMixin):
     columns = AnyField("columns", default=None)
 
     agg_results = KeyField("agg_results", default=None)
+    fill_value = AnyField("fill_value", default=None)
 
     def __init__(self, aggfunc=None, **kw):
         if aggfunc is None:

maxframe/dataframe/{misc → reshape}/pivot_table.py

@@ -39,6 +39,7 @@ class DataFramePivotTable(DataFrameOperator, DataFrameOperatorMixin):
     margins_name = StringField("margins_name", default=None)
     sort = BoolField("sort", default=False)
 
+    # generate intermediate agg result to infer value of columns
     agg_results = KeyField("agg_results", default=None)
 
     def __init__(self, aggfunc=None, **kw):

maxframe/dataframe/reshape/unstack.py

@@ -0,0 +1,114 @@
+# 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.
+
+from ...udf import builtin_function
+from ..core import SERIES_TYPE
+
+
+@builtin_function
+def _adjust_names(pivoted, idx_names=None, col_names=None, remove_col_level=False):
+    if remove_col_level:
+        pivoted = pivoted.droplevel(0, axis=1)
+    if idx_names:
+        pivoted = pivoted.rename_axis(idx_names, axis=0)
+    if col_names:
+        pivoted = pivoted.rename_axis(col_names, axis=1)
+    return pivoted
+
+
+def unstack(df_or_series, level=-1, fill_value=None):
+    """
+    Unstack, also known as pivot, Series with MultiIndex to produce DataFrame.
+
+    Parameters
+    ----------
+    level : int, str, or list of these, default last level
+        Level(s) to unstack, can pass level name.
+    fill_value : scalar value, default None
+        Value to use when replacing NaN values.
+
+    Returns
+    -------
+    DataFrame
+        Unstacked Series.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series([1, 2, 3, 4],
+    ...               index=md.MultiIndex.from_product([['one', 'two'],
+    ...                                                 ['a', 'b']]))
+    >>> s.execute()
+    one  a    1
+         b    2
+    two  a    3
+         b    4
+    dtype: int64
+
+    >>> s.unstack(level=-1).execute()
+         a  b
+    one  1  2
+    two  3  4
+
+    >>> s.unstack(level=0).execute()
+         one  two
+    a    1    3
+    b    2    4
+    """
+    if df_or_series.index.nlevels == 1:
+        if isinstance(df_or_series, SERIES_TYPE):
+            raise ValueError("index must be a MultiIndex to unstack")
+        raw_idx_nlevels = df_or_series.index.nlevels
+        stacked = df_or_series.stack(level=level, fill_value=fill_value)
+        orig_order = list(stacked.index.nlevels)
+        new_order = orig_order[raw_idx_nlevels:] + orig_order[:raw_idx_nlevels]
+        return stacked.reorder_levels(new_order)
+
+    nlevels = df_or_series.index.nlevels
+    idx_names = list(df_or_series.index.names)
+    if df_or_series.ndim == 1:
+        col_names = []
+    else:
+        col_names = list(df_or_series.columns.names)
+
+    name_to_idx = {name: i for i, name in enumerate(idx_names)}
+    level = level if isinstance(level, list) else [level]
+    level_idxes = [(nlevels + name_to_idx.get(lv, lv)) % nlevels for lv in level]
+    level_idx_set = set(level_idxes)
+    level_cols = [f"__level_{idx}" for idx in range(nlevels)]
+
+    if df_or_series.ndim == 1:
+        data = df_or_series.to_frame(name="__data")
+    else:
+        data = df_or_series
+    pivot_val_col = list(data.dtypes.index)
+    pivot_col_col = [level_cols[i] for i in level_idxes]
+    pivot_idx_col = [level_cols[i] for i in range(nlevels) if i not in level_idx_set]
+
+    new_idx_names = [idx_names[i] for i in range(nlevels) if i not in level_idx_set]
+    new_col_names = col_names + [idx_names[i] for i in level_idxes]
+
+    data = data.reset_index(names=level_cols)
+    pivoted = data.pivot(
+        index=pivot_idx_col, columns=pivot_col_col, values=pivot_val_col
+    )
+    pivoted.op.fill_value = fill_value
+    return pivoted.mf.apply_chunk(
+        _adjust_names,
+        col_names=new_col_names,
+        idx_names=new_idx_names,
+        remove_col_level=df_or_series.ndim == 1,
+        skip_infer=True,
+        output_type="dataframe",
+    )

maxframe/dataframe/sort/__init__.py

@@ -12,23 +12,38 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from .rank import DataFrameRank
 from .sort_index import DataFrameSortIndex
 from .sort_values import DataFrameSortValues
 
 
 def _install():
-    from ..core import DATAFRAME_TYPE, SERIES_TYPE
+    from ..core import DATAFRAME_TYPE, INDEX_TYPE, SERIES_TYPE
+    from .argsort import index_argsort, series_argsort
+    from .nlargest import df_nlargest, series_nlargest
+    from .nsmallest import df_nsmallest, series_nsmallest
+    from .rank import rank
     from .sort_index import sort_index
     from .sort_values import dataframe_sort_values, series_sort_values
 
     for cls in DATAFRAME_TYPE:
+        setattr(cls, "nlargest", df_nlargest)
+        setattr(cls, "nsmallest", df_nsmallest)
+        setattr(cls, "rank", rank)
         setattr(cls, "sort_values", dataframe_sort_values)
         setattr(cls, "sort_index", sort_index)
 
     for cls in SERIES_TYPE:
+        setattr(cls, "argsort", series_argsort)
+        setattr(cls, "nlargest", series_nlargest)
+        setattr(cls, "nsmallest", series_nsmallest)
+        setattr(cls, "rank", rank)
         setattr(cls, "sort_values", series_sort_values)
         setattr(cls, "sort_index", sort_index)
 
+    for cls in INDEX_TYPE:
+        setattr(cls, "argsort", index_argsort)
+
 
 _install()
 del _install