maxframe 2.0.0b2__cp311-cp311-win_amd64.whl → 2.2.0__cp311-cp311-win_amd64.whl

maxframe/dataframe/reduction/idxmin.py

@@ -0,0 +1,185 @@
+# 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 ... import opcodes
+from ...core import OutputType
+from ..utils import validate_axis
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
+
+
+class DataFrameIdxMin(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.IDXMIN
+    _func_name = "idxmin"
+
+    @property
+    def is_atomic(self):
+        return True
+
+    def get_reduction_args(self, axis=None):
+        args = dict(skipna=self.skipna)
+        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(skipna=op.skipna)
+        kw = {k: v for k, v in kw.items() if v is not None}
+        return ReductionCallable(func_name=func_name, kwargs=kw)
+
+
+def idxmin_dataframe(df, axis=0, skipna=True):
+    """
+    Return index of first occurrence of minimum over requested axis.
+
+    NA/null values are excluded.
+
+    Parameters
+    ----------
+    axis : {0 or 'index', 1 or 'columns'}, default 0
+        The axis to use. 0 or 'index' for row-wise, 1 or 'columns' for column-wise.
+    skipna : bool, default True
+        Exclude NA/null values. If an entire row/column is NA, the result
+        will be NA.
+
+    Returns
+    -------
+    Series
+        Indexes of minima along the specified axis.
+
+    Raises
+    ------
+    ValueError
+        * If the row/column is empty
+
+    See Also
+    --------
+    Series.idxmin : Return index of the minimum element.
+
+    Notes
+    -----
+    This method is the DataFrame version of ``ndarray.argmin``.
+
+    Examples
+    --------
+    Consider a dataset containing food consumption in Argentina.
+
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'consumption': [10.51, 103.11, 55.48],
+    ...                    'co2_emissions': [37.2, 19.66, 1712]},
+    ...                    index=['Pork', 'Wheat Products', 'Beef'])
+
+    >>> df.execute()
+                    consumption  co2_emissions
+    Pork                  10.51         37.20
+    Wheat Products       103.11         19.66
+    Beef                  55.48       1712.00
+
+    By default, it returns the index for the minimum value in each column.
+
+    >>> df.idxmin().execute()
+    consumption                Pork
+    co2_emissions    Wheat Products
+    dtype: object
+
+    To return the index for the minimum value in each row, use ``axis="columns"``.
+
+    >>> df.idxmin(axis="columns").execute()
+    Pork                consumption
+    Wheat Products    co2_emissions
+    Beef                consumption
+    dtype: object
+    """
+    axis = validate_axis(axis, df)
+    op = DataFrameIdxMin(
+        axis=axis,
+        skipna=skipna,
+        output_types=[OutputType.series],
+    )
+    return op(df)
+
+
+def idxmin_series(series, axis=0, skipna=True):
+    """
+    Return the row label of the minimum value.
+
+    If multiple values equal the minimum, the first row label with that
+    value is returned.
+
+    Parameters
+    ----------
+    axis : int, default 0
+        For compatibility with DataFrame.idxmin. Redundant for application
+        on Series.
+    skipna : bool, default True
+        Exclude NA/null values. If the entire Series is NA, the result
+        will be NA.
+    *args, **kwargs
+        Additional arguments and keywords have no effect but might be
+        accepted for compatibility with NumPy.
+
+    Returns
+    -------
+    Index
+        Label of the minimum value.
+
+    Raises
+    ------
+    ValueError
+        If the Series is empty.
+
+    See Also
+    --------
+    numpy.argmin : Return indices of the minimum values
+        along the given axis.
+    DataFrame.idxmin : Return index of first occurrence of minimum
+        over requested axis.
+    Series.idxmin : Return index *label* of the first occurrence
+        of minimum of values.
+
+    Notes
+    -----
+    This method is the Series version of ``ndarray.argmin``. This method
+    returns the label of the minimum, while ``ndarray.argmin`` returns
+    the position. To get the position, use ``series.values.argmin()``.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series(data=[1, None, 4, 3, 4],
+    ...               index=['A', 'B', 'C', 'D', 'E'])
+    >>> s.execute()
+    A    1.0
+    B    NaN
+    C    4.0
+    D    3.0
+    E    4.0
+    dtype: float64
+
+    >>> s.idxmin().execute()
+    'C'
+
+    If `skipna` is False and there is an NA value in the data,
+    the function returns ``nan``.
+
+    >>> s.idxmin(skipna=False).execute()
+    nan
+    """
+    validate_axis(axis, series)
+    op = DataFrameIdxMin(
+        dropna=skipna,
+        output_types=[OutputType.scalar],
+    )
+    return op(series)

maxframe/dataframe/reduction/kurtosis.py

@@ -17,10 +17,42 @@ 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 DataFrameKurtosis(DataFrameReductionOperator, DataFrameReductionMixin):
+class KurtosisReductionCallable(ReductionCallable):
+    def __call__(self, value):
+        from .aggregation import where_function
+
+        skipna = self.kwargs["skipna"]
+        bias = self.kwargs["bias"]
+        fisher = self.kwargs["fisher"]
+
+        cnt = value.count()
+        mean = value.mean(skipna=skipna)
+        divided = (
+            (value**4).mean(skipna=skipna)
+            - 4 * (value**3).mean(skipna=skipna) * mean
+            + 6 * (value**2).mean(skipna=skipna) * mean**2
+            - 3 * mean**4
+        )
+        var = value.var(skipna=skipna, ddof=0)
+        if isinstance(var, ENTITY_TYPE) or var > 0:
+            val = where_function(var > 0, divided / var**2, np.nan)
+        else:
+            val = np.nan
+        if not bias:
+            val = where_function(
+                (var > 0) & (cnt > 3),
+                (val * (cnt**2 - 1) - 3 * (cnt - 1) ** 2) / (cnt - 2) / (cnt - 3),
+                np.nan,
+            )
+        if not fisher:
+            val += 3
+        return val
+
+
+class DataFrameKurtosis(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.KURTOSIS
     _func_name = "kurt"
 
@@ -29,35 +61,10 @@ class DataFrameKurtosis(DataFrameReductionOperator, DataFrameReductionMixin):
 
     @classmethod
     def get_reduction_callable(cls, op):
-        from .aggregation import where_function
-
         skipna, bias, fisher = op.skipna, op.bias, op.fisher
-
-        def kurt(x):
-            cnt = x.count()
-            mean = x.mean(skipna=skipna)
-            divided = (
-                (x**4).mean(skipna=skipna)
-                - 4 * (x**3).mean(skipna=skipna) * mean
-                + 6 * (x**2).mean(skipna=skipna) * mean**2
-                - 3 * mean**4
-            )
-            var = x.var(skipna=skipna, ddof=0)
-            if isinstance(var, ENTITY_TYPE) or var > 0:
-                val = where_function(var > 0, divided / var**2, np.nan)
-            else:
-                val = np.nan
-            if not bias:
-                val = where_function(
-                    (var > 0) & (cnt > 3),
-                    (val * (cnt**2 - 1) - 3 * (cnt - 1) ** 2) / (cnt - 2) / (cnt - 3),
-                    np.nan,
-                )
-            if not fisher:
-                val += 3
-            return val
-
-        return kurt
+        return KurtosisReductionCallable(
+            func_name="kurt", kwargs=dict(skipna=skipna, bias=bias, fisher=fisher)
+        )
 
 
 def kurt_series(

maxframe/dataframe/reduction/max.py

@@ -14,10 +14,10 @@
 
 from ... import opcodes
 from ...core import OutputType
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin
 
 
-class DataFrameMax(DataFrameReductionOperator, DataFrameReductionMixin):
+class DataFrameMax(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.MAX
     _func_name = "max"
 

maxframe/dataframe/reduction/mean.py

@@ -14,21 +14,23 @@
 
 from ... import opcodes
 from ...core import OutputType
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
 
 
-class DataFrameMean(DataFrameReductionOperator, DataFrameReductionMixin):
+class MeanReductionCallable(ReductionCallable):
+    def __call__(self, value):
+        skipna = self.kwargs["skipna"]
+        return value.sum(skipna=skipna) / value.count()
+
+
+class DataFrameMean(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.MEAN
     _func_name = "mean"
 
     @classmethod
     def get_reduction_callable(cls, op):
         skipna = op.skipna
-
-        def mean(x):
-            return x.sum(skipna=skipna) / x.count()
-
-        return mean
+        return MeanReductionCallable(func_name="mean", kwargs=dict(skipna=skipna))
 
 
 def mean_series(df, axis=None, skipna=True, level=None, method=None):

maxframe/dataframe/reduction/median.py

@@ -14,10 +14,10 @@
 
 from ... import opcodes
 from ...core import OutputType
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin
 
 
-class DataFrameMedian(DataFrameReductionOperator, DataFrameReductionMixin):
+class DataFrameMedian(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.MEDIAN
     _func_name = "median"
 

maxframe/dataframe/reduction/min.py

@@ -14,10 +14,10 @@
 
 from ... import opcodes
 from ...core import OutputType
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DataFrameReduction, DataFrameReductionMixin
 
 
-class DataFrameMin(DataFrameReductionOperator, DataFrameReductionMixin):
+class DataFrameMin(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.MIN
     _func_name = "min"
 

maxframe/dataframe/reduction/nunique.py

@@ -22,12 +22,12 @@ from ...config import options
 from ...core import OutputType
 from ...serialization.serializables import BoolField
 from ...utils import lazy_import
-from .core import DataFrameReductionMixin, DataFrameReductionOperator
+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"
 
@@ -38,17 +38,18 @@ class DataFrameNunique(DataFrameReductionOperator, DataFrameReductionMixin):
     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):

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):