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

maxframe/dataframe/misc/value_counts.py

@@ -22,9 +22,10 @@ from ...core import EntityData, OutputType
 from ...serialization.serializables import BoolField, Int64Field, KeyField, StringField
 from ...utils import pd_release_version
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
-from ..utils import build_series, parse_index
+from ..utils import build_df, build_series, parse_index
 
 _keep_original_order = pd_release_version >= (1, 3, 0)
+_name_count_or_proportion = pd_release_version >= (2, 0, 0)
 
 
 class DataFrameValueCounts(DataFrameOperator, DataFrameOperatorMixin):
@@ -50,7 +51,16 @@ class DataFrameValueCounts(DataFrameOperator, DataFrameOperatorMixin):
         op.input = op._inputs[0]
 
     def __call__(self, inp):
-        test_series = build_series(inp).value_counts(normalize=self.normalize)
+        if inp.ndim == 2:
+            idx = pd.MultiIndex.from_frame(build_df(inp))
+            test_series = build_series(index=idx, dtype=int)
+            if _name_count_or_proportion:
+                out_name = "proportion" if self.normalize else "count"
+            else:
+                out_name = None
+        else:
+            test_series = build_series(inp).value_counts(normalize=self.normalize)
+            out_name = test_series.name
         if self.bins is not None:
             from .cut import cut
 
@@ -66,7 +76,7 @@ class DataFrameValueCounts(DataFrameOperator, DataFrameOperatorMixin):
                 [inp],
                 shape=(np.nan,),
                 index_value=parse_index(pd.CategoricalIndex([]), inp, store_data=False),
-                name=inp.name,
+                name=out_name,
                 dtype=test_series.dtype,
             )
         else:
@@ -74,7 +84,7 @@ class DataFrameValueCounts(DataFrameOperator, DataFrameOperatorMixin):
                 [inp],
                 shape=(np.nan,),
                 index_value=parse_index(test_series.index, store_data=False),
-                name=inp.name,
+                name=out_name,
                 dtype=test_series.dtype,
             )
 
@@ -170,3 +180,27 @@ def value_counts(
         method=method,
     )
     return op(series)
+
+
+def df_value_counts(
+    df,
+    subset=None,
+    normalize=False,
+    sort=True,
+    ascending=False,
+    dropna=True,
+    method="auto",
+):
+    if not subset:
+        df_to_count = df
+    else:
+        df_to_count = df[subset]
+
+    op = DataFrameValueCounts(
+        normalize=normalize,
+        sort=sort,
+        ascending=ascending,
+        dropna=dropna,
+        method=method,
+    )
+    return op(df_to_count)

maxframe/dataframe/missing/checkna.py

@@ -22,6 +22,7 @@ from ... import tensor as mt
 from ...core import ENTITY_TYPE, OutputType
 from ...serialization.serializables import BoolField
 from ...tensor.core import TENSOR_TYPE
+from ...utils import get_pd_option
 from ..core import DATAFRAME_TYPE, INDEX_TYPE, SERIES_TYPE, MultiIndex
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
 
@@ -30,6 +31,7 @@ class DataFrameCheckNA(DataFrameOperator, DataFrameOperatorMixin):
     _op_type_ = opcodes.CHECK_NA
 
     positive = BoolField("positive", default=None)
+    use_inf_as_na = BoolField("use_inf_as_na", default=None)
 
     def __call__(self, df):
         if isinstance(df, DATAFRAME_TYPE):
@@ -45,11 +47,15 @@ class DataFrameCheckNA(DataFrameOperator, DataFrameOperatorMixin):
                 f"Expecting maxframe dataframe, series, index, or tensor, got {type(df)}"
             )
 
-        params = df.params.copy()
+        params = df.params
         if self.output_types[0] == OutputType.dataframe:
-            params["dtypes"] = pd.Series(
-                [np.dtype("bool")] * len(df.dtypes), index=df.columns_value.to_pandas()
-            )
+            if df.dtypes is None:
+                params["dtypes"] = None
+            else:
+                params["dtypes"] = pd.Series(
+                    [np.dtype("bool")] * len(df.dtypes),
+                    index=df.columns_value.to_pandas(),
+                )
         else:
             params["dtype"] = np.dtype("bool")
         return self.new_tileable([df], **params)
@@ -133,13 +139,14 @@ def isna(obj):
     2     True
     dtype: bool
     """
+    use_inf_as_na = get_pd_option("mode.use_inf_as_na", False)
     if isinstance(obj, MultiIndex):
         raise NotImplementedError("isna is not defined for MultiIndex")
     elif isinstance(obj, ENTITY_TYPE):
         if isinstance(obj, TENSOR_TYPE):
             return mt.isnan(obj)
         else:
-            op = DataFrameCheckNA(positive=True)
+            op = DataFrameCheckNA(positive=True, use_inf_as_na=use_inf_as_na)
             return op(obj)
     else:
         return _from_pandas(pd.isna(obj))
@@ -207,13 +214,14 @@ def notna(obj):
     2    False
     dtype: bool
     """
+    use_inf_as_na = get_pd_option("mode.use_inf_as_na", False)
     if isinstance(obj, MultiIndex):
         raise NotImplementedError("isna is not defined for MultiIndex")
     elif isinstance(obj, ENTITY_TYPE):
         if isinstance(obj, TENSOR_TYPE):
             return ~mt.isnan(obj)
         else:
-            op = DataFrameCheckNA(positive=False)
+            op = DataFrameCheckNA(positive=False, use_inf_as_na=use_inf_as_na)
             return op(obj)
     else:
         return _from_pandas(pd.notna(obj))

maxframe/dataframe/missing/dropna.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import numpy as np
+import pandas as pd
 
 from ... import opcodes
 from ...core import OutputType
@@ -40,6 +41,8 @@ class DataFrameDropNA(DataFrameOperator, DataFrameOperatorMixin):
     # if True, drop index
     ignore_index = BoolField("ignore_index", default=False)
 
+    use_inf_as_na = BoolField("use_inf_as_na", default=None)
+
     def __init__(self, sparse=None, output_types=None, **kw):
         super().__init__(_output_types=output_types, sparse=sparse, **kw)
 
@@ -155,6 +158,7 @@ def df_dropna(
     1  Batman  Batmobile 1940-04-25
     """
     axis = validate_axis(axis, df)
+    use_inf_as_na = pd.get_option("mode.use_inf_as_na")
     if axis != 0:
         raise NotImplementedError("Does not support dropna on DataFrame when axis=1")
     if (
@@ -174,6 +178,7 @@ def df_dropna(
         thresh=thresh,
         subset=subset,
         ignore_index=ignore_index,
+        use_inf_as_na=use_inf_as_na,
         output_types=[OutputType.dataframe],
     )
     out_df = op(df)

maxframe/dataframe/missing/fillna.py

@@ -26,7 +26,7 @@ from ..utils import validate_axis
 
 class DataFrameFillNA(DataFrameOperator, DataFrameOperatorMixin):
     _op_type_ = opcodes.FILL_NA
-    _legacy_name = "FillNA"
+    _legacy_name = "FillNA"  # since v2.0.0
 
     value = AnyField(
         "value", on_serialize=lambda x: x.data if isinstance(x, Entity) else x

maxframe/dataframe/missing/replace.py

@@ -15,8 +15,8 @@
 from typing import List
 
 from ... import opcodes
-from ...core import EntityData
-from ...serialization.serializables import AnyField, Int32Field
+from ...core import ENTITY_TYPE, EntityData
+from ...serialization.serializables import AnyField, FieldTypes, Int32Field, ListField
 from ...utils import no_default
 from ..operators import SERIES_TYPE, DataFrameOperator, DataFrameOperatorMixin
 from ..utils import build_df, build_series
@@ -31,15 +31,18 @@ class DataFrameReplace(DataFrameOperator, DataFrameOperatorMixin):
     regex = AnyField("regex", default=None)
     method = AnyField("method", default=no_default)
 
+    fill_chunks = ListField("fill_chunks", FieldTypes.key, default=None)
+
     @classmethod
     def _set_inputs(cls, op: "DataFrameReplace", inputs: List[EntityData]):
         super()._set_inputs(op, inputs)
         input_iter = iter(inputs)
         next(input_iter)
-        if isinstance(op.to_replace, SERIES_TYPE):
+        if isinstance(op.to_replace, ENTITY_TYPE):
             op.to_replace = next(input_iter)
-        if isinstance(op.value, SERIES_TYPE):
+        if isinstance(op.value, ENTITY_TYPE):
             op.value = next(input_iter)
+        op.fill_chunks = list(input_iter)
 
     def __call__(self, df_or_series):
         inputs = [df_or_series]

maxframe/dataframe/reduction/__init__.py

@@ -15,18 +15,23 @@
 from .aggregation import DataFrameAggregate
 from .all import DataFrameAll
 from .any import DataFrameAny
-from .core import CustomReduction
+from .argmax import DataFrameArgMax
+from .argmin import DataFrameArgMin
+from .core import CustomReduction, NamedAgg
 from .count import DataFrameCount
 from .cummax import DataFrameCummax
 from .cummin import DataFrameCummin
 from .cumprod import DataFrameCumprod
 from .cumsum import DataFrameCumsum
 from .custom_reduction import DataFrameCustomReduction
+from .idxmax import DataFrameIdxMax
+from .idxmin import DataFrameIdxMin
 from .kurtosis import DataFrameKurtosis
 from .max import DataFrameMax
 from .mean import DataFrameMean
 from .median import DataFrameMedian
 from .min import DataFrameMin
+from .mode import DataFrameMode
 from .nunique import DataFrameNunique
 from .prod import DataFrameProd
 from .reduction_size import DataFrameSize
@@ -43,16 +48,22 @@ def _install():
     from .aggregation import aggregate
     from .all import all_dataframe, all_index, all_series
     from .any import any_dataframe, any_index, any_series
+    from .argmax import argmax_series_index
+    from .argmin import argmin_series_index
     from .count import count_dataframe, count_series
+    from .cov import cov_dataframe, cov_series
     from .cummax import cummax
     from .cummin import cummin
     from .cumprod import cumprod
     from .cumsum import cumsum
+    from .idxmax import idxmax_dataframe, idxmax_series
+    from .idxmin import idxmin_dataframe, idxmin_series
     from .kurtosis import kurt_dataframe, kurt_series
     from .max import max_dataframe, max_index, max_series
     from .mean import mean_dataframe, mean_series
     from .median import median_dataframe, median_series
     from .min import min_dataframe, min_index, min_series
+    from .mode import mode_dataframe, mode_series
     from .nunique import nunique_dataframe, nunique_series
     from .prod import prod_dataframe, prod_series
     from .reduction_size import size_dataframe, size_series
@@ -63,31 +74,37 @@ def _install():
     from .var import var_dataframe, var_series
 
     funcs = [
-        ("sum", sum_series, sum_dataframe),
-        ("prod", prod_series, prod_dataframe),
-        ("product", prod_series, prod_dataframe),
-        ("max", max_series, max_dataframe),
-        ("min", min_series, min_dataframe),
-        ("count", count_series, count_dataframe),
-        ("mean", mean_series, mean_dataframe),
-        ("median", median_series, median_dataframe),
-        ("var", var_series, var_dataframe),
-        ("std", std_series, std_dataframe),
+        ("agg", aggregate, aggregate),
+        ("aggregate", aggregate, aggregate),
         ("all", all_series, all_dataframe),
         ("any", any_series, any_dataframe),
+        ("argmax", argmax_series_index, None),
+        ("argmin", argmin_series_index, None),
+        ("count", count_series, count_dataframe),
+        ("cov", cov_series, cov_dataframe),
         ("cummax", cummax, cummax),
         ("cummin", cummin, cummin),
         ("cumprod", cumprod, cumprod),
         ("cumsum", cumsum, cumsum),
-        ("agg", aggregate, aggregate),
-        ("aggregate", aggregate, aggregate),
+        ("idxmax", idxmax_series, idxmax_dataframe),
+        ("idxmin", idxmin_series, idxmin_dataframe),
+        ("kurt", kurt_series, kurt_dataframe),
+        ("kurtosis", kurt_series, kurt_dataframe),
+        ("max", max_series, max_dataframe),
+        ("mean", mean_series, mean_dataframe),
+        ("median", median_series, median_dataframe),
+        ("min", min_series, min_dataframe),
+        ("mode", mode_series, mode_dataframe),
         ("nunique", nunique_series, nunique_dataframe),
+        ("prod", prod_series, prod_dataframe),
+        ("product", prod_series, prod_dataframe),
         ("sem", sem_series, sem_dataframe),
         ("skew", skew_series, skew_dataframe),
-        ("kurt", kurt_series, kurt_dataframe),
-        ("kurtosis", kurt_series, kurt_dataframe),
+        ("std", std_series, std_dataframe),
+        ("sum", sum_series, sum_dataframe),
         ("unique", unique, None),
-        ("_reduction_size", size_dataframe, size_series),
+        ("var", var_series, var_dataframe),
+        ("_reduction_size", size_series, size_dataframe),
     ]
     for func_name, series_func, df_func in funcs:
         if df_func is not None:  # pragma: no branch
@@ -104,6 +121,8 @@ def _install():
         setattr(t, "any", any_index)
         setattr(t, "min", min_index)
         setattr(t, "max", max_index)
+        setattr(t, "argmin", argmin_series_index)
+        setattr(t, "argmax", argmax_series_index)
 
 
 _install()

maxframe/dataframe/reduction/aggregation.py

@@ -29,9 +29,16 @@ from ... import tensor as maxframe_tensor
 from ...core import ENTITY_TYPE, OutputType, enter_mode
 from ...io.odpsio.schema import pandas_dtype_to_arrow_type
 from ...lib.dtypes_extension import ArrowDtype
-from ...serialization.serializables import AnyField, BoolField, DictField, ListField
+from ...serialization.serializables import (
+    AnyField,
+    BoolField,
+    DictField,
+    Int32Field,
+    ListField,
+)
 from ...typing_ import TileableType
-from ...utils import lazy_import, pd_release_version
+from ...udf import BuiltinFunction
+from ...utils import get_pd_option, lazy_import, pd_release_version
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
 from ..utils import build_df, build_empty_df, build_series, parse_index, validate_axis
 from .core import (
@@ -85,16 +92,25 @@ class DataFrameAggregate(DataFrameOperator, DataFrameOperatorMixin):
     _op_type_ = opcodes.AGGREGATE
 
     raw_func = AnyField("raw_func")
-    raw_func_kw = DictField("raw_func_kw")
-    func = AnyField("func")
+    raw_func_kw = DictField("raw_func_kw", default=None)
+    func = AnyField("func", default=None)
     func_rename = ListField("func_rename", default=None)
     axis = AnyField("axis", default=0)
-    numeric_only = BoolField("numeric_only")
-    bool_only = BoolField("bool_only")
-
-    pre_funcs: List[ReductionPreStep] = ListField("pre_funcs")
-    agg_funcs: List[ReductionAggStep] = ListField("agg_funcs")
-    post_funcs: List[ReductionPostStep] = ListField("post_funcs")
+    numeric_only = BoolField("numeric_only", default=None)
+    bool_only = BoolField("bool_only", default=None)
+
+    pre_funcs: List[ReductionPreStep] = ListField("pre_funcs", default=None)
+    agg_funcs: List[ReductionAggStep] = ListField("agg_funcs", default=None)
+    post_funcs: List[ReductionPostStep] = ListField("post_funcs", default=None)
+    combine_size = Int32Field("combine_size", default=None)
+    use_inf_as_na = BoolField("use_inf_as_na", default=False)
+
+    def has_custom_code(self) -> bool:
+        return any(
+            fun.custom_reduction
+            and not isinstance(fun.custom_reduction, BuiltinFunction)
+            for fun in self.agg_funcs or ()
+        )
 
     @staticmethod
     def _filter_dtypes(op: "DataFrameAggregate", dtypes):
@@ -183,7 +199,7 @@ class DataFrameAggregate(DataFrameOperator, DataFrameOperatorMixin):
         normalize_reduction_funcs(self, ndim=df.ndim)
         compile_reduction_funcs(self, df)
         if output_type is None or dtypes is None:
-            with enter_mode(kernel=False, build=False):
+            with enter_mode(kernel=False, build=False, mock=True):
                 dtypes, index = self._calc_result_shape(df)
         else:
             self.output_types = [output_type]
@@ -215,7 +231,7 @@ class DataFrameAggregate(DataFrameOperator, DataFrameOperatorMixin):
             return self.new_series(
                 [df],
                 shape=new_shape,
-                dtype=dtypes[0],
+                dtype=dtypes.iloc[0],
                 name=dtypes.index[0],
                 index_value=new_index,
             )
@@ -237,7 +253,11 @@ def is_funcs_aggregate(func, func_kw=None, ndim=2):
         elif isinstance(func, dict):
             if ndim == 2:
                 for f in func.values():
-                    if isinstance(f, Iterable) and not isinstance(f, str):
+                    if (
+                        isinstance(f, Iterable)
+                        and not isinstance(f, ENTITY_TYPE)
+                        and not isinstance(f, str)
+                    ):
                         to_check.extend(f)
                     else:
                         to_check.append(f)
@@ -293,7 +313,11 @@ def normalize_reduction_funcs(op, ndim=None):
             else:
                 op.func = list(raw_func.values())
                 op.func_rename = list(raw_func.keys())
-        elif isinstance(raw_func, Iterable) and not isinstance(raw_func, str):
+        elif (
+            isinstance(raw_func, Iterable)
+            and not isinstance(raw_func, ENTITY_TYPE)
+            and not isinstance(raw_func, str)
+        ):
             op.func = list(raw_func)
         else:
             op.func = [raw_func]
@@ -432,6 +456,7 @@ def aggregate(df, func=None, axis=0, **kw):
     min    1
     """
     axis = validate_axis(axis, df)
+    use_inf_as_na = kw.pop("_use_inf_as_na", get_pd_option("mode.use_inf_as_na", False))
     if func == "unique":
         # workaround for direct call of unique function which
         #  returns a tensor directly
@@ -456,6 +481,8 @@ def aggregate(df, func=None, axis=0, **kw):
     dtypes = kw.pop("_dtypes", None)
     index = kw.pop("_index", None)
 
+    combine_size = kw.pop("_combine_size", None) or kw.pop("combine_size", None)
+
     if not is_funcs_aggregate(func, func_kw=kw, ndim=df.ndim):
         return df.transform(func, axis=axis, _call_agg=True)
 
@@ -465,6 +492,8 @@ def aggregate(df, func=None, axis=0, **kw):
         axis=axis,
         numeric_only=numeric_only,
         bool_only=bool_only,
+        combine_size=combine_size,
+        use_inf_as_na=use_inf_as_na,
     )
 
     return op(df, output_type=output_type, dtypes=dtypes, index=index)

maxframe/dataframe/reduction/all.py

@@ -16,10 +16,10 @@ import numpy as np
 
 from ... import opcodes
 from ...core import OutputType
-from .core import DATAFRAME_TYPE, DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DATAFRAME_TYPE, DataFrameReduction, DataFrameReductionMixin
 
 
-class DataFrameAll(DataFrameReductionOperator, DataFrameReductionMixin):
+class DataFrameAll(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.ALL
     _func_name = "all"
 

maxframe/dataframe/reduction/any.py

@@ -16,10 +16,10 @@ import numpy as np
 
 from ... import opcodes
 from ...core import OutputType
-from .core import DATAFRAME_TYPE, DataFrameReductionMixin, DataFrameReductionOperator
+from .core import DATAFRAME_TYPE, DataFrameReduction, DataFrameReductionMixin
 
 
-class DataFrameAny(DataFrameReductionOperator, DataFrameReductionMixin):
+class DataFrameAny(DataFrameReduction, DataFrameReductionMixin):
     _op_type_ = opcodes.ANY
     _func_name = "any"
 

maxframe/dataframe/reduction/argmax.py

@@ -0,0 +1,103 @@
+# 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 DataFrameArgMax(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.ARGMAX
+    _func_name = "argmax"
+
+    @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 argmax_series_index(series_or_index, axis=0, skipna=True, *args, **kwargs):
+    """
+    Return int position of the smallest value in the Series.
+
+    If the maximum is achieved in multiple locations,
+    the first row position is returned.
+
+    Parameters
+    ----------
+    axis : {None}
+        Unused. Parameter needed for compatibility with DataFrame.
+    skipna : bool, default True
+        Exclude NA/null values when showing the result.
+    *args, **kwargs
+        Additional arguments and keywords for compatibility with NumPy.
+
+    Returns
+    -------
+    int
+        Row position of the maximum value.
+
+    See Also
+    --------
+    Series.argmin : Return position of the minimum value.
+    Series.argmax : Return position of the maximum value.
+    maxframe.tensor.argmax : Equivalent method for tensors.
+    Series.idxmax : Return index label of the maximum values.
+    Series.idxmin : Return index label of the minimum values.
+
+    Examples
+    --------
+    Consider dataset containing cereal calories
+
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series({'Corn Flakes': 100.0, 'Almond Delight': 110.0,
+    ...                'Cinnamon Toast Crunch': 120.0, 'Cocoa Puff': 110.0})
+    >>> s.execute()
+    Corn Flakes              100.0
+    Almond Delight           110.0
+    Cinnamon Toast Crunch    120.0
+    Cocoa Puff               110.0
+    dtype: float64
+
+    >>> s.argmax().execute()
+    2
+    >>> s.argmin().execute()
+    0
+
+    The maximum cereal calories is the third element and
+    the minimum cereal calories is the first element,
+    since series is zero-indexed.
+    """
+    # args not implemented, just ignore
+    _ = args, kwargs
+
+    validate_axis(axis, series_or_index)
+    op = DataFrameArgMax(
+        dropna=skipna,
+        output_types=[OutputType.scalar],
+    )
+    return op(series_or_index)

maxframe/dataframe/reduction/argmin.py

@@ -0,0 +1,103 @@
+# 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 DataFrameArgMin(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.ARGMIN
+    _func_name = "argmin"
+
+    @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 argmin_series_index(series_or_index, axis=0, skipna=True, *args, **kwargs):
+    """
+    Return int position of the smallest value in the Series.
+
+    If the minimum is achieved in multiple locations,
+    the first row position is returned.
+
+    Parameters
+    ----------
+    axis : {None}
+        Unused. Parameter needed for compatibility with DataFrame.
+    skipna : bool, default True
+        Exclude NA/null values when showing the result.
+    *args, **kwargs
+        Additional arguments and keywords for compatibility with NumPy.
+
+    Returns
+    -------
+    int
+        Row position of the minimum value.
+
+    See Also
+    --------
+    Series.argmin : Return position of the minimum value.
+    Series.argmax : Return position of the maximum value.
+    maxframe.tensor.argmin : Equivalent method for tensors.
+    Series.idxmax : Return index label of the maximum values.
+    Series.idxmin : Return index label of the minimum values.
+
+    Examples
+    --------
+    Consider dataset containing cereal calories
+
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series({'Corn Flakes': 100.0, 'Almond Delight': 110.0,
+    ...                'Cinnamon Toast Crunch': 120.0, 'Cocoa Puff': 110.0})
+    >>> s.execute()
+    Corn Flakes              100.0
+    Almond Delight           110.0
+    Cinnamon Toast Crunch    120.0
+    Cocoa Puff               110.0
+    dtype: float64
+
+    >>> s.argmax().execute()
+    2
+    >>> s.argmin().execute()
+    0
+
+    The maximum cereal calories is the third element and
+    the minimum cereal calories is the first element,
+    since series is zero-indexed.
+    """
+    # args not implemented, just ignore
+    _ = args, kwargs
+
+    validate_axis(axis, series_or_index)
+    op = DataFrameArgMin(
+        dropna=skipna,
+        output_types=[OutputType.scalar],
+    )
+    return op(series_or_index)